Python学习日志09 - 函数和模块

Python学习日志

RBHGO的主页欢迎关注

温馨提示：创作不易，如有转载，注明出处，感谢配合~

目录

前言

根据我们前面分享的知识，可以用循环做累乘的方式来计算阶乘，那么通过下面的Python代码我们就可以计算出组合数C(M,N)的值，c(M,N)=M!//N!//(M-N)!。

m = int(input('m = '))
n = int(input('n = '))
# 计算m的阶乘
fm = 1
for num in range(1, m + 1):
    fm *= num
# 计算n的阶乘
fn = 1
for num in range(1, n + 1):
    fn *= num
# 计算m-n的阶乘
fm_n = 1
for num in range(1, m - n + 1):
    fm_n *= num
# 计算C(M,N)的值
print(fm // fn // fm_n)

不知大家是否注意到了，上面的代码中我们做了三次求阶乘，虽然m、n、m - n的值各不相同，但是三段代码并没有实质性的区别，属于重复的代码。我们得明确一个问题，高质量的代码首先要解决的就是重复代码问题。

进入正题

对于上面的代码来说，我们可以将计算阶乘的功能封装到一个称为“函数”的代码块中，当需要计算阶乘的时候，我们只需要“调用函数”就可以得到我们想要的结果了。函数可以理解为我们数学上学的函数，每个函数都有自己的名字、自变量和因变量。

Python学习日志09课 - 函数和模块

定义函数

我们通常把Python中函数的自变量称为函数的参数，而因变量称为函数的返回值。在Python中可以使用def关键字来定义函数（与变量的命名规则是一致的）。在函数名后面的圆括号中可以放置传递给函数的参数，就是我们刚才说到的函数的自变量，而函数执行完成后我们会通过return关键字来返回函数的执行结果，就是我们刚才说的函数的因变量。一个函数要执行的代码块（要做的事情）也是通过缩进的方式来表示的，最后不要忘了def那一行的最后面还有一个:。

• 函数 —> y = f(x)/z = f(x， y)/ … —> 相对独立且会被重复使用的功能（代码)，代表将来想使用这些功能的时候，不需要再复制粘贴代码，而是直接通过调用函数来做到。

• 自变量(argument/independent variable) —> 参数(parameter)

• 因变量(dependent variable) —> 返回值(return value)

大致心里有了函数这个概念，我们就拿上面得代码进行重构,下面就是使用函数方法后的代码。

# 定义函数：def是定义函数的关键字、fac是函数名，num是参数（自变量）
def fac(num):
    """求阶乘"""
    result = 1
    for i in range(2, num + 1):
        result *= i
    # 返回num的阶乘（因变量）
    return result


