1.函数：就是对实现某一特定功能的代码块的封装
2.作用：封装(将功能绑定在一个函数中，想要使用这个功能的时候，直接调用函数)
3.怎么声明函数:
def 函数名(参数列表):
'''函数说明'''
函数体
def: 是python中声明函数的关键字
函数名: 标识符。PEP8。见名知义(看到函数名要大概知道函数的功能)
函数说明: 对函数的功能和参数以及返回值进行说明
(): 是固定格式
参数列表：（形参列表）参数名1，参数名2，参数名3...。
参数的功能是用来接收从外部传到函数内部的数据
函数体：实现函数功能的代码块，可能会包含一个return语句
4.初学者声明函数的步骤:
a.确定函数的功能
b.确定函数名
c.确定参数
确定需不需要参数
确定需要几个参数
(看实现函数的功能需不需要从外面传数据到函数里面)
d.实现函数的功能
e.确定返回值
5.函数的调用
函数名(实参列表)
函数名：调用的函数一定是已经声明过的，想要使用什么功能就调用对应的函数
实参列表：实参是用来给形参赋值的
函数的调用过程:
0.回到函数声明的地方
1.使用实参给形参赋值
2.执行函数体
3.函数体执行完成后，回到函数调用的位置
注意：
1.函数只有在调用的时候才会执行
2.函数调用的时候一定要保证每个形参都有值
3.一个函数可以调用多次
例子：写一个函数，计算两个数的和
def my_sum(number1, number2):
"""
（这儿写函数的功能的描述）求两个数的和
:param number1: 提供第一个数，int
:param number2: 提供第二个数，int
:return: 对返回值进行说明
"""
print(number1, number2)
print('=====')
print(number1+number2)
# 函数的调用一定要写在函数的声明后面
my_sum(10, 300)
函数的参数：
参数的作用: 从函数的外面给函数传值
1.位置参数
传参的时候，实参按顺序给形参赋值
def func1(a, b, c):
print(a, b, c)
func1(10, 20, 30)
2.关键字参数
调用函数的时候：
函数名(参数=值)
func1(b=20, a=10, c=30)
说明：位置参数和关键字参数可以混着来书写
print('====')
func1(10, c=30, b=20)
def func11(a, b='cc', c='bb', d='a'):
print(a,b,c,d)
func11(10, d='100')
3.参数的默认值
python中函数声明的时候参数可以设置默认值,有默认值的参数必须放在参数列表的最后
调用参数有默认值的函数，有默认值的参数可以传参也可以不传参
def func2(b, a=10, c=100):
print(a, b, c)
func2(10, 20, 30)
func2(10, 20)
4.参数个数不定
函数参数的个数不确定的时候，就在声明函数的时候，形参的前面加一个*，将形参变成元组。
调用函数的时候，这个参数会将对应的实参作为元组的元素保存起来
例子：写一个函数，求多个数的和
def my_sum(*numbers):
print(numbers)
sum1 = 0
for item in numbers:
sum1 += item
print(sum1)
my_sum(10, 20, 22, 10, 20)
注意：参数个数不定，可以是形参中的一部分是不定的
个数不确定的参数要放到放参数的最后
def func1(char, *numbers):
print(char, numbers)
func1('a', 10, 20, 39) #打印结果： a (10, 20, 39)
参数个数不定，也可以不传参，对应的参数的值就是一个空的元组
func1('a')
1.函数的返回值:
a.就是函数返回给调用者值
b.就是return关键字后面的表达式的值
c.就是函数调用表达式的值
python中每个函数都是有返回值的，返回值就是return后面的值。如果函数中没有return，那么函数的返回值就是None
函数的调用：
a.先回到函数调用的位置
b.用实参给形参赋值(传参)
c.执行函数体
d.执行完函数体，将返回值返回给函数调用表达式
c.回到函数调用的位置
函数的函数体只有在调用后才会执行
2. return关键字
a. 将return后面的值，返回给函数调用表达式
b. 结束函数
3.函数调用表达式：
python中每个函数调用表达式的都是有值
def func1():
print('aaaa')
a = func1() # 函数调用表达式
print(a, func1()) #aaaa aaaa
def my_sum(x, y):
# x = 10, y=20
print('bbb')
return x + y # return 30
num = my_sum(1, 3)
print(my_sum(10, 20))
例子：写一个函数，判断指定的年龄是否属于成年人（返回结果）
def is_adult(age):
if age >= 18:
return True
else:
return False
if is_adult(10):
print('可以进网吧')
else:
print('未成年人禁止进入')
3.函数的结束:
a. 函数体执行完
b. 遇到return
def func2():
print('123')
return 10
print('321')
print(func2())
例子：写一个函数，求1+2+3+...+N，和不能大于10000
def my_sum2():
sum1 = 0
number = 1
while True:
if sum1 + number >= 10000:
return sum1, number-1
# python中函数可以有多个返回值，在return后面返回多个值，每个值之间用逗号隔开。返回值是一个元组
sum1 += number
number += 1
print(my_sum2())
作用域: 一个变量可以使用的范围，就是这个变量的作用域（函数和类可以影响变量的作用域）
全局变量: 从声明开始，到文件结束都可以使用
局部变量: 在函数(类)中声明的变量是局部变量。作用域是从声明开始到函数结束
1.全局变量
a = 10 # 这是一个全局变量
print(a)
def func1():
print(a)
for x in range(10):
b = 100 # 这个变量是全局
print(b)
print(a)
print('===', b)
def func2():
print(b)
func2()
2.局部变量
def func3():
aaa = 200 # 局部变量，作用域是函数
print(aaa)
func3()
# print(aaa) # 报错: NameError: name 'aaa' is not defined
3.global和nonlocal
global: 在函数中声明一个全局变量
格式:
global 变量名
变量名 = 值
abc = 'abc' # 全局变量
bcd = 'bcd'
def func4():
abc = 'aaa' # 局部变量，如果全局变量名和局部变量名相同，在函数中使用的是局部变量
print(abc)
global bcd # 说明bcd是一个全局变量
bcd = 200
print(bcd)
func4()
print(abc)
print(bcd)
练习：声明一个变量，统计一个函数调用的次数
count = 0
def my_func():
global count
count += 1
print('====')
my_func()
my_func()
print('0----')
a = 10
my_func()
print(count)
nonlocal:在函数中声明函数的时候，才需要使用
def func11():
a_11 = 10
print('外部:', a_11)
# python中函数里面可以声明函数
def func12():
nonlocal a_11 # 使用nonlocal修饰后的变量还是局部变量
a_11 = 100
print('内部:', a_11)
print('内部函数')
func12()
print('外部:', a_11)
func11()
# print(a_11)
匿名函数：本质函数函数，以另外一种简单的方式来声明
匿名函数的声明：
函数名 = lambda 参数列表:返回值 ---> 结果是一个函数变量
lambda：声明匿名函数的关键字
例子:写一个函数计算两个数的和
def my_sum1(x, y):
return x+y
print(my_sum1(10, 20))
# 匿名函数
my_sum2 = lambda x, y=10: x+y
print(my_sum2(10, 20))
funcs = []
for i in range(5):
funcs.append(lambda x: x*i)
print(funcs[2](2))
print(funcs[4](2))
print(i)
(了解)
1.声明一个函数就是在声明一个变量。函数名可以当成变量来使用。类型是：function
可以打印，可以赋值，可以查看类型，可以作为函数的参数，可以作为函数的返回值
a = 10
a = 'a'
print(a)
# 函数名func1可以当成变量使用
def func1(a):
print(a)
return 10
print(func1, type(func1))
# 将函数func1赋给变量a,这个时候a就是一个函数
a = func1
b = func1(10) + 100
a('aaa')
# 将函数func1作为列表的元素
functions = [func1, func1(10)]
functions[0]('abc')
"""1.将函数作为参数"""
def my_sum(*numbers):
""" numbers = (10, 20) """
sum1 = 0
for item in numbers:
sum1 += item
return sum1
def my_mul(*numbers):
sum1 = 1
for item in numbers:
sum1 *= item
return sum1
def operation(method, *numbers):
"""
method = my_sum
numbers = (10,20)
return my_sum((10, 20, 30))
"""
a = ('1', 100, 'c')
print(*a)
print(*numbers)
return method(*numbers)
# 求10和20的和
print('+++++')
result = operation(my_sum, 10, 20)
# 求10*20
result2 = operation(my_mul, 10, 20)
# 判断10是否大于20
reslut3 = operation(lambda x,y:xy else y,10, 20)
python中三目运算符(?:)
值1 if 表达式 else 值2 ---> 判断表达式是否为True,为True整个表达式的结果是'值1'，否则是'值2'
a = 10 if 10 > 20 else 20
print(result, result2, reslut3, result4)
3.将函数作为函数的返回值
写一个函数有个参数，要求传入一个运算符号(+,-,*,>,<),返回符号对应的功能
# + ——-> 求和功能
# - --->求差功能
# ....
funca = lambda x,y:x+y
def funb(x, y):
return x+y
def get_method(char):
""" char='-' """
if char == '+':
return funb
elif char == '-':
def func(m, n):
return m - n
return func
elif char == '*':
return lambda x,y:x*y
elif char == '>':
def func(x, y):
return x > y
return func
elif char == '<':
return lambda x, y: x < y #匿名函数
else:
def func(x, y):
return None
return func
print(get_method('+')(10, 20))
print(get_method('-')(10, 20))
print(get_method('%')(10, 20))
递归函数
1.什么是递归
递归函数:在函数的函数体中调用函数本身
理论上循环能做的事情，递归都可以
对递归的要求: 能不用就不用
函数调用的过程是一个压栈的过程(没调用一次函数，系统都要为其分配内存空间，
用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁)
# 这个函数就是递归函数
def fun1():
print('===')
fun1()
2.怎么写一个递归函数
a.找临界值(跳出循环 -> return)
b.找关系:假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
c.使用f(n-1)与前面找到关系去实现f(n)的功能
例子：写一个递归函数实现:1+2+3+...n
# 普通函数
def my_sum(n):
sum1 = 0
for x in range(1, n+1):
sum1 += x
return sum1
print(my_sum(5))
# 递归函数
def my_sum2(n):
# 1.找到临界值
if n == 1:
return 1
# 2.找my_sum2(n)和my_sum2(n-1)的关系：
"""
my_sum2(n): 1+2+3+...+n-1+n
my_sum2(n-1): 1+2+3+...+n-1
关系: my_sum2(n) = my_sum2(n-1)+n
"""
# 3.使用my_sum2(n-1)去实现my_sum2(n)的功能
return my_sum2(n-1)+n
print(my_sum2(5))
"""
过程：
my_sum2(5)
my_sum2(5) n = 5 return 1+2+3+4+5
my_sum2(4) n = 4 return 1+2+3+4
my_sum2(3) n = 3 return 1+2+3
my_sum2(2) n = 2 return 1+2
my_sum2(1) n = 1 return 1
"""
2.用递归求2*4*6*...n(n是偶数)
def mul(x):
# 1.找临界值
if x == 2:
return 2
# 2.找关系
"""
f(x) = f(x-2)*x
"""
return mul(x-2)*x
print(mul(6))
"""
用递归函数实现以下功能
n = 3
***
**
*
n = 4
****
***
**
*
"""
def prin_star(n):
# 1.找临界值
if n == 1:
print('*')
return
# 2.找关系
"""
f(n)
****
***
**
*
f(n-1)
***
**
*
关系：先打印n个*,然后f(n-1)
"""
prin_star(n - 1)
print('*'*n)
print(prin_star(3))