1、str常用操作
1）字符串的索引与切片
1 str1 = "python" 2 >>> str1[0] #截取第一个字符 3 'p' 4 >>> str1[0:2] #截取0-1两个字符 5 'py' 6 >>> str1[0:4:2] #截取0-4之间的字符，且步长为2 7 'pt' 8 >>> str1[-1:] #截取最后一个字符 9 'n' 10 >>> str1[::-1] #倒着截取字符串 11 'nohtyp'
2）capitalize、swapcase、title
1 name = "hello World" 2 print(name.capitalize()) #首字母大写 3 print(name.swapcase()) #大小写反转 4 print(name.upper()) #将所有字符都换成大写 5 print(name.lower()) #将所有字符都换成小写 6 print(name.title()) #每个单词首字母大写
3）center
1 name = "hello world"
2 print(name.center(20,"+")) #内容居中，指定左右间隔字符，同时可以指定以什么字符进行填充
3
4
5 输出：
6 ++++hello world+++++
4）count
1 name = "hello world"
2 print(name.count("l")) #统计指定字符出现的次数
3
4
5 输出：
6 3
5）startswith、endswith
1 name = "hello world"
2 print(name.startswith("h")) #是否以某个字符开头
3 print(name.endswith("d")) #是否以某个字符结尾
4
5
6 输出：
7 True
8 True
6）find、index
1 name = "hello world"
2 print(name.find("h")) #返回找到的元素索引，不存在返回-1
3 print(name.index("d")) #返回找到的元素索引，不存在会报错
4
5 输出：
6 0
7 -1
8 10
9 ValueError: substring not found
7）split
1 name = "hello world"
2 print(name.split()) #指定分隔符，将分割的字符串制成列表，默认是以空格分割
3 print(name.split("o"))
4
5 输出：
6 ['hello', 'world']
7 ['hell', ' w', 'rld']
8）format
1 #format的三种玩法 格式化输出
2 res1='{} {} {}'.format('egon',18,'male')
3 res2='{1} {0} {1}'.format('egon',18,'male')
4 res3='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
5 print(res1)
6 print(res2)
7 print(res3)
8
9
10 输出：
11
12 egon 18 male
13 18 egon 18
14 egon 18 male
9）strip
1 name = "***hello world**"
2 print(name.strip("*")) #去除字符串左右的指定字符，默认是去除空格，经常是结合input使用
3 print(name.lstrip("*")) #去除字符串左边的指定字符
4 print(name.rstrip("*")) #去除字符串右边的指定字符
5
6
7 输出：
8 hello world
9 hello world**
10 ***hello world
10）replace
1 name = "hello world"
2 print(name.replace("hello","你好")) #替换字符串
3
4 输出：
5 你好 world
11）is系列
1 name1 = "hello1"
2 name2 = "hello"
3 name3 = "123"
4 print(name1.isalnum()) #字符由字母或数字组成
5 print(name2.isalpha()) #字符串由字母组成
6 print(name3.isdigit()) #字符只由数字组成
7
8 输出：
9 True
10 True
11 True
2、list
1 #切片
2 list1 = [1,2,"hello",3]
3 print (list1[1]) #2
4 print (list1[-1]) #3
5 print (list1[:2]) #[1,2]
6 print (list1[:3:2]) #[1, 'hello']
7
8 #增
9 #append 在最后追加
10 list1.append('葫芦')
11 list1.append([1,2,3])
12 #insert插入
13 list1.insert(1,"world")
14 #迭代添加
15 list1.extend('Tom')
16 list1.extend('[111,222,333]')
17
18 #删
19 #pop 有返回值 按照索引删除
20 print (list1.pop(0))
21 #remove 按照指定字符删除
22 print (list1.remove('hello'))
23 #clear 清空列表
24 print (list1.clear())
25 #del 内存级别删除列表
26 del list1
27 del list1[1] #索引删除
28 del list1[:3] #切片删除
29
30 #改
31 #按照索引修改
32 list1[2] = code
33 print (lit1)
34 #按照切片去修改
35 list1[:2] = 'aaa'
36 print (list1)
37
38 #查
39 #按照索引去查询，按照切片去查询
40 for i in list1:
41 print(i)
42 #通过元素找索引
43 print (list1.index(2))
44 #sort 排序
45 list1.sort() 从小到大排序
46 list1.sort(reverse=True) 从大到小排序
47 #reverse 列表从右往左排序
48 list1.reverse()
49
50 #列表嵌套
51 list2 = [1,2,'abc',['name','age',123],'qq']
52 #将abc全部变成大写，放回原处
53 list2[2] = 'ABC'
54 print (list[2].upper())
55 list2[2] = list[2].upper()
56 #给['name','age',123]追加一个元素‘baidu’
57 list2[-2].append('baidu')
58 #将age首字母大写
59 list2[-2][1] = list2[-2][1].capitalize()
60 #将123通过数字相加，或者字符串相加变成150
61 list2[-2][-1] = str(list2[-2][-1] + 27)
3、dict
1 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
2
3 字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
4 3.6版本之前，字典是无序的，3.6之后字典是有序的。
5 dic = {"name":"Tom","age":18}
6
7 字典的增:
8 dic['li'] = ["a","b","c"] 有则覆盖，无则添加
9 print(dic)
10 # setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
11 dic.setdefault('k','v')
12 print(dic) # dic = {"name":"Tom","age":18,"k":"v"}
13 dic.setdefault('k','v1') # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
14 print(dic)
15
16 字典的删：
17 print (dic.pop('name')) #返回删除key对应的value值
18 print (dic.pop('name1','没有此key'))
19 print(dic)
20 dic.clear() #清空
21 print (dic)
22 print(dic.popitem()) #随机删除，返回值删除的key，测试3.x版本是从后往前进行删除的，并不是随机删除
23
24 字典的改：
25 dic['name'] = 'boy'
26 print (dic)
27 dic = {"name":"Tom","age":18}
28 dic2 = {"name":boy","job":"IT"}
29 dic2.update(dic) #将dic的键值对覆盖添加到dic2中，dic不变
30
31 字典的查：
32 print (dic['name2']) #查找不存在的key会直接报错
33 print (dic.get('name2','此key不存在')) #可以自定义返回值
34
35
36 字典内置方法
37 #keys() values() items()
38 dic = {'name': 'jin', 'age': 18, 'sex': 'male'}
39 list(dic.keys()) #将key生成到一个列表中
40 for i in dic.keys(): #以列表返回一个字典所有的键
41 print (i)
42 for i in dic.values(): #以列表返回字典中的所有值
43 print (i)
44 for k,v in dic.items(): #以列表返回可遍历的(键, 值) 元组数组
45 print (k,v)
46
47 分别赋值
48 a,b = 1,2
49 如何快速将两个变量值互换
50 a =1
51 b = 5
52 a,b = b,a
53
54 fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
55 dic1 = dict.fromkeys('abc',[])
56 dic1['a'].append('Tom')
57 print ('dic1')
4、小数据池，深浅copy
1 #小数据池
2 a = "Tom"
3 b = "Tom"
4 print (a == b) #数值
5 print (a is b) #判断是否为同一个内存地址
6 #python中是有小数据池的概念
7 #int -5~256的相同的数全都指向一个内存地址，节省空间
8 #str s = 'a' * 20以内都是同一个内存地址
9
10 #深浅copy
11 a = [1,2,3]
12 b = a #b和a是共用一个内存地址，改变其中一个值，另外一个也会改变
13 a.append(666)
14 print (a,b) #[1, 2, 3, 666] [1, 2, 3, 666]
15
16
17 #浅copy
18 l1 = [1,2,3]
19 l2 = l1.copy()
20 l1.append(666)
21 print (l1,l2) #[1, 2, 3, 666] [1, 2, 3]
22 print (id(l1),id(l2)) #89582728 89581208
23
24 l1 = [1,2,3,[22,33]]
25 l2 = l1.copy()
26 l1[-1].append(666)
27 print(l1,l2) #[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
28 print(id(l1[-1]),id(l2[-1])) #89583208 89583208
29 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
30
31 #深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变
32 import copy
33 l1 = [1,2,3,[22,33]]
34 l2 = copy.deepcopy(l1)
35 l1[-1].append(666)
36 print(l1,l2)
37 print(id(l1[-1]),id(l2[-1]))
5、数据类型补充
注意：
1、在循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，删除一个数据时，再次循环时数据索引会改变
2、dict 再循环字典时，不要改变字典的大小，删除数据会报错
3、如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致
1 >>> tu1 = (1)
2 >>> type(tu1)
3 <class 'int'>
4 >>> tu2 = (1,)
5 >>> type(tu2)
6 <class 'tuple'>
| 运算符 | 表达式 | 说明 |
| and | a and b | 逻辑与，当a为True时才计算b |
| or | a or b | 逻辑或，当a为False时才计算b |
| not | not a | 逻辑非 |
非零为true，无论正负
1、 and 与 a and b a为true则计算b，否则返回false
2、 or 或 a or b a为false则计算b，否则返回true
3、 not 非 加not取反