<jupyter_start><jupyter_text>阅读笔记** 作者：方跃文 **** Email: <EMAIL> **** 时间：始于2017年9月12日， 结束写作于 **  附录 A附录A在原书最后，不过我自己为了复习python的一些命令，所以特意将这一部分提前到此。 python 解释器python解释器通过“一次执行一条语句”的方式运行程序。多加利用Ipython。通过使用 %run 命令，IPython 会在同个进程中执行指定文件中的代码。例如我在当年目录的下级目录appendix-A中创建了一个simple01.py的程序，它的内容是```a = 1print(a)```下面我在jupyter notebook中执行<jupyter_code>%run appendix-A/simple01.py<jupyter_output>1<jupyter_text>基础知识 语言语义python语言的设计特点是重视**可读性、简洁性和明确性**。 缩进，而不是大括号python是通过空白符（制表符或者空格）来阻止代码的，不像R、C++等用的是大括号。该书原作者建议使用4空格作为缩进量。 万物皆对象python语言的一个重要特点就是其对象模型的一致性。任何数值、字符串等都待在自己的“盒子”里，而这些“盒子”就是python的对象。 注释注释符使用 函数调用和对象方法的调用几乎所有的python对象都有一些附属函数（也就是方法)，它们可以访问该对象的内部数据。方法的调用时这样写的：```obj.some_method(x, y, z)``` 变量和按引用传递在python中对变量赋值时，你其实是在**创建等号右侧对象的一个引用**。用实际的例子来说，看看下面这个整数列表：<jupyter_code>a = [1, 2, 3]
b = a
a.append(4)
print(a)
print(b)<jupyter_output>[1, 2, 3, 4]
[1, 2, 3, 4]<jupyter_text>用小卡特的爹（好吧，这其实是某本python书的作者，但是我实在想不起来名字了）的话就是：相当于把a和b都贴在了[1,2,3]这个上面，上面a.append[4]之后，相当于把又贴在了[1,2,3,4]上面，因为b是贴在a上的，所以b的值也被改变，成为了[1,2,3,4]。赋值操作assignment也可以被叫做binding绑定，因为这其实是将一个名称和对象进行了捆绑。因此被赋值了得变量名有时也被称作binding variables。当我们把对象以参数的形式传入函数时候，我们其实传入的只是引用而已，不会发生任何复制。这是python区别于一些其他语言的重要特征之一。例如下面这个例子<jupyter_code>def append_element(fanglist, element):
    fanglist.append(element)

data = [1,2,3]
append_element(data, 5)
print(data)<jupyter_output>[1, 2, 3, 5]<jupyter_text>动态引用，强类型跟Java和C++**相反**， python中的对象引用没有与之关联的类型信息。从下面的例子可以看出：<jupyter_code>a = 5
type(a)
a = 2.5
type(a)<jupyter_output><empty_output><jupyter_text>变量其实是对象在特定命名空间中的名称而已。对象的类型信息是保存在它自己内部的。如果你因为这样就认为python不是类型语言，那就是错了。例如我们发现把字符串和整型数据直接相加在python中是不能进行的：<jupyter_code>a = 'hello'
b = 5
print('a is %s, and b is %s' % (type(a), type(b)))
c = a + b<jupyter_output>a is <class 'str'>, and b is <class 'int'><jupyter_text>从上面可以看出类型必须一致才能进行四则运算。从上面我们可以看出type可以用来查看一个对象的类型；反过来，python中，可以通过isinstance函数来检查一个对象是否是某个数据类型的实例。<jupyter_code>a = 5
isinstance(a, int)
a = 2.2
isinstance(a, int)<jupyter_output><empty_output><jupyter_text>instance 可以接受由类型组成的元祖。如果想检查某个对象的类型是否属于元祖中所制定的类型，可以用如下例子中的方法：<jupyter_code>a = 5
b = 2.2
isinstance(a,(int,float))
a = 5
b = 2.2
isinstance(b,(int,float))<jupyter_output><empty_output><jupyter_text>属性和方法** 时间： 2017年9月20日 **Python中的对象通常具有属性 attribute，也具有方法。所谓方法，则是与对象有关并且能够访问对象内部数据的函数。它们通过形如 obj.attribute_name 这样的语法进行访问<jupyter_code>a = 'foo' #定义了对象
a.count #访问对象的方法
#访问对象的方法还可以使用 getattr 函数 （getattr 是 getattribute 的缩写）
getattr(a, 'center')<jupyter_output><empty_output><jupyter_text>"鸭子"类型(鸭子在这里是哲学隐喻。意思是说：对于一只鸟类动物，不用管它是不是鸭子，只要看它像不像鸭子就可以了。)一般上，我们并不总是关心对象属于什么类型，但是很多时候我们想知道的是它到底有没有某些方法。比如，只要一个对象实现额迭代器协议（iterator protocol），就可以确认它是可迭代的。对于大部分对象而言，这就意味着它拥有一个<jupyter_code>__inter__<jupyter_output><empty_output><jupyter_text>魔术方法。当然，还有一个更好一些的验证办法，即利用 iter 函数：<jupyter_code>def isiterable(obj):
    try:
        iter(obj)
        return True
    except TypeError: #不可迭代
        return False