m = int(input('输入m的值: '))
n = int(input('输入n的值: '))
# 计算C(M,N)的值
# 当需要计算阶乘的时候不用再写重复的代码而是直接调用函数fac
# 调用函数的语法是在函数名后面跟上圆括号并传入参数
print(fac(m) // fac(n) // fac(m - n))

温馨提示:所谓重构，是在不影响代码执行结果的前提下对代码的结构进行调整。

(1).全局变量和局部变量

在知道大致如何定义一个函数后，我们得再心里明白函数中的变量是应该如何使用，规则是和之前一样，但是因为函数中的缩进，所以变量出现了全局变量和局部变量两种形式。全局变量(没有写在任何函数内部的变量),局部变量(定义在函数内部的变量)。下面给大家大概介绍一些注意事项，要在心里有个印象，遇到这个问题的时候就不会没有头绪。

• Python程序中搜索一个变量是按照 LEGB 顺序进行搜索的。

  • Local (局部作用域) —> Embeded (嵌套作用域) —> Global (全局作用域) —> Built-in (内置作用域)

• 关键字lobal —> 声明使用全局变量或者定义一个局部变量将其放到全局作用域

• 关键字nonlocal —> 声明使用嵌套作用域的变量

# 全局变量
x = 100

def foo():
    # 如果我不想在函数foo中定义局部变量x，想直接使用全局变量x，使用关键字global
    # global x
    x = 200  # 函数里面的局部变量x和全局变量x是两个不同的变量，相互没有关系各自不影响

    def bar():
        # 如果不想在函数bar中定义局部变量x，想直接使用嵌套作用域的x，使用关键字nonlocal
        # nonlocal x
        x = 300
        print(x)

    bar()
    print(x)


foo()
print(x)

像我这个代码，就是有全局变量x=100、局部变量x=200、以及函数中嵌套函数的局部变量x=300。def foo()对于def bar()就是嵌套作用域，如果没有局部变量x=300，那么最里面的print(x)将会输出的是嵌套结构变量x=200；而如果没有局部变量x=200,那么中间的print(x)将会输出的是全局变量x=100；如果二者都没有自然输出都是全局变量中的x=100，大家可以自行体会。

函数的参数

(1).参数的默认值

如果函数中没有return语句，那么函数默认返回代表空值的None。另外，在定义函数时，函数也可以没有自变量，但是函数名后面的圆括号是必须有的，Python中还允许函数的参数拥有默认值。

# 写一个实现生成指定长度的随机验证码（有数字和英文字母构成）的函数。
import random
import string


def captcha_code(length=4):
    """
    生成随即验证码

    :param length:验证码的长度
    :return:随机验证码字符串
    """
    selected_chars = random.choices(string.digits + string.ascii_letters, k=length)
    return ' '.join(selected_chars)


for _ in range(10):
    # 函数的参数拥有默认值验证码长度为4
    print(captcha_code())
    # 我们强调长度为8，就会生成10条长度为8的验证码
    print(captcha_code(length=8))

如果上面的例子不好理解，当然有更加直观的例子，我们以数字的加法来做例子。

def add(x=0, y=0, z=0):
    """三个数相加求和"""
    return x + y + z


# 调用add函数，没有传入参数，那么x、y、z都使用默认值0
print(add())         			  								# 运行结果:0
# 调用add函数，传入一个参数，那么该参数赋值给变量x, 变量y和z使用默认值0
print(add(1))        		  	  								# 运行结果:1
# 调用add函数，传入两个参数，1和2分别赋值给变量x和y，变量z使用默认值0
print(add(1, 2))       			  								# 运行结果:3
# 调用add函数，传入三个参数，分别赋值给x、y、z三个变量
print(add(1, 2, 3))  			 							 	# 运行结果:6
# 传递参数时可以不按照设定的顺序进行传递，但是要用“参数名=参数值”的形式
print(add(z=50, x=100, y=200))    								# 运行结果:350

温馨提示：带默认值的参数必须放在不带默认值的参数之后，否则将产生SyntaxError错误，错误消息是：non-default argument follows default argument，翻译成中文的意思是“没有默认值的参数放在了带默认值的参数后面”。

(2).可变参数

因为Python语言中的函数可以通过星号表达式语法来支持可变参数。所谓可变参数指的是在调用函数时，可以向函数传入0个或任意多个参数。如果我们以团队协作的方式开发商业项目时，很有可能要设计函数给其他人使用，但有的时候我们并不知道函数的调用者会向该函数传入多少个参数，这个时候可变参数就可以派上用场。

# 用星号表达式来表示args可以接收0个或任意多个参数
def add(*args):
    total = 0
    # 可变参数可以放在for循环中取出每个参数的值
    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))

(3).关键字参数

在没有特殊处理的情况下，函数的参数都是位置参数，也就意味着传入参数的时候对号入座即可，当然，也可以通过参数名=参数值的方式传入函数所需的参数，因为指定了参数名，传入参数的顺序可以进行调整。上面分享了参数列表中可以使用可变参数args来接收任意数量的参数，但*args并不能处理带参数名的参数。我们在设计函数时，如果既不知道调用者会传入的参数个数，也不知道调用者会不会指定参数名，那么要同时使用可变参数和关键字参数。

