1 语法
2 综合Demo：任务管理系统
3 环境问题
- 3.1 /usr/local/Cellar/python vs /opt/miniconda3/bin/python
4 Class

基于已有Go/Java/C的开发经验，Python可以在很短时间内掌握基础语法和核心概念。以下是学习要点和完整Demo：

1 语法

1.1 数据类型

# 变量和数据类型（动态类型）
name = "Python"           # 字符串
version = 3.9             # 整数
rating = 9.5              # 浮点数
is_awesome = True         # 布尔值
nothing = None            # 空值

# 集合类型
fruits = ["apple", "banana", "orange"]           # 列表（可变）
coordinates = (40.7128, -74.0060)               # 元组（不可变）
person = {"name": "John", "age": 30}            # 字典
unique_numbers = {1, 2, 3, 3, 4}                # 集合（自动去重）

# 类型注解（可选，类似Go/Java）
def greet(name: str) -> str:
    return f"Hello, {name}"

# 变量和数据类型（动态类型）

name = "Python" # 字符串

version = 3.9 # 整数

rating = 9.5 # 浮点数

is_awesome = True # 布尔值

nothing = None # 空值

# 集合类型

fruits = ["apple", "banana", "orange"] # 列表（可变）

coordinates = (40.7128, -74.0060) # 元组（不可变）

person = {"name": "John", "age": 30} # 字典

unique_numbers = {1, 2, 3, 3, 4} # 集合（自动去重）

# 类型注解（可选，类似Go/Java）

def greet(name: str) -> str:

return f"Hello, {name}"

1.2 控制流

# 条件语句
age = 25
if age < 18:
    print("Minor")
elif 18 <= age < 65:
    print("Adult")
else:
    print("Senior")

# 循环
for i in range(5):           # 0到4
    print(i)

for fruit in fruits:         # 遍历列表
    print(fruit)

# 列表推导式（Python特色）
squares = [x**2 for x in range(10) if x % 2 == 0]

# 条件语句

age = 25

if age < 18:

print("Minor")

elif 18 <= age < 65:

print("Adult")

else:

print("Senior")

# 循环

for i in range(5): # 0到4

print(i)

for fruit in fruits: # 遍历列表

print(fruit)

# 列表推导式（Python特色）

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

1.3 函数和类

# 函数定义
def calculate_area(length, width=1):  # 默认参数
    """计算面积"""  # 文档字符串
    return length * width


# 类定义
class Person:
    def __init__(self, name, age):  # 构造函数
        self.name = name
        self.age = age
    
    def introduce(self):
        return f"I'm {self.name}, {self.age} years old"

# 继承
class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

# 函数定义

def calculate_area(length, width=1): # 默认参数

"""计算面积""" # 文档字符串

return length * width

# 类定义

class Person:

def __init__(self, name, age): # 构造函数

self.name = name

self.age = age

def introduce(self):

return f"I'm {self.name}, {self.age} years old"

# 继承

class Student(Person):

def __init__(self, name, age, student_id):

super().__init__(name, age)

self.student_id = student_id

2 综合Demo：任务管理系统

"""
任务管理系统 - 展示Python核心特性
"""
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import json

class Task:
    """任务类"""
    
    def __init__(self, title: str, description: str = "", priority: int = 1):
        self.title = title
        self.description = description
        self.priority = priority  # 1-5, 5最高
        self.created_at = datetime.now()
        self.completed = False
        self.tags: List[str] = []
    
    def complete(self) -> None:
        """标记任务为完成"""
        self.completed = True
    
    def add_tag(self, tag: str) -> None:
        """添加标签"""
        if tag not in self.tags:
            self.tags.append(tag)
    
    def __str__(self) -> str:
        status = "✓" if self.completed else "◯"
        return f"[{status}] {self.title} (优先级: {self.priority})"
    
    def to_dict(self) -> Dict:
        """转换为字典（用于JSON序列化）"""
        return {
            "title": self.title,
            "description": self.description,
            "priority": self.priority,
            "created_at": self.created_at.isoformat(),
            "completed": self.completed,
            "tags": self.tags
        }

