Python 学习笔记

参考

diveintopython.org

Python 的语法特点

（Something strange ……）

代码缩进不再是美观的需要，而称为语法的一部分！

函数的参数传递：支持关键字参数传递使参数顺序不再重要！

内嵌代码中的帮助文档: DocStrings

三引号的字符串

while 循环和 for 循环可以带 else 语句块

交换赋值：a,b = b,a

Class 中 method（方法）的第一个参数非常特殊：需要声明（self），调用时却不提供（Python 自动添加）。

类的构造函数名称为 __init__(self, ...)

类的 Class 变量和 Object 变量

一切皆是对象：甚至字符串，变量，函数，都是对象

获得帮助

如何获得帮助？

1. 进入 python 命令行

2. 包含要查询的模组。如： import sys

3. 显示该模组包含的属性。命令： dir(sys)

4. 获取该模组的帮助。如： help(sys)

源文件的字符集设置

为支持中文，需要在源码的第一行或第二行（一般是第二行）添加特殊格式的注释，声明源文件的字符集。默认为 7-bit ASCII

格式为： # -*- coding: <encoding-name> -*-

参见: http://www.python.org/dev/peps/pep-0263/

如：设置 gbk 编码：

#!/usr/bin/python

# -*- coding: gbk -*-

如：设置 utf-8 编码

#!/usr/bin/python

# -*- coding: utf-8 -*-

注： emacs 能够也能识别该语法。而 VIM 通过 # vim:fileencoding=<encoding-name> 来识别

常量和变量

变量

变量名规则和 C 的相类似

合法的变量名，如： __my_name, name_23, a1b2_c3 等

保留关键字（不能与之重名）

and　　　　　 def　　　　 exec　　　　 if　　　　　not　　　　 return

assert　　　 del　　　　 finally　　　 import　　　or　　　　　try

break　　　　 elif　　　　 for　　　　　in　　　　　pass　　　　while

class　　　　 else　　　　from　　　　 is　　　　　print　　　 yield

continue　　 except　　　global　　　 lambda　　　raise

没有类型声明，直接使用

类型综述 / 查看类型

int

>>> type(17)

<type 'int'>

float

>>> type(3.2)

<type 'float'>

long

>>> type(1L)

<type 'long'>

>>> type(long(1))

<type 'long'>

bool

True 和 False，注意大小写

>>> type(True)

<type 'bool'>

>>> type(1>2)

<type 'bool'>

string

>>> type("Hello, World!")

<type 'str'>

>>> type("WorldHello"[0])

<type 'str'>

即 Python 没有 Char 类型

list

>>> type(['a','b','c'])

<type 'list'>

>>> type([])

<type 'list'>

tuple

>>> type(('a','b','c'))

<type 'tuple'>

>>> type(())

<type 'tuple'>

dict

>>> type({'color1':'red','color12':'blue'})

<type 'dict'>

>>> type({})

<type 'dict'>

字符串

三引号

三引号：''' 或者 """ 是 python 的发明。三引号可以包含跨行文字，其中的引号不必转义。（即内容可以包含的换行符和引号）

如

'''This is a multi-line string. This is the first line.

This is the second line.

"What's your name?," I asked.

He said "Bond, James Bond."

