说码解字
0%

Python 语法速览

发表于 更新于 分类于 ， Valine：

基本语法

1. Python 基本结构

Python 是一种解释型语言，代码按行执行，无需编译。

简单示例

1
print("Hello, World!")  # 输出 "Hello, World!"
  • 注释：使用 # 表示单行注释，多行注释使用三引号 ''' 或 """。

2. 变量与数据类型

变量

Python 是动态类型语言，不需要声明变量类型。

1
2
3
4
x = 10         # 整型
y = 3.14       # 浮点型
name = "Alice" # 字符串
is_valid = True # 布尔值

常用数据类型

  • 数字类型：int（整数），float（浮点数），complex（复数）
  • 布尔值：True，False
  • 字符串：str
  • 容器类型：list（列表），tuple（元组），dict（字典），set（集合）

3. 输入输出

输入

1
2
name = input("请输入你的名字: ")
print(f"你好, {name}")

输出

1
2
3
age = 25
print("年龄:", age)                # 输出 "年龄: 25"
print(f"年龄: {age}")              # 使用 f-string 输出 "年龄: 25"

4. 条件语句

if-elif-else

1
2
3
4
5
6
7
x = 10
if x > 0:
    print("x 是正数")
elif x == 0:
    print("x 是零")
else:
    print("x 是负数")

5. 循环语句

for 循环

1
2
for i in range(1, 6):  # 生成 1 到 5 的数字
    print(i)

while 循环

1
2
3
4
x = 5
while x > 0:
    print(x)
    x -= 1

循环控制

  • break：终止循环
  • continue：跳过当前迭代
1
2
3
4
5
6
for i in range(5):
    if i == 2:
        continue
    if i == 4:
        break
    print(i)

6. 函数

定义函数

1
2
3
4
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))  # 输出 "Hello, Alice"

默认参数

1
2
3
4
def add(a, b=10):
    return a + b

print(add(5))  # 输出 15

可变参数

1
2
3
4
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4))  # 输出 10

7. 数据结构

列表（List）

1
2
3
4
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")   # 添加元素
fruits.remove("banana")   # 删除元素
print(fruits[0])          # 访问元素

元组（Tuple）

元组是不可变的序列。

1
2
coordinates = (10, 20)
print(coordinates[0])  # 输出 10

字典（Dictionary）

字典存储键值对。

1
2
3
person = {"name": "Alice", "age": 25}
print(person["name"])  # 输出 "Alice"
person["age"] = 26     # 修改值

集合（Set）

集合存储唯一值。

1
2
3
numbers = {1, 2, 3, 4}
numbers.add(5)
print(numbers)  # 输出 {1, 2, 3, 4, 5}

8. 列表推导式

1
2
squares = [x**2 for x in range(5)]
print(squares)  # 输出 [0, 1, 4, 9, 16]

9. 异常处理

1
2
3
4
5
6
try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零")
finally:
    print("执行完成")

10. 文件操作

写入文件

1
2
with open("example.txt", "w") as file:
    file.write("Hello, World!")

读取文件

1
2
3
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

11. 类与对象

定义类

1
2
3
4
5
6
7
8
9
10
11
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name}")

# 创建对象
p = Person("Alice", 25)
p.greet()  # 输出 "Hello, my name is Alice"

12. 模块与库

导入模块

1
2
import math
print(math.sqrt(16))  # 输出 4.0

自定义模块

创建一个文件 mymodule.py：

1
2
def add(a, b):
    return a + b

在另一个文件中使用：

1
2
from mymodule import add
print(add(3, 5))  # 输出 8

13. 常用内置函数

  • **len()**：获取长度
  • **type()**：获取数据类型
  • **range()**：生成数值序列
  • **sum()**：计算总和
  • **zip()**：合并多个列表

14. 重要概念

列表与字典推导式

1
2
squares = [x**2 for x in range(5)]  # 列表推导式
double_dict = {x: x*2 for x in range(5)}  # 字典推导式

枚举与迭代

1
2
3
names = ["Alice", "Bob"]
for index, name in enumerate(names):
    print(index, name)

Lambda 表达式

1
2
add = lambda a, b: a + b
print(add(3, 5))  # 输出 8

15. 注解与类型提示

1
2
def greet(name: str) -> str:
    return f"Hello, {name}"

高级特性

1. 生成器与迭代器

生成器

生成器是使用 yield 的函数，用于生成一个可迭代对象。

1
2
3
4
5
6
7
def my_generator():
    for i in range(5):
        yield i

gen = my_generator()
print(next(gen))  # 输出 0
print(next(gen))  # 输出 1

生成器常用于节省内存，适合处理大量数据的场景。

迭代器

迭代器是实现了 __iter__() 和 __next__() 方法的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.count = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.count < self.limit:
            self.count += 1
            return self.count
        else:
            raise StopIteration