class TaskManager:
    """任务管理器"""
    
    def __init__(self):
        self.tasks: List[Task] = []
    
    def add_task(self, title: str, **kwargs) -> Task:
        """添加任务，支持关键字参数"""
        task = Task(title, **kwargs)
        self.tasks.append(task)
        return task
    
    def get_pending_tasks(self) -> List[Task]:
        """获取未完成的任务"""
        return [task for task in self.tasks if not task.completed]
    
    def get_high_priority_tasks(self, threshold: int = 3) -> List[Task]:
        """获取高优先级任务"""
        return [
            task for task in self.tasks 
            if task.priority >= threshold and not task.completed
        ]
    
    def complete_task(self, title: str) -> bool:
        """根据标题完成任务"""
        for task in self.tasks:
            if task.title == title and not task.completed:
                task.complete()
                return True
        return False
    
    def get_tasks_by_tag(self, tag: str) -> List[Task]:
        """根据标签筛选任务"""
        return [task for task in self.tasks if tag in task.tags]
    
    def get_task_statistics(self) -> Dict:
        """获取任务统计信息"""
        total = len(self.tasks)
        completed = sum(1 for task in self.tasks if task.completed)
        pending = total - completed
        
        # 使用字典推导式
        priority_dist = {
            f"priority_{i}": sum(1 for task in self.tasks if task.priority == i)
            for i in range(1, 6)
        }
        
        return {
            "total": total,
            "completed": completed,
            "pending": pending,
            "completion_rate": completed / total if total > 0 else 0,
            "priority_distribution": priority_dist
        }
    
    def save_to_file(self, filename: str) -> None:
        """保存任务到文件"""
        data = [task.to_dict() for task in self.tasks]
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    
    def load_from_file(self, filename: str) -> None:
        """从文件加载任务"""
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                data = json.load(f)
                self.tasks = []
                for item in data:
                    task = Task(
                        item["title"],
                        item["description"],
                        item["priority"]
                    )
                    task.completed = item["completed"]
                    task.tags = item["tags"]
                    self.tasks.append(task)
        except FileNotFoundError:
            print("文件不存在，创建新的任务列表")

def main():
    """主函数 - 演示使用"""
    manager = TaskManager()
    
    # 添加任务
    task1 = manager.add_task(
        "学习Python基础",
        description="掌握Python核心语法",
        priority=5
    )
    task1.add_tag("学习")
    task1.add_tag("编程")
    
    manager.add_task("写项目文档", priority=3).add_tag("工作")
    manager.add_task("购买 groceries", priority=2).add_tag("生活")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

"""

任务管理系统 - 展示Python核心特性

"""

from typing import List, Dict, Optional

from datetime import datetime, timedelta

import json

class Task:

"""任务类"""

def __init__(self, title: str, description: str = "", priority: int = 1):

self.title = title

self.description = description

self.priority = priority # 1-5, 5最高

self.created_at = datetime.now()

self.completed = False

self.tags: List[str] = []

def complete(self) -> None:

"""标记任务为完成"""

self.completed = True

def add_tag(self, tag: str) -> None:

"""添加标签"""

if tag not in self.tags:

self.tags.append(tag)

def __str__(self) -> str:

status = "✓" if self.completed else "◯"

return f"[{status}] {self.title} (优先级: {self.priority})"

def to_dict(self) -> Dict:

"""转换为字典（用于JSON序列化）"""

return {

"title": self.title,

"description": self.description,

"priority": self.priority,

"created_at": self.created_at.isoformat(),

"completed": self.completed,

"tags": self.tags

}

class TaskManager:

"""任务管理器"""

def __init__(self):

self.tasks: List[Task] = []

def add_task(self, title: str, **kwargs) -> Task:

