python函数与模块

|-------------|-----------|
| int() | 转换为整数 |
| float() | 转换浮点数 |
| str() | 转换字符串 |
| bool() | 转换布尔值 |
| list() | 转换为列表 |
| tuple() | 转换元组 |
| dict() | 转换字典 |
| set() | 转换集合 |

3，数学运算

|-----------------------|----------------|
| abs() | 绝对值 |
| round() | 四舍五入 |
| sum(),min(),max() | 求和，最小值，最大值 |
| pow() | 幕运算 |

**4，**迭代与序列操作

|------------------|---------------------|
| len() | 获取对象长度（如字符串、列表） |
| range() | 生成整数序列 |
| sorted() | 排序 |
| eneumerate() | 为序列添加索引 |
| zip() | 将多个序列合并为元组序列 |

5，对象操作

|------------------|------------------|
| type() | 获取对象类型 |
| isinstance() | 检查对象是否是某类的实例 |
| id() | 获取对象的内存地址 |
| dir() | 查看对象的属性和方法 |

6，函数式编程

|--------------|-----------------------------|
| map() | 对序列应用函数 |
| filter() | 过滤序列元素 |
| reduce() | 累积计算（需从 functools 导入） |

7，反射与动态执行

|-----------------------------------|--------------|
| evel() | 执行字符串表达式 |
| exec() | 执行字符串代码。 |
| hasattr(),getattr(),setattr() | 操作对象属性 |

8，文件与IO：open()打开文件

函数是一段可以重复使用的代码，通过传递的参数返回不同的结果，对于重复使用的代码，可以编写为自定义函数以便于重复使用代码，同时提高开发人员的开发效率。函数可以分为无参函数和带参函数。

1，无参函数

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

示例一：

python 复制代码

def add():
    op1 = 10
    op2 = 20
    rt = op1 + op2
    print(op1,'+',op2,'=',rt)
    return 
add()


##执行结果
10 + 20 = 30

该程序首先定义了无参函数 add()，它输出 10+20 的结果值，return 没有返回值，直接使用函数名 add()进行了调用。

把上面的代码进行修改，用return 返回结果值。

python 复制代码

def add():
    op1 = 10
    op2 = 20
    rt = op1 + op2
    return rt
i=add()
print(add())


##执行结果30

函数 add()使用 return 语句可以返回两数相加的结果值，变量 i 接收函数 add()返回的值。Python 在处理返回值时，如果没有 return 语句，会默认返回 None，程序并不会报错。

示例二：输出九九乘法表

python 复制代码

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()

使用函数时经常会范围一些错误，总结如下:

函数的定义要先于函数的调用，否则会出错。
函数体的代码是一个整体，要注意缩进。
定义函数时要使用冒号，但调用时不可以使用冒号。

2，带参函数

带参函数语法如下：

def 函数名称（形式参数列表):

代码块

return [表达式]

带参函数与无参函数的区别是在函数名称后面的小括号中有形式参数列表，简称形参列表。
注意:形式参数列表实际上只是占位符，用于体现参数的个数，每个参数都没有提供具体的数值。
调用带参函数时，需要为每个参数传递对应的实际数值，又称实参列表。

示例一：定义并调用带参函数完成两数相加的运算。

python 复制代码

def add(x,y):
    return x+y
print(add(1,2))


##执行结果
3

示例二：使用位置参数方式或关键字参数方式调用带参函数

python 复制代码

def aa(x, y):
print(x, y)
aa(10, 20)
aa(20, 10)


#执行结果：
10 6
6 10

调用带参函数时，传入函数的参数个数必须和声明的参数个数一致。当函数包含有多个
参数时，一旦实参个数与形参个数不符，就可能出错。为了避免这样的错误发生，Python 在
函数定义时允许为形式参数指定默认值，从而在调用参数时可以少写参数，省略的参数用默认值为其赋值。

python 复制代码

def aa(x,y):
    print(x,y)
