[《Python2.1宝典》笔记] 1-3章

 

第一章 认识Python

1.1启动Python解释程序

下载一个去安装。提示符">>>"。

第一个例子：

>>> print "Hello world!"

Hello world!

要退出解释程序，输入文件结束符，在Windows中的Ctrl+Z，在Linux下的Ctrl+D，之后按下Enter键。

1.2用变量和表达式进行试验

1.2.1袖珍计算器

可以在交互模式下直接进行计算。

>>> 8/2

4

1.2.2变量

使用变量在一定时间内保留值。变量总是要引用值。变量没有类型，但是对象有类型。不需要声明变量。但是在给一个变量分配值之前，不可以访问，否则会发生NameError错误。

Python区分大小写。

1.3定义函数

def FunctionName(parameter,...):是函数定义的开始，之后是缩进。Python中的缩进有语法意义。遇到非缩进的代码行时就直到该代码块结束了。

1.4运行Python程序

python spam.py

在Windows系统中还可以用鼠标双击执行。在UNIX系统中可以在文件首行加入

#!/usr/bin/python

并且给文件加上可执行属性来直接执行脚本文件。

1.5循环和控制

一个计算500以内质数表的程序：

for PrimeTest in range(2,500):

IsPrime=1 #0是false，非零是true

for TestFactor in range(2,PrimeTest):

if(PrimeTest % TestFactor==0):

IsPrime=0

break

if(IsPrime):

print PrimeTest

1.5.1整除

运算符"%"是取模，即在整除中得到余数。整数和整数相除是整除。

1.5.2循环

for语句设置了一个循环，并在range(startnum,endnum)中设置范围。这里的每次循环PrimeTest都会从range()中获得一个值。

1.5.3采用if语句的分支

if expression:是一个控制块的开头。条件表达式中不允许赋值。

1.5.4中断和继续

break跳出最内层循环。

1.6列表和元组

列表(list)是包含0个或多个元素的有序集合，写列表时用逗号隔开元素，并放在方括号中。

FibonacciList=[1,1,2,3,5,8]

1.6.1元组

元组与列表类似，但是不可改变，使用圆括号。

1.6.2切片和切换

列表是有序的，所以每个列表元素都包含一个索引，可用listname[index]来访问某个元素。索引编号从0开始。

索引编号可用负数，代表从后向前索引，-1是最后一项。

可用listname[start:end]访问子列表，从start开始，到end，但是不包括end。start和end都可以省略，代表从开头或者到结尾。

列表、元组和字符串都是序列类型(Sequence type)。序列类型都支持索引访问，也包括切片操作。

元组和字符串都是不可变的类型，不允许修改其中的元素。但是可以先转换成列表，修改之后再转换回去。例如从元组创建列表：

aList=list(aTuple)

从列表转换到元组：

aTuple=tuple(aList)

1.7词典

词典(Dictionary)是一个Python对象，能够对不同的值交叉引用不同的键。值可为任意对象。

{key:value,key:value}

查找一个值时用dict[key]。但是当访问不存在的键时会发生异常KeyError，用dictionary.get(key,defaultValue)函数可以完成安全获取，即返回一个缺省值。一般缺省值取None，类似于C语言中的NULL。

1.8读写文件

创建文件对象用open(filename,mode)函数，mode是一个字符串指定文件打开方式。得到文件对象之后可以使用read()和write()读写文件，最后用close()来关闭文件。

1.9样例程序：字频率

不同的作者会使用不同的字频率，有助于识别作者。代码略。

1.10加载及使用模块

导入一些其他库import modulename。导入后可用moduleName.itemName访问其成员。例如用string模块的lower函数，将所有大写字母转换成小写。

CurrentWord=string.lower(CurrentWord)

当导入模块时，模块层的代码(即不属于函数也不属于类定义的代码)就会执行。为了允许用户从命令行执行脚本，通常把独立执行的代码放入如下代码块中：

if(__name__=="__main__"):

另一种导入的方法是from foo import itemName，这种语法导入之后可以不加模块名而直接使用itemName。甚至还可以用from foo import *来导入模块所有的内容。不推荐这种方式，会导致命名空间的混乱。

Python不能增强模块中的“保密性”。礼貌是一个注意，仅调用想调用的函数。

1.11创建类

1.11.1一些快速对象术语

类(class)是把数据和行为连接在一起的一种机制。把特殊类的实例(instance)称为对象(object)。类实例包含确定的方法(method)和属性(attribute)。

可以从父类中派生出其他类，称为继承(inheritance)。OOP是一种有效的软件复用方法。

1.11.2对象定位、Python风格

