本文详细讲解了函数的定义、使用、参数传递、返回值、递归、lambda表达式、高阶函数、闭包和装饰器等概念，并通过实例演示了学院管理系统的设计。此外，还涵盖了文件操作和信息技术领域的关键概念，如数据结构、算法、文件操作、数据库和开发工具。
目录
一、函数
1、函数的作用
函数就是一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。函数在开发过程中，可以更高效的实现代码重用。
2、函数的使用步骤
- 定义函数
def 函数名(参数）：
代码...
- 调用函数
函数名(函数)
注：在不同需求中，参数可有可无；在Python中，函数必须先定义后使用。
3、函数参数的作用
# 定义函数的同时定义了接收用户数据的参数a和b，a和b是形参
def add_num1(a,b):
""" 函数参数 """
result = a + b
print(result)
#调用函数时传入真实的数据10和20，真实数据为实参
add_num1(10,20)4、函数的返回值作用
def buy():
return '烟'
# 使用变量保存函数返回值
b = buy()
print(b) #烟5、应用：计算任意两数字之和，并保存结果
def sum_num(a,b):
return a+b
result = sum_num(1,3)
print(result)6、函数的说明文档
- 定义函数说明文档
def 函数名(参数):
""" 说明文档的位置 """
代码...
- 查看函数说明文档
help(函数名)
7、函数的嵌套调用
函数嵌套调用是指一个函数里面又调用了另一个函数。
8、变量作用域
变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量。
- 局部变量：只在函数体内部生效
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成，则销毁局部变量。
- 全局变量：在函数体内、外都能生效的变量
在函数体内部修改全局变量：使用global关键字声明。
9、函数的参数
- 位置参数：调用函数时根据函数定义的参数位置来传递参数。
# 位置参数
def user_info(name,age,gender):
print("您的名字是%s，年龄是%s，性别是%s" %(name,age,gender))
user_info('Tom',20,'男')注：传递和定义参数的顺序及个数必须一致。
- 关键字参数
def user_info(name,age,gender):
print("您的名字是%s，年龄是%s，性别是%s" %(name,age,gender))
#关键字参数
user_info('Rose',age=20,gender='女')
user_info(gender='女',age=20,name='Lily')写法：key = value
注：函数调用时，如果又位置参数时，位置参数必须子啊关键字参数的前面，但关键字参数之间不存在先后顺序。
- 缺省函数：也叫默认参数，用于定义参数，为参数提供默认值，调用函数时可不传该默认参数的值。
def user_info(name,age,gender='男'):
print("您的名字是%s，年龄是%s，性别是%s" %(name,age,gender))
#缺省函数
user_info('Tom',20)
user_info('Rose',18,'女')注：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值
- 不定长函数：可变参数，用于不确定调用时会传递多少个参数(不传参也可以)的场景。此时，可用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。
- 包裹位置传递：收集所有位置参数，返回一个元组
- 包裹关键字传递：收集所有关键字参数，返回一个字典
#不定长参数
#包裹位置传递
def user_info(*args):
print(args)
user_info('Tom') #('Tom',)
user_info('Tom',18) #('Tom', 18)
#包裹关键字传递
def user_info(**kwargs):
print(kwargs)
#{'gender': '男', 'age': 20, 'name': 'Tom'}
user_info(name='Tom',age=20,gender='男')10、拆包
#拆包元组
def return_num():
return 100,200
num1,num2 = return_num()
print(num1) #100
print(num2) #200
#拆包字典
dict1 = {'name':'Tom','age':20}
a,b = dict1
# 对字典拆包，取出来的是key
print(a) #name
print(b) #age
print(dict1[a]) #Tom
print(dict1[b]) #20
11、引用
在python中，值是靠引用传递来的。
我们可以用id()来判断两个变量是否为同一个值得引用。可以将id得值理解为内存地址得标识。
a = 1
b = a
print(b) #1
print(id(a)) #1716474656
print(id(b)) #1716474656二、应用：学院管理系统
1、系统简介：需求，键入系统显示系统功能界面，功能如下：
- 添加学员
- 删除学员
- 修改学员信息
- 查询学员信息
- 显示所有学员信息
- 退出系统
import time
def function():
print("---" *4)
print("1.添加学员")
print("2.删除学员")
print("3.修改学员信息")
print("4.查询学员信息")
print("5.显示所有学员信息")
print("6.退出系统")
print("---" *4)
students = [] #学员列表
def add_student():
"""
添加学员信息
id:学号
name：姓名
sex：性别
"""
id = input("请输入你要添加学员的学号 :")
name = input("请输入你要添加学员的姓名 :")
sex = input("请输入你要添加学员的性别 :")
global students #声明全局变量
#判断学号是否存在
for student in students:
if name == student["name"]:
print("该用户已存在")
add_student()
# 将用户数据添加到字典
student_dict = {}
student_dict['id'] = id
student_dict['name'] = name
student_dict['sex'] = sex
students.append(student_dict)
print("id：%s,name：%s,sex：%s,添加成功!" %(id,name,sex))
time.sleep(1) #等待1秒
student_management()
def del_student():
""" 删除学员信息 """
global students
print(students)
s = input("请输入要删除的学员名字 :")
#声明全局变量
#判断学员是否存在
i = 0
for student in students:
if s == student['name']:
del students[i]
print("删除%s成功" %s)
break
i += 1
else:
print("查无此人哦...")
student_management()
def alter_student():
""" 修改学员信息 """
s = input("请输入要修改的学员名字")
global students
# 学员是否存在
for student in students:
if s == student['name']:
print("id:%s,name:%s,sex:%s" %(student['id'],student['name'],student['sex']))
new_id = input("请输入修改后的学员序号 :")
new_name = input("请输入修改后的学员名字 :")
new_sex = input("请输入修改后的学员性别 :")
student['id'] = new_id
student['name'] = new_name
student['sex'] = new_sex
print("修改后的数据为 id:%s,name:%s,sex:%s" % (student['id'], student['name'], student['sex']))
time.sleep(1)
else:
print("该学员不存在，请重新输入！")
student_management()
def selectid_student():
""" 查询学员信息 """
in_student = input("请输入查询学员的姓名！")
global students
#判断学员是否存在
for student in students:
if student['name'] == in_student:
print(student)
student_management()
else:
print("查询不到该学员...")
selectid_student()
def select_student():
""" 显示所有学员信息 """
for s in students:
for key,value in s.items():
print(("%s ：%s")%(key,value),end=" ")
print()
student_management()
def student_management():
"""
根据序号选择进行的功能
"""
function()
number = int(input("请输入您要进入的功能 ："))
if number == 1:
add_student()
elif number == 2:
del_student()
elif number == 3:
alter_student()
elif number == 4:
selectid_student()
elif number == 5:
select_student()
else:
q = input("确定要退出吗,yes or no")
if q == 'yes':
quit()
三、递归
1、递归的特点
- 函数内部自己调用自己
- 必须有出口
# 6以内累加和
def sum_numbers(num):
# 如果是1，直接返回1
if num == 1:
return 1
# 如果不是1 ，重复执行累加
result = num + sum_numbers(num-1)
return result
sum_number = sum_numbers(6)
print(sum_number)四、lambda表达式
语法： lambda 参数列表 ： 表达式
注：
- lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。
- lambda函数能接受任何数量的参数但只能返回一个表达式的值。
#函数
def fn1():
return 200
print(fn1) #<function fn1 at 0x00000199C9D67F28>
print(fn1()) #200
#lambda 表达式
fn2 = lambda :100
print(fn2) #<function <lambda> at 0x00000199CA077950>
print(fn2()) #100
#直接打印 lamdda 表达式，输出的是此 lambda 的内存地址应用：计算 a+b
#应用 a+b
#函数实现
def add(a,b):
return a+b
result = add(1,3)
print(result) #4
#lambda实现
print((lambda a,b : a+b)(1,6)) #72、lambda的参数形式
- 无参数
print((lambda:100)()) #100- 一个参数
print((lambda a:a)('hello world')) #hello world- 默认参数
print((lambda a,b,c=100 :a+b+c)(10,40)) #150- 可变参数：**args
print((lambda *args:args)(10,20,30)) #(10,20,30)这里的可变参数传入到 lambda 之后，返回值为元组
- 可变参数：**kwargs
print((lambda **kwargs:kwargs)(name="python",age=20)) #{'age': 20, 'name': 'python'}
3、lambda的应用
- 带判断的 lambda
# 带判断的lambda
print((lambda a,b:a if a > b else b)(1000,500)) #100- 列表数据按字典key值排序
#列表数据字典key值排序
students = [
{'name':'Tom','age':20},
{'name':'Rose','age':19},
{'name':'Lily','age':21},
{'name':'Jack','age':23}
]
#按 name 值升序排列
students.sort(key=lambda x:x['name'])
#[{'name': 'Jack', 'age': 23}, {'name': 'Lily', 'age': 21}, {'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}]
print(students)
#按 name 值降序排列
students.sort(key=lambda x:x['name'],reverse=True)
# [{'name': 'Tom', 'age': 20}, {'name': 'Rose', 'age': 19}, {'name': 'Lily', 'age': 21}, {'name': 'Jack', 'age': 23}]
print(students)
# 按 age 值升序排列
students.sort(key=lambda x:x['age'])
#[{'name': 'Rose', 'age': 19}, {'name': 'Tom', 'age': 20}, {'name': 'Lily', 'age': 21}, {'name': 'Jack', 'age': 23}]
print(students)五、高阶函数
把函数作为参数传入
# 需求：一个函数完成计算任意两个数字的绝对值之和
#在python中，函数 abs() 可以完成绝对值的计算
# 方法一
def add_num(a,b):
return abs(a) + abs(b)
result = add_num(-1,2)
print(result)
#方法二
def sum_num(a,b,f):
return f(a)+f(b)
result = sum_num(-4,8,abs)
print(result)1、内置高阶函数
- map()
#map(func,lst),将传入的函数变量func作用到lst变量的美国函数中，并将结果组成新的迭代器返回
# 需求：计算list1序列中各个数字的2次方
list1 = [1,2,3,4,5]
def func(x):
return x ** 2
result = map(func,list1)
print(result) #<map object at 0x000001410D0DD9E8>
print(list(result)) #[1, 4, 9, 16, 25]- reduce()
#reduce(func(x,y),lst) ,其中func必须有两个参数，每次func计算的结果继续和序列的下一个元素作累加计算。
#需求：计算list1序列中各个数字的累加和
import functools
list1 = [1,2,3,5,7,9]
def sum(a,b):
return a+b
result = functools.reduce(sum,list1)
print(result) #25- filter()
#filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象，如需转换为列表使用list()
list1 = [1,2,3,4,5,6,7,8,9,10]
def func(x):
return x%2 == 0
result = filter(func,list1)
print(result) #<filter object at 0x00000267A882DCF8>
print(list(result)) #[2, 4, 6, 8, 10]六、闭包
python函数是支持嵌套的。如果在一个内部函数中对外部函数作用域（非全局作用域）的变量进行引用，那么内部函数就会被成为闭包。
闭包需要满足如下三个条件。
- 存在于两个嵌套关系的函数中，并且闭包是内部函数。
- 内部函数引用了外部函数的变量（自由变量）。
- 外部函数会把内部函数的函数名称返回。
# 外部函数
def outer(start = 0):
count = [start] #函数内的变量
# 内部函数
def inner():
count[0] += 1 #引用外部函数的变量
return count[0]
# 返回内部函数的名称
return inner
out = outer(5)
print(out()) #6七、装饰器
假设我们已经开发了一个本有的函数，后续可能会增加临时需求，例如插入日志，我们可以增加一个包裹函数，由它来负责这些额外需求，这个包裹函数就是装饰器。
装饰器主要应用场景：
- 引入日志
- 执行函数后的清理功能
- 函数执行时间统计
- 权限校验
- 执行函数前预备处理
- 缓存
装饰器是一个函数，他需要接受一个参数，该参数表示被修饰的函数。
通过在函数定义前面添加@符合，和装饰器名，实现装饰器对函数的包装。
def wrap(func):
print("正在装饰")
def inner():
print("正在验证权限")
func()
return inner
@wrap
def f1():
print("f1")
f1()多个装饰器应用在一个函数上，调用顺序是从下至上。
八、文件
文件操作的作用：把一些内容存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。
1、打开
open(name,mode)
open:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）。
mode：设置打开文件的模式：只读，写入，追加。打开文件的方式：
- r：已读方式打开文件。
- w：打开一个文件只用于写入。
- a：打开一个文件用于追加。
2、写入
对象对象.write( ' 内容 ' )
注意：w和a模式：如果文件不存在则创建文件；如果文件存在，w模式先清空再写入，a模式直接在末尾追加。
r模式：如果文件不存在则报错。
3.读
- read()
文件对象.read(num)
num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中的所有的数据。
- readlines()
文件对象.readlines()
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
- readline()
readline()一次读取一行内容。
4、移动文件指针
seek()
文件对象.seek(偏移量，起始位置)
起始位置：0，文件开头；1，当前位置；2，文件结尾
5、关闭
文件对象.close()
6、文件和文件夹的操作
在python中文件和文件夹的操作要借助os模块里面的相关功能。
# 1、导入模块
import os
# 使用os模块相关功能
os.函数名()
# 文件重命名
os.rename(目标文件夹，新文件夹)
# 删除文件
od.remove(目标文件夹)
# 创建文件夹
os.mkdir(文件夹名字)
# 删除文件夹
os.rmdir(文件夹名字)
# 获取当前目录
os.getcwd()
# 改变默认目录
os.chdir(目录)
# 获取目录列表
os.listdir(目录)
扫一扫
299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
