目录

一、定义函数

在Python中可以使用def关键字来定义函数，命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，而函数执行完成后我们可以通过return关键字来返回一个值。

定义代码如下：

def fac(num):
    """求阶乘"""
    result = 1
    for n in range(1, num + 1):
        result *= n
    #返回值
    return result

二、函数的参数

在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式，

下面是两个小例子：

from random import randint
 
 
def roll_dice(n=2):
    """摇色子"""
    total = 0
    for _ in range(n):
        total += randint(1, 6)
    return total
 
 
def add(a=0, b=0, c=0):
    """三个数相加"""
    return a + 2 * b + 3 * c
 
 
# 如果没有指定参数那么使用默认值摇两颗色子
print(roll_dice())
# 摇三颗色子
print(roll_dice(3))
#函数重载,没有指定函数变量时，参数按照顺序传值
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
# 传递参数时可以不按照设定的顺序进行传递
print(add(c=50, a=100, b=200))
# 或者可以不传
print(add(c=50, b=200))
 
if __name__ == "__main__":
    pass

没有传入对应参数的值时将使用该参数的默认值。

不确定参数个数的时候，我们可以使用可变参数，代码如下所示：

# 在参数名前面的*表示args是一个可变参数
def add(*args):
    total = 0
    for val in args:
        total += val
    return total
 
 
# 在调用add函数时可以传入0个或多个参数
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

三、用模块管理函数

由于Python没有函数重载的概念，那么后面的定义函数会覆盖之前的定义，也就意味着两个函数同名函数实际上只有一个是存在的。

def foo():
    print("hello, world!")
 
 
def foo():
    print("goodbye, world!")
 
 
# 下面的代码会输出什么呢？
foo()
 
if __name__ == "__main__":
    pass
 
#实际输出
goodbye, world!

多人协作进行团队开发的时候，团队中可能有多个程序员都定义了名为foo的函数，那么怎么解决这种命名冲突呢？

重点如何避免函数覆盖!!!

在Python中每个.py文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数，

代码如下所示:

module1.py
 
def foo():
    print("hello, world!")
 
module2.py
 
def foo():
    print("goodbye, world!")

导入模块：

test.py
 
import module1 as m1
import module2 as m2
 
m1.foo()
m2.foo()

注意：但是如果将代码写成了下面的样子，那么程序中调用的是最后导入的那个foo，因为后导入的foo覆盖了之前导入的foo。

from module1 import foo
from module2 import foo
 
# 输出goodbye, world!，使用的是后导入的模块
foo()

需要说明的是，如果我们导入的模块除了定义函数之外还有可以执行代码，那么Python解释器在导入这个模块时就会执行这些代码，事实上我们不想执行这些代码，那我们将可执行代码放入如下所示的条件中，这样的话除非直接运行该模块，if条件下的这些代码是不会执行的，因为只有直接执行的模块的名字才是"__main__"。

def foo():
    pass
 
def bar():
    pass
 
# __name__是Python中一个隐含的变量它代表了模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == "__main__":
    print("call foo()")
    foo()
    print("call bar()")
    bar()

import module3
# 导入module3时 不会执行模块中if条件成立时的代码 因为模块的名字是module3而不是__main__

四、变量的作用域

def foo():
    b = "hello"
 
    # Python中可以在函数内部再定义函数
    def bar():
        c = True
        print(a)
        print(b)
        print(c)
 
    bar()
    # print(c)  # NameError: name "c" is not defined
 
 
if __name__ == "__main__":
    a = 100
    # print(b)  # NameError: name "b" is not defined
    foo()

打印结果：

100
hello
True

上面的代码能够顺利的执行并且打印出100、hello和True，但我们注意到了，在bar函数的内部并没有定义a和b两个变量，那么a和b是从哪里来的。

我们在上面代码的if分支中定义了一个变量a，这是一个全局变量（global variable），属于全局作用域，因为它没有定义在任何一个函数中。

在上面的foo函数中我们定义了变量b，这是一个定义在函数中的局部变量（local variable），属于局部作用域，在foo函数的外部并不能访问到它；但对于foo函数内部的bar函数来说，变量b属于嵌套作用域，在bar函数中我们是可以访问到它的。

bar函数中的变量c属于局部作用域，在bar函数之外是无法访问的。

Python查找变量顺序：

“局部作用域”-》“嵌套作用域”-》“全局作用域”和“内置作用域”的顺序进行搜索。

内置作用域：Python内置的那些标识符，我们之前用过的input、print、int等都属于内置作用域。

我们希望通过函数调用修改全局变量a的值，但实际上下面的代码是做不到的。

代码如下：

def foo():
    a = 200
    print(a)  # 200
 
 
if __name__ == "__main__":
    #这里变量值不能修改函数局部变量的值
    a = 100
    foo()
    print(a)  # 100

在调用foo函数后，我们发现a的值仍然是100，这是因为当我们在函数foo中写a = 200的时候，是重新定义了一个名字为a的局部变量，它跟全局作用域的a并不是同一个变量。

因为局部作用域中有了自己的变量a，因此foo函数不再搜索全局作用域中的a。如果我们希望在foo函数中修改全局作用域中的a，

代码如下所示：

def foo():
    global a
    a = 200
    print(a)  # 200
 
 
if __name__ == "__main__":
    a = 100
    foo()
    print(a)  # 200

可以使用global关键字来指示foo函数中的变量a来自于全局作用域。

注：

在实际开发中，我们应该尽量减少对全局变量的使用，因为全局变量的作用域和影响过于广泛，可能会发生意料之外的修改和使用。

除此之外全局变量比局部变量拥有更长的生命周期，可能导致对象占用的内存长时间无法被垃圾回收

到此这篇关于Python函数和模块的使用详情的文章就介绍到这了,更多相关Python函数模块内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

关键词： 全局变量 局部变量 局部作用 可变参数