独到科技Python笔试

建议时长 30-50min

0.简写3~4条PEP8.0规范

PEP8.0(Python Enhancement Proposal 8.0)协议[规范]

1.Python的内置 [数据结构] 有哪些?各有什么特点?

可以从存储的 [数据类型] 和操作上考虑

2.Python中list与array.array有什么区别?

可以从存储数据的方式和类型考虑

3.什么是迭代器?什么是生成器?

可以从两者的关系和如何避免无限迭代上考虑

4.按照顺序写出下列输出

可以从Python变量赋值方式角度考虑

1
2
3
4
5
6
7
8

temp_1 = [["_"] * 3] *3
temp_2 = [["_"] * 3 for _ in range(3)]

temp_1[0][0] = "X"
temp_2[0][0] = "O"

print(temp_1)
print(temp_2)

可以从三者获取值时所调用的(magic method)上考虑

PS: 如果AttributeError则写Error

1
2
3
4
5
6
7
8
9

list_1 = ["hello", "World", "!"]
list_2 = [1, "", 3]

temp_var = dict(zip(list_1, list_2))

print(temp_var[list_1[0]])
print(temp_var.hello)
print(temp_var.get("World"))
print(temp_var.get("hello, world"))

可以从python函数如何接受可变类型参数上考虑

1
2
3
4
5
6
7

def func(var_1,seq=[]):
    seq.append(var_1)
    return seq

func(1)
func(1)
print(func(1))

Part0.BulitIn

小知识

处理大数据

1. 如果是类 -> 减少内存使用__slots__
2. 如果是数值类型 使用Numpy array memoryview

为什么说repr是开发者模式的str

因为eval(repr(obj)) –> obj

如果class中有self.__attr私有变量, 则无法通过eval(repr(obj))获取obj

1
2
3
4
5
6
7

def repr(obj): # real signature unknown; restored from __doc__
    """
    Return the canonical string representation of the object.
    
    For many object types, including most builtins, eval(repr(obj)) == obj.
    """
    pass

self|cls

python中cls代表的是类的本身，相对应的self则是类的一个实例对象。

因为cls等同于类本身，类方法中可以通过使用cls来实例化一个对象。

cls通常于@classmethod搭配使用用于实例化类对象

反射

python的反射，它的核心本质其实就是利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！

林奈结构

没有采用一贯的下行二分法体系（系统）而是采用在一个界（kingdom）之内只含有四个阶元层次：纲（class），目（order），属（genus），种（species）的等级结构的体系。

帮助

想知道某个类或者函数有方法以及其例子时, 可以使用dir()或者help()

比如想了解pandas.read_excel如何读取其title和data

1
2
3
4
5
6
7
8
9
10

import pandas as pd
file = pd.read_excel("./students.xls")
columns = list(file.columns)

for data in file.values:
    print(data)
>>
['Star' 46599201 85 20]
['Drink' 36784554 90 21]
['Fire' 12492483 96 23]

想了解一个函数或者对象要做什么事情可以使用__annotation__ __doc__ inspect.signature

annotation

1

{'dtype': 'DtypeArg | None', 'storage_options': 'StorageOptions'}

doc

signature

1

(io, sheet_name=0, header=0, names=None, index_col=None, usecols=None, squeeze=False, dtype: 'DtypeArg | None' = None, engine=None, converters=None, true_values=None, false_values=None, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, parse_dates=False, date_parser=None, thousands=None, comment=None, skipfooter=0, convert_float=None, mangle_dupe_cols=True, storage_options: 'StorageOptions' = None)

下划线

format

^, <**, **> 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，**只能是一个字符[即只能填充一次]**，不指定则默认是用空格填充。

1
2
3
4
5

# 即长度为多少
str = "1{:15}".format("&")
print(string_1, len(str))
|1&               |
16

+ 表示在正数前显示 **+**，负数前显示 **-**； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

1
2
3
4
5
6

# {} format
# {0} format the index
# {0:2d} format the type --> d int 2d: remain two int
# {<2d} 左对齐，宽度为2d，不足补空格
ROW_FMT = "{0:2d}  @ {1:2d}   {2} {0:<2d}"
print(ROW_FMT.format(needle, posotion, offset))

Dis常用字节码

Attention

函数|方法返回

python 会对operation返回return None来表示对对象的就地更改, 即不会id(obj)不会变

• 用返回None来表示就地改动有一个弊端, 即调用者无法将其串联起来; 而返回一个新对象的方法(比如说str里的所有方法)则正好相反, 他们可以串联起来调用

sort

sort分为两种， 一种是value sort即根据值进行排序， 另一种是time sort即就算两个元素比不出大小， 但在每次排序的结果里他们的相对位置是固定的

推导式

• 一般推导式的作用 [] {}
  • 创建新的数据对象
  • 过滤作用

Q&A

1.python中list和array的区别

• list是python的内置数据类型
• list中的数据类不必相同的
• array的中的类型必须全部相同
• 在list中的数据类型保存的是数据存放的地址，简单的说就是指针，并非数据
• 这种保存方式增加了存储和CPU的消耗例如list1=[1,2,3,’a’]需要4个指针和四个数据
• 数组在背后存的并不是float对象，而是数字的机器翻译，也就是字节表述。这一点和c语言中的数组一样
• array创建的数组不适用于数字操作（比如矩阵和矢量运算）。另外+=和*=运算符可以用于array的添加。
• 从python3.4开始，数组（array）类型不再支持诸如list.sort()这种就地排序方法。要给数组排序的话，得用sorted函数新建一个数组：

Magic Method

表1:跟运算符无关的 magic method

表2:跟运算符相关的 magic method

1

注: 以下所有的keyword默认为 self.__xx__():

bool|len

默认情况下我们定义的类的实例总是被认为True,除非在define class中有实现bool或者len

bool()的背后其实是调用x.__bool__()的结果;如果x.__bool__()不存在, 则调用len()即x.__len__(),如果为0-False other-True

调用优先级为bool > len

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

# define a class
class temp:

    def __init__(self):
        self.value = 1

    def __len__(self):
        return 0

    !def __bool__(self):
    !   return True
>
bool(temp) False
? bool(temp) True

and|mul

and --> + add

mul --> * multiple

str|repr

两者的却别在于str will called by str() and print(), repr can only called by print()

如果两者特殊方法保留一个repr会是更好的选择, 因为在没有str时, 解释器会调用repr

优先级str > repr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# define a class
class temp:

    def __init__(self):
        self.value = 1

    def __repr__(self):
        return f"repr value is {self.value}"

    def __str__(self):
        return f"str value is {self.value}"

test = temp()
print(test)

H:\Python\python.exe H:/MY_TXM/test.py
str value is 1

Moudle

functools

recude

对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

1
2
3

sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])
>>
15 = 1 + 2 + 3 + 4 + 5

os

listdir

列出目录下的所有文件和文件夹不包括. ..隐藏目录

1
2
3
4

import os
print(os.listdir("H:\MY_TXM"))
>>
['.git', '.gitignore', '.idea', 'static', 'venv']

locale

locale 是根据计算机用户所使用的语言，所在国家或者地区，以及当地的文化传统所定义的一个软件运行时的语言环境。通常情况下它可以按照涉及使用习惯分为12大类:

• 语言符号及其分类（LC_CTYPE)
• 数字（LC_NUMBERIC）
• 比较习惯（LC_COLLATE)
• 时间显示格式（LC_TIME）
• 货币单位（LC_MONETARY)
• 信息主要是提示信息，错误信息，状态信息，标题，标签，按钮和菜单等（LC_MESSAGES）
• 行么书写方式（LC_NAME）
• 地址书写方式（LC_ADDRESS）
• 电话号码书写方式（LC_TELEPHONE）
  -度量衡表达方式（LC_MEASUREMENT）
• 默认纸张尺寸大小（LC_PAPER）
• 对locale 自身包含信息的概述（LC_IDENTIFICATION）
• 除此之外还有一个LANGUAGE参数，它与LC_MESSAGES相似

time

time

process_time

process_time_ns

perf_counter

perf_counter_ns

time()精度上相对没有那么高，而且受系统的影响，适合表示日期时间或者大程序程序的计时。

perf_counter()适合小一点的程序测试，会计算sleep()时间。

process_counter()适合小一点的程序测试，不会计算sleep()时间。

此外Python3.7开始还提供了以上三个方法精确到纳秒的计时。分别是：

1
2
3

time.perf_counter_ns()
time.process_time_ns()
time.time_ns()

arrary

数组所接受的typecode以及其对应的存储数据类型

bisect

bisect是一个根据二分算法写的库，其中主要的俩个方法是bisect和insert，根本上根据二分算法算出有序序列的索引，可以当做快速定位index使用

bisect|bisect_left

接受一个有序序列，一个元素，返回该元素在有序序列的索引，索引以前全≤该元素，bisect(bisect_right)|bisect_left主要区别是如果俩对比元素相等，前者返回index是从右边插入，后者左边

1
2
3
4
5
6
7
8
9

