Python on 测试开发刚哥

比pip快100倍的Python包安装工具

Thu, 05 Feb 2026 00:00:00 +0000

简介

uv是一款开源的Python包安装工具，GitHub star高达56k，以性能极快著称，具有以下特性（官方英文原文）：

🚀 A single tool to replace pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv, and more.
⚡️ 10-100x faster than pip.
🗂️ Provides comprehensive project management, with a universal lockfile.
❇️ Runs scripts, with support for inline dependency metadata.
🐍 Installs and manages Python versions.
🛠️ Runs and installs tools published as Python packages.
🔩 Includes a pip-compatible interface for a performance boost with a familiar CLI.
🏢 Supports Cargo-style workspaces for scalable projects.
💾 Disk-space efficient, with a global cache for dependency deduplication.
⏬ Installable without Rust or Python via curl or pip.
🖥️ Supports macOS, Linux, and Windows.

在Python MCP SDK的介绍中，也出现了We recommend using uv to manage your Python projects的字样，说明uv已经是一款实用性极强的工具。

官网学习之控制流

Wed, 04 Feb 2026 00:00:00 +0000

if

if语句是最常见的控制流：

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
... 
More

for

for语句用来遍历：

## Create a sample collection
users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

## Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

## Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

range

range函数生成数字序列：

跟着官网学习Python系列

Tue, 03 Feb 2026 00:00:00 +0000

开篇

个人而言，Python是写起来最顺手、看起来最喜欢的编程语言，也是实际工作中使用最多的编程语言。从Python入门，到完全使用Java，再回归Python，编程语言本质上是工具，与Excel、XMind无异。对于测试开发来说，要学习的东西很多，Python是可以作为基础技术深入学习的。第1次通过菜鸟教程学习Python，第2次阅读《流畅的Python》学习Python，第3次跟着官网学习Python。该系列文章参考的是Python3.13版本官方教程，期望学习者具有一定编程基础。

Python解释器

终端使用uv安装Python3.13：

uv python install 3.13

查看安装位置：

which python3.13

进入Python解释器：

