python基础-函数

一、函数参数使用

（一）return的用法

def Fun1(x, y):
    return x + y
# ②这句话没有执行，上面的return已经结束函数执行
    print("看看执行了没有")
result = Fun1(5,6)
# ①返回一个数据，给函数调用的地方
print(result)
# ③如果return后没有数据，则默认返回，返回值为none

（二）位置参数 位置参数一般配合*arg使用

# 位置参数中，参数的顺序必须对应，且不能缺少参数
def Fun(a, b, c):
    return a + b + c
print(Fun(4, 5, 6))

（三）关键字参数

# ①如果不确定参数顺序，可以通过关键字函数传出来
# ③最后一个可以使用关键字参数
def Fun(a, b, c):
    return a * b * c
print(Fun(1, 2, c=3))
# ②关键字参数后面参数都是关键字参数
def Fun(a, b, c):
    return a * b * c
print(Fun(1, b=2, 3))  ####报错

（四）默认参数

# ①在函数定义的时候就给了参数值，并且一般都写在位置参数后面
def Fun(a, b, c=1):
    return a + b + c
# ②如果调用时没有指定默认参数的值，则使用默认参数
print(Fun(1,2))         #结果为4
# ③如果调用时指定了默认参数的值，则覆盖默认参数
print(Fun(1, 2, 5))     #结果为8
# ④如果是默认参数，则用默认参数，覆盖原有的参数
print(Fun(1, 2, c=10))  #结果为13

（五）默认参数延伸

# 默认参数不能使用可变数据类型（list，dict）
# 参数全部为默认参数时，不需要再调用参数。
def Fun(list1 = []):
    list1.append(10)
    return list1
print(Fun())      # [10]
print(Fun())      # [10, 10]
print(Fun())      # [10, 10, 10]

# 如果要使用列表，该怎么办？
def Fun():          # 把列表放到函数体内
    list1 = []
    list1.append(10)
    return list1
print(Fun())
print(Fun())
print(Fun())

（六）可变参数：不确定参数个数

# 1、*args 收集所有的可变参数为元祖
def Fun(*args):
    for i in args:
        i += i
        return i
result = Fun(1, 2, 3)
print(result)
# 2、**kwargs 收集所有关键字参数作为字典
def Fun(**args):
    k ,v = args.items()
    return k, v
print(Fun(a=1, b=2))

（七）命名关键字参数

# 控制命名关键字的个数（Python3新增）*号后的参数都必须为关键字参数
def person_info(name, age, *, city, job):
#*号后的参数都必须为关键字参数
    print(name)
    print(city)
person_info("曹哲", 15, city="北京", job="programmer")

二、函数返回值（返回一个值或多个值）

（一）返回一个值

# pass的用法
def calc_func(num1, num2, num3):
# 用pass表示什么也不做，同时标记代码没有错误
    pass

# 编写简单计算机
def calc_func(num1, num2, num3):
    if num3 == "+":
        return num1 + num2
    elif num3 == "-":
        return num1 + num2
    elif num3 == "*":
        return num1 * num2
    elif num3 == "/":
        return num1 / num2
    else:
        print("输入不正确")
print(calc_func(1, 2, "+"))

（二）返回多个值

def square_func(num1, num2):
# return返回了多个数据，则先进行打包（一个元祖），再返回
    return num1 ** 2, num2 ** 2
print(square_func(10,20))
# 如何拆包？
x, y = square_func(10,20)
print(x,y)
# 注意：字典运用拆包时，拆出来的是 键
d1, d2, d3 = {"name":"python", "age":27, "id":100}
print(d1, d2, d3)

三、全局变量和局部变量

# ①函数内部使用变量，不能在外部访问
def Func():
    age = 1
print(age)      #这么写是错的，不能被访问

# ②全局变量在模块内定义，可以在整个模块内使用，函数内部可以访问全局变量
age = 1
def Fun():
    print(age)