import bisect
temp_sequence = [0, 2, 3]
index = bisect.bisect(temp_sequence, 2)
_index = bisect.bisect_left(temp_sequence, 2)

print(index)
print(_index)
2
1

insort

根据bisect或者bisect_left返回的index进行插入，接受有序序列，返回有序序列

itertools

groupby

和nlargest() nsmallest()一样支持key=

【聚合】

有时候我们需要给一个sequence按照某个属性分组，可以借助groupby来实现,groupby常常和lambda map operator.itemgetter一起使用，因为在分组前，大多希望相关的数据聚集在一起， 这样对于groupby来说分组才有意义

语法：

1
2
3
4
5

groupby(seqence, key)
args:
    sequence must iterable
    key sort the sequence 聚合
return iterator contains key, data --> type tuple

注意：

1. 如果groupby中的key=None，那么group后的key是被group中的element， 如果key=fun那么group后的key是fun(element)
2. 返回的数据
   • type(key) type(element)
   • type(data) iterator

实列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

a = [{'severity': '严重'}, {'severity': '严重'}, {'severity': '不严重'}, {'severity': '严重'}]

# 如果不将数据进行排序直接group
for key, data in groupby(a):
    print(key, list(data))

# 将会输出三组key
"""
{'severity': '严重'} [{'severity': '严重'}, {'severity': '严重'}]
{'severity': '不严重'} [{'severity': '不严重'}]
{'severity': '严重'} [{'severity': '严重'}]
"""

# 对数据进行聚合(排序)但不对group的key进行筛选
a.sort(key=itemgetter("severity"))
for key, data in groupby(a):
    print(key, list(data))
    
# 此时的key时a中的单个element
"""
{'severity': '不严重'} [{'severity': '不严重'}]
{'severity': '严重'} [{'severity': '严重'}, {'severity': '严重'}, {'severity': '严重'}]
"""

# 对数据进行聚合(排序)且对group的key进行筛选
a.sort(key=itemgetter("severity"))
for key, data in groupby(a, key=itemgetter("severity")):
    print(key, list(data))

# 此时的group返回的key是经过滤后的key
"""
不严重 [{'severity': '不严重'}]
严重 [{'severity': '严重'}, {'severity': '严重'}, {'severity': '严重'}]
"""

operator

itemgetter

使用[]运算符, 不仅支持序列还支持映射和任何实现了__getitem__方法的类

operator模块提供的itemgetter函数主要用于获取某一对象 特定维度的数据，其中的参数为特定维度的索引

operator.itemgetter函数获取的并不是某一个数值，而是某一个函数常常可以使用lambda 函数替换

用法：

1
2
3
4

itemgetter(var)
args:
    var can accept index and key
return fun()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import operator

a = [{"age": 10, "socre": 90}, {"age": 9, "socre": 98}, {"age": 0, "socre": 50}, {"age": 15, "socre": 56}]

# 定义一个获取维度数据的函数
# 获取sequence的index=0&1的数据
condition = operator.itemgetter(0, 1)

# 将sequence传入获取函数中
res = condition(a)
print(res, type(a))
({'age': 10, 'socre': 90}, {'age': 9, 'socre': 98}) <class 'tuple'>

# 对a的age进行排序
a.sort(key=itemgetter("age"))
a.sort(key=lambda x: x["socre"], reverse=True)
print(a)
[{'age': 0, 'socre': 50}, {'age': 9, 'socre': 98}, {'age': 10, 'socre': 90}, {'age': 15, 'socre': 56}]

# 先对age排序在对score排序
a.sort(key=itemgetter("age", "socre"), reverse=True)

headq

nlargest

nsmallest

和groupby()一样支持key=

介绍：

这两个函数可以帮助我们在某个集合中找出最大或最小的N个元素

语法：

1
2
3
4

def nlargest(n, iterable, key=None):
    """Find the n largest elements in a dataset.
    Equivalent to:  sorted(iterable, key=key, reverse=True)[:n]
    """

random

• 注意如果在random.method之前使用了seed，那么random.method每次都将按照一定规则返回相同的数值

shuffle

语法:

1
2
3
4
5

random.shuffle(iterable)
args:
    iterbale a list or tuple (sequence)
return:
	the origin sequence but the position of element is random ==> None

实列:

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

import random

a = [1, 2, 3, 4, 5]
print(a, id(a))

# operation in ori return None
random.shuffle(a)

print(a, id(a))

>>>
[0, 1, 2, 3, 4] 2200356865544
None
[0, 3, 4, 1, 2] 2200356865544

seed

调用 random.random()|shuffle 生成随机数时，每一次生成的数都是随机的。
但是，当使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，这个时候，先调用seed的情况下，使用 random() 生成的随机数将会是同一个

randrange

从指定范围内，按指定基数递增的集合中 获取一个随机数。

random.randrange([start], stop[, step])

1
2

# 结果相当于从[10, 12, 14, 16, … 96, 98]序列中获取一个随机数。
random.randrange(10, 100, 2)

sample

random.sample的函数原型为：random.sample(sequence, k)从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

1
2
3
4
5
6
7
8
9

temp = [i for i in range(10)]
print(temp, id(temp))
random_choice = random.sample(temp, 3)
print(random_choice, id(random_choice))
print(id(temp))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 2483596469896
[7, 8, 3] 2483594327944
2483596469896

dis

dis.dis

Python代码在执行的时候，会被编译为Python字节码，再由Python虚拟机执行Python字节码。有时候就我们执行python文件的时候会生成一个pyc文件，这个pyc文件即用于存储Python字节码指令，而这些字节码是一种类似于汇编指令的中间语言，但是每个字节码对应的不是机器指令，而是一段C代码。

而dis模块，就是用于查看这些字节码的运行轨迹，因此我们可以用dis模块判断两个函数的内存占用谁会更大，谁会更消耗CPU性能，不仅如此，通过指令，我们还可以知道Python中一些内置函数、变量的取值过程、运行逻辑，对于我们代码性能并优化代码很有帮助。

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

import dis
dis.dis("ori_tuple[index] += mutable_sequence")

  1           0 LOAD_NAME                0 (ori_tuple)
              2 LOAD_NAME                1 (index)
              4 DUP_TOP_TWO
              6             # 实现 TOS = TOS1[TOS] 
              8 LOAD_NAME                2 (mutable_sequence)
             10 INPLACE_ADD
             12 ROT_THREE
             14 STORE_SUBSCR
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

字节码操作:

• 假设

  • ori_tuple = (1, 2, [10, 20])
  • index = 2
  • mutable_sequence = [30, 40]

• 6 BINARY_SUBSCR 将 ori_tuple[index]的值存入TOS(Top Of Stack)

• 10 INPLACE_ADD 计算ori_tuple[index] += mutable_sequence, 这一步骤可以完成, 是因为TOS指向的是一个可变对象

• 14 STORE_SUBSCR 赋值, 这一步骤失败, 是因为tuple属于不可变序列(immutable)

我们从这个操作中可以得到三个教训:

1. 不要把可变对象放在元组中
2. 增量赋值(+=)不是一个原子操作, 在计算完后的赋值阶段如果抛出异常, 计算仍然会完成

譬如:

1
2
3
4
5
6
7

b = (1, 2, [10, 20])
b += [30, 40]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
print(b)
(1, 2, [10, 20])

在上述实列中, 即使在最后的赋值阶段tuple抛出异常, 但是此时tuple的数据依然发生了改变!

• 引用dis — Python 字节码反汇编器 — Python 3.10.2 文档

sys

getsizeof

1
2

getsizeof(object, default) -> int
Return the size of object in bytes.

获取对象所消耗的内存大小

argv

是一个从程序外部获取参数的桥梁，从外部取得的参数可以是多个，所以获得的是一个列表（list)，也就是说sys.argv其实可以看作是一个列表，所以才能用[]提取其中的元素。其第一个元素是程序本身，随后才依次是外部给予的参数。

memoryview

memoryview**[内存视图]是一个内置类, 它能让用户在不复制内容的情况下操作同一个数组的不同切片,其实内存试图时泛化和去数学化的numpy数组**,它允许你在不复制内容的前提下,在数据结构之间共享内存, 其中数据结构可以是任何形式,这个功能在处理大型数据集合的时候十分重要

memoryview 语法：

1

memoryview(obj)

参数说明：

• obj – 对象

返回元组列表(物理地址)。

.cast

memoryview.cast的概念和数组模型差不多,能用不同的方式读写同一块内存地址,而且内容字节不会随意移动,和C语言中类型转换的概念相似.cast会把同一块内存里的内容打包成一个全新的memoryview对象给你

Method

all|any

都接受一个可迭代对象, 其中all是当可迭代对象中的元素都是True时返回True, any是有一个为True时则返回True

1
2
3
4
5
6
7

d = all(map(lambda x: x > 10, [1, 10, 11]))
print(d)
f = any(map(lambda x: x > 10, [1, 10, 11]))
print(f)
>>
False
True

eval

描述

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

语法

