2025年了，居然还有人 Python 都没入门

重磅消息，开放了每日陪伴圈，欢迎扫码加入。

很多初学者在开始学习编程时，往往会陷入一个误区：花太多时间在"完整地学习每一个知识点"上。这种学习方式不仅效率低下，而且容易让人失去兴趣。

Python 的美妙之处在于它的简单直观，你不需要花费数月时间去啃教材或教程，只需要跟着这篇教程敲一遍代码，就能掌握基础知识。

记住，编程最重要的不是"知道"，而是"做到"。

"纸上得来终觉浅，绝知此事要躬行"，我的建议是：

先快速过一遍这篇教程，边看边敲代码
找一个感兴趣的小项目开始动手
遇到问题时再回来查阅相关章节
在解决实际问题中加深理解
通过调试 bug 来积累经验

1. Python 基础语法与概念

1.1 变量与数据类型

变量命名规则和最佳实践
基本数据类型：

数值类型 (int, float, complex)
字符串 (str)
布尔值 (bool)

类型转换和检查
Python 的动态类型特性

# 数值类型示例
age = 25          # 整数
price = 19.99     # 浮点数
complex_num = 3 + 4j  # 复数

# 字符串示例
name = "Python 学习者"
message = '''这是一个
多行字符串示例'''

# 布尔值示例
is_student = True
is_working = False

# 类型检查和转换
print(type(age))       # 
str_num = "100"



    
num = int(str_num)     # 字符串转整数

1.2 运算符

算术运算符 (+, -, *, /, //, %, **)
比较运算符 (==, !=, >, =, <=)
逻辑运算符 (and, or, not)
赋值运算符 (=, +=, -=等)
位运算符 (&, |，^, >>, <

# 算术运算符示例
a = 10
b = 3

print(a + b)    # 13  (加法)
print(a - b)    # 7   (减法)
print(a * b)    # 30  (乘法)
print(a / b)    # 3.3333... (除法)
print(a // b)   # 3   (整除)
print(a % b)    # 1   (取余)
print(a ** b)   # 1000(幂运算)

# 比较和逻辑运算符
x = 5
y = 10
print(x and y 15)  # True
print(x > y or y 15)   # True

1.3 条件语句

if 语句的基本结构
elif 和 else 的使用
嵌套条件语句
三元运算符
match-case 语句 (Python 3.10+)

# if-elif-else 示例
score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 三元运算符
age = 20
status = "成年" if age >= 18 else "未成年"

# match-case 示例 (Python 3.10+)
def check_status(status_code):
    match status_code:
        case 200:
            return "成功"
        case 404:
            return "未找到"
        case _:
            return "未知状态"

1.4 循环结构

for 循环

range() 函数的使用
遍历序列和集合
enumerate() 的应用

while 循环

循环条件设计
break 和 continue
else 子句

循环嵌套和控制

# for 循环示例
for i in range(5):
    print(i)  # 打印 0 到 4

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)

# enumerate 示例
for index, fruit in enumerate(fruits):
    print(f"第{index+1}个水果是：{fruit}")

# while 循环示例
count = 0
while count 5:
    print(count)
    count += 1
    if count == 3:
        continue  # 跳过本次循环
    if count == 4:
        break    # 结束循环

2. 函数与模块

2.1 函数基础

函数定义与调用
参数类型：

位置参数
关键字参数
默认参数
可变参数 (*args, **kwargs)

返回值处理
函数文档字符串




    
# 基本函数定义
def greet(name, greeting="你好"):
    """
    向指定的人打招呼
    
    参数：
        name (str): 人名
        greeting (str): 问候语，默认为"你好"
    返回：
        str: 完整的问候语
    """
    return f"{greeting}, {name}!"

# 函数调用
print(greet("小明"))           # 你好，小明！
print(greet("小红", "早安"))    # 早安，小红！

# 可变参数示例
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3, 4))  # 10

# 关键字参数示例
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=20, city="北京")

2.2 模块使用

模块导入方式
包的概念和结构
常用内置模块使用示例

# 常用模块示例
import math
import random
import datetime
import os

# math 模块
print(math.pi)                 # 圆周率
print(math.sqrt(16))          # 平方根

# random 模块
print(random.randint(1, 10))  # 随机整数
print(random.choice(['苹果', '香蕉', '橙子']))  # 随机选择

# datetime 模块
now = datetime.datetime.now()
print(f"当前时间：{now}")
print(f"明天：{now + datetime.timedelta(days=1)}")

