01.recode
1.列表(list) - 可变，有序 - []
a.获取元素 - 通过下标获取元素
b.增删改
增 - append,insert,(extend)
删 - remove,del,pop,clear
改 - 列表[下标] = 新值
c.相关运算: +, *, in/not in, len(), list(), max(), min()
2.元祖(tuple) - 不可变，有序 - ()
a.获取元素 - 通过下标获取元素
变量1, 变量2 = 元素1, 元素2
变量1, *变量2 = 元素1, 元素2, 元素3, 元素4
(元素,)
c.相关运算: +, *, in/not in, len(), tuple(), max(), min()
3.字典(dict) - 可变, 无序 - {}
a.获取元素 - 通过键获取元素
b.增删改
增 - 字典[key] = 值； 字典1.update(字典2)
删 - del 字典[key]; 字典.pop(key); clear
改 - 字典[key] = 值；字典1.update(字典2)
c.相关运算:in/not in, len(), dict(), max(), min()
max和min - 取的是字典的key的最大值和最小值
print(len({'a': 10, 'b': 20}))
dict1 = dict([(1, [1, 2]), ['a', 'b'], ('aaa', 100)])
print(dict1)
2
{1: [1, 2], 'a': 'b', 'aaa': 100}
dict2 = {'a': 10, 'd': 20, 'c': 30}
print(max(dict2))
print(min(dict2))
d
a
02.字典相关方法
1.clear
字典.clear() - 清空字典（删除字典中所有的键值对）
dict1 = {'a': 100, 'b': 200}
dict1.clear()
print(dict1)
{}
2.copy
字典.copy() - 复制字典中所有的键值对，产生一个新的字典
dict1 = {'a': 100, 'b': 200}
dict2 = dict1.copy() # 这儿会产生新的地址
print(dict2)
dict1['a'] = 1
print(dict2)
{'a': 100, 'b': 200}
{'a': 100, 'b': 200}
3.fromkeys
dict.fromkeys(序列, 值) - 以序列中的元素作为key，值作为所有key对应的默认值，创建一个字典
dict3 = dict.fromkeys('xyzp', 100)
print(dict3) # {'x': 100, 'y': 100, 'z': 100, 'p': 100}
dict3 = dict.fromkeys(['name', 'age', 'height'], 100)
print(dict3) # {'name': 100, 'age': 100, 'height': 100}
{'x': 100, 'y': 100, 'z': 100, 'p': 100}
{'name': 100, 'age': 100, 'height': 100}
4.get
字典.get(key) - 获取key对应的值，如果key不存在，返回None
字典.get(key,值) - 获取key对应的值，如果key不存在，返回指定的值
dict3 = {'name': 100, 'age': 100, 'height': 100}
print(dict3.get('name')) # 100
print(dict3.get('name', '不存在')) # 100
print(dict3.get('name1')) # None
print(dict3.get('name1', '不存在')) # 不存在
100
100
None
不存在
5.keys, values, items
字典.keys() - 获取字典所有的key(返回一个序列，序列中的元素就是字典的key)
字典.values() - 获取字典所有的值(返回一个序列，序列中的元素就是字典的value)
字典.items() - 获取字典所有的键值对(返回一个序列，序列中的元素是元祖，元祖中元素有两个分别是key和value)
dict4 = {'x': 23, 'y': 89, 'z': 234, 'p': 100}
# 获取所有的key
keys = dict4.keys()
print(keys, type(keys)) # 返回值是序列，但是不是列表
# print(keys[0])
for item in keys:
print(item)
dict_keys(['x', 'y', 'z', 'p'])
x
y
z
p
# 获取所有的值
print(dict4.values())
print(dict4.items()) # dict_items([('x', 23), ('y', 89), ('z', 234), ('p', 100)])
dict_values([23, 89, 234, 100])
dict_items([('x', 23), ('y', 89), ('z', 234), ('p', 100)])
6.setdefault
字典.setdefault(key, value) - 给字典添加键值对(注意：如果key本来就存在，不会修改这个key的值 - 对原字典没有影响)
dict4 = {'x': 23, 'y': 89, 'z': 234, 'p': 100}
dict4.setdefault('xx', 'abc')
print(dict4) # {'x': 23, 'y': 89, 'z': 234, 'p': 100, 'xx': 'abc'}
{'x': 23, 'y': 89, 'z': 234, 'p': 100, 'xx': 'abc'}
dict4 = {'x': 23, 'y': 89, 'z': 234, 'p': 100}
dict4.setdefault('x', 'abc')
print(dict4) # {'x': 23, 'y': 89, 'z': 234, 'p': 100}
{'x': 23, 'y': 89, 'z': 234, 'p': 100}
03.集合的基本操作
1.什么是集合(set)
a.集合是python内置的一个容器类的数据类型，是可变、无序的
b.字面量 - 使用{}括起来，里面有多个元素，多个元素之间用逗号隔开
{1, 2, 3}
c.元素 - 不是键值对; 必须是不可变的，而是还是唯一的
set1 = {1, 'hello', True, (1, 3)}
# set2 = {1, 'hello', True, [1, 3]} # TypeError, 集合中的元素不可变
set3 = {1, 'hello', True, (1, 3), 1}
print(set3)
{'hello', 1, (1, 3)}
set4 = {} # {} - 是空的字典，不是空的集合
print(type(set4))
set4 = set() # 创建一个空的集合
print(type(set4), set4)
set()
2.集合的增删改查
a.查(获取集合元素)
不能直接获取集合中单独的某个元素，只能遍历
set3 = set('hello,world')
print(set3)
for item in set3:
print(item)
{'d', 'w', 'l', 'e', ',', 'h', 'r', 'o'}
d
w
l
e
,
h
r
o
b.增(添加元素)
集合.add(元素) - 将指定的元素添加到集合中
集合.update(序列) - 将序列中的元素添加到集合
set3.add(100)
print(set3)
set3.update([10, 20])
print(set3)
{'d', 100, 'w', 'l', 'e', ',', 'h', 'r', 'o'}
{'d', 100, 'w', 'l', 'e', 10, ',', 'h', 'r', 20, 'o'}
c.删(删除元素)
集合.remove(元素) - 删除集合中指定的元素
set3 = {100, 'w', 'h', 'e', ',', 'd', 'o', 'l', 'r'}
set3.remove(100)
print(set3)
{'d', 'w', 'l', 'e', 'h', ',', 'r', 'o'}
d.改 - 集合不能修改元素的值
in/not in, max, min, len, set
set(序列) - 将序列转换成集合
print(2 in {1, 2, 3}) # True
print({1, 2} in {1, 2, 3}) # False
True
False
04.数学集合运算
python中的集合支持数学相关的集合运算
1.包含关系
集合1 >= 集合2 判断集合1中是否包含集合2(判断集合2是否是集合1的子集)
集合1 <= 集合2 判断集合2中是否包含集合1(判断集合1是否是集合2的子集)
print({1, 2, 3} >= {1, 10}) # False
print({1, 2, 3} >= {2, 3}) # True
print({1, 2, 3} <= {1, 2, 3, 9, 10}) # True
False
True
True
2.求并集
集合1 | 集合2 - 将两个集合中的元素合并在一起产生一个新的集合
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
3.求交集
集合1 & 集合2 - 使用两个集合中公共的元素，创建一个新的集合
print(set1 & set2)
{4, 5, 6}
4.求差集
集合1 - 集合2 - 使用集合1中除了集合2的部分以外的元素，创建一个新的集合
print(set1 - set2)
{1, 2, 3}
5.求补集
集合1 ^ 集合2 - 使用两个集合中除了公共部分以外的元素，创建一个新的集合
print(set1 ^ set2)
{1, 2, 3, 7, 8}
# list1 = [1, 34, 556, 78, 23, 2, 1]
# set1 = set(list1)
# print(set1)
# list1 = list(set1)
# list1.sort()
# print(list1)
05.homework
1.已知一个列表，求列表中心元素。
# list1 = [1, 2, 3, 4, 5] # index = 2 = len(list1) // 2
list1 = [1, 2, 3, 4, 5, 6] # index = 2,3 = len(list1)//2, len(list1)//2-1
length = len(list1)
if length & 1:
print(list1[length//2])
else:
# length >> 1 相当于 length//2
print(list1[length >> 1] - 1)
print(list1[length >> 1])
3
4
2.已知一个列表，求所有元素和。
list1 = [1, 2, 3, 4, 5, 6]
print(sum(list1))
21
3.已知一个列表，输出所有奇数下标元素。
list1 = [1, 2, 3, 4, 5, 6]
for index in range(1, len(list1), 2):
print(list1[index], end=' ')
2 4 6
4.已知一个列表，输出所有元素中，值为奇数的。
list1 = [10, 21, 35, 40, 5, 69, 2]
for item in list1:
# item % 2 相当于 item % 2 == 1
if item % 2 == 1:
print(item, end=' ')
21 35 5 69
5.已知一个列表，将所有元素乘二。
list2 = [1, 3, 4, 1, 2] # [2, 6, 8, 2, 4]
for index in range(len(list2)):
list2[index] *= 2
print(list2)
[2, 6, 8, 2, 4]
####### 6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的
# 方法一:
list2 = [1, 3, 4, 1, 2, 1, 2] # [1, 3, 4, 2]
numbers = []
for item in list2:
if item not in numbers:
numbers.append(item)
list2 = numbers
print(list2)
[1, 3, 4, 2]
# 方法二:
list2 = [1, 3, 4, 1, 2, 1, 2]
for item in list2.copy():
# 统计元素的个数
count = list2.count(item)
# 如果个数大于1，就删一个
if count > 1:
list2.remove(item)
print(list2)
[3, 4, 1, 2]
7.已知一个数字列表(数字大小在0~6535之间), 将列表转换成数字对应的字符列表
# 例如: list1 = [97, 98, 99] -> list1 = ['a', 'b', 'c']
list2 = [89, 78, 98, 110, 120, 7823]
for index in range(len(list2)):
list2[index] = chr(list2[index])
print(list2)
['Y', 'N', 'b', 'n', 'x', 'ẏ']
06.homework2
===============1.数据结构的设置==============
数据关系： 一个学生管理系统可以保存多个学生信息。一个学生保存姓名、年龄、电话、学号等信息。
一个学生管理系统对应的数据模型： 一个列表
一个学生对应的数据模型: 一个字典
整个数据结构:
student_system=
[
{'name':x, 'age':x, 'tel':x, 'id':x},
{'name':x, 'age':x, 'tel':x, 'id':x},
{'name':x, 'age':x, 'tel':x, 'id':x},
{'name':x, 'age':x, 'tel':x, 'id':x},
{'name':x, 'age':x, 'tel':x, 'id':x},
{'name':x, 'age':x, 'tel':x, 'id':x},
...
{'name':'张三', 'age':18, 'tel':'2333', id:'0010'}
]
"""
# ===============2.页面设计和控制==============
page = """============================
欢迎来到XX学生管理系统
♥ 1.添加学生
♥ 2.查找学生信息
♥ 3.删除学生
♥ 4.修改学生信息
♥ 5.退出
============================"""
while True:
# 1.显示主页面
print(page)
# 2.给出选择
value = input('请选择(1-5):')
# 3.根据不同的选择做不一样的反应
if value == '1':
# ====添加学生=====
while True:
name = input('请输入姓名:')
age = input('请输入年龄:')
tel = input('请输入电话号码:')
print('添加成功！')
print('1.继续\n2.返回')
value1 = input('请选择(1-2):')
if value1 == '1':
continue
else:
break
elif value == '2':
print('查找学生信息的功能')
elif value == '3':
print('删除学生的功能')
elif value == '4':
print('修改学生信息')
else:
print('退出成功！')
break
07.为什么要使用函数
例：飞机的功能: 左移、右移、上移、下移、发射子弹、自爆等
不使用函数的问题：
1.同样的功能，相同的代码需要重复写很多次
2.当功能发生改变了，需要修改多处代码
怎么解决这些问题：使用函数！
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# print('踩油门')
# print('回正方向盘')
#
# print('========右移=========')
# print('看后视镜')
# print('打右转灯')
# print('向右打方向盘')
# print('踩油门')
# print('回正方向盘')
def left():
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
print('左移')
def right():
print('========右移=========')
print('看后视镜')
print('打右转灯')
print('向右打方向盘')
# print('踩油门')
print('回正方向盘')
# 左移两次，右移两次，左移三次
left()
left()
right()
right()
left()
left()
left()
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('========右移=========')
# print('看后视镜')
# print('打右转灯')
# print('向右打方向盘')
# print('踩油门')
# print('回正方向盘')
#
# print('========右移=========')
# print('看后视镜')
# print('打右转灯')
# print('向右打方向盘')
# print('踩油门')
# print('回正方向盘')
#
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
#
# print('========左移=========')
# print('看后视镜')
# print('打左转灯')
# print('向左打方向盘')
# # print('踩油门')
# print('回正方向盘')
左移
左移
========右移=========
看后视镜
打右转灯
向右打方向盘
回正方向盘
========右移=========
看后视镜
打右转灯
向右打方向盘
回正方向盘
左移
左移
左移
08.认识函数
1.函数的定义
a.定义
函数就是对实现某一特定功能的代码段的封装
b.分类
函数可以分为内置函数和自定义函数
内置函数：python已经声明好了，程序员直接调用的函数。print函数, input函数，max等。
相当于已经造好的机器，程序员只需要知道机器的功能和使用方法
自定义函数: 程序员自己声明，自己实现功能的函数。可以提供给别人用，也可以自己用。
相当于自己设置和创建机器。
2.函数的声明
a.语法:
def 函数名(形参列表):
函数说明文档
函数体
b.说明：
def - python中声明函数的关键字
函数名 - 自己命名；要求：标识符, 不能是关键字
PEP8,名字中的字母小写，多个单词之间用下划线隔开
见名知义(看到函数名，大概知道函数的功能)
() - 固定写法
形参列表 - 形参名1,形参名2... (可以有一个参数，也可以有多个参数，也可以没有参数)
形参的作用：从函数的外部，向函数内部传递数据
: - 固定写法
函数说明文档 - 用来对函数的功能进行说明的注释。这个注释需要使用是三个双引号引起来
函数体 - 实现函数功能的代码段
c.初学者函数声明的步骤
第一步：确定函数的功能
第二步：根据函数的功能，确定函数名
第三步：确定参数，看实现函数的功能，需不需要额外的数据。需要几个数据，就需要几个参数
第四步：实现函数的功能
第五步：确定返回值
声明一个函数，求两个数的和,并且打印出来
def my_sum(num1, num2):
print(num1 + num2)
# 声明一个函数，打印10个'*'
def print_star():
print('*'*10)
# 声明一个函数，求1+2+3+...+n
def my_sum2(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
print(sum1)
3.函数的调用
(重点)函数在声明的时候不会执行函数体，只有在调用的时候才会执行
a.语法：
函数名(实参列表)
b.说明：
函数名 - 必须是已经声明过的函数
() - 固定写法
实参列表 - 实参就是给形参赋值（需要传递给函数内部的数据）
目前，形参有多个少，实参就需要多少个
my_sum(10, 20)
my_sum(100, 200)
print_star()
my_sum2(100)
30
300
**********
5050