$ python3.13
Python 3.13 (default, April 4 2023, 09:25:04)
[GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

计算器

平时我们基本不会这样来写Python，但是可以当做计算器来用：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

>>> 4 * 3.75 - 1
14.0

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _  # In interactive mode, the last printed expression is assigned to the variable _
113.0625
>>> round(_, 2)
113.06

Python也很适合用来学习算法，比如最简单的冒泡排序：

Python并发编程从入门到进阶

Mon, 02 Feb 2026 00:00:00 +0000

本文是Python进阶系列专题的最后一篇文章了，学习一下Python并发编程。懂得并发编程，就算是真正进阶了。

Python协程知多少

Sun, 01 Feb 2026 00:00:00 +0000

从概念上来说，我们都知道多进程和多线程，而协程其实是在单线程中实现多并发。从句法上看，协程与生成器类似，都是定义体中包含yield关键字的函数。区别在于协程的yield通常出现在表达式的右边：datum = yield。这一下就让初学者瞬间觉得yield关键字不香了，本来以为yield就是简简单单的暂停执行顺手返回个值，结果还能放右边？

Python上下文管理器

Sat, 31 Jan 2026 00:00:00 +0000

with语句会设置一个临时的上下文，交给上下文管理器对象控制，并且负责清理上下文。

长篇大论Python生成器

Fri, 30 Jan 2026 00:00:00 +0000

Python生成器是什么

一句话解释：包含了yield关键字的函数就是生成器，它的返回值是一个生成器对象。我简单画了个示意图：

yield相当于return。
函数遇到yield就暂停，保存当前信息，返回yield的值。
在下次执行next()时，从当前位置继续执行。

生成器函数的工作原理

先通过一个简单示例来说明生成器的行为：

## 定义一个生成器
>>> def gen_123():
...     yield 1
...     yield 2
...     yield 3
...

## 生成器本身是个函数
>>> gen_123
<function gen_123 at 0x0000019F60710790>

## 返回值是生成器对象
>>> gen_123()
<generator object gen_123 at 0x0000019F606AC040>

## 生成器也是迭代器
>>> for i in gen_123():
...     print(i)
...     
1
2
3

## 验证生成器也是迭代器，定义迭代器g
>>> g = gen_123()

## 可以通过next()获取yield生成的下一个元素
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
StopIteration

生成器的原理就是：

生成器函数会创建一个生成器对象。
把生成器传给next()函数时，生成器函数会执行函数定义体中的下一个yield语句，返回产出的值，并在当前位置暂停。
函数的定义体返回时，外层的生成器对象会抛出StopIteration异常

yield关键字一般是和for循环搭配使用的，在for循环中会隐式调用next()函数。

Python可迭代的对象与迭代器的对比

Thu, 29 Jan 2026 00:00:00 +0000

什么是迭代？迭代是指按需一次获取一个数据。是否可以迭代，可以通过是否可以使用for循环取值来进行简单的判断。更准确的判断是使用iter()函数，这是一个Python内置函数。

Python抽象基类的定义与使用

Wed, 28 Jan 2026 00:00:00 +0000

我们写Python基本不需要自己创建抽象基类，而是通过鸭子类型来解决大部分问题。《流畅的Python》作者使用了15年Python，但只在项目中创建过一个抽象基类。我们更多时候是创建现有抽象基类的子类，或者使用现有的抽象基类注册。本文的意义在于，了解抽象基类的定义与使用，可以帮助我们理解抽象基类是如何实现的，为我们以后学习后端语言（比如Java、Golang）打下基础。**毕竟抽象

Python中的接口协议和抽象基类

Tue, 27 Jan 2026 00:00:00 +0000

Python接口与协议

Python语言是没有interface关键字的，这也是动态类型语言的特点之一。Python的接口指的是类实现或继承的公开属性，包括数据或方法。比如Sequence的正式接口如下图所示：

这些都叫做Python接口。事实上，Python每个类都有接口，除了抽象基类。

接口是正式的，它定义了类具有哪些属性，协议是非正式的接口，只由文档和约定定义。比如只要类实现了__getitem__方法，按照序列协议的约定，Python就会支持这个类完成访问元素、迭代和使用in运算符等一系列操作。

猴子补丁

我们可以通过猴子补丁来进一步认识，Python中协议的约定是怎么回事。猴子补丁是这样一种技术：在运行时修改类或模块，而不改动源码。还是以序列协议来举例，比如：

>>> from random import shuffle
>>> from frenchdeck import FrenchDeck
>>> deck = FrenchDeck()
>>> shuffle(deck)

假设运行报错了：TypeError: 'FrenchDeck' object does not support item assignment，因为FrenchDeck类只有__getitem__方法，只实现了不可变的序列协议。为了解决这个报错，需要通过__setitem__方法实现可变的序列协议。

代码如下：

def set_card(deck, position, card):
    deck._cards[position] = card

FrenchDeck.__setitem__ = set_card
shuffle(deck)

这就是一段猴子补丁技术的实现代码，没有修改FrenchDeck类的源码，而是在运行时动态修改。

抽象基类

Python的抽象基类是指必须让继承它的子类去实现它所要求的方法的类。Python的collections.abc模块中就定义了很多抽象基类：

虽然我们在实际编程中并不会自己编写抽象基类（一般也不建议这样做，因为可能会导致意想不到的问题），但是了解抽象基类，可以帮助我们更好理解Python面向对象的继承等概念。

抛开枯燥的理论知识，我在书中找到了一处具有实践价值的片段：

「在一连串if/elif/elif中使用isinstance做检查，然后根据对象的类型执行不同的操作，通常是不好的做法；此时应该使用多态，即采用一定的方式定义类，让解释器把调用分派给正确的方法，而不使用if/elif/elif块硬编码分派逻辑。」

交流群和公司都有人问过我这个问题，写了太多的ifelse有没有更好的实现方式，我想这里已经给出了答案。

鸭子类型和白鹅类型

Python鸭子类型是指对象的类型无关紧要，只要实现了特定的协议即可。它的好处是避免过多的isinstance，如果遵守既定协议，能增加利用现有的标准库和第三方代码的可能性。示例：

class Animal(object):
    
    def run(self):
        print("The animal is running...")

class Dog(Animal):

    def run(self):
        print('The dog is running...')

class Cat(Animal):

    def run(self):
        print('The cat is running...')

def make_run(animal):
    animal.run()

dog = Dog()
cat = Cat()
make_run(dog)
make_run(cat)

对于 make_run() 函数来说，传入的参数并不一定需要是 Animal 类型的，只需要保证传入的对象有一个 run() 方法即可。

Python如何设计面向对象的类（下）

Mon, 26 Jan 2026 00:00:00 +0000

本文将在上篇文章二维向量Vector2d类的基础上，定义表示多维向量的Vector类。

Python如何设计面向对象的类（上）

Sun, 25 Jan 2026 00:00:00 +0000

Python是一门高级语言，支持面向对象设计，如何设计一个符合Python风格的面向对象的类，是一个比较复杂的问题，本文提供一个参考，表达一种思路，探究一层原理。

Python变量小秘密

Sat, 24 Jan 2026 00:00:00 +0000

变量全都是引用

跟其他编程语言不同，Python的变量不是盒子，不会存储数据，它们只是引用，就像标签一样，贴在对象上面。

比如：

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]
>>> b is a
True

a变量和b变量引用的是同一个列表[1, 2, 3]。b可以叫做a的别名。

比较来看：

>>> a = [1, 2, 3]
>>> c = [1, 2, 3]
>>> c == a
True
>>> c is a
False

c引用的是另外一个列表，虽然和a引用的列表的值相等，但是它们是不同的对象。

浅复制与深复制

浅复制是指只复制最外层容器，副本中的元素是源容器中元素的引用。如果所有元素都是不可变的，那么这样没有问题，还能节省内容。但是，如果有可变的元素，那么结果可能会出乎意料之外。构造方法或[:]做的都是浅复制。

示例：

>>> x1 = [3, [66, 55, 44], (7, 8, 9)]
## x2是x1的浅复制
>>> x2 = list(x1)

## 不可变元素没有影响
>>> x1.append(100)
>>> x1
[3, [66, 55, 44], (7, 8, 9), 100]
>>> x2
[3, [66, 55, 44], (7, 8, 9)]  

## x1[1]是列表，可变元素会影响x2
## 因为它们引用的是同一个对象
>>> x1[1].remove(55)
>>> x1
[3, [66, 44], (7, 8, 9), 100]
>>> x2
[3, [66, 44], (7, 8, 9)]  

## x2[1]也会反过来影响x1
>>> x2[1] += [33, 22]
>>> x1
[3, [66, 44, 33, 22], (7, 8, 9), 100]  
>>> x2
[3, [66, 44, 33, 22], (7, 8, 9)]

## 不可变元组也不会有影响
## +=运算符创建了一个新元组
>>> x2[2] += (10, 11)
>>> x1
[3, [66, 44, 33, 22], (7, 8, 9), 100]  
>>> x2
[3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]