以下是 eval() 方法的语法:

1

eval(expression[, globals[, locals]])

参数

• expression – 表达式。
• globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值

返回表达式计算结果。

isatty

isatty() 方法检测文件是否连接到一个终端设备，如果是返回 True，否则返回 False。

语法

isatty() 方法语法如下：

1

fileObject.isatty()

assert

python断言和try-except用法相反

断言函数是对表达式布尔值的判断，要求表达式计算值必须为真。可用于自动调试。

如果表达式为假，触发异常；如果表达式为真，不执行任何操作。

1
2
3

assert condition
if not condition:
    raise AssertionError()

reverse

reversed

1. s.reverse()就地排序, id(s)不变
2. reversed(s)返回s的倒序迭代器

id

返回对象的物理存储地址, 一般用作操作符是或否创建了一个新对象, 比较两个对象的物理地址是否相同使用is

map

提供的函数对指定序列做映射。

1

map(function, iterable, ...)

filter

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

Python2.7 返回列表，Python3.x 返回迭代器对象

1
2

filter(function, iterable)
# 通常和map函数一起使用

Python2.x 中返回的是过滤后的列表, 而 Python3 中返回到是一个 filter 类。

filter 类实现了 iter 和 next 方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 节约内存。

abs|fabs[math]

Python 中 fabs(x) 方法返回 x 的绝对值。虽然类似于 abs() 函数，但是两个函数之间存在以下差异：

• abs() 是一个内置函数，而 fabs() 在 math 模块中定义的。

• fabs() 函数只适用于 float 和 integer 类型，而 abs() 也适用于复数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import math

a = -1
b = -1.3232
c = b
d = 1 + 1.0j
e = 3 + 4.0j
print("a的绝对值是:", abs(a))
print("b的绝对值是:", abs(b))
print("c的绝对值是:", math.fabs(c))
print("d的的绝对值是:", abs(d))
print("e的绝对值是:", math.fabs(e))

Traceback (most recent call last):
  File "H:/MY_TXM/test.py", line 80, in <module>
    print("e的绝对值是:",math.fabs(e))
TypeError: can't convert complex to float

hypot[math]

hypot() 返回欧几里德范数 sqrt(x*x + y*y)

hypot()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。

1
2
3
4
5
6
7
8

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import math

a = int(input("请输入直角三角形的一条直角边长："))
b = int(input("请输入直角三角形的另一条直角边长："))
print("该直角三角形的斜边长为: ",  int(math.hypot(a, b)))
print("Done")

bool

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False用于判断真假

bool 是 int 的子类。

1
2

>>> issubclass(bool, int)  # bool 是 int 子类
True

issubclass

issubclass(class, classinfo) --> return True|False

issubclass() 方法用于判断参数 class 是否是类型参数classinfo的子类

Part1.DataModel

1.具名元组

Python元组的升级版本 – namedtuple(具名元组)

因为元组的局限性：不能为元组内部的数据进行命名，所以往往我们并不知道一个元组所要表达的意义，所以在这里引入了 collections.namedtuple 这个工厂函数，来构造一个带字段名的元组。具名元组的实例和普通元组消耗的内存一样多，因为字段名都被存在对应的类里面。这个类跟普通的对象实例比起来也要小一些，因为 Python 不会用 dict 来存放这些实例的属性。

namedtuple 对象的定义如以下格式：

collections.namedtuple(typename, field_names, verbose=False, rename=False)
返回一个具名元组子类 typename，其中参数的意义如下：

• typename：元组名称
• field_names: 元组中元素的名称
• rename: 如果元素名称中含有 python 的关键字，则必须设置为 rename=True
• verbose: 默认就好

下面来看看声明一个具名元组及其实例化的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

import collections

两种方法来给 namedtuple 定义方法名
User = collections.namedtuple('User', ['name', 'age', 'id'])
User = collections.namedtuple('User', 'name age id')
user = User('tester', '22', '464643123')

print(user)
collections.namedtuple('User', 'name age id') 创建一个具名元组，需要两个参数，一个是类名，另一个是类的各个字段名。后者可以是有多个字符串组成的可迭代对象，或者是有空格分隔开的字段名组成的字符串（比如本示例）。具名元组可以通过字段名或者位置来获取一个字段的信息。

输出结果：

User(name='tester', age='22', id='464643123')
具名元组的特有属性:

类属性 _fields：包含这个类所有字段名的元组 类方法 _make(iterable)：接受一个可迭代对象来生产这个类的实例 实例方法 _asdict()：把具名元组以 collections.OrdereDict 的形式返回，可以利用它来把元组里的信息友好的展示出来
from collections import namedtuple

# 定义一个namedtuple类型User，并包含name，sex和age属性。
User = namedtuple('User', ['name', 'sex', 'age'])

# 创建一个User对象
user = User(name='Runoob', sex='male', age=12)

# 获取所有字段名
print( user._fields )

# 也可以通过一个list来创建一个User对象，这里注意需要使用"_make"方法
user = User._make(['Runoob', 'male', 12])

print( user )
# User(name='user1', sex='male', age=12)

# 获取用户的属性
print( user.name )
print( user.sex )
print( user.age )

# 修改对象属性，注意要使用"_replace"方法
user = user._replace(age=22)
print( user )
# User(name='user1', sex='male', age=21)

# 将User对象转换成字典，注意要使用"_asdict"
print( user._asdict() )
# OrderedDict([('name', 'Runoob'), ('sex', 'male'), ('age', 22)])
以上实例输出结果为：

('name', 'sex', 'age')
User(name='Runoob', sex='male', age=12)
Runoob
male
12
User(name='Runoob', sex='male', age=22)
OrderedDict([('name', 'Runoob'), ('sex', 'male'), ('age', 22)])

2.列表表达式

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

# 两者相等
print([(i, j) for i in range(1, 10) for j in range(11, 20)])
res = []
for i in range(1, 10):
    for j in range(11, 20):
        res.append((i, j))
print(res)

# essential
fun() for-in-loop_1 for-in-loop_2
<==>
for-in-loop_1:
    for-in-loop_2:
        fun()

3.random choice

1
2
3

from random import choice
choice(obj) -> obj: can iterable
==> this module can choice a random element from obj

4.Magic Method

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

obj[key]
本质上调用的是__getitem__

magic method 又称为 dunder method 及双下滑线魔法方法

for-in-loop
==> __contains__ 迭代通常是隐式的

obj[key]   -->  self.__getitem__

迭代通常是隐式的,如果一个集合类型没有实现slef.__contains__,
那么in运算符就会按照顺序做一次迭代搜索

len(obj)   -->   self.__len__
注意如果obj是python内置的类型比如（list、str、bytearry）等Cpython会抄个近路，__len__实际上会直接返回PyVarObject的self.ob_size这个属性，而不是执行self.__len__这个方法

for item in x:   -->  self.__iter__
x 必须是可迭代的

5.迭代器与生成器

5.1迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 **next()**。

字符串，列表或元组对象都可用于创建迭代器：

1
2
3
4
5
6

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
print (next(it))   # 输出迭代器的下一个元素
>1
print (next(it))
>2

迭代器对象可以使用常规for语句进行遍历：

1
2
3
4
5
6
7
8

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
    
> 1 2 3 4

也可以使用 next() 函数：

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

#!/usr/bin/python3
 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

5.2创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next()

在定义类的时候都有一个构造函数，Python 的构造函数为 init(), 它会在对象初始化的时候执行。

iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。

next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Numbers():
    """
    抽象一个迭代器对象，初始属性【value=0每次next自增1，并通过【value>20】来rais StopInteration
    """
    
    def __iter__(self):
        self.value = 0
        # 注意这里返回的不是属性self.value而是self这个抽象对象
        return self
    
    def __next__(self):
        if self.value <= 20:
	        self.value += 1
            # 这里我们需要输出值,print进行查看
            return self.value
        else:
            raise StopIteration
            
# ------

temp = Numbers()
temp_iter = iter(temp)  # 这一步骤可以省略，因为temp在实例化的时候已经是一个迭代器了（contains magic method） iterm | next

# 可以直接for-in-loop temp
for item in temp_iter:
    print(item)
> 1 2 ... 21

# 将俩者的信息进行打印如下:
print(f"the obj is {temp} , type is {type(temp)}")
print(f"the iter is {temp_iter} , type is {type(temp)}")

>>
the obj is <__main__.Numbers object at 0x0000016FFBD51088> , type is <class '__main__.Numbers'>
the iter is <__main__.Numbers object at 0x0000016FFBD51088> , type is <class '__main__.Numbers'>
# 可以看到两者的物理地址相同，因此iter(OBJ)和OBJ一样都是属于迭代器

5.3生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#!/usr/bin/python3
 
import sys
 
def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
#  每次next（generator）所生成的迭代器对象公用和一个物理地址

5.4迭代器和生成器对比

