本文我们从零基础开始，系统学习 Python 的所有核心语法与知识点，通过通俗易懂的讲解和示例代码，快速掌握 Python 编程。一、基础语法入门
1. 变量与赋值
- 变量命名规则：只能包含字母、数字、下划线，不能以数字开头；区分大小写；避免使用 Python 关键字（如 if、for等）。
- 赋值方式：使用
= 进行变量赋值，且声明变量时无需使用任何关键字（这一点与 JavaScript 需要 let/const 显式声明不同）。此外，Python 还支持多变量同时赋值，写法更简洁高效。
# 单个变量赋值name = "Python"age = 30# 多变量同时赋值a, b, c = 1, 2, 3
2. 注释
- 单行注释 ：以
# 开头，用于解释单行代码。 - 多行注释 ：用三对单引号
''' 或三对双引号 """ 包裹，用于解释多行代码或文档说明。
# 这是单行注释'''这是多行注释可以写多行内容'''"""这也是多行注释同样支持多行"""
3. 输入与输出
- 输出：使用 print()函数，可输出字符串、变量等。
- 输入：使用 input()函数，接收用户输入，返回字符串类型。
# 输出print("Hello, Python!")print("年龄：", age)# 输入user_name = input("请输入你的名字：")print("你好，", user_name)
二、数据类型
1. 数字类型
- 整数（int）：如 10、-5。
- 浮点数（float）：如 3.14、-2.5。
- 复数（complex）：如 1 + 2j（j表示虚数单位。数学定义：在数学里，将平方是负数的数定义为纯虚数，虚数单位规定为i，它的定义是i2=−1，在 Python 中使用
j来表示虚数单位）
num1 = 10 # intnum2 = 3.14 # floatnum3 = 1 + 2j # complex
2. 字符串（str）
- 定义：用单引号 '或双引号 "包裹。
- 索引与切片：通过索引访问单个字符（从 0 开始），切片获取子字符串。
- 常用方法：strip()（去除首尾空格）、split()（分割字符串）、join()（拼接字符串）等。
s = "Hello, Python"# 索引print(s[0]) # 输出 'H'# 切片print(s[7:13]) # 输出 'Python'# 常用方法print(s.strip()) # 去除首尾空格print(s.split(",")) # 按逗号分割，输出 ['Hello', ' Python']print("-".join(["a", "b", "c"])) # 拼接，输出 'a-b-c'
3. 列表（list）
- 定义：用方括号 []包裹，元素可修改、可重复、有序。
- 常用操作：增（append()、insert()）、删（remove()、pop()）、改、查、排序（sort()）等。
lst = [1, 2, 3, "Python"]# 增lst.append(4) # 末尾添加lst.insert(1, "a") # 指定位置插入# 删lst.remove(3) # 删除指定元素lst.pop() # 删除末尾元素# 改lst[0] = 10# 查print(lst[1]) # 输出 'a'# 排序lst_num = [3, 1, 4, 2]lst_num.sort() # 升序排序print(lst_num) # 输出 [1, 2, 3, 4]
4. 元组（tuple）
- 定义：用圆括号 ()包裹，元素不可修改、可重复、有序。
- 特点：访问速度比列表快，占用内存小。
tup = (1, 2, 3, "Python")# 访问元素print(tup[2]) # 输出 3# 元组解包a, b, c, d = tupprint(a) # 输出 1
5. 字典（dict）
- 定义：用花括号 {}包裹，以键值对（key: value）形式存储，键唯一且不可变，值可修改。
- 常用操作：增、删、改、查键值对。
dic = {"name": "Python", "age": 30}# 增dic["version"] = 3.10# 删del dic["age"]# 改dic["name"] = "Python 3"# 查print(dic["name"]) # 输出 'Python 3'print(dic.get("age", "未知")) # 安全获取，不存在返回默认值
6. 集合（set）
- 定义：用花括号 {}包裹，元素唯一、无序、不可变。
- 常用操作：交集（&）、并集（|）、差集（-）等。
s1 = {1, 2, 3}s2 = {3, 4, 5}# 交集print(s1 & s2) # 输出 {3}# 并集print(s1 | s2) # 输出 {1, 2, 3, 4, 5}# 差集print(s1 - s2) # 输出 {1, 2}
三、控制流
1. 条件语句（if-elif-else）
根据条件判断执行不同代码块。
score = 85if score >= 90: print("优秀")elif score >= 80: print("良好")elif score >= 60: print("及格")else: print("不及格")
2. 循环语句
（1）for 循环
用于遍历可迭代对象（如列表、字符串等）。
# 遍历列表for i in [1, 2, 3]: print(i)# 遍历字符串for char in "Python": print(char)# range() 函数：生成数字序列for i in range(1, 5): # 从 1 到 4（不包含 5） print(i)
（2）while 循环
只要条件为真，就重复执行代码块。
count = 0while count < 5: print(count) count += 1
3. 循环控制语句
- break：跳出当前循环。
- continue：跳过当前循环的剩余代码，进入下一次循环。
- pass：空语句，占位用，不执行任何操作。
# break 示例for i in range(10): if i == 5: break print(i) # 输出 0-4# continue 示例for i in range(10): if i == 5: continue print(i) # 输出 0-4, 6-9
四、函数
1. 函数定义与调用
使用 def 关键字定义函数，通过函数名调用。
def greet(name): """这是一个问候函数""" # 文档字符串 print("Hello,", name)# 调用函数greet("Python")
2. 参数类型
- 位置参数：按顺序传递参数。
- 默认参数：定义函数时给参数默认值，调用时可省略。
- 可变参数：*args接收任意数量位置参数，以元组形式存储。
- 关键字参数：**kwargs接收任意数量关键字参数，以字典形式存储。
def func(a, b=10, *args, **kwargs): print("a:", a) print("b:", b) print("args:", args) print("kwargs:", kwargs)func(5, 20, 30, 40, name="Python", age=30)# 输出：# a: 5# b: 20# args: (30, 40)# kwargs: {'name': 'Python', 'age': 30}
3. 返回值
使用 return 语句返回值，可返回多个值（以元组形式）。
def add(a, b): return a + bresult = add(3, 5)print(result) # 输出 8
4. 作用域
- 局部变量：在函数内部定义，仅函数内部可访问。
- 全局变量：在函数外部定义，函数内部可访问（如需修改，需用
x = 10 # 全局变量def func(): global x # 声明使用全局变量 x = 20 y = 5 # 局部变量 print("内部 x:", x)func()print("外部 x:", x) # 输出 20
5. 匿名函数（lambda）
用于定义简单的、一次性使用的函数。
add = lambda a, b: a + bprint(add(3, 5)) # 输出 8
6. 高阶函数
接受函数作为参数或返回函数的函数，如map()、filter()、reduce()。
# map()：对可迭代对象每个元素应用函数lst = [1, 2, 3]result = map(lambda x: x * 2, lst)print(list(result)) # 输出 [2, 4, 6]# filter()：过滤可迭代对象，保留符合条件的元素result = filter(lambda x: x > 1, lst)print(list(result)) # 输出 [2, 3]# reduce()：对可迭代对象元素累积计算（需从 functools 导入）from functools import reduceresult = reduce(lambda a, b: a + b, lst)print(result) # 输出 6
五、模块与包
1. 模块导入
- import 模块名：导入整个模块。
- from 模块名 import 函数 / 类：导入模块中的特定部分。
- **from 模块名 import ***：导入模块所有内容（不推荐）。
# 导入 math 模块import mathprint(math.sqrt(16)) # 输出 4.0# 从 math 模块导入 sqrt 函数from math import sqrtprint(sqrt(16)) # 输出 4.0
2. 自定义模块
创建一个 .py 文件，即可作为模块导入。
# my_module.pydef greet(name): print("Hello,", name)# 导入自定义模块import my_modulemy_module.greet("Python")
3. 包
包是包含多个模块的文件夹，需包含 __init__.py 文件（可空）。
my_package/ __init__.py module1.py module2.py
导入包中的模块：
from my_package import module1module1.func()
六、面向对象编程（OOP）
1. 类与对象
- 类：用
class 关键字定义，是对象的模板。 - 对象：类的实例，通过类名加括号创建。
class Person: # 初始化方法（构造函数） def __init__(self, name, age): self.name = name # 实例属性 self.age = age # 实例方法 def greet(self): print("Hello, my name is", self.name)# 创建对象p = Person("Python", 30)p.greet() # 输出 'Hello, my name is Python'
2. 继承
子类继承父类的属性和方法，可重写或扩展。
class Student(Person): def __init__(self, name, age, grade): # 调用父类初始化方法 super().__init__(name, age) self.grade = grade # 重写方法 def greet(self): print("Hello, I'm a student, my name is", self.name)s = Student("Xiao Ming", 18, 3)s.greet() # 输出 'Hello, I'm a student, my name is Xiao Ming'
3. 封装
通过私有属性（以 __ 开头）限制外部访问，提供公共方法操作。
class Person: def __init__(self, name): self.__name = name # 私有属性 # 获取私有属性 def get_name(self): return self.__name # 设置私有属性 def set_name(self, name): self.__name = namep = Person("Python")print(p.get_name()) # 输出 'Python'p.set_name("Python 3")print(p.get_name()) # 输出 'Python 3'
4. 多态
不同对象对同一方法的响应不同，通过继承和方法重写实现。
class Animal: def speak(self): passclass Dog(Animal): def speak(self): print("Woof!")class Cat(Animal): def speak(self): print("Meow!")def make_speak(animal): animal.speak()dog = Dog()cat = Cat()make_speak(dog) # 输出 'Woof!'make_speak(cat) # 输出 'Meow!'
5. 类方法与静态方法
- 类方法：用 @classmethod装饰，第一个参数为 cls（类本身）。
- 静态方法：用
@staticmethod 装饰，无需 self 或 cls 参数。
class MyClass: count = 0 # 类属性 def __init__(self): MyClass.count += 1 @classmethod def get_count(cls): return cls.count @staticmethod def static_func(): print("这是静态方法")obj1 = MyClass()obj2 = MyClass()print(MyClass.get_count()) # 输出 2MyClass.static_func() # 输出 '这是静态方法'
七、异常处理
1. try-except-else-finally
捕获并处理异常，避免程序崩溃。
try: num = int(input("请输入一个数字：")) result = 10 / numexcept ValueError: print("输入的不是数字！")except ZeroDivisionError: print("不能除以零！")else: print("结果：", result) # 无异常时执行finally: print("程序结束") # 无论是否异常都执行
2. 抛出异常
使用 raise 主动抛出异常。
def check_age(age): if age < 0: raise ValueError("年龄不能为负数") print("年龄：", age)check_age(-5) # 抛出 ValueError
八、文件操作
1. 打开与关闭文件
使用 open() 函数打开文件，close() 关闭文件，推荐用 with 语句自动关闭。
# 打开文件（模式：r-读，w-写，a-追加，r+-读写）with open("test.txt", "w", encoding="utf-8") as f: f.write("Hello, Python!\n") f.write("这是第二行")# 读取文件with open("test.txt", "r", encoding="utf-8") as f: # 读取全部内容 content = f.read() print(content) # 按行读取 # for line in f: # print(line.strip())
2. 常用文件操作
read(size)：读取指定字节数。readline()：读取一行。readlines()：读取所有行，返回列表。write(str)：写入字符串。writelines(list)：写入字符串列表。
九、进阶特性
1. 推导式
快速创建列表、字典、集合。
# 列表推导式lst = [x * 2 for x in range(5) if x > 1]print(lst) # 输出 [4, 6, 8]# 字典推导式dic = {x: x * 2 for x in range(3)}print(dic) # 输出 {0: 0, 1: 2, 2: 4}# 集合推导式s = {x % 3 for x in range(5)}print(s) # 输出 {0, 1, 2}
2. 生成器
节省内存，按需生成数据，用 () 或 yield 定义。
# 生成器表达式gen = (x * 2 for x in range(5))for i in gen: print(i) # 输出 0, 2, 4, 6, 8# 生成器函数def my_gen(n): for i in range(n): yield i * 2gen = my_gen(5)for i in gen: print(i) # 输出 0, 2, 4, 6, 8
3. 迭代器
实现 __iter__ 和 __next__ 方法的对象，可被 for 循环遍历。
class MyIterator: def __init__(self, n): self.n = n self.current = 0 def __iter__(self): return self def __next__(self): if self.current < self.n: result = self.current * 2 self.current += 1 return result else: raise StopIterationit = MyIterator(5)for i in it: print(i) # 输出 0, 2, 4, 6, 8
4. 装饰器
在不修改原函数代码的情况下，扩展函数功能，用 @装饰器名 应用。
def my_decorator(func): def wrapper(): print("函数执行前") func() print("函数执行后") return wrapper@my_decoratordef say_hello(): print("Hello!")say_hello()# 输出：# 函数执行前# Hello!# 函数执行后
5. 上下文管理器
用 with 语句管理资源，实现 __enter__ 和 __exit__ 方法。
class MyContext: def __enter__(self): print("进入上下文") return "资源" def __exit__(self, exc_type, exc_val, exc_tb): print("退出上下文")with MyContext() as res: print("使用", res)# 输出：# 进入上下文# 使用 资源# 退出上下文
结语
以上这些内容，都是 Python 基础语法的核心知识点，帮大家快速掌握 Python 编程的 “基本功”。后续无论是做爬虫爬取数据、开发自动化脚本处理重复工作，还是学习大模型训练时理解数据运算逻辑，都能更顺畅地上手，一步步从入门走向实践。