aa(10)                     ##缺少y的值，会报错
aa(x=10)                   ##缺少y，无法执行
aa(10,5)
aa(x=10, y=5)

示例三：编码实现计算器功能

python 复制代码

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("无效的输入")

二：函数中变量的作用域

作用域是指变量在程序中的应用范围，而变量声明的位置决定它的作用域。Python 按作用域区分有局部变量和全局变量。
全局变量是指在一个模块中最高级别的变量有全局作用域，除非被删除,否则存活到程序运行结束，所有函数都能访问全局变量。
局部变量是指定义在函数内的变量有局部作用域，依赖于定义变量的函数现阶段是否处于活动状态。调用函数时，局部变量产生，暂时存在。一旦函数执行完，局部变量将会被释放。

局部变量和全局变量的使用规则:

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

示例一：使用函数实现年龄的输出

python 复制代码

name = 'zhangsan'
def f1():
    age1 = 18
    print(name,age1)

def f2():
    age2 = 20
    print(name,age2)
f1()
f2()


##执行结果
zhangsan 18
zhangsan 20

在 Python 中尽量不使用全局变量，因为程序的任意代码都可以自由地访问和修改全局变量的值，非常容易出现数据被意外修改的错误，而这种错误很难被发现。

global 的作用是声明变量为全局变量，即使变量定义在函数内部，加上 global 后，也可以在全局范围访问。示例代码如下：

python 复制代码

def f1():
    global name
    name = 'zhangsan'
    age1 = 18
    print(name,age1)

def f2():
    age2 = 20
    print(name,age2)

f1()
f2()

zhangsan 18 
zhangsan 20

三：lambda函数

lambda 函数的作用是创建匿名函数，是一种声明函数的特殊方式。其中 params 相当于
函数接收的参数列表，expr 是函数返回值的表达式。
示例：编写一个普通函数和一个lambda函数。

python 复制代码

def sum1(x,y):
    return x+y

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

##执行结果
7
7

实现的是相同的功能，但 lambda 函数更加简洁，只需一条语句实现，所以 lambda 也称
为 lambda 表达式。使用 lambda 只能是表达式，不能包含 if、for 等条件循环语句。对于
不需要复用、简单的匿名函数，使用 lambda 能起到很好的效果。

四：内建函数

内建函数是程序员经常使用到的方法，可以提高程序的编写效率。如 float()就是内建的函数。内建函数是自动加载的，Python 的解释器可以识别。它不需要导入模块，不必做任何的操作，不需要引用就可以调用

1，sbs()函数

abs()函数能够返回一个数字的绝对值，即正数。语法：

abs(x)
参数x可以是正数，也可以是负数，

python 复制代码

abs(10)
10

abs(-10)
10

bb = -3
sbs(bb)
3

参数是 10 或-10，返回的是绝对值，结果都是 10.

2，bool()函数

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

python 复制代码

bool() ##没有参数时返回
false

bool(0)
false

bool(-3)
True

bool(None)     ##括号中None，首字母要大写
false

bool('')
false

bool('xyz')
true

bool([11,22])
true

3，float()函数

float()函数用于转换数据为 float 类型， 参数 x 可以是字符串或数字

python 复制代码

float('25')
25.0

float(3)
3.0

float(999.586103)
999.586103

float('999.586103')
999.586103

##字符串和数字都可以转为 float 类型。如果不能转换，就会抛出异常

4，int()

python 复制代码

##int()函数可以将数据转换为整数

int(199.99)    #浮点数   
199

int('100')
100

int('100')     #字符串
100


int('99.9')    #会报错
##当参数是字符串时，字符串中只能是整数格式。如果是浮点格式将有异常产生。

5,range()

range()函数可以生成一个迭代对象，

第一个参数 start 表示起始值，是可选参数，默认值是 0。
第二个参数 stop 表示终止值。
第三个参数表示步长，是可选参数，可以是正数或负数，默认值是 1

python 复制代码

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

