Python基础02（Python序列结构/列表/元组/集合/字典/序列解包）

Python序列结构

• 序列结构的分类：

1.有无顺序（是否可以通过索引访问序列结构的元素）：

有序：列表，元组，字符串
无序：字典，集合	

2.是否可变（是否可以增加或删除元素）：

可变：列表，字典，集合
不可变：元组，字符串

1.List列表

• 列表（list）是最重要的Python内置对象之一，是包含若干元素的有序连续内存空间。在形式上，列表的所有元素放在一对[]中，元素之间使用逗号分隔。
• 在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。
• 如果只有一对方括号而没有任何元素则表示空列表。

1.1 列表的创建与销毁

1.通过“=”将列表直接赋值给一个对象
a_list = [] #空列表
b_list = ['a', 'b', 1] 

2.可以使用list()函数把元组、range对象、字符串、字典、集合或其他可迭代对象转换为列表。
>>> list((3,5,7,9,11))               #将元组转换为列表
[3, 5, 7, 9, 11]
>>> list(range(1, 10, 2))            #将range对象转换为列表
[1, 3, 5, 7, 9]
>>> list(‘hello world’)             #将字符串转换为列表
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> list({3,7,5})                     #将集合转换为列表
[3, 5, 7]
>>> list({'a':3, 'b':9, 'c':78})      #将字典的“键”转换为列表
['a', 'c', 'b']
>>> list({‘a’:3, ‘b’:9, ‘c’:78}.items())    #将字典的“键:值”对转换为列表
[('b', 9), ('c', 78), ('a', 3)]
>>> x = list()                        #创建空列表

3.通过del销毁列表对象
x = [1, 2, 3]
del x

1.2 列表元素的访问

x = list('python')
1.正向索引：0表示第1个元素，1表示第2个元素
x[1] 'y'
2.反向索引：-1表示最后1个元素，-2表示倒数第2个元素
x[-1] 'n'

1.3 list列表中常用方法

1.列表增添

1.x.append(元素)#在尾部追加元素
2.x.insert(索引，元素)#在指定位置添加一个元素
3.x.extend(迭代对象)#将可迭代对象中的元素添加到尾部，即将可迭代对象拆解成一小个元素
 extend()：将另一个列表中的元素追加至当前列表的尾部
  参数：可迭代对象（字符串、列表、元祖、字典）    返回值：无
ep：
x = [1, 2, 3]
x.append(4)
x.insert(0, 'start')
x.extend([5, 6, 7])
print(x)

2.删除元素

x.pop(索引)#默认返回最后一个元素，若删除返回响应位置元素，如果为空则抛异常
x.remove(元素)#删除第一个值为指定元素，无返回值，若不存在抛异常
del x[索引]

*由于列表有自动扩张和收缩功能，因此列表的增减元素效率比较低

3.查找相应元素

count(元素)#返回指定元素出现的次数
index(元素)#返回首次出现此的索引   若不存在抛异常
index(元素, start, end)#在指定索引范围内寻找元素

4.排序元素

#注意此操作均在原对象上进行
list.sort(key，reverse)#按某种规则进行排序，排序结果是否颠倒，返回值为None
list.reverse()#所有元素反转，没有返回值

b = list(range(11))
from random import shuffle
shuffle(b)
print("原序列为：", b)
b.sort()
print("排序后序列为：" ,b)
b.sort(key=lambda i : len(str(i)))
print("按字符串的长度排序", b)
b.reverse()
print("逆序后序列", b)

5.内置函数对列表的操作

all(列表或元组)#测试所有元素的值，是否等价于Ture
      如果列表中所有元素不为0，不为空元素，不为None，不为False，则返回True,否则返回False。特殊情况，空列表返回值为True
any(列表或元组)#测试是否有等价于Ture的元素
	  如果列表中存在元素不为0，不为空元素，不为None，不为False，则返回True,否则返回False。特殊情况，空列表返回值为False	
max(),min(),sum(),len()

1.4 列表推导式

• 列表推导式使用非常简洁的方式来快速生成满足特定需求的列表

• 格式：