• 迭代器（iterator）是一个特殊的类，其中必有iterm和next方法，本质上是一个类|对象

  • 除了使用class来定义一个迭代器外， 还可以使用iterm(obj)来快速生成一个迭代器对象
  • 可以使用rais StopIteration来抛出exception阻止迭代器进入死循环
  • 是一个可以记住遍历的位置的对象（本质上含有iterm和next）

• 生成器是一个含有yield的函数（generator），生成器是一个返回迭代器的函数，只能用于迭代操作，其实生成器也可以理解成一种特殊的迭代器

  • 生成器是一个返回迭代器的函数
  • 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
  • 调用一个生成器函数，返回的是一个迭代器对象

6.len为什么不是普通方法

如果x是一个python内置类型的实例， 那么len(x)中Cpython会直接调用这个类的属性，解释器将不走__len__()这个方法

杂谈

1. 数据模型|对象模型

   • python文档中大多使用数据模型, 而大多数喜欢使用对象模型
   • 对象模型:计算机编程语言中对象的属性<==>数据模型

2. 魔法方法

   • python用这个方法来提供更多的元对象协议,目的是让语言的使用者和开发者拥有并使用同样的工具

3. 元对象

   the art of the MetaObject Protocal | AMOP

   • 元对象协议:那些对构建语言本身来讲很重要的对象, 以此为前提, 协议也可以看成是接口, 即是说, 元对象协议是对象模型(数据模型)的同义词, 他们的本质都是构建核心语言的API

Part2.DataStructure

2.0前言

在创建poython之前Guido曾为ABC语言贡献过代码, ABC语言是一个致力于为初学者设计变成环境的长达10的研究项目, 其中很多点子在现在看来任然具有python的特性如:

1. 序列的泛型操作
2. 内置的元组
3. 映射类型
4. 用缩进来构建源码
5. 无需变量声明的强类型

python也从ABC继承了用统一风格处理序列数据这一特点, 无论是中数据结构(string|list|bytes|tuple|array|xml|element|database query)他们都公用一套操作:

1. 迭代
2. 切片
3. 排序
4. 拼接

2.1内置序列类型

python使用C实现了两大类序列类型：容器序列 扁平序列

两者的却别前者支持存储不同类型的数据; 后者仅支持一种类型的数据

容器序列: list tuple collection.deque

• 存放的是任意类型的对象的引用
• 支持存储不同数据类型
• 非连续内存存储

扁平序列: str bytes bytearray memoryvivew arrary.arrary

• 存放的是值而不是引用
• 只能存储一种数据类型[字符 字节 数值]
• 连续存储

根据是否可以被修改可以分为:可变序列 不可变序列

从UML图中可以看出两者之间的部分继承关系，但是内置的序列类型不是直接sequence和mutale sequence这两个抽象基类继承来的Abstarct Base Class | ABC

2.2 列表推导和生成器表达

list comprehension and generator expression

[]: 列表推导式

(): 生成器表达式

列表推导式: 快速构建list

使用原则:

0. 列表推导式的作用只有一个:生成列表

1. 创建新列表

2. 尽量保持简短

3. 在py3.x中修复了列表推导是中的变量泄露问题(通过局部作用域修复)

4. 使用filter + map也可以达到相同效果

5. 注意: filter返回的是一个迭代器

6. 两者的效率根据不同情况表现不一样

1
2
3
4
5
6
7

temp = '!@#$%'

m1 = [ord(s) for s in temp if ord(s) > 35]
print(m1)

m2 = list(filter(lambda x: x > 35, map(ord, temp)))
print(m2)

2.2.1 笛卡尔积

1
2
3
4
5
6
7
8
9

col_1 = ["A", "B", "c"]
col_2 = ["!", "@", "#"]

col_3 = [(i, j) for i in col_1 for j in col_2]
print(col_3)

for i in col_1:
    for j in col_2:
        print(i, j)

列表推导式和双层for循环俩者执行顺序一样

2.2.2生成器表达式

使用列表推导也可以初始化元组|数组|其他序列,但是生成器表达式是一个更好的选择, 因为背后支持迭代器协议,可以逐个产出元素而非先建立一个完整的list,可以更好的节省内存

生成器表达式和列表推导式的区别是:

• [] ()
• 生成一个完整的list; 迭代器

2.3 元组

元组: 是一个不可变的list; 记录一定的维度[位置]的数据信息

元组的拆包

本质上是将元组中的数据提取

0. 元组的拆包方式在任意可迭代对象中都是通用的

1. for-loop

2. *

   • *拆包返回的是list

3. 平行赋值

4. a, b = b, a 本质上也是拆包

5. 可以使用_占位符来过滤掉不需要的数据

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

# 1.for-loop
a = (1, 2, 3)
for i in a:
    print(i)
    
# 2.*
# 提取元素
i, *j = a
# 将可迭代对象拆开作为函数的参数
b = (3, 4)
divmod(*b)

# 平行赋值
i, j, m = a

2.3.1 具名元组

collections.namedtuple构建的类的实例所消耗的内存和元组一样, 因为字段名都存在了相应的类里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# namedtuple
from collections import namedtuple

# define a class
# namedtuple(str, iterator)
#   >>> str: the name of class
#   >>> iterator: define the attributes of class
#   >>> iterator(if accept str): "name age score" split whith ' '
student = namedtuple('student', ['name', 'age', 'score'])

# create some instances
drink = student('Drink', '21', '90')
starfire = student('starfire', '23', '92')
spark = student('spark', '24', '95')

print(drink)
print(starfire)
print(spark)

student(name='Drink', age='21', score='90')
student(name='starfire', age='23', score='92')
student(name='spark', age='24', score='95')

# we can get the specify value by [] or .attr
print(drink[0])
print(drink.name)

Drink
Drink

除了从普通元组继承的属性之外, 具名元组还有独特的属性:_fields类属性|类方法|_make(iterable)和实列方法_asdict()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

...
# get all attrs of drink
print(drink._fields)

('name', 'age', 'score')

# exchange drink into dict
drink_dict = drink._asdict()
for key, value in drink_dict.items():
    print(key, ":", value)
    
name : Drink
age : 21
score : 90
    
# accept date generate an instance
data = ("star", "20", "60")
star = student._make(data)
print(star)

student(name='star', age='20', score='60')

2.3.2 不可变列表[元组]

元组支持列表的大多数操作除了增删改元素之外

2.4切片

1. 切片支持大多数可变序列
2. 切片的数学表达式为[<= <)
3. 区间运算start default=0
4. s[a:b:c] start end step其中step可以为负即反向取值

本质上在使用slice取值时, python会调用seq.__getitem__(slice(start, end, step))

或者说slice()是一个切片对象, 可以改切片命名就像excel--sheet一样

1
2
3
4
5

name_slice = slice(0, 5)
a = "drink 21 98"
print(a[name_slice])

drink

2.4.1 多维切片|省略

多维切片所支持的数据序列也是多维度,而python内置的数据序列都是一维的

本质上多维切片seq[i, j]| seq[m:n, i:j]调用的是seq.__getitem__((i, j))或者seq.__setitem((i, j))

省略...在python解释器中是一个符号,其实本质上Ellipsis对象的别称

如果x是四维数组,那么x[i:...]就是x[i:::]的缩写

2.4.2 切片赋值

• 通过切片赋值右边必须是可迭代对象

2.5 对序列使用+和*

• +和*都遵守一条规律即不修改原有的操作对象而是创建一个全新的序列

• +通常是相同类型的数据

• 在操作中python会创建一个包含相同类型数据的序列作为拼接的结果

• 注意在使用seq * n操作时, 如果seq里的元素是对其他可变对象的引用的话, 虽然* n拼接了, 但本质上还是对seq的引用, 对其进行操作时很可能会出现”多重操作”

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

a = [["_"] * 3 for i in range(3)]

b = [["_"] * 3] * 3

a[1][2] = "X"
b[1][2] = "O"

print(a)
print(b)

[['_', '_', '_'],
 ['_', '_', 'X'],
 ['_', '_', '_']]

[['_', '_', 'O'],
 ['_', '_', 'O'], 
 ['_', '_', 'O']]

其中b时三个指向同一对象的引用

b所犯的错误和下面的错误一样

1
2
3
4
5
6
7
8
9
10
11

# list中追加的是对同一对象的三次引用
row = ["_"] * 3
board = []
for i in range(3):
    board.append(row)
    
# should optimize to this 
board = []
for i in range(3):
    row = ["_"] * 3
    board.append(row)

2.6 序列的增量赋值

即就地增量 += *= (仅针对可变序列), 不可变序列增量拼接的话实现的是 + * 每次都会创建一个新对象,效率会很低(str除外, 因为对于str的拼接操作过于频繁, CPython对其进行优化)

在调用这些运算符中, python优先调用__iadd__|__imul__如果没有会次级调用__add__|__mul__

需要注意的是:

如果a实现了__iadd__那么+=会实现就地增量赋值,像a.extend(iterator) 否则会调用__add__, 此时不是就地增加,而是首先计算a + b得到一个新的对象, 然后再将对象赋值给a,即是否实现就地完全取决于这个类型有没有实现__iadd__

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

