Python学习笔记 5.0 元组 与 字典 与 集合 与 公共操作 与 推导式

元组

如果想要存储多个数据，但是这些数据是不能修改的数据，怎么办？
答：列表可以一次性存储多个数据，但是列表中的数据允许修改
一个元组可以存储多个数据，元组内的数据是不能修改的。

一、定义元组

元组的特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型

t = (1)
print(t)			# 1
print(type(t))		# <class 'int'>

t = (1,)
print(t)			#(1,)
print(type(t))		# <class 'tuple'>

二、元组的常见操作

元组数据不支持修改，只支持查找，具体如下：
1、按下标查找数据：

2、index():查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index()方法相同。

3、count():统计某个数据在当前元组出现的次数。

三、元组数据的修改操作

注意：元组内的直接数据如果修改则立即报错

但是如果元组里面有列表，修改列表里面的数据则是支持的

t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2])		# ['cc', 'dd']
print(t2[2][0])		# cc
t2[2][0] = 'TOM'
print(t2[2])		# ['TOM', 'dd']

字典

思考1：如果有多个数据，例如：’Tom’, ‘男’, ‘20’，如何快速储存？
答：列表 list1 = [‘Tom’, ‘男’, 20]
思考2：如何查找到数据’Tom’
答：查找到下标为0的数据即可。list1[0]
思考3：如果将来数据顺序发生改变，如下所示，还能用list[0]访问到数据’Tom’吗？
list1 = [‘男’, 20, ‘Tom’]
答：不能，数据’Tom’此时下标为2.
思考4：数据顺序发生改变，每个数据的下标也会随之改变，如何保证数据顺序变化前后能使用同一的标准查找数据呢？
答：字典，字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。

创建字典的语法

注意：一般冒号前面的为键(key) 简称k；冒号后面的为值(value)，简称v。

字典的常见操作

1.增

写法：字典序列[key] = 值
注意，如果key存在则修改这个key 对应的值；如果key不存在则新增此键值对。

注意：字典为可变类型。

2.删

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# del 删除字典或指定的键值对
del(dict1)
print(dict1)

字典dict1已经被删除了

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['name']
print(dict1)		# {'age': 20, 'gender': '男'}
# 删除了键值对'name': 'Tom'以及中间的连接字符  ，

del dict1['names']
print(dict1)	
# 如果k不存在，便报错	
dict1.clear()		# clear():清空字典
print(dict1)        #{}

3.改

写法：字典序列[key] = 值
注意： 如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1['name'] = 'lily'
print(dict1)			# {'name': 'lily', 'age': 20, 'gender': '男'}

4. 查

key值查找

如果当前查找的key存在，则返回对应的值；否则则报错。

get()

语法:
字典序列.get(key, 默认值)
注意：如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数，则返回
None。

# 2.2 keys()        # 查找字典中所有的key，返回可迭代带向
print(dict1.keys())


# 2.3 values()        查找字典中的所有的value，返回课迭代对象
print(dict1.values())
# 2.4 items()          
# 查找字典中所有的键值对，返回可迭代对象，里面的数据是元组，元组数据1是字典的key，元组数据2是字典的值
print(dict1.items())

字典的循环遍历

遍历字典的key(利用for)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key in dict1.keys():
    print(key)
# name  age  gender

遍历字典的value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value in dict1.values():
    print(value)
# Tom  20  男

遍历字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for item in dict1.items():
    print(item)

遍历字典的键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value, key in dict1.items():
    print(f'{value} = {key}')

集合

一、创建集合

集合是可变类型
创建集合使用{} 或set(),但是如果要创造空集合之鞥你使用set()，因为{}用来创造空字典。

s1 = {10, 20, 30, 40, 50}
print(s1)
# {40, 10, 50, 20, 30}
# 集合没有顺序，所以没有下标操作

# 重复数据
s2 = {10, 10, 20, 30, 40}
print(s2)
# {40, 10, 20, 30}
# 自动去除重复数据

s3 = set('abcdefg')
print(s3)				# {'g', 'e', 'd', 'a', 'b', 'f', 'c'}
s4 = set('123456')
print(s4)				# {'2', '5', '1', '3', '4', '6'}
# 使用set（）创建集合，会使（）中的字符串自动分开。
# 123456必须要带上‘ ’，否则会报错，说明了set（）函数内部只允许输入字符串

# 创造空集合只能使用set函数：
s6 = set()
s7 = {}
print(type(s6))			# <class 'set'>
print(type(s7))			# <class 'dict'>

集合没有顺序，所以没有下标操作

二、 集合常见操作方法

增加数据：add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)
# {100， 10， 20}
# 集合有去重功能，所以）并不会执行 s1.add（10） 此操作
# 此外，add函数不能增加序列否则会报错。

增加序列 update():追加的数据是序列。

s1.update([10, 20, 30, 40])
print(s1)
#{40， 10， 20， 30}

错误注意！
s1.update(100)
print(s1)

update(中只能存储序列)

a = [11]
s1.update(a)
print(s1)

# 如果是以字母进行输入会自动辨识为变量名，要求你提前定义，如上图a = [11]

remove():删除集合中的指定数据，如果数据不存在则报错。

ss = {10, 20, 30, 40, 50}

# remove(): 删除指定数据，如果数据不存在报错
ss.remove(10)
print(ss)
ss.remove(10)		# error
print(ss)

第一次print正常输出，第二次由于集合当中再也没有10这个元素了所以报错。

discard():删除集合中的指定数据，如果数据不存在也不会报错。

# discard(): 删除指定数据，如果数据不存在不报错
ss.discard(10)
print(ss)			# {40, 50, 20, 30}
ss.discard(10)
print(ss)			# {40, 50, 20, 30}

