这是我关于《如何像计算机科学家一样思考》一书的体会和总结。此书的副标题叫做《Think Python》，作者是Allen.B.Downey，欧林计算机学院计算机科学教授，MIT计算机科学学士和硕士，UCB计算机科学博士。作者本身写作此书的原因是用来讲解的语言是java入门知识，其目标是：简短、循序渐进、专注于编程而非语言。这本书里出现的编程知识基本上是所有语言所共用的，因此用来做一个程序学习之架构是非常合适，这也是本文希望做的——在这本书的基础上建立一个学习所有编程语言的基本框架。

上部分介绍了基本的表达式、语句、条件、递归和迭代以及错误和调试。下部分是关于数据结构、文件操作、OOP面向对象编程的相关知识，这些内容会更少的通用，更多的具有Python特色，但这是这些特色部分，才让Python变得如此好用。

5 数据结构

从这一部分开始，很多东西便具有了Python语言的特色，但是其基本架构是不变的，比如对于大多数高级数据结构都有遍历、分片、添加删除更改的操作。

5.1 列表

5.1.1 列表(list)的结构

在第一部分我们认识了值和类型，其中穿插着介绍了两种不同的值的类型，分别是整数(int)和字符串(string)。而在第五部分，我们会认识一些高级的类型，比如列表、元组以及字典。正是因为这些高级的数据结构，Python才可以“学的更少，做的更多”。

列表(list)是一种数据结构、一种值的类型，就像字符串一样。列表有一系列的元素组成，其中元素可以是各种数据类型，比如字符串、整数、小数，甚至是另外一个列表。

list_a = ["a","Hello",12,23,["55",13]]

列表的表示方法如上所示，采用一对[]括起来，就像字符串使用一对“”括起来一样。各元素中间采用英文逗号隔开，元素可以是另外一个列表，这叫做“嵌套”。

5.1.2 遍历、操作符和分片

和字符串一样，列表可以使用for语句进行遍历，这是分片的基础。使用lista[m:n]来分片，m代表起始元素，n代表结束元素，m不写代表从头开始，n不写代表直到最后。注意第一个元素的下标为0，这和字符串分片一样。对于嵌套列表，可以使用[][]来取出二级嵌套元素，比如对于[1,2,3,[4,5]]而言，lista[3][0]可以取出元素“4”。

for item in [1,2,3]:
    print(item) # 结果是 1 ，2 ，3

列表常用的两个操作符是＋和in，前者用来粘合列表，后者用来判断一个元素是否在列表中。

5.1.3 列表常用的操作(增、删、改)

不同于字符串的不可更改性，列表是可更改的。

你可以使用list_a[1] = 27 来替换掉列表的第一个元素，这样的话，列表就变成了：["a",27,12,23,["55",13]]。这是一种更改列表特定元素的操作，除此之外，还有一些添加元素、删除元素的操作：

list_a += item # 使用＋运算符来向列表添加元素

list_a.append() # 用来扩充列表，作用同上

list_a.pop() # 根据下标删除元素，返回删除的元素

list_a.remove() #　根据元素的值来删除元素

del list_a[number] # 根据下标删除元素，无返回值

和字符串的函数不同，大多数列表函数并不返回这个列表，因为其列表本身发生了变化，所以直接调用列表就好，大多数函数的返回值都是None.

5.1.4 列表的新建

新建列表可以对于一个可迭代项目的遍历建立，也可以使用list()函数、字符串split()函数来建立。

1、通过遍历建立

for item in "Hello"
    list_a.append(item)
    # list_a结果为 ["H","e","l","l","o"]

2、通过list()函数建立

list()函数用来将可迭代的项目转换成为列表，比如可以将一个字符串分开：

var_a = list("Hello") 
=> 
var_a
["H","e","l","l","o"]

3、通过split()建立

但有时候，我们并不像这样划分字符串，可以使用字符串的split方法生成列表，比如：

var_b = "Hello World".split(" ")
=>
var_b
["Hello","World"]

5.1.5 列表的转换：字符串

可以使用字符串的join方法来将可迭代项目（比如列表）合并，比如：

"".join(["H","e","l","l","o"])
=>
"Hello"

",".join(["Hello","World"])
=>
"Hello,World"

5.1.6 映射(map)与其陷阱

不同于字符串的不可更改性，列表的可修改性造成了一个问题，就是映射，举例如下：

a = "2"
b = "2"
a is b => True

a = [0]
b = [0]
a is b => False
b[0] = 42
b => [42]

a = [0]
b = a
a[0] = 42
b => 42
a is b => True