aa = [1, 2, 3]
print(id(aa))
aa += [1, 23]
print(id(aa))

ss = "123"
print(id(ss))
ss += "qwer"
print(id(ss))

1168530238600
1168530238600
1168257348464
1168257157616

对不可变序列进行重复拼接操作:

1. 创建一个新对象
2. 将原来对象的元素复制到新对象中
3. 追加寻元素

str有优化:在为str初始化内存的时候,程序会为他流出额外的可扩展空间,因此进行增量操作的时候,并不会涉及复制原有字符串到新位置的这一操作

2.6.1 元组的增量赋值

1
2
3
4
5
6
7
8

t = (1, 2, [1, 2])
t[2] += [3, 4]

Traceback (most recent call last):
  File "<input>", line 2, in <module>
TypeError: 'tuple' object does not support item assignment
print(t)
(1, 2, [1, 2, 3, 4])

1. 元组中的元素被成功拼接
2. 解释器抛出异常

其实写成t[2].extend([3, 4])就不会抛出异常了

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

# 使用dis.dis展示操作的python字节码
dis.dis('tuple[i] += iter')

  1           0 LOAD_NAME                0 (tuple)
              2 LOAD_NAME                1 (i)
              4 DUP_TOP_TWO
              6 BINARY_SUBSCR
              8 LOAD_NAME                2 (iter)
             10 INPLACE_ADD
             12 ROT_THREE
             14 STORE_SUBSCR
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

• BINARY_SUBSCR: 将值存入stack (DONE)
• INPLACE_ADD 完成 += (DONE)
• STORE_SUBSCR 赋值 (ERROR)

可以得出:

1. 不要把可变对象放在元组里
2. 增量赋值不是一个原子操作
   • 先计算
   • 后赋值

2.7 排序.sort和sorted()

两者都是排序, 且内部算法使用的是Timsort,它是一种自适应算法,会根据原始数据的顺序特点交替使用插入排序和并归排序,而且Timsort算法是稳定的(相等元素的相对位置保持不变)

• seq.sort: 就地排序, 在原始数据的基础上排序, id不会改变, 这个方法返回None

  • python operation返回None表示就地修改, 不会创建新对象
  • 如果函数或者方法对对象进行就地修改,那么就应该让他返回None,通知调用者传入的参数发生改变,但并未创建新对象
  • random.shuffle(iterator)|id(iterator)不会修改
  • 返回None表示就地改动又个弊端, 就是调用者无法串联接口,即始终使用的是一个对象引用

• sort(obj) 会返回一个新建的list

  • 可以接收任何形式的可迭代对象作为参数,包括不可变序列和生成器
  • 最后返回的是一个list

• 两者都接受两个参数

  1. reverse=False: 是否反向排序
  2. key=identity function:接收一个排序fun通常使用lambda函数
     • 恒等函数(identity funtion)默认用元素自己的值进行排序
     • key=str.lower:忽略大小写排序
     • key=len: 基于长度排序

• 接收key参数:

  1. min|max
  2. sort|.sort
  3. itertools.groupby()
  4. heapq.nlargest()|heapq.nsmller()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import random
from itertools import groupby
from operator import itemgetter
from heapq import nlargest, nsmallest


random.seed(7)

a = [i for i in range(5)]

# 就地随机打乱seq
random.shuffle(a)

print(a)
a.sort()
print(a)
print(nlargest(3, a))
print(nsmallest(3, a))


temp_data = [
    {"name": 1, "age": 1},
    {"name": 2, "age": 32},
    {"name": 1, "age": 45},
    ]

# 根据list中每个ele中的name进行排序
temp_data.sort(key=itemgetter("name"))

# 过滤key=name
for name, data in groupby(temp_data, key=itemgetter("name")):
    print(f"name---[{name}]-----> [{list(data)}]")
    
[4, 0, 3, 1, 2]
[0, 1, 2, 3, 4]
[4, 3, 2]
[0, 1, 2]
name---[1]-----> [[{'name': 1, 'age': 1}, {'name': 1, 'age': 45}]]
name---[2]-----> [[{'name': 2, 'age': 32}]]

2.8 bisect管理有序序列

bisect模块包含两个主要的函数bisect和insort, 两者都是通过二分法获取index并进行操作

bisect(haystack, needle), 在haystack中搜索needle其中:

1. haystack必须是有序的
2. return index

bisect可以建立一个用数字作为索引的查询表格, 比如把表格和成绩对应起来

1
2
3
4
5
6
7
8

import bisect


def grade(socre, grades=None, breakpoints="FDCBA"):
    if grades is None:
        grades = [50, 60, 70, 80, 90]
    socre_index = bisect.bisect(grades, score)
    return breakpoints[socre_index]

bisect.insort(seq, item) 把变量item插入到有序序列seq中[本质上是通过二分法获取index后插入]

• 如果只是处理数字列表的话, array是一个更好的选择

2.9 当list不是首选时

list可以处理多个数据类型,但当面对大量的数字类型时, array是一个更好的选择

1. 数组存储的不是num对象,而是数字的机器翻译(字节表述)
2. 和C语言的数组一样, 如果需要频繁的对序列进行进出操作, deque的速度会更快
3. 在处理包含操作时,set是个更好的选择,python对此进行过优化,需要注意的是,set不是序列,他是无序的

2.9.1 数组

array.array在存储数字方面效率胜于list且支持list的基本操作,此外数组还提供从文件读取(.frombytes)和存入文件(.tofile)的快速方法

python中的数组和C一样, 在创建数组时都需要一个类型码,以表明要存储的数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from array import array
from random import random

# init a array
floats = array("d", [random() for _ in range(10 ** 7)])
# get ele by index
print(floats[1])

# init the path
file_path = "./floats.bin"

# open the file with "wb"
fp = open(file_path, "wb")

# write the data to the specify file
# by binaryIO
floats.tofile(fp)

# close the file
fp.close()

# init an empty array
floats2 = array("d")

# open the file with "rb
op = open(file_path, "rb")

# open the file 10 ** 7 from file
# by binaryIO
floats2.fromfile(op, 10**7)
print(floats2[1])

method区别:

1. 数组不支持浅拷贝|但支持__deepcopy__
2. 数组支持seq.reverse()但不支持seq.__reversed__()
3. 数组不支持就地排序seq.sort()

从python3.4开始数组不再支持就地排序seq.sort(), 如果需要排序得用sorted函数重新建立一个数组

a = array.array(a.typecode, sorted(a))

2.9.2 内存视图

memoryview是一个内置类, 可以让用户在不复制内容的情况下操作同一数组的不同切片

• 本质上是泛化和去数学化的Numpy数组
• 可以在不需要复制内容的前提下,在任何数据结构之间共享内存
• 处理大数据很实用 –> 节省了数据copy内存和时间
• 需要注意是对原数据直接进行操作

memoryview.cast能用不同的方式读写同一块内存数据,并且内容字节不会随意移动,会把同一块内存里的内容打包成一个全新的memoryview.cast对象给你

不同方式:可以用不同的读写方式操作数据

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

# init array 类型码“h”
temp_array = array('h', [1, 2, 3, 4, 5, 6])

# 利用数组创一个memoryview实例
view = memoryview(temp_array)

# 创建一个memoryview实例,其中把这块内存内容用“B”类型存储[无符号字符]
cast = view.cast("B")

# .tolist()以列表的形式查看|return --> list
temp = cast.tolist()

# 把位于1的字节赋值为6, 因为把占2个字节的整数高位字节改成了6
# 那么之歌有符号整数的值就变为了 1537
cast[1] = 6

2.9.3 NumPy|SciPy

NumPy和SciPy提供了高阶数组和矩阵操作, python内置数据类型都是一维数据

维度: row

每个维度所含元素: col

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import numpy

a = numpy.arange(12)
print(a.shape)
# 表述1维row 12元素
(12,) 

# using unpacking tuple 
# 将1维12元素转化成4维3元素
a.shape = 4, 3
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

# get index_row = 1 index_col = 2
a[1, 2]

# get all index_row index_col = 1
a[:, 1]

# transpose() matrix
# return new view
a.transpose()

2.9.4 双向队列

用列表和append pop(0)可以实现队列 先进先出, 但是删除list中的第一个或者在第一元素前添加一个元素都是十分耗时的, 因为这涉及到所有元素的移动

collection.deque双端队列实现了队列两端元素操作的优化, 但是涉及到中间元素的操作依然会耗时, 并且是一个thread safe类

• 快速从两端对元素进行操作
• 存储最近使用的几个元素
• collection.deque可以实现简单的过期机制<通过设置maxlen>
• append(item)|popleft(index)都是原子操作, 因此deque可以在多线程程序中安全地当作先进先出的栈使用, 而且使用者不需要担心资源锁问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from collections import deque

# create dequeue maxlen=10 eles=range(10)
dq = deque(range(10), maxlen=10)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# append one ele - right
dq.append(10)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# append one ele - left
dq.appendleft(0)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# rotate num ele default=right | negative=left
# return None ==> will change ori data
dq.rotate(3)
# [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]

