Python函数与模块

目录

一 函数

1 无参函数

2 带参函数

3 函数中变量的作用域

4 lambda函数

5 内建函数

（1）abs()函数

（2）bool()函数

（3）float()函数

（4）int()

（5）range()

（6）sum()函数

（7）max()函数

（8）min()函数

二 模块与包

1 模块

（1）模块的定义

（2）模块的导入

① import 模块名

② from 模块名 import 对象

③ from 模块名 import *

④ import 模块名 as 别名

⑤ from 模块名 import 对象 as 别名

2 包

（1）包的使用

创建与使用包的步骤

（2）_init_.py的作用

3 常用模块

（1）keyword模块

（2）random模块

（3）sys模块

（4）time模块

---

一 函数

1 无参函数

• 定义：没有参数传递的函数，仅通过函数名直接调用，执行固定逻辑。
• 特点：
  • 无需接收外部输入数据。
  • 功能相对独立，常用于执行重复性、固定流程的操作。

示例：

def add():
    op1=10
    op2=20
    rt=op1+op2
    print(op1,'+',op2,'=',rt)     #字符需要用引号
    return         #返回的数值
add()          #调用函数

2 带参函数

语法：

def  函数名称  （形式参数列表）：

        代码块

        return  [ 表达式 ]

带参函数和无参函数的区别：

• 无参函数：定义时没有参数列表，调用时无需传入参数。

                         功能相对固定，执行预先设定好的操作，难以根据外部输入改变行为。

• 带参函数：定义时会指定参数，调用时一般要传入对应的值，参数形式多样。

                         可依据传入的不同参数执行不同操作，灵活性高，能处理多样化输入。

示例：

#编写计算机功能
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("非法输入")

3 函数中变量的作用域

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

• 局部变量：定义在函数或者代码块内，只能在该函数或者代码块里使用。当函数或者代码块执行结束，局部变量就会被销毁。
• 全局变量：定义在函数外部，能在整个程序里被访问。若要在函数内部修改全局变量，就需要使用 global 关键字。

定义：变量在程序中可被访问的范围，分为以下两种：

• 局部作用域（Local）：
  • 函数内部定义的变量，仅在函数体内可访问。

#局部变量和全局变量
name="tom"         #全局变量
def f1():
    age=18          #局部变量
    print(age,name)
def f2():
    age=19
    print(age,name)
f1()
f2()

全局作用域（Global）：

• 函数外部定义的变量，在全局范围内（包括函数内部）均可访问。

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

4 lambda函数

• 定义：一种简洁的匿名函数，无需使用def关键字定义，通常用于简单逻辑的一次性使用。
• 语法：lambda 参数列表: 表达式
• • 参数列表：可以是无参、单个参数或多个参数（用逗号分隔）。
  • 表达式：函数的返回值，只能有一个表达式（无需return关键字）。

示例：

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

5 内建函数

（1）abs()函数

• 功能：返回一个数的绝对值（正数保持不变，负数转为正数，0 保持 0）。
• 语法：abs(x)
• 参数：x 可以是整数、浮点数或复数（若为复数，返回其模长）。
• 示例：

print(abs(-5))         # 输出：5

print(abs(3.14))         # 输出：3.14

print(abs(-2 + 3j))         # 输出：3.605551275463989

（2）bool()函数

• 功能：将给定值转换为布尔类型（True 或 False）。
• 语法：bool(x)
• 参数：可以是任意数据类型。
• 转换规则：
  • 默认返回 False 的值：False、0、0.0、空字符串 ""、空列表 []、空元组 ()、空字典 {}、空集合 set()、None 等。
  • 其他值默认返回 True。
• 示例：

print(bool(0))         # 输出：False

print(bool("abc"))         # 输出：True

print(bool([]))         # 输出：False

（3）float()函数

• 功能：将参数转换为浮点数。
• 语法：float(x)
• 参数：
  • 可以是整数、浮点数、字符串（需为合法数字格式，如 "123"、"45.67"）。
  • 若参数为布尔值，True 转为 1.0，False 转为 0.0。
• 示例：

print(float(5))         # 输出：5.0

print(float("3.14"))        # 输出：3.14

print(float(True))         # 输出：1.0

（4）int()

• 功能：将参数转换为整数（会舍去小数部分，非四舍五入）。
• 语法：int(x, base=10)（base 可选，指定进制，默认十进制）。
• 参数：
  • x 可以是浮点数、字符串（需为合法整数格式，如 "123"，支持二进制、八进制、十六进制，需以对应前缀开头）、布尔值等。
  • base 常见值：2（二进制）、8（八进制）、16（十六进制）。
