Python函数与模块

一、函数与模块概念
(1)函数
函数是一段可以重复使用的代码，通过传递的参数返回不同的结果。对于重复使用的代码，可以编写为自定义函数以便于重复使用代码。函数可以分为无参函数和带参函数。
函数被编写后，何时被加载取决于该函数何时被调用，若未被调用，则不会加载该函数

无参函数
格式：
def 函数名():
    代码块
    return [表达式]

无参函数以关键字def开始，后面跟函数名、小括号、冒号，最后使用return退出函数。用表达式可以传递函数的返回值，如果没有返回值，则返回None。
函数是以字母、数字和下划线组成的字符串，但不能以数字开头。

带参函数
格式：
def 函数名称(形式参数列表):
    代码块
    return [表达式] 

形式参数列表实际上只是占位符，用于体现参数的个数，每个参数都没有提供具体的数值。
调用带参函数时，需要为每个参数传递对应的实际数值，又称实参列表。
调用带参函数时，传入参数个数必须和声明的参数个数一致。

注：无参函数和实参函数的区别在于：函数名称后面的小括号中有无形式参数列表，简称形参列表。

内建函数是程序自带的函数，不需要导入模块，不必做任何操作，不需要引用就可以调用。

(2)函数中变量的作用域
作用域是指变量在程序中的应用范围，而变量声明的位置决定它的作用域。分为局部变量和全局变量。

全局变量是指在一个模块中最高级别的变量有全局作用域，除非被删除，否则存活到程序运行结束，所有函数都能访问全局变量。

局部变量是指定义在函数内的变量有局部作用域，依赖于定义变量的函数现阶段是否处于活动状态。调用函数时，局部变量产生，暂时存在。一旦函数执行完，局部变量将会被释放。

通俗来讲，局部变量就是在函数体内部定义的变量，作用域仅限于该函数体内部。全局变量就是在脚本中定义的变量，作用域是整个脚本。

局部变量和全局变量的使用规则：
    >  局部变量的作用域仅限于定义它的函数。
    >  全局变量的作用域在整个模块内部都是可见的。
    >  在同一个函数中，不允许有同名局部变量。
    >  在不同的函数中，可以有同名局部变量。
    >  在同一个程序中，全局变量和局部变量同名时，局部变量具有更高的优先级。

(3)常用的函数
lambda函数作用是创建匿名函数，是一种声明函数的特殊方式。其中params相当于函数接收的参数列表，expr是函数返回值的表达式。

语法: lambda 参数列表:表达式

注：使用lambda只能是表达式，不能包含if、for等条件循环语句。

abs()函数能返回一个数字的绝对值（正数）。
语法： abs(x) 
注：参数x可以是正数，也可以是负数。

bool()函数的返回值是True或False。它是Boolean（布尔值）的简写。 当参数是数字时，返回False，其他任何数都返回True。参数是字符串时，None或空字符返回False，否侧返回True。参数是空的列表、元组或字典返回False，否则返回True。

语法： bool(x)

float()函数用于转换数据为float（浮点型）类型
语法：float(x) 参数x可以是字符串或数字。

int()可以将数据转换为整数。
语法：int(x)
注：当参数是字符串时，字符串中只能是整数格式。如果是浮点格式将有异常产生。

range()函数可以生成一个迭代对象
语法：
range(start,stop,step)
第一个参数start表示起始值，是可选参数，默认值是0.
第二个参数stop表示终止值。
第三个参数step表示步长，是可选参数，可以是正数或负数，默认值是1.

从给定的第一个参数开始，到比第二个参数值小1的数字结束，常与for循环一起使用，循环执行指定数字的次数。

sum()函数可以对列表中元素求和。
语法：
sum(iterable[,start])
iterable--可迭代对象，如：列表、元组、集合。
start--指定相加的参数，如果没有设置这个值，默认为0.

max()函数可以返回列表、元组或字符串中最大的元素，如果元素是英文字母，那么字母是“大于”数字的，而小写字母“大于”大写字母。
语法：
max(x,y,z,...)
x 数值表达式
y 数值表达式
z 数值表达式

min()函数返回列表、元组、或字符串中最小的元素，与max()的使用方法相反，取最小值。
语法：
min(x,y,z,...)
x 数值表达式
y 数值表达式
z 数值表达式

(4)模块与包
模块和包都是组织的方式。复杂度低的可以使用模块管理，复杂度高的要用包管理。

模块

模块实际上就是包含python函数或者类的程序。模块就是一个包含python定义和语句的文件，把一组相关的函数或代码组织到一个文件中，一个文件即是一个模块。模块的文件名=模块名+后缀.py 模块之间代码共享，可以相互调用，实现代码重用，并且模块中函数名称必须唯一。

