python学习笔记07——函数

python学习笔记07——函数

调用与创建函数

def 函数名():

​ 函数体

函数调用只需要直接写函数名()

# 创建和调用函数
def myfunc():
    for i in range(3):
        print("循环三次")
myfunc()

循环三次
循环三次
循环三次

函数的参数

# 创建和调用函数
def myfunc2(name):
    for i in range(3):
        print(f"中括号里为传入的参数名{name}")
myfunc2("python")

中括号里为传入的参数名python
中括号里为传入的参数名python
中括号里为传入的参数名python

def 函数名（name，times）：

​ 函数体（里面一定会用到前面传进来的参数

函数名（实际参数，打印次数）

# 指定打印的次数
def myfunc3(name, times):
    for i in range(times):
        print(f"传递的参数{name}")
myfunc3("python",5)

传递的参数python
传递的参数python
传递的参数python
传递的参数python
传递的参数python

• 形参：提前占个位
• 实参：调用函数传递的值

函数的返回值

用return返回

# 函数的返回值
def div(x, y):
    z = x / y
    return z
print(div(4, 2))

2.0

如果函数体没有返回值return，那实际上也会返回一个none

函数的参数

位置参数

实参按照形参的位置进行传递，位置参数在关键字参数（赋值的时候把形参写上去）之前

# 函数的参数
def myfunc4(s, vt, o):
    return "".join((o, vt, s))
print(myfunc4("1", "2", "3"))

321

同时使用位置参数和关键字参数

默认参数

默认参数在后面

默认参数是指def myfunc(s, v=“他们”,t=“你们”)

收集参数

形参前面加星号，可以用.format收集信息

# 收集参数
def myfunc5(*args):
    print("有{}个参数".format(len(args)))
    print("第二个参数是：{}".format(args[1]))
myfunc5("aa", "bb")

有2个参数
第二个参数是：bb

函数可以同时返回多个值

python实际上利用元组打包

字符串format函数既可以元组形式收集也可以元组收集

解包参数

args1 = (1, 2, 3, 4)
def myfunc6(a , b, c, d):
    print(a, b, c, d)
myfunc6(*args1)

kwargs = {'a':1, 'b':2, 'c':3, 'd':4}
myfunc6(**kwargs)

1 2 3 4
1 2 3 4

作用域

变量可以被访问的位置

局部作用域

一个变量在函数内定义的，则其只能在函数内操作

全局作用域

在函数外部定义变量

global语句

# global语句
x = 880
def myfunc7():
    global x
    x = 520
    print(x)
myfunc7()
print(x)

520
520

函数定义了global变量，那么函数外的值也会随着函数内值的变化而变化

def funA():
    x = 520
    def funB():
        x = 880
        print("B")
    funB()
    print("A")
funA()

B
A
不能直接调用内部的funB函数，可以通过funA函数进行调用

nonlocal语句

nonlocal保证内部的不会影响外部的

LEGB

掌握python变量的解析机制

闭包

也称之为工厂函数，

闭包就是外部函数中定义一个内部函数，内部函数引用外部函数中的变量，外部函数的返回值是内部函数;

闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境) 在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures）， 是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。 所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。

闭包的特征
特征:

1.嵌套函数

2.内层函数引用了外层函数的变量

3.内层函数作为返回值返回给外层函数

特征2：

自由变量: 既不是局部变量，也不是模块全局变量；在闭包的时候：内层引用外层函数的变量

保存我们要执行代码的环境

执行的代码块和为自由变量提供绑定的计算环境两者的结合

# 定义闭包，完成的功能为:传入一个数求和并输出
def outer_summary():
    sum_data = []
    def summary(num):
        sum_data.append(num)
        print(sum(sum_data))
    return summary
summary = outer_summary()
summary(10)
summary(15)
summary(20)

10
25
45

装饰器

一个函数调用另一个函数

# 装饰器时间函数
import time
def time_master(func):
    print("开始运行")
    start = time.time()
    func()
    stop = time.time()
    print("结束程序")
    print(f"耗费时间{(stop-start):.2f}秒")
def myfunc():
    time.sleep(2)
    print("hello")
time_master(myfunc)

开始运行
hello
结束程序
耗费时间2.01秒

@time_master是装饰器的语法

多个装饰器可以用在同一个函数上

如何给装饰器传递参数？

lambda表达式

匿名函数

一行流

语法如下：

lambda args1, args2,args3,……argsn : expression

冒号左边是传入的参数，右边是表达式

# lambda表达式
squareY = lambda y : y * y
print(squareY(3))

9

lambda是一个表达式，可以放在列表里面

# lambda表达式
squareY = lambda y : y * y
print(squareY(3))
yy = [lambda x : x * x, 2, 3]
print(yy[0](yy[1]))

4

生成器

让函数在退出后还保持原来的状态

yield表达式替代return语句

## 生成器
def counter():
    i = 0
    while i<=5:
        yield i
        i += 1
counter()
for i in counter():
    print(i)
    
0
1
2
3
4
5

yield暂停状态

递归

函数自己调用自身的过程

# 递归
def funC(i):
    if i > 0:
        print("aaa")
        i -= 1
        funC(i)
funC(3)

aaa
aaa
aaa

求一个数的阶乘

# 求一个数的阶乘迭代
def fact(n):
    result = n
    for i in range(1, n):
        result *= i
    return result
print(fact(4))

# 求一个数的阶乘递归
def fact2(n):
    if n == 1:
        return 1
    else:
        return n * fact2(n-1)
print(fact2(4))

24
24

递归——斐波那契数列

递归——汉诺塔

函数文档、类型注释

help(函数名)

知道函数的名字

times._name_

times._annotations_

doc # 查看函数文档

高阶函数

min、max等

functools

偏函数

partial

# 偏函数
square = functools.partial(pow, exp = 2)
print(square(2))

4

@wraps装饰器