Python函数、模块与包学习笔记
1. 函数
函数是一段实现某个功能的完整代码，仅在调用时运行，达到一次编写，多次调用
也可以将数据（称为参数）传递到函数中，函数可以把数据作为结果返回。
python中函数分为两大类：内置函数、自定义函数
1.1 内置函数
len() ：计算长度或元素个数
copy() ：拷贝
sorted() ：排序，返回新列表，原序列不变
1.2 自定义函数
在 Python 中，使用 def 关键字定义一个想实现的功能的函数：
def 函数名(形式参数1, 形参2\参数列表):
实现某个功能的完整代码
def 关键字： 全称define
函数名：遵循标识符命名规则
形参：要求调用者提供的数据
#没有参数，也没有返回值
def xz():
print("主角出世")
print("主角修炼")
print("主角成神")
# 空两行
print("xz")
xz() # 调用函数
print("123")
#----xz
#----主角出世
#----主角修炼
#----主角成神
#----123
#有参数，有返回值
def q1(n1, n2):
"""
求和
:param n1: 加数1
:param n2: 加数2
:return: 求和的结果
"""#函数特有的注释
q2 = n1 + n2
print(q2)
q1(2, 3)
q1(2.2, 1)
#----5
#----3.2
在函数外面短暂调用
def q1(n1, n2):
q2 = n1 + n2 # 计算两数之和
print(q2) # 打印计算结果
return q2 # 返回计算结果
# return:将数据返回给调用者（不直接显示）
# 第一次调用
q1(3, 5) # 输出：8
# 第二次调用
print("q2:", q1(3, 5)) # 输出：8 和 q2: 8
# 直接作为print参数
# 第三次调用
q3 = q1(3, 5) # 输出：8
print("q3:", q3) # 输出：q3: 8
# 先存储到变量，再使用变量
#----8 ← 来自 q1(3, 5)
#----8 ← 来自 print("q2:", q1(3, 5)) 中的函数调用
#----q2: 8 ← 来自 print("q2:", ...)
#----8 ← 来自 q3 = q1(3, 5)
#----q3: 8 ← 来自 print("q3:", q3)
#q3 = q1(3, 5)
#将函数返回值存储在变量中
#后续可通过变量名复用结果
#避免重复计算（对比嵌套调用时的多次执行
支持返回多个元素，用一个变量名接收时，以元组的形式；
# 也可以定义多个变量依次接收
def q1(n1, n2):
q2 = n1 + n2 # 计算两数之和
print(q2) # 打印计算结果
return q2, n1, n2 # 返回计算结果
# 第一次调用
q1(3, 5) # 输出：8
# 支持返回多个元素，用一个变量名接收时，以元组的形式；
# 也可以定义多个变量依次接收
# q3 = q1(3, 5) # 输出：8
q3, q4, q5 = q1(3, 5)
print("q3:", q3) # 输出：q3: 8
# 先存储到变量，再使用变量
1.3 可变/不可变类型传参的区别
不可变类型：数字、字符串、元组
可变类型：列表、集合、字典
def w(n1, n2):
n1 = "PS"
n2["name"] = "ll"
a = "CAD"
b = {"name": "xy"}
w(a, b)
print(a)
print(b)
#----CAD
#----{'name': 'll'}
# 不可变类型传参时，函数内部修改不影响原数据的值
# 可变类型传参时，函数内部修改会改变原数据的值
1.4 函数传参
1.4.1 位置传参
def w(n1, n2):
n1 = "PS"
n2["name"] = "ll"
a = "CAD"
b = {"name": "xy"}
w(a, b)
print(a)
print(b)
#----CAD
#----{'name': 'll'}
#----定义的位置与传参位置一致
1.4.2 关键字传参
调用函数时，用 形参名字 = 值 的方式进行传参，传递参数的顺序可以和定义时参数顺序不同
def w(n1, n2,n3):
n1 = "PS"
n2["name"] = "ll"
a = "CAD"
b = {"name": "xy"}
c="ss"
w(n2=b, n1=a,n3=c)
print(a)
print(b)
print(c)
#----CAD
#----{'name': 'll'}
#----ss
#定义几个要传几个，两者要一致，否则报错
如果同时使用 位置传参和关键字传参，传参顺序必须先写位置传参
def w(a1, a2, n1, n2):
n1 = "PS"
n2["name"] = "ll"
a = "CAD"
b = {"name": "xy"}
w(123, 456, n2=b, n1=a)
print(a)
print(b)
1.4.3 默认参数
定义函数时，直接对形参赋值，在调用时如果该参数不传参，将使用默认值，如果该参数传参，则使用传递的值
def r1(name, age, sex='n'):
print(name, age, sex)
r1("xy", 23)
#----xy 23 n
1.4.4 不定长参数
定义函数时，形参用*args表示，数据类型是元组。每次调用函数时，参数个数不同
def r1(*args):
print(args)
r1("xy", 15, "we", [5, 3], {22, 55, "fg"})
#----('xy', 15, 'we', [5, 3], {'fg', 22, 55})
1.4.5 关键字不定长参数
**kwargs
把输入的关键字参数中的关键字当做键值对的键，实参当做键值对的值
def r1(**kwargs):
print(kwargs)
print(type(kwargs))
r1(name="xy", age=15, sex="boy")
r1(name="th", age=18, se="girl")
# r1(sex="girl", name="th", age=18) 也可以，但打印是按照输入顺序打印
#----{'name': 'xy', 'age': 15, 'sex': 'boy'}
#----<class 'dict'>
#----{'name': 'th', 'age': 18, 'se': 'girl'}
#----<class 'dict'>
*args 和 **kwargs同时出现在一个函数中
def r1(*args, **kwargs):
print(args)
print(kwargs)
r1(11, 25, name="xy", age=15, sex="boy")
r1(23, 25, name="th", age=18, sex="girl", hobby="ping pong")
#----(11, 25)
#----{'name': 'xy', 'age': 15, 'sex': 'boy'}
#----(23, 25)
#----{'name': 'th', 'age': 18, 'sex': 'girl', 'hobby': 'ping pong'}
1.5 函数返回值
如果函数的运行结果需要在当前函数体外使用，可以将其定义成带有返回值的函数
返回值用return关键字定义
return可以出现在函数的任意位置用于结束函数，返回值可以是一个值，或多个值，当返回多个值，默认是元组类型。函数没有返回值，结果为none
def t1(n1, n2):
t2 = n1 + n2
return t2
print(t2)
t1(3, 6)
print("t2:", t1(3, 6))
#----t2: 9
#多值
def t1(n1, n2):
t2 = n1 + n2
return t2, n1, n2
print(t2)
t1(3, 6)
print("t2:", t1(2, 6))
#----t2: (8, 2, 6)
1.6 变量的作用域
变量起作用的范围，根据范围大小分为局部变量和全局变量
局部变量：
在函数体内部和函数定义处定义的变量
仅在当前函数体内部有效，函数执行结束，局部变量的生命周期结束
全局变量：global关键字 作用：声明函数内使用的变量是全局变量
在函数体外定义的变量
整个程序运行结束，全局变量的生命周期结束
a = 234 # 定义全局变量 a = 234
def test(n1, n2): # 定义函数 test(n1, n2)
num = n1 + n2 # 局部变量，仅在函数内有效
a = 567 # 创建同名局部变量a，覆盖全局a
global b # 声明b是全局变量（若不存在则创建）
b = 12345 # 修改全局变量b的值
print("a1:", a) # 打印局部变量a
print("b1:", b) # 打印局部变量a
print("qwer") # 第一个执行的打印语句, 输出字符串
test(2, 3) # 函数调用
# print("num:", test(3, 5))
print("a2:", a) # 输出全局变量a
print("b2:", b) # 输出全局变量b
#----qwer
#----a1: 567
#----b1: 12345
#----a2: 234
#----b2: 12345
#变量 函数内部 函数外部 说明
#a 567 234 同名局部变量覆盖全局变量
#b 12345 12345 global声明修改全局变量
#num 存在 不存在 纯局部变量
1.7 匿名函数
没有名字的函数，只能用一次，一般在函数的函数体只有一句代码且返回值只有一个时，使用匿名函数来简化，使用 lambda 来创建匿名函数。
lambda 参数列表：表达式
x = lambda a : a + 10
print(x(5))
#----15
y = lambda n1, n2: n1 + n2
print(y(3, 5))
print((lambda n1, n2: n1 + n2)(32, 52))
#----15
#----8
#----84
2 模块与包
2.1 模块
在 Python 中的模块（Module）是一个包含 Python 定义和语句的文件，文件名就是模块名后加上 .py 后缀。在我们编程的时候，先创建了一个 .py 文件，这个文件就称为一个模块（Module）。
在模块中可以直接存放变量、函数，类、可执行的代码。
我们封装函数用的是 def , 封装类用的是 class 。而我们封装模块，是不需要任何语句的。模块最大的好处就是大大提高了代码的可维护性。
编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括 Python 内置的模块和来自第三方的模块。
使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。
2.1.1 import 语句：
impot a
完整语句：在名为a.py文件中有一个test函数，想去b.py文件中使用，需要在同一级目录下创建两个文件，
在a.py文件中写函数
def test(name):
print("Hello, " + name)
在b.py文件中使用 test 函数
导入名为 b 的模块，并调用 test 函数：
import b
b.test("Bill")
2.1.2 from....import
在Python中，导入一个模块的方法我们使用的是 import 关键字，这样做是导入了这个模块，并没有导入模块中具体的某个属性或方法。而我们想直接导入某个模块中的某一个功能，也就是属性和方法的话，我们可以使用 from···import 语句。
语法：from md import name1[, name2[, ... nameN]]
from 绝对路径（package.subpackage.md3）import name1
绝对路径：从调用包的同级包的上一级开始写
在a.py文件中写函数
def test(name):
print("Hello, " + name)
def hello():
print("Hi")
在b.py文件中使用 test hello 函数
from a import test, hello
hello()
test("Bill")
模块导入
| 导入方式 | 语法 | 使用示例 | 特点 |
| 完整导入 | import module_name | import mymodule | 需使用模块名前缀 |
| 别名导入 | import module_name as alias | import mymodule as mm | 简化长模块名 |
| 部分导入 | from module import name1, name2 | from mymodule import greet | 直接使用对象 |
| 全部导入 | from module import * | from mymodule import * | 导入所有对象（不推荐） |
2.2 包
随着模块数量的增加，把所有的模块不区分放到一起很不合理，Python为我们提供一种把模块组织到一起的方法，即创建一个包。因为包是模块，所以包的使用和普通模块一样
包是包含多个模块的文件夹，必须包含：一个__init__.py文件和多个模块文件或子包
package/
├── __init__.py
├── md1.py
├── md2.py
└── subpackage/
├── __init__.py
└── md3.py
2.2.1 创建包
1.创建文件夹mypackage
2.在文件夹中创建__init__.py文件（可以是空文件）
3.添加模块文件
__init__.py的作用：
3.1标识当前目录是一个Python包
3.2可以包含包初始化代码
3.3定义__all__变量控制from package import *的行为
扫一扫
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