#对于字符串以及大部分Python集合类型，该函数返回True:
print(isiterable([1,2]))
print(isiterable((1,2)))
print(isiterable('1'))
print(isiterable(1))<jupyter_output>True
True
True
False<jupyter_text>常常在编写需要处理多类型输入的函数时使用这个功能，此外还有一个常见的应用场景是：编写可以接受任何序列（列表、元祖、ndarry）或迭代器的函数。例如我们可以先检查对象是不是列表（或NumPy数组），如果不是，就将其转换成是：<jupyter_code>x = (1,2) #定义了一个tuple
print(type(x))
print(isinstance(x,list) )#因为x是tuple，不是list，所以返回 False
print(isiterable(x))
if not isinstance(x,list) and isiterable(x):
#if not isiterable(x):
    x = list(x)
    print(x)<jupyter_output><class 'tuple'>
False
True
[1, 2]<jupyter_text>引入 import**2017年9月21日**在python中，module模块就是一个含有函数和变量定义及从其他.py文件引入的此类东西的.py文件。也许这句话很拗口，所以还是让我用例子说话：我在appedix-A文件夹中创建了一个新python脚本，取名为simple02.py，它的内容是(注意原书使用的是Python 2.7, 我使用的是python 3.6所以代码细节上有微小的差别)<jupyter_code>#set up a module

PI = 3.14159
def f(x):
    return (x + 2 )

def g(a, b):
    return (a + b)<jupyter_output><empty_output><jupyter_text>如果我们想要引入 simple02.py 中定义的变量和函数，我们可以在**同目录下**创建另一个文件，取名为 simple03.py<jupyter_code>import simple02 as s2