[expression for expr1 in sequence1 if condition1
            for expr2 in sequence2 if condition2
            for expr3 in sequence3 if condition3
            ...
            for exprN in sequenceN if conditionN]

• 列表推导式在逻辑上等价于一个循环语句

aList = [x+x for x in range(10)]
print(aList)

aList = []
for x in range(10):
    aList.append(x + x)
print(aList)

• 案例：

# 实现序列的平铺
vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
alist = [x2 for x1 in vec for x2 in x1]#先执行for x1 in vec 再执行 for x2 in x1 返回x2
print(alist)

#下面的代码用于从列表中选择大于0的元素组成新的列表：
aList = [-1, -4, 6, 7.5, -2.3, 9, -11]
a = [x for x in aList if x > 0]
print(a)

#多列表嵌套循环
x_ = [(x, y) for x in [1, 2, 3] if x == 1 for y in [3, 1, 4] if y != x]
result = []
for x in [1, 2, 3]:
   for y in [3, 1, 4]:
      if x != y:
         result.append((x,y))

1.5 列表切片

aList[start:end:step]
start:默认为0(step>0时),-1(step<0时)
end:切片截至位置(step>0 默认为列表长度)
情况：start 0，-1时可以省略
     end为列表长度可省略
     step可以为1可省略，省略步长时可以省略最后一个冒号
     当step为负数的时候，这时start应该再end的右侧才行       

• 使用切片获取列表部分元素

  使用切片可以返回列表中部分元素组成的新列表。与使用索引作为下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表
  aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
  #正向切片
  print(aList[::2])
  #逆向切片
  print(aList[::-2])
  #切片结束位置大于列表长度时，从列表尾部截断
  >>> aList[0:100]    
  [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
   #切片开始位置大于列表长度时，返回空列表
  >>> aList[100:]      
  []
  

• 使用切片为列表增加元素

可以使用切片操作在列表任意位置插入新元素，不影响列表对象的内存地址，属于原地操作。

>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9]       #在列表尾部增加元素
>>> aList[:0] = [1, 2]             #在列表头部插入多个元素
>>> aList[3:3] = [4]               #在列表中间位置插入元素

• 使用切片替换和修改列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[3:] = [4, 5, 6]    #切片连续，等号两边的列表长度可以不相等
>>> aList
[1, 2, 3, 4, 5, 6]

>>> aList[::2] = [0]*3       #隔一个修改一个
>>> aList
[0, 2, 0, 4, 0, 6]
>>> aList[::2] = [0]       #隔一个修改一个，切片不连续(即step不为1)等号两边长度必须相等 
>>> aList
[0, 2, 0, 4, 0, 6]

• 使用切片删除列表中的元素

>>> aList = [3, 5, 7, 9]
>>> aList[:3] = []                  #删除列表中前3个元素
>>> aList
[9]
也可以结合使用del命令与切片结合来删除列表中的部分元素，并且切片元素可以不连续。
>>> aList = [3, 5, 7, 9, 11]
>>> del aList[:3]                #切片元素连续
>>> aList
[9, 11]
>>> aList = [3, 5, 7, 9, 11]
>>> del aList[::2]               #切片元素不连续，隔一个删一个
>>> aList
[5, 9]

2.元组

2.1 定义

• 元组属于不可变（immutable）序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。
• 元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。
• 元组也支持切片操作，但是只能通过切片来访问元组中的元素，而不允许使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。

2.2 元组与列表的区别

• Python的内部实现对元组做了大量优化，访问速度比列表更快。如果定义了一系列常量值，主要用途仅是对它们进行遍历或其他类似用途，而不需要对其元素进行任何修改，那么一般建议使用元组而不用列表。
• 元组在内部实现上不允许修改其元素值，从而使得代码更加安全，例如调用函数时使用元组传递参数可以防止在函数中修改元组，而使用列表则很难保证这一点。
• 元组可用作字典的键，也可以作为集合的元素。而列表则永远都不能当作字典键使用，也不能作为集合中的元素。

2.3 元组创建

• 直接创建

