Python全栈笔记（七）

最新推荐文章于 2021-07-06 22:09:25 发布

莫奇2513

最新推荐文章于 2021-07-06 22:09:25 发布

阅读量202

点赞数 1

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/moakey/article/details/108313106

版权

python 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

5. 元组(tuple)

元组也是一个容器，里面可以存放各种数据（和列表相似），但他有一个特殊的特点：元组的儿子元素不允许添加、不允许修改、不允许删除，只能读。tuple写在小括号里，元素之间用逗号隔开。
元组的元素不可变，但可以包含可变对象，如list
一般用于存储一些在程序中不应该被修改的一系列值。

5.1 元组的定义

v1 = (11,22,33,)
v2 = ("Jesse","Alex",)
v3 = ("Jesse",)

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。

定义一个只有一个元素的tuple，必须加逗号。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
2. 比较值 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),) 有什么区别？

5.2 常见操作

操作名称	操作方法	举例
访问元组中的元素	通过下标直接访问	print(tuple1[0])
遍历元组	通过for循环	for i in tuple1: print(i)
元组的切片	使用[: :]	tuple1[2:5:2]
元组的加法	+	tuple3 = tuple1+tuple2
元组成员关系	in	2 in tuple1
获取重复元素数量	count	tuple1.count(1)
获取元组长度	len()
获取元组元素最大值	max()
获取元组元素最小值	min()
其他类型对象转换成元组	tuple()

5.3 转换

其他类型可以转换为元组，一般可以被循环的元素才能转换，目前我们学到的可以被循环有：字符串和列表。

name = "武大郎"
data = tuple(name)
print(data) # 输出 ("武","大","郎")
name = ["武大郎",18,"python"]
data = tuple(name)
print(data) # 输出 ("武大郎",18,"python")

5.4 其他

元组和列表非常相似，但由于元组的子元素无法修改的特点，所有在元组都没有修改、删除、添加的操作，只有读操作。

获取长度

user_list = ("1","2",'3',)
print( len(user_list) )

索引

user_list = ("1","2",'3',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )

切片

user_list = ("1","2",'3',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

步长

user_list = ("1","2",'3',)
print( user_list[12] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4-1] )

for循环

user_list = ("1","2",'3',)
for item in user_list:     
 print(item)

user_list = ("1","2",'3',)
for item in user_list:  
if item == '2':      
	continue  
	print(name)

5.5 嵌套

由于元组和列表都可以充当容器，他们内部可以放很多元素，并且也支持元素内的各种嵌套。

tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱','小姨子低声说道说和姐夫还提钱'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
print(tu1) # 今天姐姐不在家
print(tu2) # 姐夫和小姨子在客厅聊天
print(tu3) # 姐夫问小姨子税后多少钱
print(tu4) # 小姨子低声说道说和姐夫还提钱

6. 字典(dict)

字典也可以当做是个容器，在内部可以存放数据。相比较于元组和列表，字典的元素必须是 键值对。
字典是无序的对象集合，使用键-值（key-value）存储，具有极快的查找速度
键（key）必须使用不可变类型
同一个字典中，键（key）必须是唯一的

注意：在Python3.6+字典就是有序了，之前的字典都是无需。

6.1 字典定义

info = {"Maichel":36, "Bob":12, "Stacy":25}
# 例如： "Stacy":25 称为一个键值对。

注意：字典的键有特殊要求，即：必须可哈希 。目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/dict

# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是不可哈希的. 不能作为key
# dic = {{1: 2}: "哈哈哈"}   # dict是不可哈希的. 不能作为key
# dic = {{1, 2, 3}: '呵呵呵'} # set是不可哈希的, 不能作为key

6.2 常见方法

字典的访问

   info = {"name":"吴彦祖","age":18}
   # 字典的访问
   print(info["name"])
   print(info["age"])
   # 访问不存在的键
   print(info["gender"])		#直接访问会报错
   print(info.get("gender"))		#使用get方法，没有找到键会返回none
   print(info.get("gender","male")) #没有找到可以设定默认值：male
   print(info.get("age","20"))		#找到会显示默认值：18

[增]新增键

   info = {"name":"吴彦祖","age":18}
   newID = input("请输入新的学号：")
   info["id"] = newID
   
   print(info["id"])

[删]移除字典的键值对

   info = {"age":12, "status":True,"name":"Jesse"}
   data = info.pop("age")
   print(info) # {"age":12,"name":"Jesse"}
   print(data) # 12

