列表与元组

列表（List）

1.列表简述

Def：Python中的列表(list)是置于方括号“[ ]”中的一组数据，数据项之间用逗号分隔。

列表中的每个数据项称为一个元素，元素的数据类型无限制，各元素类型可以相同，也可以不同。也可以将一个列表或元组作为列表的元素。列表是可变数据类型。

2.列表的创建

（1）赋值创建

Describe：直接将置于中括号“[ ]”中、用逗号分隔的一组数据赋值给一个变量。

Notes：数据可以多个，也可以0个（空列表）。

（2）List()函数

Describe：使用list()函数,将元组、range对象、字符串、字典的键、集合和其它类型的可迭代对象类型的数据转换为列表，当参数为空时生成一个空列表。

（3）Split()函数

Describe：split()函数可以根据指定字符将字符串切分为列表。函数参数省略时用空格切分，且多个空格被作为一个空格处理；参数为空格分隔符时，根据一个空格进行切分，多个空格会被切分多次。

（4）列表推导式

详见下文。

3.列表嵌套

Def：一个列表中的某个元素是列表。

4.列表的索引

单层列表：列表名[索引]

嵌套列表：列表名[外层列表索引][元素列表索引]

Notes：一个二维列表,它的每一个元素都是列表,这时仍然可以用索引和切片的方法对其进行访问和操作。每多一层，索引时就多用一组方括号。

5.列表推导式（解析式）

Def：推导式又称解析式，可以从一个数据序列构建另一个新的数据序列的结构体。本质上可以理解为一种集成了变换和筛选功能的函数，通过这个函数把一个序列转换成另一个序列。Format：

X 表达式 for X in 列表 [ if 条件表达式]

X,Y 表达式 for X in 列表1 for Y in 列表2 [ if 条件表达式]

Notes：for 语句可以有1个或多个；if语句可以有0个或多个。

Example：

>>> ls=list(range(8))

>>>s1=[x**2 for x in ls]

>>>S2=[x**2 for x in ls if x%2==1] #奇数

>>>print(ls)

[0,1,2,3,4,5,6,7]

>>>print(s1)

[0,1,4,9, 16,25,36,49]

>>>print(s2)

[1,9, 25,49]

6.列表的操作

（1）列表的更新

①索引赋值

Describe：使用索引编号来为某个特定的元素赋值,从而可以修改列表。（赋值语句是改变对象值的最简单的方法）

Format： 列表名[索引] = 值

②切片赋值

Describe：使用切片赋值可以给列表的多个元素同时赋值,更新列表中的数据。切片赋值要求新值也为列表。使其操作相当于将原列表切片的元素删除，同时用新的列表中的元素代替切片的位置。

Example：

>>>Is=[1,3,5,7,9]

>>> ls[1:3]=[11,13,15,17,19]

>>> print(ls) #原列表中的3,5被替换为11,13,15,17,19

[1,11,13,15,17,19,7,9]

④append()方法

列表对象可调用，功能为向列表尾部追加一个元素，参数为待追加的值。

Example：

>>>ls=[1,3,5,7,9]

>>>ls.append(11)

>>>print(ls)

[1,3,5,7,9,11]

⑤extend()方法

列表对象可调用，将方法参数中的列表整个追加到原列表尾部。

Example：

>>>ls=[1,3,5,7,9]

>>>ls.extend([11,13,15,17,19])

>>>print(ls)

[1,3,5,7,9,11,13,15,17,19]

⑥insert()方法

列表对象可调用，第一个参数为插入位置序号，第二个参数为插入元素。

Example：

>>>ls=[1,3,5,7,9]

>>>ls.insert(2,4)

>>>print(ls)

[1,3,4,5,7,9]>>>ls=[1,3,5,7,9]

>>>ls.insert(2,4)

>>>print(ls)

[1,3,4,5,7,9]

（2）列表的删除

①Command：del

删除元素

Format： del ListName[index]