深复制是指我们常规理解的复制，副本不共享内部对象的引用，是完全独立的一个副本。这可以借助copy.deepcopy来实现。

Python编解码问题与文本文件处理

Fri, 23 Jan 2026 00:00:00 +0000

编解码器

在字符与字节之间的转换过程称为编解码，Python自带了超过100种编解码器，比如：

ascii（英文体系）
gb2312（中文体系）
utf-8（全球通用）
latin1
utf-16

这些编解码器可以传给open()、str.encode()、bytes.decode()等函数的encoding参数。

UnicodeEncodeError

多数非UTF编解码器（比如cp437）只能处理Unicode字符的一小部分子集。把字符转换成字节时，如果目标编码中没有定义这个字符，那么就会抛出UnicodeEncodeError异常。

处理方式一：使用utf8编码。

处理方式二：添加errors参数：

## 忽略 如b'So Paulo'
city.encode("cp437", errors="ignore")
## 替换为? 如b'S?o Paulo'
city.encode("cp437", errors="replace")
## 替换为XML实体 如b'S&#227;o Paulo'
city.encode("cp437", errors="xmlcharrefreplace")

UnicodeDecodeError

把字节转换为字符时，遇到无法转换的字节时会抛出UnicodeDecodeError异常。这是因为不是每个字节都包含有效的ASCII字符，也不是每个字符都是有效的UTF-8。

处理方式也有两种，跟上面一样。

SyntaxError

Python3默认使用UTF-8编码源码。如果加载的.py模块中包含UTF-8之外的数据，而且没有声明编码，就会抛出SyntaxError异常。

处理方式是在文件顶部添加coding注释：

## coding: cp1252

但是这个办法并不好，最好还是找到这些报错字符，把它们转换为UTF-8。

处理文本文件

Unicode三明治：

在程序中尽量少接触二进制，把字节解码为字符，只处理字符串对象。比如在Django中，view应该输出Unicode字符串，Django会负责把响应数据编码成字节序列，而且默认使用UTF-8编码。

Python内置的open函数就是采用了这个原则，在读取文件时会做必要的解码，以文本模式写入文件时会做必要的编码。

文件乱码

Windows更容易遇到这个问题，因为Windows并不是统一的UTF-8编码，比如在Windows10中：

>>> open("cafe.txt", "w", encoding="utf8").write("café")
4
>>> open("cafe.txt").read()
'caf茅'

写入文件时指定了utf8，但是读取文件没有指定，Python就会使用系统默认编码：

>>> import locale
## 打开文件用这个
## 如果没有设置PYTHONENCODING环境变量，sys.stdout/stdin/stderr也用这个
>>> locale.getpreferredencoding()
'cp936'

cp936把最后一个字节解码成了茅而不是é。

>>> import sys
# 二进制数据和字符串之间转换用这个
>>> sys.getdefaultencoding()
'utf-8'

>>> import sys
# 文件名（不是文件内容）用这个
>>> sys.getfilesystemencoding()
'utf-8'

GNU/Linux或Mac OS X不会遇到这个问题，因为多年来它们的默认编码都是UTF-8。

Python字符与字节新编

Thu, 22 Jan 2026 00:00:00 +0000

字符

字符是一个信息单位，简单来讲就是一个字母、数字、标点符号、汉字等。

字符的最佳定义是Unicode字符：

它是一个全球化的标准，能表示世界上所有语言的字符。Unicode字符的标识（码位）是以4~6个十六进制数字表示的，并且加前缀U+。

字节

字节是计算机信息计量单位，一个字节代表八个比特，存储的数值范围为0~255。

字节是机器的，字符是人类的。

把人类字符转换为机器字节时使用的算法叫做编码，反之叫做解码。

算法不同，字节与字符的关系也不同：

bytes和bytearray

字节实际上是个二进制序列。不可变bytes类型和可变bytearray类型是用来存储二进制序列的，它们的示例如下：

>>> cafe = bytes("café", encoding="utf_8")
>>> cafe
b'caf\xc3\xa9'
>>> cafe[0]
99
>>> cafe[:1]
b'c'
>>> cafe_arr = bytearray(cafe)
>>> cafe_arr
bytearray(b'caf\xc3\xa9')
>>> cafe_arr[-1:]
bytearray(b'\xa9')

特别的是cafe[0]返回了整数，cafe[:1]返回了二进制序列，这是因为s[0] == s[:1]只对str类型成立，而对于其他类型来说，s[i]返回一个元素，s[i:i+1]返回一个相同类型的序列。

二进制序列实际上是整数序列。它们的字面量表示法包含ASCII字符（ASCII只能表示英文体系的字符），比如cafe的b'caf\xc3\xa9'，具体规则是：

从空格到~的字符直接使用ASCII字符
制表符\t、换行符\n、回车符\r、转义符\\
其他字符用十六进制转义序列，比如\x00空字节

构建bytes和bytearray对象的方式有以下几种：

一个str对象和一个encoding关键字参数
一个可迭代对象，数值在0~255
一个实现了缓冲协议的对象，如bytes、bytearray、memoryview、array.array

memoryview和struct

memoryview允许在二进制数据结构之间共享内存，struct能从序列中提取结构化信息。

示例如下，提取一个GIF图像的宽度和高度：

import struct

with open("filter.gif", "rb") as fp:
    img = memoryview(fp.read())

## 这里不会复制字节序列，因为用的memoryview
header = img[:10]
print(bytes(header))  # b'GIF89a+\x02\xe6\x00'