• 示例：

print(int(3.9))         # 输出：3（直接截断小数部分）

print(int("1010", base=2))         # 输出：10（二进制转十进制）

print(int(True))         # 输出：1

（5）range()

• 功能：生成一个整数序列（常用于循环迭代）。
• 语法：
  • range(stop)：生成 [0, stop-1] 的整数序列。
  • range(start, stop[, step])：生成 [start, start+step, start+2*step, ...] 的序列，直到不超过 stop。
• 参数说明：
  • start：起始值（包含），默认 0。
  • stop：终止值（不包含），必须指定。
  • step：步长（可选），默认 1，若为负数，序列从大到小生成。
• 示例：

print(list(range(5)))         # 输出：[0, 1, 2, 3, 4]

print(list(range(2, 8, 2)))         # 输出：[2, 4, 6]

print(list(range(10, 0, -1)))         # 输出：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

（6）sum()函数

• 功能：计算可迭代对象（如列表、元组、集合）中所有元素的和。
• 语法：sum(iterable, start=0)（start 可选，指定初始累加值）。
• 参数说明：
  • iterable：包含数字的可迭代对象（元素需支持加法运算）。
  • start：起始值，默认 0，即从 0 开始累加。
• 示例：

print(sum([1, 2, 3]))         # 输出：6（1+2+3）

print(sum([1, 2, 3], 10))         # 输出：16（10+1+2+3）

print(sum((0.5, 1.5)))         # 输出：2.0（支持浮点数）

（7）max()函数

• 功能：返回可迭代对象中的最大值，或多个参数中的最大值。
• 语法：
  • max(iterable, *[, key, default])
  • max(arg1, arg2, *args[, key])
• 参数说明：
  • iterable：可迭代对象（如列表、元组）。
  • arg1, arg2, ...：多个单独参数。
  • key：可选参数，指定一个函数用于提取比较的键（如按元素绝对值比较）。
  • default：可选参数，当可迭代对象为空时返回该值（Python 3.10+ 支持）。
• 示例：

print(max([-5, 2, 8]))         # 输出：8

print(max(3, 9, 1))         # 输出：9

print(max([-3, -5], key=abs))         # 输出：-5（按绝对值比较，-5 的绝对值更大）

（8）min()函数

• 功能：返回可迭代对象中的最小值，或多个参数中的最小值。
• 语法与参数：与 max() 完全一致，仅功能为取最小值。
• 示例：

print(min([-5, 2, 8]))         # 输出：-5

print(min(3, 9, 1))         # 输出：1

print(min([-3, -5], key=abs))         # 输出：-3（按绝对值比较，-3 的绝对值更小）

二 模块与包

1 模块

（1）模块的定义

• 本质：模块是一个包含 Python 代码的 .py 文件，其中可以定义 函数、类、变量 等，用于实现特定功能。
• 作用：
  • 将代码按功能拆分，提高代码的 可维护性 和 复用性。
  • 避免命名冲突（不同模块的同名函数 / 变量相互隔离）。
• 示例：
  • 自定义模块 math_utils.py 中定义加法函数：

# math_utils.py

def add(a, b):

         return a + b

（2）模块的导入

① import 模块名

• 语法：import 模块名
• 作用：导入整个模块，通过 模块名.对象 访问模块内的函数 / 变量。
• 示例：

  import math_utils  # 导入自定义模块
  result = math_utils.add(2, 3)  # 使用模块中的函数
  print(result)  # 输出：5
  

② from 模块名 import 对象

• 语法：from 模块名 import 函数名/类名/变量名
• 作用：直接导入模块中的特定对象，无需通过模块名前缀访问。
• 示例：

  from math_utils import add  # 直接导入 add 函数
  result = add(2, 3)
  print(result)  # 输出：5
  

③ from 模块名 import *

• 语法：from 模块名 import *
• 作用：导入模块中所有公开对象（不建议滥用，可能引发命名冲突）。
• 说明：模块中若定义了 __all__ 列表，则仅导入列表中的对象。

  # math_utils.py 中添加 __all__
  __all__ = ["add"]  # 限制 from * 导入的对象
  

④ import 模块名 as 别名

• 语法：import 模块名 as 别名
• 作用：为模块指定简短别名，方便调用（尤其适用于长模块名）。
• 示例：

  import math_utils as mu  # 给模块取别名 mu
  result = mu.add(2, 3)
  

⑤ from 模块名 import 对象 as 别名