Notes：index也可以是切片语句，如“del [ : ]”将删除列表中的全部元素。

删除对象

Format： del ListName

②pop()方法

Function：删除列表中元素并同时返回被删除元素的值。

Format：ls.pop(i):用于移除列表ls中序号为i的一个元素，无参数的时候默认删除列表中的最后一个元素。

③remove()方法

Function：删除列表中第一个与参数相同的元素。

Format：ls.remove(x):删除列表中第一个与参数“x”相同的元素，存在多个相同元素时,只删除第一个。

Notes：列表中不存在与参数相同元素时将报错。

④clear()方法

Function：清空列表。

（3）列表的排序

①sort()方法

Function：默认比较元素的大小，升序排序，字符串逐位比较每个字符的大小。

Format：ls.sort(*, key=None, reverse=False)

Notes：

（①）key：根据什么进行排序，一般有三种参数，len（列表中元素的长度）、str（字符串字典序）、lambda（lambda表达式）

======================================================================

ls = ['cat', 'dog', 'elephant', 'ant']

ls.sort(key=len)

print(ls) # 输出：['ant', 'cat', 'dog', 'elephant']

======================================================================

ls = ['cat', 'dog', 'elephant', 'ant']

ls.sort(key=str)

print(ls) # 输出：['ant', 'cat', 'dog', 'elephant']

======================================================================

ls = [[1, 2], [3, 4, 5], [6], [7, 8, 9]]

ls.sort(key=len)

print(ls) # 输出：[[6], [1, 2], [7, 8, 9], [3, 4, 5]]

======================================================================

ls = [(2, 'b'), (1, 'a'), (3, 'c')]

ls.sort(key=lambda x: x[0])

print(ls) # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

（②）reverse：False时为默认值，为升序排序；True时为降序。

②reverse()方法

Function：直接将列表元素逆序。

7.列表的赋值与复制

Describe：将一个列表ls直接赋值给另一个变量new时，并不会产生新的对象。只相当于给原列表存储的位置多加了一个标签new。可以同时使用ls和new两个标签访问原列表。

（二）元组（Tuple）

1.元组简述

Def：一般来讲，元组是置于小括号()中的一组数据，数据项之间用逗号隔开。元组中的每个数据项称为一个元素，各元素类型可以相同，也可以不同，还可以将列表或元组作为元组的元素。元组为不可变数据类型。

Notes：元组支持使用索引、切片的方法访问元组中的元素，但不能使用索引、切片的方法修改、增加或删除其中的元素。

2.元组的创建

（1）小括号

>>>tua1 = () #空元组

>>>tua2 = (1, 2, 3)

（2）逗号结尾的单独元素

>>>tub = (12,)

>>>tuc = 5,

（3）逗号分隔的多个元素

>>>tud = 5, 7, 9, 45, 35

（4）tuple()函数

参数为空或range、列表等可迭代对象

Notes：作为元组，虽然不可直接改变元组元素的值，作为元素的列表是可变数据类型，列表的值是可以修改的。

3.多变量赋值

Def：在确定序列长度的情况下,可以应用Python多变量赋值语句把元组、列表和字符串等序列解包,将其中的多个元素分别赋值给多个独立的变量。详见博文https://dwz.win/a6P5

>>>a,b,c,d='HFUT'

>>>a,b,c,d

('H', 'F', 'U, 'T')

（三）列表与元组的比较

1.区别

2.元素可变性

列表可以随意改变；但是元组不行。

元组虽然不可变,但可以利用现有的元组的部分来创建新的元组。

元组的不可变是针对元组元素本身，如果元组内的元素是可变的对象，则可以改变其值。

3.列表与元组的转换

tuple()函数与list()函数

4.优缺点

Python中有一些针对元组的优化策略，对元组的访问和处理速度远快于列表。

当一组数据仅被用于遍历或类似操作,而不进行任何修改操作时,一般建议使用处理速度更快的元组,而不用列表。

字典与集合

字典（Dict）

1.字典简述

Def：

①字典(dictionary)是在大括号中放置一组逗号分隔的“关键字:值”对(key-value pair) ，它是无序的“关键字:值”对（键值对)的集合体。