## <是小字节序，3s3s是两个3字节序列，HH是两个16位二进制整数
## 类型、版本、宽度、高度
struct.unpack("<3s3sHH", header)  # (b'GIF', b'89a', 555, 230)

## 删除引用，释放memoryview实例所占的内存
del header
del img

小结

本文介绍了字符和字节的概念以及它们之间的关系，一个字符对应一个或多个字节。字符是人类的，字节是机器的，编码就是人类字符转换为机器字节，反之叫做解码。然后分别介绍了二进制序列的类型bytes和bytearray，和二进制序列的工具memoryview和struct。

Python函数装饰器高级用法

Wed, 21 Jan 2026 00:00:00 +0000

在了解了Python函数装饰器基础知识和闭包之后，开始正式学习函数装饰器。

关于Python闭包的一切

Tue, 20 Jan 2026 00:00:00 +0000

任何把函数当做一等对象的语言，它的设计者都要面对一个问题：作为一等对象的函数在某个作用域中定义，但是可能会在其他作用域中调用，如何处理自由变量？

Python函数装饰器基础知识

Mon, 19 Jan 2026 00:00:00 +0000

函数装饰器是Python语言最优秀的设计之一，它以非常简洁的方式增强了函数的行为，让崎岖不平之路变得平坦顺畅。

Python设计模式知多少

Sun, 18 Jan 2026 00:00:00 +0000

设计模式

设计模式是前辈们经过相当长的一段时间的试验和错误总结出来的最佳实践。我找到的资料列举了以下这些设计模式：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式、适配器模式、桥接模式、过滤器模式、组合模式、装饰器模式、外观模式、享元模式、代理模式、责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、空对象模式、策略模式、模板模式、访问者模式、MVC模式、业务代表模式、组合实体模式、数据访问对象模式、前端控制器模式、拦截过滤器模式、服务定位器模式、传输对象模式，共33种。

这些设计模式在纯面向对象编程语言中使用最多。**Python拥有一等函数，既不需要使用某些设计模式，也减少了某些设计模式样板代码。**本文将使用一等函数实现策略模式和命令模式，研究Python代码是如何简化的。

策略模式

策略模式概述：“定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。”

经典实现

示例，根据客户的属性或订单中的商品计算折扣，规则如下：

有1000或以上积分的客户，每个订单享5%折扣。
同一订单中，单个商品的数量达到20个或以上，享10%折扣。
订单中的不同商品达到10个或以上，享7%折扣。

这很适合用策略模式来做，UML类图设计如下：

上下文，集成算法的类，图中Order会根据不同的算法计算折扣。
策略，实现不同算法的组件的共同接口，图中Promotion是个抽象类。
具体策略，策略的具体子类，图中FidelityPromo、BulkItemPromo、LargeOrderPromo分别对应上面3条计算折扣规则。

代码实现如下：

from abc import ABC, abstractmethod
from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')


class LineItem:

    def __init__(self, product, quantity, price):
        self.product = product
        self.quantity = quantity
        self.price = price

    def total(self):
        return self.price * self.quantity


class Order:  # the Context

    def __init__(self, customer, cart, promotion=None):
        self.customer = customer
        self.cart = list(cart)
        self.promotion = promotion

    def total(self):
        if not hasattr(self, '__total'):
            self.__total = sum(item.total() for item in self.cart)
        return self.__total

    def due(self):
        if self.promotion is None:
            discount = 0
        else:
            discount = self.promotion.discount(self)
        return self.total() - discount

    def __repr__(self):
        fmt = '<Order total: {:.2f} due: {:.2f}>'
        return fmt.format(self.total(), self.due())


class Promotion(ABC):  # the Strategy: an Abstract Base Class

    @abstractmethod
    def discount(self, order):
        """Return discount as a positive dollar amount"""


class FidelityPromo(Promotion):  # first Concrete Strategy
    """5% discount for customers with 1000 or more fidelity points"""

    def discount(self, order):
        return order.total() * .05 if order.customer.fidelity >= 1000 else 0


class BulkItemPromo(Promotion):  # second Concrete Strategy
    """10% discount for each LineItem with 20 or more units"""

    def discount(self, order):
        discount = 0
        for item in order.cart:
            if item.quantity >= 20:
                discount += item.total() * .1
        return discount


class LargeOrderPromo(Promotion):  # third Concrete Strategy
    """7% discount for orders with 10 or more distinct items"""

    def discount(self, order):
        distinct_items = {item.product for item in order.cart}
        if len(distinct_items) >= 10:
            return order.total() * .07
        return 0

实现策略模式的关键代码是Promotion类，它是一个抽象基类，通过继承abc.ABC来定义。

Python函数参数和注解是什么

Sat, 17 Jan 2026 00:00:00 +0000

四种参数

Python函数func定义如下：

def func(first, *args, second="Hello World", **kwargs):
    print(first)
    print(args)
    print(second)
    print(kwargs)


func("dongfanger", "san", py="good")

运行后会输出：

dongfanger
('san',)
Hello World
{'py': 'good'}

它有四种参数：

first是定位参数，positional parameter，不可省略。
*args是可变参数，arguments，存入元组。
second是默认值参数，default argument values，可以省略。
**args是关键字参数，keyword arguments，存入字典。

func函数的调用方式有以下这些：

①传入单个定位参数。

func("dongfanger")

dongfanger
()
Hello World
{}

②第一个参数后的任意个参数会被*args捕获，存入一个元组。

func("dongfanger", "a", "b", "c")

dongfanger
('a', 'b', 'c')
Hello World
{}

