目录
一、列表
Python内置的一种数据类型是列表：list。
列表（Lists）属于Python中的序列类型，它是任意对象的有序集合，通过“位置”或者“索引”访问
其中的元素，它具有可变对象、可变长度、异构和任意嵌套的特点。
创建列表
在创建列表时，列表元素放置在方括号[] 中，以逗号来分隔各元素，格式如下：
listname = [元素1, 元素2, 元素3, ……, 元素n]
举例如下：
sample_list1 = [0, 1, 2, 3, 4]
sample_list2 = ["P", "y", "t", "h", "o", "n"]
sample_list3 = ['Python', 'sample', 'list', 'for', 'your', 'reference']
print (sample_list1) #打印输出列表
列表中允许有不同数据类型的元素，例如： 但通常建议列表中元素最好使用相同的数据类型。
sample_list4 = [0, "y", 2, "h", 4, "n", 'Python']
列表可以嵌套使用，例如：
sample_list1 = [0, 1, 2, 3, 4]
sample_list2 = ["P", "y", "t", "h", "o", "n"]
sample_list3 = ['Python', 'sample', 'list', 'for', 'your', 'reference']
sample_list5 = [sample_list1, sample_list2, sample_list3] #创建一个嵌套列表
print (sample_list5)
#输出 [[0, 1, 2, 3, 4], ['P', 'y', 't', 'h', 'o', 'n'], ['Python', 'sample', 'list', 'for', 'your', 'reference']]
使用列表
用索引来访问list中每一个位置的元素, 索引是从0 开始的, 记得最后一个元素的索引是len(classmates) - 1 。
| 索引 | 0 | 1 | 2 | … | … | … | … | n-1 |
|---|---|---|---|---|---|---|---|---|
| 列表 | x1 | x2 | x3 | … | … | … | xn-1 | xn |
| 索引 | x1 | x2 | x3 | … | … | … | -2 | -1 |
当索引超出了范围时，Python会报一个IndexError 错误，所以，要确保索引不要越界。
如果要取最后一个元素，除了计算索引位置外，还可以用-1 做索引，直接获取最后一个元素。
如果一个list中一个元素也没有，就是一个空的list，它的长度为0。特别注意，“位置”或者“索引”是从0开始，
sample_list1 = [0, 1, 2, 3, 4]
print ("sample_list1[0]: ", sample_list1[0]) #输出索引为0的元素sample_list1[0]: 0
print ("sample_list1[2]: ", sample_list1[2]) #输出索引为2的元素sample_list1[2]: 2
可以在方括号中使用“负整数”，如：sample_list1[-2]，意为从列表的右侧开始倒数2个的元素，即索引倒数第2的元素。
sample_list1 = [0, 1, 2, 3, 4]
print ("sample_list1[-2]: ", sample_list1[-2]) # 输出索引倒数第2的元素sample_list1[-2]: 3
以在方括号中用冒号分开的两个整数来截取列表中的元素，例如sample_list2[2:4]，可取得列表sample_list2中的第3个和第4个元素，不包含第5个元素。
sample_list2 = ["p", "y", "t", "h", "o", "n"]
print ("sample_list2[2:4]:", sample_list2[2:4])
# 输出sample_list2[2:4]: ['t', 'h']该类操作被称为“切片”操作（slice）。
对列表的元素进行修改时，可以使用赋值语句：
sample_list3 = ['python', 'sample', 'list', 'for', 'your', 'reference']
print ("sample_list3[4]:", sample_list3[4])
# 输出sample_list3[4]: your
print ("sample_list3:", sample_list3)
# 输出 sample_list3: ['python', 'sample', 'list', 'for', 'your', 'reference']
删除列表元素
删除列表的元素，可以使用 del 语句，格式为：
del listname[索引]
该索引的元素被删除后，后面的元素将会自动移动并填补该位置。
在不知道或不关心元素的索引时，可以使用列表内置方法remove()来删除指定的值，例如：
listname.remove('值')
清空列表，可以采用重新创建一个与原列表名相同的空列表的方法，例如：
listname = []
删除整个列表，也可以使用del语句，格式为：
listname = []
del listname
代码示例如下：
sample_list4 = [0, "y", 2, "h", 4, "n", 'Python']
del sample_list4[5] #删除列表中索引为5的元素
print ("after deletion, sample_list4: ", sample_list4)
#输出 after deletion, sample_list4: [0, 'y', 2, 'h', 4, 'Python']
sample_list4.remove('Python') #删除列表中值为Python的元素
print ("after removing, sample_list4: ", sample_list4)
# 输出 after removing, sample_list4: [0, 'y', 2, 'h', 4]
sample_list4 = [] #重新创建列表并置为空
print (sample_list4) #输出该列表
# 输出[]
del sample_list4 #删除整个列表
print (sample_list4) #打印输出整个列表
'''
输出
NameError Traceback (most recent call last)
<ipython-input-60-b17c9a7334be> in <module>()
NameError: name 'sample_list4' is not defined
'''
列表内置函数与其他方法
len() 函数可以获得list元素的个数。
max() 函数可以获得list元素的最大值。
min() 函数可以获得list元素的最小值。
list(tuple) 函数将元组转换为列表。
sample_list1 = [0, 1, 2, 3, 4]
len(sample_list1) #列表的元素数量,输出5
max(sample_list1) #列表中元素的最大值，输出4
min(sample_list1) #列表中元素的最小值，输出0
序列的通用操作和函数
- List1+List2连接序列List1和List2；
- LIst1*expr序列重复expr次；
- obj in List1判断obj 元素是否在List1中，返回bool型
- sum（List[index1：index2]）序列求和，（字符串列表不适合）
列表的专用操作和函数
1、list.append(obj)：在列表末尾添加新的对象
2、list.count(obj)：统计某个元素在列表中出现的次数
3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj)：将对象插入列表
6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7、list.remove(obj)：移除列表中某个值的第一个匹配项
8、list.reverse()：反向列表中元素
9、list.sort([func])：对原列表进行排序
classmates = ['Michael', 'Bob', 'Tracy']
print('classmates= ',classmates)
classmates.append('Adam') #['Michael', 'Bob', 'Tracy', 'Adam']
print('classmates= ',classmates)
classmates.insert(1, 'Jack') #['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
print('classmates= ',classmates)
classmates.pop() #['Michael', 'Jack', 'Bob', 'Tracy']
print('classmates= ',classmates)
classmates.pop(1) #['Michael', 'Bob', 'Tracy']
classmates[1] = 'Sarah' #['Michael', 'Sarah', 'Tracy']
二、元组
另一种有序列表叫元组：tuple。
元组（Tuples）与列表一样，属于Python中的序列类型，它是任意对象的有序集合，通过“位置”或者“索引”访问其中的元素，它具有可变长度、异构和任意嵌套的特点，与列表不同的是：元组中的元素是不可修改的。
创建元组
元组的创建很简单，把元素放入小括号，并在每两个元素中间使用逗号隔开即可，格式为：
tuplename = (元素1, 元素2, 元素3, ……, 元素n)
举例如下：
sample_tuple1 = (1, 2, 3, 4, 5, 6)
sample_tuple2 = "p", "y", "t", "h", "o", "n"
sample_tuple3 = ('python', 'sample', 'tuple', 'for', 'your', 'reference')
sample_tuple4 = ('python', 'sample', 'tuple', 1989, 1991, 2018)
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。 如果可能，能用tuple代替list就尽量用tuple。
tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。
元组也可以嵌套使用，例如：
sample_tuple1 = (1, 2, 3, 4, 5, 6)
sample_tuple2 = "P", "y", "t", "h", "o", "n"
sample_tuple7 = (sample_tuple1, sample_tuple2)
print (sample_tuple7)
# 输出((1, 2, 3, 4, 5, 6), ('P', 'y', 't', 'h', 'o', 'n'))
使用元组
tuple不能变，它也没有append()，insert()这样的方法, 其他获取元素的方法和list是一样的，
你可以正常地使用tuple[0] ， tuple[-1] ，但不能赋值成另外的元素。
代码示例为：
sample_tuple1 = (1, 2, 3, 4, 5, 6)
print (sample_tuple1[1]) #截取第2个元素，输出2
print (sample_tuple1[3:5]) #第4个和第5个元素，不包含第6个元素，输出（4，5）
print (sample_tuple1[-2]) #从右侧向左数的第2个元素，输出5
元组也支持“切片”操作，例如
- sample_ tuple2 =”P”，"y”， ”t”， "h”， ”o”， ”n”
- sample_ tuple2[:] 表示取元组sample_ tuple2的所有元素:
- sample_ tuple2[3:] 表示取元组sample_ tuple2的索引为3的元素之后的所有元素;
- sample_ tuple2[0:4:2] 表示元组sample_tuple2的索引为0到4的元素，每隔一个元素取一个值
sample_tuple2 ='p','y','t', 'h', 'o','n'
a = sample_tuple2[:]
b = sample_tuple2[3:]
c= sample_tuple2[0:4:2]
a,b,c
# 输出结果(('p', 'y', 't', 'h', 'o', 'n'), ('h', 'o', 'n'), ('p', 't'))
最后来看一个“可变的”tuple
t=(a','b'，['A'，'B'])
t[2][0] # 输出结果为A
t[2][1] # 输出结果为B
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素
删除元组
由于元组中的元素是不可变的，也就是不允许被删除的，但可以使用del 语句删除整个元组：
del tuple
元组的内置函数
len() 函数可以获得元组元素的个数。
max() 函数可以获得元组元素的最大值。
min() 函数可以获得元组元素的最小值。
tuple(listname) 函数将列表转换为元组。
代码示例如下：
sample_tuple1 = (1, 2, 3, 4, 5, 6) #创建元组tuple1
print (len(sample_tuple1)) #输出元组长度6
print (max(sample_tuple1)) #输出元组最大值6
print (min(sample_tuple1)) #输出元组最小值1
a = [1,2,3] #创建列表a
print (a) #输出列表a[1, 2, 3]
print (tuple(a)) #转换列表a为元组后输出(1, 2, 3)
三、字典
字典（Dictionaries），属于映射类型，它是通过键实现元素存取，具有无序、可变长度、异构、嵌套和可变类型容器等特点。具有极快的查找速度。在其他语言中也称为map
假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：
names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。
如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢
创建字典
字典中的键和值有单引号，他们成对出现，中间用冒号分割，每对直接用逗号分割，并放置在花括号中，格式如下：
sample_dict1 = {‘Hello’: ‘World’, ‘Capital’: ‘BJ’, ‘City’: ‘CQ’}
字典也可以进行嵌套
dictname={键1：{键11：值11，键12：值12}，键2：{键21：值21，键22：值22}，键n:{键n1:值n1，键n2,值n2}}
使用字典
使用字典中的值时，只需要把对应的键放入方括号，格式为：
dictname[键]
举例如下：
sample_dict1 = {'Hello': 'World', 'Capital': 'BJ', 'City': 'CQ'}
print ("sample_dict1['Hello']: ", sample_dict1['Hello'])
# sample_dict1['Hello']: World #输出键为Hello的值为World
sample_dict2 = {12: 34, 34: 56, 56: 78}
print ("sample_dict2[12]: ", sample_dict2[12])
# sample_dict2[12]: 34 #输出键为12的值为34
如果key不存在，dict就会报错，要避免key不存在的错误，有两种办法，一是通过in 判断key是否存在
删除
可以使用del语句删除字典中的键和对应的值，格式为：
del dictname[键]
使用del语句删除字典，格式为：
del dictname
字典的内置函数和方法
内置函数：
- len（dict）
计算字典元素个数，即键的总数 - str（dict）
输出字典，以可打印的字符串表示 - type（variable）
返回输入的变量类型，如果变量是字典返回字典类型
dict={'name':'Beijing','Age':100}
type(dict)
# 输出dict
内置方法：
- clear（）
删除字典内所有的元素
2.copy（）
返回一个字典的浅复制 - fromkeys（seq，value）
创建一个新字典，以序列seq中元素做字典的键 ，value为字典所有键对应的初始值 - get（key，default=None）
返回指定键的值，如果值不在字典中返回default值 - key in dict
如果键在字典dict里返回true，否则返回false - items（）
以列表返回可遍历的（键，值）元组数组 - keys（）
以列表返回一个字典所有的键 - setdefault（key，default=None）
和get（）类似，但如果键不存在字典中，将会添加键并将值设为default - update（dict2）
把字典dict2的键/值对更新到dict里
10.values（）
以列表返回字典中的所有值 - pop（key，default）
删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出，否则返回default值 - popitem（）
随机返回并删除字典中的一对键和值（一般删除末尾对）
四、集合
集合分为两类：可变集合（set），不可变集合（frozenset）。
-
可变集合，在被创建后，可以通过很多种方法被改变，例如add()，update()等。
-
不可变集合，由于其不可变特性，它是可哈希的（hashable，意为一个对象在其生命周期中，其哈希值不会改变，并可以和其他对象做比较），也可以作为一个元素被其他集合使用，或者作为字典的键。
创建集合
使用大括号 { } 或者set()创建非空集合，格式为：
sample_set = {值1, 值2, 值3, ……, 值n}
或
sample_set = set([值1, 值2, 值3, ……, 值n])
创建一个不可变集合，格式为：
sample_set = frozenset([值1, 值2, 值3, ……, 值n])
举例如下：
sample_set1 = {1, 2, 3, 4, 5}
sample_set2 = {'a', 'b', 'c', 'd', 'e'}
sample_set3 = {'Beijing', 'Tianjin', 'Shanghai', 'Nanjing', 'Chongqing'}
sample_set4 = set([11, 22, 33, 44, 55])
sample_set5 = frozenset(['CHS', 'ENG', '', '', '',]) #创建不可变集合
但创建空集合时必须使用set()，格式：
emptyset = set()
s = set([1, 2, 3]) #{1, 2, 3}
s = set([1, 1, 2, 2, 3, 3]) #{1, 2, 3}
s.add(4) #{1, 2, 3, 4}
s.add(4) #{1, 2, 3, 4}
s.remove(4) #{1, 2, 3}
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
su=s1 & s2 #求两个集合交集，输出{2, 3}
si=s1 | s2 #求两个集合并集，输出{1, 2, 3, 4}
tips：字典中的键不可重复，可以先将键值放到set集合中，进行“过滤”，使用for循环遍历，将其组成键。
使用集合
集合的一个显著的特点就是可以去掉重复的元素，例如：
sample_set6 = {1, 2, 3, 4, 5, 1, 2, 3, 4,}
print (sample_set6) #输出去掉重复的元素的集合{1, 2, 3, 4, 5}
可以使用len()函数来获得集合中元素的数量，例如：
sample_set6 = {1, 2, 3, 4, 5, 1, 2, 3, 4,}
len(sample_set6) #输出集合的元素数量5
集合是无序的，因此没有“索引”或者“键”来指定调用某个元素，但可以使用for循环输出集合的元素，例如：
向集合中添加一个元素，可以使用add()方法，即把需要添加的内容作为一个元素（整体），加入到集合中，格式为：
setname.add(元素)
向集合中添加多个元素，可以使用update()方法，将另一个类型中的元素拆分后，添加到原集合中，格式为：
setname.update(others)
集合可以被用来做成员测试，使用in或not in检查某个元素是否属于某个集合，例如：
sample_set1 = {1, 2, 3, 4, 5}
sample_set2 = {'a', 'b', 'c', 'd', 'e'}
3 in sample_set1 #判断3是否在集合中，是则返回True
'c' not in sample_set2 #判断“c没有在集合中” ，如果c在该集合中，返回False，否则返回True
可以使用remove()方法删除集合中的元素，格式为：
setname.remove(元素)
可使用del方法删除集合，格式为：
del setname
举例如下：
sample_set1 = {1, 2, 3, 4, 5}
sample_set1.remove(1) #使用remove方法删除元素
print (sample_set1) # 输出结果{2, 3, 4, 5}
sample_set1.clear() #清空集合中的元素
print (sample_set1) #返回结果为空集合set()
del sample_set1 #删除集合
print (sample_set1)
'''
Traceback (most recent call last): #系统报告，该集合未定义
File "<pyshell#64>", line 1, in <module>
print (sample_set1)
NameError: name 'sample_set1' is not defined
'''
集合运算
集合之间可以做集合运算，求差集（difference）、并集（union）、交集（intersection）、对称差集（symmetric difference）
sample_set7 = {'C', 'D', 'E', 'F', 'G'}
sample_set8 = {'E', 'F', 'G', 'A', 'B'}
sample_set7 - sample_set8 #差集{'D', 'C'}
sample_set7 | sample_set8 #并集{'A', 'G', 'B', 'F', 'E', 'D', 'C'}
sample_set7 & sample_set8 #交集{'E', 'G', 'F'}
sample_set7 ^ sample_set8 #对称差集{'A', 'B', 'D', 'C'}
集合的方法
| 集合（s）.方法名 | 方法说明 | |||
|---|---|---|---|---|
| s.issubset(t) | s <= t 子集测试（允许不严格意义上的子集）：s 中所有的元素都是 t 的成员 | s < t 子集测试（严格意义上）：s != t 而且 s 中所有的元素都是 t 的成员 | ||
| s.issuperset(t) | s >= t 超集测试（允许不严格意义上的超集）：t 中所有的元素都是 s 的成员 | s > t 超集测试（严格意义上）：s != t 而且 t 中所有的元素都是 s 的成员 | ||
| s.union(t) | s | t 合s “或” t 中的元素 | ||
| s.intersection(t) | s & t 交集操作：s “与” t 中的元素 | |||
| s.difference(t) | s - t 差分操作：在 s 中存在，在 t 中不存在的元素 | |||
| s.symmetric_difference(t) | s ^ t 对称差分操作：s “或” t 中的元素，但不是 s 和 t 共有的元素 | |||
| s.copy() | 返回 s 的拷贝（浅复制） |
以下方法仅适用于可变集合
| 集合（s）.方法名 | 方法说明 |
|---|---|
| s.update | s |= t 将 t 中的元素添加到 s 中 |
| s.intersection_update(t) | s &= t 交集修改操作：s 中仅包括 s 和 t 中共有的成员 |
| s.difference_update(t) | s -= t 差修改操作：s 中包括仅属于 s 但不属于 t 的成员 |
| s.symmetric_difference_update(t) | s ^= t 对称差分修改操作：s 中包括仅属于 s 或仅属于 t 的成员 |
| s.add(obj) | 加操作：将 obj 添加到 s |
| s.remove(obj) | 删除操作：将 obj 从 s 中删除，如果 s 中不存在 obj，将引发异常 |
| s.discard(obj) | 丢弃操作：将 obj 从 s 中删除，如果 s 中不存在 obj，也没事儿 |
| s.pop() | 弹出操作：移除并返回 s 中的任意一个元素 |
| s.clear() | 清除操作：清除 s 中的所有元素 |
扫一扫
1811
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
