python学习day006--函数和模块的使用

为什么要引入函数

假如我们想要寻找1-100之间的质数，那么我们通过编写一个for in 就可以实现，然后我们又想找1-1000之间的质数呢？有一种方法就是再写一个for in。万一我们还要再找1-100000呢，再写一个吗？明显不是，这样子会造成程序片段的重复，而我们知道“代码有很多种坏味道，重复是最坏的一种。”

所以我们写一个函数用来求质数，一旦需要我们求质数，我们便调用即可。

定义函数

类比数学中的函数我们可以发现，函数由自变量和因变量组成。
类比Java或者c++，我们定义一个函数需要以下几个要素：
函数名，函数返回值类型，函数参数类型。
python中定义一个函数需要用 def 关键字,在python中，我们呢没有必要定义返回值和参数类型。

def 函数名(参数自变量):
return 返回值因变量

def f(x):
    return 2*x
print(fac(2))

其中要特别注意：python中没有函数重载功能。
那么我们在python中要如何实现和其他语言中的函数重载一样的功能呢。

函数重载：就是函数名相同，但是参数的类型和个数不同。

python的参数由于没有确定参数的类型，因此任何类型的参数都能传入，这就类似于参数类型的重载。
python中函数的参数有几个，则说明这个函数可以传入多少的参数。

python和其他语言显著的区别

• python的参数是可以传入默认值的，当函数调用时没有传入参数则可以计算默认值
• 当我们不知道调用者要传入几个参数时，我们可以传入可变参数。

def sum(*args):
    sum=0
    for i in args:
        sum+=i
    return sum
print(sum(1,2,4,2))#9
print(sum(1))#1

用模块管理函数

如果我们在同一个.py文件里对两个函数取的名字是一样的，那么后面一个函数是会覆盖前面一个函数的，也就是在python中，同一个.py文件中是不可能同时存在两个同名函数的。
所以如果我们想要将两个函数命名一样，那么这两个函数就只能存在在不同的.py文件中。不同的.py文件其实就是不同的模块，而当我们要用这些同名函数的时候，再将这些同名函数所在的模块导入。

module1.py

def foo():
    print('hello, world!')

module2.py

def foo():
    print('goodbye, world!')

调用不同模块中同名函数的方法：

test1.py

from module1 import foo
# 输出hello, world!
foo()

from module2 import foo

# 输出goodbye, world!
foo()

test2.py
后导入的将之前导入的给覆盖了。

from module1 import foo
from module2 import foo
foo()# 输出goodbye, world!
foo()# 输出goodbye, world!

test3.py

import module1 as m1
import module2 as m2

# 输出hello, world!
m1.foo()
# 输出goodbye, world!
m2.foo()

在test3中我们可以发现，因为我们将两个模块导入，模块里除了我们需要的函数外，其实还有我们不需要的代码，我们一并导入并进行运行。但这不是我们希望的。我们希望不运行那些我们不想要的程序。那我们是不是直接删掉这些我们不想运行的程序呢，简单粗暴？不是的，“存在即合理”，这些程序是有它存在的意义的，我们有时候还是要运行的，只是我们希望要运行的时候能够运行，不要它运行的时候不要运行。因此我们用一个if 语句来判断是否运行。

module3.py

def fac():
#省略方法体
def sum():
#省略方法体

# __name__是Python中一个隐含的变量它代表了模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
###下列是我们不想它运行的，
    print('call foo()')
    foo()
    print('call bar()')
    bar()

test.py

import module3
#不会运行if中的程序，因为模块的名字是module3，不是__main__

练习

练习1：实现计算求最大公约数和最小公倍数的函数

def gcd(x,y):
    if x>y:
        (x,y)=(y,x)
    for i in range(x,0,-1):
        if x%i==0and y%i==0:
            return i
        
def lcm(x,y):
    return x*y//gcd(x,y)

练习2：实现判断一个数是不是回文数的函数。
回文数是指一个像14641这样“对称”的数，即：将这个数的数字按相反的顺序重新排列后，所得到的数和原来的数一样。

def is_palindrome(x):
    a=0
    num=x #我们要将输入的x保存起来。后面的x已经是变化后的x
    while x>0:
        a=a*10+x%10
        x=x//10
    if x==a:
        return True

练习3：实现判断一个数是不是素数的函数。

from math import sqrt
def is_prime(x):
    a=int(sqrt(x))
    count=0
    for i in range(2,a+1):
        if x%i==0:
            count+=1
    return count==0 and x!=1

练习4：写一个程序判断输入的正整数是不是回文素数

def pp(x):
    return is_prime(x) and is_palindrome(x)

我们可以通过两个已经抽取的函数组合成一个新的复杂的函数。

变量的作用域

全局作用域>局部作用域>内部作用域
在大范围里访问不到小范围里的变量，在小范围里无法修改大范围里的变量（因为在小范围里修改，相当于又新创建了一个变量，我们对这个变量的修改会随着跳出这个作用域而无效）

def foo():
    b = 'hello'#b 的作用域是局部作用域
    a=200 #这个a是函数新定义的变量 a，不是全局变量a ，因此会随着这个函数运行的结束而消失

    # Python中可以在函数内部再定义函数
    def bar():
        c = True  # c的作用域是嵌套作用域
        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()
    print(a) #100,小范围里修改成200是没有作用的，

如果我们要在函数里修正全局变量，那么我们需要利用global 关键字
如果我们需要在函数中嵌套的函数中修改函数中的变量，我们需要利用 nonlocal 关键字。

def foo():
    global a
    a=200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)