简说 python - 技术栈

数据类型

Python 的数据类型非常丰富，了解它们对写代码很重要。下面给你总结常见的数据类型和特点：

1. 数字类型（Numbers）

int ：整数，比如 42、-7
float ：浮点数（小数），比如 3.14、-0.001
complex ：复数，比如 3+4j

python 复制代码

a = 10      # int
b = 3.14    # float
c = 2 + 3j  # complex

2. 布尔类型（Boolean）

bool ：只有两个值 True 和 False

python 复制代码

flag = True
is_valid = False

3. 字符串（String）

str：文本数据，使用单引号或双引号表示

python 复制代码

s1 = "Hello"
s2 = 'Python'

4. 序列类型（Sequence）

list：列表，可变，有序，支持不同类型元素

python 复制代码

lst = [1, 2, 3, "abc", True]

tuple：元组，不可变，有序

python 复制代码

t = (1, 2, 3)

range：表示整数序列，常用在循环

python 复制代码

r = range(5)  # 0,1,2,3,4

5. 集合（Set）

set：无序、不重复元素集合

python 复制代码

s = {1, 2, 3}

frozenset：不可变的set

6. 映射类型（Mapping）

dict：字典，键值对集合，键唯一

python 复制代码

d = {"name": "Alice", "age": 25}

7. None 类型

NoneType ：特殊类型，只有一个值 None，表示"无"或"空"

python 复制代码

x = None

Python数据类型小总结

类型	描述	可变？	例子
int	整数	否	10, -3
float	浮点数	否	3.14, -0.001
complex	复数	否	1+2j
bool	布尔值	否	True, False
str	字符串	否	"hello", 'abc'
list	列表	是	[1, 2, 3]
tuple	元组	否	(1, 2, 3)
range	整数序列	否	range(5)
set	集合	是	{1, 2, 3}
frozenset	不可变集合	否	frozenset({1, 2, 3})
dict	字典	是	{"key": "value"}
NoneType	None	否	None

语句

你要了解 Python 里的判断（条件语句）、运算和循环操作，下面我帮你系统地总结一下，方便你快速掌握：

1. 条件判断语句（if）

python 复制代码

x = 10
if x > 0:
    print("正数")
elif x == 0:
    print("零")
else:
    print("负数")

if 判断条件是否为真
elif 多重判断
else 兜底处理

2. 条件运算符（比较运算符）

运算符	说明	示例
==	等于	x == 10
!=	不等于	x != 5
>	大于	x > 3
<	小于	x < 7
>=	大于等于	x >= 4
<=	小于等于	x <= 9

3. 逻辑运算符

运算符	说明	示例
and	与	x > 0 and x < 10
or	或	x < 0 or x > 10
not	非（取反）	not (x == 5)

4. 循环语句

while 循环

python 复制代码

count = 0
while count < 5:
    print(count)
    count += 1

for 循环

python 复制代码

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

range(5) 产生 0 到 4 的序列

5. 循环控制语句

关键字	作用
break	退出整个循环
continue	跳过本次循环，进入下一次循环
else (循环后面)	循环正常结束时执行（无break时执行）

6. 综合示例

python 复制代码

for i in range(10):
    if i % 2 == 0:
        print(f"{i} 是偶数")
    else:
        print(f"{i} 是奇数")

函数

Python 定义函数的方法很简单，核心用 def 关键词。下面给你一个基础介绍和示例：

Python 函数定义语法

python 复制代码

def 函数名(参数列表):
    """函数的文档字符串（可选）"""
    函数体
    return 返回值（可选）

def：定义函数的关键字
函数名：给函数取个名字，遵守变量命名规则
参数列表：函数接收的参数，可以没有，也可以多个
函数体：函数执行的代码块，缩进表示
return：返回值，可以没有（默认返回 None）

示例

python 复制代码

def greet(name):
    """打印问候语"""
    print(f"Hello, {name}!")

greet("Alice")
# 输出：Hello, Alice!

带返回值的函数

python 复制代码

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

result = add(3, 5)
print(result)  # 8

参数类型和默认值

python 复制代码

def power(base, exponent=2):
    return base ** exponent

print(power(3))      # 9，默认指数2
print(power(2, 3))   # 8，自定义指数3

