一、容器

Python中，可包含其他对象的对象，称之为“容器”。

容器是一种数据结构。
常用的容器主要划分为两种：序列（如：列表、元祖等）和映射（如：字典）。 序列中，每个元素都有下标，它们是有序的。 映射中，每个元素都有名称（又称“ 键 ”），它们是无序的。
除了序列和映射之外，还有一种需要注意的容器——“ 集合 ”。

Table of Contents generated with DocToc

• Python语言特性
  • 1 Python的函数参数传递
  • 2 Python中的元类(metaclass)
  • 3 @staticmethod和@classmethod
  • 4 类变量和实例变量
  • 5 Python自省与反射
    • 自省
    • 反射
  • 6 字典推导式
  • 7 Python中单下划线和双下划线
  • 8 字符串格式化:%和.format
  • 9 迭代器和生成器
    • 生成器
    • 迭代器
  • 10 *args and **kwargs
  • 11 面向切面编程AOP和装饰器
  • 12 鸭子类型
  • 13 Python中重载
  • 14 新式类和旧式类
  • 15 __new__和__init__的区别
  • 16 单例模式
    • 1 使用__new__方法
    • 2 共享属性
    • 3 装饰器版本
    • 4 import方法
    • 5 线程安全的单例模式
  • 17 Python中的作用域
  • 18 GIL线程全局锁
    • 先说下python解释器
      • CPython
      • IPython
      • PyPy
      • Jython
      • IronPython
      • 小结
    • 线程全局锁
  • 19 协程
  • 20 闭包
  • 21 lambda函数
  • 22 Python函数式编程
  • 23 Python里的拷贝
  • 24 Python垃圾回收机制
    • 1 引用计数
    • 2 标记-清除机制
    • 3 分代技术
  • 25 Python的List
  • 26 Python的is
  • 27 read,readline和readlines
  • 28 Python2和3的区别(很少问了)
  • 29 super init
  • 30 Python 的dict
  • 31 Python Web
    • Nginx、WSGI、 uWSGI、 uwsgi的区别
      • WSGI
      • uwsgi 和 uWSGI
      • Nginx
      • uWSGI 和 Nginx 的关系
  • 31 Python 内存管理机制
    • 引用计数
      • 引用计数增加
      • 引用计数减少
    • 垃圾回收
    • 内存池机制
    • Python的内存池(金字塔)
  • 32 Python的序列类型
    • 不可变序列类型
    • 可变序列类型
  • 3 面向对象的特点

Python语言特性

1 Python的函数参数传递

看两个例子:

以下是 Python 进程、线程、协程与 Go Goroutine 的核心区别总结，从调度方式、资源消耗、适用场景、性能表现等维度综合对比：

对比表格

核心区别详解

1. 并行与并发能力

• Python 进程：唯一绕过 GIL 的方式，适合多核 CPU 并行计算，但进程间通信（IPC）成本高。
• Python 线程：受 GIL 限制，单核并发，适合简单 I/O 任务（如文件读写），但不适合高并发网络请求。
• Python 协程：单线程内高并发 I/O（如处理 10k+ HTTP 连接），但无法并行利用多核。
• Go Goroutine：多核并行 + 高并发，Goroutine 由 Go 运行时自动调度到多个 CPU 核心，无 GIL 限制。

2. 资源与性能

• 资源消耗：

在 Python 中，线程和进程的实现与操作系统原生概念存在显著差异，主要受 全局解释器锁（GIL） 和 Python 运行时设计的限制。以下是具体对比：

1. 线程（Thread）

操作系统线程

• 本质：内核级线程，由操作系统直接调度，支持多核并行执行。
• 特性：
  • 线程共享进程的内存空间（堆、全局变量等）。
  • 线程切换由操作系统内核管理，开销较小。
  • 可真正并行执行（在多核 CPU 上）。

Python 线程

• 本质：Python 的 threading 模块基于操作系统线程实现，但受 GIL 限制。
• 关键区别：
  • GIL 的存在：同一进程内的所有 Python 线程共享一个 GIL，导致 同一时刻只有一个线程能执行 Python 字节码。
  • 无法真正并行：即使有多核 CPU，Python 线程在 CPU 密集型任务中只能并发（交替执行），无法并行。
  • 适用场景：I/O 密集型任务（如网络请求、文件读写），此时线程在等待 I/O 时会释放 GIL。

示例代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import threading

def cpu_bound_task():
    # CPU 密集型任务（受 GIL 限制）
    sum(range(10**7))

