python列表添加元素的三种方法定义集合数据对象_python 学习第三天 可迭代对象（列表，字典，元组和集合）...

列表，字典，元组和集合

列表 list

列表是由一系列特定元素组成的，元素和元素之间没有任何关联关系，但他们之间有先后顺序关系

列表是一种容器

列表是序列的一种

列表是可以被改变的序列

Python中的序列类型简介（sequence）

字符串（str） 列表（list） 元组（tuple） 字节串（bytes） 字节数组（bytearray）

创建空列表的字面值

L = [ ] # L绑定空列表

创建非空列表： L = [1, ’two’, 3, ‘四’ ]

列表的构造（创建）函数list

list（） 生成一个空的列表，等同于[ ]

list( iterable ) 用可迭代对象创建一个列表

示例： L = list（） L为空列表 L = list（ABCD） # L ->[‘A’, ‘B’, ’C’, ‘D’ ]

列表的运算：

算术运算： + * += *=

用于拼接列表 += 用于原列表与右侧可迭代对象进行拼接，生成新的列表

‘ * ’ 生成重复的列表 ‘ *= ’ 用于生成重复的列表，同时用变量绑定新列表

比较运算

运算符： < <= > >= == != 比较规则和字符串一致 数字不能喝字符串进行比较

列表的in / not in

1.判断一个数据元素是否存在于容器（列表）内，如果存在，返回True。

not in的返回值于in运算符相反

列表的索引 index / 切片slice

列表的索引语法： 列表 [ 整数表达式 ]

用法： 列表的索引取值与字符串的索引取值规则完全相同，分为正向索引和反向索引。

列表的索引赋值

列表是可变的序列，可以通过索引赋值改变列表中的元素

语法： 列表 [ 索引 ] = 表达式

列表的切片

列表 [ : ] 列表的 [ : : ]

列表的切片取值返回一个列表，规则等同于字符串的切片规则

示例： y = x [1 : 9 : 2] # y = [1, 3, 5, 7 ]

列表的切片赋值语法：

列表[切片] = 可迭代对象

说明： 切片赋值的赋值运算符的右侧必须是一个可迭代对象

示例： L = [2, 3, 4] L [:] = [7, 8] # L = [7, 8]

L = [2, 3, 4] L[ 1:1 ] = [2.1, 2.2] # L =[2, 2.1, 2.2, 3, 4]

切片步长不为1的切片赋值：

示例： L = list（range（1， 9））

L [1::2] = [2.2, 4.4, 6.6, 8.8] # L = [1, 2.2, 3, 4.4, 5, 6.6, 7, 8.8, 9 ]

切片注意事项：

对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数。

del 语句用于删除列表元素

语法： del 列表[索引] del 列表[切片]

Python 3中常用的序列函数：

len（x） 返回序列的长度

max（x） 返回序列的最大值元素

min（x） 返回序列的最小值元素

sum（x） 返回序列中所有元素的和（元素必须是数值类型）

any（x） 真值测试，如果列表中其中一个值为真值则返回True

all（x） 真值测试，如果列表中所有值为真值，则返回True

列表方法

L.index（v, [begin[,end]]） 返回对应元素的索引下标，begin开始索引的位置

L.insert（index，obj） 将某个元素插放到列表中指定的位置

L.count（x） 返回列表中元素的个数

L.remove（x） 从列表中删除第一次出现在列表中的值

L.copy（） 复制此列表（只复制一层，不会复制深层对象）

L.append（x） 向列表中追加单个元素（追加在列表末尾）

L.extand（list） 向列表中追加另一个列表

L.clear（） 清空列表，等同于L [:] = [ ]

L.sort(reverse = False) 将列表中的元素进行排序，默认顺序按值的从小到大的顺序排列

L.reverse（） 列表的反转，用来改变原列表的先后顺序 等同于L[:] = L [::-1]

L.pop（[index]） 删除索引对应的元素，如果不加索引，默认删除最后元素。

字符串文本解析方法 split和join

s.split（sep = None） 将字符串，使用sep作用为隔符分隔S字符串，返回分割后的字符串的列表，当不给定参数时，用空白字符作为分隔符进行分割

s.join（iterable） 用可迭代对象中的字符串，返回一个中间用s进行分割的字符串。