x = (1, 2, 3)   #直接把元组赋值给一个变量
x = (3,)        #如果元组中只有一个元素，必须在后面多写一个逗号
x = ()             #空元组
x = tuple()        #空元组
tuple(range(5))    #将其他迭代对象转换为元组

• 元组生成器创建

生成器推导式（generator expression）的用法与列表推导式非常相似，在形式上生成器推导式使用圆括号（parentheses）作为定界符，而不是列表推导式所使用的方括号（square brackets）。

格式：

(expression for expr1 in sequence1 if condition1
            for expr2 in sequence2 if condition2
            for expr3 in sequence3 if condition3
            ...
            for exprN in sequenceN if conditionN)

与列表推导式最大的不同是，生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象，具有惰性求值的特点，使用生成器对象的元素时，可以根据需要将其转化为列表或元组，也可以使用生成器对象的__next__()方法或者内置函数next()进行遍历，或者直接使用for循环来遍历其中的元素。但是不管用哪种方法访问其元素，只能从前往后正向访问每个元素，没有任何方法可以再次访问已访问过的元素，也不支持使用下标访问其中的元素。当所有元素访问结束以后，如果需要重新访问其中的元素，必须重新创建该生成器对象。

#创建
x = (i * 2 for i in range(10))
print(tuple(x))
print(list(x))#已经访问所以为空列表

#遍历
x = (i * 2 for i in range(10))
for i in range(10):
    print(x.__next__(), end='\t')#等价于print(next(x), end='\t')

• 内置函数的返回值

很多内置函数的返回值也是包含了若干元组的可迭代对象，例如enumerate()、zip()等等。
>>> list(enumerate(range(5)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
>>> list(zip(range(3), 'abcdefg'))
[(0, 'a'), (1, 'b'), (2, 'c')]

3.字典

• 字典（dictionary）是包含若干“键:值”元素的无序可变序列，字典中的每个元素包含用冒号分隔开的“键”和“值”两部分，表示一种映射或对应关系，也称关联数组。定义字典时，每个元素的“键”和“值”之间用冒号分隔，不同元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
• 字典中元素的“键”可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。
• 字典中的“键”不允许重复，“值”是可以重复的。

3.1 字典的创建

1.直接赋值
aDict = {}#空字典
aDict = {1:'apple', 2:'pear'}

2.通过dict()创建
#空字典
dict()
#通过zip函数创建
key=[1, 2]
value=['apple', 'pear']
dict(zip(key,value))
#通过关键字创建
x = dict(name="apple", age='20', sex='man')

3.创建值为空的字典
>>> aDict = dict.fromkeys(['name', 'age', 'sex'])#以给定内容为“键”，创建“值”为空的字典
>>> aDict
{'age': None, 'name': None, 'sex': None}

3.2 字典的访问

#通过键找值
aDict[key]
aDict.get(key,【specialReturnValue】)//默认没找到返回None，没有找到key返回specialReturnValue指定的信息
#其他查找方式
使用字典对象的items()方法可以查看字典中的所有元素
print(aDict.items())
dict_items([(1, 'apple'), (2, 'pear')])
使用字典对象的keys()方法可以返回字典的键。
print(aDict.keys())
dict_keys([1, 2])
使用字典对象的values()方法可以返回字典的值。
print(aDict.values())
dict_values(['apple', 'pear'])

3.3 字典添加元素

1）若该“键”存在，则表示修改该“键”对应的值；
2）若不存在，则表示添加一个新的“键:值”对，也就是添加一个新元素。
>>> aDict = {'age': 35, 'name': 'Dong', 'sex': 'male'}
>>> aDict['age'] = 39                  #修改元素值
>>> aDict
{'age': 39, 'name': 'Dong', 'sex': 'male'}
>>> aDict['address'] = 'SDIBT'         #添加新元素
>>> aDict
{'age': 39, 'address': 'SDIBT', 'name': 'Dong', 'sex': 'male'}

3）update()方法
使用字典对象的update()方法可以将另一个字典的“键:值”一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新。
>>> aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.update({'a':97, 'age':39})  #修改’age’键的值，同时添加新元素’a’:97
>>> aDict
{'score': [98, 97], 'sex': 'male', 'a': 97, 'age': 39, 'name': 'Dong'}

3.4 字典删除元素

如果需要删除字典中指定的元素，可以使用del命令。
>>> del aDict['age']               #删除字典元素
>>> aDict
{'score': [98, 97], 'sex': 'male', 'a': 97, 'name': 'Dong'}

也可以使用字典对象的pop()和popitem()方法弹出并删除指定的元素，例如：
>>> aDict = {'age': 37, 'score': [98, 97], 'name': 'Dong', 'sex': 'male'}
>>> aDict.popitem()                #弹出一个元素，对空字典会抛出异常
('age', 37)
>>> aDict.pop('sex')               #弹出指定键对应的元素
'male'
>>> aDict
{'score': [98, 97], 'name': 'Dong'}

3.5 案例

# 首先生成包含1000个随机字符的字符串，然后统计每个字符的出现次数。
import string
import random
x = string.digits + string.ascii_letters
aDict = {}
str = ''
for i in range(1000):
    str += x[random.choice(range(0, len(x)))]
print(str)
for i in range(len(x)):
    aDict[x[i]] = str.count(x[i])
print(aDict)

4.集合

集合是无序可变序列，集合内元素不能重复，只能为数字，字符串，元组不可变数据类型,不能为列表，字典，集合可变数据类型

4.1 集合的创建

1.直接将集合赋值给变量即可创建一个集合对象。
>>> a = {3, 5}                         #创建集合对象
2.使用函数set()函数将列表、元组、字符串、range对象等其他可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个；如果原序列或迭代对象中有不可哈希的值无法转换成为集合，抛出异常。
b_set = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8]) #转换时自动去掉重复元素

