python函数基础

python函数

函数是组织好的，用来实现单一功能的代码段，可以重复利用

1. 函数的定义

• 函数的使用def关键字定义，后面跟着函数名和参数列表
• return关键字用于返回一个值给调用者，不带return默认返回None
• 一个函数可以return不同类型的数据类型

2.函数的参数

2.1 python不支持重载

函数是大多数语言都支持的一个代码构建块，在python中，函数的参数可以有默认值，也支持可以变的参数列表，在C，C＋＋，Java中有函数的重载，但是python不支持函数的重载。

def test():
    print('hello world!')#第一个函数
def test():
    print('no hello world!')#第二个函数

此时，函数的运行结果为：no hello world!

第二个函数会将第一个编写的函数覆盖，无论参数是否一样

2.2 python参数

python在定义参数的时候，函数的参数可以有默认值，也可以有可变参数，如果一个参数定义了默认数值，在函数调用的时候又传进来新的数值，那么就会优先调用传进的数值，没有传进的数值就会使用默认的值

def add(a = 10,b = 20):
    return a + b
a = 30
b = 20

print(add())#输出结果为：30
print(add(a,b))#输出结果为：50

python中传入的参数也可以不按照顺序进行传参

def test(a,b):
    print('a = %d'%a)
    print('b = %d'%b)
test(b = 10,a = 20)

输出结果为：
a = 20
b = 10

当我们进行add函数调用的时候，我们可能会对0 ~ n个数字进行加法操作，具体需要多少由决定传入的人决定，python提供了不确定参数个数的时候使用可变参数(以元组的方式导入)

def add(*args):
    res = 0
    for ele in args:
        res += ele
    return res

#调用函数
print(add(1,2,3))
print(add(1,2,3,4,5,6,7,8,9))

当我们定义的函数参数列表有默认参数和普通参数的时候，默认参数必须放在普通参数的后面

def test(age = 10,name):
    print('age = %d'%age)
    print('name = %s'%name)

以上写法为错误的写法，正确的写法为：

def test(name,age = 10):
   ···

在python中，字符串，元组，以及数字类型是不可以更改的对象，列表和字典是可以更改的对象

当我们在传入一个参数的时候，如果参数的类型是不可更改类型:

def test(a):
    print(id(a))
    a = 10
    print(id(a))
    return
a = 20
print(id(a))
test(a)

上面的例子输出为：

140722682954608
140722682954608
140722682954288

可以看出 a(old) 未被更改的时候，a (old)存在的地址是不变的，在 a (old)被更改了之后，python会重新创建一个新的a（new）对象，原来的 a(old) 指向的地址上面的数字在test函数中被丢弃，但是外面的 a (old)未被更改，当我们在程序末尾再加一个print(a)时，程序输出的a依然是20

当我们传入的参数是可以更改的类型的时候：

def test(mylist):
    del mylist[2]#把列表的第三个数字删除
    print('函数内：')
    print(mylist)
    
mylist = [1, 2, 3, 4]
test(mylist)
print('函数外：')
print(mylist)

上面的例子输出为：

函数内：
[1, 2, 4]
函数外：
[1, 2, 4]

函数内和函数的列表中的值都改变了，传入的列表本体

3.python中的 ‘主函数’ （类比C/C++，其实不同）

def test():
    print('hello world')
def test01():
    print('hello python!')
if __name__== '__main__':
    print('test函数的调用:')
    test()
    print('test01函数的调用:')
    test01()

在 if 条件下，test()和test01()不会自动执行

__name__是Python中一个隐含的变量，它代表了模块的名字

只有被Python解释器直接执行的模块的名字才是__main__

4. 变量作用域

def test():
    b = 20
    def test02():#在python中，函数内部仍然可以定义函数
        c = 30
        print('a = %d'%a)
        print('b = %d'%b)
        print('c = %d'%c)
        return
    test02()
    return
if __name__== '__main__':
    a = 10
    test();

上面的程序可以成功打印出以下结果：

a = 10
b = 20
c = 30

可是我们在函数test02()中并没有定义a 和 b，我们在if分支中定义了 a,这里的 a 是一个全局变量，因为它并没有定义在任何一个函数中，属于全局作用域，在test()中我们定义了b，这是一个定义在函数中局部变量，属于局部定义域，在外部无法访问定义在函数中的变量，但是test02在test内部，所以test02可以访问b,也可以访问a,但是在if分支条件下，就不可以访问b 和 c，在test()中可以访问a ,不可以访问c

但是我们仍然可以通过global和nonlocal关键字来实现逆向的操作

def test():
    global a
    a = 20
    return
if __name__=='__main__':
    a = 10
    print('修改前：',end = '')
    print(a)
    test()
    print('修改后：',end = '')
    print(a)

上面我们说过，传入的参数是不可改变的时候，在函数内更改传入的参数，函数外的参数是不会更改的，但是通过global关键字，我们可以在函数内部达成修改全局变量的目的

程序输出结果为：

修改前：10
修改后：20

nonlocal用来指示变量来自更低的作用域，程序中出现了以后python会向下作用域寻找指示的变量。