从第二章开始吧！

1、程序输出

a、使用print语句输出：调用str()，将数值转化成字符串

b、在交互式解释器中输出：调用repr()函数，将一个对象转化成字符串显示，只是显示用。

str()函数只是把字符串输出而已，但是repr()则说明了输出的是字符串。

str()与repr()具体差异会在第四章中提到。

>>> myString = ‘hello world!’

>>> print myString

hello world!

>>> myString

‘hello world!’

>>> str(‘hello world!’)

‘hello world!’

>>> repr(‘hello world!’)

“‘hello world!'”

2、程序输入和raw_input()内建函数

a、下划线(_)表示：最后一个表达式的值

>>> myString = ‘Hello World!’

>>> print myString

Hello World!

>>> myString

‘Hello World!’

>>> _

‘Hello World!’

b、Python的print语句与字符串格式运算符%结合使用，可实现字符串替换功能

>>> print “%s is number %d” %(“python”,1)

python is number 1

c、input()和raw_input()函数

input()：希望能够读取一个合法的python表达式，如输入字符串是必须使用引号将它廓起来。

raw_input()：把所有输入都当作字符串处理。输出的type为字符串。

>>> a = input(‘please enter:’)

please enter:6

>>> print type(a)

<type ‘int’>

>>> b = raw_input(‘please enter:’)

please enter:6

>>> print type(b)

<type ‘str’>

3、注释

从#开始，直到一行结束的内容都是注释

>>> #one comment

… print ‘hello world’ #another comment

hello world

名为文档字符串的特别注释：可以在模块、类或者函数的起始添加一个字符串，起到在线文档的功能。与普通文档不同，文档字符串可以在运行时

访问，也可以用来自动生成文档。

def foo():

“This is a doc string.”

return True

4、运算符

+   –  *  /  //  %  **

‘/’表示传统除法，即如果两个操作数都是整数的话，它将执行地板除（取比商小的最大整数）。

‘//’表示浮点除法（对结果进行四舍五入）

优先级：乘方(**) > 单目运算符-+ > * / // % >加减+-

<  <=  >  >=   == !=  <>(弃用)

>>> 2 < 4

True

>>> 2 ==4

False

>>> 2 > 4

False

>>> 6.2 < 6

False

>>> 6,2 <= 6.2

(6, True)

>>> 6.2 <= 6

False

>>> 6.2 <= 6.2000

True

>>> 6.2 < 6.2

False

and  or  not

>>> 2 < 4 and 2 == 4

False

>>> 2 > 4 or 2 < 4

True

>>> not 6.2 <=6

True

>>> 3 < 4 < 5

True

上面3 <4 <5是下面的缩写

>>> 3 < 4 and 4 < 5

True

需要合理的使用括号增强代码可读性。

5、变量和赋值

变量名：字母、下划线开头。其余的字符可以是数字、字母或下划线。

Python对大小写敏感。

Python是动态类型语言，不需要预先声明变量的类型，变量的类型和值在赋值那一刻被初始化，变量赋值使用等号执行。

python支持:n *= 10，但是不支持C语言中的自增和自减运算符，Python会将–n解释为-(-n)，从而得到n，同样++n的结果也是n，因为+-也是

表示正负的单目运算符。

6、数字

Python支持五种基本数字类型：

int：    有符号整数

long：   长整数，不要与C语言长整数混淆，python的长整型仅受限于用户计算机虚拟内存总数。

未来版本中，int和long将会无缝结合，长整数后缀”L”也变得可有可无。

bool：   布尔值，将布尔值用到一个数值上下文环境中（如将True与一个数字相加），True会被当成数值1，而False会被当成整数值0.

float：  浮点值

complex：复数

在导入decimal模块后，可以使用decimal数值类型，用于十进制浮点数。

由于在二进制表示中有一个无限循环片段，数字1.1无法用二进制浮点数精确表示，数字1.1实际上会被表示成：

>>> 1.1

1.1000000000000001

>>> import decimal

>>> print decimal.Decimal(‘1.1’)

1.1

7、字符串

Python中字符串被定义为引号之间的字符集合，支持成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可用来包含特殊字符。

支持使用索引运算符([])和切片运算符([:])可以得到子字符串，字符串有其特有的索引规则：第一个字符的索引是0，最后一个字符的索引是-1.

加号(+)用于字符串连接，星号(*)用于字符串重复。

>>> pystr = ”’python

… is cool”’

>>> pystr

‘python\nis cool’

>>> print pystr

python

is cool

8、列表和元组

同一列表和元组能保存任意数量任意类型的Python对象，以0开始索引

列表：[]，元素个数及元素的值可以改变

元组：()，不可更改

使用切片运算[]和[:]可以得到子集。

>>> aList = [1,2,3,4]

>>> aList

[1, 2, 3, 4]

>>> aList[0]

1

>>> aList[2:]

