python高级编程代码_Python高级编程

过滤删选(解析比filter快)

d = [-1, 3, 2, 1, 0, 10]

r = [x for x in d if d > 3] ==> [10]

dd = {'a': 1, 'b': -1}

rr = {k: v for k, v in dd.items() if v > 0} ==> {'a': 1}

集合对象，减少[0][1]...的使用，提高代码的可维护性

method-1:

index_name_1, index_name_2 ... = xrange(2)

s = ('a', 'b' ...)

s[index_name_1] ==> 'a'

s[index_name_2] ==> 'b'

method-2:

from collections import namdtuple

s = namdtuple('tuple_name', ['index_name_1', 'index_name_2'...])

obj = s('a', 'b' ... )

obj.index_name_1 ==> 'a'

obj.index_name_2 ==> 'b'

对一定结构数据的计数统计

from collections import Counter

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

c = Counter(a)

a[1] ==> 2

a[2] ==> 1

a[3] ==> 2

a[4] ==> 4

c.most_common(1) ==> [(4, 4)]

Counter方法详细介绍：http://www.pythoner.com/205.html

dict中按照value值排序

method-1:

a = {'a': 2, 'b': 1, 'c': 5}

sorted(zip(a.itervalues(), a.iterkeys())) ==> [(1, 'b'), (2, 'a'), (5, ')]

method-2:

a = {'a': 2, 'b': 1, 'c': 5}

sorted(a.iteritems(), key=lambda x: x[1]) ==> [('b', 1), ('a', 2), ('c', 5)]

如何快速找到多个字典中的公共键(key)

method-1：(只是试用有限个数)

s1 = {'a': 1, 'b'；2}

s2 = {'b': 1, 'c': 1}

s3 = {'a': 2, 'b': 3, 'd': 1}

s1.viewkeys() & s2.viewkeys() & s3.viewkeys() ==> {'b'}

method-2:

reduce(lambda a, b: a & b, map(dict.viewkeys, [s1, s2, s3])) ==> {'b'}

如何让字典保持有序(collections.OrderedDict)

from time import time

from random import randint

from collections import OrderedDict

d = OrderedDict()

players = list('abcdefgh')

start = time()

for i in xrange(7):

raw_input()

p = players.pop(randint(0, 7 - i))

end = time()

print i + 1, p, end - start

d[p] = (i + 1, end - start)

for y in d:

print y, d[y]

==> p (1, time)

p (2, time)

p (3, time)

p (4, time)

p (5, time)

p (6, time)

p (7, time)

记录历史记录，collections.deque和pickle的使用

from random import randint

from collections import deque

import pickle

N = randint(1, 100)

try:

history = pickle.load(open('history.txt'))

except:

history = deque([], 5)

def guess(k):

if k == N:

print 'right'

return True

if k < N:

print '%s is less then N' % k

else:

print '%s is greater then N' % k

return False

while True:

line = raw_input('plase input a number:')

if line.isdigit():

k = int(line)

history.append(k)

pickle.dump(history, open('history.txt', 'w'))

if guess(k):isalnum

break

elif line == 'history' or line == 'h?':

print list(history)

注：deque列表对象，有两个参数，初始队列和最大长度，并有append和appendleft方法，分别是从后插入和从前插入

pickle的作用是将python对象存入文件，用法与json的使用的方法很相似，有dump和load方法等

使用isdigit判断字符串是否可以转为整型，另外还有很多字符串内置的判断函数

构造可迭代对象，collections.Iterable和collections.Iterator的使用

from collections import Iterable, Iterator

class Demo1(Iterator):

def __init__(self, cities):

self.cities = cities

self.index = 0

def next(self):

if self.index == len(self.cities):

raise StopIteration

city = self.cities[self.index]

self.index += 1

return city

class Demo2(Iterable):

def __init__(self, cities):

self.cities = cities

def __iter__(self):

return Demo1(self.cities)

a = Demo2(['a','b', 'c'])

for each in a:

print each

注：在构造可迭代对象时必须使用raise StopIteration来结束迭代

使用yield生成器实现可迭代对象

class PrimeNumber:

def __init__(self, start, end):

self.start = start

self.end = end

def isPrimeNum(self, k):

if k < 2:

return False

for i in xrange(2, k):

if k % i == 0:

return False

return True

def __iter__(self):

for k in xrange(self.start, self.end + 1):

if self.isPrimeNum(k):

yield k

for x in PrimeNumber(1, 100):

print x

注：关注yield的使用

反向迭代(reversed)

class Demo:

def __init__(self, start, end, step=0.1):

self.start = start

self.end = end

self.step = step

def __iter__(self):

t = self.start

while t <= self.end:

yield t

t += self.step

def __reversed__(self):

t = self.end

while t >= self.start:

yield t

t -= self.step

a = Demo(1.0, 2.0, 0.1)

for x in reversed(a):

print x

注：reversed获得的是反向迭