# os 模块
print(os.getcwd())            # 当前工作目录
print(os.listdir())           # 目录内容列表

3. 数据处理基础

3.1 数据结构

列表 (List)
元组 (Tuple)
集合 (Set)
字典 (Dict)

# 列表示例
fruits = ["苹果", "香蕉", "橙子"]
fruits.append("葡萄")         # 添加元素
fruits.insert(1, "梨")       # 插入元素
fruits.remove("香蕉")        # 删除元素
print(fruits[1:3])          # 切片操作

# 元组示例
point = (3, 4)
x, y = point                # 元组解包

# 集合示例
numbers = {1, 2, 3, 4, 5}
more_numbers = {4, 5, 6, 7, 8}
print(numbers & more_numbers)  # 交集
print(numbers | more_numbers)  # 并集

# 字典示例
student = {
    "name": "张三",
    "age": 20,
    "scores": {
        "数学": 90,
        "英语": 85
    }
}
print(student.get("grade", "未知"))  # 安全获取值

3.2 字符串操作

字符串方法
格式化方式
正则表达式

# 字符串方法示例
text = "  Python 编程  "
print(text.strip())          # 去除空白
print(text.upper())          # 转大写
print(text.lower())          # 转小写

# 字符串格式化
name = "小明"
age = 20
# f-string
print(f"{name}今年{age}岁")
# format 方法
print("{}今年{}岁".format(name, age))
# %-格式化
print("%s今年%d岁" % (name, age))

# 正则表达式
import re
text = "我的电话是 123-4567-8900"
phone = re.search(r"\d{3}-\d{4}-\d{4}", text)
if phone:
    print(f"找到电话号码：{phone.group()}")

3.3 文件操作

文件读写
JSON 处理
CSV 处理

# 文件读写示例
with open("example.txt", "w", encoding="utf-8") as f:
    f.write("这是一个示例文件\n")
    f.write("包含多行文本")

with open("example.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# JSON 处理
import json

data = {
    "name": "Python 教程",
    "version": "2025",
    "topics": ["基础", "进阶", "实战"]
}

# 写入 JSON
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# 读取 JSON
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)

4. 错误处理

异常处理机制
自定义异常

# 异常处理示例
def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：除数不能为 0")
        return None
    except TypeError:
        print("错误：参数类型必须是数字")
        return None
    else:
        return result
    finally:
        print("计算完成")

# 自定义异常
class ValidationError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

def validate_age(age):
    if not isinstance(age, int):
        raise ValidationError("年龄必须是整数")
    if age 0 or age > 150:
        raise ValidationError("年龄必须在 0-150 之间")
    return True

# 异常处理示例
try:
    validate_age("20")
except ValidationError as e:
    print(f"验证失败：{e.message}")

5. 面向对象编程 (OOP)

5.1 类和对象

类的定义和实例化
属性和方法
构造函数和析构函数
访问修饰符
属性装饰器 (@property)

class Student:
    # 类变量
    school = "Python 大学"
    
    def __init__(self, name: str, age: int):
        # 实例变量
        self.name = name        # 公有属性
        self._age = age         # 受保护属性
        self.__score = 0        # 私有属性
        
    def __del__(self):
        print(f"{self.name}对象被销毁")
    
    # 实例方法
    def study(self, course: str) -> None:
        print(f"{self.name}正在学习{course}")
    
    # 属性装饰器 - getter
    @property
    def score(self) -> int:
        return self.__score
    
    # 属性装饰器 - setter
    @score.setter
    def score(self, value: int) -> None:
        if not isinstance(value, int):
            raise TypeError("分数必须是整数")
        if 0 <= value <= 100:
            self.__score = value
        else:
            raise ValueError("分数必须在 0-100 之间")
    
    # 类方法
    @classmethod
    def get_school(cls) -> str:
        return cls.school
    
    # 静态方法
    @staticmethod
    def is_adult(age: int) -> bool:
        return age >= 18

# 使用示例
if __name__ == "__main__":
    # 创建实例
    student = Student("张三", 20)
    
    # 访问公有属性和方法
    print(student.name)         # 张三
    student.study("Python")     # 张三正在学习 Python
    
    # 使用属性装饰器
    student.score = 95          # 设置分数



    
    print(student.score)        # 95
    
    # 使用类方法和静态方法
    print(Student.get_school()) # Python 大学
    print(Student.is_adult(20)) # True

5.2 继承与多态