③没有明确指定名称的关键字参数会被**kwargs捕获，存入一个字典。

func("dongfanger", j="1", k="2")

dongfanger
()
Hello World
{'j': '1', 'k': '2'}

④second只能作为关键字参数传入。

func("dongfanger", second="cool")

dongfanger
()
cool
{}

⑤定位函数也能作为关键字参数传入。

func(first="san")

san
()
Hello World
{}

⑥字典前加上**，其所有元素作为单个参数传入，同名键会绑定到对应具名参数上，余下的被**args捕获。

原来Python函数只是个对象

Fri, 16 Jan 2026 00:00:00 +0000

写Python越多，写函数越多，于是乎有人觉得Python是函数式语言，其实不然，Python只是从函数式语言中借鉴了一些好的想法而已。

深度剖析Python字典和集合（下）

Thu, 15 Jan 2026 00:00:00 +0000

集合

集合的字面量是{1}、{1, 2}，和字典有点像，不同的是集合只有值没有键。

set构造方法

set构造方法如下：

my_set = {1, 2, 3}
my_set = set([1, 2, 3])

前者比后者更快更易读，因为对于前者，Python会利用一个专门的叫做BUILD_SET的字节码来创建集合。而对于后者，Python必须先从set这个名字来查询构造方法，然后新建一个列表，最后再把这个列表传入到构造方法里。

集合也有集合推导：

>>> my_set = {x for x in range(1, 4)}
>>> my_set
{1, 2, 3}
>>> type(my_set)
<class 'set'>

集合还有个不可变类型叫做frozenset，如同元组之于列表，它的构造函数如下：

>>> frozenset(range(10))
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

集合的操作

集合的本质是许多唯一对象的聚集，它最常见的操作是用来去重：

>>> my_list = [1, 2, 2, 3]
>>> set(my_list)
{1, 2, 3}
>>> list(set(my_list))
[1, 2, 3]

除此之外，集合还能进行数学运算，比如求交集、并集、差集等。示例，求needles的元素在haystack里出现的次数，暴力解法：

found = 0
for n in needles:
    if n in haystack:
        found += 1

集合解法：

found = len(needles & haystack)

即使不是set也能先转换为set：

found = len(set(needles) & set(haystack))

## 另一种写法
found = len(set(needles).intersection(haystack))

集合支持的操作如下：

散列表揭秘

这一部分的内容略微有点硬，请注意提前喝点水！

从上篇的简介可以知道，散列表就是一张表，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录。散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组），散列表里的单元叫作表元，在dict的散列表中，每个键值对占用一个表元，每个表元有两个部分，一个是对键的引用，另一个是对值的引用，因为所有表元的大小一致，所以可以通过偏移量来读取某个表元。

为什么要用稀疏数组？举个例子，身份证号411697199702076425，如果把它作为键存储到数组中，虽然能用O(1)时间就找到，但是需要开辟一个999999999999999999大的空间。假如只有1的空间，就只能把最后一位作为键存储到数组中，多个身份证号的键就容易冲突，得多看n位才能找到，要用O(n)时间。空间既不能太大，也不能太小，需要结合时间，在两者之间产生一个平衡，即空间和时间的平衡，所以要用稀疏数组！

Python会设法保证大概还有三分之一的表元是空的，用空间换时间，提高散列表查询效率。如果剩余空间不足，原有的散列表会被复制到一个更大的空间里面。

散列表的键值，又称为散列值，Python中可以用hash()方法来计算所有内置类型对象的散列值。

如果两个对象在比较的时候是相等的，那么它们的散列值必须相等，否则散列表就不能正常运行了：

>>> a = 1
>>> b = 1
>>> a == b
True
>>> hash(a)
1
>>> hash(b)
1
>>> a = "x"
>>> b = "x"
>>> a == b
True
>>> hash(a)
706802421
>>> hash(b)
706802421

越是相似但不相等的对象，它们的散列值的差别越大：

深度剖析Python字典和集合（上）

Wed, 14 Jan 2026 00:00:00 +0000

“字典这个数据结构活跃在所有Python程序的背后，即便你的源码里并没有直接用到它”，摘抄自《代码之美》第18章Python的字典类：如何打造全能战士。字典是Python语言的基石！在函数的关键字参数、实例的属性和模块的命名空间都能够看到它的身影，我们自己写代码时也经常会用到。

序列赋值引发的Python列表陷进

Tue, 13 Jan 2026 00:00:00 +0000

序列赋值是Python默认操作，如果使用不当，有可能会掉入语法陷阱。

能取值亦能赋值的Python切片

Mon, 12 Jan 2026 00:00:00 +0000

切片，就像面包，给几刀，切成一片一片，可以做成吐司，也可以做成三明治，口味更佳：

Python元组拆包捡到8倍镜快准狠

Sun, 11 Jan 2026 00:00:00 +0000

元组拆包

元组是不可变列表，列表是通过索引取值的，元组也是：

tuple_test = (1, 2, 3)
a = tuple_test[0]
b = tuple_test[1]
c = tuple_test[2]

但Python是出了名的一行代码解决问题，元组拆包就是精髓技术之一：

a, b, c = tuple_test

print("%s %s %s" % tuple_test)

把元组一一对应拆出来，就叫做元组拆包。拆包有个要求，元组中的元素数量必须跟接受这些元素的空挡数一致，否则会报错：

tuple_test = (1, 2, 3)
a, b = tuple_test  # ValueError: too many values to unpack (expected 2)

_占位符

使用_占位符可以解决这个问题：

tuple_test = (1, 2, 3)
a, b, _ = tuple_test

