python入门知识（四）：序列+列表+字典+元组+字典+集合

一、序列

序列用来存储一系列数据。

在内存中，序列是一块用来存放多个值的连续的内存空间。序列实质上存储的是每个对象的地址，然后再将整个序列的地址复制给变量a。
常用的序列结构有：字符串、列表、元组、字典和集合。

二、列表

列表中可以放任意类型的数据。

（一）列表的创建

1.list()函数

• 将字符串中的每个字符放在列表中，如list(“hello”)==>[“h”,“e”,“l”,“l”,“o”]
• 使用range(起始数字，终止数字（必选），步长)，能够将任何可迭代的数据转化成为列表，如list(range(10))、list(range(15,3,-1))

2.推导式生成列表

#通过range()和控制语句生成多个元素，并放到列表中
>>>a=[x*2 for x in range(5)] 
>>>a
[0,2,4,6,8]
>>>b=[x*2 for x in range(50) if x%9==0]
>>>b
[0,18,36,54,72,90] 

（二）列表元素的增加和删除

一般在列表尾部增加或删除元素。删除或增加列表中间的元素，将会减弱列表的操作效率。

1.append()

>>>a=[1,3,6]
>>>a.append(10)
>>>a
[1,3,6,10]

2.+运算符操作

>>>a=[1,3,6]
>>>a=a+[10]
>>>a
[1,3,6,10]

注：+和append()的不同点在于，+运算符产生的是一个新的列表。

3.extend()

>>>a=[1,3,6]
>>>a.extend([10,50])
>>>a
[1,3,6,10,50]

extend()方法可以在列表尾部插入一个指定列表。

4.insert()

>>>a=[1,3,6]
>>>a.insert(2,100) #在列表索引为2的地方插入元素100
>>>a
[1,100,3,6]

注：insert()的本质是数组的拷贝，即将元素向后移，这样会降低操作效率

5.乘法拓展

>>>a=[1,3,6]
>>>b=a*2 #将列表a复制两次
>>>b
[1,3,6,1,3,6]

（三）列表元素的删除

1.del

del用以删除指定位置上的元素

>>>a=[1,3,6]
>>>del a[2] #删除列表a中索引为2的元素
>>>a
[1,3]

注：del 的本质是数组元素的拷贝，即将后面的元素依次拷贝到前一个位置上

2.pop()

• pop()默认删除列表中的最后一个元素
• pop()也可以删除指定位置的元素

>>>a=[1,3,6]
>>>a.pop()  #默认删除最后一个元素
>>>a
[1,3]

>>>a.pop(0) #指定删除位置
>>>a
[3]

3.remove()

remove()用来删除首次出现的指定元素，若不存在该元素，则会抛出异常。

>>>a=[1,3,6,3]
>>>a.remove(3)  
>>>a
[1,6,3]

（四）列表的访问和计数

1.索引访问

通过指定位置获取元素。语法为：列表名[0，列表长度-1]，如果超出范围，会报错。

2.index()访问

获得指定元素在列表中首次出现的索引位置。语法为：列表名.index(指定元素（必选），起始位置，终止位置)。如a.index(20)、a.index(20,1,6)

3.count()

>>>a=[1,3,6,3]
>>>a.count(3)   #返回元素3在列表a中出现的次数
2

4.len()

>>>a=[1,3,6,3]
>>>len(a)   #返回列表a的长度
4

5.成员资格判断

>>>a=[1,3,6,3]
>>>20 in a   #成员操作符in 、not in
False

（五）切片操作

（六）列表的遍历

>>>a=list(range(1,10,2))
>>>for x in a:
	print(x)

（七）列表的排序

1.修改原列表

修改原列表，不建新列表的排序：

• 升序排列：a.sort()
• 降序排列：a.sort(reverse=True)
• 打乱顺序：import random
  random.shuffle(a)

2.建立新列表

调用内置函数sorted()进行排序，这个方法返回新列表，不对原列表进行修改。

• 升序排列：sorted(列表名)
• 降序排列：sorted(列表名，reverse=True)

3.返回迭代器

内置函数reversed()也支持逆序排列，但只能逆序排列一次。因为逆序排列的实质是指针从后往前移动，排列完毕之后，指针转移到了列表的开头处，再进行逆序排列，指针前已无元素。

