Python组蓝桥杯备赛超详细知识点总结笔记_语言基础篇3---函数、类与Python常用库函数

Python组蓝桥杯备赛超详细知识点总结笔记_语言基础篇3—函数、类与Python常用库函数

六、函数

1. 函数的基本定义与声明

def 函数名(参数列表):
    """函数文档字符串（可选，描述功能、参数、返回值）"""
    # 函数体:
    功能代码逻辑
    return 返回值  # 可选，无return则默认返回None

2. 函数的调用方式

调用场景	示例代码	说明
直接调用	greet("Alice")	仅执行函数逻辑，不接收返回值（适用于无返回值或仅需副作用的函数）
接收返回值	result = sum_two_numbers(10, 20)	将函数返回值赋值给变量，用于后续处理
作为表达式组件	print(sum_two_numbers(5, 3))、total = sum_two_numbers(2, 3) * 4	调用结果可直接用于打印、运算等表达式中
作为函数参数	max_result = max(sum_two_numbers(1,2), sum_two_numbers(3,4))	函数调用结果作为另一个函数的实参

3. 函数的参数类型

参数类型	定义语法	调用要求	适用场景
位置参数	def func(a, b):	必须按顺序传入，数量与形参一致	最基础的必选参数场景，如计算两数和
关键字参数	func(a=1, b=2)	通过形参名=值传入，调用时使用，可忽略顺序	参数较多时，提高调用可读性
默认参数	def func(a, b=2):	调用时可省略，使用默认值；若传入则覆盖默认值	参数值相对固定的场景，如默认分页大小
可变位置参数	def func(*args):	接收任意数量位置实参，自动封装为元组	不确定参数数量的场景，如求多个数的和
可变关键字参数	def func(**kwargs):	接收任意数量关键字实参，自动封装为字典	不确定参数名称和数量的场景，如接收用户属性

4. 参数组合顺序

当多种参数类型同时使用时，需遵循固定顺序（从左到右）：

​ 位置参数 → 默认参数 → 可变位置参数（*args） → 可变关键字参数（**kwargs）

# 正确的参数组合示例
def func(a, b, c=3, *args, **kwargs):
    print(f"位置参数：a={a}, b={b}")
    print(f"默认参数：c={c}")
    print(f"可变位置参数：args={args}")
    print(f"可变关键字参数：kwargs={kwargs}")

func(1, 2, 4, 5, 6, x=7, y=8)
# 输出：
# 位置参数：a=1, b=2
# 默认参数：c=4
# 可变位置参数：args=(5, 6)
# 可变关键字参数：kwargs={'x': 7, 'y': 8}

5. 函数的返回值

返回场景	示例代码	输出结果
无返回值	def print_hello(): print("Hello")``result = print_hello()	None
返回单个值	def multiply(a, b): return a * b``result = multiply(4, 5)	20
返回多个值	def get_user(): return "Alice", 30, "female"``name, age, sex = get_user()	name=Alice, age=30, sex=female
提前终止函数	def check_num(n):``if n < 0: return "负数"``return "非负数"	输入-5返回 “负数”

说明：返回多个值本质是返回一个元组，调用时可通过 “解包” 赋值给多个变量。

6. 匿名函数（lambda 函数）

（1）基本语法

lambda 参数列表: 表达式  # 表达式结果即为返回值

（2）应用示例

应用场景	示例代码	说明
简单计算	add = lambda x, y: x + y``print(add(3, 5))	实现两数相加，等价于普通函数def add(x,y): return x+y
作为函数参数	numbers = [(1,3), (4,1), (2,5)]``numbers.sort(key=lambda x: x[1])	作为sort函数的key参数，按元组第二个元素排序
配合内置函数	list1 = [1,2,3,4]``list2 = list(map(lambda x: x*2, list1))	配合map函数实现列表元素翻倍，返回[2,4,6,8]

7. 常见错误与注意事项

错误类型	错误原因	解决方案
NameError	函数调用在声明之前，或函数名拼写错误	确保函数先定义后调用，检查函数名拼写
TypeError	实参数量与形参不匹配，或参数类型错误	核对实参数量，确保类型符合函数逻辑要求
SyntaxError	函数定义语法错误（如参数顺序错误、缩进错误）	遵循参数组合顺序，确保函数体缩进一致
默认参数失效	默认参数为可变对象（如列表、字典），多次调用后状态累积	将默认参数设为None，在函数内部初始化可变对象（如if lst is None: lst = []）

七、类

1. 类的定义

class 类名(父类列表):
    """类的文档字符串，描述类的功能"""
    # 类属性
    类属性名 = 属性值
    
    # 初始化方法（创建对象时自动调用）
    def __init__(self, 参数1, 参数2, ...):
        # 对象属性（每个对象独有）
        self.对象属性名1 = 参数1
        self.对象属性名2 = 参数2
    
    # 对象方法
    def 方法名(self, 参数列表):
        方法体