采用class ClassName:定义了一个新类。类后面的控制块是类声明。

采用newObject=ClassName()句法创建对象，这时会先调用__init__()函数。构造函数也可能需要参数。

每个对象方法都获取self参量来作为他的第一个参数，类似于本对象的引用。Python的self与C++/Java中的this相似。

在Python中，不能显式的声明属性。一个对象的属性并不属于本地名字空间的一部分，换句话说，要在某个对象的一个方法中访问该对象的属性foo，一定要输入self.foo。

1.11.3访问类成员

属性和方法都是公共的，全部在外部可见。但是为了保持封装性，很多类都包含一些不能够直接访问的属性和方法。易于维护。

1.11.4示例：点类

import math

class Point:

# __init__方法在创建对象时执行，可以包含参数，并在

# 创建对象时必须指定这些参数。推荐写一个__init__方法

def __init__(self,X,Y):

self.X=X

self.Y=Y

def DistanceToPoint(self,OtherPoint):

"Returns the distance from this point to another"

SumOfSquares=((self.X-OtherPoint.X)**2)+/

((self.Y-OtherPoint.Y)**2)

return math.sqrt(SumOfSquares)

1.12推荐的阅读资料

初学者http://www.honors.montana.edu/~jjc/easytut/easytut/。

全面的http://star-ship.python.net/quick-ref1_52.html

源码http://www.vex.net/parnassus

1.13小结

略...

完成...

-------------------------------------------------------------------

第二章 标识符、变量和数字类型

2.1标识符和运算符

Python中的变量名和标识符与其他语言类似，都是以字母或下划线开头，后面接字母、数字或下划线。长度不限，区分大小写。

以下一些格式有特殊意义，应该准确使用：

_name 不能由"from x import *"而导入的成员

__name__ 系统名

__name 类的私有成员

交互模式下的单下划线"_"代表上一个表达式的计算结果，适于桌面计算器。

2.1.1保留字

and del for is raise

assert elif from lambda return

break else global not try

class except if or while

continue exec import pass

def finally in print

2.1.2运算符

- != % & * ** / ^ | ~

+ < << <= <> == > >= >>

2.2数字类型

2.2.1整型

整型都是32位有符号整数，范围-20亿到+20亿。sys模块的maxint成员保存了允许的最大正整数值。

十六进制是前加0x，八进制是前加0。

2.2.2长整型

长整型的长度不固定，由内存大小所决定。在末尾加L，但是也可以用小写，但是不容易区分，建议用大写。

2.2.3浮点数

允许表示小数值，也可以使用指数。如果不加入小数点则Python理解为整数，可以在浮点数后面加.0代表浮点数，如200.0。有时计算机上会出现舍入错误，这是可以允许的。

浮点数的有效值和值的精度是独立实现的，至少是64位双精度数字，通常还兼容IEEE754。

2.2.4虚数

在语言层提供了支持，但是实际用处不大。在整数后面加上"j"形成虚部。实部和虚部共同构成复数。

>>> 2+5j

(2+5j)

>>> 2*(2+5j)

(4+10j)

2.2.5处理数字类型

+n等于n；-n等于-1*n。

~按位取反：~5=6；数字x的一元按位取反定义-(x+1)

二元运算：+、-、*、/、%、**(乘幂)

按位运算：&、|、^(异或)

移位运算：<<、>>；5<<2=20；50>>3=6；仅限整型和长整型

Python的自动类型转换规则：

1. 如果一个数字是复数，则其他数字也转为复数

2. 如果一个数字是浮点数，其他数字转为浮点数

3. 如果一个数字是长整数，其他数字转为长整数

4. 不符合以上规则，入两个数都为整数，则不转换

abs(x)取绝对值

适于整数、长整数、浮点数。用于复数时取平面点到原点的距离，即二数平方和的开方。

>>> abs(-5.0)

5.0

coerce(x,y)将两个数字转换为同一类型

按照如上的四条规则转换，返回元组。

>>> coerce(5.5,5+2j)

((5.5+0j),(5+2j))

divmod(a,b)带余数整除运算

a整除b，返回结果元组，分别是商和余数

pow(x,y[,z])求幂

同**运算符，必要时，Python试图将两个数字转换成一种通用类型，如果最后的类型无法表达正确的结果时会报错，如最后结果是浮点型而通用类型是整型。

>>> pow(2.0,-1)

0.5

>>> pow(2,-1) #报错ValueError

pow的第三个参数可选，指定对结果进行模运算。

>>> pow(2,5)

32

>>> pow(2,5,10)

2

>>> (2**5)%10

