目录
一、函数
1.函数的定义
- 使用关键字def，确定函数名称、参数名称、参数个数、编写函数体（用于实现函数功能的代码）
def func():
print("python")2.函数的调用
- 通过函数名称进行调用函数
- 定义好函数之后，只表示这个函数封装了一段代码而已，如果不主动调用函数，函数是不会主动执行的
3.函数的参数
（1）形参：是函数定义时小括号里的参数，是用来接收参数的，在函数内部作为变量使用
（2）实参：是函数调用时小括号里的参数，是用来把数据传递到函数内部的
另：函数可以没有形参和实参
def my_sum(a,b): # 函数的定义,a,b为形式参数
return a+b
result = my_sum(3,4) # 函数的调用，3,4为实际参数
print(result)运行结果：
74.函数的参数类型
（1）位置参数：要求实参顺序必须和形参顺序完全一致，由形参顺序决定实参顺序。
def power(x,n=2): # n:默认参数，缺省参数
return x**n
a = power(4,3)
b = power(5,3)
c = power(6)
print(a)
print(b)
print(c)运行结果：
64
125
36（2）缺省参数：定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就|叫做缺省参数。注意：可选参数要定义在非可选参数的后面
def infos(name,age=24,gender='女'):
return '大家好，我是%s ，%d岁，是一名%s生'%(name,age,gender)
s = infos('-17',18,'女')
ly = infos('ly')
cy = infos('cy',34,'男')
ie = infos('ie',gender='男')
print(s)
print(ly)
print(cy)
print(ie)运行结果：
大家好，我是-17 ，18岁，是一名女生
大家好，我是ly ，24岁，是一名女生
大家好，我是cy ，34岁，是一名男生
大家好，我是ie ，24岁，是一名男生（3）可变参数：传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
例1：
def total(*args): # 可变参数
print(args)
result = 0
for i in args:
result += i
return result
result = total(1,2,3,4,5,6)
print(result)
# a=[1,2,3,4,5]
# result = total(*a)
result = total(1,2,3,4,5)
print(result)运行结果：
(1, 2, 3, 4, 5, 6)
21
(1, 2, 3, 4, 5)
15例2：
def f(**kwargs): # 可变参数，接收字典
for k,v in kwargs.items():
print(k,v)
d = {'name':'cy','age':18}
f(**d)运行结果：
name cy
age 18二、变量作用域
1.全局变量
- 全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
2.局部变量
- 局部变量是在函数内部定义的变量，只能在函数内部使用
例1：
# 全局变量
num1 = 10
def f():
num2 = 20 # 局部变量
num1 = 20 # 相当于创建了一个变量叫num1，与全局变量num1同名，并不是同一个变量
print('在函数f内部打印num1的值', num1)
print('num2的值',num2)
print('在函数f外部打印num1的值', num1)
f()
# print('在函数f内部打印num2的值', num2) # 报错
print('在函数f执行后打印num1的值', num1)运行结果：
在函数f外部打印num1的值 10
在函数f内部打印num1的值 20
num2的值 20
在函数f执行后打印num1的值 10若将num1声明为全局变量：
# 全局变量
num1 = 10 # 不可变数据类型
def f():
global num1
num2 = 20 # 局部变量
num1 = 20
print('在函数f内部打印num1的值', num1)
print('num2的值',num2)
print('在函数f外部打印num1的值', num1)
f()
# print('在函数f内部打印num2的值', num2) # 报错
print('在函数f执行后打印num1的值', num1)运行结果：
在函数f外部打印num1的值 10
在函数f内部打印num1的值 20
num2的值 20
在函数f执行后打印num1的值 20例2：
list = [1,2,3,4,5] # 可变数据类型
def f():
list[2] = 8
print('在函数f内部打印list的值', list)
f()
# print('在函数f内部打印num2的值', num2) # 报错
print('在函数f执行后打印list的值', list)运行结果：
在函数f内部打印list的值 [1, 2, 8, 4, 5]
在函数f执行后打印list的值 [1, 2, 8, 4, 5]三、匿名函数
- lambda函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方
- 优点：让代码更加精简，不需要考虑命名的问题
# 常规函数
def fun(x,y):
return x + y
# 匿名函数
a= lambda x，y:x + y
print(fun(2，3))例1：map函数，功能：映射
# (1)
# a = [1,2,3,4,5]
# b =[]
# for i in a:
# b.append(i**2)
# print(b)
# (2)
# a = [1,2,3,4,5]
# for i in range(len(a)):
# a[i] = a[i]**2
# print(a)
# (3)
# a = [1,2,3,4,5]
# def f(x):
# return x**2
# result = map(f,a)
# print(list(result))
# (4)
a = [1,2,3,4,5]
result = map(lambda x:x**2,a)
print(list(result))运行结果：
[1, 4, 9, 16, 25]例2：reduce函数，功能：累积
a = [1,2,3,4,5]
from functools import reduce
result = reduce(lambda x,y:x+y,a)
print(result)运行结果：
15例3：filter函数，功能：过滤
a = [1,2,3,4,5]
result = filter(lambda x:x%2==0,a)
print(list(result))运行结果：
[2, 4]四、内置函数
1.内置函数
| 函数 | 用途 |
| abs() | 对传入参数取绝对值 |
| bool() | 对传入参数取布尔值，None，0，""，{}，[]，（）这些参数传入bool后，返回False |
| all() | 所有传入参数为真，才为真 |
| any() | 任何一个传入参数为真，才为真 |
| ascii() | 自动执行传入参数的_repr_方法（将对象转换为字符串） |
| bin() | 接收一个十进制，转换成二进制 |
| oct() | 接收一个十进制，转换成八进制 |
| hex() | 接收一个十进制，转换成十六进制 |
| bytes() | 字符串转换成字节。第一个传入参数是要转换的字符串，第二个参数按什么编码转换为字节 |
| str() | 字节转换成字符串。第一个传入参数是要转换的字节，第二个参数是按什么编码转换成字符串 |
| chr(65) | 数字转字母，查看ASCII码表 |
| ord('A') | 字母转数字，查看ASCII码表 |
| compile() | 接收.py文件或字符串作为传入参数，将其编译成python字节码 |
| eval() | 执行python代码，并返回其执行结果。 |
| exec() | 执行python代码（可以是编译过的，也可以是未编译的），没有返回结果（返回None） |
| dir() | 接收对象作为参数，返回该对象的所有属性和方法 |
| 函数 | 用途 |
| help() | 接收对象作为参数，更详细地返回该对象的所有属性和方法 |
| divmod(100,10) | 返回一个元组（10，0），第一个元素的100/10的商，第二个元素的100/10的余数 |
| enumerate() | 接收序列化类型的数据，返回一个迭代器（对象） |
| isinstance(object,class) | 判断对象是否是某个类的实例 |
| filter() | 对可迭代对象中的每一个元素，将其作为实参传入函数（或lambda表达式），如果函数返回False，将该元素丢弃，如果函数返回True，将该元素添加到6lter的返回值中。注意ilter返回的是一个filter对象，实际应用中往牲需要用list或tuple将其转换为列表或元组类型 |
| map() | 对可选代的每一个元素，将其作为实参传入函数，将每一次调用函数返回的结果都添加到map的返回值中 |
| format() | 字符串格式化 |
| frozenset() | 转换为不可变的集合 |
| globals() | 返回一个字典，包括所有的全局变量与它的值所组成的键值对 |
| locals() | 返回一个字典，包括所有的局部变量与它的值所组成的键值对 |
| hash() | 对传入参数取哈希值井返回 |
| id() | 返回内存地址，可用于查看两个变量是否指向相同一块内存地址 |
| input('please input:') | 提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型） |
| issubclass(subclass,class) | 查看这个类是否是另一个类的派生类，如果是返回True，否则返回False |
| 函数 | 用途 |
| len() | 返回长度 |
| max() | 接收序列化类型数据，返回其中值最大的元素 |
| min() | 返回其中值最小的元素 |
| memoryvlew() | 查看内存地址 |
| next() | |
| iter() | |
| object() | |
| pow(x,y) | 求次方，返回x**y的结果 |
| pow(x.y,z) | 返回x**y%z的结果 |
| property) | 获取对象的所有属性 |
| range() | 获取随机数或随机字符eg.range（10）从0到10的随机数 |
| repr() | 执行传入对象中的_repr_方法 |
| reversed() | 对序列化类型数据反向排序，返回一个新的对象。注意与对象的reverse方法区别，后者是就地改变对象 |
| sorted() | 对序列化类型数据正向排序，返回一个新的对象。注意与对象的sort方法区别，后者是就地改变对象 |
| slice() | 对序列化类型数据切片，返回一个新的对象。 |
| 函数 | 用途 |
| round() | 返回四舍五入后的结果 |
| int() | 转换为整型 |
| list() | 转换为列表类型 |
| set() | 转换为集合类型 |
| str() | 转换为字符串类型 |
| tuple() | 转换为元组类型 |
| type() | 返回对象类型 |
| staticmethod() | 返回静态方法 |
| super() | 返回基类 |
| vars() | 返回当前模块中的所有变量 |
| zip() | 接收多个序列化类型的数据，对各序列化数据中的元素，按索引位置分类成一个个元组 |
2.递归函数
（1）递归
- 一个函数调用自身称为递归调用
- 一个会调用自身的函数称为递归函数
（2）递归的过程
- ①写出临界条件
- ②找这一次和上一次的关系
- ③假设当前函数已经能用，调用自身计算上一次结果，再求出本次结果当参数满足一个条件时,函数不再执行
例：上台阶问题，一共10阶楼梯，每次上1个台阶或者2个台阶，问一共有多少种走法
def f(n):
if n == 0:
return 0
elif n == 1:
return 1
elif n == 2:
return 2
return f(n-1)+f(n-2)
for i in range(11):
print('楼梯有%d阶时，有%d种走法'%(i,f(i)))运行结果：
楼梯有0阶时，有0种走法
楼梯有1阶时，有1种走法
楼梯有2阶时，有2种走法
楼梯有3阶时，有3种走法
楼梯有4阶时，有5种走法
楼梯有5阶时，有8种走法
楼梯有6阶时，有13种走法
楼梯有7阶时，有21种走法
楼梯有8阶时，有34种走法
楼梯有9阶时，有55种走法
楼梯有10阶时，有89种走法用循环实现：
a = [0,1,2]
for i in range(3,11):
a.append(a[i-1] + a[i-2])
print('楼梯有%d阶时，有%d种走法'%(i,a[-1]))
运行结果：
楼梯有3阶时，有3种走法
楼梯有4阶时，有5种走法
楼梯有5阶时，有8种走法
楼梯有6阶时，有13种走法
楼梯有7阶时，有21种走法
楼梯有8阶时，有34种走法
楼梯有9阶时，有55种走法
楼梯有10阶时，有89种走法五、练习题：名片管理系统
1.需求分析
（1）程序启动，显示名片管理系统欢迎界面，并显示功能菜单
- 功能：新建名片、显示全部、查询名片、退出系统
（2）用户用数字选择不同的功能
（3）根据功能选择，执行不同的功能
（4）用户名片需要记录用户的姓名、电话、QQ、邮箱
（5）如果查询到指定的名片，用户可以选择修改或者删除名片
2.任务分解
- 增、删、改、查
3.数据结构设计
- 字典、列表
4.代码实现
cards = [{'name': '-17', 'phone': '123', 'qq': '123', 'email': '123'},
{'name': 'cy', 'phone': '456', 'qq': '456', 'email': '456'},
{'name': 'ly', 'phone': '789', 'qq': '789', 'email': '789'}]
def menu():
print('*'*20)
print('''欢迎使用【名片管理系统】
1.新建名片
2.显示全部
3.查询名片
0.退出系统''')
print('*' * 20)
def new_card(name,phone,qq,email):
user = {
'name':name,
'phone':phone,
'qq':qq,
'email':email
}
cards.append(user)
return True
# def modify_card():
# pass
#
# def del_card():
# pass
def show_card():
for card in cards:
print(card)
def query_card(kw):
for card in cards:
for k,v in card.items():
if kw == v:
return card
return False
def quit():
print('欢迎下次使用【名片管理系统】')
menu()
while True:
op = input('请输入你要操作的序号：')
if op=='1':
name = input('请输入你的姓名：')
phone = input('请输入你的电话：')
qq = input('请输入你的QQ号：')
email = input('请输入你的邮箱：')
result = new_card(name,phone,qq,email)
if result:
print('添加成功')
else:
print('请重试')
elif op=='2':
show_card()
elif op=='3':
kw = input('请输入查询的关键字：')
result = query_card(kw)
if result:
print(result)
# op2 = input('输入4修改名片，输入5删除名片：')
# if op2=='4':
# modify_card()
# if op2=='5':
# del_card()
else:
print('查无此人')
elif op=='0':
quit()
break
else:
print('请重试')测试结果：
********************
欢迎使用【名片管理系统】
1.新建名片
2.显示全部
3.查询名片
0.退出系统
********************
请输入你要操作的序号：1
请输入你的姓名：yy
请输入你的电话：147
请输入你的QQ号：147
请输入你的邮箱：147
添加成功
请输入你要操作的序号：2
{'name': '-17', 'phone': '123', 'qq': '123', 'email': '123'}
{'name': 'cy', 'phone': '456', 'qq': '456', 'email': '456'}
{'name': 'ly', 'phone': '789', 'qq': '789', 'email': '789'}
{'name': 'yy', 'phone': '147', 'qq': '147', 'email': '147'}
请输入你要操作的序号：3
请输入查询的关键字：cy
{'name': 'cy', 'phone': '456', 'qq': '456', 'email': '456'}
请输入你要操作的序号：3
请输入查询的关键字：147
{'name': 'yy', 'phone': '147', 'qq': '147', 'email': '147'}
请输入你要操作的序号：3
请输入查询的关键字：1656
查无此人
请输入你要操作的序号：221
请重试
请输入你要操作的序号：0
欢迎下次使用【名片管理系统】
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
