文章目录

1. 序列共同特点

  • 1.1 序列的索引和切片
  • 1.2 序列相加
  • 1.3 序列相乘
  • 1.4 检查元素是否包含在序列中
  • 1.5 序列的内置函数
  • 2. 列表
  • 2.1 列表的创建
  • 2.2 列表的增删查改
  • （1）列表元素的添加
  • （2）列表元素的删除
  • （3）列表元素的查找
  • （4）列表元素的修改
  • 1.3 列表的遍历
  • 1.4 列表的其它操作
  • 3. 元组
  • 3.1 元组的创建
  • 3.2 元组的其它说明
  • 4. 字典
  • 4.1 字典的创建
  • 4.2 字典的增删查改
  • （1）字典元素的添加
  • （2）字典元素的删除
  • （3）字典元素的查找
  • （4）字典元素的修改
  • 4.3 字典的遍历
  • 4.4 字典的其它操作
  • 4. 集合
  • 5.1 集合的创建
  • 5.2 集合的增、删、查、改
  • （1）集合元素的增加
  • （2）集合元素的删除
  • （3）集合元素的查找
  • （4）集合元素的修改
  • 5.3 集合的数据操作
  • 5.4 集合的遍历
  • 5.5 集合的其它操作

列表、元组、字典和集合中，

只有元组属于不可变类型，因此它没有增删查改操作，其余列表、字典和集合都属于可变对象。

集合和字典不支持索引、切片、相加和相乘操作。

1. 序列共同特点

在 Python 中，序列类型包括字符串、列表、元组、集合和字典。由于字符串比较重要且内容比较多，对它的常用函数进行了单独讲解，如果感兴趣可以移步到这篇文章。

这里先讲一下这些序列共同的操作，需要说明的是，集合和字典不支持索引、切片、相加和相乘操作。

1.1 序列的索引和切片

  • 索引
str = "my name is qlee"
print(str[1])# y
print(str[-3])# l
  • 切片

序列切片语法如下：

sname[start : end : step]
  • sname：序列的名称
  • start：切片的开始位置（包含），默认为0
  • end：切片的结束位置（不包含），默认为序列的长度
  • step：切片时候的步长，默认为1

举例：

tup = (1,2,3,4,5,6,7)
print(tup[1:5:2])#步长为2，(2, 4)
print(tup[:2])#默认步长，默认从0开始，(1, 2)
print(tup[1:])#默认步长，默认结束位置为最后，(2, 3, 4, 5, 6, 7)
print(tup[::])#均为默认，(1, 2, 3, 4, 5, 6, 7)

1.2 序列相加

序列相加"+"操作，会将两个序列拼接，组成一个新的序列且不会去除重复元素，新序列类型与原序列相同。

tup1 = (1,2,3,6)
tup2 = (6,7)
print(tup1 + tup2)# (1, 2, 3, 6, 6, 7)

lst1 = [1,2,3,4]
lst2 = [3,4,5,6]
print(lst1 + lst2) #[1, 2, 3, 4, 3, 4, 5, 6]

str1 = "my name"
str2 = " qlee."
print(str1 + str2) # my name qlee.

1.3 序列相乘

使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。

tup1 = (1,2,3,6)
print(tup1*2)# (1, 2, 3, 6, 1, 2, 3, 6)

lst1 = [1,2,3,4]
print(lst1 * 2) #[1, 2, 3, 4, 1, 2, 3, 4]

str1 = "my name"
print(str1 *2) # my namemy name

1.4 检查元素是否包含在序列中

  • in 关键字：检查某元素是否为序列的成员，存在则返回true
  • not in关键字：用来检查某个元素是否不包含在指定的序列中，不存在时返回true
str = "my name is qlee"
print("my" in str) #True

dic = {10:"张三",20:"李四"}
print(10 in dic)#True
print(30 not in dic) #True

1.5 序列的内置函数

函数

功能

len()

计算序列的长度，即返回序列中包含多少个元素。

