开发技术--Python核心知识A

开发|Python核心知识A

A篇，主要介绍Python基础中列表，元祖，字典，集合，字符串，I/O，条件与循环，异常处理的底层知识与使用的注意事项。

希望大家对于Python会有新的收获，本篇不同于之前的浅谈Python基础知识，会更加的深入，但是在深入的同时，涉及更多内容，需要自行看源码，着重点我会标明。

前言

目前所有的文章思想格式都是:知识+情感。
知识:对于所有的知识点的描述。力求不含任何的自我感情色彩。
情感:用我自己的方式，解读知识点。力求通俗易懂，完美透析知识。

正文

由于本文不是基础篇，所以重要的名词与知识点，如果不懂，就一定要多google.

谈谈Jupyter Notebook

使用过jupyter的人都知道，我简短做一下jupyter的介绍。

**Jupyter Notebook 官网: **https://jupyter.org/

** Jupyter 创始人: ** Fernando Pérez

**Jupyter 单词的解释: **Ju （Julia）、Py （Python）和 R 三种科学运算语言的计算工具平台，所以将其命名为 Ju-Py-te-R。

Jupyter能干什么: 把软件代码、计算输出、解释文档、多媒体资源整合在一起的多功能科学运算平台

建议: jupyter属于我定义的工具范畴，是加快学习的工具，所以需要掌握。

备注:关于jupyter在Python的安装与使用，我在IPython介绍里面已经写过。

谈谈列表(list)

列表内可以放置的内容: 任意数据类型。(有序)

特性: 列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素（mutable）。

list操作: 多使用append()，enumerate()，切片(注意步长的正负)，多使用[....]创建list(直接识别调用内置C函数)，少使用list()创建(使用函数方法，会创建stack，并进行操作的检验，expensive!)

时间复杂度:

增加 / 删除的时间复杂度均为 O(1)。

列表进行排序，然后使用二分查找，时间复杂度 O(logn) .

列表排序需要时间: O(nlogn)

遍历列表的时间复杂度是: O(n)

两层列表循环，在最差情况下，需要 O(n^2) 的时间复杂度。

list使用场景: 存储的数据和数量是不变的

底层实现: 在cpython中，为了减小每次增加 / 删减操作时空间分配的开销，Python 每次分配空间给列表的时候，都会额外多分配一些，这样的机制（over-allocating）。

源码角度:

浏览器输入:

1)https://github.com/python/cpython/blob/949fe976d5c62ae63ed505ecf729f815d0baccfc/Include/listobject.h#L23

2)https://github.com/python/cpython/blob/3d75bd15ac82575967db367c517d7e6e703a6de3/Objects/listobject.c#L33

显示list源码关键内容如下:

#ifndef Py_LIMITED_API
typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;

    /* ob_item contains space for 'allocated' elements.  The number
     * currently in use is ob_size.
     * Invariants:
     *     0 <= ob_size <= allocated
     *     len(list) == ob_size
     *     ob_item == NULL implies ob_size == allocated == 0
     * list.sort() temporarily sets allocated to -1 to detect mutations.
     *
     * Items must normally not be NULL, except during construction when
     * the list is not yet visible outside the function that builds it.
     */
    Py_ssize_t allocated;
} PyListObject;
#endif

源码解读:

列表(list)本质是 over-allocate 的数组(array)。(注意，数组就是数组，列表就是列表，数组不是列表，列表不是数组，不是一个概念。)

ob_item是一个指针列表，里面的每一个指针都是指向列表的元素。(这就是为什么列表可变)

allocated 表示的是当前列表确实被分配的空间大小。

ob_size 是列表的实际大小，实际大小是len(list) 获得结果，表示当前列表共存储了多少个元素。

为优化存储结构，避免每一次更改元素都重新分配内存，列表的分配空间allocated 会大于 ob_size。即: allocated >= len(list) == ob_size。

当分配给列表的空间满了的时候，就是allocated == len(list) 的情况，此时会向操作系统申请更大的内存空间，并将已经存在的元素全部拷贝到新的内存中。

每一个向操作系统申请内存的大小变化是:0, 4, 8, 16, 25, 35, 46, 58, 72, 88....

谈谈元祖(tuple)

元祖内可以放置的内容: 任意数据类型。(有序)

特性: 元祖是静态的，长度固定，无法增加删减或改变。

注意:

1. 只要对元祖修改，必然是开辟一块新的内存，将原有数据重新写入。
   
   2)虽然属于不可变数据类型，但是内部嵌套可变数据类型，可变数据类型仍属于动态。

tuple使用场景: 存储的数据和数量是变化的。

底层实现: ** Python内部对于静态资源 ，存在资源缓存（resource caching）。

解释一下，资源缓存就是静态数据当不被使用并且占用内存空间不大的时候，Python会对这些 资源进行缓存处理，并不会由于垃圾回收机制**而将数据返回给操作系统。当下次创建静态数据的时候，会直接使用已经缓存的内存空间，此时就节省了与操作系统交互的环节。

