- 博客(103)
- 资源 (1)
- 收藏
- 关注
RSS订阅原创 第17章：使用 concurrent.futures 模块处理并发-使用 futures.as_completed 函数立刻获取多线程任务执行结果
前面的章节我们使用了Executor.map 函数，这个函数易于使用，不过有个特性可能有用，也可能没用， 具体情况取决于需求：这个函数返回结果的顺序与调用开始的顺序一致。我们知道map 返回的结果是一个生成器 results，当我们用 for 循环取值时， for 会隐式调用 next(results) 返回第一个任务，然后又会在第一个任务的 Future实例上调用 .result() 方法。而 result() 方法会阻塞，直到第一个Future 运行结束；如果第一个调用生成结果用时 10 秒...
2020-09-11 16:05:07
3871
原创 第17章：使用 concurrent.futures 模块处理并发-阻塞型 I/O 和 GIL、使用 ProcessPoolExecutor 启动进程
17.2 阻塞型I/O和GILCPython 解释器本身就不是线程安全的，因此有全局解释器锁(GIL)， 一次只允许使用一个线程执行 Python 字节码。因此，一个 Python 进程通常不能同时使用多个 CPU 核心。编写 Python 代码时无法控制 GIL；不过，执行耗时的任务时，可以使用一个内置的函数或一个使用 C 语言编写的扩展释放 GIL。其实，有个使用 C 语言编写的 Python 库能管理 GIL，自行启动操作系统线程，利用全部可用的 CPU 核心。这样做会极大地增加库代码的复杂度
2020-09-11 16:04:50
1174
原创 第17章：使用 concurrent.futures 模块处理并发-ThreadPoolExecutor 多线程并发和 Future 介绍
本章主要讨论 Python 3.2 引入的 concurrent.futures 模块。这一章还会介绍“Future”的概念，Future 指一种对象，表示异步执行的操作。这个概念的作用很大，是 concurrent.futures 模块和 asyncio 包的基础。17.1使用 concurrent.futures 模块并发处理下载任务为了高效处理网络 I/O，需要使用并发，因为网络有很高的延迟，所以为了不浪费 CPU 周期去等待，最好在收到网络响应之前做些其他的事。为了说明这一点，我们通过代码.
2020-09-11 16:04:29
2713
原创 第16章：协程
16.1 生成器如何进化成协程协程的底层架构在“PEP 342”中定义，并在 Python 2.5(2006 年)实现了。自此之后，yield 关键字可以在表达式中使用，而且生成器 API 中增加了 .send(value) 方法。生成器的调用方可以使用 .send(...) 方法发送数据，发送的数据会成为生成器函数中 yield 表达式的值。因此，生成器可以作为协程使用。协程是指一个过程，这个过程与调用方协作，产出由调用方提供的值。除了 .send(value) 方法，PEP 342 还添加了 .
2020-09-01 17:34:20
222
原创 第15章：上下文管理器和 else 块
if 语句之外的 else 块这个语言特性不是什么秘密，但却没有得到重视：else 子句不仅能在 if 语句中使用，还能在 for、while 和 try 语句中使用。else 子句的行为如下：在 for 中 ：仅当 for 循环运行完毕时(即 for 循环没有被 break 语句中止) 才运行 else 块。在 while 中：仅当 while 循环因为条件为假值而退出时(即 while 循环没有被 break 语句中止)才运行 else 块。在 try 中：仅当 try 块中没有异常
2020-08-31 15:24:42
112
原创 第14章：扩展-标准库中的生成器函数
标准库提供了很多生成器，有用于逐行迭代纯文本文件的对象，还有出色的 os.walk 函数。 这个函数在遍历目录树的过程中产出文件名，因此递归搜索文件系统像 for 循环那样简单。os.walk 生成器函数的作用令人赞叹，不过本节专注于通用的函数：参数为任意的可迭代对象，返回值是生成器，用于生成选中的、计算出的 和重新排列的元素。表14-1 用于过滤的生成器函数：从输入的可迭代对象中产出元素的子集，而且不修改元素本身。filter(predicate, it)：把 it 中的各个元素传给 pred
2020-08-31 14:47:39
136
原创 第14章：可迭代的对象、迭代器、生成器
迭代是数据处理的基石。扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式(Iterator pattern)。为此，Python 语言实现了“迭代器”和“生成器”。在 Python 中，所有集合都可以迭代。在 Python 语言内部，迭代器用于支持:for 循环 构建和扩展集合类型 逐行遍历文本文件 列表推导、字典推导和集合推导 元组拆包 调用函数时，使用 * 拆包实参本章涵盖以下话题：语言内部如何使用 iter(...) .
2020-08-28 18:12:40
300
原创 第9章：符合Python风格的对象-私有属性和“受保护的”属性、使用 __slots__ 类属性节省内存空间、覆盖类属性
私有属性和“受保护的”属性私有属性：Python 不能像 Java 那样使用 private 修饰符创建私有属性，但是 Python 有个简单的机制，能避免子类意外覆盖“私有”属性。举个例子：有人编写了一个名为 Dog 的类，这个类的内部用到了 mood 实例属性，但是没有将其开放。现在，你创建了 Dog 类的子类：Beagle。如果你在毫不知情的情况下又创建了名为 mood 的实例属性，那么在继承的方法中就会把 Dog 类的 mood 属性覆盖掉，这是个难以调试的问题。为了避免这种情况，如
2020-08-07 17:32:09
193
原创 第9章：符合Python风格的对象-可散列的自定义对象 Vector2d
按照定义，目前 Vector2d 实例是不可散列的，因此不能放入集合( set )中：class Vector2d: def __init__(self, x, y): self.x = float(x) self.y = float(y) # 同前章节内容 ......v1 = Vector2d(3, 4)hash(v1)# Traceback (most recent call last):# File
2020-08-06 11:27:47
343
原创 第9章：符合Python风格的对象- classmethod与staticmethod、格式化显示
9.4 classmethod与staticmethodPython 教程没有提到 classmethod 装饰器，也没有提到 staticmethod。学过 Java 面向对象编程的人可能觉得奇怪，为什么 Python 提供两个这样的装饰器，而不是只提供一个?先来看 classmethod。示例 9-3 展示了它的用法:定义操作类，而不是操作实例的方法。classmethod 改变了调用方法的方式，因此类方法 的第一个参数是类本身，而不是实例。class Demo: @classm
2020-08-06 10:43:46
100
原创 第9章：符合Python风格的对象-对象表示形式、实现自定义类的魔术方法和备选构造方法
得益于 Python 数据模型，自定义类型的行为可以像内置类型那样自然。 实现如此自然的行为，靠的不是继承，而是鸭子类型(duck typing): 我们只需按照预定行为实现对象所需的方法即可。前一章分析了很多内置对象的结构和行为，这一章则自己定义类，而且让类的行为跟真正的 Python 对象一样。本章包含以下话题：支持用于生成对象其他表示形式的内置函数( 如 repr()、bytes()等等 ) ； 使用一个类方法实现备选构造方法； 扩展内置的 format() 函数和 str.form.
2020-08-05 13:55:57
215
原创 第8章：对象引用、可变性和垃圾回收-del、垃圾回收、弱引用
8.5 del 和垃圾回收del 语句删除名称(对象的引用)，而不是对象。del 命令可能会导致对象被当作垃圾回收，但是仅当删除的变量保存的是对象的最后一个引用，或者无法得到对象时。重新绑定也可能会导致对象的引用数量归零，导致对象被销毁。在 CPython 中，垃圾回收使用的主要算法是引用计数。实际上，每个对象都会统计有多少引用指向自己。当引用计数归零时，对象立即就被销毁：CPython 会在对象上调用 __del__ 方法(如果定义了)，然后释放分配给对象的内存。CPython 2.0..
2020-08-04 13:54:17
149
原创 第8章：对象引用、可变性和垃圾回收-当函数的参数作为引用时
Python 唯一支持的参数传递模式是“共享传参”，多数面向对象语言都是采用这一模式，包括 Ruby 和 Java（Java 的引用类型是这样的，基本类型是按值传参）。“共享传参”是指函数的各个形式的参数获得实参中各个引用的副本，也就是说，函数内部的形参是实参的别名。这个方案的结果是，函数可能会修改作为参数传入的可变对象，但是无法修改那么对象的标识（即不能把对象替换成另一个对象），详见示例：def f(a, b): a += b return ax = 1y = 2p
2020-07-31 16:34:52
145
原创 第8章：对象引用、可变性和垃圾回收-浅复制和深复制
浅复制复制列表（或其他可变类型）最简单的办法是使用内置的类型构造方法（还可以用 copy 内置库的 copy() 方法）例如：l1 = [3, [66, 55, 44], (7, 8, 9)]l2 = list(l1)print(l1 == l2) # Trueprint(l1 is l2) # False然而，使用构造方法或 cpoy.copy() 做的都是浅复制（即复制了最外层容器，副本中的元素还是源容器中的元素的引用，见上图）。如果所有的元素都是不可变的，那么这样做没有问
2020-07-30 16:25:39
96
原创 第8章：对象引用、可变性和垃圾回收-对象引用概念、元组的相对不可变性
8.1 变量不是盒子人们经常使用“变量是盒子”这样的比喻，但是这有碍于理解面对对象语言中的引用式变量，Python 变量类似于 Java 中的引用式变量，因此最好把变量理解为附加在对象上的标注，或者是贴在对象上的便利贴。示例 8-1 变量 a 和 b 引用同一个列表，而不是那个列表的副本a = [1, 2, 3]b = aa.append(4)print(b) # [1, 2, 3, 4] 8.2 标识、相等性和别...
2020-07-30 15:24:31
131
原创 第7章：函数装饰器和闭包-实现简单装饰器和参数化装饰器
实现简单装饰器：import timedef timer(func): # 1. 装饰器接收被装饰的函数 def wrapper(*args, **kwargs): # 2. wrapper 接收被装饰函数的参数，然后将参数传给被装饰的函数： print(f'wrapper() 接收到位置参数{args}, 关键字参数{kwargs}') start_ti = time.time() result = func(*args, **k
2020-07-29 15:28:50
150
原创 第7章：函数装饰器和闭包-变量作用域规则、闭包、nonlocal 声明
Python 的变量作用域规则先来看一段示例：b = 6def func(a): print(a) print(b) b = 9func(3)上面的代码中，a 变量会正常打印，打印 b 的变量时竟然会报错：UnboundLocalError: local variable 'b' referenced before assignment，这是为什么呢？这是因为 Python 在编译函数的定义体时，判断 b 是局部变量，而不是全局变量，因为 b 在函数体中
2020-07-28 17:01:41
191
原创 第7章：函数装饰器和闭包-基础知识和装饰器执行时机
装饰器基础知识装饰器是可调用对象，其参数是另一个函数(被装饰的函数)，装饰器可能会处理被装饰的函数，然后把它返回，或者将其替换成另一个函数或者可调用对象，例如：def deco(func): # 1. 接收被装饰的函数作为参数 def inner(): print('running inner()...') return inner # 2. 返回 inner 函数，原函数被替换# 3. 装饰在函数上@decodef target(): pri
2020-07-28 14:26:31
261
原创 第6章：使用函数实现“策略模式”
策略模式是定义一系列算法，把它们一一封装起来，并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。电商系统有个功能明显的可以使用"策略"模式，即根据用户的属性或订单中的商品数量计算折扣。假如一个网店制定了一下的折扣规则：有 1000 积分或以上的用户，每个订单享受 5% 的折扣； 同一个订单中，单个商品的数量达到20个及以上，享受 10% 的折扣； 订单中的不同商品达到10个及以上，享受 7% 的折扣；简单起见，我们假设一个订单一次只能享受一个折扣；# 使用函数实现.
2020-07-28 10:48:16
255
原创 第5章：函数-从定位参数到仅限关键字参数
Python 最好的特性之一就是提供了极为灵活的参数处理机制，而且 Python3 中进一步提供了仅限关键字参数；下面来通过代码展示这些特性："""从定位参数到仅限关键字参数；"""def tag(name, *content, cls=None, **attrs): print('name: ', name) print('content: ', content) print('cls: ', cls) print('attrs: ', attrs)
2020-07-27 15:35:11
144
原创 第5章：函数-函数内省、提取参数信息、函数注解
除了 __doc__，函数对象还有很多属性，使用 dir 内置函数可以查看其他函数具有的属性：def func(): pass# 使用 dir 内置函数查看其他函数具有的属性print(dir(func))# ['__annotations__', '__call__', '__class__', '__closure__', '__code__', # '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__'
2020-07-27 15:07:35
347
原创 第5章：函数-函数相关名词解释
一等函数：在运行时创建； 能赋值给变量或数据结构中的元素； 能作为参数传给函数； 能作为函数的返回结果；在 Python 中，所有的函数都是一等函数，包括 str、int、dict 等等；高阶函数：接收函数作为参数，或者把函数作为返回结果的函数都是高阶函数；例如：内置函数中 map、filter、sorted 都是高阶函数；匿名函数：在 Python 中 可以使用 lambda 关键词创建匿名函数，例如：# 不过一般不建议这样写 lambda，一般是作为参数或者返回值时写
2020-07-24 17:27:13
768
原创 第4章：文本和字节序列-了解编码问题
"""常见编解码异常：UnicodeEncodeError：编码错误，将字符串编码成字节串(二进制字节序列)时的异常；UnicodeDecodeError：解码错误，将字节串(二进制字节序列)解码成字符串时的异常；SyntaxError：如果源码的编码与预期不符，加载 Python 模块时还可能抛出 SyntaxError 异常；"""# 4.4.1 处理编码时 UnicodeEncodeError 异常：----------------city = 'São Paulo'# utf-.
2020-07-24 16:38:19
168
原创 第3章：字典和集合-扩展：dict 从无序到有序
在 Python 3.5（含）以前，字典是不能保证顺序的，键值对A先插入字典，键值对B后插入字典，但是当你打印字典的 Keys 列表时，你会发现B可能在A的前面。但是从 Python 3.6 开始，字典是变成有顺序的了。你先插入键值对A，后插入键值对B，那么当你打印 Keys 列表的时候，你就会发现B在A的后面。不仅如此，从 Python3.6 开始，下面的三种遍历操作，效率要高于 Python 3.5 之前：for key in my_dictfor value in my_dict.va
2020-07-24 13:45:22
241
原创 第3章：字典和集合- dict 和 set 的背后
想要理解 Python 里字典和集合类型的长处和弱点，它们背后的散列表是绕不开的一环。这一节将会回答以下几个问题。 Python 里的dict和set的效率有多高？ 为什么它们是无序的？ 为什么并不是所有的 Python 对象都可以当作dict的键或set里的元素？ 为什么dict的键和set元素的顺序是跟据它们被添加的次序而定的，以及为什么在映射对象的生命周期中，这个顺序并不是一成不变的？ 为什么不应该在迭代循环dict或是s...
2020-07-24 12:19:18
135
原创 第3章：字典和集合-集合(set、frozenset)
Python 中“集合”有两种，set和它的不可变的姊妹类型frozenset，它们实现也依赖“散列表”，但在它们的散列表里存放的只有元素的引用（就像在字典里只存放键而没有相应的值）。集合的本质是许多唯一对象的聚集。因此，集合可以用于去重：# 集合的本质是许多唯一对象的集合，所以可以用来去重：s = ['spam', 'spam', 'eggs', 'spam']ls = set(s) # 返回一个新集合print(ls) # {'spam', 'eggs'}集合中的元素...
2020-07-23 18:12:32
455
原创 第3章：字典和集合-不可变映射类型
标准库里所有的映射类型都是可变的，但有时候你会有这样的需求，比如不能让用户错误地修改某个映射。所以从 Python 3.3 开始，types模块中引入了一个封装类名叫MappingProxyType。如果给这个类一个映射，它会返回一个只读的映射视图，虽然是个只读视图，但是它是动态的，这意味着如果对原映射做出了改动，我们通过这个视图可以观察到，但是无法通过这个视图对原映射做出修改。示例 3-9 用MappingProxyType来获取字典的只读实例from types imp...
2020-07-23 16:56:40
210
原创 第3章：字典和集合-字典的变种(OrderedDict、Counter、UserDict、ChainMap)
这一节总结了标准库里collections模块中，除了defaultdict之外的不同映射类型。OrderedDict OrderedDict类型在添加键的时候会保持顺序，因此键的迭代次序总是一致的。OrderedDict的popitem方法默认删除并返回的是字典里的最后一个元素，但是如果像my_odict.popitem(last=False)这样调用它，那么它删除并返回第一个被添加进去的元素。Counter Counter类型会给“键”准备一个整数计数器。...
2020-07-23 16:41:23
206
原创 第3章：字典和集合-映射的弹性键查询(defaultdict 和 特殊方法 __miss__)
有时候为了方便起见，就算某个键在映射里不存在，我们也希望在通过这个键读取值的时候能得到一个默认值。有两个途径能帮我们达到这个目的，一个是通过defaultdict这个类型而不是普通的dict，另一个是给自己定义一个dict的子类，然后在子类中实现__missing__方法。下面将介绍这两种方法。3.4.1 defaultdict：处理找不到的键的一个选择 在创建一个defaultdict的时候，需要给构造方法提供一个可调用对象，这个可调用对象会在__getitem_...
2020-07-23 15:58:14
151
原创 第3章：字典和集合-常见的映射方法(字典方法)
常见的映射方法映射类型的方法其实很丰富。表 3-1 为我们展示了dict、defaultdict和OrderedDict的常见方法，后面两个数据类型是dict的变种，位于collections模块内。表3-1：dict、defaultdict和OrderedDict这三种映射类型的方法列表（依然省略了继承自object的常见方法）；可选参数以[...]表示 dict defaultdict Ordere...
2020-07-23 15:00:42
302
原创 第3章：字典和集合-泛映射类型、字典推导
dict类型不但在各种程序里广泛使用，它也是 Python 语言的基石。模块的命名空间、实例的属性和函数的关键字参数中都可以看到字典的身影。跟它有关的内置函数都在__builtins__.__dict__模块中。正是因为字典至关重要，Python 对它的实现做了高度优化，而“散列表”则是字典类型性能出众的根本原因。集合（set）的实现其实也依赖于散列表，想要进一步理解集合和字典，就得先理解散列表的原理。3.1 泛映射类型collections.abc模块中有Mapping和...
2020-07-22 18:20:02
376
原创 第2章：序列构成的数组-数组 array 和 队列 deque
虽然列表既灵活又简单，但面对各类需求时，我们可能会有更好的选择，比如：1. 要存放 1000 万个浮点数的话，数组（array）的效率要高得多，因为数组在背后存的并不是float对象，而是数字的机器翻译，也就是字节表述。2. 如果需要频繁对序列做“先进先出”的操作，队列（deque）的速度应该会更快。2.9.1 数组如果我们需要一个只包含数字的列表，那么array.array比list更高效。数组支持所有跟可变序列有关的操作，包括.pop、.insert和.extend。另...
2020-07-22 15:57:54
233
原创 第2章：序列构成的数组-用 bisect 模块来管理已排序的序列
bisect模块包含两个主要函数，bisect和insort，两个函数都利用二分查找算法来在有序序列中查找或插入元素。2.8.1 用bisect来搜索bisect 用来搜索x在假设插入序列n后，然后再对 n 排序之后的索引位置，实际上 x 并不在 n 中；bisect(n, x)有2个必须参数：n : 被搜索的序列； x : 要搜索的对象；from bisect import bisectn = [3, 1, 4, 2, 8, 6] # 模拟排序后的结果...
2020-07-22 15:30:41
121
原创 第2章：序列构成的数组-list.sort 方法和内置函数 sorted
list.sort方法：list.sort方法会就地排序列表，也就是说不会把原列表复制一份。list.sort 有两个可选参数 key 和 reverse。reverse 是 bool 类型，默认为 False，升序排序；设置为 True 时为降序排序；key 接受一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字。t = [3, 1, 4, 2, 8, 5, 6, 9, 7, 0]print(id(t)) # 45...
2020-07-22 14:38:16
151
原创 第2章：序列构成的数组-序列的增量赋值(+=、*=)
增量赋值运算符+=和*=的表现取决于它们的第一个操作对象，是可变类型还是不可变类型。+=背后的特殊方法是__iadd__（用于“就地加法”）。但是如果操作对象没有实现这个方法的话，Python 会退一步调用__add__。对可变序列使用增量赋值运算符： 如果a实现了__iadd__方法，就会调用这个方法。对可变序列（例如list、bytearray和array.array）来说，a会就地改动，就像调用了a.extend(b)一样。a = ...
2020-07-22 11:09:56
171
原创 第2章：序列构成的数组-对序列使用 + 和 *
Python 默认序列是支持+和*操作的。通常+号两侧的序列由相同类型的数据所构成，在拼接的过程中，两个被操作的序列都不会被修改，Python 会新建一个包含同样类型数据的序列来作为拼接的结果。⚠️注意：+和*都遵循这个规律，不修改原有的操作对象，而是构建一个全新的序列。ls = [1, 2, 3]ls_1 = [4, 5, 6]new_ls = ls * 2 + ls_1print(ls) # [1, 2, 3]print(ls_1) # [4, 5, 6]...
2020-07-21 18:14:01
110
原创 第2章：序列构成的数组-列表切片
4.1 对对象进行切片一个众所周知的秘密是，我们还可以用s[a:b:c]的形式对s在a和b之间以c为间隔取值。c的值还可以为负，负值意味着反向取值。ls = [10, 20, 30, 40, 50, 60, 70]# 从头开始取3个print(ls[:3]) # [10, 20, 30]# 从第4个到最后一个print(ls[3:]) # [40, 50, 60, 70]# 根据步长切片, 从0个开始，每+3取1次print(ls[::3]) # [10...
2020-07-21 17:54:02
178
原创 第2章：序列构成的数组-元组、元组拆包、具名元组
3.1 元组拆包元组拆包可以应用到任何可迭代对象上(str、list、dict、set)，唯一的硬性要求是，被可迭代对象中的元素数量必须要跟接受这些元素的元组的空档数一致。除非我们用*来表示忽略多余的元素平行赋值拆包：完全拆包，左侧变量必须和元组元素数量一致；# 平行赋值city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)print(city, year, pop, chg, area) # Tokyo...
2020-07-21 16:32:40
307
原创 第2章：序列构成的数组-列表推导和生成器表达式
2.1 列表推导：列表推导的结果是构建一个新的列表；特点：保存推导结果，比生成器执行速度快，可以重新迭代，但内存开销较大；⚠️ 列表推导的通常原则：列表推导只用来创建新列表，并且尽量保持简介；示例 2-1 把一个字符串变成 Unicode 码位的列表symbols = '#¥%&*'# 列表推导：将字符串转为Unicodecodes = [ord(i) for i in symbols]print(codes) # [36, 162, 163, 165, 8364
2020-07-17 16:29:46
255
原创 第2章：序列构成的数组-内置序列类型概览
2.1 内置序列类型概览Python 标准库用 C 实现了丰富的序列类型，列举如下。容器序列：list、tuple和collections.deque(双端队列)这些序列能存放不同类型的数据。扁平序列：str、bytes、bytearray、memoryview(内存视图)和array.array(数组)，这类序列只能容纳一种类型。容器序列存放的是它们所包含的任意类型的对象的引用，换句话说，扁平序列其实是一段连续的内存空间。扁平序列里存放的是值而不是引用，它里面只能存放诸如字符...
2020-07-17 15:30:45
171
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人