max()

找出序列中的最大元素。

min()

找出序列中的最小元素。

list()

将序列转换为列表。

str()

将序列转换为字符串。

sum()

计算元素和。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。

sorted()

对元素进行排序。输出结果为列表

reversed()

反向序列中的元素。输出结果为列表

enumerate()

将序列组合为一个索引序列，多用在 for 循环中。

str="mynameisqlee"

print(max(str))#y
print(min(str))#a
print(sorted(str))#['a', 'e', 'e', 'e', 'i', 'l', 'm', 'm', 'n', 'q', 's', 'y']
print(str)#内置函数排序，不影响原列表

2. 列表

2.1 列表的创建

lst = [] # 创建控列表，[]
lst = [None] * 5 #创建空列表，[None, None, None, None, None]
lst = [1,2,"hello","world"]
lst = list(range(10)) #使用内建函数list创建[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]列表
lst = [i * i for i in range(1,10)] #列表推导,[1, 4, 9, 16, 25, 36, 49, 64, 81]

2.2 列表的增删查改

（1）列表元素的添加

方式

说明

+

两个列表相加，会生成新列表，

append

添加单个元素到列表末尾，原列表地址id不变

extend

添加单个或多个元素到列表末尾，单个元素必须用[]，原列表地址id不变

insert

在指定位置插入元素，原列表地址id不变

lst1=[1,2,3,4,5,6]
lst2=[5,6,7,8]

print(lst1 + lst2)#[1, 2, 3, 4, 5, 6, 5, 6, 7, 8]

lst1.append(100)
print(lst1)#[1, 2, 3, 4, 5, 6, 100]
lst1.append([1,2])
print(lst1)#[1, 2, 3, 4, 5, 6, 100, [1, 2]]

lst2.extend([100])#单个元素必须用[]
print(lst2)# [5, 6, 7, 8, 100]
lst2.extend([1,2])
print(lst2)#[5, 6, 7, 8, 100, 1, 2]

lst2.insert(1,999)
print(lst2) #[5, 999, 6, 7, 8, 100, 1, 2]
lst2.insert(1,[122,32])
print(lst2)#[5, [122, 32], 999, 6, 7, 8, 100, 1, 2]

（2）列表元素的删除

方式

说明

del listname[index]

删除单个元素

del listname[start : end : step]

删除一段连续的元素

del listname

删除列表本身，再次使用会报错。

listname.pop(index=-1)

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

listname.remove(obj)

移除列表中某个值的第一个匹配项

listname.clear

清空列表

lst1=[1,2,3,4,5,6]

del lst1[1]
print(lst1)#[1, 3, 4, 5, 6]
del lst1[:5:2]
print(lst1)#[3, 5]
del lst1
print(lst1)#NameError: name 'lst1' is not defined

（3）列表元素的查找

方式

说明

listname.index(obj, start, end)

如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

所以最好还是用count函数进行判断

lst1=[1,2,3,4,5,6]

if lst1.count(1):
    print(lst1.index(1)) #输出位置0
else:
    print("元素不存在")

（4）列表元素的修改

方式

说明

listname[index]

修改单个元素

listname[start : end : step]

切片修改一段元素

lst1=[1,2,3,4,5,6]

lst1[1]=100
print(lst1)#[1, 100, 3, 4, 5, 6]
lst1[:5:2]=[99,99,99]
print(lst1)#[99, 100, 99, 4, 99, 6]

1.3 列表的遍历

lst1=[1,2,3,4,5,6]
for i in lst1:				#顺序遍历
    print(i)

1.4 列表的其它操作

方式

说明

list.count(obj)

统计某个元素在列表中出现的次数

list.copy()

复制列表

3. 元组

与列表、字典和集合不同，元组为不可变序列(所以可以作为字典的键)，所以不允许对它进行改变。

3.1 元组的创建

需要注意的是，单个元素元组必须加","号，如果不添加","则它实际为元素本身的含义。