当tuple的大小不超过20，Python将其缓存子啊一个free list中，当下一次创建同样的tuple的时候，就直接去缓存中取出来，提高运行效率。

源码角度:

浏览器输入:

1)https://github.com/python/cpython/blob/3d75bd15ac82575967db367c517d7e6e703a6de3/Include/tupleobject.h#L25

2)https://github.com/python/cpython/blob/3d75bd15ac82575967db367c517d7e6e703a6de3/Objects/tupleobject.c#L16

显示tuple源码关键内容如下:

#ifndef Py_LIMITED_API
typedef struct {
    PyObject_VAR_HEAD
    PyObject *ob_item[1];

    /* ob_item contains space for 'ob_size' elements.
     * Items must normally not be NULL, except during construction when
     * the tuple is not yet visible outside the function that builds it.
     */
} PyTupleObject;
#endif

源码解读:

tuple本质上也是一个数组(array)，但是空间是固定的。并且tuple做了相应的优化(资源缓存)，提升程序的效率。

谈谈字典(dict)

字典 :是一系列由键（key）和值（value）配对组成的元素的集合。

key必须是不可变数据类型。(只有不可变数据类型才可以hash)

字典变成有序的啦!!!

在 Python3.7+，字典被确定为有序。

在 3.6 中，字典有序是一个 implementation detail，在 3.7 才正式成为语言特性，因此 3.6 中无法 100% 确保其有序性。

而 3.6 之前是无序的，其长度大小可变，元素可以任意地删减和改变。

字典的操作:

多使用{....}创建，少使用dict() 创建。

多使用.get()获取值，少使用[...]获取值。(get不报错，并可以自己指定没找到的返回值)。

常使用pop()， items()， keys(), values()。

时间复杂度:

存储，删除，增加数据的时间复杂度是: O(1)

字典的存储结构:

此时，需要回忆数据库的表结构。

老版本 Python 的哈希表结构如下:(随着数据量的增加，表会变的稀疏，空间利用率低)

它是一个 over-allocate 的 array，根据元素键（key）的哈希值，来计算其应该被插入位置的索引。

--+-------------------------------+
  | 哈希值 (hash)  键 (key)  值 (value)
--+-------------------------------+
0 |    hash0      key0    value0
--+-------------------------------+
1 |    hash1      key1    value1
--+-------------------------------+
2 |    hash2      key2    value2
--+-------------------------------+
. |           ...
__+_______________________________+

新版本哈希表，除了字典本身的结构，会把索引和哈希值、键、值单独分开，看下面:(提高空间利用率)

它把存储结构分成了 Indices 和 Entries 这两个 array，而’None‘代表这个位置分配了内存但没有元素。

Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------

Entries
--------------------
hash0   key0  value0
---------------------
hash1   key1  value1
---------------------
hash2   key2  value2
---------------------
        ...
---------------------

字典的工作原理:

1)计算key的哈希值，hash(key)

2)mask = PyDicMinSize - 1 和哈希值做与操作，计算这个元素应该插入哈希表的位置 index = hash(key) & mask。

3)如果哈希表此处是空的，那么这个元素就会被插入。

4)如果这个元素不是空的，分类讨论:

a:比较两个元素的哈希值和键是否相等，如果相等，表明这是同一个元素，如果值不同，增跟新字典的value，反之，啥都不错。

b:比较两个元素的哈希值和键是否相等，如果不相等，此时**哈希冲突(hash collision **意思是两个元素的键不相等，但是哈希值相等。)此时，需要一种解决冲突的策略。(最简单是线性查找，即从这个位置开始，挨个往后寻找空位，找到就插进去。但是Python不使用这个，因为线性效率不高)

注意:哈希冲突情况的发生，会降低字典的查找等操作速度。但是，哈希冲突概率极小，但是不代表不发生。

所以哈希表，通常会保证其至少留有** 1/3 的剩余空间。随着元素的不停插入，当剩余空间小于 1/3 时，Python 会重新申请得到更大的内存空间，扩充哈希表。此时，表内所有的元素位置都会被重新排放**。

谈谈集合(set)

集合: 没有键和值的配对，是一系列无序的、唯一的元素组合。

集合本质: 是一个 哈希表。(不能索引)

集合操作:

不要使用pop()。(集合无序，pop谁？？？)

时间复杂度:

添加与查找的时间复杂度是 O(1)

列表的哈希表:完全等同于字典的哈希表思路，只是没有value而已。

谈谈字符串(str)

字符串: 是由独立字符组成的一个序列，通常包含在单引号（''）双引号（""）或者三引号之中（''' '''或""" """，两者一样）。(不可变数据类型)

字符串操作:

字符串的算数运算: + 、*

多用 .join() 函数，实现字符串拼接

多使用 strip() ,split()

时间复杂度:

更改字符串的时间复杂度是O(n)

字符串的+操作:

从 Python2.5 开始，每次处理字符串的拼接操作时（str1 += str2），Python 首先会检测 str1 还有没有其他的引用。

如果没有的话，就会尝试原地扩充字符串 buffer 的大小，而不是重新分配一块内存来创建新的字符串并拷贝。