示例： L = [‘aaa’,’bbb’,’ccc’] s = ‘ . ’.join(L) # s ‘aaa.bbb.ccc’

深拷贝 deep copy 和 浅拷贝 shallow copy

浅拷贝：是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的复制过程。

深拷贝： 语法 ： import copy #导入copy函数

L2 = copy.deepcopy(L1) #深拷贝

注：深拷贝通常只对可变对象进行复制，不可变对象通常不变。

列表推导式 list comprehension

列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

作用： 用简易方法生成列表

语法： [表达式 for 变量 in 可迭代对象] 或 [表达式 for 变量 in 可迭代对象 if 真值表达式 ]

示例： 以下生成一个数值为1-9的平方的列表。

L =[ x*x for x in range(1, 10) ]

列表推导式的嵌套：

语法： [ 表达式1

for 变量1 in 可迭代对象1 if 真值表达式1

for 变量2 in 可迭代对象2 if 真值表达式2

… ]

示例： 将L1中的全部元素与L2中的全部元素依次相乘后放到列表L3中

L3 = [ x*y for x in L1 for y in L2 ]

元组 tuple

元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一旦元组生成，则它不可以改变

元组的表示方式：

用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组

创建空元组的字符值 t = ( )

创建非空元组的字面值 t = 200, t = (20 ,) t = (1, 2, 3) t = 100, 200, 300

元组的构造函数 tuple

tuple（) 生成一个空的元组，等同于（）

tuple（iterable） 用可迭代对象生成一个元组

示例： t = tuple（range( 10 )）

元组的算术运算: + += * *=

元组的比较运算 < <= > >= == !=

in / not in 索引取值 切片取值 规则与列表完全相同

区别：元组是不可变对象，不支持索引赋值和切片赋值

元组的方法 L.count（x） L.index（x [, begin [, end ] ] ）

可用于序列的函数（包括元组）： len max min sum all any

三个构造函数：

str（obj） 字符串

list（iterable） 列表

tuple（iterable）元组 用于创建相应的对象

其他函数：

reversed（seq） 返回反向顺序的可迭代对象

sorted（iterable，reverse = False） 返回已排序的列表

字典 dict

1.字典是一种可变的容器，可以存储任意类型的数据

2.字典中的每个数据都是用 ’键’ （key）进行索引，而不像序列可以用下标来进行索引

3.字典的数据没有先后顺序关系，字典的存储是无序的

4.字典中的数据以‘键’（key）-‘值’（value）对进行映射存储

5.字典的键不能重复，且只能用不可变类型作为字典的键

字典的字面值表示方式：

用{ }括起来，以冒号分隔键值对，各键值对用分号分隔开

创建空字典 ： d = { }

创建非空的字典： d = {‘name’ : ‘tarena’ , ‘age’ : 15}

字典的构造函数 dict

dict（） 创建一个空字典，等同于{ }

dict（iterable） 用可迭代对象初始化一个字典

dict（**kwargs） 关键字传参形式生成一个字典

示例：

d = dict（[(‘name’, ‘tarena’), (‘age’, 15)]）

d = dict(name = ‘tarena’, age = 15)

不可变类型： int float complex bool str tuple frozenset（固定集合） bytes（字节串）

可变类型： list dict set（集合） bytearray（字节数组）

字典的键索引

用[ ]运算符可以获取字典内‘键’所对应的‘值’

语法： 字典[ 键 ] # 获取数据元素

d = dict（name = ‘tarena’）, age = 15)