tup = ()#空元组
tup = (3,)#单个元素的元组，必须有","
tup = (1,)*4 #(1, 1, 1, 1) 
tup = (1,2,3,4)
tup = 1,2,3,4 #还可以不添加括号： (1, 2, 3, 4)
tup = ([1,2,3,4])
dict1 = {'a':100, 'b':42, 'c':9}
tup = tuple(dict1)#字典只转换key：('a', 'b', 'c')

#元组推导可以通过，先推导列表，然后转换为元组
tup = tuple([i * i for i in range(1,10)]) #(1, 4, 9, 16, 25, 36, 49, 64, 81)

3.2 元组的其它说明

  • 访问元素：同列表，可以通过下标和切片
  • 元组的不可变指的是元组所指向的内存中的内容不可变。

4. 字典

字典由键值对组成，键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，值可以随意。每个键是唯一的。

4.1 字典的创建

字典可通过dict.fromkeys(list，value=None)方法来创建字典，其中list为列表，None为默认值。

dic = {} #空字典
dic = {'数学': 95, '英语': 92, '语文': 84}#一般创建1 {'数学': 95, '英语': 92, '语文': 84}
dic = dict(two=0.65, one=88, three=100, four=-59) #一般创建2{'two': 0.65, 'one': 88, 'three': 100, 'four': -59}

# 由列表或元组转化
lst = [[1,2],[3,4]]
dic = dict(lst) # {1: 2, 3: 4}

# 字典推导式
items = ["Fruits","Books","Othes"]
prices=[23,45,73,56,78]
dic = {item:price for item,price in zip(items,prices)}#{'Fruits': 23, 'Books': 45, 'Othes': 73}

# fromkeys方法
list = [1,2,3]
dic = dict.fromkeys(list, 3)#{1: 3, 2: 3, 3: 3}

4.2 字典的增删查改

（1）字典元素的添加

方式

说明

dictname[key] = value

索引添加，如果key存在，会覆盖原有的value值

update

更新一组键值对，如果原有字典没有则添加，如果有则覆盖。

dic = {'one': 1, 'two': 2, 'three': 3}
dic.update({'one':4.5, 'four': 9.3})
print(dic) # {'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}

（2）字典元素的删除

方式

说明

del dictname[key]

通过key索引来删除，如果没有key会报错。

del dictname

删除整个字典，后续再次访问会报错

dictname.pop(key)

删除指定的键值对，pop没有默认值，如果不指定key会报错

dictname.popitem()

随机删除键值对（其实是底层的最后一个元素，虽然字典表面无序，但是底层有序）

dic = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
del dic["数学"]#删除：数学：95
print(dic) #{'语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
dic.pop("语文")# 删除：语文：89
print(dic)# {'英语': 90, '化学': 83, '生物': 98, '物理': 89}

（3）字典元素的查找

方式

说明

dictname[key]

直接通过key访问，如果没有key会报错。

dictname.get(key, default = None)

default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

dictname.setdefault(key, defaultvalue=None)

setdefault() 方法用来返回某个 key 对应的 value，如果没有相应的key，则会添加相应的key和defaultvalue，并返回defauvalue或None。

dic = dict(two=0.65, one=88, three=100, four=-59)
print( dic.get('one') )#88
print(dic.get("five"))#None
print(dic.get("five","手动默认")) # 手动默认
print(dic.setdefault("two")) # 0.65
print(dic.setdefault("five")) #返回None，并添加five:None
print(dic.setdefault("six","手动默认")) #返回手动默认，并添加six:手动默认

（4）字典元素的修改

方式

说明

dictname[key] = value

如果key不存在，会增加相应的key，value

4.3 字典的遍历

先来介绍keys()、values() 和 items() 的方法：

  • keys() 方法用于返回字典中的所有键（key）；
  • values() 方法用于返回字典中所有键对应的值（value）；
  • items() 用于返回字典中所有的键值对（key-value）。