对于第一个例子而言，a和b是同一个字符串的映射，对于第二个例子而言，a和b是不同的列表，没有映射关系，但是奇怪的是第三个例子，b=a这个赋值是一种映射关系，a和b是映射而非不同的列表。对于高级数据结构，比如列表、字典等，所有的赋值都是映射（浅赋值），这保证了其数据在运算的时候的高效，但是却很容易弄迷糊。使用b=a[:]可以复制列表而不是建立映射，或者使用b=copy.deepcopy(a)来复制列表。

映射对于字符串来说没什么影响，因为字符串不可更改，如果想要修改，必须新建字符串，但是列表元素可以更改，所以任何映射此列表的其它列表都会被这个列表的元素更改所影响。

5.2 字典

区别于列表，字典没有下标，其采用的方式是键值对（key-value）存储数据。字典更加灵活。

5.2.1 字典(dict)结构概览

字典的结构如下所示，字典使用花括号括起来，其中的键可以为字符串或者是数字类型，值可以为任意类型。

dict_a = {"key1":"value1","key2":"value2","key3":True,"key4":233}

5.2.2 遍历、操作符运算和切片

使用for进行字典的键的遍历，如下：

for key in dict_a:
    print(key) # key为字典的键
    print(dict_a[key]) # dict_a[key]可以通过键取出对应的值，区别于列表使用下标取出值的方式

字典的in操作符运算，如下：

if "key2" in dict_a: # 字典可以进行in操作符运算，判断键是否在字典中
    print("I got it")

5.2.3 字典的一些常用函数

dic = dict()

dic.values() 可以显示出来所有值的结果

dic.has_key(key) 返回字典中是否有此键的布尔值

dic.keys() 可以显示所有的键，一般直接使用for对字典遍历即可，不需要此函数

dic.items()/pop()/copy()等请自行参考Python手册：打开CMD，输入python调出交互模式，使用dir(dict)可以查看所有dict类型的方法，使用help(dict.pop)可以查看pop方法的帮助。

5.2.4 字典的新建

使用dict()函数可以新建一个字典，或者对于一个变量直接如下指定：

dict_a = {} # 建立一个空字典
dict_a = dict() # 作用同上

5.2.5 字典的使用：暂存数据

如下所示是字典的一个计数器应用，判断字符串各字母出现的多少：

from pprint import pprint # pretty print 更人性化的打印函数
dict_a = {} # 新建一个字典结构
for key in "helloworld":
    if dict_a.has_Key(key): # 字典方法：判断是否有此键，返回布尔值
        dict_a[key] += 1
    else:
        dict_a[key] = 1
pprint(dict_a)

=> {'d': 1, 'e': 1, 'h': 1, 'l': 3, 'o': 2, 'r': 1, 'w': 1}

可以看到，字典一般被用作计算结果的内存暂存器。这些值可以被保存在字典中以备后续使用。

5.2.6 键的限制、全局变量陷阱

字典对于键和值有一定的要求。字典是采用散列表的方式实现的。散列可以接受任意类型的值并返回一个整数，字典使用这些被称之为散列值得整数来保存键值对。当键不变的时候，可以良好工作，其会根据值和键进行散列，但是，对于字典、列表这类可以变化的数据结构，如果键本身发生了变化，那么散列就不能够顺利找到键值对，因此键必须是可散列的，也就是不可变的，字典和列表都是可变对象类型，因此不能用作键。

在函数之外创建的变量称之为全局变量。而在函数内的变量称之为局部变量，如下：

var_a = 233
var_b = 233

def xxx()：
    var_a = 222
    print(var_a) # 局部变量，结果为222

    global var_b # 声明此变量为全局变量
    var_b = 111
    print(var_b) # 结果为 111

xxx()
print(var_a) # 全局变量，结果为233
print(var_b) # var_b 在函数中被声明是全局变量，被修改为111，因此结果是111.

注意：对于不可变类型的全局变量，在函数内如果不声明则不能修改，但是对于可变类型的全局变量，在函数内不声明可以进行添加、删除、替换，但是，如果进行赋值，则需要声明它。

比如：

dic1 = {"a":1}

def xxx():
    dic1 = {"b":2}
    print("in xxx dic1",dic1)

xxx()
print("out1dic1",dic1) 
# dic1在xxx函数内被重新赋值，变成局部变量，因此两次输出不同

输出结果如下：in xxx dic1 {'b': 2} ；out1dic1 {'a': 1}

def xxy():
    dic1["a"] = 2
    print("in xxy dic1",dic1)

xxy()
print("out2dic1",dic1) 
# dic1在xxy函数内被更改元素，依然是全局变量，所以结果不变

