核心编程笔记2.md

关于int(),floor(),round()的说明

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

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

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

---

>>> int(2.323)

2

>>> import math

>>> round(2.623)

3.0

>>> math.floor(2.623)

2.0

hex,oct,ord,unichr

hex(num) 将数字转换成十六进制数并以字符串形式返回

oct(num) 将数字转换成八进制数并以字符串形式返回

chr(num) 将ASCII值的数字转换成ASCII字符,范围只能是0 <= num <= 255。

ord(chr) 接受一个 ASCII 或 Unicode 字符(长度为1的字符串),返回相应的ASCII或Unicode 值。

unichr(num) 接受Unicode码值,返回 其对应的Unicode字符。所接受的码值范围依赖于 你的Python是构建于UCS‐2还是UCS‐4。

>>> hex(2323)

'0x913'

>>> hex(2.32)

Traceback (most recent call last):

File "", line 1, in

TypeError: hex() argument can't be converted to hex

>>> oct(2323)

'04423'

>>> ord('H')

72

>>> chr(72)

'H'

>>> unichr(72)

u'H'

核心模块: random

当你的程序需要随机数功能时,random 模块就能派上用场。该模块包含多个伪随机数发生 器,它们均以当前的时间戳为随机数种子。这样只要载入这个模块就能随时开始工作。下面列 出了该模块中最常用的函数:

两个整数参数,返回二者之间的随机整数

randrange() 它接受和 range()函数一样的参数, 随机返回 range([start,]stop[,step])结果的一项

>>> for i in range(10):

...     print random.randrange(1,100)

...

19

78

79

25

56

42

30

25

64

84

uniform() 几乎和 randint()一样,不过它返回的是二者之间的一个浮点数(不包括范围 上限)。

>>> random.uniform(1,200)

99.49992973419876

>>> random.uniform(1,200)

31.397479296429413

>>> random.uniform(1,200)

62.16024352925623

>>> random.uniform(1,200)

14.23821717081191

>>> random.uniform(1,200)

5.162732675350789

random()类似 uniform() 只不过下限恒等于 0.0,上限恒等于 1.0

choice()随机返回给定序列(关于序列,见第六章)的一个元素

>>> random.random()

0.44415727533326277

>>> random.choice([1,2,3,3,4,2])

3

>>> random.choice([1,2,3,3,4,2])

3

>>> random.choice([1,2,3,3,4,2])

3

>>> random.choice([1,2,3,3,4,2])

3

>>> random.choice([1,2,3,3,4,2])

3

>>> random.choice([1,2,3,3,4,2])

1

>>> random.choice([1,2,3,3,4,2])

2

序列操作符

seq[ind] seq[ind1:ind2] 获得下标为 ind 的元素

seq * expr seq1 + seq2 获得下标从ind1到ind2间的元素集合 序列重复 expr 次

obj in seq 判断 obj 元素是否包含在 seq 中

obj not in seq 判断 obj 元素是否不包含在 seq 中

s[::-1] # 可以视作"翻转"操作

>>> str='1234567'

>>> str[::-1]

'7654321'

>>> for i,j in enumerate(str):

...     print i,j

...

0 1

1 2

2 3

3 4

4 5

5 6

6 7

函数名 enumerate(iter)

zip([it0, it1,... itN])d 返回一个列表,其第一个元素是 it0,it1,...这些元素的第 一个元素组成的一个元组,第二个...,类推.

一般来说,从性能的的角度来考虑,把重复操作作为参数放到循环里面进行是非常低效的.

循环的一个注意事项

while i < len(myString):

print 'character %d is:', myString[i]

上面的循环操作把大把的时间都浪费到了重复计算字符串 myString 的长度上了.每次循环

迭代都要运行一次这个函数.如果把这个值做一次保存,我们就可以用更为高效的方式重写我们 的循环操作.

length = len(myString)

while i < length:

print 'character %d is:', myString[i] 这个方法同样适用于上面的例 6.1

for otherChar in myInput[1:]:

if otherChar not in alphas + nums:

for 循环包含了一个 if 语句,在这个 if 里面执行了合并两个字符串的操作。

被合并的这两个字符串从始至终就没变过,而每次都会重新进行一次计算.如果先把这两个字 符串存为一个新字符串,我们就可以直接引用这个字符串而不用进行重复计算了。

alphnums = alphas + nums

for otherChar in myInput[1:]:

if otherChar not in alphnums:

编译时字符串连接

在xpath里面用过，为了保证不超过80个字符

格式化字符

%c 转换成字符(ASCII 码值,或者长度为一的字符串)

%r 优先用 repr()函数进行字符串转换

%s 优先用 str()函数进行字符串转换

%d / %i 转成有符号八进制数

%u 转成无符号十进制数

