摘自python cookbook1(字符串，字典)

摘自python cookbook1(字符串，字典)
url：http://wiki.woodpecker.org.cn/moin/PyCookbook



1.变量互换值，在java里需要使用临时变量，在python中则可以不必这样，只需 a,b,c=c,a,b这样的即可

2.你需要从字典中获得一个值，不要处理在字典里找不到你所需要的键值的异常。dic.get('key', 'not found')

3.用一个字典D工作，如果D[k]存在，使用它。如果不存在增加一个新的D[k] .d.setdefault(word, []).append(pagenumber)

4.你需要执行一段合适的代码去和一些控制变量的值来通信。问题在于在一些其他语言里，你可能要 处理case,switch, 或者select语句。
在python里可以使用字典来进行处理。如下所示：
animals = []
number_of_felines = 0

def deal_with_a_cat( ):
global number_of_felines
print "meow"
animals.append('feline')
number_of_felines += 1

def deal_with_a_dog( ):
print "bark"
animals.append('canine')

def deal_with_a_bear( ):
print "watch out for the *HUG*!"
animals.append('ursine')

tokenDict = {
"cat": deal_with_a_cat,
"dog": deal_with_a_dog,
"bear": deal_with_a_bear,
}

# Simulate, say, some words read from a file
words = ["cat", "bear", "cat", "dog"]

for word in words:
# Look up the function to call for each word, then call it
functionToCall = tokenDict[word]
functionToCall( )
# You could also do it in one step, tokenDict[word]( )

5.给定两个字典，你要找出它们共有的键的集合。如：print "Intersects:", filter(another_dict.has_key, some_dict.keys())
或print "Intersects:", [k for k in some_dict if k in another_dict] 这两种方法会比较好一些

6.你想在一个list上的所有元素上执行一个操作.但是你想避免使用map和filter .因为他们难以阅读和理解, 特别是当使用lambda的时候.
如：thenewlist = [x + 23 for x in theoldlist if x > 5]

7.你需要在一个序列上循环，但是在每一步，你也需要知道什么索引进入到你已经到达的序列中。
如：for index in range(len(sequence)):
something(sequence[index], index)
或：class Indexed:
def _ _init_ _(self, seq):
self.seq = seq
def _ _getitem_ _(self, i):
return self.seq[i], i

for item, index in Indexed(sequence):
something(item, index)

8.你需要变换一个列表的列表，把行转换成列，反之亦然。
如：print [[r[col] for r in arr] for col in range(len(arr[0]))]

9.你想建立一个多维list， 但是最简单的方法充满惊奇
如：multilist = [[0 for col in range(5)] for row in range(10)]

10.想排序一个字典。因为排序是一个仅仅对序列有意义的概念。
如：def sortedDictValues2(adict):
keys = adict.keys( )
keys.sort( )
return [adict[key] for key in keys]
更好的一种方法：
def sortedDictValues3(adict):
keys = adict.keys( )
keys.sort( )
return map(adict.get, keys)

11.需要有效的处理来自于两个大的相关数据集合的数据对。使用一个辅助的字典去做数据的预处理。因此会减少在大多数不相关数据上的迭代。
如（原方法）：results = [ process(webhit, ccinfo) for webhit in weblog for ccinfo in cclog \
if ccinfo.ipaddress==webhit.ipaddress ]
新方法：
ipdict = {}
for webhit in weblog: ipdict.setdefault(webhit.ipaddress, []).append(webhit)
results = [ process(webhit, ccinfo) for ccinfo in cclog \
for webhit in ipdict[ccinfo.ipaddress] ]

12.你需要一个保证稳定的方法来排序一个python list。除了速度之外， 装饰－排序－去除装饰（DSU）提供了比仅仅使有一个比较函数参数的排序所没有的弹性。
如：def stable_sorted_copy(alist, _indices=xrange(sys.maxint)):
# Decorate: prepare a suitable auxiliary list
decorated = zip(alist, _indices)

# Sort: do a plain built-in sort on the auxiliary list
decorated.sort( )

# Undecorate: extract the list from the sorted auxiliary list
return [ item for item, index in decorated ]

def stable_sort_inplace(alist):
# To sort in place: assign sorted result to all-list slice of original list
alist[:] = stable_sorted_copy(alist)


13.二分查找法是一个在python通过bisect来提供的基本算法。怎样去执行一个二分查找去检查是否一个值出现在一个list里可以总结成三行代码
如：thelist.sort( )
item_insert_point = bisect.bisect(thelist, theitem)
is_present = thelist[item_insert_point-1:item_insert_point] == [theitem]
或：is_present = thelist and thelist[item_insert_point-1] == theitem


14.你有一个对象list，你需要根据每个对象的一个属性来对他们排序，要尽可能的快和方便。
如：def sort_by_attr(seq, attr):
import operator
intermed = map(None, map(getattr, seq, (attr,)*len(seq)),
xrange(len(seq)), seq)
intermed.sort( )
return map(operator.getitem, intermed, (-1,)*len(intermed))

def sort_by_attr_inplace(lst, attr):
lst[:] = sort_by_attr(lst, attr)

15.不用循环从一个list中选择随机的元素
如： def best( ):
random.shuffle(data)
for elem in data: process(elem)

# or, if you need to preserve the data list's original ordering:
def best_preserve( ):
aux = list(data)
random.shuffle(aux)
for elem in aux: process(elem)
或：def faster( ):
while data:
index = random.randrange(len(data))
elem = data[index]
# direct deletion, no search needed
del data[index]
process(elem)


16.在一个序列里，你需要为成员关系执行频繁的测试。在操作上重复O(N)行为损害了性能。但是你不 能切换去使用一个字典，因为你需要这个序列的顺序。
如：def addUnique2(baseList, otherList):
auxDict = {}
for item in baseList:
auxDict[item] = None
for item in otherList:
if not auxDict.has_key(item):
baseList.append(item)
auxDict[item] = None

17.三行代码中展示Quicksort
def qsort(L):
if len(L) <= 1: return L
return qsort([lt for lt in L[1:] if lt < L[0]]) + L[0:1] + \
qsort([ge for ge in L[1:] if ge >= L[0]])


18.判断是否是字符串
如：def isStringLike(anobj):
try: anobj + ''
except: return 0
else: return 1

19.有几个小的字符串，你想吧他们合并成一个大的字符串
如：为了把短的片断放在少数的变量中，字符串操作符'%'经常是更好的选择!
largeString = '%s%s something %s yet more' % (small1, small2, small3)
或：为了加入一系列的短字符串到一个大的字符串中，字符串操作符join总是最好的：
largeString = ''.join(pieces)

20.你需要检查检查是否一个集合的字符在某个字符串中出现.
如：def containsAny(str, set):
""" Check whether sequence str contains ANY of the items in set. """
return 1 in [c in str for c in set]

def containsAll(str, set):
""" Check whether sequence str contains ALL of the items in set. """
return 0 not in [c in str for c in set]

21.测一个字符串是否表达一个整数
如：def isInt(astring):
""" Is the given string an integer? """
try: int(astring)
except ValueError: return 0
else: return 1
或：def isAllDigits(astring):
""" Is the given string composed entirely of digits? """
# In Python 2.0 and later, "astring.isdigit( ) or not astring" is faster
import string
acceptable_characters = string.digits
for acharacter in astring:
if acharacter not in acceptable_characters:
return 0
return 1