"""添加任务，支持关键字参数"""

task = Task(title, **kwargs)

self.tasks.append(task)

return task

def get_pending_tasks(self) -> List[Task]:

"""获取未完成的任务"""

return [task for task in self.tasks if not task.completed]

def get_high_priority_tasks(self, threshold: int = 3) -> List[Task]:

"""获取高优先级任务"""

return [

task for task in self.tasks

if task.priority >= threshold and not task.completed

]

def complete_task(self, title: str) -> bool:

"""根据标题完成任务"""

for task in self.tasks:

if task.title == title and not task.completed:

task.complete()

return True

return False

def get_tasks_by_tag(self, tag: str) -> List[Task]:

"""根据标签筛选任务"""

return [task for task in self.tasks if tag in task.tags]

def get_task_statistics(self) -> Dict:

"""获取任务统计信息"""

total = len(self.tasks)

completed = sum(1 for task in self.tasks if task.completed)

pending = total - completed

# 使用字典推导式

priority_dist = {

f"priority_{i}": sum(1 for task in self.tasks if task.priority == i)

for i in range(1, 6)

}

return {

"total": total,

"completed": completed,

"pending": pending,

"completion_rate": completed / total if total > 0 else 0,

"priority_distribution": priority_dist

}

def save_to_file(self, filename: str) -> None:

"""保存任务到文件"""

data = [task.to_dict() for task in self.tasks]

with open(filename, 'w', encoding='utf-8') as f:

json.dump(data, f, ensure_ascii=False, indent=2)

def load_from_file(self, filename: str) -> None:

"""从文件加载任务"""

try:

with open(filename, 'r', encoding='utf-8') as f:

data = json.load(f)

self.tasks = []

for item in data:

task = Task(

item["title"],

item["description"],

item["priority"]

)

task.completed = item["completed"]

task.tags = item["tags"]

self.tasks.append(task)

except FileNotFoundError:

print("文件不存在，创建新的任务列表")

def main():

"""主函数 - 演示使用"""

manager = TaskManager()

# 添加任务

task1 = manager.add_task(

"学习Python基础",

description="掌握Python核心语法",

priority=5

)

task1.add_tag("学习")

task1.add_tag("编程")

manager.add_task("写项目文档", priority=3).add_tag("工作")

manager.add_task("购买 groceries", priority=2).add_tag("生活")

3 环境问题

python环境搭建

3.1 /usr/local/Cellar/python vs /opt/miniconda3/bin/python

在 macOS 上出现多个 Python 路径是很常见的，这通常是因为你通过不同方式安装了 Python（比如系统自带、Homebrew、conda 等）。

1、不同路径对应不同的 “环境”，用途和场景不同：

/usr/local/Cellar/python这是通过 Homebrew（macOS 常用的包管理器）安装的 Python。
- 特点：属于 “系统级” 或 “用户级” 的独立 Python 环境，不依赖其他工具，适合日常开发、运行脚本等场景。
- 安装的第三方库会放在 ~/Library/Python/版本/site-packages 或 Cellar/python/版本/lib/pythonX.X/site-packages 下。

/opt/miniconda3/bin/python这是 Miniconda（轻量级的 Anaconda 发行版）自带的 Python。
- 特点：属于 “虚拟环境管理工具” 自带的 Python，主要用于 隔离不同项目的依赖（比如不同项目需要不同版本的 Python 或库）。
- 当你创建 conda 虚拟环境时，会在 miniconda3/envs/环境名 下生成独立的 Python 和库，避免依赖冲突。

应该选择哪一个？取决于你的使用场景：

如果是普通开发、运行简单脚本：优先用 Homebrew 安装的 Python（/usr/local/Cellar/python 对应的可执行文件通常会软链接到 /usr/local/bin/python3），更轻量且不依赖 conda 环境。

如果需要管理多个项目的依赖（比如不同项目用不同版本的库）：用 Miniconda 的 Python，通过 conda create 创建虚拟环境，此时会自动使用该环境下的 Python，避免依赖冲突。

