目录
学习Python(5)排序&tuple元组&dict字典&set集合
排序
冒泡排序
排序思路：比较两个相邻下标对应的元素，如果以升序为例的话，则最大值出现在最右边
原理:
[9,7,6,8,5,4,3,2,1]
第1次(i=0, j=9-i-1) [9,7,6,8,5,4,3,2,1] => [7,6,8,5,4,3,2,1, 9]
第2次(i=1, j=9-i-1) [7,6,8,5,4,3,2,1, 9] => [6,7,5,4,3,2,1, 8,9]
第3次(i=2, j=9-i-1) [6,7,5,4,3,2,1, 8,9] => [6,5,4,3,2,1, 7,8,9]
第4次(i=3, j=9-i-1) [6,5,4,3,2,1, 7,8,9] => [5,4,3,2,1, 6,7,8,9]
第5次(i=4, j=9-i-1) [5,4,3,2,1, 6,7,8,9] => [4,3,2,1, 5,6,7,8,9]
第6次(i=5, j=9-i-1) [4,3,2,1, 5,6,7,8,9] => [3,2,1, 4,5,6,7,8,9]
第7次(i=6, j=9-i-1) [3,2,1, 4,5,6,7,8,9] => [2,1, 3,4,5,6,7,8,9]
第8次(i=7, j=9-i-1) [2,1, 3,4,5,6,7,8,9] => [1, 2,3,4,5,6,7,8,9]
代码说明：
nums = [9,7,6,8,5,4,3,2,1]
for i in range(len(nums)-1): # i=0,1,2,3,4,5,6,7
for j in range(len(nums)-1-i):
if nums[j] > nums[j+1]:
nums[j], nums[j+1] = nums[j+1], nums[j]
print(nums)
选择排序
排序思路：固定一个下标，然后拿这个下标对应的元素和其他的元素依次进行比较，最小值出现在最左边
原理:
[9,7,6,8,5,4,3,2,1]
第1次(i=0) [9,7,6,8,5,4,3,2,1] => [1, 7,6,8,5,4,3,2,9]
第2次(i=1) [1, 7,6,8,5,4,3,2,9] => [1,2, 6,8,5,4,3,7,9]
第3次(i=2) [1,2, 6,8,5,4,3,7,9] => [1,2,3, 8,5,4,6,7,9]
第4次(i=3) [1,2,3, 8,5,4,6,7,9] => [1,2,3,4, 5,8,6,7,9]
第5次(i=4) [1,2,3,4, 5,8,6,7,9] => [1,2,3,4,5, 8,6,7,9]
第6次(i=5) [1,2,3,4,5, 8,6,7,9] => [1,2,3,4,5,6, 8,7,9]
第7次(i=6) [1,2,3,4,5,6, 8,7,9] => [1,2,3,4,5,6,7, 8,9]
第8次(i=7) [1,2,3,4,5,6,7, 8,9] => [1,2,3,4,5,6,7,8, 9]
代码说明：
nums = [9,7,6,8,5,4,3,2,1]
for i in range(len(nums)-1): # i=0,1,2,3,4,5,6,7
# 求剩下数中最小数的下标
min_index = i
for j in range(i, len(nums)):
if nums[j] < nums[min_index]:
min_index = j
# 用最小数和第i个元素交换
nums[i], nums[min_index] = nums[min_index], nums[i]
print(nums)
元组
和列表相似，本质上是一种有序的集合
元组和列表的不同之处：
列表:[ ] 元组：( )
列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】
创建元组
创建空元组：tuple1 = ( )
创建有元素的元组：tuple1 = (元素1，元素2，。。。。)
代码展示：
t = () # 空元组
t = (1,) # 包含1个元素的元组
t = (1, 2, 3, "hello", True)
print(t, type(t))
元组元素的访问
元组元素的访问
#格式：元组名[索引],和列表完全相同
tuple1 = (10,20,30,40,50)
获取元素值
print(tuple1[2])
获取元组中的最后一个元素
print(tuple1[4])
正数表示从前往后获取，负数表示从后往前获取
print(tuple1[-1])
print(tuple1[-2])
print(tuple1[-5])
修改元素值
#不能修改，本质原因不能修改元素的地址
#和列表不同的地方：元组的元素值不能随意的更改
#tuple1[1] = 100
tuple2 = (1,35,54,[4,5,6])
获取元组中列表中的元素
print(tuple2) #(1, 35, 54, [4, 5, 6])
tuple2[3][1] = 50
print(tuple2) #(1, 35, 54, [4, 50, 6])
删除元组
tuple3 = (53,6,7,76)
del tuple3
元组操作
合并
print((1,2) + (3,4)) # (1, 2, 3, 4)
重复
print((1,2,3) * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)
长度
print(len(t))
成员
print(33 in t)
元组截取【切片】
t = (1,2,3,4,5,6)
print(t[2:5])
print(t[::-1])
元组功能
获取元组的元素个数
tuple1 = (54,3,5,46,56)
print(len(tuple1))
#2.获取元组中元素的最大值和最小值
print(max(tuple1))
print(min(tuple1))
元组和列表之间的相互转换:取长补短
print(list( (1,2,3) )) # [1, 2, 3]
print(tuple( [1,2,3] )) # (1, 2, 3)
排序
t = (3, 2, 7, 1, 9)
t2 = sorted(t) # 升序
t2 = sorted(t, reverse=True) # 降序
print(t2)
t = (3, 2, 7, 1, 9)
t2 = reversed(t)
print(list(t2))
元组列表可以快速取值
x, y = (2, 3)
x, y = [2, 3]
print(x, y)
遍历
t = (11, 22, 33)
for n in t:
print(n) # 元素
for i in range(len(t)):
print(i) # 下标
for i,n in enumerate(t):
print(i, n)
二维元组
当做一维元组进行处理，实质：一维元组中的元素为一个一维元组
代码展示：
tuple1 = ((2,43,5),(54,65,6),(5,54,54,54))
print(tuple1[1][1])
遍历二维列表或者二维元组的思路：嵌套循环
代码展示：
#遍历外层元组
for element in tuple1:
#遍历内层元组
for num in elment:
print(num)
字典
字典dict
1. 里面的元素是一个键值对: key-value
2. key有3个特点:
a.唯一
b.不可变类型
c.无序(没有下标)
列表和字典的区别:
list:
1. 定义方式: [], 一般存放相同类型的数据
2. 内存相对字典较小
3. 数据量较大时, 查找所需时间越久
dict:
1. 定义方式: {}, 一般存放同一个事物的不同属性
2. 内存消耗较大
3. 数据量不管多少, 对查询速度影响不大
创建字典
字典名 = {key1:value1,key2:value2…}
方式一：
d = {"name": "蔡徐坤", "age": 22, "height": 184}
# d = {0: 1, 1: 2, 1:3}
print(d)
方式二
dict(key=value),key是一个变量名，value是一个值
dict22 = dict(a="avvv",b="2353")
print(dict22)
dict22 = dict(a=200,b=33)
print(dict22)
方式三
ict()和zip(序列),zip表示映射
dict(zip([key1,key2,key3…],[value1,value2,value3…]))
注意：key的数量和value的数量可以不一致，以少的作为参考
z1 = zip([1,2],["a","b","c"])
dict23 = dict(z1)
print(dict23)
dict23 = dict(zip(("name","age"),("aaa",10)))
print(dict23)
dict23 = dict(zip("xyz","abc"))
print(dict23)
方式四
[(key1,value1), (key2,value2)…] => {key1:value1, key2:value2…}
dict24 = dict([("a",10),("b",20),("c",30)])
print(dict24)
字典操作
遍历字典
d = {"name": "蔡徐坤", "age": 22, "height": 184}
for k in d:
print(k) # key
# for k in d.keys():
# print(k) # key
for v in d.values():
print(v) # value
for k, v in d.items():
print(k, v) # key value
k = d.keys()
print(k, list(k))
# dict_keys(['name', 'age', 'height']) ['name', 'age', 'height']
# print(d.values())
合并
# print({1:2} + {3:4}) # 错误
d1 = {1: 2}
d2 = {3: 4}
d1.update(d2)
print(d1) # {1: 2, 3: 4}
长度
print(len(d))
成员: 判断的是key是否在字典中存在
print('name' in d)
字典功能
增
d['sex'] = "男"
print(d) # {'name': '蔡徐坤', 'age': 22, 'height': 184, 'sex': '男'}
删
d = {"name": "蔡徐坤", "age": 22, "height": 184}
d.pop('age') # 删除指定key的元素
# d.clear() # 清空字典
# d.popitem() # 删除最后一项,可以认为是随机删除一项, 了解
# del d['age']
print(d)
改
d = {"name": "蔡徐坤", "age": 22, "height": 184}
d['age'] = 30
print(d) # {'name': '蔡徐坤', 'age': 30, 'height': 184, 'sex': '男'}
查
通过key来查value
print(d['name'])
print(d.get('name'))
# print(d['sex']) # 报错,没有key则报错
print(d.get('sex')) # 没有key不报错,但是返回None
print(d.get('sex', "男")) # 没有key不报错,返回默认值
key = "name"
print(d[key])
print(d.get(key))
集合
和数学上的集合基本是一样的，
特点:
不允许有重复元素，可以进行交集，并集，差集的运算
本质：
无序，无重复元素的集合
集合 set
set(列表或者元组或者字典)
1. 无序
2. 唯一: 不能重复
创建集合
s = {1, 2, 2, 2, 3, 4}
print(s) # {1, 2, 3, 4}
s = set()
print(s) # set() 空集合
类型转换
# int()
# float()
# str()
# list()
# tuple()
# dict()
# set()
l = [1,2,3]
l = (1,2,3)
l = "123"
l = {1:2, 2:3, 3:4} # 只取key
print(set(l))
列表去重
l = [1, 2, 4, 4, 4, 3, 3, 2, 2, 1, 6, 7, 6]
l2 = list(set(l))
print(l2) # [1, 2, 3, 4, 6, 7]
集合操作
遍历集合
s = {11, 22, 33}
for n in s:
print(n)
注意：
set是没有索引的，所以不能通过s4[2]获取元素，
原因：set是无序的
#print(s4[2])
长度
print(len(s))
集合之间关系
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 & s2) # 交集; {3, 4}
print(s1 | s2) # 并集; {1, 2, 3, 4, 5, 6}
print(s1 - s2) # 差集; {1, 2}
print(s1 ^ s2) # 对称差集; {1, 2, 5, 6}
print(s1 > s2) # s1包含s2; False
print(s1 < s2) # s2包含s1; False