>>> 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))    ##0表示开始的数字，30表示结束的，3表示步进
[30, 27, 24, 21, 18, 15, 12, 9, 6, 3]

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

6,sum()函数

python 复制代码

##sum()函数可以对列表中元素求和，使用 range()生成了一个列表，然后使用 sum()对列表中的数值进行累加求和。

>>> 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

7，max()函数

max()函数可以返回列表、元组或字符串中最大的元素，如果元素是英文字母，那么字母是
"大于"数字的，而小写字母"大于"大写字母，

python 复制代码

>>> num = [1,20,30,40]
>>> max(num)
40
>>> string = 'a,b,c,A,B,C'
>>> max(string)
'c'

8，min()函数

min()函数返回列表、元组、或字符串中最小的元素，与 max()的使用方式相反，它取的是最
小值，

python 复制代码

>>> min([10,20,30,40,1])
1

五：模块与包

如果编写的程序中类和函数较多时，就需要对它们进行有效的组织分类，在 Python 中模
块和包都是组织的方式。复杂度较低可以使用模块管理，复杂度高则还要使用包进行管理

1，模块

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

模块定义如下：

python 复制代码

##在linux系统中进行操作
##定义模块
[root@localhost ~]# cat myModule.py 
def add(a,b):
    print (a+b)
def mul(a,b):
    print (a*b)

在模块 myModule 中，定义了 2 个函数，一个加法函数和一个乘法函数。它们处理的问题
是同类的，作为一个模块定义。

模块导入

使用模块中的函数时，要先导入模块才能使用，导入有 2 种方式。在一行导入一个模块，

语法如下。
import 模块名
以在一行导入多个模块，语法如下：
import 模块名 1[，模块名 2][，模块名 3]...
模块和变量一样也有作用域的区别。如果在模块的顶层导入，则作用域是全局的。如果在
函数中导入，则作用域是局部的，
导入的模块也分几种，有 Python 的标准库模块、第三方模块和应用程序自定义的模块。
加载执行时在搜索路径中找到指定的模块，如果是第一次导入，模块将被加载并执行，之后再
调用时就不需要再次加载了。

python 复制代码

>>> import sys
>>> print (sys.platformn)
linux


##导入并调用自定义模块myModule
>>> import myModule
>>> myModule.add(2,3)
>>> myModule.mul(2,3)
#结果
5
6

如果不使用模块名，而直接用函数名进行调用，就需要在导入时指定需要使用模块的属
性，一行导入一个模块属性的语法如下：

from 模块名 import 属性名

导入模块的多个属性语法如下：

from 模块名 import 属性名 1[，属性名 2] [，属性名 3]...

python 复制代码

##导入模块属性

>>> from myModule import add,mul
>>> add(2,3)
5
>>> mul(2,3)
6
>>>

还可以使用 as 关键字为模块或模块属性重新命名，语法如下：

import 模块名 as 模块新名称
或者
from 模块名 import 属性名 as 属性新名称

python 复制代码

##使用 as 关键字为模块重新命名

>>> from myModule import add as add1,mul as mull

>>> add1(2,3)
5

>>> mull(2,3)
6

2，包

当程序中的模块非常多时，可以把模块再进行划分，组织成包。包实际上就是一个目录，但必须包含一个" init .py"文件。" init .py"可以是一个空文件，表示当前目录是一个包。包还可以嵌套使用，包中可以包含其它子包。
1，包的使用
创建目录project/project.py subproject project包含project.py subproject
而subproject 目录则需要创建__init__.py submodel.py

python 复制代码

[root@localhost subproject]# cat submodel.py 
def add(a,b):
    return a+b


[root@localhost project]# cat project.py 
import subproject.submodel
print (subproject.submodel.add(1,3))


>>> project.py
4

2，init.py
前面使用的是空 init.py 文件，也可以在里添加代码，它的作用实际上是初始化包中的公共变
量。在第一次使用 import 导入 subproject 包中的任何部分后，会执行包中的 init .py 文件代码。