输出结果如下：in xxy dic1 {'a': 2} ；out2dic1 {'a': 2}

5.3 元组

和列表类似，元组也是根据下标来计数的高级结构，但是元组的单个元素无法改变，并且其创建和使用也都更加容易。

5.3.1 元组(tuple)结构

元组采用括号和逗号以及其分隔开的元素表示：

tuple_a = (1,2,"a")

需要注意，("a")这种表示是字符串，而("a",)这种表示才算作元组。元素可以为任意类型，支持无限层级的嵌套。

其实，元组只用逗号隔开就可以，但一般而言，约定俗成的约定是加上括号。

a,b = b,a # 一个极其优雅的值交换

5.3.2 遍历和操作符、分片

由于元组元素不可变，所以不仅可以用+操作符，也可以用in操作符，还可以用<、>这样的比较操作符。对于大小比较，如果第一个元素相同则比较第二个，以此类推。

对于for遍历而言，和列表大同小异。

5.3.3 元组的新建

元组可以直接使用元素新建，比如：("a",)，也可以使用tuple(),此函数传递的参数为任意可迭代的类型(iter)，比如字符串或者列表，甚至字典。

tuple("Hello") => ('H', 'e', 'l', 'l', 'o')

5.3.4 元组的使用:收集分散、参数传递

元组常用于作为参数输入，对于函数而言，以*开头的参数会收集(gather)所有的参数到一个元组内：

def xxx(a,b,*args):
    print(args)

xxx(1,2,3,4,5,6)
=> 结果为 (3,4,5,6)

同样的，对于某些函数，可以接受两个参数，但是我们只有一个元组，可以这样：

def yyy(a="",b=""):
    pass

c = (1,2)

yyy(c) # 错误的，因为只能接收一个参数
yyy(*c) # 正确，星号将c元组分开成为多个参数传入函数中，这叫做scatter（分散）。

其次，对于函数而言，返回多个值，使用列表较为麻烦，但是，使用元组就很简单，比如：

def zzz(a,b):
    return a,b # 作为元组返回

5.3.5 元组和列表、字典的关系

元组和其他高级数据结构关系密切，比如列表和字典。对于任何可迭代内容，使用zip()函数可以新建可迭代列表的元组对，比如：

zip("Hello","123456") 
=> [('H', '1'), ('e', '2'), ('l', '3'), ('l', '4'), ('o', '5')]

对于无法zip的元素自动舍弃，返回最短元素那一组。

元组也可以转换成为别的结构，比如上述结果可转换成为：

dict(zip("Hello","123456")) => {'H': '1', 'e': '2', 'l': '4', 'o': '5'}

需要注意的是，元组对转化成为字典的时候，其第一个可迭代对象作为字典的值，因此，两个l中的第一个已经被第二个覆盖了（重复键值写入）。

当然，字典也可以转换成为元组对/元组，比如

dic = {'H': '1', 'e': '2', 'l': '4', 'o': '5'}

tuple(dic) => ('H', 'e', 'l', 'o')

dic.items() => [('H', '1'), ('e', '2'), ('l', '4'), ('o', '5')]

综上所述，可以将元组对列表看作是字典。这也就是列表、元组和字典的关系。

6 持久化

Python持久化储存可以采用二进制和字符串两种方式进行存储。常用的有文本文件存储，pickle和shelve序列化后的key-value存储，json格式、xml格式存储等。对于存储一个较为重要的模块是os.path。此模块包含了在Windows和Unix平台下由于不同的平台特性导致的各种兼容性问题的解决方法。

对于目录而言，常用的方法有：

os.path.exists(dir) # 是否存在此目录

os.path.isdir(dir) # 判断是否为目录

os.listdir(dir) # 遍历一级列表查找文件夹中的文件

对于文件而言，常用的方法有：

os.path.exists(file) #判断是否存在此文件

os.path.isfile/islink # 判断是否为文件/链接文件

open(file,"mode",encoding="utf8",ignore=True).read() # 打开文件

对于路径而言，常用的方法主要是关于平台差异的：

os.path.normpath(dir) # 此方法返回符合本平台编码的path格式。

os.path.join(dir,file) # 连接多个字段

文件和数据库的操作请自行参考Python文档。

[引用6.1]错误捕获和处理

文件的读取和存储有一定的问题，因此需要错误捕获，通常采用try-except-finally语法块进行捕获和处理：

try: # 尝试执行此语句下的代码

    fh = open("filepath","a",encoding="utf8")
    content = fh.read()
    content = content.replace("\n\n","\n")
    fh.write(content)

