【无标题】

---

前言

函数

---

1.函数的语法结构

1.函数代码块以def开头，后接函数标识符名称和圆括号()
2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
3.函数的第一行语句可以选择性的使用文档字符串–用于存放函数说明
4.函数的内容以冒号起始，并且缩进
5.return[表达式]结束函数，选择性的返回一个值给调用方，不带表达式的retrun相当于返回none

# 计算面积函数
def area(width, height):
    return width * height
def printline(name):
    print(name)
printline("sdjh")
w = 4
h = 5
print("w= ", w, "height = ", h, "area = ", area(w, h))
运行结果：
sdjh
w=  4 height =  5 area =  20

2.return

return是函数中不可或缺的一部分。用于退出函数，选择性的向调用函数的调用方返回一个表达式，并把控制权一起返回，当不设置return 参数的时候，默认返回none而不是false.

def sum(arg1,arg2):
    "返回两个参数的和"
    total = arg1 +arg2
    print("函数内",total)
    return total


total = sum(10,20)
print("函数外",total)
运行结果：
函数内 30
函数外 30

3.参数传递

定义哈桑农户的时候，我们将参数的名字和位置确定下来，函数的接口就定义完成了。除了定义必选参数外，还可以使用默认参数、可变参数和关键字参数使用函数定义的接口可以处理复杂的函数
必选参数：也称为位置参数，必须以正确的顺序传入哈桑农户，调用时的数量必须和声明时的一样

def parameter_transfer(str):
    "必选参数"
    print(str)
    return
parameter_transfer("传递的参数")
运行结果：
传递的参数

关键字参数：使用关键字参数来确定传入的参数值，使用关键字参数允许函数调用时参数的顺序和声明时不一致，python解释器讷讷感狗用参数名匹配参数值

def parameter_transfer(name,age):
    "关键字参数"
    print("姓名",name)
    print("年龄",age)
    return

parameter_transfer(age = 62,name="shdjs ")
运行结果
姓名 shdjs 
年龄 62

默认参数：如果没有传递参数 则会使用默认参数

def parameter_transfer(age,name="jkj "):
    print(age,name)

parameter_transfer(age= 50)
运行结果：
50 jkj 

不定长参数：一个函数能处理比当初声明时更多的参数
加了*号的参数会以元组（tuple）的形式导入，存放所有未命名的变量参数
如果在函数调用时没有指定参数，就是一个空元组，我们也可以不向函数传递未命名的变量
如果参数带两个星号 则会以字典的形式导入

def functionname(arg1,*vartuple):
    "不定长参数"
    print(arg1)
    print(vartuple)
functionname(70,60,50)

def printinfo(arg1,*vartuple):
    print(arg1)
    for var in vartuple:
        print(var)
    return

printinfo(10)
printinfo(70,60,50)
运行结果
70
(60, 50)
10
70
60
50

4.匿名函数

python中使用lambda来创建一个匿名函数
lambda函数的语法只包含一个语句，lambda是python预留的关键字，argument_list和expression由用户自定义

# lambda [argument_list]:expression
argument_list:
a,b
a = 1, b = 1
*args
**kwargs
a, b = 1,*args
空

expression:
1
None
a + b
sum(a)
1 if a > 10 else 0

# 常用的匿名函数
lambda x,y:x*y :输出x,y的乘积
lambda None: 没有输入参数，输出是none
lambda *args:sum(args) :输入任意个参数，输出它们的和
lambda  **kwargs 1 ：输入是任意键值对，输出是1

匿名参数的特征：
1.lambda只是一个表达式
2.lambda主体是一个表达式而不是一个代码块，仅仅能在表达式中封装优先的逻辑进去
3.lambda函数有自己的命名空间，不能访问自己参数列表之外或全局命名空间里的参数

匿名参数的使用
1.将lambda函数赋值给一个变量，通过这个变量间接调用该匿名函数
2.将lambda函数赋值给其他函数，从而将其他函数使用该lambda函数替换
3.将lambda函数作为其他含糊的返回值，返回给调用者，函数的返回值也可以是一个函数，lambda函数实际上是在定义某个函数的内部函数
4.将lambda函数作为参数传递给其他函数，部分python内置哈桑农户接收匿名函数作为参数

from datetime import time
from functools import reduce

add = lambda x, y: x + y
print(add(1, 2))

# time.sleep = lambda x:None
# print("--",time.sleep(3))

# return lambda x,y:x+y

# 用于指定过滤列表元素的条件
filter(lambda x: x % 3 == 0, [1, 2, 3])
# 用于指定对列表中所有元素进行排序的准则
sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5 - x))
# 用于指定对列表中每一个元素的共同操作
map(lambda x: x + 1, [1, 2, 3])

#用于指定列表中两两相邻元素的结合条件
reduce(lambda a,b:'{},{}'.format(a,b),[1,2,3,4,5,6,7,8,9])

5.局部变量和全局变量

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量的名称，python一共有4中：
1.L（local）:局部作用域
2.E（enclosing）:闭包函数外的函数中
3.G（global）:全局作用域
4.B（built-in）:内建作用域
以 L>E>G>B的规则查找

Python解释器在工作的时候会默认导入常见的功能input等称之为内建；
闭包函数：
（1）闭包函数必须有内嵌函数
（2）内嵌函数必须要引用外层函数的变量
（3）闭包函数返回内嵌函数的地址（函数名称）

x = int(2.9) #内建作用域
g_count = 0 #全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数
    def inner():
        i_count = 2 #局部作用域

定义在函数内部的变量拥有一个局部作用域，定义在函数外的变量拥有全局作用域，局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内部声明的变量名称都将被加入到作用域中

6.global和nonlocal关键字

1.global:如果想为一个在函数外的变量重新赋值，并且这个变量会作用域多个函数中，就要告诉python这个变量的作用域是全局变量
可以使用一个global指定多个局部变量，只要在变量名之间使用都逗号分开即可

x = 6
def func():
    global x
    x = 1
func()
print("1.",x)

def func2():
    return x
func2()

print("2.",x)
运行结果：
1. 1
2. 1

使用在任何地方，即使之前未定义该变量，修饰后也可直接使用
2.nonlocal：想要修改嵌套作用域中的变量

def outer():
    num = 10
    print("1.", num)

    def inner():
        nonlocal num
        num = 100
        print("2.",num)

    inner()
    print("3.", num)


outer()
运行结果：
1. 10
2. 100
3. 100

nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误
只能用在嵌套函数中，并且外层函数中定义了相应的局部变量

7.内置函数