这样就只获取到部分数据了，这在取函数返回值时特别有用，比如：

import os

_, filename = os.path.split("/home/dongfanger/.ssh/idrsa.pub")
print(filename)  # "idrsa.pub"

*前缀

当返回值特别多时，_占位符写起来麻烦，可以用*来处理剩下的元素：

>>> a, b, *rest = range(5)
>>> a, b, *rest
(0, 1, [2, 3, 4])

注意rest是个列表，如果没有足够元素，会返回空列表：

>>> a, b, *rest = range(2)
>>> a, b, *rest
(0, 1, [])

*前缀变量能放在任意位置，比如，放在中间：

>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)

放在前面：

Python数据模型与Python对象模型

Sat, 10 Jan 2026 00:00:00 +0000

数据模型==对象模型

Python官方文档说法是“Python数据模型”，大多数Python书籍作者说法是“Python对象模型”，它们是一个意思，表示“计算机编程语言中对象的属性”。这句话有点抽象，只要知道对象是Python对数据的抽象，在Python中万物皆对象就可以了。

对象三要素

对象有三个要素：编号（identity）、类型（type）、值（value）。

identity

编号就是对象的内存地址，从创建后就不会改变。is运算符用来比较2个对象的编号。id()函数返回对象编号的整数表示。

type

类型决定了可以对对象做哪些操作，也定义了对象的可能值，比如int和bool类型的值就不一样。type()函数返回对象类型。很多人会误以为Python是弱类型语言，其实Python是强类型语言，这个误解的真实原因是，Python不需要编译，不需要提前知道变量的类型，在运行时才检查类型，这应该叫做动态语言。

类型在创建后也不会改变，虽然可以进行类型转换，但转换实际会产生新对象：

a = 1
print(id(a))
print(id(str(a)))
print(id(a))

结果为：

140715000207008
2136059506160
140715000207008

value

对象三要素中唯一能改变的就只有值了。官网有一句正确的废话：允许改变值的对象是mutable（可变的），不允许改变值的对象是immutable（不可变的）。它的意义在于当不可变对象的值是对可变对象的引用时，该如何判断对象的可变性？结论是不可变对象仍然是不可变的，因为这个引用是不能变的，但是我们通常会认为这个不可变对象的值是可变的，尤其是对象容器。对象类型也会决定是否可变，比如numbers、strings、tuples是不可变的，dictionaries、lists是可变的。

对象容器

有些对象包含了对其他对象的引用，这叫做containers对象容器，比如tuples、lists、dictionaries。大多数情况下，我们说容器的值，说的是引用的对象的值，而不是引用编号。但讨论容器可变性时，则仅仅是指容器直接包含的引用编号。比如tuple是不可变的，如果它包含了对一个可变对象的引用后，当该可变对象改变时容器的值也会改变。

对象回收

对象不会被显式销毁，但是它们会被当做垃圾回收，只要不存在对象引用，这就是Python垃圾回收机制！垃圾回收机制比较复杂，比如循环引用，实际上已经没有使用了，但是还存在引用等，涉及到算法规则，等写完Python进阶，在写Python原理时做进一步研究。

Python垃圾回收机制不是银弹，不能解决所有问题，所以在引用外部资源，比如打开文件后，我们需要注意显式close，防止资源始终占用内存，无法释放，造成内存泄漏。close除了手动调用close()方法外，也可以使用with来自动close。

类型决定一切

对象的类型几乎决定了对象的一切行为，甚至是对象编号，比如对于不可变类型：

a = 1
b = 1

a和b可能会指向同一个值为1的对象，也可能会指向两个不同的值为1的对象，这取决于具体实现。

但是对于可变类型：

c = []
d = []

c和d一定会指向两个不同的单独的空列表。

小结

Python数据模型就是常说的对象模型，万物皆对象，有编号、类型、值三个要素。了解了对象模型后，Python另一个重要概念即将浮出水面，它就是数据结构。

Python骚操作从列表推导和生成器表达式开始

Fri, 09 Jan 2026 00:00:00 +0000

序列

序列是指一组数据，按存放类型分为容器序列与扁平序列，按能否被修改分为不可变序列与可变序列。

容器序列与扁平序列

容器序列存放的是对象的引用，包括list、tuple、collections.deque。

扁平序列存放的是对象的值，包括str、bytes、bytearray、memoryview和array.array。

不可变序列与可变序列

不可变序列，包括tuple、str、bytes。

可变序列，包括list、bytearray、array.array、collection.deque、memoryview。

下图左边是父类，右边是子类，可以看出可变序列是从不可变序列继承来的，扩展了可变方法：

列表推导

Python语言魅力在于简洁，这能从最常见的创建列表体现出来，比如我们想把字符串"abc"转换成新列表["a", "b", "c"]，常规写法：

symbols = "abc"
codes = []
for symbol in symbols:
    codes.append(symbol)
print(codes)  # ["a", "b", "c"]

用到了for循环和列表append方法。实际上可以不用append方法，直接：

symbols = "abc"
codes = [symbol for symbol in symbols]

这叫做列表推导，是更加Pythonic的写法。

无论是编写效率还是可阅读性，列表推导都更胜一筹，可以说是构建列表的快捷方式。但是不能滥用，通用原则是，如果列表推导的代码超过了两行，就要考虑用append了。这不是规定，完全可以凭借自我喜好来选择。

笛卡尔积是指多个序列中元素所有组合，我们用列表推导来实现笛卡尔积：

colors = ["black", "white"]
sizes = ["S", "M", "L"]
tshirts = [(color, size) for color in colors for size in sizes]

