一、元组【了解】
1.概念
和列表相似,本质上是一种有序的集合
元组和列表的不同之处:
a.列表:[] 元组:()
b.列表中的元素可以进行增加和删除操作,但是,元组中的元素不能修改【元素:一旦被初始化,将不能发生改变】
2.和列表比较
创建列表:
创建空列表:list1 = []
创建有元素的列表:list1 = [元素1,元素2,。。。。。]
创建元组
创建空元组:tuple1 = ()
创建有的元组:tuple1 = (元素1,元素2,。。。。)
3.元组操作
# 1.概念
"""
列表:列表是一种有序的,可变的,可以存储重复元素的,可以存储不同类型数据的集合
元组:元组是一种有序的,不可变的,可以存储重复元素的,可以存储不同类型数据的集合
"""
# 2.定义
l1 = [34,5,67,5,5,True,'abc']
print(l1,type(l1)) # <class 'list'>
t1 = (34,5,67,5,5,True,'abc')
print(t1,type(t1)) # <class 'tuple'>
# 注意:当元组中只有一个元素时,需要在元素的后面添加逗号,以消除歧义
l2 = [10]
print(l2,type(l2)) # <class 'list'>
# t2 = (10) # 等价于t2 = 10
# print(t2,type(t2)) # <class 'int'>
t2 = (10,)
print(t2,type(t2)) # (10,) <class 'tuple'>
# 3.元素的访问
# a.获取
print(l1[0])
print(t1[0])
print(l1[-1])
print(t1[-1])
# 注意:元组和列表的索引相同,都有正数索引和负数索引,也都不能越界
# print(l1[10]) # IndexError: list index out of range
# print(t1[10]) # IndexError: tuple index out of range
# b.修改
# 注意:元组一旦定义完成,只能获取其中的元素,无法修改元素
l1[0] = 100
print(l1)
# t1[0] = 100 # TypeError: 'tuple' object does not support支持 item元素 assignment赋值
# 【面试题】
tuple1 = (3,5,'aga',False,[1,2,3])
tuple1[-1][1] = 100 # 修改的是列表
print(tuple1) # (3, 5, 'aga', False, [1, 100, 3])
# 4.遍历
for ele in t1:
print(ele)
for i in range(len(t1)):
print(i,t1[i])
for i,ele in enumerate(t1):
print(i,ele)
# 5.系统功能
# 注意:元组是不可变的,所以元组没有增删改的相关系统功能
# a.len()
print(len(t1))
# b.max(0/min()
t1 = (34,5,67,5,5)
print(max(t1))
print(min(t1))
# c.index()
print(t1.index(5))
# d.count()
print(t1.count(5))
# e.list()/tuple():列表和元组之间的相互转化
t1 = (34,5,67,5,5)
print(t1,type(t1))
l1 = list(t1)
print(l1,type(l1))
t2 = tuple(l1)
print(t2,type(t2))
# 6.元组的意义
"""
a.在实际项目开发中,因为列表相对比较灵活,可以增删改查的操作,所以使用列表较多
b.在多进程和多线程中,一般需要不能被随意修改的数据,元组比列表功能强大
"""
二、字典【重点掌握】
1.概念
列表和元组的使用缺点:当存储的数据要动态添加、删除的时候,我们一般使用列表,但是列表有时会遇到一些麻烦
解决方案:既能存储多个数据,还能在访问元素的很方便的定位到需要的元素,采用字典
# 1.需求:存储5个人的年龄,获取张三的年龄
# 使用列表或元组存储,可以存储多个数据,因为列表和元组都是有序的,只能通过索引的方式获取元素
# 但是,如果要定位张三的年龄,无法定位
age_list = [34,6,22,46,10] # 可变的,可以增删改
age_tuple = (34,6,22,46,10) # 不可变的,无法修改
print(age_list[1])
print(age_tuple[1])
# 使用字典存储
age_dict = {'小明':34,"张三":6,'小王':22,'老张':46,"李四":10}
age = age_dict['张三']
print(age)
# 2.使用的场景
# 列表:如果需要存储同类型的数据,建议列表
list1 = ['张三','李四','jack']
score_list = [66,100,56]
# 字典:可以存储同一个对象的不同信息 或者 需要精确定位某个数据,建议字典
age_dict = {'小明':34,"张三":6,'小王':22,'老张':46,"李四":10}
info_dict = {'name':"张三",'age':18,'hobby':"篮球"}
"""
【面试题】:简述列表,元组,字典,集合和字符串的区别
列表的本质:list,是一种有序的,可变的,可以存储重复元素的,可以存储不同类型的集合
元组的本质:tuple,是一种有序的,不可变的,可以存储重复元素的,可以存储不同类型的集合
字典的本质:dict,是一种有序的【Python3.7之后】,可变的,key不可以重复,
但是value可以重复,key只能是不可变的数据类型,vlue可以是任意的类型的 集合
集合的本质:set,是一种无序的,可变的,不可以存储重复元素的,可以存储不同类型的集合
字符串的本质:str,是一种有序的,不可变的,可以存储重复字符的集合
"""
2.定义字典
语法:{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}
说明:
- 字典和列表类似,都可以用来存储多个数据
- 在列表中查找某个元素时,是根据下标进行的;字典中找某个元素时,是根据’名字’(就是冒号:前面的那个值,例如上面代码中的’name’、‘id’、‘sex’)
- 字典中的每个元素都由2部分组成,键:值。例如 ‘name’:‘班长’ ,'name’为键,'班长’为值
- 键可以使用数字、布尔值、元组,字符串等不可变数据类型,但是一般习惯使用字符串,切记不能使用列表等可变数据类型,值可以是任意类型的数据
- 每个字典里的key都是唯一的,如果出现了多个相同的key,后面的value会覆盖之前的value,但是value可以重复
习惯使用场景:
- 列表更适合保存相似数据,比如多个商品、多个姓名、多个时间
- 字典更适合保存不同数据,比如一个商品的不同信息、一个人的不同信息
【面试题】如何定义字典,至少列出两种方式
1.
dict1 = {‘name’:“张三”,‘age’:18,‘hobby’:“篮球”}
print(dict1)
2. *****
dict2 = {}
dict2[‘a’] = 100 # 添加键值对
dict2[‘b’] = 200
print(dict2)
3.
int(x) float(x) str() bool() list() tuple() dict() set()
dict(key1=value1,key2=value2…):必须以name=value的方式传值,而且name只能是变量
dict3 = dict(a = 10,b = 20,c = 30)
print(dict3)
dict31 = {1:100,2:200}
print(dict31)
dict31 = dict(1=100,2=200)
print(dict31)
4.
dict(iterable):iterable必须是二维的
工作原理:
d = {}
for k,v in [[‘x’,11],[‘y’,22],[‘z’,33]]:
d[k] = v
print(d)
dict4 = dict([[‘x’,11],[‘y’,22],[‘z’,33]])
print(dict4)
dict4 = dict([(‘x’,11),(‘y’,22),(‘z’,33)])
print(dict4)
dict4 = dict(((‘x’,11),(‘y’,22),(‘z’,33)))
print(dict4)
5. ******
dict(zip(所有的key,所有的value))
dict5 = dict(zip([‘name’,‘age’,‘score’],[‘tom’,10,100]))
print(dict5)
dict5 = dict(zip((‘name’,‘age’,‘score’),(‘tom’,10,100)))
print(dict5)
dict5 = dict(zip((‘name’,‘age’,‘score’),[‘tom’,10,100]))
print(dict5)
dict5 = dict(zip([‘name’,‘age’,‘score’,‘gender’],[‘tom’,10,100]))
print(dict5)
dict5 = dict(zip([‘name’,‘age’,‘score’],[‘tom’,10,100,46,67,8,8]))
print(dict5)
注意:不管通过哪种方式定义字典,字典中的key都是不可变的数据类型
“”"
不可变的类型:int float bool str tuple
可变的数据类型:list dict set
“”"
3.基本使用
# 列表/元组:列表/元组[索引]
# 字典:字典[key]
# 1.获取
# a.
# 每个字典里的key都是唯一的,如果出现了多个相同的key,后面的value会覆盖之前的value
d1 = {'a':10,'b':20,"a":30}
print(d1) # {'a': 30, 'b': 20}
# b.方式一:字典[key]
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
print(dict1['age'])
# 注意:如果key不存在,则无法获取
# print(dict1['score']) # KeyError: 'score'
# 优化
if 'score' in dict1:
print(dict1['score'])
else:
print("key不存在")
# b.方式二:字典.get(key) ******
# 注意:如果key存在,则获取对应的值,如果key不存在,则返回None
print(dict1.get('age'))
print(dict1.get('score'))
# 2.修改,主要目的是为修改value
# 语法:字典[key] = value,作用:如果key存在,则表示修改对应的值,但是,如果key不存在,则表示添加键值对
print(dict1)
dict1['age'] = 66
print(dict1)
dict1['score'] = 100
print(dict1)
# 3.遍历字典
# a *******
for key in dict1:
print(key,dict1[key])
# b.
print(dict1.keys()) # 获取字典中所有的key
for key in dict1.keys():
print(key,dict1[key])
# c.
print(dict1.values())
for value in dict1.values():
print(value)
# d. *******
print(dict1.items())
for key,value in dict1.items():
print(key,value)
# 练习1:已知如下字典,获取张三的年龄,获取到的结果是否唯一?唯一
age_dict = {'小明':34,"张三":6,'小王':22,'老张':6,"李四":6}
age = age_dict['张三']
print(age) # 6
# 练习2:已知如下字典,获取年龄为6的学生的名字,获取到的结果是否唯一?不一定
age_dict = {'小明':34,"张三":6,'小王':22,'老张':6,"李四":6}
for key,value in age_dict.items():
if value == 6:
print(key)
"""
总结:
通过key获取到的value是唯一的,但是,通过value获取到的key不一定是唯一的
"""
4.字典系统功能
# 一、增
dict1 = {'a':10,'b':20}
print(dict1)
# 1.字典[key] = value,当key不存在时,表示增加键值对 *****
# dict1['c'] = 30
# print(dict1)
# 2.update():更新,合并字典,将指定字典中的键值对添加到原字典中 ******主要会出现在面试题中
# dict1.update(dict2):将dict2中的键值对添加到dict1中
new_dict = {'x':34,'y':75}
dict1.update(new_dict)
print(dict1)
print(new_dict)
# 3.setdefault(key,default):通过设置默认值的方式增加键值对,了解
dict1 = {'a':10,'b':20}
print(dict1)
# a.default省略,则向指定字典中添加:key:None
dict1.setdefault('abc')
print(dict1) # {'a': 10, 'b': 20, 'abc': None}
# b.default未省略,则向指定字典中添加:key:default
dict1.setdefault('xyz',88)
print(dict1) # {'a': 10, 'b': 20, 'abc': None, 'xyz': 88}
# 二、删
# 1.pop(key):弹出,删除指定key对应的键值对, ********
# 【实际工作原理:将指定键值对从字典中移除,但是在内存中】
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
r = dict1.pop('age') # pop跟列表中的用法类似,返回被删除的数据
print(dict1)
print(r)
# 2.popitem():在Python3.7之前,表示随机删除一对,在3.7之后,删除最后一对
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.popitem()
print(dict1)
# 3.clear()
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.clear()
print(dict1)
# 4.del
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
del dict1['age']
print(dict1)
# del dict1 # 删除字典
# 三、改
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1['age'] = 66
print(dict1)
# 四、查
print(len(dict1)) # 获取键值对的对数
print(dict1.keys())
print(dict1.values())
print(dict1.items())
# 五、其他
# 但凡是可变的数据类型,都有copy()
# 字典同样可以使用copy(),copy.copy(),copy.deepcopy()
# 字典同样遵循和列表一样的深浅拷贝的特征
5.字典推导式
"""
列表推导式:[元素的规律 for循环 if语句]
字典推导式:{key:value for循环 if语句}
"""
# 1.已知字典d1 = {'a':10,'b':20},生成一个新的字典,{10:'a',20:'b'}
d1 = {'a':10,'b':20}
# 方式一
d2 = {}
for k in d1:
d2[d1[k]] = k
print(d2)
# 方式二
d2 = {}
for k,v in d1.items():
d2[v] = k
print(d2)
# 方式三
d2 = dict(zip(d1.values(),d1.keys()))
print(d2)
# 方式四
d2 = {v:k for k,v in d1.items()}
print(d2)
# 方式五:
d2 = {d1[k]:k for k in d1}
print(d2)
# 2.生成字典:{0:0,2:4,4:16,6:36,8:64}
dict2 = {i:i ** 2 for i in range(0,9,2)}
print(dict2)
dict2 = {i:i ** 2 for i in range(0,10) if i % 2 == 0}
print(dict2)
# 3.和列表推导式相同,在字典推导式中,也可以使用多个for或者多个if,从左往右表示依次嵌套的关系
list1 = [a + b for a in 'xyz' for b in '123']
print(list1) # ['x1', 'x2', 'x3', 'y1', 'y2', 'y3', 'z1', 'z2', 'z3']
dict1 = {a:b for a in 'xyz' for b in '123'}
print(dict1) # {'x': '3', 'y': '3', 'z': '3'}
三、集合【了解】
1.概念
Python中的集合跟数学上的集合是一致的,不允许有重复元素,而且可以进行交集、并集、差集等运算
set与dict类似,但是与dict的区别在于只是一组key的集合,不存储value
本质:无序且无重复元素的集合
表示:{},注意:如果直接使用{}则默认表示字典
2.创建
# 1.概念
"""
【面试题】:简述列表,元组,字典,集合和字符串的区别
列表的本质:list,是一种有序的,可变的,可以存储重复元素的,可以存储不同类型的集合
元组的本质:tuple,是一种有序的,不可变的,可以存储重复元素的,可以存储不同类型的集合
字典的本质:dict,是一种有序的【Python3.7之后】,可变的,key不可以重复,
但是value可以重复,key只能是不可变的数据类型,vlue可以是任意的类型的 集合
集合的本质:set,是一种无序的,可变的,不可以存储重复元素的,可以存储不同类型的集合
字符串的本质:str,是一种有序的,不可变的,可以存储重复字符的集合
"""
# 2.定义
# a.定义一个空集合
# {}默认表示字典
dict1 = {}
print(type(dict1))
set1 = set()
print(set1)
# b.定义一个非空集合
set2 = {3,5,6}
print(set2,type(set2))
# c.去重
set3 = {3,3,3,3,4,5,6,6,6,6}
print(set3)
# d.无序
set4 = {7,2,45,2,6,7,8,9,10}
print(set4)
# 练习:去重一个列表中的重复元素
list1 = [45,67,7,8,2,2,2]
list2 = list(set(list1))
print(list2)
3.集合间的运算
# 3.运算
s1 = {1,2,3}
s2 = {3,4,5}
# 3.1符号
# a.交集
print(s1 & s2) # {3}
# b.并集
print(s1 | s2) # {1, 2, 3, 4, 5}
# c.差集
print(s1 - s2) # {1, 2}
# 3.2系统功能
# a.交集
r1 = s1.intersection(s2) # {3}
print(r1)
# b.并集
r1 = s1.union(s2) # {1, 2, 3, 4, 5}
print(r1)
# c.差集
r1 = s1.difference(s2)
print(r1) # {1, 2}
4.集合系统功能
# 集合和字典之间的联系:集合相当于存储了字典中的key
# 一、增
# 1.add(x),x只能是不可变的数据类型,如果x是一个可迭代对象,则整体加入
s1 = {11,22,33}
print(s1)
s1.add(44)
print(s1)
s1.add("abc")
print(s1)
s1.add(True)
print(s1)
s1.add((55,66))
print(s1)
# s1.add([55,66]) # TypeError: unhashable type: 'list'
# s1.add({'a':10}) # TypeError: unhashable type: 'dict'
print("*" * 30)
# 2.update(x),x只能是可迭代对象,只会将可迭代对象中的元素加入【打碎加入】
# 可迭代对象:list,tuple,dict,set,set,range()等容器
s1 = {11,22,33}
print(s1)
# s1.update(44) # TypeError: 'int' object is not iterable可迭代对象
s1.update("abc")
print(s1)
# s1.update(True) # TypeError: 'bool' object is not iterable
s1.update((55,66))
print(s1)
s1.update([77,88])
print(s1)
s1.update({'x':10,'y':20}) # 注意:如果x是字典,只能添加key
print(s1)
# 二、删
# 1.remove(x):x表示需要删除的元素 ******
s1 = {11,22,33,4,78,79}
print(s1)
s1.remove(33)
print(s1)
# s1.remove(100) # KeyError: 100
# 2.pop():因为集合是无序的,所以pop表示随机删除一个
s1 = {11,22,33,4,78,79}
print(s1)
s1.pop()
print(s1)
# 3.discard(x):和remove用法相同,如果被删除的元素不存在,remove会报错,但是discard不会报错 *****
s1 = {11,22,33,4,78,79}
print(s1)
s1.discard(33)
print(s1)
s1.discard(100)
# 4.clear():清空
s1.clear()
print(s1) # set()
# 三、查
s1 = {11,22,33,4,78,79}
s2 = s1.copy()
print(len(s1))
print(max(s1))
print(min(s1))
# int()/float()/bool()/list()/tuple()/dict()/set()