• 语法：from 模块名 import 对象 as 别名
• 作用：为模块中的对象指定别名。
• 示例：

  from math_utils import add as my_add  # 给 add 函数取别名 my_add
  result = my_add(2, 3)

2 包

（1）包的使用

• 定义：包是一个 包含 __init__.py 文件的目录，用于组织多个模块，形成层次化的模块结构。
• 作用：
  • 管理复杂项目的模块结构，避免模块命名冲突。
  • 支持嵌套导入（如 包.子包.模块）。

创建与使用包的步骤

1. 目录结构：

   mypackage/              # 包名（目录名）
       __init__.py        # 必需文件（可为空，用于标识包）
       module1.py         # 子模块
       subpackage/        # 子包
           __init__.py
           module2.py
   

2. 导入包中的模块

   • 导入子模块：

     import mypackage.module1  # 导入顶层模块
     from mypackage.subpackage import module2  # 导入子包中的模块
     

   • 从模块中导入对象：

     from mypackage.module1 import func1  # 直接导入模块中的函数

（2）_init_.py的作用

• 标识目录为包：Python 通过该文件识别目录为包。
• 批量导入模块：在 __init__.py 中预导入模块，简化调用：

  # mypackage/__init__.py
  from . import module1  # 导入顶层模块
  from .subpackage import module2  # 导入子包模块
  

  
  调用时可直接：

  import mypackage.module1  # 无需写完整路径

3 常用模块

（1）keyword模块

作用：用于检查 Python 关键字，或获取关键字列表。
常用函数：

keyword.iskeyword(word)

• 检查指定字符串是否为 Python 关键字，返回 True 或 False。
• 示例：

import keyword
print(keyword.iskeyword('if'))   # 输出: True
print(keyword.iskeyword('hello')) # 输出: False

keyword.kwlist

• 返回当前 Python 版本的所有关键字列表。
• 示例：

print(keyword.kwlist)  
# 输出: ['False', 'None', 'True', 'and', 'as', ..., 'while', 'with', 'yield']

（2）random模块

random模块用于生成随机的浮点数，整数或字符串，常用使用方法：

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

示例：

fruits = ['apple', 'banana', 'cherry']
print(random.choice(fruits))  # 可能输出 'banana'

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)  
print(numbers)  # 可能输出 [3, 1, 5, 2, 4]

letters = ['a', 'b', 'c', 'd']
print(random.sample(letters, 2))  # 可能输出 ['d', 'a']

（3）sys模块

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

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

示例：

import sys
print(sys.argv)  # 输出: ['demo.py', 'arg1', 'arg2']

print(sys.path)  
# 输出: ['', '/usr/lib/python3.8', ...]（路径因环境而异）

sys.stdout.write("Hello, World!\n")  # 等价于 print()

（4）time模块

作用：用于处理时间相关操作，包括获取当前时间、休眠程序、时间格式转换等。
常用函数：

• time.time()

  • 返回当前时间的时间戳（自 1970 年 1 月 1 日以来的秒数，浮点数）。
  • 示例：print(time.time())（可能输出 1682345678.901234）。

• time.sleep(seconds)

  • 让程序休眠指定的秒数（暂停执行）。
  • 示例：

print("开始休眠")
time.sleep(2)  # 休眠 2 秒
print("休眠结束")

time.localtime([secs])

• 将时间戳转换为本地时间的 struct_time 对象（默认使用当前时间）。
• 示例：

local_time = time.localtime()
print(local_time.tm_year)  # 输出当前年份（如 2025）

time.strftime(format, [t])

• 将 struct_time 对象格式化为指定字符串（t 可选，默认当前时间）。
• 常用格式符：
  • %Y：四位数年份（如 2025）
  • %m：两位数月份（01-12）
  • %d：两位数日期（01-31）
  • %H:%M:%S：时分秒
• 示例：

current_time = time.strftime("%Y-%m-%d %H:%M:%S")
print(current_time)  # 输出: "2025-04-24 14:30:45"（举例）

time.strptime(string, format)

• 将时间字符串解析为 struct_time 对象（与 strftime 反向操作）。
• 示例：

t = time.strptime("2025-04-24", "%Y-%m-%d")
print(t.tm_year)  # 输出: 2025

总结对比：

模块	核心功能	典型场景
keyword	检查关键字、获取关键字列表	代码静态分析、关键字过滤
random	生成随机数、随机操作序列	游戏、数据采样、密码生成
sys	访问解释器环境、命令行参数、程序退出	脚本开发、环境配置、程序调试
time	时间获取、休眠、格式转换	计时、日志记录、定时任务