Python基础（08）——函数

Python基础（08）——函数

Python中函数是一段仅在调用时执行的代码块。可以将数据作为参数传入到函数中，函数也可以将数据作为返回结果

1. 定义函数

在Python中使用def定义函数，调用函数时使用函数名后紧跟括号

def myfunction():
    print("Hello")
myfunction()

2. 函数参数

**多个参数：**函数中的参数可以传递数据信息，参数在函数名后的括号内指定，可以指定多个参数，只需要用逗号分割开即可。

def myfunction(name,age):
    print("{} is {} years old".format(name,age))   #jing is 18 years old
myfunction("jing",18)

**默认参数值:**如果我们调用了没有传入参数的函数，将会启动函数的默认值。当然这个默认值是在创建函数自己定义的。

def function1(country="China"):
    print("I come from %s"%country)
function1("UK")    #I come from UK
function1()        #I come from China

**List传参：**发送到函数的参数可以是任何数据类型。可以是列表，元组，字典，字符串等数据类型

food = ["chicken","cookie"]
def function2(dinner):
    for x in dinner:
        print(x)
function2(food)

**关键字参数：**可以使用key=value等语法传入参数。在Python中“关键字参数”一词简称为”kwargs“

def function3(food1,food2):
    print(food1,food2)
function3(food1="Chicken",food2="cookie")

**任意参数（args）：**也叫可变位置参数。如果不确定参入的某个参数有多少个值时，可以使用任意参数。在函数定义的参数名前加即可。这样函数接收到的参数会成为一个参数元组，以元组的身份存储。

def function4(*food):
    print(type(food),food)   #<class 'tuple'> ('Chicken', 'Cookie', 'bread')
    for x in food:
        print(x)
function4("Chicken","Cookie","bread")

**可变关键词参数：如果在传参时对不存在的参数进行了命名，可以用 kwargs接收参数，以字典的形式存储在计算机中。可变关键字参数用于接收在调用函数时命名的参数，所以放在定义函数形参的最后的位置。

def function6(food1,food2,**kwargs):
    print(food1,food2,kwargs)   #Chicken cookie {'food3': 'bread', 'food4': 'sandwich'}
    print(type(kwargs))         #<class 'dict'>
function6("Chicken","cookie",food3="bread",food4="sandwich")

强制命名参数： 在后面的参数名进行调用时必须传入对应的参数名。如：参数food2在之后，那么在调用函数时必须传入food2=值；

def function7(food1,*,food2,):
    print(food1,food2)
function7("Chicken",food2="cookie")

**参数定义顺序：**在定义函数的时候要注意参数定义的顺序：必须参数、默认参数、可变位置参数、强制参数、可变关键字参数。其中可变关键字参数在定义的时候一定放在最后，但是在调用函数传入参数的时候，**kwargs接收到的参数是，所有传入的参数找到相对应的形参之后，多余的关键字按照字典的形式传给可变关键字参数。

**逆向参数收集（解包）：逆向参数收集就是在程序已有列表，字典，元组等前提下。把他们的元素拆开后传给函数的形参，也就是Python中所说的解包unpacking。解包就是将容器中所有的元素逐个取出来，Python中任何可以迭代的对象都可以进行解包。在进行函数调用时在列表、元组前加*进行解包，在字典前加进行解包。

thislist = ["chicken","cookie","sandwich"]
thisdict = {"food1" : "chicken",
            "food2":"cookie",
            "food3":"sandwich"
}

def function8(food1,food2,food3):
    print(food1,food2,food3)   #chicken cookie sandwich
function8(*thislist)     #列表加*
function8(**thisdict)    #字典加**

**pass语句：**在Python中函数定义不能为空，如果定义了一个函数，但是使用不到时，可以用pass语句来避免错误

def myfunction:
  pass

**return语句：**return语句用来返回函数值。也可以返回多个值。

def function5(x,y):
    return x+y
print(function5(3,2))   #5

当返回多个值时，Python会自动将其封装成元组。当接收返回的多个值时，Python会自动执行解包操作，我们可以使用多个变量来接收返回值。

thislist=[1,2,3,4,5]
def function9(thislist):
    min_number = min(thislist)
    max_number = max(thislist)
    return min_number,max_number     #返回多个值Python会自动将其封装成元组
min_number,max_number=function9(thislist)
print(type(function9(thislist)),min_number,max_number)  #<class 'tuple'>   1, 5 

**函数参数的传递机制：**关于Python中函数的传递机制，传递采用“对象引用”的方式。有一句话很解释的很清楚。

Python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典 或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。当在函数中对可变对象本身进行修改操作时，原始可变对象也会被修改。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于过“传值”来传递对象。原文链接：https://blog.csdn.net/CARL__Meng/article/details/109030280

3. 变量的作用域

变量根据其作用的范围，可以分为两种：

全局变量：在函数外部定义的变量，全局范围定义的变量。在函数内部和函数外部都可以正常使用和访问。作用于全局。

局部变量：在函数内部定义的变量，包括参数也是局部变量，只能在函数的内部正常使用，在函数外部不能正常访问

Python中有可以获得指定范围的变量字典

1. globals():获得全局范围内变量组成的字典。
2. locals()：获得当前范围内变量组成的字典，可以是函数的局部范围，也可以是全局范围。与globals不同，locals无法修改当前范围的变量。
3. var(object): 获得当前范围内指定变量组成的字典。如果没有传入参数object对象，var()和locals()作用时相同的。

name = "jing"
def fun1():
    print("全局便变量nama=",globals()["name"])   #全局便变量nama= jing
    globals()['name']="Tian"
fun1();
print(name)     #Tian

def fun1():
    name = "Jing"
    print(locals())    #{'name': 'Jing'}
    locals()['name'] = "Tian"
    print(name)     #Jing,   locals()无法修改当前范围的变量
fun1()

class person:
    name = "Jing"
def fun3():
    print(vars(person))
    print(person.name)
fun3()
#---outPut---
# {'__module__': '__main__', 'name': 'Jing', '__dict__': <attribute '__dict__' of 'person' objects>, '__weakref__': <attribute '__weakref__' of 'person' objects>, '__doc__': None}
# Jing

global和nonlocal的区别：

global关键字修饰的变量会作为全局变量，修改该变量就是修改全局变量。可以在上层函数或者嵌套函数中使用。

name = "jing"
def fun1():
    global name
    name = "Tian"
    print(name)    #Tian
fun1()

nonlocal关键字修饰的变量是上级函数中定义的局部变量，如果上一级函数中不存在该变量，则会报错。nonlocal关键字使用在嵌套函数中的内部函数中。

def fun2():
    name = "Jing"
    def inner_fun():
        nonlocal name
        name = "Tian"
        print(name)    #Tian
    inner_fun()
    print(name)       #Tian
fun2()