2、如何确认当前在用哪个 Python？

which python3   # 或 which python

1	which python3 # 或 which python

3、如何指定？

可以把下面配置放置在环境变量文件最前面，比如.zshrc文件

# 优先使用 Homebrew 路径
export PATH="/usr/local/bin:$PATH"

1 2	# 优先使用 Homebrew 路径 export PATH="/usr/local/bin:$PATH"

4 Class

示例 1：最基础的类（空类 + 实例化）

核心：定义空类、创建实例（对象）、给实例绑定属性。

# 定义一个空类（没有任何属性/方法）
class Person:
    # pass表示“空实现”，避免类体为空报错
    pass

# 1. 创建类的实例（对象）—— 类名+() 就是实例化
p1 = Person()

# 2. 给实例动态绑定属性（Python特有的灵活特性）
p1.name = "张三"
p1.age = 20

# 3. 访问实例属性
print(p1.name)  # 输出：张三
print(p1.age)   # 输出：20

# 4. 创建另一个实例（属性独立）
p2 = Person()
p2.name = "李四"
p2.age = 25
print(p2.name)  # 输出：李四

# 定义一个空类（没有任何属性/方法）

class Person:

# pass表示“空实现”，避免类体为空报错

pass

# 1. 创建类的实例（对象）—— 类名+() 就是实例化

p1 = Person()

# 2. 给实例动态绑定属性（Python特有的灵活特性）

p1.name = "张三"

p1.age = 20

# 3. 访问实例属性

print(p1.name) # 输出：张三

print(p1.age) # 输出：20

# 4. 创建另一个实例（属性独立）

p2 = Person()

p2.name = "李四"

p2.age = 25

print(p2.name) # 输出：李四

示例 2：带构造函数（init）的类

核心：__init__是类的 “构造函数”，创建实例时自动执行，用于初始化属性（最常用）。

class Person:
    # 构造函数：self必须是第一个参数，代表实例本身
    # name/age是传入的参数，用于初始化实例属性
    def __init__(self, name, age):
        # 定义实例属性：把传入的参数绑定到self（实例）上
        self.name = name
        self.age = age

# 实例化时必须传name/age参数（__init__要求）
p1 = Person("张三", 20)
p2 = Person("李四", 25)

# 访问属性
print(p1.name, p1.age)  # 输出：张三 20
print(p2.name, p2.age)  # 输出：李四 25

# 动态修改属性
p1.age = 21
print(p1.age)  # 输出：21

class Person:

# 构造函数：self必须是第一个参数，代表实例本身

# name/age是传入的参数，用于初始化实例属性

def __init__(self, name, age):

# 定义实例属性：把传入的参数绑定到self（实例）上

self.name = name

self.age = age

# 实例化时必须传name/age参数（__init__要求）

p1 = Person("张三", 20)

p2 = Person("李四", 25)

# 访问属性

print(p1.name, p1.age) # 输出：张三 20

print(p2.name, p2.age) # 输出：李四 25

# 动态修改属性

p1.age = 21

print(p1.age) # 输出：21

示例 3：带方法的类（实例方法 + 类方法 + 静态方法）

核心：类中可以定义不同类型的方法，实现实例的行为。

class Person:
    # 类属性：所有实例共享（区别于实例属性）
    species = "人类"

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    # 1. 实例方法：第一个参数必须是self，操作实例属性
    def introduce(self):
        """自我介绍"""
        return f"我叫{self.name}，今年{self.age}岁"

    # 2. 类方法：第一个参数是cls（代表类本身），操作类属性
    @classmethod
    def get_species(cls):
        """获取类属性"""
        return f"物种：{cls.species}"

    # 3. 静态方法：无默认参数，和类/实例无关，仅做工具函数
    @staticmethod
    def is_adult(age):
        """判断是否成年"""
        return age >= 18