"""
example - 关键字参数

arguments -—->args -—->参数
位置参数---> positional argument
关键字参数---> keyword argument ---> 参数名 = 参数值
关键字参数一定是在位置参数的后面！! !
    - 用星号表达式来表示args可以接收0个或任意多个参数
    - *args ---> 可变参数---> 可以接收零个或任意多个位置参数 ---> 将所有的位置参数打包成一个元组
    - **kwargs ---> 可以接收零个或任意多个关键字参数 ---> 将所有的关键字参数打包成一个字典

Author: RBHGO
Date: 2021/8/4
Declaration: Mia San Mia ~~~
"""


def add(*args, **kwargs):
    total = 0
    # 可变参数可以放在for循环中取出每个参数的值
    for val in args:
        if type(val) in (int, float):
            total += val
    for value in kwargs.values():
        if type(value) in (int, float):
            total += value
    return total


def mul(*args, **kwargs):
    total = 1
    for val in args:
        if type(val) in (int, float):
            total *= val
    for value in kwargs.values():
        if type(value) in (int, float):
            total *= value
    return total


# 在调用add函数时可以传入0个或任意多个参数
print(add('GG_bond'))						# 运行结果：0
print(add(1))								# 运行结果：1
print(add(1, 2))							# 运行结果：3
print(add(1, 2, a=3))						# 运行结果：6
print(add(1, b=3, c=5, e='NB', f=9))		# 运行结果：18
print(mul(11, 22, 33, 44))					# 运行结果：351384

温馨提示：再次提醒不带参数名的参数（位置参数）必须出现在带参数名的参数（关键字参数）之前，否则将会引发异常。

用模块管理函数

不管用什么样的编程语言来写代码，给变量、函数起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名的函数，如下所示。

def say_hello():
    print('hello, world')
    
def say_hello():
    print('goodbye, world')
    
say_hello()

上面的代码不会报错，也不是输出先定义的hello, world而是输出了相当于更新了函数say_hello的值的goodbye, world。当然上面的这种情况我们很容易就能避免，但是如果项目是团队协作多人开发的时候，团队中可能有多个程序员都定义了名为say_hello的函数,这时我们应该明白Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块再使用完全限定名的调用方式就可以区分到底要使用的是哪个模块中的say_hello函数，代码如下所示。

foo.py

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

bar.py

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

test.py

import foo
import bar

# 用“模块名.函数名”的方式（完全限定名）调用函数，
foo.say_hello()    				# 运行结果：hello, world!
bar.say_hello()    				# 运行结果：goodbye, world!

在导入模块时，上面的代码我们导入了定义函数的模块，我们也可以使用from...import...语法从模块中直接导入需要使用的函数，还可以使用as关键字对模块进行别名，这样我们可以使用更为简短的完全限定名，结果是一样的。

from foo import say_hello as s1
from bar import say_hello as s2

s1()         				# 运行结果：hello, world!
s2()         				# 运行结果：goodbye, world!

小结：做工程化项目开发时, 如果项目中的代码文件非常多，我们可以使用"包"(package)来管理 “模块”,再通过模块来管理函数, 包其实就是一个文件夹, 而模块就是一个Python文件, 通过这种方式就可以解决大型项目团队开发中经常遇到的命名冲突的问题。

Python中的from、import、as关键字就是专门用来处理包和模块导入的操作的。

标准库中的模块和函数

Python标准库中还有一类函数是不需要import就能够直接使用的，我们将其称之为内置函数，这些内置函数都是很有用也是最常用的，下面的表格列出了一部分的内置函数。