②关键字就相当于索引，而它对应的“值”就是数据，数据是根据关键字来存储的。

③同一个字典之内关键字必须是互不相同的，字典中一个关键字只能与一个值关联。

④字典是一种可变数据类型。对同一个关键字，后添加的值会覆盖之前的值。

2.字典的索引与访问

Describe：

①序列是以连续的整数为索引。字典以关键字(键)为索引。

②关键字(键)必须使用不可变数据类型，如整型、浮点型、字符串等。

③如果元组中只包含字符串和数字，则元组也可以作为关键字。

④不能用列表作为关键字。

⑤字典以关键字作为索引。

⑥若索引不存在与字典中，将会在字典中新建一个以该关键字为键的新键值对。

>>>scores={'Wang':92,'Zhang':78,'Li':90,'Wu':85}

>>> scores['Li']

90

>>> scores['Li']=89

>>>scores['Zhou']='YuanYuan'

>>> scores

{'Wang':92 , 'Zhang':78 , 'Li':89 , 'Wu':85 , 'Zhou':'YuanYuan'}

3.字典的创建

（1）赋值创建

创建字典的一般格式为：

字典名={[关键字1:值1[,关键字2:值2,……,关键字n:值n]]}

Notes：

①关键字与制之间用冒号“:”分隔。

②字典的元素与元素之间用逗号“,”分隔。

③字典中的关键字必须是唯一的且是不可变类型，值可以不唯一。

④当键值对都省略的时候生成一个空字典，即“{}”表示一个空字典。

（2）dict()函数创建

Describe：

①使用dict()函数创建一个空字典并给变量赋值。

②使用列表或元组作为dict()函数参数。

③将数据按“关键字=值”形式作为参数传递给dict()函数。

======================================================================

>>m1=dict()

>>>m1

{}

======================================================================

>>>m2=dict((['x',1],['y',2]))

>>>m2

{'x':1, 'y': 2}

>>>m3=dict([('x',1),('y',2)])

>>>m3

{'x':1, 'y': 2}

======================================================================

>>>m4=dict(name='allen',age=25)

>>> m4

{'name': 'allen', 'age': 25}

4.字典的操作

（1）字典元素的访问

一般格式：

字典名[关键字]

字典嵌套字典访问格式：

字典名[关键字1][关键字1_1]