[删]删除键，字典，清空字典

   info = {"name":"吴彦祖","age":18}
   print("删除前：%s"%info["name"])
   del info["name"]
   print("删除后：%s"%info["name"])  # 删除指定的键值对后，再次访问会报错

   info = {"name":"吴彦祖","age":18}
   print("删除前：%s"%info)
   del info
   print("删除后：%s"%info) # 删除字典后，再次访问会报错

   info = {"name":"吴彦祖","age":18}
   print("清空前：%s"%info)
   info.clear()
   print("清空后：%s"%info) # 清空字典后，打印空

[改]修改值

   info = {"name": "吴彦祖", "age": 18}
   info["age"] = 20
   print(info["age"])

[改]更新字典键值对

   info = {"age":12, "status":True}
   info.update({"age":14,"name":"Jesse"}) # info中没有的键直接添加；有的键则更新值
   print(info)

[查]根据键获取值

   info = {"age":12, "status":True,"name":"Jesse"}
   data = info.get("name",None) # 根据name为键去info字典中获取对应的值，如果不存在则返回None，存在则返回值。
   print(data) # 输出：Jesse

[查]查找所有的键值

   info = {"name": "吴彦祖", "age": 18 , "gender":"male"}
   print(info.keys())	# 获取字典的所有的键，返回一个`高仿的`列表，存放的都是字典中的key
   
   info = {"name": "吴彦祖", "age": 18 , "gender":"male"}
   print(info.values())	# 获取字典的所有的值，返回一个`高仿的`列表，存放的都是字典中的value
    
   info = {"name": "吴彦祖", "age": 18 , "gender":"male"}
   print(info.items())	# 获取字典的所有的键值，返回一个列表，每个键值对是一个元组

注意：在Python2中字典.keys()和字典.values()都是直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

6.3 转换

由于字典的每一个元素是键值对，所以想要转换为字典的必须要有个特定的格式才能转换成功

v = dict([("k1","v1"),("k2","v2")])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}
v = dict([ ["k1","v1"], ["k2","v2"] ])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}

子元素必须包含两个元素，从而将值对应给字典的键、值。

6.4 其他

取长度

   info = {"age":12, "status":True,"name":"Jesse"}
   data = len(info)
   print(data) # 输出：3

索引（键）
字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值 。

   info = {"age":12, "status":True,"name":"Jesse"}
   print(info["age"])      # 输出：12
print(info["name"])        # 输出：Jesse
   print(info["status"])    # 输出：True
print(info["xxxx"])       # 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）

提示：字典根据键的查找速度非常快，远远大于列表或元组通过索引查找的速度，因为字典内部是基于hash存储。

根据键修改值和添加值和删除键值对
上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

   info = {"age":12, "status":True,"name":"Jesse"}
   info["gender"] = "男" # gender键在字典中不存在，则自动在字典中新添加一个键值对
print(info) # 输出： {"age":12, "status":True,"name":"Jesse","gender":"男"}

info = {"age":12, "status":True,"name":"Jesse"}
   info["age"] = "18" # age键在info字典中已存在，则更新键对应的值
   print(info) # 输出： {"age":18, "status":True,"name":"Jesse"}

   info = {"age":12, "status":True,"name":"Jesse"}
   del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错）
   print(info) # 输出： {"status":True,"name":"Jesse"}

for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；

   info = {"age":12, "status":True,"name":"Jesse"}
   for key in info.keys():
       print(key)		# 遍历字典的所有的键

   info = {"age":12, "status":True,"name":"Jesse"}
   for val in info.values():
       print(val)		# 遍历字典的所有的值

   info = {"age":12, "status":True,"name":"Jesse"} 
   for item in info.items():
   	print(item) 		# 遍历所有的键值，item是一个元组 (键，值)
   for key,value in info.items():
   	print(key,value) 	# 遍历字典的所有的键值，将键值从元组中直接拆分出来了。

字典嵌套

截止目前位置我们已学了：int/str/list/tuple/dict 五种常见数据类型，而其中list/tuple/dict类型中可以包含子元素，所以他们的内容就可以进行数据的嵌套。但在嵌套和对内部数据操作时要注意：元组子元素不能变、不可哈希的list、dict不能做字典的键。

    dic = {
        'name':'汪峰',
     'age':48,
        'wife':[{'name':'国际章','age':38}],
     'children':['第一个熊孩子','第二个熊孩子']
    }
    """
    1. 获取汪峰的妻子名字
     d1 = dic['wife'][0]['name']
        print(d1)
 	2. 获取汪峰的孩子们
        d2 = dic['children']
        print(d2)
    3. 获取汪峰的第一个孩子
        d3 = dic['children'][0]
        print(d3)
    4. 汪峰的媳妇姓名变更为 章子怡
        dic['wife'][0]['name] = "章子怡"
        print(dic)
    5. 汪峰再娶一任妻子
        dic['wife'].append({"name":"铁锤","age":19})
        print(dic)
    6. 给汪峰添加一个爱好：吹牛逼
        dic['hobby'] = "吹牛逼"
        print(dic)
    7. 删除汪峰的年龄
        del dic['age']
        或
        dic.pop('age')_
        print(dic)
    """