单继承和多继承
方法重写
super() 函数
抽象类和接口
混入类 (Mixins)

from abc import ABC, abstractmethod
from typing import List

# 抽象基类
class Animal(ABC):
    def __init__(self, name: str):
        self.name = name
    
    @abstractmethod
    def make_sound(self) -> str:
        pass
    
    def introduce(self) -> str:
        return f"我是{self.name}, {self.make_sound()}"

# Mixin 类
class FlyableMixin:
    def fly(self) -> str:
        return "我可以飞行"

class SwimmableMixin:
    def swim(self) -> str:
        return "我可以游泳"

# 具体类 - 单继承
class Dog(Animal):
    def make_sound(self) -> str:
        return "汪汪汪！"
    
    def fetch_ball(self) -> str:
        return "我可以接球"

# 具体类 - 多继承
class Duck(Animal, FlyableMixin, SwimmableMixin):
    def make_sound(self) -> str:
        return "嘎嘎嘎！"

# 使用示例
def animal_chorus(animals: List[Animal]) -> None:
    """演示多态性"""
    for animal in animals:
        print(animal.introduce())

if __name__ == "__main__":
    dog = Dog("旺财")
    duck = Duck("唐老鸭")
    
    # 测试继承和多态
    animal_chorus([dog, duck])
    
    # 测试多继承
    print(duck.fly())      # 我可以飞行
    print(duck.swim())     # 我可以游泳
    
    # 测试方法重写
    print(dog.make_sound())    # 汪汪汪！
    print(duck.make_sound())   # 嘎嘎嘎！

5.3 特殊方法

str__和__repr
len__和__getitem
call
运算符重载
上下文管理器协议

class Vector:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
    
    # 字符串表示
    def __str__(self) -> str:
        return f"Vector({self.x}, {self.y})"
    
    def __repr__(self) -> str:
        return f"Vector(x={self.x}, y={self.y})"
    
    # 运算符重载
    def __add__(self, other: 'Vector') -> 'Vector':
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other: 'Vector') -> 'Vector':
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar: float) -> 'Vector':
        return Vector(self.x * scalar, self.y * scalar)
    
    # 可调用对象
    def __call__(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5  # 返回向量长度

class MathList:
    def __init__(self, data: List[int]):
        self.data = data
    
    # 长度
    def __len__(self) -> int:
        return len(self.data)
    
    # 索引访问
    def __getitem__(self, index: int) -> int:
        return self.data[index]
    
    # 切片支持
    def __setitem__(self, index: int, value: int) -> None:
        self.data[index] = value

class FileManager:
    def __init__(self, filename: str):
        self.filename = filename
    
    # 上下文管理器协议
    def __enter__(self):
        print(f"打开文件：{self.filename}")
        self.file = open(self.filename, 'w', encoding='utf-8')
        return self.file
    
    


    
def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"关闭文件：{self.filename}")
        if self.file:
            self.file.close()
        return False  # 返回 False 则异常会继续传播

# 使用示例
if __name__ == "__main__":
    # 测试 Vector 类
    v1 = Vector(1, 2)
    v2 = Vector(3, 4)
    
    print(str(v1))             # Vector(1, 2)
    print(repr(v2))            # Vector(x=3, y=4)
    
    v3 = v1 + v2              # 运算符重载
    print(v3)                 # Vector(4, 6)
    
    length = v1()             # 调用对象
    print(f"向量长度：{length}")  # 向量长度：2.236...
    
    # 测试 MathList 类
    numbers = MathList([1, 2, 3, 4, 5])
    print(len(numbers))       # 5
    print(numbers[2])         # 3
    numbers[2] = 10
    print(numbers[2])         # 10
    
    # 测试文件管理器
    try:
        with FileManager('test.txt') as f:
            f.write('测试上下文管理器')
            raise Exception("测试异常")
    except Exception as e:
        print(f"捕获到异常：{e}")

总结

本教程涵盖了 Python 编程的基础概念和实践应用。

通过学习这些内容，你应该能够：

理解 Python 的基本语法和数据类型
掌握函数编程的核心概念
熟练使用 Python 的内置数据结构
进行基本的文件操作和错误处理

继续学习和实践的建议：

动手练习每个代码示例
尝试修改和扩展示例代码
阅读 Python 官方文档深入学习
开始编写自己的小项目

祝你在 Python 编程的道路上取得进步！

👇👇Pycharm2024账号免费提供了👇👇



    
(支持全家桶，永久免费)
关注上面公众号回复“账号”自助获取