result = s2.f(5)
print(result)
pi = s2.PI
print(pi)
sumvalue = s2.g(2,2)
print(sumvalue)<jupyter_output><empty_output><jupyter_text>运行它：python simple03.py(如果是在windows系统的git bash中运行python，需要先设置一下python的路径，方法是在git bash terminal中运行PATH=$PATH:/c/ProgramData/Anaconda3/，然后就可以使用python了, see [referene](https://stackoverflow.com/questions/22869192/git-bash-wont-run-my-python-files))或者我们也可以直接在jupyter notebook中运行，但是需要增加一些代码让系统知道module在什么位置。此处我使用了import sys的方法，这种方法参考自名为shuang的github用户：[链接](https://github.com/Shuang0420/Shuang0420.github.io/wiki/python----%E5%B0%86%E8%87%AA%E5%B7%B1%E5%86%99%E7%9A%84py%E6%96%87%E4%BB%B6%E4%BD%9C%E4%B8%BA%E6%A8%A1%E5%9D%97%E5%AF%BC%E5%85%A5)以下是我摘自这位用户的wiki:>>> 为了让我们自己写的模块能够被 Python 解释器知道，需要用sys.path.append("~/sample.py")。其实，在 Python 中，所有模块都被加入到了 sys.path 里面了。用下面的方法可以看到模块所在位置：>>> import sys>>> import pprint>>> pprint.pprint(sys.path)<jupyter_code>#Fang code
import sys
sys.path.append("./appendix-A/simple02.py")
import simple02

result=simple02.f(5)
print(result)<jupyter_output>7<jupyter_text>二元运算符和比较运算符一些常用的运算符如下：<jupyter_code>a + b # 求和
a - b
a*b
a/b
a//b # a 除以 b后向下圆整，丢弃小数部分
a**b  # a 的 b次方
a & b # 如果a和b均为True，则结果为True. 对于整数，执行按位与操作 https://zh.wikipedia.org/wiki/%E4%BD%8D%E6%93%8D%E4%BD%9C
a|b #如果a或者b为True, 则结果为True. 对于整数，执行按位与操作
a^b #对于布尔值，如果a或者b为True(但不都为True),则结果为True. 对于整数，执行按位异或操作
a==b #如果a等于b，则结果为True
a !=b #不等，则True
a <= b、a<b # 如果a小于等于（或小于）b,则结果为True
a > b、a >= b # 如果a大于（或大于等于）b，则结果为True
a is b #如果引用a和引用b都指向同一个python对象，则结果为True
a is not b #如果引用a和引用不指向同一个python对象，则结果为True
#举例子来运用这些算符
a = (1,2,3)
b = a
c = 1.2
d = 2.0
e = 2
f = 3

sumtuple = a + b
print (sumtuple)
suminteger = e + f
print(suminteger)
print(c/d)
print(c//d)
print(e/f)
print(e//f)
print(e & f)
print (True & True)
print(e is f)
print (e is not f)
print (True^True)
print (True^False)

if a == b:
    print('a=b')<jupyter_output>(1, 2, 3, 1, 2, 3)
5
0.6
0.0
0.6666666666666666
0
2
True
False
True
False
True
a=b<jupyter_text>严格与懒惰无论使用什么变成语言，都需要了解一下表达式是何时被求值的。在python中，例如这样一个例子：<jupyter_code>a=b=c=5
d=a+b*c<jupyter_output><empty_output><jupyter_text>在python中，只要这些句子被求值，相关计算就会立即发生。上述的例子中，d的值会被立即设定为30。而在其他一些语言（eg. Haskell), d的值在被使用之前是不会被计算出来的。在一些特定环境下，我们希望求值计算并不是立即进行的。特别是在密集型计算中，计算负荷重，延迟计算就可以发挥作用。Python 提供了一些技术来实现这样的计算，但是在本书中并没有做介绍。  可变和不可变对象大部分python对象是可变的（mutable),比如列表、字典、NumPy数组以及大部分用户自定义类型（类）。也就是说，它们所包含的对象或者值是可被修改的。<jupyter_code>a = [1,2,3,4]
a[0]=2
print(a)<jupyter_output>[2, 2, 3, 4]<jupyter_text>另外一些对象，诸如tuple元组和字符串是不可变的immutable。下面这个例子中，我们试图去改变tuple，但是python告诉我们这样的操作是不被支持的。<jupyter_code>a_tuple = (2,3,4)
a_tuple[1]=2<jupyter_output><empty_output><jupyter_text>标准类型Python 有一些用于处理数值数据、字符串、布尔值（True or False)以及日期/时间的内置类型。这里我们列出主要的标量类型。后面我们将单独讨论日期/时间的处理，因为它们是由标准库中的datetime模块提供的。** 标准的Python标量类型 **        | 类型 | 说明| | ------| ------ | | None | Python的'null'值（None只存在一个实例对象） || str | 字符串类型。Python 2.x 中只有 ASCII 值，而Python 3中则是Unicode|| unicode | Unicode 字符串类型 || float | 双精度（64）浮点数。注意这里没有专门的doubl类型||bool| True或者False||int|有符号整数，其最大值由平台系统决定||long|任意精度的有符号整数。大的itn值会被自动转换为long|因为我在这里使用了Markdown输入表格，所以顺便介绍下Markdown中关于表格的一些小细节语法说明：1. |、-、:之间的多余空格会被忽略，不影响布局。2. 默认标题栏居中对齐，内容居左对齐。3. -:表示内容和标题栏居右对齐，:-表示内容和标题栏居左对齐，:-:表示内容和标题栏居中对齐。4. 内容和|之间的多余空格会被忽略，每行第一个|和最后一个|可以省略，-的数量至少有一个。  数值类型在 Python 中，用于表述数据的类型主要是 int 和 float. 1)能被保存为int的整数的大小由平台决定，但是Python会把非常大的证书转换为long，它可以存储任意大小的整数。2)float型可以写成小数形式，也可以写作科学技术法形式如 1e-53)python3中整数除法除不尽时就会产生浮点，例如<jupyter_code>3/2<jupyter_output><empty_output><jupyter_text>但是在python2.x中，并不能默认产生这个浮点解。要产生浮点解，需要在python2.x的程序中写入<jupyter_code>from __future__ import division<jupyter_output><empty_output><jupyter_text>如果不加这句话，也可以用显示的方式来转化，如<jupyter_code>3/float(2)<jupyter_output><empty_output><jupyter_text>4)如果要得到C风格的整数除法，即除不尽时候丢弃小树，可以使用“除后圆整运算符//”<jupyter_code>3//2<jupyter_output><empty_output><jupyter_text>5)在python中，复数的虚部用j表示，例如<jupyter_code>a=1+2j
b=3-3j
c=a-b
print(c)<jupyter_output>(-2+5j)<jupyter_text>字符串字符串在python中的使用十分灵活。可以用单引号或者双引号。对于大段的字符串则可以使用三重引号。例如<jupyter_code>a='Hi, this is <NAME> from NYU SHANGHAI'
b="He is a visiting researcher!"
c='''
##########################
##########################
##########################
'''
print(a)
print(b)
print(c)<jupyter_output>Hi, this is <NAME> from NYU SHANGHAI
He is a visiting researcher!