'''

单引号和双引号都可以用于创建字符串。

注意，单引号和双引号没有任何不同，不像 PHP, PERL

\ 作为转义字符，\ 用在行尾作为续行符

r 或者 R 作为前缀，引入 Raw String

例如: r"Newlines are indicated by \n."

在处理常规表达式，尽量使用 Raw String，免得增加反斜线。例如 r'\1' 相当于 '\\1'。

u 或者 U 作为前缀，引入 Unicode

例如: u"This is a Unicode string."

u， r 可以一起使用，u在r前

例如 ur"\u0062\n" 包含三个字符

\u0062

字符串连接：两个字符串并排，则表示两个字符串连接在一起

'What\'s ' "your name?" 自动转换为 "What's your name?" .

作用一：减少 \ 作为续行符的使用。

作用二：可以为每段文字添加注释。如：

re.compile("[A-Za-z_]" # letter or underscore

"[A-Za-z0-9_]*" # letter, digit or underscore

)

用括号包含多行字串

>>> test= ("case 1: something;" # test case 1

... "case 2: something;" #test case 2

... "case 3: something." #test case 3

... )

>>> test

'case 1: something;case 2: something;case 3: something.'

类似于 sprintf 的字符串格式化

header1 = "Dear %s," % name

header2 = "Dear %(title)s %(name)s," % vars()

字符串操作

String slices

[n] : 字符串的第 n+1 个字符

print "WorldHello"[0]

str="WorldHello"

print str[len(str)-1]

[n:m] : 返回从 n 开始到 m 结束的字符串，包括 n，不包括 m

>>> s = "0123456789"

>>> print s[0:5]

01234

>>> print s[3:5]

34

>>> print s[7:21]

789

>>> print s[:5]

01234

>>> print s[7:]

789

>>> print s[21:]

len : 字符串长度

len("WorldHello")

字符串比较

==, >, < 可以用于字符串比较

string 模组

警告： python 中字符串不可更改，属于常量

# 错误！字符串不可更改

greeting = "Hello, world!"

greeting[0] = 'J' # ERROR!

print greeting

# 可改写为：

greeting = "Hello, world!"

newGreeting = 'J' + greeting[1:]

print newGreeting

数字

整形和长整形

浮点数

类型转换

int("32")

int(-2.3)

float(32)

float("3.14159")

str(3.14149)

ord('A') ：返回字母'A' 的 ASCII 值

复杂类型，如 list, tuple, dict 参见后面章节

局部变量与全局变量

函数中可以直接引用全局变量的值，无须定义。但如果修改，影响只限于函数内部。

函数中没有用 global 声明的变量是局部变量，不影响全局变量的取值

global 声明全局变量

#!/usr/bin/python

def func1():

print "func1: local x is", x

def func2():

x = 2

print 'func2: local x is', x

def func3():

global x

print "func3: before change, x is", x

x = 2

print 'func3: changed x to', x

x = 1

print 'Global x is', x

func1()

print 'Global x is', x

func2()

print 'Global x is', x

func3()

print 'Global x is', x

locals() 和 globals() 是两个特殊函数，返回局部变量和全局变量

locals() 返回局部变量的 copy，不能修改

globals() 返回全局变量的 namespace, 可以通过其修改全局变量本身

vars() 等同于 locales()，可以用 vars()['key'] = 'value' 动态添加局部变量

复杂类型

string/unicode（字符串）

list （列表）

方括号建立的列表

[10, 20, 30, 40]

["spam", "bungee", "swallow"]

["hello", 2.0, 5, [10, 20]]

range 函数建立的列表

>>> range(1,5)

[1, 2, 3, 4]

从1 到 5，包括1，但不包括5。（隐含步长为1）

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

从 0 到 10，包括 0，但不包括 10。（隐含步长为1）

>>> range(1, 10, 2)

[1, 3, 5, 7, 9]

步长为2

访问列表中的元素

类似数组下标

print numbers[0]

numbers[1] = 5

print 语句显示列表

vocabulary = ["ameliorate", "castigate", "defenestrate"]

numbers = [17, 123]

empty = []

print vocabulary, numbers, empty

['ameliorate', 'castigate', 'defenestrate'] [17, 123] []

列表操作

列表长度

len() 函数

+ （相加）

>>> a = [1, 2, 3]

>>> b = [4, 5, 6]

>>> c = a + b

>>> print c

[1, 2, 3, 4, 5, 6]

* （重复）

>>> [0] * 4

[0, 0, 0, 0]

>>> [1, 2, 3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

List slices

参见 String slices

列表是变量，可以更改

不像字符串 str， List 是可以更改的

>>> fruit = ["banana", "apple", "quince"]

>>> fruit[0] = "pear"

>>> fruit[-1] = "orange"

>>> print fruit

['pear', 'apple', 'orange']

>>> list = ['a', 'b', 'c', 'd', 'e', 'f']

>>> list[1:3] = ['x', 'y']

>>> print list

['a', 'x', 'y', 'd', 'e', 'f']

列表中增加元素

>>> list = ['a', 'd', 'f']

>>> list[1:1] = ['b', 'c']

>>> print list

['a', 'b', 'c', 'd', 'f']

>>> list[4:4] = ['e']

>>> print list

['a', 'b', 'c', 'd', 'e', 'f']

删除列表中元素

通过清空而删除

>>> list = ['a', 'b', 'c', 'd', 'e', 'f']

>>> list[1:3] = []

>>> print list

['a', 'd', 'e', 'f']

使用 del 关键字

>>> a = ['one', 'two', 'three']

>>> del a[1]

>>> a

['one', 'three']

>>> list = ['a', 'b', 'c', 'd', 'e', 'f']

>>> del list[1:5]

>>> print list

['a', 'f']

查看列表的id

>>> a = [1, 2, 3]

>>> b = [1, 2, 3]

>>> print id(a), id(b)

418650444 418675820

>>> b = a

>>> print id(a), id(b)

418650444 418650444

>>> b = a[:]

>>> print id(a), id(b)

418650444 418675692

引用和Copy/Clone

b = a，则两个变量指向同一个对象，两个变量的值一起变动

b = a[:]，则建立克隆，b 和 a 指向不同对象，互不相干

list 作为函数的参数，是引用调用，即函数对 list 所做的修改会影响 list 对象本身

列表嵌套和矩阵

嵌套

>>> list = ["hello", 2.0, 5, [10, 20]]

>>> list[3][1]

20

矩阵

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> matrix[1]

[4, 5, 6]

>>> matrix[1][1]

5

字符串和列表

string.split 方法

>>> import string

>>> song = "The rain in Spain..."

>>> string.split(song)

['The', 'rain', 'in', 'Spain...']

>>> string.split(song, 'ai')

['The r', 'n in Sp', 'n...']

string.join 方法

>>> list = ['The', 'rain', 'in', 'Spain...']

>>> string.join(list)

'The rain in Spain...'

>>> string.join(list, '_')

'The_rain_in_Spain...'

>>> list = ['The', 'rain', 'in', 'Spain...']

>>> '|'.join(list)

'The|rain|in|Spain...'

Tuples

圆括号建立 Tuple

在最外面用圆括号括起来

>>> type((1,2,3))

<type 'tuple'>

必需是逗号分隔的多个值

>>> type((1))

<type 'int'>

>>> type((1,))

<type 'tuple'>

>>> type(('WorldHello'))

<type 'str'>

>>> type(('WorldHello',))

<type 'tuple'>

Tuple vs list

Tuple 和 list 的区别就是: Tuple 是不可更改的，而 list 是可以更改的

一个元素也可以构成 list，但 tuple 必需为多个元素

>>> type([1])

<type 'list'>

>>> type((1))

<type 'int'>

Dictionaries （哈希表）

花括号建立哈希表

Perl 管这种类型叫做哈希表或者关联数组。即下标可以是字符串的数组

>>> eng2sp = {}

>>> eng2sp['one'] = 'uno'

>>> eng2sp['two'] = 'dos'

>>> print eng2sp

{'one': 'uno', 'two': 'dos'}

访问哈希表中元素：下标为字符串

>>> print eng2sp

{'one': 'uno', 'three': 'tres', 'two': 'dos'}

>>> print eng2sp['two']

'dos'

哈希表操作

keys() 方法，返回 keys 组成的列表

>>> eng2sp.keys()

['one', 'three', 'two']

values() 方法，返回由 values 组成的列表

>>> eng2sp.values()

['uno', 'tres', 'dos']

items() 方法，返回由 key-value tuple 组成的列表

>>> eng2sp.items()

[('one','uno'), ('three', 'tres'), ('two', 'dos')]

from MoinMoin.util.chartypes import _chartypes

for key, val in _chartypes.items():

if not vars().has_key(key):

vars()[key] = val

haskey() 方法，返回布尔值

>>> eng2sp.has_key('one')

True

>>> eng2sp.has_key('deux')

False

get() 方法

返回哈希表某个 key 对应的 value

如 eng2sp.get('one')

等同于 eng2sp['one']

get() 可以带缺省值，即如果没有定义该 key，返回缺省值

如 eng2sp.get('none', 0)，如果没有定义 none, 返回 0，而不是空

引用和 copy/clone

哈希表的克隆：copy() 方法

>>> opposites = {'up': 'down', 'right': 'wrong', 'true': 'false'}

>>> copy = opposites.copy()

Iterators

type 函数返回变量类型

isinstance(varname, type({}))

语句

每一行语句，不需要分号作为语句结尾！

如果多个语句写在一行，则需要分号分隔；

用 “\” 显示连接行

如：

i=10

print \

i

默认连接行

方括号，圆括号，花括号中的内容可以多行排列，不用 \ 续行，默认续行

例如：

month_names = ['Januari', 'Februari', 'Maart', # These are the

'April', 'Mei', 'Juni', # Dutch names

'Juli', 'Augustus', 'September', # for the months

'Oktober', 'November', 'December'] # of the year

缩进

一条语句前的空白（空格、TAB）是有意义的！

相同缩进的语句成为一个逻辑代码块

错误的缩进，将导致运行出错！

缩进的单位是空格。Tab 转换为1-8个空格，转换原则是空格总数是 8 的倍数。

空语句 pass

def someFunction():

pass

操作符和表达式

** 代表幂

3 ** 4 gives 81 (i.e. 3 * 3 * 3 * 3)

// 代表 floor

4 // 3.0 gives 1.0

% 代表取余

-25.5 % 2.25 gives 1.5 .

<< 左移位

>> 右移位

<, >, <=, >=, ==, != 和 C 类似

比较可以级联。如：

if 0 < x < 10:

print "x is a positive single digit."

~, &, |, ^ 和 c 语言相同

5 & 3 gives 1.

5 | 3 gives 7.

5 ^ 3 gives 6

~5 gives -6

取反。 ~x 相当于 -(x+1)

and, or, not 代表逻辑与或非

if 0 < x and x < 10:

print "x is a positive single digit."

is 和 is not，用于比较两个 object 是否为同一个对象

实际上两个对象的 ID 相同，才代表同一个对象。

is: id(obj1) == id(obj2)

is not: id(obj1) != id(obj2)

in, not in 用于测试成员变量

'a' in ['a', 'b', 'c'] # True

交换赋值 a,b = b,a

为交换变量 a, b 的值，其它语言可能需要一个中间变量

temp=a

a=b

b=temp

python 有一个交换赋值的写法： a,b = b,a

控制语句

if 语句

if ... elif ... else ，示例：（注意冒号和缩进）

#!/usr/bin/python

# Filename : if.py

number = 23

guess = int(raw_input('Enter an integer : '))

if guess == number:

print 'Congratulations, you guessed it.' # new block starts here

print "(but you don't win any prizes!)" # new block ends here

elif guess < number:

print 'No, it is a little higher than that.' # another block

# You can do whatever you want in a block ...

else:

print 'No, it is a little lower than that.'

# you must have guess > number to reach here

print 'Done'

# This last statement is always executed, after the if statement

# is executed.

注意: 没有 switch... case 语句！

while 循环语句

while ... [else ...] ，示例：（else 可选）

#!/usr/bin/python

# Filename : while.py

number = 23

stop = False

while not stop:

guess = int(raw_input('Enter an integer : '))

if guess == number:

print 'Congratulations, you guessed it.'

stop = True # This causes the while loop to stop

elif guess < number:

print 'No, it is a little higher than that.'

else: # you must have guess > number to reach here

print 'No, it is a little lower than that.'

else:

print 'The while loop is over.'

print 'I can do whatever I want here.'

print 'Done.'

break 和 continue 语句

break 语句跳出循环，且不执行 else 语句

for 循环语句

for... else... ，示例：（else 可选）

#!/usr/bin/python

# Filename : for.py

for i in range(1, 5):

print i

else:

print 'The for loop is over.'

range(1,5) 相当于 range(1,5,1) 第三个参数为步长

range 止于第二个参数，但不包括第二个参数

break 和 continue 语句

break 语句跳出循环，且不执行 else 语句

后置 for 语句

[ name for name in wikiaction.__dict__ ]

actions = [name[3:] for name in wikiaction.__dict__ if name.startswith('do_')]

示例

字符串中的字符

prefixes = "JKLMNOPQ"

suffix = "ack"

for letter in prefixes:

print letter + suffix

函数

函数声明

def 关键字

函数名

括号和参数

冒号

如：

#!/usr/bin/python

# Filename : func_param.py

def printMax(a, b):

if a > b:

print a, 'is maximum'

else:

print b, 'is maximum'

printMax(3, 4) # Directly give literal values

参数的缺省值

如同 C++ 那样

#!/usr/bin/python

# Filename : func_default.py

def say(s, times = 1):

print s * times

say('Hello')

say('World', 5)

关键字参数

在 C++ 等语言中遇到如下困扰：有一长串参数，虽然都有缺省值，但只为了修改后面的某个参数，还需要把前面的参数也赋值。这种方式，在 python 中称为顺序参数赋值。

Python 的一个特色是关键字参数赋值

例如：

#!/usr/bin/python

# Filename : func_key.py

def func(a, b=5, c=10):

print 'a is', a, 'and b is', b, 'and c is', c

func(3, 7)

func(25, c=24)

func(c=50, a=100)

可变参数

参数前加 * 或者 **，则读取的是 list 或者 dictionary

示例1

#!/usr/bin/python

def sum(*args):

'''Return the sum the number of args.'''

total = 0

for i in range(0, len(args)):

total += args[i]

return total

print sum(10, 20, 30, 40, 50)

函数返回值

return 语句提供函数返回值

没有 return，则返回 None

DocStrings

DocStrings 提供函数的帮助

函数内部的第一行开始的字符串为 DocStrings

DocStrings 一般为多行

DocString 为三引号扩起来的多行字符串

第一行为概述

第二行为空行

第三行开始是详细描述

DocStrings 的存在证明了函数也是对象

函数的 __doc__ 属性为该 DocStrings

例如 print printMax.__doc__ 为打印 printMax 函数的 DocStrings

help( ) 查看帮助就是调用函数的 DocStrings

Lambda Forms

Lambda Forms 用于创建并返回新函数，即是一个函数生成器

示例

内置函数和对象

帮助： import __builtin__; help (__builtin__)

函数

数学／逻辑／算法

abs(number) : 绝对值

cmp(x,y) ：比较x y 的值。返回 1,0,-1

divmod(x, y) -> (div, mod) ：显示除数和余数

pow(x, y[, z]) -> number

round(number[, ndigits]) -> floating point number ：四舍五入，保留 n 位小数

sum(sequence, start=0) -> value ：取 sequence 的和

hex(number) -> string ：返回十六进制

oct(number) -> string ：八进制

len(object) -> integer

max(sequence) -> value

min(sequence) -> value

range([start,] stop[, step]) -> list of integers

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

filter(function or None, sequence) -> list, tuple, or string

function 作用于 sequence 的每一个元素，返回 true 的元素。返回类型同 sequence 类型。

如果 function 为 None，返回本身为 true 的元素

map(function, sequence[, sequence, ...]) -> list

将函数作用于 sequence 每个元素，生成 list

>>> map(lambda x : x*2, [1,2,3,4,5])

[2, 4, 6, 8, 10]

reduce(function, sequence[, initial]) -> value

从左至右，将函数作用在 sequence 上，最终由 sequence 产生一个唯一值。

>>> reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])

15

相当于 ((((1+2)+3)+4)+5)

sorted(iterable, cmp=None, key=None, reverse=False) ：排序

zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

>>> zip('1234','789')

[('1', '7'), ('2', '8'), ('3', '9')]

coerce(x, y) -> (x1, y1)

Return a tuple consisting of the two numeric arguments converted to a common type, using the same rules as used by arithmetic operations. If coercion is not possible, raise TypeError.

字符串

chr(i) ： 0<=i<256, 返回 ascii 码为 i 的字符

unichr(i) -> Unicode character ：返回 unicode 。 0 <= i <= 0x10ffff

ord(c) ：返回字符 c 的 ascii 码

对象相关

delattr(object,name) ：在对象 object 中删除属性 name

delattr(x, 'y') 相当于 del x.y

getattr(object, name[, default]) -> value

getattr(x, 'y') 相当于 x.y

缺省值，是当对象不包含时的取值

hasattr(object, name) -> bool

id(object) -> integer ：返回对象 ID，相当于内存中地址

hash(object) -> integer ：两个对象具有相同的值，就有相当的 hash。但反之未必。

setattr(object, name, value) ：相当于赋值 x.y = v

isinstance(object, class-or-type-or-tuple) -> bool

issubclass(C, B) -> bool

globals() -> dictionary

locals() -> dictionary

vars([object]) -> dictionary

没有参数相当于 locals()

以对象为参数，相当于 object.__dict__

dir([object]) ：显示对象属性列表

repr(object) -> string ：对象 object 的正式名称

reload(module) -> module ：重新加载 module

iter

iter(collection) -> iterator

Get an iterator from an object. In the first form, the argument must

supply its own iterator, or be a sequence.

iter(callable, sentinel) -> iterator

In the second form, the callable is called until it returns the sentinel.

输入输出

input([prompt]) -> value ：输入。相当于 eval(raw_input(prompt))。

raw_input([prompt]) -> string ：输入内容不做处理，作为字符串

其他

__import__(name, globals, locals, fromlist) -> module ：动态加载模块

import module 中的 module 不能是变量。如果要使用变量动态加载模块，使用下面的方法。

def importName(modulename, name):

""" Import name dynamically from module

Used to do dynamic import of modules and names that you know their

names only in runtime.

Any error raised here must be handled by the caller.

@param modulename: full qualified mudule name, e.g. x.y.z

@param name: name to import from modulename

@rtype: any object

@return: name from module

"""

module = __import__(modulename, globals(), {}, [name])

return getattr(module, name)

callable(object) ：是否可调用，如函数。对象也可以调用。

compile(source, filename, mode[, flags[, dont_inherit]]) -> code object

eval(source[, globals[, locals]]) -> value

执行代码，source 可以是字符串表达的代码，或者 compile 返回的 code object

execfile(filename[, globals[, locals]])

intern(string) -> string

对象

basestring

str

unicode

buffer

classmethod

complex

dict

enumerate

file

float

frozenset

int

bool

list

long

property

reversed

set

slice

staticmethod

super

tuple

type

xrange

输入和输出

输入：raw_input vs input

最好用 raw_input

name = raw_input ("What...is your name? ")

input 只能用于输入数字

age = input ("How old are you? ")

如果输入的不是数字，直接报错退出！

文件

打开文件

读

>>> f = open("test.dat","r")

写

>>> f = open("test.dat","w")

>>> print f

<open file 'test.dat', mode 'w' at fe820>

write("content")：写文件

>>> f.write("Now is the time")

>>> f.write("to close the file")

read(count)：读文件

读取全部数据

>>> text = f.read()

>>> print text

Now is the timeto close the file

读取定长数据

>>> f = open("test.dat","r")

>>> print f.read(5)

Now i

判断是否到文件尾：读取内容为空

readline()：读取一行内容，包括行尾换行符

readlines()：读取每行内容到一个列表

关闭文件

>>> f.close()

示例

def copyFile(oldFile, newFile):

f1 = open(oldFile, "r")

f2 = open(newFile, "w")

while True:

text = f1.read(50)

if text == "":

break

f2.write(text)

f1.close()

f2.close()

return

% 格式化输出

% 用在数字中，是取余数。

% 前面如果是字符串，则类似 C 的 printf 格式化输出。

示例

>>> cars = 52

>>> "In July we sold %d cars." % cars

'In July we sold 52 cars.'

>>> "In %d days we made %f million %s." % (34,6.1,'dollars')

'In 34 days we made 6.100000 million dollars.'

pickle 和 cPickle

相当于 C++ 中的序列化

示例

>>> import pickle

>>> f = open("test.pck","w")

>>> pickle.dump(12.3, f)

>>> pickle.dump([1,2,3], f)

>>> f.close()

>>> f = open("test.pck","r")

>>> x = pickle.load(f)

>>> x

12.3

>>> type(x)

<type 'float'>

>>> y = pickle.load(f)

>>> y

[1, 2, 3]

>>> type(y)

<type 'list'>

使用 cPickle

cPickle 是用 C 语言实现的，速度更快