print(d [‘age’] # 15

添加/修改字典元素

字典[键] = 表达式

示例 ： d [‘age’] = 16 # 修改键值对 如果键不存在，则创建一个新的键值对

del 语句删除字典的元素

语法： del 字典[ 键 ]

字典的in / not in运算符

可以用in运算符来判断一个‘键’是否存在于字典中，如果存在则返回True

not in与 in 返回值相反

字典的迭代访问：

字典是可迭代对象，字典只能对键进行迭代访问

d = { ‘name’ : ‘tarena’ , (2002, 1, 1) : ‘生日’ }

for x in d: # x 的值为 name （2002，1,1）

可以用于字典的内建函数

len(x) 返回字典键-值对的个数

max（x） 返回字典的键的最大值

min（x） 返回字典的键的最小值

sum（x） 返回字典所有键的和

all（x） 真值测试，全部键为True时，结果才为True

any（x） 真值测试，只对键测试，如果其中一个键为True，结果为True

字典常用方法：

D.clear 清空字典

D.pop(key) 移除键，同时返回此键所对应的值，需要用一个变量来接收

D.copy() 返回字典D的副本，只复制一层（浅拷贝）

D.update(D2) 将字典D2合并到D中，如果键相同，则此键的值取D2的值作为新值

D.get(key, default) 返回键key所对应的值，如果没有此键，则返回default

D.keys() 返回可迭代的dict_keys集合对象（键的集合）

D.values() 返回可迭代的dict_values值对象 （值的集合）

D.items 返回可迭代的dict_items对象 （键值对的集合）元组的形式

字典推导式

字典推导式是用可迭代对象依次生成字典内元素的表达式

语法：

{键表达式：值表达式 for 变量 in 可迭代对象 [if 真值表达式] }

示例：d = {x : x**2 for x in range(10) }

集合 set

集合是可变的容器

集合内的数据对象是唯一的（不能重复多次的）

集合是无序的存储结构，集合中的数据没有先后关系

集合内的元素必须是不可变对象

集合是可迭代的

集合是相当于只有键没有值的字典（键是集合的数据）

创建空的集合 ： s = set( ) # set( ) 创建一个空的集合

创建非空集合 ： s = {1,2,3} # 集合中的三个整数1,2,3

集合的构造函数 set

set（）创建空集合

set（iterable） 用可迭代对象创建一个新的集合对象

s = set([1,2,[2.1,2.2],4]) # 错的 [2.1,2.2]是可变对象

集合的运算：

交集 并集 补集 子集 超集

& 生成两个集合的交集

| 生成两个集合的并集

生成两个集合的补集

s3 = s1-s2 生成属于s1，但不属于s2的所有元素的集合

^ 生成两个集合的对称补集

s3 = s1 - s2 等同于 s3 = （s1 - s2） | （s2 - s1）

< 判断一个集合是另一个集合的子集

> 判断一个集合是另一个集合的超集

in / not in 运算符

等同于字典，in 运算符用于集合中，当某个值存在于集合中，则为真，否则为假。

python3 中可用于集合的函数：

len（x） max（x） min（x） sum（x） any（x） all（x）

集合是可迭代对象，故可用于for循环语句

集合的方法：

S.add（e） 在集合中添加一个新的元素，如果元素已经存在，则不添加

S.remove（e） 在集合中删除一个元素，如果元素不存在集合中，则报错

S.discard（e） 在集合中删除一个元素，如果元素不存在集合中，则什么都不做

S.clear（） 清空集合内的所有元素

S.copy（） 将集合进行一次浅拷贝

S.pop（） 从集合中删除一个随机元素，如果集合为空，则报错

S.update（s2） 用S和s2得到的全集更新变量S

S.difference（s2） 用S-s2运算，返回存在于在S中，但不在s2中的所有值

S.difference_update（s2）等同于S = S - s2

S.intersection（s2） 等同于 S & s2

S.intersection_update（s2） 等同于 S = S & s2

S.isdisjoint（s2） 如果交集为空，返回True

S.issubset（s2） 如果交集为非空，返回True

注：对于不可变对象，有事复合赋值运算符不同于运算后再赋值。

如： s1 = s1 | s2 不等同于 s1 |= s2`

集合推导式

用可迭代对象来创建 [ 生成 ] 集合的表达式

语法：

{表达式 for 变量 in 可迭代对象 [if 真值表达式]}

集合推导式的嵌套和列表推导式相同

固定集合 frozenset

固定集合是不可变的，无序的，含有唯一元素的集合

作用：固定集合可以作为字典的键，也可以作为集合的值

创建空的固定集合： fs = frozenset（）

创建非空的固定集合： fs = frozenset（[2, 3, 5, 7]）

构造函数：

frozenset（）

frozenset（可迭代对象） # 同set函数一致，返回固定集合

固定集合的运算：

& 交集 | 并集 ^ 对称补集 - 补集 > >= < <= == !=

in / not in （运算规则等同于set中的用法）

固定集合的方法：相当于集合的全部方法（去掉修改集合的方法）