##########################
##########################
##########################<jupyter_text>前面我们已经提到过，字符串在python中是不可以被改变的，即immutable，如果要修改字符串就必须创建一个新的。<jupyter_code>a="He is a visiting researcher!"
b=a.replace('is a visiting researcher','graduated from East China Normal University') #创建了一个新的字符串，b引用了这个新的字符串
print(a)
print(b)
python中允许将其他类型转化成字符串，用str函数，例如
a=5
str(a)
print(a)<jupyter_output>5<jupyter_text>由于字符串其实是一串字符序列，所以可以被当作某种序列类型（类似列表、元祖等）进行处理<jupyter_code>a="ALOHA!"
print(a)
list(a)
print(a[:3])<jupyter_output>ALOHA!
ALO<jupyter_text>如果一个字符串包含很反斜杠，这会很让人懊恼，因为反斜杠常常会将字符进行转移。在python中，为了使得反斜杠就代表反斜杠本身而不去进行转移，可以在字符串前面加上字母r。这个在matplot里面画图添加希腊字母标注时候会显得比较有用。<jupyter_code>s = 'This\\is\\a\\flower'
s1 = r'This\\is\\a\\flower'
print(s,'\t',s1)<jupyter_output>This\is\a\flower 	 This\\is\\a\\flower<jupyter_text>** 这里重点讲一讲python 3带来的一些新的字符串格式化的手段，其实我在平时也已经在用了，但是这里再进行简短的讨论。因为在数据分析中这个经常会用到。**这里简单说一下主要的机制：以一个%开头且后面跟着一个或者多个格式字符的字符串是需要插入值的目标。这句话读起来也很拗口，让我们看例子<jupyter_code>template = '%s was born in %d' 
template % ('yue-wen',1990)<jupyter_output><empty_output><jupyter_text>上述，%s代表将参数格式化为字符串，%d将参数格式化为整数，这些地方都是需要实际参数来替换的，因此在上述代码的第二行中，我们使用了由值组成的元组，将这些值传入形参的位置。<jupyter_code># 再看一个例子
a=2e6
b=2.9
print('a is %d and b is %f' %(a, b))<jupyter_output>a is 2000000 and b is 2.900000<jupyter_text>布尔值比较运算和表达式都可以产生True或者False. 布尔值可以用and和or关键字进行连接<jupyter_code>True and False
True or False<jupyter_output><empty_output><jupyter_text>** 几乎所有内置的python类型以及任何定义了__nonzero__魔术方法的类都能在if语句中被解释为True或者False:<jupyter_code>a = [1,2,3]
b = a[:]
c = []
if a:
    print('a is %s' % a)