# extend iterator ele default=right
dq.extend([10, 11, 12])
# [0, 1, 2, 3, 4, 5, 6, 10, 11, 12]

# extendleft iterator ele
# attention the order!
dq.extendleft([-1, -2, -3])
# [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6]

2.10 线程安全

除了collections.deque外还有其他python标准库也有对队列的实现

queue

提供了同步线程安全类Queue|LifoQueue|PriorityQueue,不同的线程可以利用这些数据类型来交换信息

• 线程通信
• 三个类构造时都有一个可选参数maxsize用来限制队列大小
• 在满员时这些类并不会丢掉旧的元素腾出位置
• 而是会锁住资源, 直到另外的线程移除了某个元素
• 适合控制活跃线程的数量

multiprocessing

这个包实现了自己的Queue和queue.Queue类似, 是设计给进程通信用的还有一个multiprocessiong.JoinableQueue

• 进程通信
• 任务管理

asyncio

python3.4及以上提供, 里面有Queue LifoQueue PriorityQueue和JoinableQueue这些类受到queue和multiprocessing的影响,用于异步变成任务管理

• 异步编程

heapq

和上面三个模块不同, heapq没有队列类,而是提供了heappush和heappop方法, 可以让用户把可变序列当作堆队列或者优先队列使用

本章小结

可变序列 不可变序列

容器序列: 存储引用 非连续存储

扁平序列: 存储值 连续存储 原子性数据

列表: 列表中数据最好是具有相同特性的数据

拆包: 获取元组内数据最安全可靠的方法,*拆包的利器

具名元组: 将元组与数据关联

• namedtuple()._asdict将具名元组转化成ordereddoct
• dict(zip(iter_key, iter_value))普通元组转化dict

序列切片是python中最受欢迎的语言特性之一

对切片赋值是一个修改可变序列的捷径

重复拼接n*seq要在正确的前提下使用!!!!!

• 初始化含有不可变元素的序列

增量赋值+= 和 *=的操作行为和序列本身有关(可变序列|不可变序列)

PS: string类型有优化不会重复复制原数据

• 可变序列: 就地修改

• 不可变序列: 生成新的序列

  sort和sorted()与key的用法

• 背后的逻辑是timsort算法, 它是一种自适应算法, 会根据原始数据的特点交替使用插入排序和并归排序

元组的鼻祖是ABC语言中的compounds, tuple更准确的说是frozenlist

key参数

再使用默认函数key进行排序时Python总会比较两个键, 但是这一计算阶段发生在C语言层, 这也是比调用用户自定义比较函数快的原因

• 当ele是int 或者str时, key支持int或者str
  • int: 比较整个数值
  • str: 只比较第一位数值

1
2
3
4
5
6

temp_1 = [3, 45, 2, "10", "34"]
print(sorted(temp_1, key=int))
print(sorted(temp_1, key=str))

[2, 3, '10', '34', 45]
['10', 2, 3, '34', 45]

Part3.Dict|Set

dict的内置函数_builtins_.dict_, Python对字典实现了高度优化 –> hashtable

3.1 泛映射类型

collections.abc中含有Mapping和MutableMapping这俩个抽象类,为dict和其他类似的类型定义形式接口

非抽象类一般不会直接继承这些抽象基类, 而是直接对dict或者collections.User.Dict进行扩展,这些抽象基类的主要作用是作为形式化的文档, 定义构建一个映射类型所需要的最基本接口.而且还可以与isinstance一起使用来判断某个数据是否是广义上的mapping类型

1
2

my_dict = {}
isinstance(my_dict, abc.mapping)

• 使用isinstance而不是type
• 可以判断除dict外的广义映射类型

标准库的所有映射类型都是通过dict来实现的,他们有个共同的限制, 即key必须是可散列的

可散列数据

1

An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__() method), and can be compared to other objects (it needs an __eq__() method). Hashable objects which compare equal must have the same hash value. 

• 含有__hash__ 散列
• 含有__eq__ 比较key
• 哈希值在整个声明周期不会变化
• 散列对象相等==>散列值一定相等

可散列的数据类型:

• str
• bytes
• 数值类型
• frozenset
• tuple(所含的元素全为可散列)

一般用户自定义的类型的对象都是可散列的, 其中散列值就是id(obj), 所以所有这些对象在比较时都是不相等的. 如果一个对象实现了__eq__方法, 并且在方法中用到了这个对象的内部状态的话, 那么只有当所有这些内部状态都是不可变的情况下, 这个对象才是可散列的

构造字典方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

>>
dict(name="Drink", age="23", score="98")

>>
{"name": "Drink", "age": "23", "score": "98"}

>>
dict(zip(["name", "age", "score"], ["Drink", "23", "98"]))

>>
dict([("name", "Drink"), ("age", "23"), ("score", "98")])

>>
dict({"name": "Drink", "age": "23", "score": "98"})

>>
{key, value for key, value in iterator(key-value-pair)}

3.2 字典推导

推导式的作用:

创建新的数据对象

过滤作用

3.3 常见的映射方法

映射类型的方法很丰富, dict defalutdict 和OrderedDict的常见方法, 后面两个数据类型是dict的变种,位于collections模块内

default_factory不是一个方法而是一个可调用对象, 他的值在defaultdict初始化中由用户设置

OrderedDict.popitem()会移除最先插入的元素**(先进先出), 如果.popitem(last=True)则会移除最后插入的元素(后进先出)**

d.update(m, [**kargs]), 在处理m时, 函数首先检验m是否有keys方法,

• 有–>update会把它当作映射对象处理
• 无–>update会把它当作含有(key-vaule)键值对元素的迭代器
• python大多数映射类型的构建都采用了相似的逻辑

可调用对象

将类当作函数调用instance()

• 类中实现__call__
• 快速调用带有某一实例化属性的类的函数

1
2
3
4
5
6
7
8
9

class eval_some:
    
    def __init__(slef, g):
        self.g = g
    def __call__(self, t):
        return (self.g * 2) / t

earth = eval_some(9.8)
print(earth(10))

3.3.1 更新字典kV

用setdefault处理找不到的键

d[k] --> getitem找不到键时, 会有异常抛出KeyError

• 符合python的快速失败哲学
• 可以使用d.get(k, default)代替异常
• 当在更新某个键对应的值的时候, 以上俩个方式效率都很低

如果要更新字典的一个键值对(包括不存在)使用setdefault(key, default) [operate]这样只会query 1,如果使用if else []则会查询2~3次

1
2
3
4
5
6
7
8
9
10
11

a = {"name": "Drink"}

# 这里只会查询一次key并更新或初始化
# 如果key存在则对key-value更新
# 不存在将key-default放进映射中
a.setdefault("things", []).append("reading")

# 当存在key时查询2次, 不存在会查询3次
if "things" not in a:
    a["things"] = []
a["things"].append("reading")

3.4 映射的弹性键查询

在映射中查找不存的key时, 我们希望可以返回一个default value而不是error, 以下俩途径可以实现弹性键查询

1. 通过defaultdict这个类而不是普通的dict
2. 自己定义一个dict子类, 并在在子类中实现__missing__方法

3.4.1 defaultdict处理不存在的key

defaultdict是collections中的一个类, 在实例化它时,可以接受一个defaultfoctory不接受参数(一定是可调用的且不接受参数的方法类|函数)

1. 在调用d[key]中如果__getitem__找不到对应的key会调用__missing__查看是否定义了defaultfactory

2. 将defaultfactory返回的值赋值给d[key]

3. 更新dict

1
2
3
4
5
6
7
8

from collections import defaultdict

temp = defaultdict(list)

temp["name"]
print(temp)
>> 
defaultdict(<class 'list'>, {"name": []})

• 如果defaultfactory=None在没有找到对应的key时会抛出KeyError

• defaultfactory只会在__getitem__中调用, 比如dict[key]才会被调用, 其中连接两者桥梁的时__missing__

3.4.2 特殊方法missing

所有的映射类型在找不到key的时候都会牵扯到missing, python基类虽然直到这个方法,但并没有定义这个方法, 不过, 如果一个class继承了dict并且这个类提供了missing方法,那么在getitem找不到值的时候不会抛出异常

特点:

1. missing方法只会被getitem调用
2. 不会对.get() __contains__方法产生影响

dict[key] -- __getitem__ -- __missing__

dict.get() -- get -- try except

如果要自定义一个映射类型, 更合适的策略是继承collections.UserDict

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# define the new mapping class by user based on dict
class StrKeyDict(dict):

    def __missing__(self, key):
        # 如果键不存在且本身是str则抛出异常
        if isinstance(key, str):
            raise KeyError(key)
        # 如果键不存在且本身不是str则调用getitem
        return self[str(key)]
    
    # get方法吧查找工作用self[key]的形式委托给getitem,这样
    # 在宣布查找失败之前还missing再给某个键一个机会
    def get(self, key, default=None):
        try:
            return self[key]
        except KeyError:
            # 如果cast异常则missing也失败了,返回default
            return default

    def __contains__(self, key):
        # 按照传入键的原本值来查找,如果没找到则转化成str再次查找
        return key in self.keys() or str(key) in self.keys()

