Python-快速入门
【注】本文是学习《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 数字操作符
如果有一个操作数是复数，另一个操作数被转换为复数；
否则，如果有一个操作数是浮点型，这另一个操作数被转换为浮点型；
否则，如果有一个操作数是长整型，这另一个操作数被转换为长整型；
否则，两者必然为普通整型，无需要转换
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)或者
。
幂运算：幂运算操作符比其左侧操作符的一元操作符优先级低，比其右侧操作符的一元操作符的优先级高。
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) |
