1 函数
1.1 函数的定义
- 函数以def关键词开头，后接函数名和圆括号()。
- 函数执行的代码以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。
def functionname(parameters):
"函数_文档字符串"
function_suite
return [expression]1.2 函数的调用
def add(a,b):
return a+b
a=1
b=2
print(add(a,b))
print([1,2,3]+[4,5,6])3
[1, 2, 3, 4, 5, 6]
1.3 函数文档
def printfunction(name):
"函数定义过程中的name是形参"
#因为它只是个形式，表示占用一个位置
print('这是第一个函数输出内容：{0}'.format(name))
printfunction("一本书的内容")
print(printfunction.__doc__)
help(printfunction)这是第一个函数输出内容：一本书的内容
函数定义过程中的name是形参
Help on function printfunction in module __main__:
printfunction(name)
函数定义过程中的name是形参
1.4 函数参数
Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：
- 位置参数 (positional argument)
- 默认参数 (default argument)
- 可变参数 (variable argument)
- 关键字参数 (keyword argument)
- 命名关键字参数 (name keyword argument)
- 参数组合
- 位置参数
def functionname(arg1):
"函数_文档字符串"
function_suite
return [expression]- arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。
- 默认参数
def functionname(arg1,arg2=v):
"函数_文档字符串"
function_suite
return [expression]- arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
- 默认参数一定要放在位置参数 后面，不然程序会报错。
def info(name,age=10):
print('{0}：{1}'.format(name,age))
info('小马')
info('小马',20)小马：10
小马：20
- Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def info(name,age=10):
print('{0}:{1}'.format(name,age))
info(age=12,name='小马')小马:12
- 可变参数
顾名思义，可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。
def functionname(arg1, arg2=v, *args):
"函数_文档字符串"
function_suite
return [expression]*args- 可变参数，可以是从零个到任意个，自动组装成元组。- 加了星号（*）的变量名会存放所有未命名的变量参数。
def printfunc(arg1,*arg2):
print(arg1)
for i in arg2:
print("可变：",i)
printfunc(1,2,3,4,3,2)
printfunc(1)1
可变： 2
可变： 3
可变： 4
可变： 3
可变： 2
1
- 关键字参数
def functionname(arg1, arg2=v, *args, **kw):
"函数_文档字符串"
function_suite
return [expression]**kw- 关键字参数，可以是从零个到任意个，自动组装成字典。
def printfunc(arg1,*arg2,**arg3):
print(arg1)
print('可变参数：',arg2)
print('关键字参数：',arg3)
printfunc(1,2,3,4)
printfunc(1,2,3,4,'w',a=1,b=2,c=3)1
可变参数： (2, 3, 4)
关键字参数： {}
1
可变参数： (2, 3, 4, 'w')
关键字参数： {'a': 1, 'b': 2, 'c': 3}
「可变参数」和「关键字参数」的同异总结如下：
- 可变参数允许传入零个到任意个参数，它们在函数调用时自动组装为一个元组 (tuple)。
- 关键字参数允许传入零个到任意个参数，它们在函数内部自动组装为一个字典 (dict)。
- 命名关键字参数
def functionname(arg1, arg2=v, *args, *, nkw, **kw):
"函数_文档字符串"
function_suite
return [expression]*, nkw- 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。- 如果要限制关键字参数的名字，就可以用「命名关键字参数」
- 使用命名关键字参数时，要特别注意不能缺少参数名。
def printfunc(arg1,*,arg2,**arg3):
print(arg1)
print(arg2)
print(arg3)
printfunc(10,arg2='www',a=10,b=20,c=30)
10
www
{'a': 10, 'b': 20, 'c': 30}
- 参数组合
在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：
- 位置参数、默认参数、可变参数和关键字参数。
- 位置参数、默认参数、命名关键字参数和关键字参数。
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args 接收的是一个 tuple**kw是关键字参数，kw 接收的是一个 dict
命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名关键字参数不要忘了写分隔符 *，否则定义的是位置参数。
警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。
1.5 函数的返回值
def add(a,b):
return(a+b)
print(add(1,2))3
1.6 变量作用域
- Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
- 定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
- 定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
- 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问
def discount(price,rate):
new_price=price*rate
return new_price
oldprice=float(input('请输入商品的价格：'))
rate1=float(input('请输入折扣：'))
price=discount(oldprice,rate1)
print('当前商品的价格是：',price)请输入商品的价格：98
请输入折扣：0.96
当前商品的价格是： 94.08
- 当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。
num=1
def printfunc():
global num# 需要使用 global 关键字声明
print(num)
num=123
print(num)
printfunc()
print(num)1
123
123
内嵌函数
def outer():
print('outer函数在这里被调用')
def inner():
print('inner函数在这里被调用')
#inner()
outer()
outer函数在这里被调用
闭包
- 是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
- 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
- 通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。
def funx(x):
def funy(y):
return x*y
return funy
i=funx(8)
print(i)
print(type(i))
print(i(5))
print(funx(8)(9))<function funx.<locals>.funy at 0x000001A58EB57798>
<class 'function'>
40
72
闭包的返回值通常是函数。
def make_counter(init):
counter=[init]
def inc():
counter[0]+=1
def dec():
counter[0]-=1
def get():
return counter[0]
def reset():
counter[0]=init
return inc,dec,get,reset
inc,dec,get,reset=make_counter(0)
inc()
inc()
print(get())
dec()
print(get())
reset()
print(get())2
1
0
如果要修改闭包作用域中的变量则需要 nonlocal 关键字
def outer():
num=10
def inner():
num=100
print(num)
inner()
print(num)
outer()100
10
def outer():
num=10
def inner():
nonlocal num # nonlocal关键字声明
num=100
print(num)
inner()
print(num)
outer()100
100
递归
- 如果一个函数在内部调用自身本身，这个函数就是递归函数。
# 循环
n=5
for i in range(1,5):
n=n*i
print(n)
120
# 递归
def factorial(n):
if n==1:
return 1
return n*factorial(n-1)
print(factorial(5))120
斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1
def fbnq(n):
if n<=1:
return n
return fbnq(n-1)+fbnq(n-2)
print(fbnq(6))
k=[]
for i in range(10):
k.append(fbnq(i))
print(k)8
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
设置递归的层数，Python默认递归层数为 100
import sys
sys.setrecursionlimit(1000)2 lambda 表达式
2.1 匿名函数的定义
在 Python 里有两类函数：
- 第一类：用 def 关键词定义的正规函数
- 第二类：用 lambda 关键词定义的匿名函数
python 使用 lambda 关键词来创建匿名函数，而非 def 关键词，它没有函数名，其语法结构如下：
lambda argument_list: expression<function __main__.<lambda>(argument_list)>
- lambda - 定义匿名函数的关键词。
- argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
- :- 冒号，在函数参数和表达式中间要加个冒号。
- expression - 只是一个表达式，输入函数参数，输出一些值。
注意：
- expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
- 匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
def sqr(x):
return x**2
print(sqr)<function sqr at 0x000001A58EB741F8>
y=[sqr(x) for x in range(10)]
print(y)[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
sqr2=lambda x:x**2
print(sqr2)<function <lambda> at 0x000001A58EB8D048>
y=[sqr2(x) for x in range(10)]
print(y)[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
sumfunc=lambda x1,x2:x1+x2
y=sumfunc(1,2)
print(y)3
sumfunc2=lambda *x:sum(x)
y=sumfunc2(1,2,3,4)
print(y)10
2.2 匿名函数的应用
函数式编程 是指代码中每一块都是不可变的，都由纯函数的形式组成。这里的纯函数，是指函数本身相互独立、互
不影响，对于相同的输入，总会有相同的输出，没有任何副作用。
#非函数式编程
def f(x):
for i in range(0,len(x)):
x[i]+=10
return x
a=[1,3,5,7,9]
print(f(a))
print(a)[11, 13, 15, 17, 19]
[11, 13, 15, 17, 19]
#函数式编程
def f(x):
y=[]
for i in x:
y.append(i+10)
return y
a=[1,3,5,7,9]
print(f(a))
print(a)
[11, 13, 15, 17, 19]
[1, 3, 5, 7, 9]
def f(x):
x2=[i+10 for i in x]
return x2
a=[1,3,5,7,9]
print(f(a))
print(a)
[11, 13, 15, 17, 19]
[1, 3, 5, 7, 9]
匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：
- 参数是函数 (filter, map)
- 返回值是函数 (closure)
如，在 filter 和 map 函数中的应用：
- filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为 列表，可以使用 list() 来转换。
- map(function, *iterables) 根据提供的函数对指定序列做映射
odd=lambda x:x%2==1
y=filter(odd,[1,2,3,4,5,6,7])
print(y)
print(list(y))<filter object at 0x000001A58EB620C8>
[1, 3, 5, 7]
func1=lambda x:x**2
y=map(func1,[1,2,3,4,5,6,7])
print(y)
print(list(y))<map object at 0x000001A58EB65DC8>
[1, 4, 9, 16, 25, 36, 49]
除了 Python 这些内置函数，我们也可以自己定义高阶函数。
def funcx(func,x):
return func(x)
a=[1,2,3,4,5]
print(funcx(sum,a))
print(funcx(len,a))
print(funcx(print,a))
print(funcx(lambda x:sum(x)/len(x),a))15
5
[1, 2, 3, 4, 5]
None
3.0
练习题：
- 怎么给函数编写⽂档？
def printc(x):
'打印！'
print(x)
x=[12,2,3,4]
print(printc.__doc__)打印！
- 怎么给函数参数和返回值注解？
def sumfunc(*a):
return(sum(a))
print(sumfunc(1,2,3,4))
10
- 闭包中，怎么对数字、字符串、元组等不可变元素更新
def outer():
num=10
def inner():
nonlocal num # nonlocal关键字声明
num=100
print(num)
inner()
print(num)
outer()100
100
- 分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)
func1=lambda *x:sorted(x[0])
a=[[6,5],[3,7],[2,8]]
print(a)
print(func1(a[:]))
func2=lambda *x:sorted(x[1])
print(func2(a[:]))[[6, 5], [3, 7], [2, 8]]
[[2, 8], [3, 7], [6, 5]]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-83-c6691f632d28> in <module>
4 print(func1(a[:]))
5 func2=lambda *x:sorted(x[1])
----> 6 print(func2(a[:]))
<ipython-input-83-c6691f632d28> in <lambda>(*x)
3 print(a)
4 print(func1(a[:]))
----> 5 func2=lambda *x:sorted(x[1])
6 print(func2(a[:]))
IndexError: tuple index out of range
- 利用python解决汉诺塔问题？
有a、b、c三根柱子，在a柱子上从下往上按照大小顺序摞着64片圆盘，把圆盘从下面开始按大小顺序重新摆放在c 柱子上，尝试用函数来模拟解决的过程。（提示：将问题简化为已经成功地将a柱上面的63个盘子移到了b柱）
扫一扫
4348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