>>>a=[10,20,30,40]
>>>c=reversed(a)
>>>list(c)
[40,30,20,10]

（八）列表操作方法小结

（九）二维列表

一维列表中的某元素为一维列表。
二维列表可以用来存储二维、表格的数据。

二维列表的内存结构图为：

-嵌套循环打印二维列表的所有数据

#打印上图表示的二维列表
for m in range(3)：
	for n in range(4):
		print(a[m][n],end="\t")
	print("\n")

三、元组

列表属于可变序列（可以在列表里删除、修改、添加），而元组属于不可变序列，不能修改、删除、添加元组中的元素。

（一）元组的创建

1.通过()创建元组

a=(10,20,30)
a=10,20,30 #可以不要括号

a=(10,) #只有一个元素时，需要加逗号
a=10,

2.通过tuple()创建元组

tuple(可迭代的对象)

>>>a=tuple("abc")
('a','b','c') 

>>>a=tuple(range(3))
(0,1,2)

>>>a=tuple(['a','b','c'])
('a','b','c')  

3.生成器推导式创建元组

>>>a=(x*2 for x in range(4)) #这里的a为生成器
>>>tuple(a)
(0,2,4,6)
>>>list(a) #只能访问一次，第二次就为空了，需要再生成一次
[]

>>>a=(x*2 for x in range(4)) 
>>>a._next_() #指针逐个下移，迭代器依次返回数值
0
>>>a._next_()
2
>>>a._next_()
4
>>>a._next_()
6

总结：

• tuple()可以接受列表、字符串、其他序列类型、迭代器等生成元组
• list()可以接受元组、字符串、其他序列类型、迭代器等生成序列

（二）元组的完全删除

del a

（三）元组的索引访问

列表名称[索引值]，如a[0]

（四）元组的切片操作

a[1:10]、a[::-1]、a[-5:-3]

（五）元组的排序

list.sort(a)是修改原列表对象，元组不能修改元素。所以只能使用sorted(元组名)。

>>>a=(10,20,30)
>>>sorted(a,reverse=True)

（六）元组的连接

1.用加号+连接元组

a+b

2.zip()

zip(列表1，列表2，…)将多个列表对应位置的元素组合成元组，并返回这个zip对象。

>>>a=[10,20,30]
>>>b=[40,50,60]
>>>c=[100,90,80]
>>>d=zip(a,b,c)
>>>list(d)
[(10,40,100),(20,50,90),(30,60,80)]

（七）元组总结

1. 核心特点：不可变序列
2. 元组的访问和处理速度都比列表快
3. 与整数和字符串一样，元组可以作为字典的键，列表不能。
   

四、字典

• 字典里每个元素都是一个“键值对”，如a={“name”:“tony”,“age”=18}
• 字典通过“键”来找“值”
• 键：只能是整数、浮点数、字符串和元组（不可变），而不能是列表、字典等可变类型

（一）字典的创建

1.花括号{}

>>>a={"name":"tony","age"=18}
>>>print(a)
{"name":"tony","age"=18}

2.dict()

>>>a=dict(name="tony",age=18}
>>>print(a)
{"name":"tony","age"=18}

>>>a=dict([("name","tony"),("age",18)])
>>>print(a)
{"name":"tony","age"=18}

3.zip()

>>>k=["name","age"]
>>>v=["tony",18]
>>>a=dict(zip(k,v))
>>>a
{"name":"tony","age"=18}

4.fromkeys创建空字典

>>>a=dict.fromkeys(['name','age'])
>>>a
{"name":None,"age":None}

（二）字典的访问

1.通过键获得值

>>>a=dict('name':'tony','age':18])
>>>a
{'name':tony,'age':18}
>>>a["name"]
tony

2.通过get()获得值

推荐使用

>>>a=dict('name':'tony','age':18])
>>>a
{"name":tony,"age":18}
>>>print(a.get("name"))
tony
>>>print(a.get("ddd"))
None
>>>a.get("ddd","不存在")
不存在

3.列出所有的键值对

>>>a.items()
{"name":tony,"age":18}

4.列出所有的键、所有的值

>>>a.keys()
dict_keys(['name','age'])
>>>a.values()
dict_values(['tony',18])

5.检查键是否在字典中

>>>"name" in a
True

（三）字典元素的添加、修改和删除