pop():随机删除集合中的某个数据，并返回这个数据。

（可以设立一个新的变量接受被删除的值）

del_num = ss.pop()
print(del_num)		 # 40
print(ss)			# {10, 50, 20, 30}

查找数据

in :判断数据在集合序列
not in:判断数据不在集合序列

sz = {10, 20, 30, 40, 50}
print(10 in sz)			#Ture

print(10 not in sz)		#False

公共操作

一、运算符

str1 = 'aa'
str2 = 'bb'

list1 = [1,2]
list2 = [3,4]

s1 = (1,2)
s2 = (3,4)

dict1 = {'name':'Tom'}
dict2 = {'age': 18}

# +:合并
print(str1+str2)
print(list1 + list2)
print(s1 + s2)
print(dict1 + dict2)

字典不支持 + 运算符 所以报错

print(str1 * 5)
print('-' * 10)
print(list1 * 5)
print(s1 * 5)

类似的，字典也不支持*运算符
in:
not in:

print('a' in str1)					# True
print('a' not in str1)				# False
print(1 in list1)					# True
print(1 not in list1)				# False
print(dict1.keys())					# dict_keys(['name'])	
print('name' in dict1.keys())		# True
print('name' in dict1.values())		# False

二、公共方法

len(), del

str1 = 'abcdefg'
lsst = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {'name': 'tom', 'age': 18}
# len()的使用
print(len(str1))	# 7
print(len(lsst))	# 5
del lsst[0]
print(lsst)
del lsst
print(lsst)

报错原因：del函数删除lsst之后，lsst列表消失了，print无法找到lsst列表，print要求重新定义一个lsst列表

min() 和 max()

str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]

# max()
print(f'{max(str1)}')		# g
print(max(list1))			# 50

# min()
print(min(str1))			# a
print(min(list1))			# 10

range()

range(start,end,step)的使用:生成从start到end的数字，步长为step，供for循环使用
注意：range的使用方法和切片一样，左闭右开，即取得到start的数字取不到end的数字
默认步长为1，默认start为0；

for i in range(1, 10, 1):
    print(i, end=' ')			# 1 2 3 4 5 6 7 8 9
print()
for i in range(1, 10, 2):
    print(i, end=' ')			# 1 3 5 7 9
print()
for i in range(10):
    print(i, end=' ')			# 0 1 2 3 4 5 6 7 8 9
print()

enumerate()

语法
enumerate(可遍历对象, start = 0)
注意： start参数用来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
# enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
    print(i)

for i in enumerate(list1, start=1):
    print(i)

for index,char in enumerate(list1):
    print(f'下标为{index}，对应的字符为{char}')

三、 容器类型转换

# tuple():将某个序列转换成元组
# list():将某个序列转换成列表
# set():将某个序列转换成集合
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
t1 =('a', 'b', 'c', 'd', 'e')
print(tuple(list1))
print(tuple(s1))
print(list(s1))
print(list(t1))
print(set(list1))
print(set(t1))

注意：1.集合可以快速完成列表去重
2.集合不支持下标

推导式

一、列表推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。

需求： 创建一个0-10的列表。

# While循环实现：
# 需求：0， 1， 2， 3, 4 ...
# 1.循环实现； 2.列表推导式（化简代码：创建或控制有规律的列表）
"""
1. 创建空列表
2. 循环将有规律的数据写入到列表

"""
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# for 循环实现-----
list1 = []
for i in range(10):
    list1.append(i)
print(list1) 		#同样的结果

# 列表推导式实现   放在中括号里表示的是列表推导式  在列表推导式里面读与写都从for循环开始
# 第一个i：i是整个列表推导式 列表里面要返回的数据 第二个i：是range10里面从0开始的到9为止的数

list1 = [i for i in range(10)]
print(list1)		#同样的结果

带if的列表推导式

需求：创建0-10的偶数列表

# 方法1：range()步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)
# [0, 2, 4, 6, 8]

# 方法2：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0, 2, 4, 6, 8]

多个 for循环实现列表推导式

需求：创建列表如下：
[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]

listt = []
for i in range(1, 3):
    for j in range(3):
        # 列表里面追加元组： 循环前准备一个空列表，然后这里追加元组数据到列表
        listt.append((i,j))
print(listt)



list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
# 多for 的列表推导式等同于for循环嵌套

二、字典推导式

思考：如果有如下两个列表：
list1 = [‘name’, ‘age’, ‘gender’]
list2 = [‘Tom’, 20, ‘man’]
如何快速合并为一个字典？
字典推导式作用： 快速合并列表为字典或提取字典中目标数据。

# 1.	创建一个字典：字典key是1-5数字，value是这个数字的2次方。
dict1 = {i: i**2 for i in range(1, 5) }
print(dict1)		#{1: 1, 2: 4, 3: 9, 4: 16}
# 2.	将两个列表 合并成为一个字典
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)		#{'name': 'Tom', 'age': 20, 'gender': 'man'}
# 3. 提取字典中目标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in counts.items() if value >= 200}
print(counts.items())
print(count1)
# dict_items([('MBP', 268), ('HP', 125), ('DELL', 201), ('Lenovo', 199), ('acer', 99)])
# {'MBP': 268, 'DELL': 201}

总结：

1. 如果两个列表数据个数相同，len统计任何一个列表的长度都可以
2. 如果两个列表数据个数不同，len统计数居多的列表数据个数会报错；len统计数据少的列表数据个数不会报错

三、集合推导式

需求：创建一个集合，数据为下方列表的2次方。
list = {1, 1, 2}

list1 = {1, 1, 2}
set1 = {i ** 2 for i in list1}
print(set1)				#{1, 4}

注意：集合有数据去重功能。