2

使用pow的运算效率更高，因为快速的幂-模运算用于一些密码术。

round(x[,n])舍入

获得浮点数x舍入的最近的数字，可以指定舍入到小数点后n位。

2.3给变量赋值

Python会自动管理变量的生存期，在首次赋值时创建变量，不用后自动清除。

2.3.1简单的赋值语句

最简单的variable=value

>>> a=5

>>> a

5

Python变量并不包含数据，只是引用数据而已。变量(by gashero)所引用的数据类型随时可以更改。

2.3.2多个赋值

>>> a,b,c=5.5,2,10

>>> a,b,c=c,a,b

多个赋值适于元组的打包和拆包。

2.3.3扩充赋值

如a+=5之类的。扩充赋值是Python2.0中的新特性。

扩充赋值运算符：+=、-=、*=、/=、%=、**=、>>=、<<=、&=、|=、^=。对于a+=5语句和a=a+5的区别：

1. 扩充赋值只计算一次，普通方法计算两次

2. 可能的情况下，扩充复制修改原值，而不创建新对象。普通写法会创建新值a+5。

完成...

-------------------------------------------------

第三章 表达式和字符串

3.1表达式

Python中把任何非零，非空，非None的值看作是true，其他是false。常见的比较：

>>> 12>5

1

>>> 2<1

0

3.1.1比较数字类型

Python提供了一组标准的运算符，用于比较数字数据类型：

> < <= >= == !=

Python也支持<>，但是不保证将来也支持

比较之前注意强制转换。复数之间的比较先比较实部，再比较虚部。比较表达式可以使用多个比较操作符，作为and连接。

>>> a,b,c=10,20,30

>>> a

#True because 10<20 and 20<30

在ac也是合法的，但是不推荐。使用min()函数用于获取一组数字中最小的一个，参数个数不限。同时还有max()。参数也可以用序列类型。

cmp(x,y)比较函数比较两个参数的值。x时返回负数，x=y时返回0，x>y时返回正数。

3.1.2复合表达式

使用布尔运算符and、or和not合并单个(by gashero)表达式。Python对布尔运算符的理解与其他语言稍有差别。

and有短路，两端都是true时才为true。

or也有短路，有一端为true时就为true。

not取反。

3.1.3复合表达式

表达式可以组合。圆括号用于控制计算的顺序。

3.1.4运算符的优先顺序

优先顺序从高到低，同层的具有相同优先级

'x' 字符串转换

{key:datum,...} 词典

{x,y,...} 列表

(x,y,...) 元组

f(x,y,...) 函数调用

x[j:k] 切片

x[j] 下标

x.attribute 属性引用

~x 按位取反

+x,-x 正、负

** 乘幂

*,/,% 乘、除、取模

+,- 加、减

<<,>> 移位

& 按位AND

^ 按位XOR

| 按位OR

<,<=,==,!=,>=,> 比较

is,is not 等同性

in,not in 成员资格

not x 布尔型NOT

and 布尔型AND

or 布尔型OR

lambda Lambda表达式

3.2字符串

Python的字符串可以保存各种字符，包括非显示字符，甚至二进制数据。字符串是Python核心的一部分。

3.2.1字符串文字

由单引号或双引号括起来的字符序列。使用哪一种引号随个人喜好，也用于括起来包含另一种引号的字符串。

Python能够自动把只由空格分开的字符串合并起来：

>>> "one" 'two' "three"

'onetwothree'

字符串内部的反斜杠用于把字符串放在多行：

>>> 'Rubber baby /

... buggy bumpers'

'Rubber baby buggy bumpers'

如果文本字符串占据了几行，并且希望保留输入时的格式，则可用三个引号来括起来。而且这种格式中还可以包含两种引号。(by gashero)

字符串的长度len(str)

转义序列，同C语言。"/xhh"用十六进制表示ASCII字符；"/ooo"用八进制表示ASCII字符；"/f"换页；"/v"垂直进格。如果输入无效的转义序列则按照原样输出。

Python中的字符串不一定包含可打印文本，还可以包含图像、网络数据包等等。

还有一种使用未加工的字符串，其中的反斜杠也作为转义字符，但是Python把他们留在字符串内。这种方式采用r前缀。例如：

>>> s=r"c:/games/hl/hl.exe"

>>> s

'c://games//hl//hl.exe'

>>> print s

c:/games/hl/hl.exe

3.2.2处理字符串

可用加法运算符来连接字符串。乘法运算符用于将字符串重复指定次数。注意这里也有运算符优先级的问题。扩展的运算符也是可用的。