it = MyIterator(3)
for num in it:
    print(num)  # 输出 1, 2, 3

2. 装饰器

装饰器是一个函数，用于增强其他函数的功能。

函数装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出:
# Before function call
# Hello!
# After function call

类装饰器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before function call")
        result = self.func(*args, **kwargs)
        print("After function call")
        return result

@MyDecorator
def greet(name):
    print(f"Hello, {name}")

greet("Alice")

3. 上下文管理器

上下文管理器通过实现 __enter__ 和 __exit__ 方法，用于管理资源。

1
2
3
4
5
6
7
8
9
10
class MyContext:
    def __enter__(self):
        print("Entering context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting context")

with MyContext() as ctx:
    print("Inside context")

常见上下文管理器示例：

1
2
with open("file.txt", "w") as file:
    file.write("Hello, World!")

4. 元类

元类控制类的创建，是用来“创建类的类”。

定义元类

1
2
3
4
5
6
7
class MyMeta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

5. 多线程与多进程

多线程

多线程使用 threading 模块实现。

1
2
3
4
5
6
7
8
9
import threading

def print_numbers():
    for i in range(5):
        print(i)

thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

多进程

多进程使用 multiprocessing 模块实现。

1
2
3
4
5
6
7
8
9
from multiprocessing import Process

def print_numbers():
    for i in range(5):
        print(i)

process = Process(target=print_numbers)
process.start()
process.join()

6. 协程

协程是基于生成器的一种更轻量级的并发方式。

async 和 await

1
2
3
4
5
6
7
8
import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(say_hello())

并发执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import asyncio

async def task(name, delay):
    print(f"{name} started")
    await asyncio.sleep(delay)
    print(f"{name} finished")

async def main():
    await asyncio.gather(
        task("Task1", 2),
        task("Task2", 1),
    )

asyncio.run(main())

7. 数据类（Dataclass）

数据类是简化类定义的一种方式，适用于存储数据的类。

1
2
3
4
5
6
7
8
9
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

person = Person(name="Alice", age=25)
print(person)  # 输出 Person(name='Alice', age=25)

8. 类型提示

类型提示提供了静态类型检查的能力。

1
2
3
4
5
6
7
8
def add(a: int, b: int) -> int:
    return a + b

from typing import List

def greet_all(names: List[str]) -> None:
    for name in names:
        print(f"Hello, {name}")

9. 正则表达式

使用 re 模块进行模式匹配。

1
2
3
4
5
6
import re

pattern = r"\d+"
text = "There are 42 apples and 33 bananas."
matches = re.findall(pattern, text)
print(matches)  # 输出 ['42', '33']

10. 枚举

枚举用于定义一组常量。

1
2
3
4
5
6
7
8
9
10
from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

print(Color.RED)       # 输出 Color.RED
print(Color.RED.name)  # 输出 RED
print(Color.RED.value) # 输出 1

11. 函数式编程

map、filter 和 reduce

1
2
3
4
5
6
from functools import reduce

nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))       # [1, 4, 9, 16]
even = list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]
summed = reduce(lambda x, y: x + y, nums)       # 10

列表推导式

1
squares = [x**2 for x in range(10) if x % 2 == 0]

12. 序列化

使用 json 和 pickle 模块处理数据序列化。

JSON

1
2
3
4
5
6
7
import json

data = {"name": "Alice", "age": 25}
json_str = json.dumps(data)
print(json_str)  # 输出 '{"name": "Alice", "age": 25}'

parsed_data = json.loads(json_str)

Pickle

1
2
3
4
5
6
7
8
import pickle

data = {"name": "Alice", "age": 25}
with open("data.pkl", "wb") as file:
    pickle.dump(data, file)

with open("data.pkl", "rb") as file:
    loaded_data = pickle.load(file)

13. 内存优化

生成器代替列表

1
gen = (x**2 for x in range(1000000))  # 节省内存

__slots__

使用 __slots__ 限制类的属性，减少内存开销。

1
2
3
4
5
class MyClass:
    __slots__ = ["name", "age"]

obj = MyClass()
obj.name = "Alice"

14. 集合操作

1
2
3
4
5
6
a = {1, 2, 3}
b = {3, 4, 5}

print(a & b)  # 交集 {3}
print(a | b)  # 并集 {1, 2, 3, 4, 5}
print(a - b)  # 差集 {1, 2}

15. 上下文管理与性能优化

上下文管理器

1
2
3
4
5
6
7
8
9
10
from contextlib import contextmanager

@contextmanager
def my_context():
    print("Entering context")
    yield
    print("Exiting context")

with my_context():
    print("Inside context")

时间分析

1
2
3
4
5
6
import time

start = time.time()
# 代码块
end = time.time()
print(f"Elapsed time: {end - start} seconds")