# 多线程执行（实际为并发，无法加速）
threads = [threading.Thread(target=cpu_bound_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

2. 进程（Process）

操作系统进程

• 本质：独立的内存空间和资源，由操作系统隔离管理。
• 特性：
  • 进程间通信（IPC）需通过管道、信号、共享内存等机制。
  • 进程创建和切换开销较大。
  • 不同进程的线程可并行执行在多核 CPU 上。

Python 进程

• 本质：通过 multiprocessing 模块创建，每个进程是独立的 Python 解释器实例。
• 关键区别：
  • 绕过 GIL：每个进程有自己的 GIL，可 真正并行执行 CPU 密集型任务。
  • 内存隔离：进程间不共享内存，需通过 Queue、Pipe 或共享内存（Value/Array）通信。
  • 适用场景：CPU 密集型任务（如数值计算、图像处理）。

示例代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import multiprocessing

def cpu_bound_task():
    # CPU 密集型任务（多进程可并行加速）
    sum(range(10**7))

# 多进程执行（真正并行）
processes = [multiprocessing.Process(target=cpu_bound_task) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()

3. 对比总结

4. 性能优化建议

1. I/O 密集型任务：

1. 设计理念

• Go：

  • 强调静态类型、编译速度和并发编程。
  • 语法简单，几乎没有语法糖，强制代码风格统一（如 gofmt）。

• Python：

  • 强调动态类型、灵活性和开发效率。
  • 语法简洁，支持多种编程范式（面向对象、函数式、过程式）。

2. 类型系统

• Go：
  • 静态类型语言，变量类型在编译时确定。
  • 类型安全，编译时检查类型错误。
  • 不支持泛型（Go 1.18 引入了泛型，但使用受限）。
• Python：
  • 动态类型语言，变量类型在运行时确定。
  • 类型灵活，但运行时可能出现类型错误。
  • 支持泛型（通过类型注解和第三方库实现）。

3. 性能

• Go：
  • 编译为机器码，执行速度快。
  • 内存管理高效，垃圾回收机制优化良好。
  • 适合高并发、高性能场景（如网络服务、微服务）。
• Python：
  • 解释执行，执行速度较慢。
  • 内存管理依赖垃圾回收，性能较低。
  • 适合开发效率优先的场景（如脚本、数据分析、原型开发）。

4. 并发模型

• Go：
  • 内置 goroutine 和 channel，支持轻量级并发。
  • goroutine 是用户级线程，开销小，适合高并发场景。
  • channel 用于 goroutine 之间的通信，避免共享内存的问题。
• Python：
  • 支持多线程、多进程和异步编程（如 asyncio）。
  • 由于全局解释器锁（GIL），多线程无法充分利用多核 CPU。
  • 多进程和异步编程是常见的并发解决方案。

5. 语法

• Go：
  • 语法简洁，强制代码风格统一。
  • 没有类和继承，通过接口和组合实现面向对象。
  • 错误处理通过返回值显式处理（如 err != nil）。
• Python：
  • 语法灵活，支持丰富的语法糖。
  • 支持类和继承，面向对象特性完善。
  • 错误处理通过异常机制（try-except）。

6. 生态系统

• Go：
  • 标准库功能强大，适合网络编程和系统编程。
  • 第三方库数量较少，但质量较高。
  • 工具链完善（如 go build、go test、go mod）。
• Python：
  • 标准库功能丰富，涵盖多种领域。
  • 第三方库数量庞大，覆盖广泛的应用场景（如 Web 开发、数据分析、机器学习）。
  • 包管理工具多样（如 pip、conda）。

7. 应用场景

• Go：
  • 网络服务（如微服务、API 服务）。
  • 系统编程（如命令行工具、操作系统组件）。
  • 高并发、高性能场景（如分布式系统、消息队列）。
• Python：
  • 数据分析与科学计算（如 Pandas、NumPy）。
  • 机器学习与人工智能（如 TensorFlow、PyTorch）。
  • Web 开发（如 Django、Flask）。
  • 脚本与自动化任务。

8. 开发效率

• Go：
  • 编译速度快，适合大型项目。
  • 代码简洁，但开发效率可能不如 Python。
• Python：
  • 开发效率高，适合快速原型开发。
  • 代码易读易写，但性能较低。

单例模式

简介

单例模式是指在内存中只会创建一次对象的设计模式，在程序中多次使用同一个对象且作用相同的时候，为了防止频繁的创建对象，单例模式可以让程序在内存中创建一个对象，让所有调用者都共享这一单例对象。