2. 核心操作

操作类型	方法 / 语法	功能描述
实例化	对象名 = 类名(参数列表)	创建类的实例对象（调用构造方法）
访问类成员	类名.类属性	访问类属性
	类名.类方法()	调用类方法
访问对象成员	对象名.对象属性	访问对象属性
	对象名.对象方法()	调用对象方法

3. 方法类型

	对象方法	类方法	静态方法
装饰器	无	@classmethod	@staticmethod
第一个参数	必须是对象对象，约定为 self	必须是类对象，约定为 cls	无强制参数，可随意定义
访问权限	可访问对象属性和类属性	仅可访问类属性，不可访问对象属性	不可访问类属性和对象属性
调用方式	仅能通过对象调用	类和对象均可调用（推荐类调用）	类和对象均可调用

4. 类的继承与方法重写

（1）继承的基本语法与分类

# 父类（基类）
class 父类名:
    父类属性和方法

# 子类（派生类）：括号中指定父类
class 子类名(父类名):
    # 子类的扩展属性和方法
    def __init__(self, 父类参数, 子类参数):
        # 调用父类的初始化方法（必选，否则父类属性无法初始化）
        super().__init__(父类参数)  # 推荐方式
        # 或 父类名.__init__(self, 父类参数)
        self.子类参数 = 子类参数

继承类型	定义说明	语法示例
单继承	子类仅继承一个父类	class Dog(Animal):
多继承	子类同时继承多个父类，获取所有父类的属性和方法	class Duck(Flyer, Swimmer):

（2）方法重写

子类定义与父类同名、同参数列表的方法，覆盖父类原有实现，使子类对象调用该方法时，执行的是子类自定义逻辑而非父类逻辑。

# 父类：定义通用方法
class Animal:
    def make_sound(self):
        print("动物发出叫声")  # 父类的通用实现

# 子类：重写父类方法
class Dog(Animal):
    def make_sound(self):
        print("汪汪汪")  # 子类的自定义实现

# 调用验证：执行子类重写后的方法
dog = Dog()
dog.make_sound()  # 输出：汪汪汪

（3）super() 函数

返回父类的代理对象，用于在子类中调用父类的方法（如初始化方法、普通方法），无需硬编码父类名称，增强代码灵活性。

# 父类：定义带参数的初始化方法
class Animal:
    def __init__(self, name):
        self.name = name  # 父类的属性

# 子类：新增参数，用super()调用父类初始化
class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的__init__，初始化name属性
        super().__init__(name)
        # 初始化子类独有的breed属性
        self.breed = breed

# 验证：父类和子类属性均正常初始化
dog = Dog("大黄", "中华田园犬")
print(dog.name, dog.breed)  # 输出：大黄 中华田园犬

• 核心优势：
  1. 解耦父类名称：若父类名后续修改，子类中的调用代码无需同步修改。
  2. 支持多继承：自动遵循 “方法解析顺序（MRO）” 调用父类方法，避免手动调用导致的冲突。

（4）多继承与方法解析顺序（MRO）

• MRO 定义：多继承时，Python 通过 “方法解析顺序” 确定调用方法的优先级，确保每个类只被调用一次，核心遵循 “广度优先” 原则（先遍历同级父类，再遍历上级父类）

• 查看 MRO：类名.__mro__ 或 class.mro() 查看顺序（返回元组，从左到右优先级递减）

# 定义多层父类
class A:
    def func(self):
        print("A的func方法")

class B(A):
    def func(self):
        print("B的func方法")

class C(A):
    def func(self):
        print("C的func方法")

# 多继承子类：同时继承B和C
class D(B, C):
    pass

# 1. 查看D类的MRO顺序
print(D.__mro__)  
# 输出：(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

# 2. 调用func方法：按MRO顺序查找，优先执行B的实现
d = D()
d.func()  # 输出：B的func方法

5.多态

子类重写父类的统一接口方法，通过 “父类类型的引用” 调用子类方法，实现 “同一接口，不同实现”

# 父类：定义统一接口
class Animal:
    def make_sound(self):
        pass  # 父类仅定义接口，不实现具体逻辑

# 子类1：重写接口方法
class Dog(Animal):
    def make_sound(self):
        print("汪汪汪")

# 子类2：重写接口方法
class Cat(Animal):
    def make_sound(self):
        print("喵喵喵")

# 统一调用函数：接收Animal类型的参数（实际可传任意子类对象）
def animal_sound(animal):
    animal.make_sound()  # 调用统一接口

# 调用验证：传入不同子类对象，执行不同逻辑
animal_sound(Dog())  # 输出：汪汪汪
animal_sound(Cat())  # 输出：喵喵喵

