知识回顾
列表，字典，元组，集合
列表(list):[];可变，有序；元素是任何类型的数据
增：append，insert，extend
删：del，remove，pop
改：列表[下标] = 新值
查：列表[下标]，切片，遍历
字典(dict):{};可变，无序；元素是键值对，键是不可变的惟一的，值可以是任何类型的数据
增：字典[key] = 值，setdefault(key,默认值)，update
删：del，pop，clear
改：字典[key] = 值
查：字典[key]，字典.get(key),字典.get(key,默认值),遍历
元组(tuple):();不可变，有序；元素是任何类型的数据
查：和列表一样
tuple1 = 1, 2, 3
tuple2 = (10,)
x,y = (10, 20)
x,y = 10, 20
x, *nums, y = tuple1
集合(set):{};可变，无序；元素是不可变的惟一的
增：add，update
删：remove
改：遍历
集合运算：包含（>=,<=）,交集（&），并集（|），差集（-），补集（^）
浅拷贝和深拷贝
import copy
copy.copy(对象):浅拷贝
copy.deepcopy(对象):深拷贝
拷贝：将变量中的值复制一份，产生新的数据。然后将新的数据对应的地址返回。
浅拷贝：直接拷贝地址（切片和字典列表的copy方法都是浅拷贝）
深拷贝：将地址地址对应值拷贝，产生新的地址
a1 = [1, 2]
a2 = {'a': 10}
list1 = [a1, a2]
# 浅拷贝
# list2 = list1.copy()
# list2 = copy.copy(list1)
# 深拷贝
list2 = copy.deepcopy(list1)
list2.append(10)
print(list1)
print(list2)
list2[0].append(100)
print(list1)
print(list2)
字典和列表的应用
列表的元素和字典的值可以是任何类型的数据
1.列表中有字典
persons = [
{'name': '张三', 'age': 30, 'sex': '男'},
{'name': '李四', 'age': 25, 'sex': '女'},
{'name': '王五', 'age': 40, 'sex': '男'}
]
print(persons)
print(persons[1]['name'])
找出person中年龄最大的人的名字
max_age = 0
for index in persons:
if index['age'] > max_age:
max_age = index['age']
name = index['name']
print('年龄最大的是：', name, max_age)
2.字典中有列表
写一个程序，保存一个班级的信息，包含班级，位置，所有学生（学生中需要保存名字、年龄和学校）
my_class = {
'class_name': 'python1807',
'location': '18-6',
'all_student': [
{'name': '小华', 'age': 18, 'school': '清华'},
{'name': '小明', 'age': 20, 'school': '北大'},
{'name': '小红', 'age': 20, 'school': '川大'}
]
}
print(my_class['all_student'][0]['school'])
练习：在班级中添加一个学生，姓名：老王，年龄：40，学校：北大青鸟
print('___________________')
print('添加信息')
name = input('姓名：')
age = int(input('年龄：'))
school = input('学校：')
new_student['name'] = name
new_student['age'] = age
new_student['school'] = school
new_student = {'name': name, 'age': age, 'school': school}
print(new_student)
my_class['all_student'].append(new_student)
print(my_class['all_student'])
2.练习：删除班级中年龄小于20岁的学生
for index in my_class['all_student']:
if index['age'] < 20:
my_class['all_student'].remove(index)
print(my_class['all_student'])
all_student = my_class['all_student']
for student in all_student[:]:
if student['age'] < 20:
all_student.remove(student)
print(my_class)
index = 0
while index < len(all_student)
student = all_student
if student['age'] < 20:
del all_student[index]
continue
index += 1
print(my_class)
函数的声明
函数就是对实现某一特定功能代码段的封装
分类：自定义函数(程序员自己声明实现其功能)和内置函数(系统已经声明实现完成)
1.声明函数语法
def 函数名(参数列表)：
函数体
说明：
a.def --> python中声明函数的关键字
b.函数名 --> 标识符，不能是关键字。遵守PEP8命名规范(所有字母小写，多个单词用下划线隔开)
见名知义(看见名字知道函数的功能)
c.() --> 固定格式
d.参数列表 --> 形参列表，参数名1，参数2，...
可以有多个参数，也可以没有
参数是用来从函数的外部给函数里面传值用的
e. : --> 固定格式
f.函数体 --> 就是实现函数功能的代码段
2.初学者声明函数的步骤
a.确定函数的功能
b.根据功能确定函数名
c.确定参数:确定有没有，确定有几个（看实现函数的功能需不需要从函数外面传值，需要传几个）
d.实现功能函数
e.确定返回值
3.函数的调用
声明函数的时候，不会执行函数体。函数只有在函数调用的时候才会执行
语法：
函数名(实参列表)
说明：
函数名 --> 必须是已经声明过的函数
() --> 固定的
实参列表 --> 数据1 ，数据2...
用来给形参赋值
写一个函数，打印两个数的和
def my_sum(num1, num2):
print(num1 + num2)
写一个函数，打印五个'*'
def print_star():
print('*' * 5)
写一个函数，打印n个'*'
def print_star2(n):
print('*' * n)
练习:写一个函数，计算1+2+...+n的和
def my_sum2(n):
sum1 = 0
for index in range(n + 1):
sum1 += index
print('1+2+...+', index, '=', sum1)
my_sum2(100)
函数的调用
1.格式
函数名(实参列表)
2.函数的调用过程(重点)
第一步：回到函数声明的位置
第二步：用实参给形参赋值(传参：一定要保证每个参数都有值)
第三步：执行函数体
第四步：返回值 --> 返回给函数调用表达式
第五步：执行完函数体回到函数调用的位置，接着执行后面的代码
def sum2(num1, num2):
print(num1 + num2)
sum2(10, 20)
函数的参数
1.位置参数和关键字参数
位置参数：按照参数的顺序一一给形参赋值
关键字参数：按照关键字一一给形参赋值
def fun1(a, b, c):
print('a', a, 'b', b, 'c', c)
# 位置参数
fun1(10, 20, 30)
# 关键字传参
fun1(c=300, b=200, a=100)
2.默认参数
**函数声明的时候可以给参数设置默认值，但是有默认值的参数，必须放在参数列表的最后
有默认值的参数，在调用的时候可以不用传参**
def fun2(a, c, b=0):
print('a:', a, 'b:', b, 'c:', c)
fun2(10, 20)
fun2(100, 200, 300)
def fun3(a=10, c=20, b=0):
print('a:', a, 'b:', b, 'c:', c)
fun3(a=100, b=200)
fun3(100, b=200)
3.不定长参数
*参数的个数不确定的时候，可以在形参的前面加，将这个形参变成一个元组，用来接收多个参数
注意：如果函数有多个参数，那么不定长参数要放在最后**
写一个函数，计算多个数的和
def my_sum(*nums):
print(sum(nums))
my_sum()
my_sum(1)
my_sum(1, 2)
def fun4(name, age, *scores):
print(name, age, scores)
fun4('小花', 20, 98, 99, 85)
函数的返回值
函数的返回值就是函数调用表达式的值，就是return关键字后面的表达式的值。
python中所有的函数都有返回值，返回值的默认值是None
执行函数体没有遇到return，函数的返回值就是None；函数的返回值是return后面的值
函数调用表达式 --> 调用函数的语句(函数名(实参))
return --> 关键字，只能写在函数体中。用来返回返回值和结束函数
注意：看一个函数的返回值，只看有没有遇到return。只要没有遇到return就是None，遇到return就是return后面的值
情况一：没有return
def fun1():
print('hello python!')
# 将返回值赋给一个变量
re = fun1()
print(re)
# 直接打印返回值
print(fun1())
# 将返回值作为列表的元素
list1 = [fun1(), 1]
print(list1)
情况二：有return
执行函数的时候，一旦遇到return，函数就直接结束。并且把return后面的结果作为返回值
def func2():
print('_________')
print('++++++++')
print('***********')
return 100
print('11111111')
re = func2()
print(re)
注意：并不是只要函数中有return，函数的返回值就是return后面的值
def func3(n):
if n % 2:
return '是奇数'
print(func3(4))
print(func3(5))
如果实现函数的功能会产生新的数据，就将新的数据返回。如果不会产生新的数据就不用返回值
写一个函数，功能是计算一个数的阶乘
def jie_cheng(num):
sum1 =1
for x in range(1, num + 1):
sum1 *= x
return sum1
re = jie_cheng(10)
print(re)
# 写一个函数，打印问候语：‘吃饭了吗？’
def say_hello():
print('吃饭了吗？')
作业
- 编写一个函数，求1+2+3+...+N
def my_sum(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
return sum1
num = int(input('请输入结束的数：'))
print('1 + 2 + ... + ', num, '=', my_sum(num))
结果
- 编写一个函数，求多个数中的最大值
def my_max(n):
return max(n)
list1 = [15, 565, 64, 56, -23]
print(list1)
print('最大的数是：', my_max(list1))
结果
- 编写一个函数，实现摇骰子的功能，打印n个骰子的点数和
def sum_shaizi(n):
sum1 = 0
for index in range(n):
num = random.randint(1, 6)
print('第', index + 1, '颗点数：', num)
sum1 += num
return sum1
num_shaizi = int(input('输入骰子的个数：'))
print('点数和：', sum_shaizi(num_shaizi))
结果
- 编写一个函数，交换指定字典的key和value。
如:{'a':1, 'b':2, 'c':3} ---> {1:'a', 2:'b', 3:'c'}
def change_key_value(n):
for index in list(n):
key = index
value = n[index]
del n[index]
n[value] = key
return n
dict1 = {'a': 1, 'b': 2, 'c': 3}
print(change_key_value(dict1))
结果
- 编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来
如:'12a&bc12d--' ---> 打印'abcd'
def abc(n):
str1 = ''
for word in n:
if word.isalpha():
str1 += word
return str1
str2 = input('输入一个字符串：')
print(abc(str2))
结果
- 写一个函数，求多个数的平均值
def aver(*nums):
num_ave = 0
count = 0
sum1 = 0
for num in nums:
for index in num:
sum1 += index
count += 1
print(num, '的平均数是：', end='')
return sum1 / count
list2 = [545, 4, 45, 95, 56]
print(aver(list2))
结果
- 写一个函数，默认求10的阶层，也可以求其他数的阶层
def jie_cheng(n=10):
num1 = 1
for x in range(1, n + 1):
num1 *= x
return num1
print(jie_cheng())
print(jie_cheng(5))
结果
- 写一个函数，可以对多个数进行不同的运算
如: operation('+', 1, 2, 3) ---> 求 1+2+3的结果 operation('-', 10, 9) ---> 求 10-9的结果 operation('', 2, 4, 8, 10) ---> 求 24810的结构
def operation(flag, *nums):
num1 = 1
if flag == '+':
for num in nums:
print(num)
return sum(num)
elif flag == '-':
count = 1
for num in nums:
print(num)
for x in num:
while count == 1:
num1 = x
count += 1
num1 -= x
return num1
elif flag == '*':
for num in nums:
print(num)
for x in num:
num1 *= x
return num1
elif flag == '/':
count = 1
for num in nums:
print(num)
for x in num:
num1 /= x
return num1
else:
print('输入的运算符有误')
list1 = [10, 3, 5, 7, 9]
flag = input('输入要进行的运算（+，-，*，/）：')
print(operation(flag, list1))
结果
9.写一个函数，求指定列表中，指定的元素的个数
def sum1(list2, ele):
count = 0
print(list2)
print(ele, '的个数：', end='')
for index in list2:
if str(index) == ele:
count += 1
return count
list1 = [1, 1, 2, 2, 2, 'a', 'a', 'abc']
ele1 = str(input('下列列表中，输入要统计的元素：'))
print(sum1(list1, ele1))
结果
10.写一个函数，获取指定列表中指定元素对应的下标(如果有多个，一起返回)
def xia_biao(list2, ele):
xiabiao = 0
while xiabiao <= len(list2) - 1:
for index in list2:
if str(index) == ele:
print(xiabiao)
xiabiao += 1
else:
xiabiao += 1
list1 = [1, 1, 2, 2, 2, 'a', 'a', 'abc']
print(list1)
ele1 = str(input('该列表中，输入要获取下标的元素：'))
xia_biao(list1, ele1)
结果