一行代码搞定！Life is short，use Python，list comprehension is wonderful，amazing。

魔法方法推开Python进阶学习大门

Thu, 08 Jan 2026 00:00:00 +0000

热爱Python

Python是Guido van Rossum设计出来的让使用者觉得如沐春风的一门编程语言。2020年11月12日，64岁的Python之父宣布由于退休生活太无聊，自己决定加入Microsoft的DevDiv Team，致力于“确保更好地使用Python”。尽管在国内有些声音在Diss着Python，认为它太简单，只是个脚本语言，但是它的发明者对Python的热情，仍然激励着我们坚持对Python的热爱。

奇迹时刻

collection.len()是面向对象语言的写法，len(collection)是Python语言的写法，这种风格叫做Pythonic。从前者到后者，就像变魔术一样，一瞬间让人眼前一亮。这个魔术就是Python魔法方法，或者叫双下方法，它是用双下划线开头和双下划线结尾的特殊方法，比如obj[key]，Python解释器实际上会转换成obj.__getitem__(key)来运行，但是使用者并无感知。

`getitem`和`len`

__getitem__用来获取数据，__len__用来返回长度，这2个魔法方法是Python基础，我们通过一副扑克牌来了解：

import collections

# 定义一副牌
Card = collections.namedtuple('Card', ['rank', 'suit'])

