python基础python序列--列表元组字典和集合详解

Posted 非晚非晚

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python基础python序列--列表元组字典和集合详解相关的知识,希望对你有一定的参考价值。

只有元组属于不可变类型,因此它没有增删查改操作,其余列表、字典和集合都属于可变对象。集合和字典不支持索引、切片、相加和相乘操作。

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 字典的其它操作

方式说明
copycopy() 方法即有浅拷贝也有深拷贝。一般情况它属于深拷贝,不会及内存共享。而对于某些列表类型的值来说,此方法对其做的是浅拷贝
  • 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()函数。

以上是关于python基础python序列--列表元组字典和集合详解的主要内容,如果未能解决你的问题,请参考以下文章

Python基础数据结构:列表 | 元组 | 集合 | 字典

2.python基础之—列表,元组,字典,集合,字符串的使用方法

python 列表,字典,元组

Python基础进阶之路之元组字典和字符串

Python之路-(列表元组字典集合)

Python之元组列表and 字典