一. 元组（tuple）
元组——只读列表，数据能被查询，不能修改。字符串的切片操作同样适用于元组。
一些重要的信息，放在列表中不安全，需要一个容器类的数据类型，创建初衷就是这个原因，比如个人信息，密码等不允许任何人改变。
1 s = ("ada", "jalksdj", "alkjsd") 2 3 # 注意，元组内只有一个值时，必须加个英文符逗号，比如下面也会自动打印出来 4 print(s[-2:-1]) # ('jalksdj',)
1 # 格式化输出 %s 2 3 # 方法一： 4 msg = "我叫%s, 今年%s, 性别%s" % ("太白", "18", "男"） # 这是一个元组 5 print(msg) 6 7 # 方法二： 8 dic = {"name": "太白", "sex": "男", "age": 18} 9 msg = "我叫%(name)s, 今年%(age)s, 性别%(age)s." % dic 10 print(msg)
二. 列表（list）
如果只用字符串来存储数据，会有很多问题，比如：
s = "1 True alex"
首先， 对s1[2:6]取值，很费劲
然后对字符串进行的任何操作，取出来的都是字符串类型，不方便。
再者，字符串有长度限制，只能存储少量的而且是字符串类型的数据。
因此有了列表这个数据类型，列表中可以存放各种数据类型，比如：
s = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表的增删改查操作：
1 # 列表的增 2 3 s = [1,'a','b',2,3,'a'] 4 5 6 # insert —— 按照索引增加 7 s.insert(0, 55) 8 print(s) # [55, 1, 'a', 'b', 2, 3, 'a'] 9 10 11 # append —— 增加到最后 12 s.append("aaa") 13 print(s) # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa'] 14 15 16 # extend —— 迭代的增 17 s.extend(["q, a, w"]) 18 print(s) # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w'] 19 # 注意这里列表内其实只有一个元素 20 # 与下面的对比 21 22 s.extend('a,b,c') 23 print(s) # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c'] 24 # 这里通过迭代把字符串里的 5个元素(包括逗号) 都单独加进去了 25 26 s.extend("") # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c'] 27 s.extend(" ") # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c', " "] 28 # 迭代一个空字符串和一个只含空格的字符串的区别
29
30 # 列表的增中这两种方法结果一样
31 a = [1,2]
32 a[2:] = "as"
33 a.extend("as")
34 # 以上两个都要看字符串里的元素个数，有几个就添加几个进去
35 a[::-1] = "34" # ['4', '3']
36 # 多一个少一个都会报错
37 a[::-1] = "345"
38 a[::-1] = "3"
39 # 这个也会报错
40 a[::-1] = 34
1 # 列表的删 2 3 # pop() —— 默认删除最后一个值 4 # 括号里要是添加索引位置数字，则删除指定的元素，有返回值 5 s = [1, 3, 4, "a", "abc", "12sda"] 6 s1 = s.pop() 7 s2 = s.pop(1) 8 9 print(s1) # 12sda 10 print(s2) # 3 11 print(s) # [1, 4, 'a', 'abc'] 12 13 14 # del —— 按照指定位置删除，也可以切片删除，没有返回值 15 s = [1, 3, 4, "a", "abc", "12sda"] 16 del s[1] # [1, 4, 'a', 'abc', '12sda'] 17 del s[:2] # ['a', 'abc', '12sda'] 18 del s # 删除整个列表，很少用这个 19 20 # remove —— 按照指定元素删除 21 s = [1, 3, 4, "a", "abc", "12sda"] 22 s.remove("a") 23 print(s) # [1, 3, 4, 'abc', '12sda'] 24 25 26 # clear() —— 直接清空整个列表 27 s = [1, 3, 4, "a", "abc", "12sda"] 28 s.clear() 29 print(s) # []
1 # 列表的改 2 # 通过索引号更改对应的值即可，也可使用切片 3 4 s = [1, "a", "b", 2, 3, "a"] 5 s[1] = "asd" 6 print(s) # [1, 'asd', 'b', 2, 3, 'a'] 7 s[1:3] = [123, "asdjlk"] 8 print(s) # [1, 123, 'asdjlk', 2, 3, 'a'] 9 10 11 # 如果是单使用切片，则只是把列表里索引号对应的元素删掉，可以加入任何东西，方法和 extend 类似 12 s = [1, "a", "b", 2, 3, "a"] 13 s[:3] = ["asj"] 14 print(s) # ['asj', 2, 3, 'a'] 15 s[:3] =[1, 2, ["22", "sad", True]] 16 print(s) # [1, 2, ['22', 'sad', True], 'a'] 17 18 # 如果使用切片加步长，那么添加的元素个数必须与切片删除原列表的个数一样
还有列表的查：
索引， 切片， 切片(加步长) 及 for 循环
列表的其他操作
1 # count —— 统计某个元素在列表中出现的次数 2 3 s = ["q","w","q","r","t","y"] 4 print(s.count("q")) # 2
5 s = (1, 3, True)
6 # 这里的 1 和 True 其实是相等的
7 print(s.count(1)) # 2
1 # index —— 从列表中找出某个值第一个匹配项的索引位置 2 # 列表跟字符串不同，不能用 find()，只能用 index()，找不到就报错 3 s = ["q","w","r","t","y"] 4 print(s.index("r")) # 1
5
6 l1 = ['wusir', "taibai", "ritian", "alex"]
7 # 方法一：通过元素找到其对应的索引号
8 # for i in l1:
9 # print(l1.index(i))
10
11 # 使用上面的有一个坑，比如列表中有相同的元素时
12 # 使用 index 的话，找到相同元素的第一个元素时就返回索引值了
13 # 后面即使有相同的也不会再返回索引值
14 # l1 = ['wusir', "wusir", "taibai", "ritian", "alex"]
15 # for i in l1:
16 # print(l1.index(i))
17
18 # 方法二：动态获取列表的元素
19 for index in range(0, len(l1)):
20 print(index)
1 # sort —— 在原位置对列表进行排序 2 3 a = [2,1,3,4,5] 4 a.sort() # 他没有返回值，所以只能打印a 5 print(a) # [1, 2, 3, 4, 5] 6 # 还有 sort(reverse=True) 这个反向操作 7 8 # reverse —— 将列表中的元素反向存放 9 10 a = [2,1,3,4,5] 11 a.reverse() # 他没有返回值，所以只能打印a 12 print(a) # [5, 4, 3, 1, 2]
1 # 就目前版本(Python3.6版本及以上)来说，列表可以相加 2 3 s1 = [1, 2] 4 s2 = [1, 2, 3] 5 ret = s1 + s2 6 print(ret) # [1, 2, 1, 2, 3] 7 8 9 # 列表也可以与数字想乘 10 s3 = [2, 3, 4] 11 s4 = s3 * 2 12 print(s4) # [2, 3, 4, 2, 3, 4] 13 14 # 这就类似于字符串的拼接和与数字的相乘
1 # 在循环一个列表时，最好不要改变列表的长度 2 # 因为这样会影响列表后面元素的索引位置 3 4 # 把下面列表索引为奇数的元素删掉 5 s = [11, 22, 33, 44, 55] 6 7 # 错误方法： 8 for i in range(len(s)): 9 if index % 2 == 1: 10 s.pop(index) 11 12 print(s) 13 # 结果发现是 11, 33, 44，明显有问题 14 15 # 正确方法一： 16 17 new_li = [] 18 for i in range(len(s)): 19 if i % 2 == 0: 20 new_li.append(s[i]) 21 22 s = new_li 23 print(s) 24 25 # 正确方法二： 26 # 倒叙法 —— 循环删除列表元素 27 for i in range(len(s)-1, -1, -1): 28 if i % 2 == 1: 29 s.pop(i) 30 31 print(s)
32
33 # 正确方法三：
34 s[1::2]
1 # 同理，在循环一个字典时，不能改变字典的大小，否则会报错 2 3 # 删除下面字典中 key 中带有 "k" 的键值对 4 # dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'} 5 6 # 错误方法： 7 for key in dic: 8 if "k" in key: 9 dic.pop(key) 10 11 12 # 正确方法： 13 l1 = [] 14 for key in dic: 15 if "k" in key: 16 l1.append(key) 17 18 for k1 in l1: 19 dic.pop(k1) 20 21 print(dic)
三. 字典（dict）
列表有好处，也有缺点：
1. 列表如果存储大量的数据，查找速度相对慢一些
2. 列表存储的数据一般没有什么关联性，比如：
["wusir", 175, "男"...]
单是看这个列表不知道它们之间的联系，因此就有了字典。
字典相比列表有以下优点：
查询速度非常快，因为字典是Python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
字典在3.5及之前的版本中是无序的，但是3.6开始优化机制，字典会按照创建之初的顺序排列。
Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。
可哈希表示key必须是不可变类型，如：数字、字符串、元组，而且这个键是唯一的，后面再写一个到这个位置就会被替换掉。
dic = {"name": "ss", "name": "a", "name": "sd"}
print(dic) ==> {"name": "sd"}
字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。
列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
1 # 字典的增， 有则覆盖key原来对应的值，无则将键值添加进去 2 3 dic = {'age': 18, 'name': 'jin', 'sex': 'male'} 4 5 dic.setdefault('k','v') 6 print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} 7 8 # setdefault —— 有则不变，无则添加 9 # 在字典中添加键值对，如果只有键那对应的值是none.但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。 10 dic.setdefault('k','v1') 11 print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
12 dic.setdefault("high", 175)
13 print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v', 'high': 175}
1 # 字典的删 2 3 # pop() —— 有返回值 4 dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} 5 dic_pop = dic.pop("age") 6 print(dic_pop) # 18 7 print(dic) # {'name': 'jin', 'sex': 'male', 'k': 'v'} 8 9 # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值 10 dic_pop2 = dic.pop("a") # 报错，显示 "KeyError" : "a" 11 dic_pop2 = dic.pop("a", "无Key返回默认值") 12 print(dic_pop2) # 无Key返回默认值 13 print(dic) # {'name': 'jin', 'sex': 'male', 'k': 'v'} 14 # 设置返回值的好处是避免程序报错 15 16 # del —— 没有返回值 17 del dic["name"] 18 print(dic) # {'sex': 'male', 'k': 'v'} 19 20 21 # popitem() —— 随机删除字典中的某个键值对，并将删除的键值对以元组的形式返回 22 dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} 23 dic_pop3 = dic.popitem() 24 print(dic_pop3) # ('k', 'v') 25 print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male'} 26 # 前面提到Python3.5及之前的版本中字典是无序的，所以每次使用 popitem() 随机删除一个键值对 27 # 但是3.6版本之后就只会删除最后一个，相当于 pop()，多次尝试运行都一样的结果。 28 # clear() —— 清空字典 29 dic_clear = dic.clear() 30 print(dic_clear) # None 31 print(dic) # {}
32
33 注意：dic.pop(key) 与 dic.popitem() 的区别，前者删除某元素，括号里要加键，而后者只是删除最后一对键值
1 # 字典的改 2 3 dic = {"name":"jin","age":18,"sex":"male"} 4 dic2 = {"name":"alex","weight":75} 5 6 # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中,注意不是 dic1 7 dic2.update(dic) 8 print(dic2) # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
9 # update 还可以这样用
10 dic.update(weight = 150, high = 175) # key 不用加引号，也不能是数字, 因为它是一个变量
11
12 # 还有一个最简单的方法，比如
13 dic["age"] = 28
1 # 字典的查(取值) 2 3 dic = {"name":"jin","age":18,"sex":"male"} 4 5 value1 = dic["name"] # 没有会报错 6 print(value1) # jin 7 8 value2 = dic.get("age") 9 print(value2) # 18 10 # 没有对应的 Key 则返回设定的返回值 11 value3 = dic.get("djffdsafg","默认返回值") 12 print(value3) # 默认返回值
13
14 # 还可以使用 for...in... 循环字典，获取的是key值
1 # 字典的其他操作 2 3 dic = {"name":"jin","age":18,"sex":"male"} 4 item = dic.items() 5 print(item,type(item)) 6 # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'> 7 # 这个类型就是dict_items类型，可迭代的 8 9 keys = dic.keys() 10 print(keys,type(keys)) 11 # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'> 12 13 values = dic.values() 14 print(values,type(values)) 15 # dict_values(['male', 18, 'jin']) <class 'dict_values'>
1 # 字典的循环 2 3 dic = {"name":"jin","age":18,"sex":"male"} 4 5 for key in dic: # 或者这样写完善点： for key in dic.keys(): 6 print(key) 7 8 for item in dic.items(): 9 print(item) 10 11 for key,value in dic.items(): 12 print(key,value)
1 # 分别赋值 2 3 a, b = 10, 20 4 print(a, b) # (10 20) 5 6 a, b, c = (1, 2, 3) 7 print(a, b, c) # (1, 2, 3) 8 9 a = 50 10 b = 30 11 a, b = b, a # 先看右边，首先 b 指向 30， a 指向 50 12 print(a, b) # (30, 50)
13 # 相当于重新赋值
1 # 字典的四种创建方式 2 3 # 第一种 4 dic = dict(name="alex", age="12") 5 # 这种方法的值没法是数字 6 dic = dict({键值对}） 7 8 # 第二种 9 # 直接创建 10 dic = {键值对} 11 12 # 第三种 13 dict.fromkeys("abc", "alex")
14 # 这里的第一个参数是迭代添加为字典的键，第二个参数为值，默认为 None。
15 # 所以第一个参数就是可迭代对象，比如字符串，列表。
16
17 # 第四种
18 dic = dict([("a", 1), ("b", 2), ("c", 3)])
19
20 # 拓展
21 l1 = [1, 2, 3]
22 l2 = ["a", "b", "c"]
23 dic = dict(zip(l1, l2
四. 集合（set）
集合和字典一样，是无序的。
集合有一点就是它是不重复的数据集合，它里面的元素是可哈希的(不可变类型)
但是集合本身是不可哈希（所以集合做不了字典的键）的。
1 set1 = {1, 2, "ad", [2, "34"]} 2 print(set1) 3 4 # 打印结果会报错，提示列表不可哈希，因为它是可变的
以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1 # 集合的创建 2 3 set1 = set({1,2,'barry'}) 4 set2 = {1,2,'barry'} 5 6 print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'}
1 # 集合的增 2 3 set1 = {'alex','wusir','ritian','egon','barry'} 4 set1.add('景女神') 5 print(set1) # {'ritian', 'wusir', 'barry', '景女神', 'alex', 'egon'} 6 7 8 #update：迭代着增加，注意看与前面的区别 9 set1.update('A') 10 print(set1) # {'ritian', 'wusir', 'barry', '景女神', 'A', 'alex', 'egon'} 11 12 set1.update('老师') 13 print(set1) # {'ritian', 'wusir', '师', 'barry', '景女神', 'A', 'alex', '老', 'egon'} 14 15 set1.update([1,2,3]) 16 print(set1) 17 # {1, 2, 3, 'ritian', 'wusir', '师', 'barry', '景女神', 'A', 'alex', '老', 'egon'} 18 # 可以看出与列表的迭代的增类似
1 # 集合的删 2 3 set1 = {'alex','wusir','ritian','egon','barry'} 4 5 # 删除一个元素 6 set1.remove('alex') 7 print(set1) # {'ritian', 'wusir', 'barry', 'egon'} 8 9 # 随机删除一个元素 10 set_pop = set1.pop() 11 print(set_pop) # ritian 12 print(set1) # {'wusir', 'barry', 'egon'} 13 14 # 清空集合 15 set1.clear() 16 print(set1) # set() 17 18 # 删除集合 19 del set1 20 print(set1) # 报错
集合的其他操作
1 # 交集（& 或者 intersection） 2 3 set1 = {1,2,3,4,5} 4 set2 = {4,5,6,7,8} 5 6 print(set1 & set2) # {4, 5} 7 print(set1.intersection(set2)) # {4, 5} 8 9 10 # 反交集 （^ 或者 symmetric_difference） 11 12 set1 = {1,2,3,4,5} 13 set2 = {4,5,6,7,8} 14 15 print(set1 ^ set2) # {1, 2, 3, 6, 7, 8} 16 print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
1 # 并集 （| 或者 union） 2 3 set1 = {1,2,3,4,5} 4 set2 = {4,5,6,7,8} 5 6 print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8} 7 print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
1 # 差集 （- 或者 difference） 2 3 set1 = {1,2,3,4,5} 4 set2 = {4,5,6,7,8} 5 6 print(set1 - set2) # {1, 2, 3} 7 print(set1.difference(set2)) # {1, 2, 3} 8 9 print(set2 - set1) # {8, 6, 7} 10 print(set2.difference(set1)) # {8, 6, 7}
1 # 子集与超集 2 3 set1 = {1,2,3} 4 set2 = {1,2,3,4,5,6} 5 6 # 这两个相同，都是说明set1是set2子集。 7 print(set1 < set2) # True 8 print(set1.issubset(set2)) # True 9 10 11 # 这两个相同，都是说明set2是set1超集。 12 print(set2 > set1) # True 13 print(set2.issuperset(set1)) # True
1 # frozenset —— 不可变集合，让集合变成不可变类型 2 3 s = frozenset('barry') 4 5 print(s, type(s)) 6 # frozenset({'b', 'y', 'a', 'r'}) <class 'frozenset'>
1 # 给你两个列表，将它们合并在一起，去重后以新列表的形式打印出来 2 # 一定要会这种题目！！！ 3 l1 = [1, 2, 3, 4, 5] 4 l2 = [2, 3, 4, 5, 6] 5 6 l3 = l1 + l2 7 print(l3) # [1, 2, 3, 4, 5, 2, 3, 4, 5, 6] 8 9 new_list = list(set(new_list)) 10 print(new_list, type(new_list))
五. 基础数据类型总结
按存储空间的占用分（从低到高）
数字 字符串 集合：无序，即无序存索引相关信息 元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串，布尔值 |
| 容器类型 | 列表，元组，字典，集合 |
按数据类型可变不可变区分——（可变即可哈希）
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组，布尔值 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
六. for -- enumerate -- range 的用法
1 # for 循环 —— 按顺序循环可迭代对象的内容 2 3 msg = '老男孩python是全国范围内最好的python培训机构' 4 for item in msg: 5 print(item) 6 7 8 li = ['alex','银角','女神','egon','太白'] 9 for i in li: 10 print(i) 11 12 13 dic = {'name':'太白','age':18,'sex':'man'} 14 for k,v in dic.items(): 15 print(k,v)
1 # enumerate —— 枚举 2 # 对于一个可迭代、可遍历的对象，enumerate 将其组成一个索引序列 3 # 利用它同时获得索引和值 4 5 li = ['alex','银角','女神','egon','太白'] 6 7 for i in enumerate(li): 8 print(i) 9 # (0, 'alex') 10 # (1, '银角') 11 # (2, '女神') 12 # (3, 'egon') 13 # (4, '太白') 14 15 for index,name in enumerate(li,1): 16 print(index,name) 17 # 1 alex 18 # 2 银角 19 # 3 女神 20 # 4 egon 21 # 5 太白 22 23 # 起始位置默认是0，可更改 24 for index, name in enumerate(li, 100): 25 print(index, name) 26 # 100 alex 27 # 101 银角 28 # 102 女神 29 # 103 egon 30 # 104 太白
1 # range —— 指定范围，生成指定数字,可当作自制一个可控范围的数字列表，也就是说它不是列表 2 3 for i in range(1,10): 4 print(i) 5 6 for i in range(1,10,2): # 步长 7 print(i) 8 9 for i in range(10,1,-2): # 反向步长 10 print(i)
1 # 打印一个乘法口诀表 2 3 for i in range(1, 10): 4 for j in range(1, i + 1): 5 # print(str(i) + "x" + str(j) + "=" + str(i * j), end=" ") 6 print("%dx%d=%d" %(i, j, i*j), end=" ") 7 print() 8 9 # end=" " 使用制表符，表示对齐 10 # 注意print()默认跳到下一行 11 # 所以这里的 print() 相当于 print("", end=" ") 12 13 # 1x1=1 14 # 2x1=2 2x2=4 15 # 3x1=3 3x2=6 3x3=9 16 # 4x1=4 4x2=8 4x3=12 4x4=16 17 # 5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 18 # 6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 19 # ...