# ------------------- 使用示例 -------------------
# 1. 实例方法：通过实例调用
p1 = Person("张三", 20)
print(p1.introduce())  # 输出：我叫张三，今年20岁

# 2. 类方法：通过类或实例调用
print(Person.get_species())  # 输出：物种：人类
print(p1.get_species())      # 输出：物种：人类

# 3. 静态方法：通过类或实例调用
print(Person.is_adult(18))   # 输出：True
print(p1.is_adult(17))       # 输出：False

# 4. 访问类属性
print(Person.species)  # 输出：人类
print(p1.species)      # 输出：人类

class Person:

# 类属性：所有实例共享（区别于实例属性）

species = "人类"

def __init__(self, name, age):

self.name = name # 实例属性

self.age = age

# 1. 实例方法：第一个参数必须是self，操作实例属性

def introduce(self):

"""自我介绍"""

return f"我叫{self.name}，今年{self.age}岁"

# 2. 类方法：第一个参数是cls（代表类本身），操作类属性

@classmethod

def get_species(cls):

"""获取类属性"""

return f"物种：{cls.species}"

# 3. 静态方法：无默认参数，和类/实例无关，仅做工具函数

@staticmethod

def is_adult(age):

"""判断是否成年"""

return age >= 18

# ------------------- 使用示例 -------------------

# 1. 实例方法：通过实例调用

p1 = Person("张三", 20)

print(p1.introduce()) # 输出：我叫张三，今年20岁

# 2. 类方法：通过类或实例调用

print(Person.get_species()) # 输出：物种：人类

print(p1.get_species()) # 输出：物种：人类

# 3. 静态方法：通过类或实例调用

print(Person.is_adult(18)) # 输出：True

print(p1.is_adult(17)) # 输出：False

# 4. 访问类属性

print(Person.species) # 输出：人类

print(p1.species) # 输出：人类

示例 4：带继承的类（子类继承父类）

核心：子类复用父类的属性 / 方法，也可重写自定义。

# 父类（基类）
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"我叫{self.name}，今年{self.age}岁"

# 子类（派生类）：继承Person
class Student(Person):
    # 子类的构造函数：先调用父类构造函数，再定义自己的属性
    def __init__(self, name, age, student_id):
        # 调用父类的__init__，初始化name/age
        super().__init__(name, age)
        # 子类独有的属性
        self.student_id = student_id

    # 重写父类的introduce方法（自定义行为）
    def introduce(self):
        return f"我叫{self.name}，学号{self.student_id}，今年{self.age}岁"

# ------------------- 使用示例 -------------------
# 创建子类实例
s1 = Student("李四", 18, "2025001")

# 调用重写后的方法
print(s1.introduce())  # 输出：我叫李四，学号2025001，今年18岁

# 访问父类的属性
print(s1.name, s1.age)  # 输出：李四 18

# 访问子类独有的属性
print(s1.student_id)    # 输出：2025001

# 父类（基类）

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def introduce(self):

return f"我叫{self.name}，今年{self.age}岁"

# 子类（派生类）：继承Person

class Student(Person):

# 子类的构造函数：先调用父类构造函数，再定义自己的属性

def __init__(self, name, age, student_id):

# 调用父类的__init__，初始化name/age

super().__init__(name, age)

# 子类独有的属性

self.student_id = student_id

# 重写父类的introduce方法（自定义行为）

def introduce(self):

return f"我叫{self.name}，学号{self.student_id}，今年{self.age}岁"

# ------------------- 使用示例 -------------------

# 创建子类实例

s1 = Student("李四", 18, "2025001")

# 调用重写后的方法

print(s1.introduce()) # 输出：我叫李四，学号2025001，今年18岁

# 访问父类的属性

print(s1.name, s1.age) # 输出：李四 18

# 访问子类独有的属性

print(s1.student_id) # 输出：2025001

示例 5：实战类（模拟文件选择器，贴近你之前的代码）

