我要评论大家好,今天的内容涵盖四个相对独立但同样重要的知识点：常用内置函数的使用、函数注释的规范写法、异步函数的基础概念，以及面向对象编程的入门知识。这四个知识点在实际开发中各有其用武之地，掌握它们能让你对 python 的理解更加全面。
一、常用内置函数
python 提供了大量内置函数，这里选取几个实用但容易被忽视的函数进行讲解。
1.1 abs()：绝对值
abs() 返回数字的绝对值，支持整数、浮点数和复数。
# 整数和浮点数 print(abs(-10)) # 10 print(abs(-3.14)) # 3.14
1.2 all()：全部为真
all() 接收一个可迭代对象，当所有元素都为 true 时返回 true，否则返回 false。
# 所有元素为真 print(all([true, true, true])) # true print(all([1, 2, 3])) # true # 存在假值 print(all([true, false, true])) # false print(all([1, 0, 3])) # false # 空可迭代对象返回 true print(all([])) # true
1.3 any()：存在为真
any() 接收一个可迭代对象，当任意一个元素为 true 时返回 true，否则返回 false。
# 存在真值 print(any([false, false, true])) # true print(any([0, 0, 1])) # true # 所有元素为假 print(any([false, false, false])) # false print(any([0, 0, 0])) # false # 空可迭代对象返回 false print(any([])) # false
1.4 callable()：判断是否可调用
callable() 判断一个对象是否可以被调用（即是否可以像函数一样使用 () 调用）。
只有函数和类可以被调用
print(callable(100)) f = lambda :print(666) print(callable(f)) f()
1.5 dir()：查看对象的属性和方法
dir() 返回对象的所有属性和方法列表，是调试时非常有用的工具。
# 查看字符串的方法
print(dir("hello"))
# ['__add__', '__class__', '__contains__', ... 'upper', 'zfill']1.6 divmod()：返回商和余数
divmod(a, b) 返回一个元组 (a // b, a % b)，即商和余数。
# 基本用法 print(divmod(10, 3)) # (3, 1) 10 // 3 = 3, 10 % 3 = 1 print(divmod(17, 5)) # (3, 2)
1.7 pow()：幂运算
pow(base, exp, mod) 返回 base 的 exp 次方，如果指定了 mod，则返回 (base ** exp) % mod。
# 基本幂运算 print(pow(2, 3)) # 8 相当于 2 ** 3 print(pow(5, 2)) # 25
二、函数注释
函数注释（type hints）是 python 3.5+ 引入的特性，用于为函数参数和返回值添加类型信息，提高代码的可读性和可维护性。
基本语法:
def 函数名(参数名: 类型, 参数名: 类型 = 默认值) -> 返回值类型:
"""函数文档字符串"""
pass
# 基本类型注释
def greet(name: str) -> str:
return f"hello, {name}"
def add(a: int, b: int) -> int:
return a + b
# 调用
print(greet("张三")) # hello, 张三
print(add(3, 5)) # 8三、异步函数 async / await
异步编程是用于编写并发代码，特别适合 i/o 密集型任务（网络请求、数据库操作、文件读写等）。
3.1 基本概念
| 概念 | 说明 |
|---|---|
async def | 定义异步函数（协程） |
await | 等待一个异步操作完成 |
asyncio | python 内置的异步 i/o 库 |
| 事件循环 | 调度和管理多个协程的核心机制 |
3.2 基本用法
import asyncio
# 定义异步函数
async def say_hello():
print("hello")
await asyncio.sleep(1) # 模拟耗时操作
print("world")
# 运行异步函数（需要事件循环）
# python 3.7+
asyncio.run(say_hello())
# 输出：
# hello
# (等待1秒)
# world3.3 多个异步任务并发执行
import asyncio
import time
async def task(name: str, delay: int):
print(f"任务 {name} 开始")
await asyncio.sleep(delay)
print(f"任务 {name} 完成 (耗时 {delay}秒)")
return f"{name} 的结果"
async def main():
# 创建多个任务并发执行
tasks = [
task("a", 3),
task("b", 2),
task("c", 1)
]
start = time.time()
results = await asyncio.gather(*tasks) # 并发执行所有任务
print(f"所有结果: {results}")
print(f"总耗时: {time.time() - start:.2f}秒")
asyncio.run(main())
# 输出：
# 任务 a 开始
# 任务 b 开始
# 任务 c 开始
# 任务 c 完成 (耗时 1秒)
# 任务 b 完成 (耗时 2秒)
# 任务 a 完成 (耗时 3秒)
# 所有结果: ['a 的结果', 'b 的结果', 'c 的结果']
# 总耗时: 3.00秒（而不是 3+2+1 = 6秒）四、面向对象与初始化对象
面向对象编程（oop）是 python 的核心编程范式之一，通过类和对象来组织代码。
4.1 类与对象的基本概念
| 概念 | 说明 | 示例 |
|---|---|---|
| 类 | 对象的模板或蓝图 | class person: |
| 对象 | 类的具体实例 | p = person() |
| 属性 | 对象的特征或数据 | p.name = "张三" |
| 方法 | 对象的行为或功能 | p.greet() |
4.2 定义类和创建对象
# 定义类
class person:
"""人类"""
species = "人类" # 类属性（所有实例共享）
# 初始化方法（构造方法）
def __init__(self, name: str, age: int):
self.name = name # 实例属性
self.age = age
# 实例方法
def greet(self) -> str:
return f"你好，我是 {self.name}，今年 {self.age} 岁"
def birthday(self):
self.age += 1
print(f"{self.name} 过生日了，现在 {self.age} 岁")
# 创建对象（实例化）
p1 = person("张三", 25)
p2 = person("李四", 30)
# 访问属性和方法
print(p1.name) # 张三
print(p1.greet()) # 你好，我是 张三，今年 25 岁
p1.birthday() # 张三 过生日了，现在 26 岁
print(p2.name) # 李四
print(p2.greet()) # 你好，我是 李四，今年 30 岁
# 访问类属性
print(person.species) # 人类
print(p1.species) # 人类4.3__init__方法详解
__init__ 是类的构造方法，在创建对象时自动调用，用于初始化对象的属性。
class student:
def __init__(self, name: str, score: int, school: str = "北京大学"):
self.name = name
self.score = score
self.school = school
def info(self) -> str:
return f"{self.name}，{self.school}，成绩：{self.score}"
# 创建对象时传入参数
s1 = student("张三", 85)
s2 = student("李四", 92, "清华大学")
print(s1.info()) # 张三，北京大学，成绩：85
print(s2.info()) # 李四，清华大学，成绩：924.4self参数的含义
self 代表当前实例对象，在实例方法中通过 self 访问实例的属性和其他方法。
class car:
def __init__(self, brand: str, speed: int = 0):
self.brand = brand
self.speed = speed
def accelerate(self, amount: int):
self.speed += amount
print(f"{self.brand} 加速到 {self.speed} km/h")
def brake(self, amount: int):
self.speed = max(0, self.speed - amount)
print(f"{self.brand} 减速到 {self.speed} km/h")
# 每个实例都有自己的状态
car1 = car("宝马", 0)
car2 = car("奔驰", 0)
car1.accelerate(50) # 宝马 加速到 50 km/h
car2.accelerate(80) # 奔驰 加速到 80 km/h
car1.brake(20) # 宝马 减速到 30 km/h
print(car1.speed) # 30
print(car2.speed) # 80五、总结
| 知识点 | 核心要点 |
|---|---|
| abs() | 返回数字的绝对值 |
| all() | 所有元素为真时返回 true |
| any() | 任意元素为真时返回 true |
| callable() | 判断对象是否可调用 |
| dir() | 列出对象的属性和方法 |
| divmod() | 返回 (商, 余数) 元组 |
| pow() | 幂运算，支持取模 |
| 函数注释 | 参数: 类型 和 -> 返回类型，提高可读性，辅助 ide 提示 |
| async/await | 异步编程，适用于 i/o 密集型任务 |
| asyncio.run() | 运行异步函数的入口 |
| asyncio.gather() | 并发执行多个协程 |
| 类 | 对象的模板，用 class 定义 |
| 对象 | 类的实例，通过 类名() 创建 |
__init__ | 构造方法，初始化实例属性 |
| self | 代表当前实例 |
| 类属性 | 所有实例共享的属性 |
| 实例属性 | 每个实例独有的属性 |
内置函数是 python 提供的基础工具箱，熟练掌握能提高编码效率；函数注释让代码更清晰；异步函数是处理高并发 i/o 的有力工具；面向对象是组织大型项目的核心方式。这四个知识点覆盖了从工具使用到架构设计的多个层面，建议结合实际项目多练习。
以上就是python零基础必学之内置函数、函数注释、异步函数详解的详细内容，更多关于python内置函数的资料请关注代码网其它相关文章！
发表评论