day10_函数基础2

前言回顾

1.函数的定义：函数就是对实现某一特定功能的代码块的封装
2.函数的声明：

def 函数名(形参列表):
函数体 - 两部分组成(声明文档，代码块)

注意：1.python中不支持函数的重载(名字相同的函数只能有一个)
2.声明函数的时候函数体不会执行

3.函数的调用 - 调用函数必须在声明函数之后

函数名(实参列表)

(重点！)函数的调用过程：

回到函数声明的位置

传参

执行函数体

执行完函数，确定函数返回值
怎么确定返回值：看执行完函数有没有遇到return，如果遇到return后面的值就是函数的返回值，否则就是None

回到函数调用的位置，接着往后执行 (这个时候函数调用表达式的值就是函数的返回值)

def func1(a=10):
    print('函数1')
    func2()  # 此处func2存在，是因为python是解释性语言，在没有调用的时候，是不会执行函数里面的函数体的

# func1()  # func1 在此位置会出错，因为func2()还没声明

def func2():
    print('函数2')

func1()  # 此处func1和func2都已经声明了，不会报错
print('=====')

4.函数的参数

位置参数和关键字参数(位置参数要在关键字参数前)

参数默认值 (没有默认值的参数要放在有默认值的参数前面)

函数中参数和返回值类型说明

不定长参数
参数名，参数名 (为位置参数 ->多个数据返回元组，**为关键字参数 -> 多个数据返回字典)

def func3(b: str, a=10) -> int:  # -> 说明返回值类型
    a = 10
    if a >=10:
        print('大于等于10')
    print('函数3')
    return 10

result = func3('abc')
print(result)

print(func3('abc') * 100)

def func4() -> str:  # 说明返回值为str
    return 'abc'

print(func4())
print('======')

5.返回值

怎么确定返回值：看return
2)怎么获取返回值：使用函数调用表达式

def func6(a, b, c):
    print('abc:', a, b, c)

def func5(*num):
    print(*num)  # 容器加*，是将容器中的元素都拿出来
    # func6(10, 20, 30)
    func6(*num)
    
    # range(12, 34, 56)
    for x in range(*num):  # num中的元素自动填充，放在range里面，最后一个数就是步长
        print('===:', x)  # ===: 12

func5(12, 34, 56)

print('+++++++++')
def func7():
    print('=======')
    return 'abc'

print(func7()[0])  # func7返回后(返回'abc')，然后切片(即为'a')

for x in func7():
    print(x)

匿名函数

1.什么是匿名函数

匿名函数就是没有名字的函数

语法

lambda 参数列表：返回值

说明

lambda - 关键字
参数列表 - 相当于普通函数的形参列表，变量1，变量2...
： - 固定写法
返回值 - 相当于普通函数体中的return语句可以是除了赋值语句以外的任何语句

注意：1.匿名函数本质还是函数，之前函数中的语法绝大多数都使用(通过类型名对参数类型进行说明不支持如：-> x:int)
2.匿名函数能做的事情，普通函数都能做，只是匿名函数简洁

用匿名函数求两个数的和

func = lambda x, y=20: x+y

print(func(10, 20))  # 位置参数也支持
print(func(y=10, x=20))  # 关键字参数也支持
print(func(10))

# func = lambda x: int, y=20: x+y  # 不支持x: int 匿名函数无法识别:

func1 = lambda *num: sum(num)
print(func1(1, 2, 3))

# lambda x, y: x+y的意义如下：
# def func(x, y):
#     return x+y

print('=====')
func2 = lambda x, y: x if x>y else y
print(func2(3, 5))

例如用匿名函数实现用某一关键字进行排序

students = [
    {'name': '张三', 'age': 20},
    {'name': '李四', 'age': 19},
    {'name': '王五', 'age': 18}
]

students.sort(key=lambda stu: stu['age'])
print(students)

===匿名函数就是函数的值的理解===

10      # int的值
a = 10
print(type(a))

'abc'   # str的值
str1 = 'abc'
print(type(str1))

[10, 39, 90]    # list的值
list1 = [10, 39, 90]
print(type(list1))

{'a': 10, 'b': 100} #dict的值
dict1 = {'a': 10, 'b': 100}
print(type(dict1))

lambda x, y: x+y    # function的值
func1 = lambda x, y: x+y
print(type(func1))

1.变量的作用域

指的就是变量的使用范围

2.全局变量、局部变量

全局变量：没有声明在函数/类中的变量都是全局变量，全局变量的作用域是从变量[声明]开始到整个py[文件结束]
局部变量：声明在函数中的变量都是局部变量，局部变量的作用域是从变量[声明]到[函数结束]
注意：形参也是局部变量

当在调用函数的时候，系统会自动的在内存的栈区间为这个函数开辟一个独立的内存区域，
用来保存在函数中声明或者产生的数据，当函数调用结束后，这块内存区域会自动销毁

===全局变量===

a = 10  # a是全局变量
if True:
    print('if:', a)

for x in range(4):
    print('for:', x, a)

# num 全局变量
for num in range(3):
    temp = 100  # temp 全局变量
    print(num)

print('循环外', num)

def func2():
    print('函数里', num)

func2()

===局部变量===

# 函数里面声明的数是局部变量，函数的形参也是也是局部变量
def func3(xx):
    yy = 100
    print('函数中', xx, yy)

func3(10)
# print(xx)  # NameError: name 'xx' is not defined
# print(yy)  # NameError: name 'yy' is not defined

3.global和nonlocal

global - 在函数中声明一个全局变量(只能在函数中使用)
global 变量名
变量名 = 值 # 不可以把global和变量赋值放在一行
nonlocal - 在局部环境(函数内部)的局部中取修改一个局部变量的值，就使用nonlocal

===global===

# x1 = 100

def func4():
    global x1  # 说明后面的x1是全局变量
    x1 = 200
    
    # 只有下面一行时
    # x1 = 200  # 新增的局部变量x1，下面的print就近打印x1
    
    print('函数中', x1)

func4()
print('函数外面', x1)

===nonlocal===

def func5():
    x2 = 100

    def func6():
        nonlocal x2
        x2 = 200
        print('函数中的函数', x2)
    func6()
    
    print('函数中', x2)

func5()

声明函数是不会执行函数体的