6. Python 访问控制机制

Python 没有严格的 public/private 关键字，而是通过 “命名规则” 实现访问限制，本质是 “约定优于强制”，开发者需自觉遵循。

访问级别	命名规则	访问范围	应用场景
公开成员	普通命名（如 name、get_info()）	类内部、子类、类外部均可自由访问	对外提供的接口（如获取用户信息）
保护成员	单下划线开头（如 _age、_calc_total()）	类内部、子类可访问；类外部不建议直接访问（仅为约定，非强制）	子类需复用的内部辅助逻辑
私有成员	双下划线开头（如 __password、__check_pwd()）	仅类内部可访问（Python 会自动 “名称修饰”，外部无法直接调用）	类的核心敏感数据（如密码、密钥）

class User:
    def __init__(self, name, password):
        self.name = name        # 公开成员：对外可见
        self._age = 18          # 保护成员：子类可访问，外部不建议用
        self.__password = password  # 私有成员：仅类内部可访问
    
    # 私有方法：仅类内部可调用，用于验证密码
    def __check_password(self, pwd):
        return self.__password == pwd
    
    # 公开方法：对外提供登录接口，间接访问私有成员
    def login(self, pwd):
        if self.__check_password(pwd):
            print(f"{self.name} 登录成功")
        else:
            print("密码错误")

# 实例化与访问验证
user = User("张三", "123456")

# 1. 访问公开成员：正常
print(user.name)  # 输出：张三

# 2. 访问保护成员：不建议但可访问（仅为约定）
print(user._age)  # 输出：18

# 3. 直接访问私有成员：报错（名称修饰后无法识别）
# print(user.__password)  # AttributeError: 'User' object has no attribute '__password'
# user.__check_password("123456")  # AttributeError: 'User' object has no attribute '__check_password'

# 4. 通过公开接口访问私有成员：正常
user.login("123456")  # 输出：张三 登录成功

八、Python 常用库函数

1. 模块的导入

导入方式	语法格式	调用方式	优点	缺点	适用场景
1. 导入整个模块	import 模块名	模块名.类/函数/变量	避免命名冲突，清晰区分模块来源	调用时需写完整模块名，代码稍冗余	模块内工具较多，需明确区分来源（如 datetime）
2. 模块别名导入	import 模块名 as 别名	别名.类/函数/变量	简化代码，解决同名模块冲突	需遵守行业别名惯例（如 np 对应 numpy）	模块名较长或需区分同名模块（如 import datetime as dt）
3. 导入模块指定内容	from 模块名 import 类/函数/变量	直接使用 类/函数/变量	调用简洁，无需模块前缀	可能与本地变量重名	仅需使用模块内少数工具（如 from datetime import date）
4. 导入模块全部内容	from 模块名 import *	直接使用所有 类/函数/变量	代码最简洁，无需任何前缀	极易引发命名冲突，难以定位代码来源	小型脚本或临时测试，不推荐大型项目

2. Python 常用内置函数

（1） 数学操作函数

函数名	功能描述	示例代码	输出结果
abs(x)	返回 x 的绝对值（x 可为整数、浮点数、复数，复数返回模）	abs(-5)、abs(3.14-5)	5、1.86
round(x, n)	对 x 四舍五入，n 为保留小数位数（默认 n=0）	round(3.1415, 2)、round(2.5)	3.14、2
sum(iter)	对可迭代对象（如列表、元组）求和，可选 start 参数指定累加起点（默认 0）	sum([1,2,3])、sum([1,2,3], start=10)	6、16
max(iter)	返回可迭代对象中的最大值，或多个参数中的最大值	max([3,1,4])、max(5,2,7)	4、7
min(iter)	返回可迭代对象中的最小值，或多个参数中的最小值	min([3,1,4])、min(5,2,7)	1、2
pow(x, y)	计算 x 的 y 次幂（等价于 x ** y）	pow(2, 3)、pow(4, 0.5)	8、2.0
divmod(x, y)	同时返回 x 除以 y 的商和余数（元组形式：(商，余数)）	divmod(7, 3)、divmod(10, 4)	(2,1)、(2,2)
eval(expr)	执行字符串形式的表达式，返回结果（需注意安全风险，避免执行未知字符串）	eval("3 * 10 + 5")、eval("pow(2,3)")	35、8
bin(x)	将整数 x 转换为带前缀 “0b” 的二进制字符串	bin(5)、bin(-3)	‘0b101’、‘-0b11’
oct(x)	将整数 x 转换为带前缀 “0o” 的八进制字符串	oct(8)、oct(10)	‘0o10’、‘0o12’
hex(x)	将整数 x 转换为带前缀 “0x” 的十六进制字符串	hex(16)、hex(255)	‘0x10’、‘0xff’
complex(a,b)	构建复数 a + bj（a 为实部，b 为虚部，默认 b=0）	complex(1, 2)、complex(3)	(1+2j)、(3+0j)

