Python-快速入门

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

1 Python快速入门

1.1 格式化输出print

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

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

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

1.2 标准输入raw_input

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

1.3 输出重定向

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

1.4 运算符

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

1.5 数字

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

1.6 字符串

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

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

1.7 列表

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

>>> alist = [1, 2, 3, 4]
>>> alist[0]
1
>>> alist[-1]
4
>>> alist[0:3]
[1, 2, 3]
>>> alist[2] = 5
>>> alist
[1, 2, 5, 4]
>>>

1.8 元组

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

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

1.9 字典

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

>>> adict = {'host':'search'}
>>> adict['port'] = 90
>>> adict
{'host': 'search', 'port': 90}
>>> adict.keys()
['host', 'port']
>>> adict['host']
'search'
>>> adict['port']
90
>>> for key in adict:    
...     print key, adict[key]
... 
host search
port 90

1.10 if

if expression1:
if_suite
elif expression2:
    elif_suite
else:
    else_suite

1.11 while

while expression:
    while_suite

1.12 for

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

>>> for item in ['email', 'net', 'home']:
...     print item,                      
... 
email net home

1.13 range

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

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

1.14 enumerate

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

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

1.15 列表解析

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

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

1.16 open

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

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

返回值：文件句柄

>>> fobj = open(filename, 'r')
>>> for eachline in fobj:
...     print eachline    ,
... 
>>> fobj.close

1.17 错误和异常

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

>>> try:
...     filename = raw_input('filename: ')
...     for eachline in fobj:
...         print eachline,
...     fobj.close()
... except IOError, e:
...     print 'file open error:', e

1.18 函数

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

函数参数是可选的

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

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

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

>>> def foo(debug = True):
...     if debug:                
...         print 'in debug mode'
...     print 'done'             
... 
>>> foo()
in debug mode
done

1.19 类

定义类：

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

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

>>> class fooclass(object):
...     version = 0.1
...     def __init__(self, name='John'):
...         self.name = name
...         print 'create a class instance for', name
...     def showname(self):
...         print 'your name is ', self.name
...     def addme2me(self, x):
...         return x+x

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

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

1.20 模块

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

导入模块：import module_name

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

>>> import sys
>>> sys.stdout.write('hello, world!
')
hello, world!
>>> sys.platform
'linux2'

1.21 赋值

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

>>> n = 12
>>> n ^= 3
>>> n
15

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

>>> x = y = z = 1
>>> x
1
>>> y
1
>>> z
1

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

>>> (x, y, z) = (1, 2.2, 'string')
>>> x
1
>>> y
2.2000000000000002
>>> z
'string'
>>> (x, y) = (y, x)
>>> x
2.2000000000000002
>>> y
1

1.22 python对象

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

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

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

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

1.23 数字

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

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

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

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

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

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

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

>>> acomplex = -8.333-1.47j
>>> acomplex
(-8.3330000000000002-1.47j)
>>> acomplex.real
-8.3330000000000002
>>> acomplex.imag
-1.47
>>> acomplex.conjugate()
(-8.3330000000000002+1.47j)
>>>

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)或者 

。 

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

>>> 3 ** 2
9
>>> -3 ** 2
-9
>>> 4.0 ** -1.0
0.25

1.26 位操作符

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

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

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

1.27 标准类型函数

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

1.28 数字类型函数

>>> int(4.12)
4
>>> long(321)
321L
>>> complex(4)
(4+0j)
>>> complex(4, -8)
(4-8j) 

1.29 功能函数

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

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

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

>>> coerce(1, 2)
(1, 2)
>>> coerce(1.3, 2L)
(1.3, 2.0)
>>> coerce(1, 2L)  
(1L, 2L)
>>> coerce(1j, 2L)
(1j, (2+0j))
>>> coerce(1.23+4j, 2L) 
((1.23+4j), (2+0j))

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

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

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

>>> pow(2, 5)
32
>>> pow(5, 2) 
25

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

>>> round(3)
3.0
>>> round(3.45)
3.0
>>> round(3.49999, 1)
3.5
>>> import math
>>> for eachnum in range(10):
...     print round(math.pi, eachnum)
... 
3.0
3.1
3.14
3.142
3.1416
3.14159
3.141593
3.1415927
3.14159265
3.141592654
>>> round(-3.5)
-4.0
>>> round(-3.4)
-3.0
>>> round(-3.49)
-3.0
>>> round(-3.49, )
-3.0
>>> round(-3.49, 1)
-3.5

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

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

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

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

1.30 仅用于整型的函数

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

>>> hex(255)
'0xff'
>>> oct(255)
'0377'

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

>>> ord('A')
65
>>> chr(97)
'a'

1.31 布尔数

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

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

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

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

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

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

>>> person = ['name', ['saving', 100.0]]
>>> hubby = person[:]
>>> wifey = list(person)
>>> [id(x) for x in person, hubby, wifey]
[140275404798072, 140275404797928, 140275404798936]
>>> hubby[0] = 'joe'
>>> wifey[0] = 'jane'
>>> hubby, wifey
(['joe', ['saving', 100.0]], ['jane', ['saving', 100.0]])
>>> hubby[1][1] = 50.0
>>> hubby, wifey      
(['joe', ['saving', 50.0]], ['jane', ['saving', 50.0]])

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

>>> [id(x) for x in hubby]
[140275404800288, 140275404797784]
>>> [id(x) for x in wifey]
[140275404800096, 140275404797784]

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

>>> person = ['name', ['saving', 100.0]] 
>>> hubby = person
>>> import copy
>>> wifey = copy.deepcopy(person) 
>>> [id(x) for x in person, hubby, wifey]
[140275404798792, 140275404798792, 140275404798072]
>>> hubby[0] = 'joe'
>>> wifey[0] = 'jane'
>>> hubby, wifey
(['joe', ['saving', 100.0]], ['jane', ['saving', 100.0]])
>>> hubby[1][1] = 50.5
>>> hubby, wifey      
(['joe', ['saving', 50.5]], ['jane', ['saving', 100.0]])
>>> [id(x) for x in hubby]
[140275404801968, 140275404797136]
>>> [id(x) for x in wifey]
[140275404800624, 140275404799080]

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

>>> person = ('name', ('saving', 100.0))  
>>> newperson = copy.deepcopy(person)   
>>> [id(x) for x in person, newperson]
[140275404813160, 140275404813160]
>>> [id(x) for x in person] 
[140275405043824, 140275404797424]
>>> [id(x) for x in newperson]
[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)