7. 集合(set)

集合与字典相似，也是一组key的集合，但不存储value，由于key不能重复，所以在集合中没有重复的key。set是无序的，重复元素在set中自动过滤。
集合与元组和列表相似都用于做容器，在内部可以放一些子元素，但集合有三特殊特点： 子元素不重复 、 子元素必须可哈希、无序.
提示：目前可哈希的数据类型 int/str/tuple;不可哈希的类型tuple/list/set 。

7.1 集合的定义

v1 = {1,2,99,18}
v2 = {"Jesse","Alex","大桥","Aoe"}
v3 = {1,True,"world",(11,22,33)}

集合与字典虽然都是用{}括号，但字典内部是键值对，而集合内部直接是值。

7.2 常用方法

常用操作	操作方法	举例
遍历集合	通过for循环	for i in set1: print(i)
更新集合	update方法	set1.update(set2)
向集合添加新元素	add方法	set1.add(5)
移除集合中的元素	remove方法	set1.remove(5)
弹出元素	pop方法	val = set1.pop()
清除元素	clear方法	set.clear()
删除集合	del	del set1
--------------------	--------------------	--------------------
获取集合长度	len()
获取最大的元素	max()
获取最小的元素	min()
其他类型对象转换成集合	set()

添加元素

 data = {"刘嘉玲", '关之琳', "王祖贤"} 
 data.add("郑裕玲") 
 print(data)

 data = set() 
 data.add("周杰伦") 
 data.add("林俊杰") 
 print(data)

删除元素

 data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"} 
 data.discard("关之琳")  
 print(data)

交集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 & s2                 # 方式一：取两个集合的交集
s4 = s1.intersection(s2)    # 方式二：取两个集合的交集
print(s3,s4)

并集

 s1 = {"刘能", "赵四", "⽪⻓⼭"} 
 s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} 
 s3 = s1 | s2               # 方式一：取两个集合的并集 
 s4 = s1.union(s2)          # 方式二：取两个集合的并集 
 print(s3,s4)

差集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 - s2            # 方式一：差集，s1中有且s2中没有的值
s4 = s1.difference(s2)  # 方式二：差集，s1中有且s2中没有的值
print(s3, s4)
s5 = s2 - s1            # 方式一：差集，s2中有且s1中没有的值
s6 = s2.difference(s1)  # 方式一：差集，s2中有且s1中没有的值
print(s5, s6)

7.3 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。

提示：int/list/tuple/dict都可以转换为集合。

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # 输出{11,22,33,3,99}

v1 = "苍井空"
v2 = set(v1)
print(v2) # 输出{"苍","井","空"}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # 输出{11,22,3}

v1 = {"age":12, "status":True,"name":"苍井空"}
print( set(v1.keys()) )     # 输出：{'age', 'name', 'status'}
print( set(v1.values()) )    # 输出：{True, 12, '苍井空'}
print( set(v1.items()) )    # 输出：{('status', True), ('name', '苍井空'), ('age', 12)}

7.4 其他

索引/切片/步长
集合中没有提供索引/切片/步长这些功能，因为他无需，所以无法使用索引操作。

获取集合长度

v = {"柚木提娜", "波多野结衣", "天海翼"}
data = len(v)
print(data)

for循环

v = {"柚木提娜", "波多野结衣", "天海翼"}
for item in v:
    print(item)

8. 小结

数据类型	是否有序	是否可变类型
列表[]	有序	可变类型
元组(,)	有序	不可变类型
字典{}	无序	key不可变，value可变
集合{}	无序	可变类型（不重复）

莫奇2513

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python全栈笔记（七）

5. 元组(tuple)元组也是一个容器，里面可以存放各种数据（和列表相似），但他有一个特殊的特点：元组的儿子元素不允许添加、不允许修改、不允许删除，只能读。tuple写在小括号里，元素之间用逗号隔开。元组的元素不可变，但可以包含可变对象，如list一般用于存储一些在程序中不应该被修改的一系列值。5.1 元组的定义v1 = (11,22,33,)v2 = ("Jesse","Alex",)v3 = ("Jesse",)注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。定义一个
复制链接

扫一扫