if not b:
    print('b is %s' % b)

if not c: # 因为c是空的，所以会当作False处理，not False则为True
    print('c is none')<jupyter_output>a is [1, 2, 3]
c is none<jupyter_text>如果想知道一个对象会被强制转换成哪个布尔值，可以使用bool函数。<jupyter_code>a = [1,2,3]
b = a[:]
c = []
print('The bool values of a, b, and c are %s, %s, and %s, respectively' % (bool(a), bool(b), bool(c)))
bool([]), bool([1]), bool('hello'), bool()<jupyter_output><empty_output><jupyter_text>类型转换str、 bool、 int 以及 float 等类型也可用作将值转换成该类型的函数. 我觉得，通过下面的例子不难发现，这些函数并不会从本质上改变原始值，而只是创建了新的引用。<jupyter_code>import math
s = math.pi
a = str(s)
print(type(s))
print(type(a))
b = float(a)
int(float(a))
print(type(a))<jupyter_output><class 'float'>
<class 'str'>
<class 'str'><jupyter_text>NoneNone是python的空值类型。如果一个函数无显示的返回值，则隐式返回None<jupyter_code>a = None
a is None
b = 5
print(b is not None)
if b is None:
    print(b)<jupyter_output>True<jupyter_text>None 还是函数可选参数的一种常见默认值；(不过，虽然我知道可以这样用，但是我暂时联想不到有什么场景可以用到)<jupyter_code>def add_and_maybe_multipy(a, b, c=None):
    if a is not None and b is not None and c is None:
        return(a+b)
    else:
        return(a*c)

x = add_and_maybe_multipy(1, 1, None)
y = add_and_maybe_multipy(1, 2, 3)
print('x = %d and y = %d' % (x, y))<jupyter_output>x = 2 and y = 3<jupyter_text>** 值得注意的是， None并非是保留关键字，它只是NoneType的一个实例**  日期和时间Python 内置的 datetime 模块提供了 datetime, date 以及 time 等类型。datetime 类型是用的最多的，它合并了保存在 date 和 time 中的信息。<jupyter_code>from datetime import datetime, date, time

dt = datetime(2017, 10, 28, 19, 20, 22)
day = dt.day
print(day)
min = dt.minute
print(min)<jupyter_output>28
20<jupyter_text>给定 datetime 一个实例。你可以通过调用其date和time方法提取相应的date和time对象<jupyter_code>dt.date()
dt.time()<jupyter_output><empty_output><jupyter_text>** strftime **方法用于将datetime格式化为字符串：<jupyter_code>from datetime import datetime, date, time

dt = datetime(2017, 9, 22, 12, 30, 20)
print(dt.day)

datetime.strptime('20170923', '%Y%m%d')
#完整的格式化定义请参考表书本10-2
#Page 417<jupyter_output><empty_output><jupyter_text>控制流  if, elif 和 elseif语句是常见的控制语句类型。它用于判断一个条件，如果为 True， 则执行紧跟其后的代码块：<jupyter_code>x=-1
if x<0:
    print(repr("hello"))
    print("%s" % ("hello"))

