一、复习
1. 列表
- 1)数据: [元素1, 元素2, 元素3,...] -- 元素是任何类型的数据
- 2)特点: 可变、有序
- 3)支持的相关操作: +, *, ==, !=, in/not in, len(), list()
- 4)什么时候使用: 需要保存的多个数据是相同性质的数据, 例如：保存多个学生的成绩、保存多个学生的信息...
2. 元组
- 1)数据: (元素1, 元素2, 元素3,...) -- 元素是任何类型的数据
(元素,)
元素1, 元素2, 元素3,...
变量1, 变量2,... = 元祖
变量1, *变量2,... = 元祖 - 2)特点: 不可变，有序
- 3)支持的相关操作: +, *, ==, !=, in/not in, len(), tuple()
- 4)什么时候使用: 存储数据的时候一般不主动使用元组。主要是在使用函数的过程中经常遇到元组
3. 字典
- 1)数据: {键1:值1, 键2:值2, ...} -- 键: 不可变、唯一 值: 任何类型的数据
- 2)特点: 可变、无序
- 3)支持的相关操作: ==, !=, in / not in, len(), dict()
- 4)什么时候使用: 同时存储的多个数据需要区分(性质不同)
4. 集合
- 1)数据: {元素1, 元素2, 元素3,...} -- 元素不可变、唯一
- 2)特点: 可变，无序
- 3)支持的相关操作: 数据集合运算(|,&,-,^对称差分)、 in/not in 、len()、set()
- 4)什么时候使用: 去重、对数据的处理涉及到数学集合运算
补充: is的使用
== 和 is的区别: 他们两个都是来判断两个数据是否相等， ==判断的是值是否相等，is判断地址是否相等
python中所有的变量都是保存的数据在内存中地址;
用一个变量给另外一个变量赋值，实质将变量中存储的地址赋过去;
使用变量实质是使用变量中地址对应的内存区域中的值
== : 判断两个变量地址对应的值是否相等
is : 判断两个变量存储的地址是否相等
list1 = [1, 2]
list2 = [1, 2]
print(id(list1), id(list2))
print(list1 == list2) # True
print(list1 is list2) # False
list3 = list1
print(id(list1), id(list3))
print(list1 == list3) # True
print(list1 is list3) # True
class1 = {
'name': 'python1902',
'address': '19楼5教室',
'all_student': [
{'name': '张三', 'age': 18, 'id': 'stu001'},
{'name': '李四', 'age': 20, 'id': 'stu002'},
{'name': '小明', 'age': 30, 'id': 'stu003'},
{'name': '王五', 'age': 16, 'id': 'stu004'}
]
}
print(len(class1['all_student']))
all_student = class1['all_student']
for stu in all_student:
if stu['age'] < 18:
print(stu['name'])
school = {
'leader': {'name': '雷静', 'tel': '1723828333'},
'all_class': [
{
'name': 'python1902',
'address': '19楼5教室',
'all_student': [
{'name': '张三', 'age': 18, 'id': 'stu001'},
{'name': '李四', 'age': 20, 'id': 'stu002'},
{'name': '小明', 'age': 30, 'id': 'stu003'},
{'name': '王五', 'age': 16, 'id': 'stu004'}
]
},
{
'name': 'python1901',
'address': '19楼10教室',
'all_student': [
{'name': '张三1', 'age': 18, 'id': 'stu005'},
{'name': '李四1', 'age': 20, 'id': 'stu006'},
{'name': '小明1', 'age': 30, 'id': 'stu007'},
{'name': '王五1', 'age': 16, 'id': 'stu008'}
]
}
]
}
all_class = school['all_class']
for class1 in all_class:
all_student = class1['all_student']
for stu in all_student:
if stu['age'] < 18:
print(stu['name'])
二、作业
1. 声明一个字典保存一个学生的信息，学生信息中包括: 姓名、年龄、成绩(单科)、电话
student = {'name': '张三', 'age': 23, 'score': 80, 'tel': '15382839992'}
2. 声明一个列表，在列表中保存6个学生的信息(6个题1中的字典)
all_student = [
{'name': '小明', 'age': 28, 'score': 89, 'tel': '15627382903'},
{'name': '路飞', 'age': 30, 'score': 59, 'tel': '15627382904'},
{'name': '鸣人', 'age': 29, 'score': 60, 'tel': '15627382908'},
{'name': '柯南', 'age': 17, 'score': 45, 'tel': '15627382909'},
{'name': '佐助', 'age': 22, 'score': 90, 'tel': '15627382902'},
{'name': '张楚岚', 'age': 16, 'score': 90, 'tel': '15627382908'}
]
# a.统计不及格学生的个数
count = 0
for stu in all_student:
if stu['score'] < 60:
count += 1
print('不及格的人数: %d' % count)
# b.打印不及格学生的名字和对应的成绩
for stu in all_student:
if stu['score'] < 60:
print(stu['name'], stu['score'])
# c.统计未成年学生的个数
count = 0
for stu in all_student:
if stu['age'] < 18:
count += 1
print('未成年的人数: %d' % count)
# d.打印手机尾号是8的学生的名字
for stu in all_student:
tel = stu['tel']
if tel[-1] == '8':
print(stu['name'], tel)
# e.打印最高分和对应的学生的名字
max_score = 0
names = []
for stu in all_student:
score = stu['score']
if score >= max_score:
max_score = score
for stu in all_student:
if stu['score'] == max_score:
names.append(stu['name'])
print(names, max_score)
# f.将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)
all_student = [
{'name': '小明', 'age': 28, 'score': 89, 'tel': '15627382903'},
{'name': '路飞', 'age': 30, 'score': 59, 'tel': '15627382904'},
{'name': '鸣人', 'age': 29, 'score': 60, 'tel': '15627382908'},
{'name': '柯南', 'age': 17, 'score': 45, 'tel': '15627382909'},
{'name': '佐助', 'age': 22, 'score': 90, 'tel': '15627382902'},
{'name': '张楚岚', 'age': 16, 'score': 90, 'tel': '15627382908'}
]
# all_student = [
# {'name': '佐助', 'age': 22, 'score': 90, 'tel': '15627382902'},
# {'name': '张楚岚', 'age': 16, 'score': 90, 'tel': '15627382908'},
# {'name': '小明', 'age': 28, 'score': 89, 'tel': '15627382903'},
# {'name': '鸣人', 'age': 29, 'score': 60, 'tel': '15627382908'},
# {'name': '路飞', 'age': 30, 'score': 59, 'tel': '15627382904'},
# {'name': '柯南', 'age': 17, 'score': 45, 'tel': '15627382909'}
# ]
# nums = [3, 2, 5, 7, 1]
"""
3, 2, 5, 7, 1
i = 0, j = 1,2,3,4
i = 0, j = 1: [3, 2, 5, 7, 1]
j = 2: [5, 2, 3, 7, 1]
j = 3: [7, 2, 3, 5, 1]
j = 4: [7, 2, 3, 5, 1]
i = 1, j = 2,3,4
j = 2: [7, 3, 2, 5, 1]
j = 3: [7, 5, 2, 3, 1]
j = 4: [7, 5, 2, 3, 1]
i = 2, j = 3, 4
j = 3: [7, 5, 3, 2, 1]
j = 4: [7, 5, 3, 2, 1]
i = 3, j = 4
j = 4: [7, 5, 3, 2, 1]
选择排序: 让前面的数依次和后面的每一个数比较大小, 如果后面的比前面的数大就交换位置(降序)。
整个过程执行长度-1次
"""
# 选择排序
nums = [3, 2, 5, 7, 1]
length = len(nums)
# i前面的数的下标
for i in range(0, length-1):
# j表示前面数后边的每个数的下标
for j in range(i+1, length):
# 后面的数比前面的大
if nums[j] > nums[i]:
# 交换位置
nums[i], nums[j] = nums[j], nums[i]
print(nums)
length = len(all_student)
for i in range(0, length-1):
for j in range(i+1, length):
if all_student[j]['age'] > all_student[i]['age']:
all_student[i], all_student[j] = all_student[j], all_student[i]
print(all_student)
3. 用三个列表表示三门学科的选课学生姓名(一个学生可以同时选多门课)
chinese = {'凛', '律', '鸣', '叶', '陆', '绿', '空', '白'}
math = {'凛', '律', '优', '梓', '澪', '柚', '松', '柏'}
english = {'凛', '鸣', '红', '唯', '澪', '空', '白', '堇'}
# a. 求选课学生总共有多少人
all_student = chinese | math | english
print('选课学生的总人数:', len(all_student), all_student)
# b. 求只选了第一个学科的人的数量和对应的名字
only_chinese = chinese - math - english
print('只选了语文的学生:', only_chinese)
# c. 求只选了一门学科的学生的数量和对应的名字
only_one = (chinese - math - english) | (math - chinese - english) | (english - math - chinese)
print('只选一门学科的学生', only_one)
only_one = (chinese ^ math ^ english) - (chinese & math & english)
print('只选一门学科的学生', only_one)
# d. 求只选了两门学科的学生的数量和对应的名字
only_two = ((chinese & math) | (chinese & english) | (english & math)) - (chinese & math & english)
print('只选两门学科的学生', only_two)
# e. 求选了三门学生的学生的数量和对应的名字
print(chinese & math & english)
三、函数
1. 什么是函数
函数就是对实现某一特定功能的代码块的封装
2. 函数的分类
- 1)系统函数(内置函数) - 系统已经实现函数(已经造好的机器),程序员只需要调用就行
print函数、input函数、len函数、sum函数、max函数等 - 2)自定义函数 - 程序员自己声明的函数(自己造机器)
3. 函数的声明(定义) - 造机器
- 语法:
def 函数名(形参列表):
函数说明文档
函数体
- 语法:
2)说明
def - python声明函数的关键字
函数名 - 和变量名要求一样
见名知义（看到函数名大概知道函数的功能）
() - 固定写法
形参列表 - 变量名1,变量名2,变量名3... (根据情况变量名的个数可以是0个、1个或者多个)
形参的作用是将函数外面的数据传递到函数的里面
: - 固定写法
函数体 - 和def保持一个缩进的一条或者多条语句。（实现函数功能的代码块）3)初学者声明函数的步骤
第一步: 确定函数的功能
第二步: 根据功能确定函数名
第三步: 确定形参（看实现函数的功能需不需要从外面传值，如果需要传值需要几个）
第四步: 实现函数的功能
第五步: 确定返回值
(!!!!)注意：函数声明的时候，函数体不会执行！
# 写一个函数来求两个数的和
def yt_sum(num1, num2):
# num1 = 23, num2 = 90
"""
函数说明文档(功能说明)
:param num1: 参数说明
:param num2: 参数说明
:return: 返回值说明
"""
print('求和')
print(num1+num2) # print(23+90)
# 声明一个函数，实现求1+2+3+..+n的功能
def sum1(n):
# n = 100, n=10
total = 0
for num in range(1, n+1):
total += num
print(total)
4. 函数的调用 - 使用机器
1)语法
函数名(实参列表)2)说明
函数名 - 已经声明过的函数
() - 固定写法
实参列表 - 数据1,数据2,数据3,... (实参是用来给形参赋值)3)函数的调用过程(特别重要!!!)
第一步：回到函数声明的位置
第二步：用实参给形参赋值。（这个过程又叫传参， 传参要保证每个形参都有值）
第三步：执行函数体
第四步：回到函数调用的位置，接着往后执行
yt_sum(23, 90)
print('=============')
# 同一个函数可以调用多次
sum1(100)
sum1(10)
print('==============')
四、函数参数
1. 位置参数和关键字参数
调用函数时候根据实参的写法分为位置参数和关键字参数
- 1)位置参数: 让实参的顺序和形参一一对应，中间用逗号隔开
- 2)关键字参数: 以'形参名1=值1, 形参名2=值2...'格式来确定实参
注意: 如果既有位置参数又有关键字参数，位置参数必须写在关键字参数前面
def func1(a, b, c):
# a=10, b=20, c=30
print('a:', a, 'b:', b, 'c:', c)
# 位置参数
func1(10, 20, 30)
# 关键字参数
func1(c=30, b=20, a=10)
func1(b=20, a=10, c=30)
# 位置参数+关键字参数
func1(10, c=30, b=20)
# func1(c=30,20,a=10) # SyntaxError: positional argument follows keyword argument
2. 参数默认值
声明函数的时候，可以给形参赋默认值。有默认值的形参，在调用函数的时候可以不用给这个形参赋值
注意: 声明的时候有默认值的参数要放在没有默认值的参数的后面
def func2(a=10, b=20, c=30):
# a=100, b=200, c=30
# a=100,b==200,c=300
print(a, b, c)
func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
# 调用函数只给a和c赋值，b使用默认值
func2(a=100, c=300)
func2(100, c=300)
3. 参数的类型说明
python中类型只有说明的作用，没有约束的作用
- 参数赋默认值
- 参数名:类型
def func3(nums: list, a: int, b=''):
nums.append(a)
4. 不定长参数 - 形参的参数不确定
- 声明函数的时候，在形参的前面加*，那么这个参数就变成不定长参数，可以同时接收多个实参(将这个参数变成元祖)
注意: 不带*的参数要放在带*参数的前面
# 写一个函数，求多个数的和
def yt_sum(a, *nums, b=0):
print(a, nums)
# yt_sum()
yt_sum(1, 2) # a=1, nums=()
yt_sum(23, 10, 8) # a=23, nums=(10,)
yt_sum(10, 29, 90, 9)
yt_sum(9, 9, 90, 0, 29, 9)
# 练习: 写一个函数，按指定的方式计算多个数字的结果
# operation('+', 23, 34, 45, 56) -> 求和
# operation('-', 23, 34, 45, 56) -> 23-34-45-56
# operation('*', 23, 34, 45, 56) -> 23*34*45*56
# operation('/', 23, 34, 45, 56) -> 23/34/45/56