>>>score={'Name':{'First':'Xiaoming,Last:'Zhang'l,Age":18}

>>> score[ 'Age']

18

>>> score[ 'Name']['First']

'Xiaoming'

（2）字典元素的更新

更新字典值的语句格式为:字典名[关键字]=值

如果关键字不存在，则在字典中增加一个新元素，即“关键字:值”对。

>>>scores={'Wang':92,'Zhang':78,'Li':90,'Wu':85}

>>> scores['Li']=89

>>>scores['Zhou']='YuanYuan'

>>> scores

{'Wang':92 , 'Zhang':78 , 'Li':89 , 'Wu':85 , 'Zhou':'YuanYuan'}

（3）字典元素的删除

删除关键字对应的元素：

del 字典名[关键字]

删除整个字典：

del 字典名

（4）检查关键字是否存在

关键字 in 字典

关键字 not in 字典

>>>scores={'Wang':92,'Zhang': 78, 'Li': 89,'Wu ': 85, 'Zhao':82}

>>> 'Zhang' in scores

True

>>>'Li' not in scores

False

（5）字典的长度和运算

len()函数可以获取字典所包含“关键字:值”对的数目，即字典长度。

虽然也支持max()、min()、sum()和sorted()函数，但针对字典的关键字进行计算，很多情况下没有实际意义。

字典不支持连接(+)和重复操作符(*)，关系运算中只有“-”和“!=”有意义。

list()函数可以获取字典的所有关键字，并将所有关键字按其在字典中的顺序组成一个列表。

（6）字典的遍历

d.keys()：返回一个包含字典所有关键字的可迭代对象，对字典关键字的遍历转换为对列表的遍历。

d.values()：返回一个包含字典所有值的可迭代数据对象，对字典值的遍历转换为对列表的遍历。

d.items()：返回一个包含所有(关键字，值)元组的可迭代数据对象，对字典元素的遍历转换为对列表的遍历。

>>>scores={'Wang': 92,'Zhang': 78, 'Li': 89, 'Wu': 85, 'Zhao': 82}

>>> for item in scores.items():

>>> print(item)

[('Wang', 92) , ('Zhang', 78) , ('Li', 89) , ('Wu',85) , ('Zhao',82)]

集合（Set）

1.集合简述

Def：集合(set)是一个无序排列的、不重复的数据集合体。

Notes：

①在产生集合的过程中，若源数据中存在重复元素，Python将自动删除重复元素。

②作为无序的集合体，集合不记录元素位置或插入点,因此集合不支持索引、切片等操作。

2.集合的创建

（1）赋值创建

用一对大括号将多个用逗号分隔的数据括起来。

（2）set()函数

使用set()函数创建一个集合，函数中的参数可以是任意可迭代数据类型。

Notes：“{}”空大括号表示新建一个空字典，而新建一个空集合必须使用set()函数。

>>>s2=set([1,3,5,7,9,11])

>>>s2

{1,3,5,7,9,11}

3.集合的可变性

（1）可变集合

上述所提及的集合相关内容均为可变集合。

不可变集合

使用frozenset()函数创建的集合为不可变集合，其元素不可变化。

4.集合的运算

（1）并集

符号： |

>>>a={1,3,5,7,9]

>>>b={2,4,6,8,10}

>>>s=a | b

>>>s

{1,2,3,4,5,6,7,8,9,10}

（2）交集

符号： &

>>>S={1,2,3,4,5}&{1,2,3,4,5,6}&{2,3,4,5}&{2,4,6,8}

>>>S

{2,4}

（3）差集

>>>S={1,2,3,4,5,6,7,8,9}-{1,2,3,4,5,6]-{2,3,4,5]-{2,4,6,8]

>>>S

{9,7}

（4）对称差集

作用：计算集合之间的相异元素

格式：s1 ^ s2

>>>S={1,2,3,4,5,6,7,8,9}^{5,6,7,8,9,10}

>>>S

{1,2,3,4,10}

集合的并入

作用：将s2的元素并入s1中

格式：s1 |= s2

>>>sl={4,3,2,1}

>>>S2={7,8}

>>>sl=s2

>>>s1

{1,2,3,4,7,8}

5.集合比较

（1）异同比较

①“s1==s2”若集合具有完全相同的元素，则返回TRUE，否则返回FALSE。

②“s1!=s2”如果s1和s2至少有一个不同的元素，则返回True，否则返回False。

（2）子集比较

①s1<=s2

Describe：s1中所有的元素都是s2的元素(s1是s2的子集)，则返回True，否则返回False。

②s1<s2

Describe：s1!=s2，且s1中所有的元素都是s2的元素(s1是s2的纯子集)，则返回True，否则返回False。

（3）超集比较

①s1>=s2

Describe：如果s2中所有的元素都是s1的元素(s1是s2的超集)，则返回True，否则返回False。

②s1>s2

Describe：如果s1不等于s2，且s2中所有的元素都是s1的元素(s1是s2的纯超集)，则返回True，否则返回False。

6.集合的遍历

集合与for循环语句配合使用,可实现对集合各个元素的遍历。

a=set([1,2,3,4,5,6,7,8,9])

t=0

for x in a:

　　print(x,end='/t')

　　t+=x

print(t)