前言回顾
1. 列表(list)
容器型数据类型(序列),可变、有序
2. 元素
任何python类型的数据都可以作为列表元素
3. 元素的增删改查
1. 查
查单个元素：列表[下标]
查部分元素(切片)：列表[开始下标:结束下标:步长]，列表[:]，列表[::-1]
遍历：直接遍历、遍历下标
2. 增
列表.append(元素)、列表.insert(下标、元素)
3. 删
del 列表[下标]
列表.remove(元素) 不能删除不存在的元素；多个元素相同，只会删除第一个
列表.pop() 列表.pop(下标)
4. 改
列表[下标] = 新值
4. +, *, ==, !=, in/not in, len(), list(序列), max/min
+ : 列表拼接
* : 列表重复多次
== :列表相等，元素和顺序都相同
!= :列表不等
in/not in : 判断某个[元素]是否在列表中
5. 列表常用方法
- count
列表.count(元素) - 统计列表中指定元素的个数，返回一个整数
nums = [1, 34, 1, 6, 8, 1]
print(nums.count(1))
- extend
列表.extend(序列) - 将序列的元素全部添加到列表中
nums.extend('abc')
print(nums)
nums.extend([100, 'abc', 'name'])
print(nums)
- index
列表.index(元素) - 获取指定元素在列表中出现的[第一个]下标
注意：元素不存在会报错！
nums = [100, 60, 34, 100]
print(nums.index(100))
4. reverse
列表.reverse() - 反向列表 (对原列表进行修改，不会产生新的列表)
reversed(序列) - 反向序列 (不修改原序列，而是产生新的序列(迭代器)，即有返回值)
序列(seq) -- 要转换的序列，可以是 tuple, string, list 或 range
nums = [100, 60, 34, 100]
nums.reverse()
print(nums)
nums = [100, 60, 34, 100]
new_nums = reversed(nums)
print(nums, list(new_nums))
str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.join(list(new_str)))
# 字符串.join(序列) 将序列用前面的字符串拼接起来，并返回拼接了的字符串
- sort
列表.sort() - 将列表中的元素升序排序(从小到大)
列表.sort(reverse=True) - 将列表中的元素降序排序(从大到小)
sorted(序列) - 排序的时候不修改原序列，产生新的序列
注意：能够进行排序的列表要求列表中的元素类型一致，并且支持比较运算！！
nums = [100, 60, 34, 101]
# nums.sort()
nums.sort(reverse=True)
print(nums)
nums = [100, 60, 34, 101]
new_nums = sorted(nums) # 从小到大排序
print(nums) # [100, 60, 34, 101]
print(new_nums) # [34, 60, 100, 101]
str2 = 'helloworld'
new_str = sorted(str2)
print(new_str) # ['d', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str)) # dehllloorw
- clear
列表.clear() - 删除列表中所有的元素(清空列表)
nums = [100, 60, 34, 101]
nums.clear()
# nums = []
print(nums, id(nums)) # id 获取对象的内存空间地址
# 区别：clear是清空容器；[]是销毁原空间，再开辟一个新的空间
- copy
列表.copy() - 相当于列表[:],将列表中的元素拷贝一份产生一个新的列表 (浅拷贝)
产生一个新的列表，两个列表空间地址不同，对某一个列表进行元素操作不会相互影响
nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))
作业
选讲前一天的作业，括号里面为前一天的标题序号
1(5).已知一个数字列表，将所有元素乘二。
例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]
nums = [1, 2, 3, 4]
for index in range(len(nums)):
nums[index] *= 2
print(nums)
2(6).有一个长度是10的列表，数组内有10个人名，要求去掉重复的
例如:names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']
方法一：
names = ['张三', '李四', '大黄', '张三', '二狗', '将军', '爵爷', '花生', '警长', '二狗']
new_names = []
for name in names:
if name not in new_names:
new_names.append(name)
print(new_names)
方法二：
names = ['张三', '李四', '大黄', '张三', '二狗', '将军', '爵爷', '花生', '警长', '二狗']
for name in names[:]:
if names.count(name) > 1:
names.remove(name)
print(names)
3(8).用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)
list1 = [9.2, 9.0, 7.8, 8.8, 7.6, 9.4]
avge = (sum(list1) - max(list1) - min(list1))/(len(list1) - 2)
print(avge)
4(9).有两个列表A和B，使用列表C来获取两个列表中公共的元素
例如: A = [1, 'a', 4, 90] B = ['a', 8, 'j', 1] --> C = [1, 'a']
A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for i in A:
for j in B:
if i == j:
C.append(i)
print(C)
5(10).有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)
例如: nums = [19, 89, 90, 600, 1] —> 600
nums = [19, 89, 90, 600, 1]
max1 = nums[0]
for item in nums[1:]:
if max1 < item:
max1 = item
print(max1)
6(11).获取列表中出现次数最多的元素
例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3
nums = [1, 2, 3, 1, 4, 2, 1, 3, 7, 3, 3]
max_count = 0 # 保存最大个数
num = None # 最大个数对应的元素，None - 空值
for item in nums:
count = nums.count(item)
if count > max_count:
max_count = count
num = item
print('出现次数最多的元素:%d, 次数是:%d' % (num, max_count))
元组
1.什么是元组(tuple)
元组是python提供的容器型数据类型(序列)，不可变(特色)，有序
元组就是不可变的列表，一般保存一些不让修改的数据
(元素1, 元素2, 元素3...)
除了不可变(即增删改)以外，其他和list列表差不多
2.元素
空的元组(没有意义)
tuple1 = ()
print(tuple1, type(tuple1))
- 元素个数是1的元组：如果一个元组中只有一个元素，这个元素后面必须加逗号！
tuple2 = (10,) # 若不加逗号，tuple2 = (10)， 输出 type(tuple2) -> <class 'int'>
print(tuple2, type(tuple2))
- 元组数据中小括号可以省略 (多个数据直接用逗号隔开，表示的是一个元组)
tuple3 = 10, 23, 89, 12, '小明'
print(tuple3, type(tuple3))
3.获取元素：和列表一样
tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2)
print(tuple2[1])
print(tuple2[2:])
for item in tuple2:
print(item)
- 让变量的个数和元组中元素的个数保持一致(必须一致)，来一一获取元组中每个元素的值
point = (100, 50)
x, y = point
print('x:', x, 'y:', y)
a, b, c = 10, 20, 30 # 实质就是：a, b, c = (10, 20, 30)
- 让多个变量同时获取元组中的元素的时候，可以在一个变量前加*将这个变量变成一个列表，来获取不带*的变量获取后剩下的数据。(注意，带*的变量只能有一个)
和不定长参数不一样,带*的变量可以放在中间
student = ('小明', 18, 89, 68, 89, 90) # 带*的只能有一个
name, age, *scores = student
print(name, age, scores)
name, *scores, age, a = student
print(name, age, scores, a)
*items, a, b = student
print(items, a, b)
# 容器前面加*，表示获取这个容器中的全部元素
tuple4 = (10, 20)
print(*tuple4) # print(10, 20)
容器前面加*，表示获取这个容器中的全部元素
字典
用一个变量保存一个学生的信息
student = {'name': '小明', 'age': 18, 'gender': '男', 'score': 59}
print(student['name'])
print(*student)
1.什么是字典(dict)
字典是python提供的容器型数据类型(序列)，可变，无序
2.字典中的元素
{key1: value1, key2: value2...} - 字典的元素就是键值对
key-value(键值对) - 以'键：值'的形式成对出现
键(key) - 要求不可变，唯一(建议用字符串作为key，用来对值进行说明和区分的)
值(value) - 任何类型的数据都可以作为值(python支持的)
dict1 = {10: 100, 'name': 98, (1, 2): 99, 'a': 'abc', 'b': True, 'c': [1, 2],'d': {'a': 2}} # int、str、tuple均是不可变的
print(dict1)
# dict2 = {10: 100, 'name': 98, [1, 2]: 99} # list可变，不能作为key值 TypeError: unhashable type: 'list'
# dict2 = {10: 100, 'name': 98, {'a': 1}: 99} # dict也不能作为key值 TypeError: unhashable type: 'dict'
dict1 = {10: 100, 'name': 100, (1, 2): 100, 10: 200}
print(dict1) # {10: 200, 'name': 100, (1, 2): 100}
3.元素的操作
- 查 - 获取值
1. 字典[key] - 获取字典中key对应的value (如果key不存在会报错！)
2. 字典.get(key) - 获取字典中key对应的value (如果key不存在不报错，结果是None)
字典.get(key, 默认值) - 获取字典中key对应的value (如果key不存在不报错，结果是默认值)
dog = {'name': '旺财' , 'color': '黄色', 'age': 3, 'type': '土狗'}
print(dog['type'])
# print(dog['gender']) # KeyError: 'gender'
print(dog.get('name'))
print(dog.get('gender')) # None
print(dog.get('age', 100))
print(dog.get('gender', '公狗')) # 公狗
key = 'age'
print(dog.get(key))
print(dog[key])
3. 遍历字典
直接通过for循环遍历字典的时候，获取到的是所有的key
1.直接遍历(只用这个，时间复杂度最低！！)
print('===1===')
for key in dog:
print(key, dog[key])
2.间接遍历
print('===2===')
print(dog.values())
for value in dog.values():
print(value)
print('===3===')
print(dog.items())
for key, value in dog.items():
print(key, value)
- 增/改
字典[key] = value - 如果key存在，修改key对应的值；如果key不存在，添加键值对
class1 = {'name': 'py1902', 'address': '19楼5教室'}
print(class1)
# 增
class1['num'] = 50
print(class1)
# 改
class1['name'] = 'python1902'
print(class1)
- 删
1. del 字典[key] - 删除字典中指定key对应的键值对 如果key不存在会报错
2. 字典.pop(key) - 取出字典中key对应的值 如果key不存在会报错
"""
class2 = {'name': 'py1902', 'address': '19楼5教室', 'num': 50}
del class2['num']
print(class2) # {'name': 'py1902', 'address': '19楼5教室'}
name = class2.pop('name')
print(class2, name)
4. 字典相关操作
- 运算符：不支持数学运算,比较运算符只支持比较相等不支持比较大小(因为字典无序)
print({'a': 100, 'b': 10} == {'b': 10, 'a': 100}) # True 因为无序
- in /not in
key in 字典 - 判断字典中是否存在指定的key
class2 = {'name': 'py1902', 'address': '19楼5教室', 'num': 50}
print('name' in class2) # True
print(50 not in class2) # True
- len - 键值对的个数
print(len(class2))
- dict
能转换成字典的数据要求：数据本身是序列，序列中的每个元素长度是2的序列，
并且小序列中的第一个元素是不可变的
data = [(1, 2), ['a', 23]]
print(dict(data))
dict2 = {'a': 10, 'b': 20}
print(list(dict2)) # ['a', 'b']
5.相关方法
- clear
字典.clear() - 清空字典
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2) # {}
- copy
字典.copy() - 拷贝字典中的键值对产生一个新的字典
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 20, 'b': 20} 直接赋值会有影响 (共享空间地址)
dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}
- fromkeys
dict.fromkeys(序列， 值) - 创建一个新的字典，字典的key是序列的元素， key对应的value是值
new_dict = dict.fromkeys('hello', 100)
print(new_dict)
- keys, values, items
字典.keys() - 获取字典中所有的key，结果是一个序列
字典.values() - 获取字典中所有的value，结果是一个序列
字典.items() - 获取字典中的key和value，key和value以元祖的形式返回
students = {'name': '张三', 'age': 18, 'stu_id': 'stu001', 'gender': '女'}
print(students.keys())
print(students.values())
print(students.items())
- setdefault
字典.setdefault(key, value) - 添加键值对(不能修改)
students.setdefault('tel', '15300022233')
print(students)
- update
字典1.update(字典2) - 使用字典2中的键值对去更新字典1(不存在就添加、存在就修改)
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2)
print(dict1) # {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}
集合
1.什么是集合(set)
容器型数据类型(序列)，可变、无序
2.集合中的元素
{元素1, 元素2, 元素3...}
元素：不可变，唯一(自带去重功能)
！！注意：{}不能表示空的集合，set() - 空集合
set1 = set() # set 空集合表示方法
set2 = {1, 'abc', (1, 3), False} # {False, 1, (1, 3), 'abc'}
# True 显示不出来, 因为python中，1 == True；0 == False
# 若是集合中同时存在1 和 True，会输出在前面的那一个；0 和 False同理
print(set2) # {False, (1, 3), 1, 'abc'}
# 集合可以去重
str1 = 'sdfsadfadssw'
print(set(str1))
print(''.join(set(str1)))
list1 = [1, 34, 34, 2, 2]
print(list(set(list1))) # [1, 34, 2]
3.元素相关操作
- 查
集合不能单独获取指定的一个元素，只支持遍历
set3 = {12, 34, 56, 2, 7, 88}
for x in set3:
print(x)
- 增
集合.add() - 往集合中添加一个元素
集合.update(序列) - 将序列中的元素添加到集合中(自带去重)
set1 = {1}
print(set1)
set1.add(100)
print(set1)
set1.update('abc')
print(set1)
set1.update({'name': '张三', 'age': 20})
print(set1)
- 删
集合.remove(元素) - 删除集合中指定的元素
set4 = {1, 100, 'name', 'a', 'age', 'b', 'c'}
set4.remove(100)
print(set4)
(*)4.数学集合运算
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
- 并集： |
集合1 | 集合2 -- 将两个集合中的元素合并产生新的集合
print(set1 | set2)
- 交集：& -- 求两个集合公共的部分
print(set1 & set2)
- 差集：集合1 - 集合2 -- 获取集合1中除了集合2以外的部分
print(set1 - set2)
- 对称差集(补集)：集合1 ^ 集合2 -- 获取除了两个集合公共部分以外的部分
print(set1 ^ set2)
- 包含关系
集合1 >= 集合2 - 集合1中是否包含集合2
集合1 <= 集合2 - 集合1是否在集合2中
print({5, 6, 7, 8, 9} >= {1, 2, 3}) # False
print({5, 6, 7, 8, 9} >= {5, 9}) # True