多参数和可变参数

python 复制代码

def func(*args, **kwargs):
    print("位置参数：", args)
    print("关键字参数：", kwargs)

func(1, 2, x=3, y=4)

python 函数的几个进阶用法，包括：

函数装饰器（Decorator）
匿名函数（Lambda）

1. 函数装饰器（Decorator）

装饰器本质上是一个函数，接受另一个函数作为参数，并返回一个新的函数，常用于给函数增加额外功能，比如打印日志、权限检查等。

简单装饰器示例

python 复制代码

def decorator(func):
    def wrapper(*args, **kwargs):
        print("调用函数前，执行一些操作")
        result = func(*args, **kwargs)
        print("调用函数后，执行一些操作")
        return result
    return wrapper

@decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")

运行结果：

复制代码

调用函数前，执行一些操作
Hello, Alice!
调用函数后，执行一些操作

解释：

@decorator 语法等价于 say_hello = decorator(say_hello)
每次调用 say_hello，实际上调用的是 wrapper 函数

2. 匿名函数（Lambda）

匿名函数是一种快速定义简单函数的方法，通常用于函数式编程场景，比如 map、filter。

语法：

python 复制代码

lambda 参数列表: 表达式

示例

python 复制代码

# 普通函数
def add(x, y):
    return x + y

# 匿名函数
add_lambda = lambda x, y: x + y

print(add(2, 3))         # 5
print(add_lambda(2, 3))  # 5

# 用lambda和map
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, nums))
print(squares)  # [1, 4, 9, 16]

示例代码。

1. 函数作为参数

Python 函数是"一等公民"，可以当作参数传递给另一个函数。

python 复制代码

def greet(name):
    return f"Hello, {name}!"

def call_func(func, arg):
    result = func(arg)
    print(result)

call_func(greet, "Alice")
# 输出：Hello, Alice!

解释：call_func 接受一个函数和参数，调用这个函数并打印结果。

2. 函数返回函数

函数可以返回另一个函数，这样能动态创建函数。

python 复制代码

def make_multiplier(x):
    def multiplier(n):
        return n * x
    return multiplier

times3 = make_multiplier(3)
print(times3(5))  # 15

times5 = make_multiplier(5)
print(times5(5))  # 25

解释：make_multiplier 返回了一个乘以 x 的函数，调用时可用不同的 x。

3. 闭包（Closure）

闭包就是返回的函数记住了定义时的环境变量（即使外部函数已经返回了）。

上面 make_multiplier 就是闭包的一个例子：

返回的 multiplier 函数记住了 x 的值
即使外部函数执行完，multiplier 仍然能访问 x

额外示例：闭包保存计数器状态

python 复制代码

def counter():
    count = 0
    def increment():
        nonlocal count  # 声明外层变量可修改
        count += 1
        return count
    return increment

c = counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

解释：

increment 函数访问并修改外部变量 count
nonlocal 声明允许修改外层变量
每次调用 c()，计数器加1并返回当前值

总结

概念	作用	代码作用点
函数作为参数	动态传递行为	`call_func(func, arg)`
函数返回函数	创建自定义函数	`make_multiplier` 返回 `multiplier`
闭包	记住外部状态，函数携带数据	`increment` 记住并修改 `count`

import 功能

1. import 包 / 模块

import 只是把模块（文件）加载进来了，方便你访问里面的函数、类、变量。
你不一定非得实例化（创建对象），要看你用什么。

2. 函数

python 复制代码

import math
print(math.sqrt(16))  # 直接调用函数，不用实例化

这里 math 是模块，里面有函数，直接调用即可。

3. 类

如果模块里有类，想用类里面的方法，你通常需要先实例化：

python 复制代码

from datetime import datetime

now = datetime.now()  # datetime 是类，先实例化对象，再用它的方法
print(now)

有些类也提供类方法或静态方法，不用实例化也能用：

python 复制代码

print(datetime.today())  # 类方法，直接调用

4. 包和模块结构

包是多个模块的集合，是文件夹+__init__.py。导入包时，是导入包的命名空间。
你依然需要访问里面的模块或类。

5. 总结

内容	是否需要实例化	备注
函数	否	直接调用
类的实例方法	是	先实例化对象
类的静态/类方法	否	可直接调用
模块	不涉及实例化	只是命名空间

