编程范式——《像计算机科学家一样思考》读书笔记(下)

这是我关于《如何像计算机科学家一样思考》一书的体会和总结。此书的副标题叫做《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(&quot;Hello&quot;) =&gt; (&#39;H&#39;, &#39;e&#39;, &#39;l&#39;, &#39;l&#39;, &#39;o&#39;)

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

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

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

xxx(1,2,3,4,5,6)
=&gt; 结果为 (3,4,5,6)

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

def yyy(a=&quot;&quot;,b=&quot;&quot;):
    pass

c = (1,2)

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

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

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

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

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

zip(&quot;Hello&quot;,&quot;123456&quot;) 
=&gt; [(&#39;H&#39;, &#39;1&#39;), (&#39;e&#39;, &#39;2&#39;), (&#39;l&#39;, &#39;3&#39;), (&#39;l&#39;, &#39;4&#39;), (&#39;o&#39;, &#39;5&#39;)]

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

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

dict(zip(&quot;Hello&quot;,&quot;123456&quot;)) =&gt; {&#39;H&#39;: &#39;1&#39;, &#39;e&#39;: &#39;2&#39;, &#39;l&#39;: &#39;4&#39;, &#39;o&#39;: &#39;5&#39;}

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

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

dic = {&#39;H&#39;: &#39;1&#39;, &#39;e&#39;: &#39;2&#39;, &#39;l&#39;: &#39;4&#39;, &#39;o&#39;: &#39;5&#39;}

tuple(dic) =&gt; (&#39;H&#39;, &#39;e&#39;, &#39;l&#39;, &#39;o&#39;)

dic.items() =&gt; [(&#39;H&#39;, &#39;1&#39;), (&#39;e&#39;, &#39;2&#39;), (&#39;l&#39;, &#39;4&#39;), (&#39;o&#39;, &#39;5&#39;)]

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

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,&quot;mode&quot;,encoding=&quot;utf8&quot;,ignore=True).read() # 打开文件

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

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

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

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

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

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

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

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

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

    print(&quot;ERROR&quot;)

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

    fh.close()

7 类和面向对象编程

7.1 类:一种高层次的抽象

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

class Fruit(object):
    &quot;&quot;&quot;这是水果类&quot;&quot;&quot;

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

7.2 类和函数的封装

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

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

一个类的结构如下:

class People():
    &quot;&quot;&quot;定义一个人的类&quot;&quot;&quot;

    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):
    &quot;&quot;&quot;员工类,其继承了People类的方法和属性&quot;&quot;&quot;

    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日 添加持久化、类的相关内容初稿