例如：

dic = dict(two=0.65, one=88, three=100, four=-59)
print(dic.keys())# dict_keys(['two', 'one', 'three', 'four'])
print(dic.values()) # dict_values([0.65, 88, 100, -59])
print(dic.items()) # dict_items([('two', 0.65), ('one', 88), ('three', 100), ('four', -59)])

lst = list(dic) #只是将key转换为list ['two', 'one', 'three', 'four'] 。等同于：lst = list(dic.keys)

所以字典有3种遍历方式：

dic = {'数学': 95, '语文': 89, '英语': 90}
for k in dic.keys():
    print(k,end=' ') 
print("\n---------------")
for v in dic.values():
    print(v,end=' ') 
print("\n---------------")
for k,v in dic.items():
    print("key:",k," value:",v)

输出：

数学 语文 英语 
---------------
95 89 90 
---------------
key: 数学  value: 95
key: 语文  value: 89
key: 英语  value: 90

4.4 字典的其它操作

方式

说明

copy

copy() 方法即有浅拷贝也有深拷贝。一般情况它属于深拷贝，不会及内存共享。而对于某些列表类型的值来说，此方法对其做的是浅拷贝

  • copy说明：
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，因此 a 添加新键值对，不会影响 b。
a['four']=100
print(a) #一般元素深拷贝
print(b)
#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
a['three'].remove(1)
print(a) #列表元素属于共享，属于浅拷贝
print(b)

4. 集合

集合是没有value的字典，所以集合的key也是唯一的，不允许重复。

5.1 集合的创建

set1 = set() # 空集合
set1 = {1,'c',1,(1,2,3),'c'} #一般创建

#使用set() 将字符串、列表、元组、range 对象等可迭代对象转换成集合
lst = [1,2,3,4,5,6]
set1 = set(lst)

set1= {i * i for i in range(1,10)} # {64, 1, 4, 36, 9, 16, 49, 81, 25}

5.2 集合的增、删、查、改

（1）集合元素的增加

方式

说明

setname.add(element)

添加元素element。只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则会报错

setname.update(elem)

添加列表或集合中的元素到 setname

（2）集合元素的删除

方式

说明

del setname

删除整个集合，后续访问会报错

setname.remove(element)

删除现有 set 集合中的指定元素，如果element不存在，则会报错。

setname.pop()

删除集合中的一个元素，并返回。如果setname为空集合，则会报错

setname.discard(elem)

删除集合中的 elem 元素，如果element不存在，不会报错

setname.clear()

清空集合

（3）集合元素的查找

同序列的查找，1.4章节

（4）集合元素的修改

5.3 集合的数据操作

功能

运算符

函数

说明

交集

&

set3 = set1.intersection(set2)

取两集合公共的元素

并集

|

set3 = set1.union(set2)

取两集合全部的元素

差集

-

set3 = set1.difference(set2)

取一个集合中另一集合没有的元素

对称差集

^

set3 = set1.symmetric_difference(set2)

取集合 A 和 B 中不属于 A&B 的元素

5.4 集合的遍历

dic = {1,'c',1,(1,2,3),'c'}
for d in dic:
    print(d,end=' ')

5.5 集合的其它操作

方法名

语法格式

功能

copy()

set2 = set1.copy()

拷贝 set1 集合给 set2

difference_update()

set1.difference_update(set2)

从 set1 中删除与 set2 相同的元素

intersection_update()

set1.intersection_update(set2)

取 set1和 set2 的交集，并更新给 set1

symmetric_difference_update()

set1.symmetric_difference_update(set2)

取 set1 和 set2 中互不相同的元素，并更新给 set1

isdisjoint()

set1.isdisjoint(set2)

判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回

issubset()

set1.issubset(set2)

判断 set1 是否是 set2 的子集 >>> set1 = {1,2,3}

issuperset()

set1.issuperset(set2)

判断 set2 是否是 set1 的子集

注意没有union_update()函数。