python 复制代码

##在 subproject 目录中的__init__.py，加入如下代码

[root@localhost subproject]# cat __init__.py 
name = '__init__.py'
print ('subproject->',name)


python3 project.py
subproject->__init__.py
4

六：常用模块

1，keyword 模块

使用 keyword 模块可以查看 Python 语言的关键字，它的属性 kwlist 包含了所有 Python 关键
字的列表。方法 iskeyword(字符串)用于判断参数是否是 Python 的关键字。如果参数是 Python 的关键字，则返回 True；否则，返回 False.

python 复制代码

>>> import keyword
>>> print(keyword.iskeyword("if"))
True
>>> print(keyword.iskeyword("abcde"))
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']

2，random模块

random 模块用于生成随机的浮点数、整数或字符串，常用的方法如下表所示。

random() ：生成一个随机的浮点数，范围在 0.0~1.0 之间
uniform([上限][，下限]) ：在设定浮点数的范围内随机生成一个浮点数
randint([上限][，下限]) ：随机生成一个整数，可以指定这个整数的范围20
choice(序列)：从任何序列中选取一个随机的元素返回
shuffle(序列) ：随机打乱一个序列中元素的顺序
sample(序列，长度)：从指定的序列中随机截取指定长度的片断，序列本身不做修改

python 复制代码

##使用 random 模块常用方法生成随机整数，并重新排序

>>> import random
>>> print (random.randint(1,100))
21

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

>>> random.shuffle(list1)
>>> print (list1)
['bbb', 'aaa', 'ccc']

3，sys模块

sys 模块包含与 Python 解释器和运行环境相关的属性和方法，常用的属性和方法如下：

version：获取解释器的版本信息
path：获取模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值
platform：获取操作系统平台名称
maxint：最大的 int 值
maxunicode：最大的 Unicode 值
stdin：读取信息到 Shell 程序中
stdout：向 Shell 程序输出信息
exit()：退出 Shell 程序

python 复制代码

>>> import sys
>>> print ("Python version:%s" %sys.version)
Python version:3.11.6 (main, Dec 18 2024, 22:06:12) [GCC 12.3.1 (openEuler 12.3.1-62.oe2403sp1)]

>>> print ("Python platform:%s" %sys.platform)
Python platform:linux

>>> print ("Python path:%s" %sys.path)
Python path:['', '/usr/lib64/python311.zip', '/usr/lib64/python3.11', '/usr/lib64/python3.11/lib-dynload', '/usr/lib64/python3.11/site-packages', '/usr/lib/python3.11/site-packages']

4，time模块

time 模块包含各种操作时间的方法

time()：获取当前时间戳
localtime()：获取当前时间的元组形式
ctime()：获取当前时间的字符串形式
asctime(t)：将时间转换成字符串，参数 t 是元组形式的时间
sleep(secs)：按指定的时间推迟运行，参数是推迟的时间，单位是

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

python 复制代码

>>> import time
>>> print (time.time())
1745485625.9917963

>>> print (time.asctime())
Thu Apr 24 17:07:17 2025

>>> print (time.localtime())
time.struct_time(tm_year=2025, tm_mon=4, tm_mday=24, tm_hour=17, tm_min=7, tm_sec=29, tm_wday=3, tm_yday=114, tm_isdst=0)

>>> t1 = (2015,9,29,10,30,12,12,12,0)
>>> print (time.asctime(t1))
Sat Sep 29 10:30:12 2015

>>> t2 = time.localtime()
>>> year = t2[0]
>>> print (year)
2025
>>>

python函数与模块

一：函数

1，无参函数

2，带参函数

二：函数中变量的作用域

三：lambda函数

四：内建函数

1，sbs()函数

2，bool()函数

3，float()函数

5,range()

6,sum()函数

7，max()函数

8，min()函数

五：模块与包

1，模块

2，包

六：常用模块

1，keyword 模块

2，random****模块

3，sys模块

4，time模块

2，random模块