像k in dict.keys()操作在python3中是十分快速的, 即使映射类型对象很庞大, 因为:

• dict.keys()返回的值是一个视图, 就像集合, 在里面查找一个元素是十分快的
• key in dict扫描的是一个list, 处理大数据效率低dict.keys()

3.5 字典的变种

都是基于collections库

除了bultin中定义的dict外, 其余字典的变种都是collections库中的

UserDict

比较特殊的一种dict, 这个类其实是把builtin中的dict用纯Pyhton又实现了一遍

一般用于用户自定义子类的继承

OrderedDict

这个类型会在添加键的时候保持顺序, 因此键的每次迭代次序总是一致的

OrderedDict的popitem方法默认删除并返回的时字典里的最后一个元素(先进后出), 如果popitem(last=False)则会删除并返回第一个元素(先进先出)

ChainMap

什么是chainmap?为什么要搞chainmap

该类型可以容纳数个不同的映射对象,然后在进行键查找操作时, 这些对象会被当作一个整体逐个进行查找,直到键被找到

在给有嵌套功能作用域的语言做解释器的时候很有用, 可以用一个映射对象来代表一个作用域的上下文

ChainMap可以将多个字典合并为一个独有的字典，这样的操作 并不是对源数据的拷贝，而是指向源数据，假如原字典数据修改，ChainMap映射也会改变；如果对ChainMap的结果修改，那么原数据一样也会被修改

使用update进行合并字典,是对源数据的拷贝

1. ChainMap 可接受多个映射然后在逻辑上使它们表现为一个单独的映射结构；它只是维护了一个记录底层映射关系的列表，然后去重定义常用的字典操作

2. 如果有重复的键，会采用第一个映射中键对应的值

3. 修改 ChainMap 映射结构，会同时作用在自己和原始字典结构上

4. 可以使用字典的 update() 方法，来替代上面的合并方案；但是这就需要创建一个新的字典对象(或者修改原字典，破坏了原始数据)，并且原始字典做了修改，并不会反映到新建的字典上

5. ChainMap 使用的就是原始字典，因此原字典变，它也会改变。

6. 如果在使用 ChainMap 合并多个字典时，字典中有重复的 key 值，默认取第一个字典中 key 对应的 value ，从原理上面讲，ChainMap 实际上是把放入的字典存储在一个队列中，当进行字典的增加删除等操作只会在第一个字典上进行，当进行查找的时候会依次查找(以查找的第一个key-value返回)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

m1 = {"name": "Drink", "age": 23}
m2 = {"name": "Drinkle", "score": 93}
m3 = {"name": "Spark", "age": 23, "score": 98, "sex": "man"}

cm = collections.ChainMap(m1, m2, m3)
print(cm)
print(cm["name"])

for key, value in cm.items():
    print(key, " <--> ", value)

ChainMap({'name': 'Drink', 'age': 23}, {'name': 'Drinkle', 'score': 93}, {'name': 'Spark', 'age': 23, 'score': 98, 'sex': 'man'})
Drink
name  <-->  Drink
age  <-->  23
score  <-->  93
sex  <-->  man

Counter

这个类型会给键准备一个整数计数器, 每次更新一个键的时候都会增加这个计数器.因此这个类型可以用来给可散列对象计数(str bytes frozenset 数值型)或者当成多重集来用–>多重集合就是集合里的元素可以出现不止一次, Counter实现了+ - 运算符来和并记录

还有像most_common(num)这类方法, 会按照次序返回映射里最常见的num个键和他们的计数

1
2
3
4
5
6
7
8
9
10
11

counter = collections.Counter("asdxzcsdfwerewrfewzsqawd")

print(counter)

counter.update("asdsassd")

print(counter.most_common())

Counter({'w': 4, 's': 3, 'd': 3, 'e': 3, 'a': 2, 'z': 2, 'f': 2, 'r': 2, 'x': 1, 'c': 1, 'q': 1})

[('s', 7), ('d', 5)]

3.6 子类化UserDict

自定义mapping类型,以UserDict为基类更加方便,因为UserDict是原生的方法, 而dict可能会走写捷径,导致我们不得不在子类中重写这些方法, 而UserDict则不会出现这个问题

需要注意的是, UserDict并不是Dict的子类,但在data属性是基于Dict的实例实现的, 这个属性实际上是UserDict最终存储数据的地方

• UserDict的子类在实现__setitem__避免了不必要的递归
• 可以让__contains__的代码更加简洁

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

import collections

class StrKeyDict(collections.UserDict):
    
    def __missing__(self, key):
        if isinstance(key, str):
            raise KeyError (key)
        return self[str(key)]
    
    def __contains__(self, key):
        return str(key) in self.data
    
	def __setitem__(self, key, value):
        self.data[str(key)] = value

UserDict继承的是MutableMapping,所以StrKeyDict里剩下的映射类型方法都是从UserDict MutableMapping 和 Mapping这些超类中继承的

Mapping类虽然是一个抽象基类ABC,但它提供了许多实用方法

1.MutableMapping.update

• 可以直接使用dict.update(obj)
• 定义在__init__中, 实列化时可以接受多个不同类型的参数构造dict
• 本质上调用的是__setitem__ –> self[key]=value

2.Mapping.get

• .get() –> def get() –> try except

3.7 不可变映射类型

接受一个mapping类型, 返还一个动态只读视图, 在原数据上更改可以反映到视图上,但不能对视图进行写操作, 只能读取 types.MappingProxyType

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from types import MappingProxyType

temp = {"name": "Drink"}

proxy_dict = MappingProxyType(temp)

>>
proxy_dict["name"] 
proxy_dict["age"]
proxy_dict["score"] = 90
temp["age"] = 23
proxy_dict
>>
<Dirnk>
<KeyError: 'age'>
<TypeError: 'mappingproxy' object does not support item assignment>
<SUCCESS>
<{'name': 'Drink', 'age': 23}>

3.8 集合论

集合从2.3以module出现, 到2.6才成为built-in type, 包括set frozenset

集合的本质是许多唯一对象的聚集(去重)

拥有极快的查找速度 ==> 散列表

空集 –> set()

{} –> dict 本质上是一个空字典

集合内元素必须是can hash即可散列的

• str
• bytes
• 数值类型
• frozenset

集合的操作

| –> ∪

& –> ∩ –> set.intersection(set)

- –> 差集

3.8.1 集合字面量「仅set」

除了空集合set()外, 集合的字面量如同{1} {1, 2}

字面量语句构造集合的方法比set([1, 2, "3"])更快, 后者python需要新建一个列表, 最后吧这个列表传入到构造方法中, 如果是{1, 2, "3"}的字面量构造, python会利用一个BUILD_SET的字节码创建集合

使用反汇编函数查看字节码:

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

from dis import dis

dis("{1}")
dis("set([1])")

0 LOAD_CONST    0 (1)
2 BUILD_SET     1
4 RETURN_VALUE
            
0 LOAD_NAME      0 (set)
2 LOAD_CONST     0 (1)
4 BUILD_LIST     1  --
6 CALL_FUNCTION  1  --
8 RETURN_VALUE

python对于frozenset没有特殊字面量句法, 只能采用构造的方式

3.8.2 集合推导

同列表推导字典推导一样

1. 创建一个新的序列
2. 起到过滤条件的作用

3.8.3 集合的操作

1
2
3
4
5
6
7
8
9
10

a = {1, 2, 3}

# KeyError
a.remove(4) 

# pop the first one ele
a.pop()  

# if number not in set do nothing
a.discard(4)

下表中, 缀运算符需要两侧的对象都是集合类型, 但是其他的方法则只要求所传入的参数是可迭代对象

集合的比较运算符, 返回布尔值

集合的其他操作方法

3.9 dict和set的原理

principles of dict and set, 了解python里的字典和集合类型,他们背后所涉及的hash table是必不可少的

这节将会回答以下几个问题

1. python中的dict和set效率有多高?
2. 为什么他是无序且不稳定的?
3. 为什么并不是所有的python对象都可以当作dict的key或set里的number?
4. 为什么dict的key和set的number的顺序是根据它们被添加的次序而定的,以及为什么在映射对象的生命周期中,这个顺序并不是一成不变的?
5. 为什么不应该迭代循环dict或set的同时往里面添加元素?

1
2
3
4
5
6
7
8

temp_list = [1, 2, 3, 4]
a = {"name": "Drink"}.fromkeys(temp_list, "")
print(a)

dict.fromkeys(iterator, values)
# Create a new dictionary with keys from iterable
# and values set to value.
{1: '', 2: '', 3: '', 4: ''}

3.9.1 效率实验

使用in set(&) 操作符,分别在set dict list查询是否含有某个元素

其中结果如下:

最快的是&

最慢的是list in