核心：结合属性、方法、内部方法（下划线命名），模拟实际场景。

class FileSelector:
    """模拟文件选择器类"""
    def __init__(self, path, match_rules=None):
        # 初始化路径和匹配规则
        self.path = path  # 目标路径
        # 匹配规则：默认空列表，避免None报错
        self.match_rules = match_rules or []
        # 内部属性（下划线标记：仅类内部使用）
        self._is_dir = self._check_if_dir()

    # 内部方法：检查路径是否为目录（下划线标记）
    def _check_if_dir(self):
        # 模拟判断（实际可调用os.path.isdir）
        return self.path.endswith("/")

    # 公开方法：筛选符合规则的文件
    def select_files(self):
        if not self._is_dir:
            return []  # 非目录返回空
        # 模拟筛选逻辑
        fake_files = ["file1.py", "file2.txt", "dir1/"]
        return [f for f in fake_files if any(rule in f for rule in self.match_rules)]

# ------------------- 使用示例 -------------------
# 创建选择器实例：匹配.py文件
selector = FileSelector("/home/user/", match_rules=["*.py"])

# 调用公开方法
print(selector.select_files())  # 输出：['file1.py']

# 访问公开属性
print(selector.path)  # 输出：/home/user/

# 不建议访问内部属性（但语法上允许）
print(selector._is_dir)  # 输出：True

class FileSelector:

"""模拟文件选择器类"""

def __init__(self, path, match_rules=None):

# 初始化路径和匹配规则

self.path = path # 目标路径

# 匹配规则：默认空列表，避免None报错

self.match_rules = match_rules or []

# 内部属性（下划线标记：仅类内部使用）

self._is_dir = self._check_if_dir()

# 内部方法：检查路径是否为目录（下划线标记）

def _check_if_dir(self):

# 模拟判断（实际可调用os.path.isdir）

return self.path.endswith("/")

# 公开方法：筛选符合规则的文件

def select_files(self):

if not self._is_dir:

return [] # 非目录返回空

# 模拟筛选逻辑

fake_files = ["file1.py", "file2.txt", "dir1/"]

return [f for f in fake_files if any(rule in f for rule in self.match_rules)]

# ------------------- 使用示例 -------------------

# 创建选择器实例：匹配.py文件

selector = FileSelector("/home/user/", match_rules=["*.py"])

# 调用公开方法

print(selector.select_files()) # 输出：['file1.py']

# 访问公开属性

print(selector.path) # 输出：/home/user/

# 不建议访问内部属性（但语法上允许）

print(selector._is_dir) # 输出：True

核心知识点总结

语法 / 概念	作用
`class 类名:`	定义类，冒号标记类体开始
`__init__(self, ...)`	构造函数，实例化时自动执行，初始化实例属性
`self.属性名 = 值`	定义实例属性（每个实例独立）
`类名.属性名 = 值`	定义类属性（所有实例共享）
`def 方法名(self):`	定义实例方法，self 代表实例本身
`@classmethod`	类方法装饰器，cls 代表类本身
`@staticmethod`	静态方法装饰器，无默认参数，仅做工具函数
`class 子类(父类):`	子类继承父类，可复用 / 重写父类属性 / 方法
`_方法名/_属性名`	下划线命名约定：标记内部方法 / 属性，建议仅类内部使用（非语法强制）

Heart.Think.Do

【Python】一天掌握python

1 语法

1.1 数据类型

1.2 控制流

1.3 函数和类

2 综合Demo：任务管理系统

3 环境问题

3.1 /usr/local/Cellar/python vs /opt/miniconda3/bin/python

4 Class

示例 1：最基础的类（空类 + 实例化）

示例 2：带构造函数（init）的类

示例 3：带方法的类（实例方法 + 类方法 + 静态方法）

示例 4：带继承的类（子类继承父类）

示例 5：实战类（模拟文件选择器，贴近你之前的代码）

核心知识点总结

Related Posts:

分类&标签