模块和变量一样也有作用域的区别，如果在模块的顶层导入，则作用域是全局的。如果在函数中导入，则作用域是局部的，其作用域只是所在的函数中。一个模块只能被导入一次，是防止多重导入时代码被多次执行。

导入的模块分为Python的标准库、第三方模块和应用程序自定义的模块。加载执行时在搜索路径中找到指定的模块，如果是第一次导入，模块将被加载并执行，之后再调用时就不需要再次加载了。

模块名就是定义的文件名。在调用模块中函数的语句格式是“模块名.函数名”。每个模块都有name属性，表示模块的名称。

导入模块的语法：
import 模块名  # 单个导入

import 模块名1[,模块名2][,模块名3]...  # 多个导入

不适用模块名，直接用函数名进行调用，就需要在导入时指定需要使用模块的属性。
语法：
from 模块名 import 属性名  # 单个导入

from 模块名 import 属性名1[,属性名2][,属性名3]... # 多个导入

重命名模块导入
语法：
import 模块名 as 模块新名称
或
from 模块名 import 属性名 as 属性新名称

包

包实际上是一个目录，存放了许多模块。包中必须包含一个__init__.py的文件，该文件可以为空，表示当前目录是一个包。包还可以嵌套使用，包中可以包含其他子包。
注意：__init__.py 这个文件是初始化包中的公共变量。里面可以写代码，包被导入时，会执行这个文件中的代码。

导入包中的模块只需要在模块名前加上包的名称即可。

(5)常用模块
keyword模块可以查看python语言的关键字，它的属性kwlist包含了所有python关键字的列表。

random模块用于生成随机的浮点数、整数或字符串。
方法            操作
--------------------------------------------------------------------------------
random()        生成一个随机的浮点数，范围在 0.0~1.0之间。
uniform([上限][,下限])  在设定浮点数的范围内随机生成一个浮点数。
randint([上限][,下限])  随机生成一个整数，可以指定这个整数的范围。
choice(序列)        从任何序列中选取一个随机的元素返回。
shuffle(序列)        随机打乱一个序列中元素的顺序。
sample(序列,长度)    从指定的序列中随机截取指定长度的片段，序列本身不做修改。
---------------------------------------------------------------------------------

sys模块包含与Python解释器和运行环境相关的属性和方法，常用的属性和方法如下表:
属性/方法        操作
----------------------------------------------------------------------------------
version            获取解释器的版本信息。
path            获取模块的搜索路径，初始化时使用PYTHONPATH环境变量的值。
platform        获取操作系统平台名称。
maxint            最大的int值。
maxunicode        最大的Unicode值。
stdin            读取信息到shell程序中。
stdout            向shell程序输出信息。
exit()            退出shell程序。
-----------------------------------------------------------------------------------

time模块包含各种操作时间的方法，如表。
属性/方法        操作
-----------------------------------------------------------------------------------
time()            获取当前时间戳。
localtime()        获取当前时间的元组形式。
ctime()            获取当前时间的字符串形式。
asctime(t)        将时间转换成字符串，参数t是元组形式的时间.
sleep(secs)        按指定的时间推迟运行，参数是推迟的时间，单位是秒。
------------------------------------------------------------------------------------

Python中时间有时间戳和元组两种表现形式。时间戳的表现形式是以相对1970.1.1 00:00:00 为起点，以秒计算的偏移量，是唯一的值。而以元组的形式表示则共有9个元素，分别是year（4位数字组成）、month（1-12）、day（1-31）、hours（0-23）、minutes（0-59）、second（0-59）7weekday（0-6，0表示周一）、Julian day（1-366，一年里的天数）、DST flag（-1，0或1，是否是夏令时，默认为-1）。

使用time.time()获得的是以秒为单位的偏移量，在for循环开始处获得时间戳，循环结束时再获得时间戳，相减后就是循环执行的时间。
 

二、示例

（1）无参函数和带参函数

无参函数（return无返回值）
def add():
    op1=10
    op2=20
    rt=op1+op2
    print (op1,'+',op2,'=',rt)
    return
add()

10 + 20 = 30

无参函数（return有返回值）
def add():
    op1=10
    op2=20
    rt=op1+op2
    print (op1,'+',op2,'=',rt)
    return rt
i=add()
print(i)

10 + 20 = 30
30

无参函数（return无返回值）
def nine():
    op1 = (1,2,3,4,5,6,7,8,9)
    op2 = (1,2,3,4,5,6,7,8,9)
    for i in op1:
        for j in op2:
            print (i,"*",j,"=",i * j)
    return