因为字符串是序列类型，所以可以进行元素索引和切片。Python字符串不可变。字符串是对象，有一些方法。

索引只是指明字符之间的位置，在索引的数轴上，索引对应的字符是在索引右侧的。包括负数的部分。对于切片只是取数轴上两个索引之间的字符。

Python中没有专门的字符类型，一个字符就是长度为1的字符串。

"%"用于格式化字符串时指定一些替换参数。

>>> "It's %d past %d, %s!" %(7,9,"Fred")

"It's 7 past 9, Fred!"

字符串格式化字符：

字符	说明
d或l	十进制整数
f	浮点数
s	字符串或对象的.str()返回串
c	单个字符
u	无符号十进制整数
X或x	十六进制整数
o	八进制整数
e或E	指数格式的浮点数
g或G	按照较短的格式自选%f或%e
r	对象的repr()版本
%	使用%%打印百分号

Python还允许在%和格式化字符之间加入一些内容，如下：

1.键名，用于提供词典键值，键名放在圆括号中，如：

>>> d={'name':'sam','num':32,'amt':10.12}

>>> '%(name)s is %(num)d years old. has $%(amt).2f' % d

'Sam is 32 years old. has $10.12'

2.-或0，负号指明数字左对齐，0告诉数字用前导0补齐

3.+，正好指明数字总是显示符号，即使是正数

4.最小字段宽度数字，指明应该占据的最小字段，如果打印值占据了较小的空间，Python会补齐，使用空格或前导0，如：

>>> '%5d % 2

' 2'

>>> '%-5d, %05d' % (2,2)

'2 , 00002'

5.附加精度数字，是一个句点字符，前后都可接数字表示显示的最大字符数，小数点后指明数据位数；整数部分是打印的最大位数。

>>> '%.3s' % 'python'

'pyt'

>>> '%05.3f' % 3.5

'3.500'

>>> '%-8.5d' % 10

'00010 '

也可以用星号"*"来代替宽度字段中的位数，如果提供了星号则代表在后面提供宽度值：

>>> '%*.*f' % (6,3,1.41421356)

' 1.414'

3.2.3比较字符串

比较字符串是按照字典顺序进行比较的，按照ASCII码值，区分大小写。空字符串为false，非空字符串为true，注意短路效应。如：

>>> s='page.html'

>>> name=s or 'index.html'

>>> name

'page.html'

因为按照字典序，所以字符串还可以使用min()、max()、cmp()。

字符串是序列类型，所以可用in和not in运算符，测试子串。

>>> 'i' not in 'teamwork'

1

3.2.4Unicode字符串文字

使用16位表示所有语言的符号。从Python2.0开始完全支持。通常在字符串之前加u代表Unicode字符串。

3.3在简单类型之间进行转换

3.3.1转换为数字类型

• int(x[,radix])

按照一个可选的基数radix转换为数字。

>>> int('15')

15

>>> int('15',16) #将十六进制数字15转换为10进制数字

21

要转换的字符串必须是一个有效的整数，不可以是浮点数或其他。另外也可以将其他数字转换为整数。

>>> int(3.5)

3

>>> int(10L)

10

将会丢失小数部分，如果需要四舍五入则用round()函数。

• long(x[,radix])

将字符串转换成一个长整数，也可以指定基数。

>>> long('125')

125L

• float(x)

转换为浮点数。也可以对复数用abs()函数转换成浮点数。

• round(num[,digits])

四舍五入，指定小数位digits，如果忽略则舍弃所有小数。

>>> round(123.4578,3)

123.458

>>> round(123.4578)

124.0

• complex(real[,imaginary])

转换为复数，虚部可略，则为0。

>>> complex('2+5j')

(2+5j)

>>> complex('2')

(2+0j)

• ord(ch)

获取一个字符，返回ASCII码值或Unicode码值。

>>> ord(u'a')

97

3.3.2转换为字符串

将其他类型转换成字符串。

• chr(x)和unichr(x)

是ord()函数的反函数，从ASCII码或Unicode码转换为字符。

• oct(x)或hex(x)

从十进制转换为其他进制的字符串。

• str(obj)

获取一个对象的可打印字符串版本。

• repr(obj)

与str()类似，只是试图返回对象的字符串版本。对于简单类型来说是相同的。在很多地方使用他的简写形式，即小撇号(TAB上面那个)。

从Python2.1开始，str()和repr()都以输入他们的方式显示换行和其他转义字符。当交互模式，Python将调用repr()函数显示对象，通过设置sys.displayhook的值可以使用其他函数完成显示功能。指定为printstr更友好一些。

3.4小结

略...

完成...