1.字典元素的添加

#在字典中新增键值对
>>>a["job"]="engineer"
>>>a
{'name':'tony','age':18,'job'='engineer'}

2.字典元素的修改

#修改字典的值
>>>a['job']="cook"
>>>a
{'name':'tony','age':18,'job'='cook'}

#修改字典的键
>>>a['salary']=a.pop('job') #因为pop函数会返回删除的键值对的值，将该值赋给新的键，就可以在字典中放入新的键值对

#update()方法可以将新的字典中所有的键值对添加到旧字典中。若key有重复，则直接覆盖。
>>>a={'name':'tony','age':18,'job'='cook'}
>>>b={'name':'selina','age':20,'sex'='女'}
>>>a.update(b)
{'name':'selina','age':20,'job'='cook','sex'='女'}

3.字典元素的删除

（1）del(字典名[键])

>>>a={'name':'tony','age':18,'job'='cook'}
>>>del(a['name']) #删除字典a中name的键值对
>>>a
{'age':18,'job'='cook'}

（2）字典名.pop(键)

>>>a={'name':'tony','age':18,'job'='cook'}
>>>b=a.pop('name') #pop删掉的值将返回并保存在b中
>>>b
'tony' 

（3）popitem()

随机删除和返回键值对。

>>>a={'name':'tony','age':18,'job'='cook'}
>>>a.popitem() #popitem将返回删掉的值
{'name':'tony'}
>>>a
{'age':18,'job'='cook'}

五、序列解包

序列解包可以让我们方便的对多个变量赋值，可以用于元组、列表和字典中。

#对多个变量进行序列解包赋值
>>>x,y,z=10,20,30

#对元组进行序列解包赋值
>>>(x,y,z)=(10,20,30)

#对列表进行序列解包赋值
>>>[x,y,z]=[10,20,30]

#对字典进行序列解包赋值
>>>s={'name':'tony','age':18,'job'='cook'}
>>>a,b,c=s   #1.对键进行序列解包赋值
>>>a
'name'

>>>e,d,f=s.values()   #2.对值进行序列解包赋值
>>>e
'tony'

>>>x,y,z=s.items()    #3.对键值对进行序列解包赋值
>>>x
{'name':'tony'}

六、小练习：使用字典和列表储存表格数据

>>>r1={'name':'高小一','age'=18,'salary'=30000,'city'='北京'}
>>>r2={'name':'高小二','age'=19,'salary'=20000,'city'='上海'}
>>>r3={'name':'高小五','age'20,'salary'=10000,'city'='深圳'}
>>>tb=[r1,r2,r3] #将字典放在列表中

#获得第二行的人的薪资
>>>tb[2].get('salary')

#打印表中所有的薪资
>>>for i in range(len(tb)):  #循环遍历的次数可以通过len()函数获得
>>>    print(tb[i].get('salary'))

#打印表的所有数据
>>>for i in range(len(tb)):
>>>    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))

七、散列表

• 散列表：如字典。散列表可以不断扩容，每次扩容，字典里的键都会根据哈希算法，重新计算散列值，根据算得的值，重新摆放键值对，所以说字典是无序的。
• 可散列：如元组、字符串、数字等。可散列的长度是固定的，元素摆放的位置也是固定的。
• 不能一边遍历字典，一边对字典进行增添。因为这样会使字典发生扩容，键值对的位置会发生改变。

八、集合

集合是无序可变的，它的底层是字典实现。

• 和字典的相同点：集合的元素是不可变的，并且不能出现重复元素
• 和字典不一样点：集合只有键，没有值。

（一）集合的创建

1.使用花括号{}

>>>a={10,20,30}
>>>a
{10,20,30}

2.使用set()

>>>a=[10,20,30,20]  #重复元素只能保留一个
>>>b=set(a)
{10,20,30}

（二）集合的删除remove()

>>>a={10,20,30,40}  #重复元素只能保留一个
>>>a.remove(20)
>>>a
{10,30,40}

（三）集合的情况clear()

>>>a={10,20,30,40}  #重复元素只能保留一个
>>>a.clear()
>>>a
set()

（四）集合的相关操作

• 集合的并集：a|b 或 a.union(b)
• 集合的交集：a&b 或 a.intersection(b)
• 集合的差集：a-b 或 a.difference(b)