由于列表背后没有散列表来支持in运算符, 每次搜索都会扫描一次完成的列表 [说明了, dict和set在使用散列表存储的时候使用了类似排序的功能]

3.9.2 dict中的散列表

这一节只是笼统的描述python如何使用hashtable来实现dict, 其中Cpython对dict有过优化

散列表

• 本质上是一个稀疏数组(总是有空白元素的数组称为稀疏数组)

• 散列表中的单元叫做表元(bucket)

• 在dict的散列表中, 每个键值对占用一个表元,一个表元有俩部分, 分别是对值的引用和对键的引用

• 表元大小一致, 可以通过偏移量读取特定的表元

• python会保证散列表中大约三分之一的表元是空的,如果达到阈值, 原有的散列表会被复制到一个更大的空间中

• 把对象放入散列表, 首先使用hash()计算这个元素键的散列值

有关散列表的概念:

1.散列值和相等性

hash() ==

• hash()可以用于任何内置类型对象, 自定义对象调用自定义实现的__hash__
• 如果俩对象在比较时是相等的, 则它们的散列值一定相等(但对象的类型和存储结构不一定相等)
• 为了让散列值可以当作散列表的索引, 越是相似但不相等的对象,他们散列值的差别就越大

从python3.3开始 str bytes datetime对象的散列值计算过程中多了随机加盐 所加盐值是python进程内的一个常量每次启动python解释器都会生成一个不同的盐值,目的是为了防止DOS攻击而采取的安全措施

2.散列表算法

以dict[key]为例:

• python首先会调用hash(key)计算key的散列值
• 把计算的散列值最低的几位数字当作偏移量, 在散列表中查找表元bucket
  • 具体取几位要看散列表的大小
  • 若对应的表元为空 –> KeyError
  • 若非空 –> 表元里会有key-value-pairs
• python会校验key-value-pairs中的key与输入的key是否相等==
  • 相等 –> 返回对应的value
  • 不等 –> 散列冲突
• 散列冲突: 因为散列表所做的是把随机的元素映射到只有几位的数字上,而散列表本身的索引又依赖于这个数字的一部分
  • 为了解决冲突,算法会在散列值中另外再取几位数字用特殊方法处理后把新的数字当作索引寻找表元,并重复之前的操作

添加新元素:

发现表元为空时会放入一个新元素

更新元素:

找到表元后会更新元素

需要注意的是,python会按照散列表的拥挤程度来决定是否要重新分配内存为它扩容,如果增加散列表的大小,那散列值所占的位数和用作索引的位数会增加,减少了散列冲突

**注意:**Cpython中规定如果有一个整型对象,而且他能存进入一个机器字中,那么他的散列值就是它本身

3.9.3 dict的实现和限制

主要讨论hashtable给dict带来的优势和限制

1.键必须是可散列的

包括: str bytes frozenset 数值类型

一个可散列的对象必须包括

• 支持hash()函数并且通过__hash__所得到的散列值不变(在他的生命周期中)
• 支持通过__eq__方法检测相等性
• 若a==b那么hash(a)==hash(b)
• 所有由用户自定义的对象默认都是可散列的,因为他们的散列值都是id()来获取的,而且他们不相等

**注意:**如果自定义的类实现了_eq_,并且希望他是可散列的, 那么必须定义一个恰当的_hash_保证a==b时hash(a)==hash(b)另一方面,如果一个含有自定义_eq_依赖的类处于可变状态, 那么就不要在这个类中实现_hash_,因为他的实例是不可散列的

2.字典在内存中开销大

• 字典使用散列表实现
• 散列表是稀疏的
• 在自定义类中_slots_属性可以改变实例属性的存储方式, 由dict-->tuple
• optimization优化往往和可维护相对立maintain

3.键查询很快

• 空间换时间
• hash table实现了无视数据量大小的快速访问(在数据能放入内存的前提下)

4.键的次序取决于添加次序

• 在添加新键时, 可能会由哈希冲突, 此时新键会被安排到另一个表元(bucket)中
• 但是和俩个值相同的键添加顺序有关
• 虽然逻辑和面向用户表现形式上如此,在判断俩上依旧是相等的

1
2
3
4
5
6

a = {"name": "Drink", "age": 23}
b = {"age": 23, "name": "Drink"}
if a == b:
    print("you are right")
>>
right

5.添加新键会改变已有键的顺序

尽量不要边遍历边添加新键

• 添加新键
• python解释器为字典扩容
• 新键散列表并把已有元素添加到新表中
• 这个过程可能会发生散列冲突,导致新散列表中键的次序变化
• 如果在迭代一个字典的所有键的过程中同时对字典进行修改,那么这个循环可能会跳过一些键甚至是字典中已有的键

因此:不要对字典同时进行迭代和修改,如果扫描并修改一个字典,最好分成俩步 :

​ [迭代–得出要添加的内容–并把内容放到新字典]

​ [对原有字典进行更新]

不过在python3中对此进行了优化,.keys() .items() .values()方法返回的都是字典视图, 换句话说这些方法返回的更像set而不是list,此外视图还可以动态的反馈字典的变化

3.9.4 set的实现和限制

set 和 frozenset的实现也依赖于散列表

• 在散列表中只存放元素的引用(类似只存放key的引用)
• 集合中的元素必须是可散列的
• 集合很消耗内存
• 可以很高效的判断元素是否在集合中
• 元素的次序取决于被添加到集合中的顺序
• 在集合里添加元素会改变集合里已有元素的次序

本章小结

dict是python的基石, 除了dict外builtin里还提供了特殊映射比如collections里的defaultdict OrderDict ChainMap Counter UserDict以及types里的MappingProxyTypes

映射类型的重要方法

1.setdefault

• 更新字典里存档的可变值(比如列表)
• 避免重复搜索键

2.update

• 让批量更新字典成为可能

3.missing

• 可以自定当找不到对应的key时, 对象如何处理

collections.abc模块提供了Mapping和MutableMapping俩大抽象基类,利用它可以进行类型查询或者引用,此外还有Set和MutableSet俩大抽象基类

Part4.TextAndBytes

human use text and computer use bytes.

本章节主要讨论:

• 字符 码位 字节表述
• bytes bytearray 和 memoryview等二进制序列的独特性
• 全部unicode和陈旧字符集的编解码器
• 避免和处理编码错误
• 处理文本文件的最佳实践
• 默认编码的陷阱和标准I/O问题
• 规范化 Unicode文本 进行安全比较
• 规范化 大小写折叠和暴力移除音调符号的实用函数
• 使用locale模块和PyUCA库正确地排序Unicode文本
• Unicode数据库中的字符元数据
• 能处理字符串和字节序列的双模式API

4.1 字符问题

字符串:一个字符序列, 本质上是一个序列; 问题是什么是字符?

2015年字符的定义为Unicode字符(面向人)

Unicode标准把字符的标识-和具体的字节表述进行了区分:

• 字符的标识即码位:是01114111的数字(10进制)在unicode标准中以46个十六进制数字标识,并且加前缀U+
• 字符的具体表述取决于所用的编码:编码是在码位和字节序列之间转换时使用的算法

把码位转化成字节序列的过程时编码,反之是解码

简单的理解:

码位是数字映射后的准备编码的字符标识;

字节序列是通过一定编码规则(算法)编码后的用于计算机存储和传播的字节序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# init string
a = 'advdv我'  

# advdv我字符串有四个Unicode字符
print(len(a))

# 使用UTF-8把str对象编码成bytes对象
b = a.encode('utf-8')

# check b and len of b
# \xe6 --> one 16-base
# 我 -encode-> three bytes
# -> \xe6\x88\x91
print(b, len(b))

# decode b with utf-8
# 使用UTF-8把bytes对象解码成str对象
print(b.decode('utf-8'))

>>
6 
# bytes对象字面量以b开头
# 字节序列b有8个字节 我被编码成了三个字节
b'advdv\xe6\x88\x91' 8
advdv我

python3的str类型基本相当于python2的unicode类型, 但是前者的bytes类型却不是把str类型换个名字那么简单

4.2 字节概要

python内置了两个基本的二进制序列类型其中有py3引入的不可变bytes类型和py2.6添加的可变bytesarray类型

bytes和bytearray对象的各个元素是介于0~255(含)之间的整数而不是py2的str对象那样的单个字符.

需要注意的是二进制序列的切片始终是同一类型的二进制序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# bytes对象可以从str对象加给定的编码方法构建
cafe = bytes("cafの", encoding="utf_8")
print(cafe)

# bytes对象中的各个元素是range(256)的整数
print(cafe[0])
# bytes对象的切片依然是bytes
print(cafe[:1])

# bytesarray对象没有字面量语句而是以bytearray()
# 和字节序列字面量参数的形式显示
cafe_arr = bytearray(cafe)
print(cafe_arr)
# bytearray对象的切片还是bytearray对象
print(cafe_arr[-1:])

>>
b'caf\xe3\x81\xae'
99
b'c'
bytearray(b'caf\xe3\x81\xae')
bytearray(b'\xae')