nine()

1 * 1 = 1
...略
9 * 9 = 81

带参函数
def add(x,y):
    return x+y
print(add(1,2))

3

def aa(x,y):		或者  def aa(x,y):
    print(x,y)			  print(x,y)

aa(10,6)		      aa(x=10,y=6)
aa(6,10)		      aa(x=6,y=10)

10 6			       10 6
6 10			       6 10

错误定义：
def aa(x,y)
    print(x, y)

aa(10)   # 会报错，缺少y
aa(x=10) # 会报错，缺少y

def aa(x=1,y):
    print (x,y)
aa(10,6)
位置参数y出现在了有默认值的参数x之前，会报错。

def aa(y,x=1):
    print (x,y)
aa(10,6)

6 10

带参函数定义计算器功能
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    return x / y

# 用户输入
print ("选择运算：")
print ('1、相加')
print ('2、相减')
print ('3、相乘')
print ('4、相除')

choice = int(input("输入你的选择(1/2/3/4):"))

num1 = int(input("输入第一个数字："))
num2 = int(input("输入第二个数字："))

if choice == 1:
    print(num1,"+",num2,"=", add(num1,num2))

elif choice == 2:
    print(num1,"-",num2,"=", subtract(num1,num2))

elif choice == 3:
    print(num1,"*",num2,"=", multiply(num1,num2))

elif choice == 4:
    print(num1,"/",num2,"=", divide(num1,num2))
else:
    print("非法输入")

选择运算：
1、相加
2、相减
3、相乘
4、相除
输入你的选择(1/2/3/4):1
输入第一个数字：15
输入第二个数字：20
15 + 20 = 35

输入你的选择(1/2/3/4):2
输入第一个数字：10
输入第二个数字：2
10 - 2 = 8

输入你的选择(1/2/3/4):3
输入第一个数字：66
输入第二个数字：23
66 * 23 = 1518

输入你的选择(1/2/3/4):4
输入第一个数字：80
输入第二个数字：33
80 / 33 = 2.4242424242424243

输入你的选择(1/2/3/4):5
输入第一个数字：11
输入第二个数字：11
非法输入

（2）局部变量和全局变量

局部变量的使用
name = 'Tim'

def f1():
    age = 18 # 局部变量
    print(age,name)

def f2():
    age=19 # 局部变量
    print(age,name)
f1()
f2()

18 Tim
19 Tim

def f1():
    global name  # 全局变量，要写在前面
    name='Tim'   # 定义变量的值，写在后面，注意前后顺序
    age = 18 # 局部变量
    print(age,name)

def f2():
    age=19 # 局部变量
    print(age,name)

f1()
f2()

18 Tim
19 Tim

（3）lambda函数

lambda函数
def sum1(x,y):
    return x+y

sum2=lambda x,y:x+y
print(sum1(3,4))
print(sum2(3,4))

7
7

（4）内建函数

abs()函数
>>> abs(10)
10
>>> abs(-10)
10
>>> bb=-3
>>> abs(bb)
3

bool()函数
>>> bool()
False
>>> bool(0)
False
>>> bool(-3)
True
>>> bool(None)
False
>>> bool('')
False
>>> bool('xyz')
True
>>> bool([11,22])
True

float()函数
>>> float('25')
25.0
>>> float(3)
3.0
>>> float(999.586103)
999.586103
>>> float('999.586103')
999.586103

int()函数
>>> int(199.99)
199
>>> int('100')
100
>>> int('99.9')
Traceback (most recent call last):
  File "<python-input-17>", line 1, in <module>
    int('99.9')
    ~~~^^^^^^^^
ValueError: invalid literal for int() with base 10: '99.9'

range()函数
>>> range(0,5)
range(0, 5)
>>> list(range(0,5))
[0, 1, 2, 3, 4]
>>> range(0,30,3)
range(0, 30, 3)
>>> list(range(30,0,-3))
[30, 27, 24, 21, 18, 15, 12, 9, 6, 3]

>>> for i in range(0,5):
...     print (i)
...
0
1
2
3
4

num()函数
>>> num=list(range(1,101))
>>> num
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> print(sum(num))
5050

max()函数
>>> num = [6,2,12,7,65]
>>> max(num)
65
>>> string = 'd,u,a,n,g,D,U,A,N,G'  # 字符串比大小，通过ascli表中数值进行比对。
>>> max(string)
'u'
>>> max(1000,650,98,2678,9)
2678

min()函数
>>> min([6,2,12,7,65])
2