%o 转成无符号八进制数

%x/%X (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写)

%e/%E 转成科学计数法(e/E 控制输出 e/E)

%f/%F 转成浮点数(小数部分自然截断)

%% 输出%

字符串模板

>>> from string import Template

>>> s = Template('There are ${howmany} ${lang} Quotation Symbols')

>>> print s.substitute(lang='Python', howmany=3)

There are 3 Python Quotation Symbols

>>>  print s.substitute(lang='Python')

File "", line 1

print s.substitute(lang='Python')

^

IndentationError: unexpected indent

>>> print s.safe_substitute(lang='Python')

There are ${howmany} Python Quotation Symbols

输入

raw_input('enter somthing')

不到必须时不要在你的程序里面编解码 Unicod 字符.只在你要写入文件或数据库或者

网络时,才调用 encode()函数;相应地,只在你需要把数据读回来的时候才调用 decode() 函数.

list函数的一些注意

list.count(obj) 返回一个对象 obj 在列表中出现的次数

list.extend(seq) 把序列 seq 的内容添加到列表中

sort()方法,它默认的排序算法是归并排序(或者说"timsort")的衍生算法,时间复杂 度是 O(lg(n!)).

python 队列

import copy

>>> person = ['name', ['savings', 100.00]]

>>> hubby = person

>>> import copy

>>> wifey = copy.deepcopy(person)

>>> [id(x) for x in person, hubby, wifey]

[4533863560, 4533863560, 4533806792]

>>> hubby[0] = 'joe'

>>> wifey[0] = 'jane'

>>> hubby, wifey

(['joe', ['savings', 100.0]], ['jane', ['savings', 100.0]])

删除字典

del dict2['name'] # 删除键为“name”的条目

dict2.clear() # 删除 dict2 中所有的条目

del dict2 # 删除整个 dict2 字典

dict2.pop('name') # 删除并返回键为“name”的条目

字典的几个重要函数：

dict.clear()

dict.fromkey(seq,val=None)

创建并返回一个新字典,以 seq 中的元素做该字典的键,val 做该字 典中所有键对应的初始值(如果不提供此值,则默认为 None)

dict.get(key,default=None)

对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此 键,则返回 default 的值(注意,参数 default 的默认值为 None)

dict.items()

返回一个包含字典中(键, 值)对元组的列表

dict.keys()

返回一个包含字典中键的列表

dict.iter()

方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法 一样,不同的是它们返回一个迭代子,而不是一个列表

dict.pop(key[, default])

和方法 get()相似,如果字典中 key 键存在,删除并返回 dict[key], 如果 key 键不存在,且没有给出 default 的值,引发 KeyError 异常

dict.setdefault(key,default=None)

和方法 set()相似,如果字典中不存在 key 键,由 dict[key]=default 为它赋值。

集合运算

等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指,对每个集合而言,当 且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。

联合(union)操作和集合的 OR(又称可兼析取(inclusive disjunction))

其实是等价的,两个集 合的联合是一个新集合,该集合中的每个元素都至少是其中一个集合的成员,即,属于两个集合其 中之一的成员。联合符号有一个等价的方法,union().

和其他的布尔集合操作相似,对称差分是集合的 XOR(又称”异或“ (exclusive disjunction)).

两个集合(s 和 t)的对称差分是指另外一个集合C,该集合中的元素,只能是属于集合s或者集合t的成员,不能同时属于两个集合。对称差分有一个等价的方法,

两个集合(s 和 t)的差补或相对补集是指一个集合 C,该集合中的元素,只属于集合 s,而不属 于集合 t。差符号有一个等价的方法,difference().

你可以把交集操作比做集合的 AND(或合取)操作。两个集合的交集是一个新集合,该集合中的每 个元素同时是两个集合中的成员,即,属于两个集合的成员。交集符号有一个等价的方法, intersection().

>>> s = set('cheeseshop')

>>> t = frozenset('bookshop')

>>> print s

set(['c', 'e', 'h', 'o', 'p', 's'])

>>> 'c' in t

False

>>> 'c' in s

True

>>> t

frozenset(['b', 'h', 'k', 'o', 'p', 's'])

>>> s==t

False

>>> s|t

set(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])

>>> s&t

set(['h', 's', 'o', 'p'])

>>> s or t

set(['c', 'e', 'h', 'o', 'p', 's'])

>>> s and t

frozenset(['b', 'h', 'k', 'o', 'p', 's'])

>>> s xor t

File "", line 1

s xor t

^

SyntaxError: invalid syntax

>>> s -t

set(['c', 'e'])

>>> s XOR t

File "", line 1

s XOR t

^

SyntaxError: invalid syntax

>>> s ^ t

set(['b', 'e', 'k', 'c'])