1. 运算符操作
1、 数值运算
+：加法
-：减法
*：乘法
/: 除法，带小数
//:整除，
%：取余运算
**：幂次运算，2**10=1024
+=、-=、*=、/=、//=、%=、**=：简写运算
2、 关系运算
>, <, >=,<=,==，!=,Frue,false
3、 逻辑运算
and：与运算
or ：或研究
not：非运算
2. 基础数据类型
1、布尔(bool)
只有 True 和 False 两个值，表示真或假。
2、整型(int)
整数值，可正数亦可复数，无小数。 3.x 整型是没有限制大小的，可以当作 Long 类型使用，所以 3.x 没有 2.x 的 Long 类型。
3、浮点型(float)
浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）
4、复数(complex)
复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示，复数的实部 a 和虚部 b 都是浮点型。
5、数字运算
不同类型的数字混合运算时会将整数转换为浮点数
在不同的机器上浮点运算的结果可能会不一样
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //。
// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
在交互模式中，最后被输出的表达式结果被赋值给变量 _，_ 是个只读变量
3. 字符串操作
age = input("输入年龄：")#接受输出字符串给变量
exit("input age error")#输出错误信息并退出程序
age = input("输入年龄：")#接受输出字符串给变量
exit("input age error")#输出错误信息并退出程序
print(str({'name':'Alex'}))#将字典转字符串类型
print(eval("{'name':'Alex'}"))#将字符串转字典类型
print('hello'*2)#输出两个hello
print('hello'[2:])#切片输出llo
print('ll' in 'hello')#判断子串是否在原串中，返回True/False
print('%s:%s' % ('name','Alex'))#格式化字符串，输出name:Alex
print(','.join(['123','456','789']))#输出'123,456,789'
print('+'.join(['123','456','789']))#输出'123+456+789'
print('hello kitty'.count('l'))#统计l字符串出现次数
print('hello kitty'.capitalize())#字符串首字母大写Hello kitty
print('hello kitty'.center(50,'-'))#居中输出，其余用-补充，-------------------hello kitty--------------------
print('This is China'.endswith('ina'))#输出TRUE
print('This is China'.sta rtswith('This'))
#输出TRUE
print('this\tis\tchina'.expandtabs(tabsize=3))
#设定字符串中\t符即tab键的宽度
print('This is C hina'.find('C'))
#输出查找字符所在位置
print('hello {name} {age}'.format(age=100, name='China'))
#按名称对应组装字符串， hello China 100
print('hello {name} {age}'.format_map({'age':100, 'name':'China',}))
#按字典名称对应组装字符串， hello China 100
print('hel loChina100'.isalnum())
#判断字符串是否只有数字和字母、汉字，TRUE和FALSE
print('123'.isdigit())
#判断字符串是否是整形数值
print('China'.islower())
#判断字符串是否全为小写
print('China'.isupper())
#判断字符串是否全为大写
print(' '.isspace())
#判断字符串是否全为空格
print('Hello China'.istitle())
#判断字符串是否全为标题，即只有单词首字母均大写
print('Hello CHina'.lower())
#字符串转小写
print('Hello CHina'.upper())
#字符串转大写
print('Hello CHina'.swapcase())
#将字符串中大小写子母翻转：hELLO chINA
print('Hello CHina'.ljust(50,'*'))
#输出Hello CHina***************************************
print('Hello CHina'.rjust(50,'*'))#输出***************************************Hello CHina
print(' Hello CHina\n'.strip())
#去掉字符串首尾空格和换行符
print('Hello CHina'.replace('H','h',1))
#字符串替换1次
print('This is China'.split(' '))
#字符串分割['This', 'is', 'China']
print('This is China'.title())
#字符串转title：This Is China
+法：加几个字符串就需要开几个内存，效率低
占位符，只开一个内存进行字符串拼接，效率高
占位符：
%s:string
%f:float
%d:digit
4. 列表list操作
1、查找
names = ['Tom', 'Alex', 'Jonh', 'Mark']
print(names[2])#输出Jonh
print(names[1:3])#切片后输出['Alex', 'Jonh'],不包括3
print(names[1:])#切片后输出从下标1到最后的元素，['Alex', 'Jonh', 'Mark']
print(names[1:-1])#切片后输出从下标1到倒数第二个的元素，['Alex', 'Jonh']
print(names[1::-2])#切片后输出从下标1到最后的元素，步长为2，['Alex', 'Mark']
2、添加
names = ['Tom', 'Alex', 'Jonh', 'Mark']
names.append('Lucy')#在列表最后添加Lucy
names.insert(2,"Lucy")
#在下标2插入Lucy，其他后延
['Tom', 'Alex', 'Lucy', 'Jonh', 'Mark']
3、 修改
names = ['Tom', 'Alex', 'Jonh', 'Mark']
names[2] = 'Lucy'
names[1:3] = ["Lucy", "Max"]#一次修改多个元素值['Tom', 'Lucy', 'Max', 'Mark']
4、删除remove pop del
names = ['Tom', 'Alex', 'Jonh', 'Mark']
names.remove('Jonh')#删除Jonh,输出['Tom', 'Alex', 'Mark']
names.pop(3)#删除下标3的元素，同时返回该下标的元素：若不加下标，默认删除最后一个元素
del names[3]#删除下标为3的元素
del names#删除列表
names.clear()#清空列表
5、count计数
names = ['Tom', 'Alex', 'Jonh', 'Alex', 'Mark']
print(names.count('Alex'))#统计names中出现Alex元素2次
6、元素扩展extend
a = [1,2,3]
b = [4,5,6]
a.extend(b)#将b列表元素拷贝到a列表中
print(a,b)#输出[1,2,3,4,5,6] [4,5,6]
c = a + b#加法将ab的元素拷贝到c新列表中，修改c列表，不影响ab列表
print(a,b,c)#输出[1,2,3] [4,5,6] [1,2,3,4,5,6]
7、元素索引index
names = ['Tom', 'Alex', 'Jonh', 'Mark']
names.index("Alex")#查找元素Alex的下标1，若出现多次则只返回第一次出现位置
8、逆序reverse
names = ['Tom', 'Alex', 'Jonh', 'Mark']
names.reverse()
print(names)#将names元素反序['Mark', 'Jonh', 'Alex', 'Tom']
names.sort()
#默认按ASCII码值升序排列
print(names)#['Alex', 'Jonh', 'Mark', 'Tom']
names.sort(reverse=True)#降序排列['Tom', 'Mark', 'Jonh', 'Alex']
5. 元组tumple操作
元组称为不可变列表，因为不可变，所以方法较少
names = ('Tom', 'Alex', 'Jonh', 'Mark')
print(names[2])
#输出Jonh
print(names[2:4])#输出('Jonh', 'Mark')
6. 字典dict操作
1、增
user = {'name':'Tom', 'age':'18',}
user.setdefault('age',20)
print(user)
#user存在age则不修改值，setdefault会返回对应值，否则增加age字段，输出{'name': 'Tom', 'age': 20}
2、查
user = {'name':'Tom', 'age':'18',}
print(user['name'])
print(user.get('age'))#获取age值，若没有age则返回None
print(user.get('sex','male'))#获取sex值，若没有sex字段则返回male
print(user.keys())#输出所有的keys，注意类型dict_keys(['name', 'age'])
，可以转list类型
print(list(user.keys()))#输出列表keys，['name', 'age']
print(user.values())#输出所有的value，注意类型dict_values(['Tom', '18'])
，可以转list类型
print(list(user.values()))#输出列表value，['Tom', '18']
print(names.items())
#输出所有的键值对dict_items([('name', 'Tom'), ('age', '18')])
3、改
user = {'name':'Tom', 'age':'18',}
work = {'age':20, 'home':'beijing'}
user.update(work)
#user中有work的健则用其覆盖user的健，没有的则增加健，输出{'name': 'Tom', 'age': 20, 'home': 'beijing'}
4、删
user = {'name':'Tom', 'age':'18',}
del user['name']#删除name键值对，输出{'age':'18'}
user.clear()#清空字典
user.pop('name')#删除user中的name健，并返回其对应的值，user输出{'age':'18'}
del user#删除整个字典
5、其他功能
json.loads(json_str) #json字符串转换成字典
json.dumps(dict) #字典转换成json字符串
user = dict.fromkeys(['name','age'],'test')
print(user)#初始化字典{'name': 'test', 'age': 'test'}
sorted(user.item())#字典按键排序
user = {'name':'Tom', 'age':'18',}
for i in user:
#循环效率高
print(i)
#输出name，age
for k,v in user.items():
#循环效率低
print(k,v)
#输出name Tom
; age 18
7. 集合set操作
【注意】：1、set为可变集合，可以进行增删；frozenset为不可变集合。
2、在数据进行set前，数据中的元素必须是可以hash操作，如果元素是列表或字典进行set会报错
如：set([[1,2],3]),元素[1,2]是列表，不可进行hash操作
3、集合是无序的不能索引，只能遍历或迭代判断处理。
1、字符串集合
setStr = set('hello')
print(setStr)#输出去重字符：{'o', 'l', 'h', 'e'}
2、列表集合
setList = ['Alex','Mark','Alex']
setSet = set(setList)#对setList去重并转为set类型
print(setSet)#{'Alex','Mark'}
setList = list(setSet)#在转回去重后的list数据类型
print(setList)#输出['Alex','Mark']
3、访问集合：in 或 not in
li = [2, 3, 'Alex']
st = set(li)
print(st)
#输出{2, 3, 'Alex'}
print(2 in st)#TRUE
4、添加集合元素
st = set([2, 3, 'Alex'])
st.add('Mark')
print(st)
#输出{2, 3, 'Alex','Mark'}
5、update方法
st = set([2, 3, 'Alex'])
st.update(['Alex',2])
print(st)#输出{2, 3, 'Alex'}
st.update('Mark')
print(st)#{'k', 2, 3, 'Alex', 'a', 'r', 'M'}
6、remove方法
st = set([2, 3, 'Alex'])
st.remove('Alex')
print(st)#{2, 3}
7、pop方法
st = set([2, 3, 'Alex'])
st.pop()
#随机删除集合st中的一个元素
print(st)#{2, 3}
8、clear方法
st = set([2, 3, 'Alex'])
st.clear()
#清空集合
print(st)#set()
9、del方法
st = set([2, 3, 'Alex'])
del st#删除集合st
print(st)#删除后在使用该集合会报异常
10、集合等价
print( set('Alex')==set('Alexlex') )#输出True,因为集合元素都是{'e', 'A', 'x', 'l'}
11、集合父集、子集
st1 = set([1,2,3,4])
#{1, 2, 3, 4}
st2 = set([3,4,5,6])#{3, 4, 5, 6}
print(st1.issubset(st2))
#st1的元素是否完全包于含st2；即st1<st2
print(st1 < st2)
print(st1.issuperset(st2))#st1是否完全包含st2的元素；即st1>st2
print(st1 > st2)
12、集合并集：| 方法与union方法等价
st1 = set([1,2,3,4])
#{1, 2, 3, 4}
st2 = set([3,4,5,6])#{3, 4, 5, 6}
print(st1 | st2)
#输出{1, 2, 3, 4, 5, 6}
print(st1.union(st2))#输出{1, 2, 3, 4, 5, 6}
12、集合交集：& 方法与intersection()方法等价
st1 = set([1,2,3,4])
#{1, 2, 3, 4}
st2 = set([3,4,5,6])#{3, 4, 5, 6}
print(st1 & st2)
#输出{ 3, 4 }
print(st1.intersection(st2))#输出{ 3, 4 }
13、集合差集：- 方法与difference()
st1 = set([1,2,3,4])
#{1, 2, 3, 4}
st2 = set([3,4,5,6])#{3, 4, 5, 6}
print(st1 - st2)
#输出st1独有元素{ 3, 4 }
print(st1.differenc(st2))#输出st1独有元素{ 3, 4 }
14、集合的交集补集：即两个集合独有元素的并集：^ 方法与symmetric_difference()
st1 = set([1,2,3,4])
#{1, 2, 3, 4}
st2 = set([3,4,5,6])#{3, 4, 5, 6}
print(st1 ^ st2)
#输出两个集合独有元素的并集：{1, 2, 5, 6}
print(st1.symmetric_difference(st2))#输出两个集合独有元素的并集：{1, 2, 5, 6}
8. 深浅拷贝
=============== 浅拷贝 ===============
1、浅拷贝只能拷贝数据的第一层数据，一层以上数据是共有属性的，一层以上的可以是列表，字典等类型
如：lists = [[0,1],2]中，lists[0]:第一层；lists[0][0]:第二层
nameList = ['Mark ','Lucy']
copyList = nameList.copy()
#进行浅拷贝，copyList = nameList[:]也是浅拷贝
copyList[1] = 'Alex'
print(nameList)
#['Mark','Lucy']
print(copyList)#['Mark','Alex']
nameList = ['Mark',['Lucy','Tom']]
copyList = nameList.copy()
#浅拷贝，因为nameList[1]中存储的是列表地址，类似指针，修改此空间数据会影响其他浅拷贝变量
copyList[1][1] = 'Alex'
print(nameList)
#['Mark', ['Lucy', 'Alex']]
print(copyList)#['Mark', ['Lucy', 'Alex']]
2、引入拷贝模块
import copy
copy.copy()#该方法也是浅拷贝，nameList.copy()就是使用的该方法
=============== 深拷贝 ===============
1、深拷贝：是两个变量是两个独立的内存，彼此修改均不影响对方
import copy
nameList = ['Mark',['Lucy','Tom']]
copyList = copy.deepcopy(nameList)
#深拷贝，两个存储独立的空间
copyList[1][1] = 'Alex'
print(nameList)
#['Mark', ['Lucy', 'Tom']]
print(copyList)#['Mark', ['Lucy', 'Alex']]
浙公网安备 33010602011771号