（2） 序列和集合操作函数

函数名	功能描述	示例代码	输出结果（需转换为列表查看）
len(iter)	返回序列（如列表、字符串、元组）或集合的长度	len([1,2,3])、len("hello")	3、5
sorted(iter, key=None, reverse=False)	对可迭代对象排序，key 指定排序依据，reverse=True 降序排列（返回新列表，不修改原对象）	sorted([3,1,4], reverse=True)、sorted(["apple","banana"], key=len)	[4,3,1]、[“apple”,“banana”]
reversed(iter)	翻转序列，返回迭代器（原序列不变）	reversed([1,2,3])、reversed("abc")	[3,2,1]、[‘c’,‘b’,‘a’]
zip(*iters)	将多个可迭代对象打包为元组迭代器，长度与最短的可迭代对象一致	zip([1,2], ["a","b","c"])	[(1,‘a’), (2,‘b’)]
enumerate(iter, start=0)	为序列添加索引，返回 (索引，元素) 元组迭代器，start 指定起始索引（默认 0）	enumerate(["a","b"], start=1)	[(1,‘a’), (2,‘b’)]
range(start, stop, step)	生成整数序列，start 起始值（默认 0），stop 终止值（不包含），step 步长（默认 1）	range(5)、range(2, 10, 2)	[0,1,2,3,4]、[2,4,6,8]

（3） 类型转换和判断函数

函数名	功能描述	示例代码	输出结果及类型
int(x)	将 x 转换为整数（x 可为字符串、浮点数，浮点数转换会截断小数部分）	int("123")、int(3.9)	123（int）、3（int）
float(x)	将 x 转换为浮点数	float("3.14")、float(5)	3.14（float）、5.0（float）
str(x)	将 x 转换为字符串	str(123)、str([1,2])	“123”、“[1,2]”
list(iter)	将可迭代对象（如元组、字符串、集合）转换为列表	list((1,2,3))、list("abc")	[1,2,3]、[‘a’,‘b’,‘c’]
tuple(iter)	将可迭代对象转换为元组	tuple([1,2,3])、tuple("abc")	(1,2,3)、(‘a’,‘b’,‘c’)
set(iter)	将可迭代对象转换为集合（自动去重）	set([1,2,2,3])、set("aab")	{1,2,3}、{‘a’,‘b’}
dict(iter)	将键值对可迭代对象（如 [(k1,v1), (k2,v2)]）转换为字典	dict([("a",1), ("b",2)])	{‘a’:1, ‘b’:2}
bool(x)	将 x 转换为布尔值（0、空序列、None 等为 False，其余为 True）	bool(0)、bool([1])、bool(None)	False、True、False
type(x)	返回 x 的类型	type(123)、type("abc")	<class ‘int’>、<class ‘str’>
id(x)	返回 x 的唯一标识符（内存地址，整数）	a=5; id(a)、id(5)	140708485569328（示例值）
chr(x)	将整数 x（ASCII 码）转换为对应字符	chr(65)、chr(97)	‘A’、‘a’
ord(c)	将字符 c 转换为对应 ASCII 码（整数）	ord('A')、ord('a')	65、97

（4） 其他常用函数

函数名	功能描述	示例代码	输出结果
input(prompt)	获取用户输入，prompt 为输入提示语，返回字符串类型	input("请输入数字：")（用户输入 123）	“123”
print(*args, sep=' ', end='\n')	输出内容，sep 分隔多个参数（默认空格），end 结束符（默认换行）	print("a", "b", sep="-", end="!")	“a-b!”
help(obj)	查看对象（函数、类、模块）的详细帮助文档	help(print)、help(datetime.date)	打印帮助信息
all(iter)	判断可迭代对象中所有元素是否为 True（空可迭代对象返回 True）	all([1, True, "a"])、all([1, False])	True、False
any(iter)	判断可迭代对象中至少一个元素是否为 True（空可迭代对象返回 False）	any([0, False, "a"])、any([0, False])	True、False
map(func, *iters)	对可迭代对象的每个元素应用 func 函数，返回迭代器	list(map(int, ["1","2","3"]))	[1,2,3]
dir(obj)	获取对象的属性和方法列表（无参数时返回当前作用域的属性列表）	dir(str)（查看字符串的方法）	打印字符串方法列表
hasattr(obj, attr)	判断对象是否包含指定属性（attr 为字符串）	hasattr("abc", "upper")	True
getattr(obj, attr)	获取对象的指定属性值，不存在时可指定默认值（避免报错）	getattr("abc", "upper")()、getattr("abc", "len", 0)	“ABC”、3