我该用哪个第三方包或者标准库来解决我的需求？

一些帮你选包的思路和方法：

1. 明确你的需求是什么？

先想清楚你要做什么，比如：

需要做网络请求
需要处理数据分析
需要操作Excel文件
做网页爬虫
做机器学习/深度学习
做图像处理
...

不同需求有不同的"经典包"或"推荐包"。

2. 先查 Python 标准库

Python自带了非常多基础库，比如：

文件操作（os, shutil）
网络请求（urllib）
数据处理（json, csv, sqlite3）
正则表达式（re）
多线程/多进程（threading, multiprocessing）

如果标准库能满足，优先用它，省得装额外依赖。

3. 查第三方包时，选择主流且维护活跃的包

通过 PyPI (https://pypi.org) 搜索关键词
看包的GitHub仓库星数、最近更新
看文档是否完善
查社区推荐和教程

4. 常用领域包推荐（帮你快速入门）

领域	常用包推荐
HTTP请求	`requests`
数据分析	`pandas`, `numpy`
机器学习	`scikit-learn`, `tensorflow`, `pytorch`
爬虫	`scrapy`, `beautifulsoup4`
Excel操作	`openpyxl`, `xlrd`
图像处理	`Pillow`
Web开发	`flask`, `django`
数据库	`SQLAlchemy`, `psycopg2`

5. 参考别人代码和教程

看别人是怎么做类似事情的，通常用哪些包。

6. 试用和实验

遇到几个备选包，可以都简单试试，看看哪个用起来方便、文档好、适合你项目。

总结

先明确需求
优先用标准库
主流、活跃、文档好的第三方包
参考社区和教程
多试用

用Python的包很简单，下面是基础步骤和示范，快速上手：

1. 安装包

先确保你安装了需要用的包，比如用pip：

bash 复制代码

pip install 包名

比如安装 requests：

bash 复制代码

pip install requests

2. 导入包或模块

在Python代码里用 import 语句导入包或模块：

python 复制代码

import requests

或者导入包里的某个模块/函数：

python 复制代码

from requests import get

3. 使用包提供的功能

举个用 requests 发GET请求的例子：

python 复制代码

import requests

response = requests.get("https://api.github.com")
print(response.status_code)
print(response.text)

4. 包结构理解（简单）

假设包里有模块和子包，可以这样导入：

python 复制代码

import mypackage.module1
from mypackage.subpackage import module2

5. 使用虚拟环境（推荐）

为了管理包依赖，建议新建虚拟环境：

bash 复制代码

python3 -m venv env
source env/bin/activate  # Linux/macOS
env\Scripts\activate     # Windows
pip install requests

这样安装的包只在这个环境里有效，互不影响。

总结

安装包：pip install 包名
导入包：import 包名 或 from 包名 import 模块/函数
调用包里的功能实现需求

OOP

Python 的类是面向对象编程（OOP）的核心，帮你组织代码、封装数据和行为。下面是基础介绍和示例：

1. 定义类

python 复制代码

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

    def greet(self):
        print(f"Hello, my name is {self.name}, I'm {self.age} years old.")

class 关键字定义类
__init__ 是构造函数，实例化时自动调用
self 代表实例本身，访问实例属性和方法

2. 创建实例

python 复制代码

p = Person("Alice", 30)
p.greet()
# 输出：Hello, my name is Alice, I'm 30 years old.

3. 类属性和实例属性

python 复制代码

class Dog:
    species = "Canis familiaris"  # 类属性，所有实例共享

    def __init__(self, name):
        self.name = name          # 实例属性，每个实例不同

dog1 = Dog("Buddy")
dog2 = Dog("Max")
print(dog1.species)  # Canis familiaris
print(dog2.species)  # Canis familiaris

4. 方法示例

实例方法（带 self）
类方法（用 @classmethod 装饰，参数是 cls）
静态方法（用 @staticmethod 装饰，不接收隐含参数）

python 复制代码

class MyClass:
    @classmethod
    def class_method(cls):
        print("这是类方法")

    @staticmethod
    def static_method():
        print("这是静态方法")

MyClass.class_method()
MyClass.static_method()

5. 继承

python 复制代码

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Woof!")

d = Dog()
d.speak()  # Woof!

好嘞！我给你写一个完整的 Python 类示例，涵盖基本用法、继承和常见的魔术方法（特殊方法）。你可以直接运行体验：

python 复制代码

class Person:
    species = "Homo sapiens"  # 类属性

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

    def greet(self):
        print(f"Hello, my name is {self.name}, and I'm {self.age} years old.")

    def __str__(self):
        # 当打印对象时，调用此方法
        return f"Person(name={self.name}, age={self.age})"

    def __repr__(self):
        # 交互式解释器中显示，通常和 __str__ 类似
        return f"Person('{self.name}', {self.age})"

    def __eq__(self, other):
        # 判断两个对象是否相等（基于name和age）
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

    def __lt__(self, other):
        # 用于比较年龄，小于判断
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented

    def __del__(self):
        # 对象被销毁时调用（少用）
        print(f"{self.name} 对象被删除了")

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

    def greet(self):
        # 重写 greet 方法
        print(f"Hi, I'm {self.name}, a student with ID {self.student_id}.")

    def __str__(self):
        return f"Student(name={self.name}, age={self.age}, student_id={self.student_id})"


# 测试代码
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
s1 = Student("Charlie", 20, "S12345")

p1.greet()  # Hello, my name is Alice, and I'm 30 years old.
print(p1)   # Person(name=Alice, age=30)
print(repr(p2))  # Person('Bob', 25)

print(p1 == p2)  # False
print(p1 == Person("Alice", 30))  # True

print(p2 < p1)  # True，因为25 < 30

s1.greet()  # Hi, I'm Charlie, a student with ID S12345.
print(s1)   # Student(name=Charlie, age=20, student_id=S12345)

重点总结：

魔术方法	用途
`__init__`	初始化对象（构造函数）
`__str__`	打印对象时的友好字符串
`__repr__`	交互式环境显示对象信息
`__eq__`	判断两个对象是否相等
`__lt__`	小于比较（可用于排序等）
`__del__`	对象销毁时调用

更多魔术方法的用法（比如算术操作重载、属性访问控制等）

虚拟环境（virtualenv）

好的！虚拟环境（virtualenv）是 Python 开发中非常重要的工具，配合 pip 使用，能帮你隔离项目依赖，避免包冲突。下面我给你讲讲它的作用、怎么创建和用法。

什么是虚拟环境（virtualenv）

Python虚拟环境是一个独立的、隔离的Python运行环境
它有自己独立的Python解释器和包管理目录
不会影响系统全局Python和其他项目环境
方便管理不同项目的依赖版本，避免冲突

常见的虚拟环境工具

venv（Python 3.3+内置）
virtualenv（第三方包，功能更丰富，但现在大部分用内置的 venv 就够了）

用 Python 内置 venv 创建虚拟环境

1. 创建虚拟环境

bash 复制代码

python3 -m venv myenv

这会在当前目录创建一个叫 myenv 的文件夹，里面是隔离的Python环境

2. 激活虚拟环境

Linux/macOS：

bash 复制代码

source myenv/bin/activate

Windows (cmd):

cmd 复制代码

myenv\Scripts\activate.bat

Windows (PowerShell):

powershell 复制代码

myenv\Scripts\Activate.ps1

激活后，命令行前面通常会出现 (myenv)，表示你已经进入虚拟环境。

3. 使用 pip 安装包

激活环境后，运行：

bash 复制代码

pip install requests

安装的包只会在这个虚拟环境中生效，不会影响全局。

4. 退出虚拟环境

bash 复制代码

deactivate

virtualenv 旧版用法（可选）

安装：

bash 复制代码

pip install virtualenv

创建：

bash 复制代码

virtualenv myenv

激活和退出同上。

总结

步骤	命令示例	说明
创建虚拟环境	`python3 -m venv myenv`	创建一个新虚拟环境
激活虚拟环境	`source myenv/bin/activate`	切换到虚拟环境
安装包	`pip install 包名`	在虚拟环境中安装包
退出虚拟环境	`deactivate`	退出虚拟环境回到全局环境

虚拟环境和 pip 配合，能保证你项目的包不会互相影响，是 Python 项目开发和部署的基础。