[3, 4]

>>> aList[:3]

[1, 2, 3]

>>> aList[1] = 5

>>> aList

[1, 5, 3, 4]

元组中数值不可改变：

>>> aTuple = (‘robots’,77,93,’try’)

>>> aTuple

(‘robots’, 77, 93, ‘try’)

>>> aTuple[:3]

(‘robots’, 77, 93)

>>> aTuple[1] = 5

Traceback (most recent call last):

File “”, line 1, in ?

TypeError: object does not support item assignment

9、字典

字典由键-值(key-value)对构成，几乎所有类型的Python对象都可以用作键，不过一般还是以数字或者字符串最为常用。

值可以是任意类型的Python对象，字典元素用大括号({})包裹

>>> aDict = {‘host’:’earth’}#create dict

>>> aDict[‘port’] = 80 # add to dict

>>> aDict

{‘host’: ‘earth’, ‘port’: 80}

>>> aDict.keys()

[‘host’, ‘port’]

>>> aDict[‘host’]

‘earth’

>>> for key in aDict:

…   print key,aDict[key]

…

host earth

port 80

10、代码块及缩进对齐

代码块使用缩进对齐来表达代码逻辑，而不是使用大括号。

11、if语句

if    expression1:

if_suite

elif  expression2:

elif_suite

else:

else_suite

python中条件表达式并不需要加括号。

12、while循环

while    expression:

while_suite

>>> counter = 0

>>> while counter < 3:

…   print ‘loop #%d’ %(counter)

…   counter += 1

…

loop #0

loop #1

loop #2

13、for循环和range()内建函数

Python里面的for循环更像shell里面的foreach。Python中的for接受可迭代对象(例如序列或迭代器)作为其参数，每次迭代其中一个元素：

>>> print ‘I like to use the Internet for:’

I like to use the Internet for:

>>> for item in [‘e-mail’,’net-surfing’,’homework’,’chat’]:

…     print item

…

e-mail

net-surfing

homework

chat

print语句默认给每一行添加一个换行符，只要在print语句的最后添加一个逗号(，)就可以改变这种行为，而且加逗号的print语句会在输出的元素之间会自动添加一个空格：

>>> print ‘I like to use the Internet for:’

I like to use the Internet for:

>>> for item in [‘e-mail’,’net-surfing’,’homework’,’chat’]:

…     print item,

…

e-mail net-surfing homework chat

>>> who = ‘knights’

>>> what = ‘Ni!’

>>> print ‘We are the’,who,’who say’,what,what,what,what

We are the knights who say Ni! Ni! Ni! Ni!

>>> print ‘We are the %s who say %s’% \

… (who,((what + ‘ ‘)*4))

We are the knights who say Ni! Ni! Ni! Ni!

要达到递增数值的效果：

>>> for eachNum in [0,1,2]:

…    print eachNum,

…

0 1 2

因为我们要使用的数值范围经常变化，python提供了range()内建函数来生成这种列表

>>> for eachNum in range(3):

…   print eachNum

…

0

1

2

对字符串来说，很容易迭代每一个字符：

>>> for c in foo:

…   print c,

…

a b c

range()经常和len()一起用于字符串索引，下面显示的是每一个元素及其索引值：

>>> foo = ‘abc’

>>> for i in range(len(foo)):

…   print foo[i],'(%d)’%i

…

a (0)

b (1)

c (2)

上述循环存在约束：要么循环索引，要么循环元素，这导致了enumerate()函数推出，它同时做到了这两点：

>>> for i, ch in enumerate(foo):

…   print ch, ‘(%d)’%i

…

a (0)

b (1)

c (2)

14、列表解析

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

>>> sqdEvents = [x ** 2 for x in range(8) if not x %2]

>>>

>>> for i in sqdEvents:

…   print i

…

0

4

16

36

15、文件和内建函数open()、file

如何打开文件：

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

file_name 变量包含我们希望打开的文件的字符串名字， access_mode 中 ‘r’ 表示读取，

‘w’ 表示写入， ‘a’ 表示添加。其它可能用到的标声还有 ‘+’ 表示读写， ‘b’表示二进制访

问. 如果未提供 access_mode ， 默认值为 ‘r’。如果 open() 成功， 一个文件对象句柄会被

返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后， 我们就可

以访问它的一些方法， 比如 readlines() 和close().文件对象的方法属性也必须通过句点属

性标识法访问。

访问属性的方法：句点属性标识法，即在对象名和属性名之间加一个句点：object.attribute

filename = raw_input(‘Enter file name: ‘)

fobj = open(filename, ‘r’)

for eachLine in fobj:

print eachLine,

fobj.close()

对于print eachLine，后面带逗号，是为了抑制出现\n，因为每行已经有自带的换行符了，不抑制\n会出现额外的空行。

此外，这是将文件内容一次性读出，然后再逐行显示。

