1、判断一个字符串是否为数字：
str.isdigit()方法，将返回True后者False
‘aaa’.isdigit()
False
‘111’.isdigit()
True
‘111.11’.isdigit()
False
2、每次处理一个字符：
strList = list(string)
for c in strList:
do_something(c)
可以使用set来检查两个字符串中的交集
可以使用 str.count(otherStr) 来计算other字符串出现过几次
3、字符串和ascii码转换：
print ord(‘a’)
97
print chr(97)
a
同样unicode也支持
print ord(u’发’)
21457
print unichr(21457)
发
另外需要注意 str 和 chr 的差别，str是直接格式专程string，char是根据int返回ascii
4、类型判断推荐使用 isinstance 方法
def isAString(anobj):
return isinstance(anobj, basestring)
5、去除字符串的空格：
string.lstrip()
string.rstrip()
string.strip()
6、大小写：
将字符串转为大小写和首字母大写，upper(),lower(),title()
判断是否为大小写和首字母大写，isupper(),islower(),istitle()
7、字符串切片操作：
str = str[3:8]
如果要获取5位一组的切片数组
list = [ str[k:k+5] for k in xrange(0, len(str), 5) ]
在小范围的情况下，range和xrange差不多，但是当值比较大，使用xrange效率高一些
8、模拟三元运算：
condition and val1 or val2
x = True and 1 or 2
x
1
x = False and 1 or 2
x
2
9、使用re模块创建一个支持多个字符串匹配的正则表达式：
import re
rx = re.compile(‘|’.join(map(re.escape, adict)))
10、检查文件的扩展名是否为制定的文件名：
s ＝ ‘xxx.jpg’
s.endswith(‘.jpg’)
True
11、unicode编码注意事项：
总结一句话，在接受外部的字符串时，应该将字符串转换为unicode对象，然后根据情况进行decode操作；在响应出去的时候也一样，先将字符串转为unicode然后再转成其他编码的字符串。总之unicode编码对象是一个通用的，中转编码对象。
创建unicode编码的字符串：
str = u’hello world’
将unicode字符串转为其他格式：
utf8string = unicodestring.encode(‘utf8’)
gbkstring = unicodestring.encode(‘gbk’)
将其他收到的外部字符串转换为unicode类型：
unicodestring = unicode(utf8string, ‘utf8’)
unicodestring = unicode(gbkstring, ‘gbk’)
12、文件操作：
使用open方法返回一个文件处理对象，默认打开方式为r，表示以文本的形式打开，rb表示以2进制形式打开。w和wb表示以文本写和2进制写的形式打开文件。最后记得执行 close() 关闭文件。
逐行读取并处理文本文件：
for line in input:
process(line)
13、使用try和finally来处理文本：
file_o = open(‘file.txt’)
try:
all_the_text = file_o.read()
finally:
file_o.close()
注意不要把open也放入try中，不然如果open出错，对于file_o来说时没有什么close的。
可以使用writelines把一个数组字符串写入文本
open(‘file’, ‘wb’).writelines(list_of_data_strings)
对于在文件追加内容使用a和ab这样的模式open文件
14、读取文件返回制定的行内容：
如果我们打算只返回一个小文件的制定行，如下代码：
import linecache
thelline = linecache.getline(the_file_path, desired_line_number)
如果文件过大，我们需要把代码改成这样：
def getline(file_path, line_number):
if line_number < 1: return ‘’
for cur_line_num, line in enumerate(open(file_path, ‘rU’)):
if cur_line_num == line_number - 1 : return line
return ‘’
15、string.format中使用大括号
只需要将大括号写2次就可以转义了，例如：
u’{
{“code”:200,”status”:”ok”,”result”:{0}}
}’.format(str)
16、获取命令行执行的输出：
import commands
status, output = commands.getstatusoutput(‘ps -ef|grep gunicorn’)
print ‘——-‘
print output
print ‘——-‘
print output.find(‘python2.7’)
17、计算文件的行数
大文件循环计数方式：
count = -1
for count, line in enumerate(open(theFilePath, ‘rU’)):
pass
count += 1
还有一种方式，计算换行符：
couont = 0
thefile = open(theFilePath, ‘rb’)
while True:
buffer = thefile.read(8192*1024)
if not buffer:
break
couont += buffer.count(‘\n’)
thefile.close()
18、快速读取zip包中的文件：
import zipfile
z = zipfile.ZipFile(‘zipfile.zip’, ‘r’)
for filename in z.namelist()
print ‘File:’,filename
bytes = z.read(filename)
print ‘has’, len(bytes), ‘bytes’
19、利用python打包文件夹为tar
import tarfile, os
def make_tar(folder_to_backup, dest_folder, compression=’bz2’):
if compression:
dest_ext = ‘.’+compression
else:
dest_ext = ‘’
arcname = os.path.basename(folder_to_backup)
dest_name = ‘%s.tar%s’ % (arcname, dest_ext)
dest_path = os.path.join(dest_folder, dest_name)
if compression:
dest_cmp = ‘:’ + compression
else:
dest_cmp = ‘’
out = tarfile.TarFile.open(dest_path, ‘w’+dest_cmp)
out.add(folder_to_backup, arcname)
out.close()
return dest_path
20、使用glob来查找文件
glob.glob，一次返回所有查找对象
glob.iglob，返回一个可迭代对象，一次返回一个
for path in glob.glob(“C:\source\.bak”):
os.remove(path)
下面的代码返回当前目录的所有子目录中扩展名为.txt的文件
glob.glob(“\*.txt”)
通配符的说明：
通配符 匹配 示例
- 0个或多个任意字符 .m匹配扩展名以m开头的名称
？ 任意单个字符 ???匹配恰好包含3个字符的名称
[…] 方括号中列出的任意一个字符 [AEIOU]匹配以大写的元音字母开头的名称
[!…] 不在方括号中出现的任意一个字符 [!s]匹配不以s结尾的名称
iglob的应用：
import glob
#父目录中的.py文件
f = glob.iglob(r’../*.py’)
print f #
for py in f:
print py
21、计算昨天和明天的日期
考虑使用timedelta来处理
import datetime
today = datetime.date.today()
yesterday = today - datetime.timedelta(days=1)
tomorrow= today + datetime.timedelta(days=1)
22、寻找上一个星期五
通过python标准库的datetime模块，轻松完成此任务
import datetime, calendar
lastFriday = datetime.date.today()
oneDay = datetime.timedeltar(days=1)
while lastFriday.weekday() != calendar.FRIDAY:
lastFriday -= oneday
print lastFriday.strftime(‘%A, %d-%b-%Y’)
23、计算日期之间的时段
计算两个日期之间隔了几周
from dateutil import rrule
import datetime
def weeks_between(start_date, end_date):
weeks = rrule.rrule(rrule.WEEKLY, dtstart = start_date, until = end_date)
return weeks.count
24、定时执行任务：
可以使用sched模块，针对处理定时任务：
import time, os, sys, sched
schedule = sched.scheduler(time.time, time.sleep)
def perform_command(cmd, inc):
schedule.enter(inc, 0, perform_command, (cmd, inc))
os.system(cmd)
def main(cmd, inc=60):
schedule.enter(0, 0, perform_command, (cmd, inc))
schedule.run()
if name == ‘main‘:
main(‘echo ok’, 10)
25、十进制数学计算：
十进制数字计算用来计算精确的数值，一般金融方面较多
import decimal
dl = decimal.Decimal(‘0.3’)
dl/3
(dl/3)*3
26、对象拷贝：
import copy
new_list = copy.copy(exist_list)
new_list = copy.deepcopy(exist_list)
new_list = list(exist_list)
new_dict = dict(exist_dict)
new_set = set(exist_set)
27、将列表中的每个值都加上23：
可以使用列表推导方式，对于旧数组中每个大于5的值加23
newList = [ x+ 23 for x in oldList if x > 5]
#复制列表
L = list(L)
#将L中所有大于100的元素设置成100
L[:] = [min(x, 100) for x in L]
#计算数组中所有元素之和
total = sum(x+ 23 for x in oldList if x > 5)
28、展开一个嵌套的序列
有如下序列，进行展开：
oneList = [1, 2, [3, [], 4 , [5, 6], 7, [8, ], ], 9]
def list_or_tuple(x):
return isinstance(x, (list, tuple))
def flatten(sequence, to_expand=list_or_tuple):
for item in sequence:
if to_expand(item):
for subitem in flatten(item, to_expand):
yield subitem
else:
yield item
for x in flatten(oneList):
print x
输出：1 2 3 4 5 6 7 8 9
29、根据内嵌的数字，对数组进行排序：
比如对 foot1.txt，foot10.txt 这样的字符串进行排序
import re
re_digits = re.compile(‘r’(\d+)’)
def embedded_numbers(s):
pieces = re_digits.split(s) #分割字符串
pieces[1::2] = map(int, pieces[1::2]) #将数字部分转为整数
return pieces
def sort_strings_with_embedded_numbers(alist):
aux = [(embedded_numbers(s), s) for s in alist]
aux.sort()
return [ s for _, s in aux]
30、random.shuffle 对数组重新洗牌：
import random
a = [1,2,3,4,5,6]
print random.shuffle(a)
None
a
[4, 3, 6, 5, 2, 1]
print random.shuffle(a)
None
a
[5, 6, 1, 3, 2, 4]
print random.shuffle(a)
None
a
[3, 4, 1, 5, 2, 6]
31、利用heapq模块查找数组中的最小的几个数：
a = [5, 6, 1, 3, 2, 4]
heapq.nsmallest(2, a)
[1, 2]
32、利用bisect查找元素是否在list中，对于长数组高效：
import bisect
x_insert_point = bisect.bisect_right([1,2,3,4,5,6], 3) #或者使用 bisect_left
33、可排序的python字典：
可以使用 UserDict 类
34、元类的定义：
def someClass(someBase):
metaclass = type
x = 23
someClass = type(‘someClass’, (Somebase,), {‘x’:23})
35、把一个类作为常量：
可以通过_getattr__、setattr、delattr来进行封装：
class _const(object):
class ConstError(TypeError): pass
def setattr(self, name, value):
if name in self.dict
raise self.ConstError, ‘Cant rebind const(%s)' % name
self.__dict__[name] = value
def __delattr__(self, name):
if name in self.__dict__
raise self.ConstError, 'Cant unbind const(%s)’ % name
raise NameError, name
import sys
sys.modules[name] = const() #文件名问const.py
这样任何代码都可以使用和绑定一次这个const
const.magic = 23
36、单例：
new：创建对象时调用，返回当前对象的一个实例
init：创建完对象后调用，对当前对象的实例的一些初始化，无返回值
class Singleton(object):
def new(cls, args, **kwargs):
if ‘_inst’ not in vars(cls):
cls._inst = super(Singleton, cls).new(cls, args, **kwargs)
return cls._inst
37、非单例模式，但是实例共享数据：
class Borg(object):
_shared_state = {}
def new(cls, a, **k):
obj = object.new(cls, a, **k)
obj.dict = cls._shared_state
return obj
38、优化init函数：
很多init函数都是对变量的定义，这样只需要如下就可以优化一些代码
def attributesFromDict(d):
self = d.pop(‘self’)
for n,v in d.iteritems():
setattr(self, n, v)
原本的赋值构造函数：
def init(self, foo, bar, baz, boom=1, bang=2):
self.foo = foo
self.bar = bar
self.baz = baz
self.boom = boom
self.bang =bang
可以改写为：
def init(self, foo, bar, baz, boom=1, bang=2):
attributesFromDict(locals())
不过我还是觉得的原来的直观
39、继承中调用父类的构造函数，py中需要手动：
super(CurClass, self).init()
40、终止线程：
python不允许线程杀死线程，所以每个线程必须周期的检查是否要被杀死：
import threading
class TestThread(threading.Thread):
def init(self, name=’TestThread’):
self._stopevent = threading.Event()
self._sleepperiod = 1.0
threading.Thread.init(self, name=name)
def run(self):
print '%s starts ' % (self.getName(),)
count = 0
while not self._stopevent.isSet():
count += 1
print 'loop %d' % (count, )
self._stopevent.wait(self.__sleepperiod)
print '%s end' % (self.getName(),)
def join(self, timeout=None):
self._stopevent.set()
threading.Thread.join(self, timeout)
if name == ‘main‘:
testthread = TestThread()
testthread.start()
import time
time.sleep(5.0)
testthread.join()
41、生成随机密码：
from random import choice
import string
def GenPasswd(length=8, chars=string.letters+string.digits):
return ‘’.join([ choice(chars) for i in range(length)])
42、简单的UDP服务器和客户端：
udp服务器代码：
import socket
port = 8081
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#从给定的端口，从任何发送者，接受数据
s.bind((‘’, port))
print ‘waiting on port:’, port
while True:
#接收一个数据包（最大1024字节）
data, addr = s.recvfrom(1024)
print 'reveived:', data, 'from', addr
对应的客户端代码：
import socket
port = 8081
host = ‘localhost’
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(‘holy guido it\’s working.’, (host,port))
在windows下可能需要这么发送数据
BUFFSIZE = 1024
while msg:
bytes_sent = s.sendto(msg[:BUFFSIZE], (host, port))
msg = msg[bytes_sent:]
13.11