《小白初识python之第五章列表排序、元组、字典查询》

目录

一、成员运算

二、排序

 三、内置函数的使用

四、元组 tuple=（）

五、字典 dict{'key1':'val1','key2':'val2'}

六、深拷贝浅拷贝

---

 

---

一、成员运算

1.in

2.not in 

返回布尔值：True  False

list = [1,2,3]
print(2 in list) #元素2在列表中存在返回True
print(2 not in list) #元素2在列表中存在，not in是判断不存在的，所以返回False

二、排序

1.排序原理：通过ASCII码来排序

2.排序常用方法： list.sort(reverse= True) 、new_list =  sorted(list,reverse=True) 

reverse参数不写默认，正序排序；reverse传参为True，则进行倒叙排序

sort():不会生成行的列表，在原有列表的基础上进行排序

sorted() :会生成行的列表，不会修改原有列表

3.反序(反转列表)  list.reverse()

# 通过ASCII码值，获取对应的字符
print(chr(97))
# 通过字符，获取对应的ASCII码
print(ord('a'))

# sort()
list1 = ['a', 'c', 'b']
list2 = [1, 2, 3, 2, 2, 5, 4, 9, 7]
list1.sort()  # 正序
print(list1)
list2.sort()  # 正序
print(list2)
list1.sort(reverse=True)  # 倒序
print(list1)
list2.sort(reverse=True)  # 倒序
print(list2)

# sorted()
list3 = [11, 21, 13, 22, 42, 55, 47, 89, 97]
new_list3 = sorted(list3)  # 正序
print(new_list3)
new_list4 = sorted(list3, reverse=True)  # 倒序
print(new_list4)

# reverse()
list3.reverse() #只把元素进行倒叙排列 不进行排序
print(list3)

 三、内置函数的使用

1.max()  

2. min()

3.sum()

4.len()

list3 = [11, 21, 13, 22, 42, 55, 47, 89, 97]
print(max(list3))  # 返回最列表最大值
print(min(list3))  # 返回列表最小值
print(sum(list3))  # 返回列表总和
print(len(list3))  # 返回列表长度

四、元组 tuple=（）

1.元组特点：

 1、元素不可修改

 2、元素内容可以重复

3、如果元组里面只有一个元素，必须加逗号(,)，否则类型就不是元组了

获取：通过索引 切片：同列表

2.元组分类：

  1、可变元组：元素包含了可变类型,实际上修改的是元素可变类型

   2、不可变元组：元素为不可变类型

#修改操作:实际是修改的元组里面可变元素的数据
tuple_1 = (1, 2, 3, ['a', 'c', 1])
tuple_1[3].append('d')
print(tuple_1)

list_1 = [11, 21, 'python']
tuple_1[3].extend(list)
print(tuple_1)

3.元组的常用方法：

max() 、min() 、len()

set()： 去重元组、列表，返回的是集合，需要进行类型强制转换

tuple_1 = (1, 2, 2, 3, 3, 4, 4, 5)

print(max(tuple_1))  # 输出元组最大值
print(min(tuple_1))  # 输出元组最小值
print(sum(tuple_1))  # 输出元组总和
print(len(tuple_1))  # 输出元组长度

# set()
res = set(tuple_1)
print(type(res))
print(res)  # 输出的为集合类型
print(tuple(res))  # 把集合类型强制转换为元组类型

五、字典 dict{'key1':'val1','key2':'val2'}

1.元组特性：

  1、通过键值对来表示元素

  2、key不能重复且不可修改，如果重复认为是同一个元素，输出最后一个键对应应得值

2.创建字典：

  1.dict_1={'key1':'val1','key2':'val2'}

  2.dict_2=dict(a=2,b=1)

  3.dict.fromkeys(list1,list2)

  4.zip()

dict_2 = dict(a=2, b=1)
print(dict_2)

list1 = ['a', 'b', 'c']  # key
list2 = [1, 2, 3]  # val
res = dict.fromkeys(list1, list2)
print(res)

#zip()
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped1 = zip(a, b)  # key = valu
zipped2 = zip(a, c)  # key<valu
zipped3 = zip(c, a)  # key>valu
print(dict(zipped1))
print(dict(zipped2))
print(dict(zipped3))

zipped11 = zip(*zipped1)  # 解压缩
print(zipped11)

3.字典操作

  1、增

      dict_1={key:val,key2:val}

  2、删（通过key）

      1、del dict_1['key1']

      2、dict.pop('key1') 返回被删除key的value

      3、dict.popitems()  ： 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。

            如果字典已经为空，却调用了此方法，就报出KeyError异常返回被删除元素的(key,val)

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name']  # 删除键 'Name'
print("dict['Age']: ", dict)

dict.clear()  # 清空字典
print("dict: ", dict)

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict1  # 删除字典
print("dict1: ", dict1)  # 会引发一个异常，因为用执行 del 操作后字典不再存在

dict2 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
new_dict2 = dict2.pop('Name')
print(new_dict2)  # 返回被删除的值
print("dict2:", dict2)

new1_dict2 = dict2.popitem()  # 删除最后一组数据
print(new1_dict2)  # 返回被删除的键值对
print(dict2)

  3、改(重点)

      1、dict_1['key1']='8888' 如果修改的Key不存在，那么会自动新增一个键值对

      2、dict_1.setdefault('key','value') key存在不做任何操作，key不存在就新增键值对

      3、dict_1.update(dict_2) （了解） 将dict_2合并到dict_1，key存在直接覆盖value的值，key不存在就直接添加到dict_1

dict = {'Name': 'Python', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8  # 更新 Age
dict['School'] = "小白学院"  # 添加信息

print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
print(dict)
print('-' * 100)  # 分割线
# dict.setdefault('sex', '男')
dict.setdefault('Age', '12')  # key存在 不作任何修改
print("key存在 dict:", dict)
dict.setdefault('sex', '男')  # key不存在 进行新增操作
print("key不存在的dict", dict)
# dict.update(dict1)
dict1 = {'Name': 'xiaoming', 'dress': 'shanghai'}
dict.update(dict1)#存在KEY就变更值，不存在KEY就新增
print(dict)

  4、查

通过key 获取val

1、dict_1 = {'key1': 'val1', 'key2': 'val2'}

result = dict_1['key1']

2、result2 = dict_1.get('key3', 'val3')

print(result2)

当key3不存在的时候返回val3，如果存在直接返回对应value的值

3、dict.keys() ：获取字典的key

4、dict.values() :获取字典的value

# dict_1.keys()
dict_1 = {'key1': 'val1', 'key2': 'val2'}
keys = dict_1.keys()
print(type(keys))
print(keys) # 输出字典的所有的KEY

# dict_1.values()
dict_1 = {'key1': 'val1', 'key2': 'val2'}
val1 = dict_1.values()
print(type(val1))
print(val1) # 输出字典所有的valu

六、深拷贝浅拷贝

• 直接赋值：其实就是对象的引用（别名）。

• 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

• 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象

# 字典浅拷贝
a = {1: [1, 2, 3]}
b = a.copy()
print('字典a:', a)
print('字典b:', b)
a[1].append(4)
print('字典a:', a)
print('字典b:', b)
print('*' * 50)  # 分割线
# 字典深拷贝
import copy

c = copy.deepcopy(a)
print('字典a', a)
print('字典c', c)
a[1].append(5)
print('字典a', a)
print('字典c:', c)