函数	说明
abs	返回一个数的绝对值，例如：abs(-1.3)会返回1.3。
bin	把一个整数转换成以'0b'开头的二进制字符串，例如：bin(123)会返回'0b1111011'。
chr	将Unicode编码转换成对应的字符，例如：chr(8364)会返回'€'。
hex	将一个整数转换成以'0x'开头的十六进制字符串，例如：hex(123)会返回'0x7b'。
input	从输入中读取一行，返回读到的字符串。
len	获取字符串、列表等的长度。
max	返回多个参数或一个可迭代对象（后面会讲）中的最大值，例如：max(12, 95, 37)会返回95。
min	返回多个参数或一个可迭代对象（后面会讲）中的最小值，例如：min(12, 95, 37)会返回12。
oct	把一个整数转换成以'0o'开头的八进制字符串，例如：oct(123)会返回'0o173'。
open	打开一个文件并返回文件对象（后面会讲）。
ord	将字符转换成对应的Unicode编码，例如：ord('€')会返回8364。
pow	求幂运算，例如：pow(2, 3)会返回8；pow(2, 0.5)会返回1.4142135623730951。
print	打印输出。
range	构造一个范围序列，例如：range(100)会产生0到99的整数序列。
round	按照指定的精度对数值进行四舍五入，例如：round(1.23456, 4)会返回1.2346。
sum	对一个序列中的项从左到右进行求和运算，例如：sum(range(1, 101))会返回5050。
type	返回对象的类型，例如：type(10)会返回int；而type('hello')会返回str。

还有更多，不一个个列举，感兴趣的话记得试一试，要是没弄懂ctrl点击函数可以再PyCharm中查看，shift + F1点击可以到官网查看，两种方法都可以查看函数的意义及他的作用。

对函数有了一个阶段性的认知，我们可以做一个题来应用一下

双色球随机选号(实现机选N注)
红色球:01-33，选择不重复的6个球，按从小到大排列
蓝色球:01-16，选择一个球，跟在红色球的后面

大乐透随机选号

红色球:01-35，选择不重复的个球，按从小到大排列
蓝色球:01-12，选择两个球，跟在红色球的后面

首先是单独实现双色球

import random


def generate():
    """
    生成一组彩票号码

    :return:保存一组彩票号码的列表
    """
    red_balls = [i for i in range(1, 34)]
    blue_balls = [i for i in range(1, 17)]
    selected_balls = random.sample(red_balls, 6)
    selected_balls.sort()
    # selected_balls += random.choices(blue_balls, k=1)
    selected_balls.append(random.choice(blue_balls))
    return selected_balls


def display(balls):
    """
    显示一组彩票号码

    :param balls:装彩票号码对应的球的列表
    """
    for ball in balls:
        print(f'{ball:0>2d}', end=' ')
    print()


n = int(input('机选几组: '))
for _ in range(n):
    display(generate())

下面是同时实现双色球和大乐透，并且更加精炼的代码，也可以看得出，通过对学习函数，我们对程序的处理方法又多了不少。

# 实现双色球和大乐透同时进行
import random


def generate(ball_max, ball_num):
    """
    选择一组随机的球

    :param ball_max: 球的最大值
    :param ball_num: 球的数量
    :return: 保存一组球的列表
    """
    balls = [i for i in range(1, ball_max + 1)]
    selected_balls = random.sample(balls, ball_num)
    selected_balls.sort()
    return selected_balls


def make_big_lottery():
    """生成大乐透的号码"""
    return generate(35, 5) + generate(12, 2)


def make_two_colors():
    """生成双色球的号码"""
    return generate(33, 6) + generate(16, 1)


def display(balls):
    """
    显示一组彩票号码

    :param balls: 装彩票号码对应的球的列表
    """
    for ball in balls:
        print(f'{ball:0>2d}', end=' ')
    print()


n = int(input('机选几注: '))

print('双色球: ')
for _ in range(n):
    display(make_two_colors())

print('大乐透: ')
for _ in range(n):
    display(make_big_lottery())

总结

今天分享了函数，函数是功能相对独立且会重复使用的代码的封装，除了python标准库中的不用导入的内置函数、直接能import导入的、pip install下载后import导入的，需要知道我们能自己写函数，并且把他们封装起来，供自己使用，甚至你觉得你的代码足够好，可以上传到官方有机会让大家都能使用。

感谢学习陪伴，您的点赞，评论就是我更新的动力