（5）模块
[root@localhost ~]# ls
anaconda-ks.cfg  a.py  b  __pycache__
[root@localhost ~]# cat a.py  # 模块内的函数
def add(x,y):
    print(x+y)

def mul(x,y):
    print(x*y)

>>> import a # 导入模块（方式一），使用方式为模块名.函数名
>>> a.add(1,2)
3
>>> a.mul(6,6)
36

>>> from a import add,mul  # 导入模块（方式二），使用方式为直接用函数名即可。
>>> add(2,3)
5
>>> mul(2,3)
6

>>> from a import add as add1,mul as mul1 # 导入模块（方式三），使用方式为直接用别名来使用函数，或者使用原函数名。
>>> add1(2,3)
5
>>> mul1(2,3)
6
>>> add(2,3)
5
>>> mul(2,3)
6

>>> import sys # 导入Python标准库内置模块sys
>>> print (sys.platform)  # platform函数用于输出当前的操作系统。
linux

（6）包
导入包中模块只需要在模块名前加上包的名称即可。
在/root下目录结构
b/  # 目录（项目的主目录）
	c.py  #  项目的主文件，内写大量的python语句，其中包含了导入包中模块的语句。
	d/  # 子目录（包名） 
	__init__.py   # 必备文件，表示该目录是一个包。
	e.py   # 模块的名字

[root@localhost d]# pwd 
/root/b/d
[root@localhost d]# ls
e.py  __init__.py  __pycache__
[root@localhost d]# cat e.py 
def add(x,y):		# 函数add用于两数相加。
    return x+y

def mul(x,y):		# 函数mul用于两数相乘。
    return x*y

def subtract(x,y):	# 函数subtract用于两数相减。
    return x-y

def divide(x,y):	# 函数divide用于两数相除。
    return x/y


[root@localhost b]# pwd
/root/b
[root@localhost b]# ls
c.py  d
[root@localhost b]# cat c.py   # 主项目文件，只写了导入包中模块这一部分的语句。
import d.e		 # 导入d包中的e模块

print(d.e.add(1,3))	 # 使用e模块中的函数add，并赋值。
print(d.e.mul(2,4))	 # 使用e模块中的函数mul，并赋值。
print(d.e.subtract(3,4)) # 使用e模块中的函数subtract，并赋值。 
print(d.e.divide(5,6))   # 使用e模块中的函数divide，并赋值。

[root@localhost d]# cat __init__.py  # 该文件会初始化包中的公共变量，当使用import语句导入d包中的任何部分后，会执行包中init.py文件代码。
name='ooos'
print(name)

[root@localhost b]# python c.py   #在linux中导入包
ooos		 # init文件中定义的name，先加载init文件，所以输出在第一位。
4		 # add函数
8		 # mul函数
-1		 # subtract函数
0.8333333333333334 # divide函数

（7）常用模块
keyword模块
>>> import keyword
>>> print(keyword.iskeyword('if'))
True
>>> print(keyword.iskeyword('abc'))
False
>>> print (keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

random模块
>>> import random
>>> print (random.randint(1,100))
89
>>> print (random.randint(100,500))
201
>>> list1 = ['aaa','bbb','ccc']
>>> str1 = random.choice(list1)
>>> print ('随机选取列表中的一个元素: ',str1)
随机选取列表中的一个元素:  ccc
>>> print('重新排序后:\n')
>>> random.shuffle(list1)
>>> print(list1)
重新排序后:
['ccc', 'bbb', 'aaa']

sys模块
>>> import sys
>>> print ("Python version:%s" %sys.version)
Python version:3.13.2 (tags/v3.13.2:4f8bb39, Feb  4 2025, 15:23:48) [MSC v.1942 64 bit (AMD64)]
>>> print ("Python platform:%s" %sys.platform)
Python platform:win32
>>> print ("Python path:%s" %sys.path)
Python path:['', 'E:\\Python\\python313.zip', 'E:\\Python\\DLLs', 'E:\\Python\\Lib', 'E:\\Python', 'E:\\Python\\Lib\\site-packages']

time模块
>>> import time
>>> print (time.time())
1745468481.388366
>>> print (time.asctime())
Thu Apr 24 12:21:28 2025
>>> print (time.localtime())
time.struct_time(tm_year=2025, tm_mon=4, tm_mday=24, tm_hour=12, tm_min=21, tm_sec=35, tm_wday=3, tm_yday=114, tm_isdst=0)
>>> t1 = (2016,5,2,10,30,12,12,12,0)
>>> print (time.asctime(t1))
Sat May  2 10:30:12 2016
>>> t2 = time.localtime()
>>> year = t2[0]
>>> print(year)
2025