16、错误和异常

编译时会检查语法错误，Python也允许在程序运行时检测错误。当检测到一个错误，Python解释器就引发一个异常，并显示异常的详细信息。

要给你的代码添加错误检测及异常处理，只要将它们封装在try-except语句中。try之后的代码组是你打算管理的代码。except之后的代码组，则是你处理错误

的代码。

>>> try:

…   filename = raw_input(‘Enter file name: ‘)

…   fobj = open(filename,’r’)

…   for eachLine in fobj:

…     print eachline,fobj.close()

… except IOError,e:

…   print ‘file open error:’,e

…

Enter file name: test

file open error: [Errno 2] No such file or directory: ‘test’

程序员也可以用raise语句故意引发一个异常。

17、函数

函数在调用前必须先定义。如果函数中没有return语句，则会自动返回None对象。Python是通过引用调用的，这意味着函数内对参数的改变会影响到原始对象。

不过事实上只有可变对象会受此影响，对不可变对象来说，它的行为类似按值调用。

def function_name([arguments])：

“optional documentation string”

function_suite

参数中[]表示参数可选，调用python函数时不能省略()。

‘+’对于数字是两数之和，对于字符串则是两个字符串连接，对应列表，则是：

>>> [1,2] + [3,4]

[1, 2, 3, 4]

函数的参数可以有一个默认值，如果提供有默认值：在函数定义中，参数以赋值语句定义。在提供默认值的情况下，如果函数调用时没提供这个参数，就取这个值

作为默认值。

>>> def foo(debug=True):

…   ‘determine if in debug mode with default argument’

…   if debug:

…      print ‘in debug mode’

…   print ‘done’

…

>>> foo()

in debug mode

done

>>> foo(False)

done

18、类

定义类：

class ClassName(base_class[es])：

“optional documentation string”

static_member_declarations

method_declaration

使用class关键字定义类，可以提供一个可选的基类，如果没有合适的基类，那就使用object作为基类。

>>> class FooClass(object):

…    “””my very first class: FooClass”””

…    version = 0.1 # class (data) attribute

…    def __init__(self, nm=’John Doe’):

…        “””constructor”””

…        self.name = nm # class instance (data) attribute

…        print ‘Created a class instance for’, nm

…    def showname(self):

…        “””display instance attribute and class name”””

…        print ‘Your name is’, self.name

…        print ‘My name is’, self.__class__.__name__

…    def showver(self):

…        “””display class(static) attribute”””

…        print self.version #references FooClass.version

…    def addMe2Me(self,x): #does not use ‘self’

…        “””apply + operation to argument”””

…        return x + x

…

上面定义的version是一个静态变量，它将被所有实例及四个方法共享。

__init__()方法有一个特殊的名字，所有名字开始和结束都有两个下划线的方法都是特殊方法。当一个类实例被创建时，__init__()会自动执行，在类实例创建完毕

后执行，__init__()可以被当成构建函数，但是它并不创建实例—-它仅仅是你的对象创建后执行的第一个方法，它的目的是执行一些该对象的必要的初始化工作。

通过创建自己的__init__()方法，可以覆盖默认的__init__()方法（默认的方法什么也不做）。

在该例子中，初始化了一个名为name的类实例属性，这个变量仅在类实例中存在，它并不是实际类本身的一部分。__init__()需要一个默认的参数。

self是类实例自身的引用，类似其他语言的this

创建类实例

>>> foo1 = FooClass()

Created a class instance for John Doe

>>> foo1.showname()

Your name is John Doe

My name is FooClass

>>>

>>> foo1.showver()

0.1

>>> print foo1.addMe2Me(5)

10

>>> print foo1.addMe2Me(‘xyz’)

xyzxyz

对于一个实例来说，self.__class__.__name__表示实例化它的类的名字，self.__class__引用实际的类。

上例没有提供参数，使用的是默认参数’John Doe’，下例是提供了参数：

>>> foo2 = FooClass(‘Jane Smith’)

Created a class instance for Jane Smith

>>> foo2.showname()

Your name is Jane Smith

My name is FooClass

19、模块

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

当你创建了一个python源文件，模块的名字就是不带.py后缀的文件名，一个模块创建后，可从另一个模块中使用import语句导入这个模块来使用：

import module_name

访问一个模块函数或访问一个模块变量：

一旦导入完成，可用句点属性标识法访问：

module.function()

module.variable

使用示例：

>>> import sys

>>> sys.stdout.write(‘Hello World!\n’)

Hello World!

>>> sys.platform

‘linux2’

>>> sys.version

‘2.4.3 (#1, May  5 2011, 16:39:10) \n[GCC 4.1.2 20080704 (Red Hat 4.1.2-50)]’

里面的write()不会自动在字符串后面添加换行符号，所以需要显示添加’\n’

20、实用函数

内建函数：                           描述

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 对象！）