class FrenchDeck:
    # 大小
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    # 花色
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        # 生成一副牌
        self._cards = [Card(rank, suit) for suit in self.suits
                                        for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

本来我们对这副牌什么都不能做，但是由于实现了__len__，可以使用len()函数查看有多少张牌：

>>> len(deck)
52

由于实现了__getitem__，可以使用中括号索引取值：

>>> deck[0]
Card(rank='2', suit='spades')

能进行切片：

>>> deck[:3]
[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), Card(rank='4', suit='spades')]
>>> deck[12::13]
[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'), Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]

能迭代：

从函数到包的Python代码层次

Wed, 07 Jan 2026 00:00:00 +0000

代码层次

Python是一门脚本语言，新建一个.py文件，写点代码，就可以跑起来了，无论放哪都可以。比如where.py文件：

print("Where am I?")

那么问题来了，这是写在哪里的呢？为了一目了然，我们用“导游图”的视角来看看代码层次：

红色箭头指出了，是写在模块中的，原来一个.py文件就是一个模块。模块中可以写函数和类，模块可以放在包中。

函数

Python中最出名的函数一定是print()了，毕竟全世界都在用它say Hello World。Python函数其实和数学中的函数很像，比如y = f(x)。有函数名字、输入和输出。Python的函数结构如下：

函数通过def关键字来定义：

def 函数名（参数列表）:
    函数体

参数列表有就有，无则无，多个参数用逗号分隔。例如：

def hello() :
    print("Hello World!")

hello()  # 调用函数

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

调用函数，不需要再加def，直接函数名（参数列表）即可。参数既可以是变量，也可以是其他函数，只要能一一对应。return关键字用来返回值。return不是必需的，如果没有，那么函数会把内部代码全部都执行完再退出，如果有，函数会在return语句立刻退出，同时返回return语句的值，例如：

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
   print("这里不会执行！")
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

类

为什么还要写类，函数它不香么？这个问题有点大，我只能简单解释一下，那就是因为，类是包括了函数的，如果有一天你发现函数不够用了，那么可以用类试试，哈哈哈。

条件循环语句组成了Python代码的骨架

Tue, 06 Jan 2026 00:00:00 +0000

条件控制

我们都知道流程图是有多个分支的，程序中也是如此，在Python中是用if语句来判断程序该走哪个分支的。它的执行过程如下：

代码执行过程如下

if

if语句的一般形式如下：

if condition_1:
    statement_block_1

如果condition_1为True，执行statement_block_1。

condition_1是条件表达式，由各种运算符和数据类型组成，条件表达式的结果可以是True/False的布尔值，也可以是非布尔值。Python中的0、None、空列表、空字典等都会被认为是False，反之都会被认为是True。

else

else语句在条件为False时执行：

if condition_1:
    statement_block_1
else:
    statement_block_2

如果condition_1为True，执行statement_block_1。
如果condition_1为False，执行statement_block_2。

elif

if…else实现了“如果满足条件，那么xxx，否则xxx”，除此之外，还可以用elif实现多个连续判断，分别执行不同的语句：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果condition_1为True，执行statement_block_1。
如果condition_1为False，再判断，如果condition_2为True，执行statement_block_2。
否则，执行statement_block_3。

elif可以写多个。这种写法的执行顺序是从上往下，只要满足了某个if或elif的条件，就会在当前分支执行后跳出去，不再执行后面的判断，如果每个if或elif的条件都是False，最后就会执行else。

if嵌套

假如想满足if或elif的条件后，继续做判断，那么就需要进行if语句嵌套，让statement_block_1等代码块也包含if语句：

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

示例：

你知道Python基本数据类型是哪6个么

Mon, 05 Jan 2026 00:00:00 +0000

Python 是强类型语言，在学习 Python 时，有必要了解 Python 有哪些基本数据类型，一共 6 个：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）。数据类型的知识是非常多的，一篇文章讲不明白，本文仍然属于入门系列，内容主要是基础简介。

Python运算符可不只有加减乘除

Sun, 04 Jan 2026 00:00:00 +0000

数学里面的加减乘除，就是运算符，但是 Python 的运算符更多样，更复杂，分为算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符、身份运算符。为了更直观的看到运算符的使用，本文采用代码和注释结合的方式进行讲解。

用PyCharm打个专业的招呼

Sat, 03 Jan 2026 00:00:00 +0000

PyCharm 是什么

PyCharm（读作“拍恰姆”）是 JetBrains 全家桶中的一员，专门用来写 Python 的：

官方网址是：

https://www.jetbrains.com/pycharm/

for Professional Developers，顾名思义，它是为专业开发者而生的。

版本选择

PyCharm 有 2 个版本：

左边的 Professional 是专业版，需要付（ po ）费（ jie ）。右边的 Community 是社区版，永久免费。一般社区版够用了。我用的是专业版，看着齐全。

打开 PyCharm

安装完成后，打开：

不需要导入配置，点击 OK 按钮：

有 2 个主题，个人偏好左边这种，酷酷的。点击左下角 Skip Remaining and Set Defaults 跳过插件安装，进入主界面（专业版破解后才能看到这个界面，具体破解方法网上贼多）：

首次打开，还没有创建项目，会出现引导页。选择 New Project：

这是专业版的界面，社区版会简略一点。选择好存放目录后，还需要配置解释器。点击解释器右边的 ... ，切换到 System Interpreter，选择已经安装好的 Python：

OK 后再点击 Create，来了：

老手可以勾选 Tip of the Day 左小角 Don't show tips。

真香，理解记忆法学习Python基础语法

Fri, 02 Jan 2026 00:00:00 +0000

这篇文章很难写！我最开始学 Python，和大多数人一样，是看的菜鸟教程：

如何让文科生5分钟写上Python

Thu, 01 Jan 2026 00:00:00 +0000

序言

这篇文章是转型后发表的第一篇文章，有必要先聊一下我的写文计划。

串行文章和并行文章

我会按照发文顺序分为串行文章和并行文章。Python 语言本身的内容，我会按照入门、进阶、原理的顺序依次展开。由于我的水平有限，为了保证质量不乱讲，我选择站在巨人的肩膀上进行二次创作。入门篇主要参考菜鸟教程的基础教程部分。进阶篇主要参考《流畅的Python》这本书，我是买了实体书的，计划后面会送出来，虽然有些破旧，还望不要嫌弃（当时买的时候书页就坏了，京东还赔了我 1000 京豆）。原理篇主要参考官方文档以及外网资料，有一说一，国外资料确实更多更专业，只不过都是英文的，还好现在已经适应了。Django、算法、pytest、tep、测试成长小说等系列专题会并行发表，也包括其他单篇文章。这两天了解到 Python 之父 Guido van Rossum 从 Google 退休后，又加入微软继续搞 Python 了。有点意思。

有啥不一样？

Python 文章和视频都非常多，我就在想我写的东西对读者而言价值到底在哪？我不是搞培训的，也不是做教程，内容会更偏向于学习笔记和实用经验。看我的文章，说不定能把以前遗漏或遗忘的知识点再次补上。同时我已经有一段时间的写作经验了，我也尽量深入浅出的把知识讲清楚讲透彻，首先写的文章我要自己都理解透，这样别人看的时候才会觉得一目了然。另外就是认真的态度，见过一些为了流量写的教程，不做评价。只是觉得既然写了，既要对得起自己，也要对得起别人。

标题

既为了提高打开率，也是为了新颖，我不会按照比如《Python入门1》、《Python入门2》这种常规的命名，这样的文章实在是太多了。而是会在写完文章后，根据文章内容，选择其中的亮点，作为标题。这个过程也挺有趣，有种点睛之笔的意味。同时我也希望随便摘一篇文章拿出去，也是够看的。

（突然想起来上学写 2000 多条错题笔记的时候，简单又充实）

开篇

为了把这个开篇写好，我专门在 B 站上面找了最火的 Python 教程，全站排行榜最高第1名的《花了2万多买的Python教程全套》，质量很高，也推荐大家看看。不过我不搞培训，也不需要宣扬 Python 的好处促进就业，就不写那么多背景介绍了。身边学财会的朋友之前让我教教 Python，干脆我就以这个为契机，作为开篇，保证 5 分钟内，即便是文科生，也能用 Python 编起程序来！

电脑

Python 并不神秘，它其实就和 QQ 一样，只是一个运行在电脑上的普普通通的软件。只要有一台电脑，就可以写 Python。

安装

打开这个下载网址：

https://www.python.org/downloads/

点击 Download Python 进行下载（Mac 土豪请注意选择版本）。下载后傻瓜式一路点击下一步安装就好。

使用

一般的软件我们都是双击图标打开。Python 在安装以后桌面上不会出现图标。不过可以从开始菜单找到：

点击后就打开了：

Python 毕竟是一门编程语言，它也有它自己的尊严，所以它的界面看起来也有专业的一面，比如那一串密密麻麻的英文。

输入一句话试试：

print("hello")

敲击回车。它马上就会回应一句，hello：

没错，是的，你已经在用 Python 编程了！

小结

本文以极其简单的例子，介绍了如何动手用 Python 编程。我试了下，如果网速快的话，5 分钟内完成是妥妥的。哈哈哈。之所以选择这个简单例子，也是想说明 Python 本来就是很简单的，不用听到编程就被吓到了。先动手，一点一点学习就好。不过言归正传，我们工作中并不是这么写 Python 的，而是用一款叫做 PyCharm 的软件。PyCharm 分为社区免费版和专业旗舰版。日常使用社区版就可以了，个人推荐旗舰版。提示一下，破解的时候注意搜索带上 PyCharm 的版本，比如 2020.2.3，成功率会更高。