except: # 上述代码块出错后立即终止处理并且调用此处代码

    print("ERROR")

finally：# 不论try代码块是否有问题，这里的代码块都会被执行

    fh.close()

7 类和面向对象编程

7.1 类：一种高层次的抽象

类是一种块状的抽象表达，其对应现实世界的对象。比如苹果、橘子、香蕉都属于水果，水果这一概念是各种水果的高层次抽象和共同特征集。苹果、香蕉属于水果的实例，我们也可以新建一个包含水果特征的新水果，这也是水果这个类的实例。采用以下方法定义一个类：

class Fruit(object):
    """这是水果类"""

newfruit = Fruit() # 创造一种水果类的实例

7.2 类和函数的封装

通常而言，计算机的类称之为对象，其对应真实世界中的对象，类的交互称之为函数，其对应真实世界中不同类的交互。函数有两种，其一为不涉及实参，而返回新的类对象的纯函数以及对实参进行变形、计算和处理后返回的非纯函数。通常而言，将涉及某个特定类的函数封装在一个类中方便调用，其称之为类的方法。

除了我们声明的类的方法以外，还有一些特殊的类的方法，比如init方法用来在初始化类的实例的时候进行某些操作，add方法在两个类的对象相加时进行逻辑运算，str方法会在你打印类时返回自定义的字符串，这些方法你都可以使用，以让自己的类更加强健和方便。

一个类的结构如下：

class People():
    """定义一个人的类"""

    def __init__(self):
        self.name = None
        self.age = 0
    def __str__(self):
        return self.name,self.age
    def __add__(self,*arg):
        return self.age + arg
    def dosomething(self):
        # do something
    
class Employ(People):
    """员工类，其继承了People类的方法和属性"""

    def __init__(self):
        super(Employ,self).__init__(self) 
        # 此句话用来初始化其父类的__init__方法中的代码段
    ...

封装在类中的函数一般称之为类的方法，其有两种调用方式：

其一为函数式（少用）：

实例1 = 类()
类.方法(实例1)

而最常用的是：

实例1 = 类()
实例1.方法()

7.3 函数的多态和类的继承

编写一个类/函数最好可以让其能够接受不同类型的参数并且进行处理，这种理念称之为多态，这丰富了函数的用途，增强了其健壮性，是一种良好的编程实践。

类可以继承，就比如人类和雇员类这种包含关系，其代指了类的继承关系，父类的所有方法子类都可以使用，但是需要进行一个声明。self表示此函数属于类的方法。

————————————————————

更新日志

2018年2月10日

这天我更新了持久化、类和继承相关的内容。关于OOP的相关内容只是一个初稿，在写作时我正在阅读JavaScript的对象的使用，我会在JS进行一个学习和比较后继续补充本文类相关的内容。

这就是《像计算机科学家一样思考Python》的全部笔记了，而JavaScript的实践，只是一个开始。JS和DOM的HTML交互，就好比Python和Qt GUI低配版，很多东西都是通的，我惊讶的发现Python的字符串方法中竟然很多和JS的字符串方法重合，很多连名字都一样，比如split()等，而大多数也都是采用不同表述形式的翻版。而对于DOM，其作为代码和用户交互的入口，类似事件Event(evnet.target)等业务逻辑其实和作为GUI的Qt信号/槽/Event(event.sender())很类似。甚至，JS的对象结构——JSON和Python最重要的数据结构字典都长的一模一样，这可不仅仅是巧合。

我下一步的计划是阅读《像计算机科学家一样思考C++》，因为Qt的原本Driver就是C++，对C++的进一步了解，有利于我对于Qt知识的巩固，进一步发掘其价值。此外，因为JS和Python实在太相似了，我还想要自己的范式在编译型语言进行验证，这也是对于本文的一个实践方向。

最后，范式让我很快的在短短几天就把握住一门动态语言，但是我发现，这还不够，因为仅仅是语法的掌握，对于现代的业务逻辑来说是不可想象的，框架、流程，这才是重点。因此，自从我学习Python以来，才发现原来学习一门语言如此的容易，但是，要在学习过语言之后做点事情，还需要了解各种场景的逻辑和框架的流程，这才是最耗时的。不必提各种语言本身内置的玲琅满目的包，需要花费时间的还有这些包后面所驱动的各种框架和业务流程，比如前端的GUI(PC、Web)，后端的SQL和NoSQL数据库，如果还要搞科学计算，视觉、语音、算法都有其逻辑体系，这些都是无关语言的。

更新历史

2018年2月6日 verion 0.0.1 添加文档，更新了列表、字典、元组部分

2018年2月10日添加持久化、类的相关内容初稿