4.2 集合的方法

#添加集合元素
add(元素)：添加值，自动去重，不报错
update(集合)：将另一个集合并入到此集合中
>>> s = {1, 2, 3}
>>> s.add(3)                   #添加元素，重复元素自动忽略
>>> s
{1, 2, 3}
>>> s.update({3,4})            #更新当前字典，自动忽略重复的元素
>>> s
{1, 2, 3, 4}

#删除集合
pop():随机删除并返回集合中的一个元素，集合为空会抛异常
remove():指定删除一个集合中的元素，如果不存在抛异常
discard():指定删除一个集合中的元素,不抛异常
clear():清理集合中所有元素

4.4 集合运算

#无论是通过运算符还是函数方法均不会改变原先集合的值，而是返回一个新的集合
>>> a_set = set([8, 9, 10, 11, 12, 13])
>>> b_set = {0, 1, 2, 3, 7, 8}
>>> a_set | b_set                     #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set.union(b_set)                #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set & b_set                     #交集
{8}
>>> a_set.intersection(b_set)         #交集
{8}
>>> a_set.difference(b_set)           #差集
{9, 10, 11, 12, 13}
>>> a_set - b_set
{9, 10, 11, 12, 13}
>>> a_set.symmetric_difference(b_set) #对称差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
>>> a_set ^ b_set
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}

5.序列解包和封包

• 把多个值赋给一个变量时，Python会自动的把多个值封装成元组，称为序列封包。

a = 'name'
b = 'Alice'
c = 'age'
d = 25
packed_a = {a: b, c: d}  # 封包成字典
packed_b = [a, b, c, d]  # 封包成列表
packed_c = a, b, c, d  # 封包成元组
packed_d = {a, b, c, d}  # 封包成集合

• 把一个序列（列表、元组、字符串等）直接赋给多个变量，此时会把序列中的各个元素依次赋值给每个变量，但是元素的个数需要和变量个数相同，这称为序列解包。

#把一个序列（列表、元组、字符串等）直接赋给多个变量
x, y, z = 1, 2, 3
tuple_x = (1, 2, 3) x, y, z = tuple_x
x, y = y, x
x, y, z = range(3)

#使用序列解包遍历字典元素：
s = {'a':1, 'b':2, 'c':3}
for k, v in s.items():      #字典中每个元素包含“键”和“值”两部分
    print(k, v)