Fun()

# ③什么时候用global，先声明再使用全局变量，并可随意改全局变量
#   global可以声明全局变量，并可以修改全局变量和局部变量的指向。
#   如果只是获得全局变量，有没有global都一样
#   如果要修改全局变量的值，就必须使用
#   如果是可变数据类型，不管有没有修改，都不要global
age = 10
def Func():
    global age
    age = 20
    print(age)
Func()
print(age)  # 全局变量的age也更改了

四、命名空间

（一）命名空间（作用域）为了防止多个变量冲突，而引入一组对变量名作用范围分组机制。

1、局部命名空间：函数内的命名空间是局部的
2、全局的命名空间：模块类的命名为全局的
3、内置命名空间：内置函数，异常处理等
4、一个Python表达式，可以访问局部命名空间和全局命名空间，如果变量重名，则局部命名空间覆盖全局命名空间。（从内到外，强龙不压地头蛇）
age = 10
def func():
    age = 5
    return age
print(func())

（二）命名空间的访问

1、locals() 包含了所有局部变量的命名空间全部是字典。
def Func():
    a = 10
# 把这个局部的变量 编程字典
    return locals()
print(Func())
2、globals() 包含了所有全局变量的命名空间全部是字典。
golbals() 在函数体内也能访问全局变量。
b = 20
def Func():
    a = 10
    # 访问的不是10，而是在函数里访问的外部的20
    return globals()
print(Func())
# 把这个全局变量变成字典
print(globals())

（三）命名空间查找顺序（LEGB规则）Python2.2之前不支持

L – Local 局部命名空间
E – Enclosing （嵌套函数）外部
G – Global 全球的，全局命名空间
B – BIF 内置命名空间 内置函数

（四）命名空间的生命周期

1、局部命名空间的生命周期：
当函数结束时（return，正常执行结果，抛出异常），
该命名空间下的变量全部销毁。
2、全局命名空间的生命周期：
从模块加载的代码执行开始，到程序结束后，是全局命名
空间的存货时间。
3、内置命名空间：从Python的解释器启动开始，到程序执行结束

四、匿名函数（lambda）

（一）lambda的基本定义

# ①lambda表达式是单一的，没有语句块
# ②lambda表达式可以有参数，也可以无参数。
# ③lambda表达式默认值带返回值
# ④lembda可以有函数名

# 无参   另一种表达形式  print（lambda:10()）
f = lambda: 10
print(f())

# 有参，冒号左边是参数，右边是返回值（返回值只能为表达式或者if）
f = lambda x, y: x + y
print(f(1, 2))
print((lambda x, y: x if x > y else y)(2, 3))

（二）lambda表达式支持默认参数、元祖类型多变参数，字典类型多变参数，表达式作为参数传递。

Python对匿名函数支持有限，只有一些简单的情况下可以使用匿名函数。
# ①默认参数
print((lambda a, b, c=5 : a + b + c)(1, 2))

# ②元祖数据多变参数,返回元组类型。
print((lambda *args: args)(1, 2, 3, 4))

# ③字典数据类型多变参数，返回字典类型，参数为关键字参数
print((lambda **kwargs: kwargs)(a=1, b=2, c=3))

# ④lambda表达式为参数传递
def Func(a, b, f):
    return f(a, b)
print(Func(1, 2, lambda x, y: x + y))

# ⑤filter（）过滤器   会把非True筛出，即0
# 使用filter()和lambda表达式快速求出100以内所有3的倍数
a = list(filter(lambda x : x%3 == 0 ,range(101)))
print(a)     #filter()返回list和reversed一样 或者tuple

# ⑥map() 映射   zip()
b = list(map(lambda x,y : [x,y],[1,2,3,4,5],[6,7,8,9]))
print(b)    是列表类型的列表
c = list(zip([1,2,3],[4,5,6])) #zip（）出来的是元祖类型的列表
print(c)