a = [2, 3, 4, 5, 6, 8, 10]
if type(a)==list:
    print(a)<jupyter_output>'hello'
hello
[2, 3, 4, 5, 6, 8, 10]<jupyter_text>if 可以和多个 elif 以及一个“滴水不漏”的 else 块（如果所有条件都为False)，例如<jupyter_code>x = 10

if x<0:
    print('x is negative')
elif x == 0:
    print('x = 0')
elif x > 0:
    print('x > 0')
else:
    print('x is a complex')<jupyter_output>x > 0<jupyter_text>for 循环for 循环用于对集合（比如列表或者元祖）或迭代器进行迭代。for 循环的标准语法是：for value in collection:continue关键字用于使for循环提前进入下一次迭代，即跳过本次循环中剩余的代码块。我们来看个例子来理解下continue的功能，其功能是对列表中证书求和并跳过None值.<jupyter_code>sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
    if value is None:
        continue
    total += value
    print('total is %f in this cyle' % (total))<jupyter_output>total is 1.000000 in this cyle
total is 3.000000 in this cyle
total is 7.000000 in this cyle
total is 12.000000 in this cyle<jupyter_text>后面我们会看到，如果集合或者迭代器的元素是序列类型，例如元组或者列表，那么还可以方便将这些元素拆散成for语句中的多个变量.<jupyter_code>#使用的语法是
#for a,b,c in iterator:
#    do something

#我这里只写一个简单的例子，但是这个例子可能还不是上述语法最正统的例子。
# date: 20170923
sequence = [(1,2,3),(4,5,6)]
total = 0
for (i,j,k) in sequence:
    print((i,j,k))
    coor = (i,j,k)
    for i in coor:
        i=i+1
        print(i, end=' ')
    print('\n')<jupyter_output>(1, 2, 3)
2 3 4 

(4, 5, 6)
5 6 7<jupyter_text>while 循环while 循环定义了一个条件和一个代码块，只要条件不为False或者循环没有被break显示终止，则代码会一直执行下去：<jupyter_code>x = 256
total = 0
while x > 0:
    if total > 500:
        break
    total += x
    print('total = %d' %total)
    x = x//2
    print('x = %d' %x)<jupyter_output>total = 256
x = 128
total = 384
x = 64
total = 448
x = 32
total = 480
x = 16
total = 496
x = 8
total = 504
x = 4<jupyter_text>psspass 是 python 中的“空操作”语句。它可以被用在那些没有任何功能的代码块中。由于python是根据空白符划分代码块的，所以它的存在是很有必要的。<jupyter_code>if x < 0:
    print 'negative'
elif x==0:
    #TO DO: here you can add codes in future
    pass
else:
    print 'positive'<jupyter_output><empty_output><jupyter_text>在开发一个新功能时，常常会将pass用作代码中的占位符：<jupyter_code>def f(x,y,z):
    #TODO: realize a function here
    pass<jupyter_output><empty_output><jupyter_text>异常处理** 优雅地处理Python错误或异常是构建健壮程序的重要环节。** 译者翻译的这句真有意思，感觉铺面而来一种“知乎”风格。在data science中，许多函数只对特定数据类型有效。例，python中的float函数可将字符串转换为浮点数，但是如果输入值不正确就会产生 ValueError<jupyter_code>float('1.2345')
float('something')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.15148924041613224, 'fraction_numerical': 0.035413994584580305, 'mean_word_length': 8.406836461126005, 'pattern_counts': {'":': 0, '<': 174, '<?xml version=': 0, '>': 188, 'https://': 3, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '46', 'dir': 'jupyter-structured-clean-dedup', 'id': '605621', 'license': 'Apache-2.0', 'n_tokens_mistral': 8822, 'n_tokens_neox': 9088, 'n_words': 898, 'path': 'machine-learning/McKinney-pythonbook2013/appendix-A-note.ipynb', 'repo_name': 'yw-fang/MLreadingnotes', 'size': '14056'}