时间复杂度为 O(n) ，所以就可以直接使用+ 了吗？？

字符串的格式化

官方推荐使用: ''.format() ，是最新的字符串格式函数与规范

可以使用之前的方法: % 进行格式化。%s 表示字符串型，%d 表示整型。

谈谈I/O

I/O表示的是输入输出，不知道大家会不会直接想到，input()与print()，文件操作。

input() 函数暂停程序运行，同时等待键盘输入；直到回车被按下，函数的参数即为提示语，输入的类型永远是字符串型（str）。

所以，针对输入的str一般需要进行强制转换为 int 用 int()，转为浮点数用 float()。

Python 对 int 类型没有最大限制，但是对 float 类型有精度限制。

注意:在生产环境中使用强制转换时，请记得加上 try .....except（即错误和异常处理）。

文件操作:

生产级别的 Python 代码，大部分 I/O 则来自于文件、网络、其他进程的消息等。

计算机内核（kernel）对文件的处理相对比较复杂，涉及到内核模式、虚拟文件系统、锁和指针等一系列概念。建议所有的 I/O 都应该进行错误处理。

文件操作概览:

1)open（)函数

2)打开文件方式 r (默认)，w, a .... (注意:只需要读取文件，就不要请求写入权限)

3)read() (注意:文件过大的处理方法，可以给 read 指定参数 size ，用来表示读取的最大长度。还可以通过 readline() 函数，每次读取一行)

4)write()

5)close()

with上下文管理:

自动判断关闭打开的文件，代码简洁，不需要close()的出现。

JSON序列化:

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它的设计意图是把所有事情都用设计的字符串来表示，这样既方便在互联网上传递信息，也方便人进行阅读（相比一些 binary 的协议）。

JSON操作

json.dumps() 这个函数，接受 Python 的基本数据类型，然后将其序列化为 string；

而 json.loads() 这个函数，接受一个合法字符串，然后将其反序列化为 Python 的基本数据类型。

注意: 进行异常捕获。

**JSON业务场景: **当开发一个第三方应用程序时，可以通过 JSON 将用户的个人配置输出到文件，方便下次程序启动时自动读取。

**扩展: **在 Google，有类似的JSON工具叫做 Protocol Buffer，已经开源。

它的优点是生成优化后的二进制文件，因此性能更好。但与此同时，生成的二进制序列，是不能直接阅读的。

谈谈条件与循环

条件: if 语句是可以单独使用的，但 elif、else 都必须和 if 成对使用

注意:除了 boolean 类型的数据，条件判断最好是显性的。

if num != 0:
        print(num)

循环:

分为while循环和for循环。并且可以使用break与continue.

要尽量避免多层嵌套的情况

range函数:直接由 C 语言写的，调用它速度非常快。并且特是一个迭代器。

>>> d = range(10)
>>> d
range(0, 10)
>>> type(d)
<class 'range'>

三元运算

使用三元运算可以简洁明了，配合列表与字典的生成式，此时达到最高境界~(一行搞定千言万语)

谈谈异常处理

错误至少包括两种，一种是语法错误，另一种则是异常。

语法错误: 就是各种Error.....

官方解释:https://docs.python.org/3/library/exceptions.html#bltin-exceptions

异常: try ... except ... finally.. 来解决异常。

注意:except block 只接受与它相匹配的异常类型并执行，如果程序抛出的异常并不匹配，那么程序照样会终止并退出。

万能异常爸爸，Exception。Exception 是其他所有非系统异常的基类，能够匹配任意非系统异常

在 finally 中，通常会放一些无论如何都要执行的语句。

自定义异常:

raise 主动抛出异常。

异常应用场景:

大型社交网站的后台，需要针对用户发送的请求返回相应记录。用户记录往往储存在 key-value 结构的数据库中，每次有请求过来后，我们拿到用户的 ID，并用 ID 查询数据库中此人的记录，就能返回相应的结果。

而数据库返回的原始数据，往往是 json string 的形式，在 json.loads() 函数中，输入的字符串如果不符合其规范，那么便无法解码，就会抛出异常，因此需要加上异常处理。

注意: 正常的 flow-control 逻辑，不要使用异常处理，直接用条件语句解决就可以了。

一般来说异常抛出，都会对其进行Log（一般每1000次log一次），输出到real time的table和dashboard里，这样有利于之后的分析和改进。

except之后的delete操作:

"When an exception has been assigned using as target, it is cleared at the end of the except clause."
# 在异常处理的 except block 中，把异常赋予了一个变量，那么这个变量会在 except block 执行结束时被删除
# 在平时写代码时，一定要保证 except 中异常赋予的变量，在之后的语句中不再被用到。

比如下面这个code block：
except E as N:
    foo

就等于
except E as N:
    try:
        foo
    finally:
        del N

结束语

本文涵盖了我目前学习Python的基础知识的所有深度知识点。希望大家学习的时候，可以区分出什么是深度与浅度，对深度加以理解。大不了就是github源码来一下....

祝，大家阅读开心 C-: