【注】本文是学习《Python核心编程《第二版》》时的笔记。

1 Python快速入门

1.1 格式化输出print

1 >>> print "%s is number %d" % ('python', 1)
2 python is number 1

print语句默认会给每一行添加一个换行符，只要在print语句的最后加上一个逗号（,），带逗号的print语句输出的元素之间会自动添加一个空格，就可以改变这种行为。

1 >>> who = 'zheng'
2 >>> what = 'Ni'
3 >>> print 'we are the %s who say %s' % (who, (what + ' ')*4)
4 we are the zheng who say Ni Ni Ni Ni

1.2 标准输入raw_input

raw_inpout返回的是字符串类型，string类型。

1 >>> num = raw_input('input a number: ')
2 input a number: 123
3 >>> print 'Your input number is ', int(num)
4 Your input number is  123

 当输入纯数字时，input返回的是数值类型，如int、float。

下面举例中得情况就可以看出两者的差异：

#这个不会报错
Host_ip     = raw_input("Enter ftp server ip  : ")
#这个会报错
Host_ip     = input("Enter ftp server ip  : ")

1.3 输出重定向

1 >>> import sys
2 >>> print >> sys.stderr, 'Fatal error: invalid input'
3 Fatal error: invalid input
4 >>> logfile = open('/tmp/mylog.txt', 'a')
5 >>> print >> logfile, 'Fatal error: invalid input'
6 >>> logfile.close()

1.4 运算符

<  >  ==  !=  and  or  not  +  -  *  /  //  %

1.5 数字

有符号整型、长整型、布尔值、浮点值、复数

1.6 字符串

字符串的索引规则：第一个字符的索引是0，最后一个字符的索引是-1。

1 >>> pystr = 'python'
2 >>> pystr[0]
3 'p'
4 >>> pystr[2:5]
5 'tho'
6 >>> pystr[-1]
7 'n'

1.7 列表

列表和数组相似，只是列表可以保存任意数量和类型的python对象，索引方式从0开始的数字索引。

1 >>> alist = [1, 2, 3, 4]
 2 >>> alist[0]
 3 1
 4 >>> alist[-1]
 5 4
 6 >>> alist[0:3]
 7 [1, 2, 3]
 8 >>> alist[2] = 5
 9 >>> alist
10 [1, 2, 5, 4]
11 >>>

1.8 元组

元组用小括号()包裹，不可以修改（尽管他们的内容可以），元组可看成是只读的列表，通过切片可以得到子集。

1 >>> atuple = ('roboots', 77, 90, 'try')
2 >>> atuple
3 ('roboots', 77, 90, 'try')
4 >>> atuple[:3]
5 ('roboots', 77, 90)
6 >>> atuple[1] = 53
7 Traceback (most recent call last):
8   File "<stdin>", line 1, in <module>
9 TypeError: 'tuple' object does not support item assignment

1.9 字典

字典是python中的映射数据类型，由键-值（key-value）对组成，一般使用数字或者字符串作为键，值可以是任意类型的python对象，字典使用大括号{}包裹。

1 >>> adict = {'host':'search'}
 2 >>> adict['port'] = 90
 3 >>> adict
 4 {'host': 'search', 'port': 90}
 5 >>> adict.keys()
 6 ['host', 'port']
 7 >>> adict['host']
 8 'search'
 9 >>> adict['port']
10 90
11 >>> for key in adict:    
12 ...     print key, adict[key]
13 ... 
14 host search
15 port 90

1.10 if

1 if expression1:
2 if_suite
3 elif expression2:
4     elif_suite
5 else:
6     else_suite

1.11 while

1 while expression:
2     while_suite

1.12 for

python中的for接收可迭代对象（例如序列或迭代器）作为参数，每次迭代其中的一个元素

1 >>> for item in ['email', 'net', 'home']:
2 ...     print item,                      
3 ... 
4 email net home

1.13 range

range()函数通常和len()函数一起用于字符串的索引

1 >>> foo = 'abc'
2 >>> for i in (range(len(foo))):
3 ...     print foo[i], '(%d)' % i
4 ... 
5 a (0)
6 b (1)
7 c (2)

1.14 enumerate

enumerate()函数可同时循环索引和循环元素

1 >>> foo = 'abc'
2 >>> for i, ch in enumerate(foo):
3 ...     print ch, '(%d)' % i
4 ... 
5 a (0)
6 b (1)
7 c (2)

1.15 列表解析

可以在一行中使用一个for循环将所有值放到一个列表中

1 >>> squared = [x**2 for x in range(4)]
 2 >>> for i in squared:
 3 ...     print i,
 4 ... 
 5 0 1 4 9
 6 >>> sqdevens = [x**2 for x in range(6) if not x%2]
 7 >>> for i in sqdevens:
 8 ...     print i
 9 ... 
10 0
11 4
12 16

1.16 open

handle = open(file_name, access_mode = ‘r’)

access_mode取值：’r’读取，‘w’写入，‘a’添加，‘+’读写，‘b’二进制访问

返回值：文件句柄

1 >>> fobj = open(filename, 'r')
2 >>> for eachline in fobj:
3 ...     print eachline    ,
4 ... 
5 >>> fobj.close

1.17 错误和异常

给代码添加错误检测和异常处理，将代码封装在try-except语句中，try之后放代码组，except之后放处理错误的代码。

1 >>> try:
2 ...     filename = raw_input('filename: ')
3 ...     for eachline in fobj:
4 ...         print eachline,
5 ...     fobj.close()
6 ... except IOError, e:
7 ...     print 'file open error:', e

1.18 函数

1 def function_name ([arguments]):
2     ‘optional documentation string’
3     function_suite

函数参数是可选的

1 >>> def addme2me(x):
2 ...     return (x+x)
3 >>> addme2me([-1, 'abc']) 
4 [-1, 'abc', -1, 'abc']

注：加号操作几乎与所有的数据类型工作，不管是数值还是序列合并。

函数的参数可以有一个默认值，如果提供默认值，在函数定义中，参数以赋值语句的形式提供，表示函数调用时如果没有提供这个参数，就取这个值作为默认值

1 >>> def foo(debug = True):
2 ...     if debug:                
3 ...         print 'in debug mode'
4 ...     print 'done'             
5 ... 
6 >>> foo()
7 in debug mode
8 done

1.19 类

定义类：

1 class classname (base_class[es]):
2     ‘option documentation string’
3     static_member_declarations
4     method_declarations

class关键字定义类，可提供一个可选的父类或者基类，如果没有，就使用object作为基类。class之后是可选的文档描述符、静态成员和方法定义。

1 >>> class fooclass(object):
2 ...     version = 0.1
3 ...     def __init__(self, name='John'):
4 ...         self.name = name
5 ...         print 'create a class instance for', name
6 ...     def showname(self):
7 ...         print 'your name is ', self.name
8 ...     def addme2me(self, x):
9 ...         return x+x

__init__()方法是一个特殊方法，当一个类实例被创建时，__init__()方法会被自动执行，在类实例创建完毕后执行，类似构造器。主要完成初始化的工作。__init__()需要一个默认的参数。

1 >>> fool = fooclass()
2 create a class instance for John

1.20 模块

模块是一种组织形式，将彼此有关系的代码组织到一个个独立的文件中，模块可以包括执行代码，函数和类，或者这些东西的组合。

导入模块：import module_name

访问模块函数或模块变量：module.function()、module.variable

1 >>> import sys
2 >>> sys.stdout.write('hello, world!\n')
3 hello, world!
4 >>> sys.platform
5 'linux2'

1.21 赋值

增量赋值：+=、-=、*=、/=、%=、**=、<<=、>>=、&=、^=、|=

1 >>> n = 12
2 >>> n ^= 3
3 >>> n
4 15

多重赋值：x = y = z = 1

1 >>> x = y = z = 1
2 >>> x
3 1
4 >>> y
5 1
6 >>> z
7 1

“多元赋值”：采用这种方法赋值时，等号两边的对象都是元组

1 >>> (x, y, z) = (1, 2.2, 'string')
 2 >>> x
 3 1
 4 >>> y
 5 2.2000000000000002
 6 >>> z
 7 'string'
 8 >>> (x, y) = (y, x)
 9 >>> x
10 2.2000000000000002
11 >>> y
12 1

1.22 python对象

所有的python对象都有三个特性：身份（可使用id()得到）、类型（可使用type()得到）和值

身份：可看作对象的内存地址

类型：（1）标准类型：数字、整型、布尔型、长整型、浮点型、复数型、字符串、列表、元组、字典；（2）其它内建类型：类型、Null对象（None）、文件、集合/固定集合、函数/方法、模块、类。

类就是类型，实例就是类型的对象

1.23 数字

python支持多种数字类型：整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数

布尔型：布尔型只有两个值，True和Fasle

标准整型：32位机器上标准整型的取值范围为-232到232-1，标准整型等价于C语言的有符号长整型，如果是八进制以数字“0”开始，十六进制整型以“0x”或“0X”开始；

长整型：python的长整型能表达的数值仅仅与机器支持的虚拟内存大小有关，长整型是标准整型类型的超集，在一个整型值后面加个L（大小写都可以），表示这个整型是长整型。

双精度浮点型：类似于C语言中的double类型，可以直接用十进制或者科学计数法表示，每个浮点型占8个字节，其中52位用于表示底，11位用于表示指数，剩下的1位表示符号，浮点型值通常都有一个小数点和一个可选的后缀e（大写或小写，表示科学计数法），在e和指数之间可以用正负号表示指数的正负。

复数：一个复数就是一对有序浮点型（x, y），表示x+yi，其中x是实数部分，y是虚数部分

复数的内建属性：分别为该复数的实部和虚部，复数还有conjugate方法，返回的该复数的共轭复数对象。

1 >>> acomplex = -8.333-1.47j
 2 >>> acomplex
 3 (-8.3330000000000002-1.47j)
 4 >>> acomplex.real
 5 -8.3330000000000002
 6 >>> acomplex.imag
 7 -1.47
 8 >>> acomplex.conjugate()
 9 (-8.3330000000000002+1.47j)
10 >>>

1.24 数字操作符

如果有一个操作数是复数，另一个操作数被转换为复数；

否则，如果有一个操作数是浮点型，这另一个操作数被转换为浮点型；

否则，如果有一个操作数是长整型，这另一个操作数被转换为长整型；

否则，两者必然为普通整型，无需要转换

 

Python中输入一行数 python输入一行数字逗号隔开_python

1.25 算术操作符

除法：对整型操作数，执行“地板除”（floor，取比商小的最大整型），例如5除以2等于2.5，“地板除”的结果是2

传统除法

真正的除法

地板除

如果是整型除法，传统除法会舍去小数部分，返回一个整型

1/2=0  1.0/2.0=0.5

除法运算总是返回真实的商

可通过执行 from __future__ import division执行做到

操作符//执行的是地板除：//除法不管操作数是何种数值类型，总是舍去小数部分，返回数字序列中比真正的商小的最接近的数字

取余：浮点数取余商取小于等于精确值的最大整型的乘积之差，即：x-(math.floor(x/y)*y)或者 

Python中输入一行数 python输入一行数字逗号隔开_python_02

。 

幂运算：幂运算操作符比其左侧操作符的一元操作符优先级低，比其右侧操作符的一元操作符的优先级高。

1 >>> 3 ** 2
2 9
3 >>> -3 ** 2
4 -9
5 >>> 4.0 ** -1.0
6 0.25

1.26 位操作符

标准位运算：~、&、|、^、<<、>>

负数会当作正数的二进制补码处理

左移和右移N位等价于无溢出检查的2的N次幂，2**N

1.27 标准类型函数

cmp()、str()、type()：可以用于所有的标准类型，对数字对象来说，这些函数分别比较两个数的大小，将数字转换为字符串，以及返回数字对象的类型。

1.28 数字类型函数

1 >>> int(4.12)
2 4
3 >>> long(321)
4 321L
5 >>> complex(4)
6 (4+0j)
7 >>> complex(4, -8)
8 (4-8j)

1.29 功能函数

进行数值运算：abs()、coerce()、divmod()、pow()、round()

abs()：返回给定参数的绝对值，如果是复数返回模的值

coerce()：为程序员提供了不依赖python解释器，而是自定义两种数值类型转换的方法，返回一个包含类型转换完毕的两个数值元素的元组。

1 >>> coerce(1, 2)
 2 (1, 2)
 3 >>> coerce(1.3, 2L)
 4 (1.3, 2.0)
 5 >>> coerce(1, 2L)  
 6 (1L, 2L)
 7 >>> coerce(1j, 2L)
 8 (1j, (2+0j))
 9 >>> coerce(1.23+4j, 2L) 
10 ((1.23+4j), (2+0j))

divmod()：把除法和取余运算结合起来，返回一个包含商和余数的数组，对整型来说，它的返回值就是地板除和取余操作的结果，对浮点数来说，返回的商部分是math.floor（num1/num2），对复数来说，商部分是ath.floor((num1/num2).real)

1 >>> divmod(10, 3) 
2 (3, 1)
3 >>> divmod(3, 10) 
4 (0, 3)
5 >>> divmod(10, 2.5)
6 (4.0, 0.0)
7 >>> divmod(2+1j, 0.5-1j)
8 __main__:1: DeprecationWarning: complex divmod(), // and % are deprecated
9 (0j, (2+1j))

pow()：pow()函数和（**）操作符都可以进行指数运算。

1 >>> pow(2, 5)
2 32
3 >>> pow(5, 2) 
4 25

round()：用于对浮点型进行四舍五入运算，它可以有一个可选的小数位数参数，如果不提供小数参数，它返回与第一个参数最接近的整型（但仍然是浮点类型），第二个参数告诉round函数将结果精确到小数点后指定位数。round()函数按四舍五入的规则进行取整。

1 >>> round(3)
 2 3.0
 3 >>> round(3.45)
 4 3.0
 5 >>> round(3.49999, 1)
 6 3.5
 7 >>> import math
 8 >>> for eachnum in range(10):
 9 ...     print round(math.pi, eachnum)
10 ... 
11 3.0
12 3.1
13 3.14
14 3.142
15 3.1416
16 3.14159
17 3.141593
18 3.1415927
19 3.14159265
20 3.141592654
21 >>> round(-3.5)
22 -4.0
23 >>> round(-3.4)
24 -3.0
25 >>> round(-3.49)
26 -3.0
27 >>> round(-3.49, )
28 -3.0
29 >>> round(-3.49, 1)
30 -3.5

int()、round()、math.floor()之间的区别：

函数int()直接截去小数部分，返回值为整型；

函数floor()得到最接近原数但小于原数的整型，返回值为浮点型；

函数round得到最接近原数的整型，返回值为浮点型。

1.30 仅用于整型的函数

进制转换函数：oct()返回八进制整型，hex()返回十六进制整型

1 >>> hex(255)
2 '0xff'
3 >>> oct(255)
4 '0377'

ASCLL转换函数：用于ASCLL码和其序列值之间的转换，函数chr()接受一个单字节整型值，返回一个字符串；函数ord()接受一个字符，返回其对应的整型值。

1 >>> ord('A')
2 65
3 >>> chr(97)
4 'a'

1.31 布尔数

有两个永不改变的值True和False

布尔型是整型的子类，但是不能再被继承而生成它的子类

没有__nonzero__()方法的对象的默认值是True

对于值为0的任意数字或空集（空列表、空元祖和空字典等），布尔值为False

1.32 拷贝python对象、浅拷贝和深拷贝

浅拷贝：对象赋值是简单的对象引用，当创建一个对象，然后把它赋值给另一个变量的时候，python并没有拷贝这个对象，而是拷贝了这个对象的引用。

1 >>> person = ['name', ['saving', 100.0]]
 2 >>> hubby = person[:]
 3 >>> wifey = list(person)
 4 >>> [id(x) for x in person, hubby, wifey]
 5 [140275404798072, 140275404797928, 140275404798936]
 6 >>> hubby[0] = 'joe'
 7 >>> wifey[0] = 'jane'
 8 >>> hubby, wifey
 9 (['joe', ['saving', 100.0]], ['jane', ['saving', 100.0]])
10 >>> hubby[1][1] = 50.0
11 >>> hubby, wifey      
12 (['joe', ['saving', 50.0]], ['jane', ['saving', 50.0]])

这里仅仅是做了一个浅拷贝，拷贝的对象本身是新的，但是内容不是，序列类型对象的浅拷贝是默认类型拷贝，可以通过（1）完全切片操作[:]；（2）利用工厂函数，比如list()、dict()等；（3）使用copy模块的copy函数。

1 >>> [id(x) for x in hubby]
2 [140275404800288, 140275404797784]
3 >>> [id(x) for x in wifey]
4 [140275404800096, 140275404797784]

深拷贝：要得到一个完全拷贝或者深拷贝-创建一个新的容器对象，包含原有对象元素（引用）全新拷贝的引用-需要copy.deepcopy()函数。

1 >>> person = ['name', ['saving', 100.0]] 
 2 >>> hubby = person
 3 >>> import copy
 4 >>> wifey = copy.deepcopy(person) 
 5 >>> [id(x) for x in person, hubby, wifey]
 6 [140275404798792, 140275404798792, 140275404798072]
 7 >>> hubby[0] = 'joe'
 8 >>> wifey[0] = 'jane'
 9 >>> hubby, wifey
10 (['joe', ['saving', 100.0]], ['jane', ['saving', 100.0]])
11 >>> hubby[1][1] = 50.5
12 >>> hubby, wifey      
13 (['joe', ['saving', 50.5]], ['jane', ['saving', 100.0]])
14 >>> [id(x) for x in hubby]
15 [140275404801968, 140275404797136]
16 >>> [id(x) for x in wifey]
17 [140275404800624, 140275404799080]

注意：1、非容器类型（比如数字、字符串和其它“原子”类型的对象，像代码、类型和xrange对象等）没有拷贝一说，浅拷贝是用完全切片操作来完成的；2、如果元组变量只包含原子类型对象，对它的深拷贝将不会进行。

1 >>> person = ('name', ('saving', 100.0))  
2 >>> newperson = copy.deepcopy(person)   
3 >>> [id(x) for x in person, newperson]
4 [140275404813160, 140275404813160]
5 >>> [id(x) for x in person] 
6 [140275405043824, 140275404797424]
7 >>> [id(x) for x in newperson]
8 [140275405043824, 140275404797424]

附录：

1 常用的内建函数

函数

描述

dir([obj])

显示对象的属性，如果没有提供参数，则显示全局变量的名字

help([obj])

显示对象的文档字符串，如果没有提供任何参数，则会进入交互式帮助

int(obj)

将一个对象转换为整型

len(obj)

返回对象的长度

open(fn, mode)

以mode(‘r’=读，’w’=写)方式打开一个文件名为fn的文件

range([start,] stop [,step])

返回一个整型列表，起始值为start，结束值为stop-1，start默认为0，step默认为1

raw_input(str)

等待用户输入一个字符串，可以提供一个可选的参数str用作提示信息

str(obj)

将一个对象转换为字符串

type(obj)

返回对象的类型，返回值本事是一个type对象

2 python类型操作符和内建函数总结

操作符/函数

描述

结果

字符串表示

``

对象的字符串表示

str

内建函数

cmp(obj1, obj2)

比较两个对象

int

repr(obj)

对象的字符串表示

str

str(obj)

对象的字符串表示

str

type(obj)

检测对象的类型

type

值比较

< 

小于

bool

> 

大于

bool

<=

小于等于

bool

>=

大于等于

bool

==

等于

bool

!=

不等于

bool

<> 

不等于

bool

对象比较

Is

是

bool

not is

不是

bool

布尔操作符

not

逻辑反

bool

and

逻辑与

bool

or

逻辑或

bool

3 标准类型分类

数据类型

存储模型

更新模型

访问模型

数字

标量

不可更改

直接访问

字符串

标量

不可更改

顺序访问

列表

容器

可更改

顺序访问

元组

容器

不可更改

顺序访问

字典

容器

可更改

映射访问

4 数值工厂函数

类（工厂函数）

操作

bool(obj)

返回obj对象的布尔值，也就是obj.__nonzero__()方法的返回值

int(obj, base=10)

返回一个字符串或数值对象的整型表示，类似于string.atoi()

long(obj, base=10)

返回一个字符或数据对象的长整型表示，类似于string.atol()

float(obj)

返回一个字符串或数据对象的浮点型表示，类似string.atof()

complex(str) or complex(real, imag=0.0)

返回一个字符串的复数表示，或者根据给定的实数（及一个可选的虚数部分）生成一个复数对象

5  数值运算内建函数

函数

功能

abs(num)

返回num的绝对值

coerce(num1, num2)

将num1和num2转换为同一类型，然后以一个元组形式返回

divmod(num1, num2)

除法-取余运算的结合，返回一个元组（num1/num2, num1%num2），对浮点型和复数的商进行下舍入，复数仅取实数部分的商

pow(num1, num2, mod=1)

取num1得num2次方，如果提供mod参数，这计算结果再对mod进行取余运算

round(fit, ndig=1)

接受一个浮点型fit并对其四舍五入，保存ndig位小数，若不提供ndig参数，则默认小数点后0位

6 仅适用于整型的内建函数

函数

功能

hex(num)

将数字转换为十六进制数并以字符串形式返回

oct(num)

将数字转换为八进制数并以字符串形式返回

chr(num)

将ASCLL值的数字转换为ASCLL字符，范围只能是0<=num<=255

ord(chr)

接受一个ASCLL或Unicode字符（长度为1的字符串），返回对应的ASCLL值或Unicode值

unichr(num)

接受Unicode码值，其对应的Unicode字符，所接受的码值范围依赖于你的python是内建于UCS-2还是USC-4

7 数值类型相关模块

模块

介绍

decimal

十进制浮点运算类Decimal

array

高效数值数组（字符、整型、浮点型等）

math/cmath

标准C库运算函数，常规数学运算在math模块，复数运算在cmath模块

operator

数字操作符的函数实现，比如tor.sub(m, n)等价于m-n

random

多种伪随机数生成器

8 random模块

函数

介绍

使用

randint(a, b)

两个整型参数，返回二者之间的随机整型

import random

random.randint(a,b)

randrange(start, stop[, step])

接受和range()函数一样的参数，随机返回range([start, ]stop[,step])结果中的一项

random.randrange(1,100,2)

uniform()

几乎和randint()一样，不过返回的是二者之间的一个浮点型（不包括范围上限）

random.uniform(a, b)

random()

类似于uniform()，只不过下限恒等于0，上限恒等于1.0

random.random()

 

choice()

随机返回给定序列的一个元素

random.choice(seq)