Python零基础必学之内置函数、函数注释、异步函数详解

# 整数和浮点数
print(abs(-10))      # 10
print(abs(-3.14))    # 3.14

# 所有元素为真
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

# 存在真值
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

print(callable(100))
f = lambda :print(666)
print(callable(f))
f()

# 查看字符串的方法
print(dir("hello"))
# ['__add__', '__class__', '__contains__', ... 'upper', 'zfill']

# 基本用法
print(divmod(10, 3))    # (3, 1)  10 // 3 = 3, 10 % 3 = 1
print(divmod(17, 5))    # (3, 2)

# 基本幂运算
print(pow(2, 3))     # 8  相当于 2 ** 3
print(pow(5, 2))     # 25

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

import asyncio

# 定义异步函数
async def say_hello():
    print("Hello")
    await asyncio.sleep(1)   # 模拟耗时操作
    print("World")

# 运行异步函数（需要事件循环）
# Python 3.7+
asyncio.run(say_hello())
# 输出：
# Hello
# (等待1秒)
# World

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

# 定义类
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)       # 人类

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())   # 李四，清华大学，成绩：92

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