短い（そして便利）python snippets
既存の精神 "あなたの最も有用なC/C++スニペットは何か" -スレッド：
あなたは短い、単機能のPython使用するスニペットを（頻繁に）使用していて、StackOverlowコミュニティと共有したいですか？）エントリを小さく（25行以下か）してください。投稿ごとの例。
pythonプロジェクト：
# prints recursive count of lines of python source code from current directory
# includes an ignore_list. also prints total sloc
import os
cur_path = os.getcwd()
ignore_set = set(["__init__.py", "count_sourcelines.py"])
loclist = []
for pydir, _, pyfiles in os.walk(cur_path):
for pyfile in pyfiles:
if pyfile.endswith(".py") and pyfile not in ignore_set:
totalpath = os.path.join(pydir, pyfile)
loclist.append( ( len(open(totalpath, "r").read().splitlines()),
totalpath.split(cur_path)[1]) )
for linenumbercount, filename in loclist:
print "%05d lines in %s" % (linenumbercount, filename)
print "\nTotal: %s lines (%s)" %(sum([x[0] for x in loclist]), cur_path)
2Dリストの初期化
リストを初期化するためにこれを安全に行うことができます：
lst = [0] * 3
同じトリックは2Dリスト（リストのリスト）では機能しません。
>>> lst_2d = [[0] * 3] * 3
>>> lst_2d
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> lst_2d[0][0] = 5
>>> lst_2d
[[5, 0, 0], [5, 0, 0], [5, 0, 0]]
演算子*はそのオペランドを複製し、[]で構成された複製リストは同じリストを指します。これを行う正しい方法は次のとおりです。
>>> lst_2d = [[0] * 3 for i in xrange(3)]
>>> lst_2d
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> lst_2d[0][0] = 5
>>> lst_2d
[[5, 0, 0], [0, 0, 0], [0, 0, 0]]
anyとジェネレータを使用するのが好きです：
if any(pred(x.item) for x in sequence):
...
次のように書かれたコードの代わりに：
found = False
for x in sequence:
if pred(x.n):
found = True
if found:
...
私はこの技術を最初にPeter Norvig article から学びました。
私が知っている唯一の「トリック」は、それが列挙型であることを知ったときに本当に感動しました。これにより、forループ内の要素のインデックスにアクセスできます。
>>> l = ['a','b','c','d','e','f']
>>> for (index,value) in enumerate(l):
... print index, value
...
0 a
1 b
2 c
3 d
4 e
5 f
現在のディレクトリにあるファイル用のシンプルなWebサーバーを起動します。
python -m SimpleHTTPServer
ファイルの共有に役立ちます。
Zip(*iterable)はイテラブルを転置します。
>>> a=[[1,2,3],[4,5,6]]
>>> Zip(*a)
[(1, 4), (2, 5), (3, 6)]
これは、dictsにも役立ちます。
>>> d={"a":1,"b":2,"c":3}
>>> Zip(*d.iteritems())
[('a', 'c', 'b'), (1, 3, 2)]
次のような「進行状況バー」：
|#############################---------------------|
59 percent done
コード：
class ProgressBar():
def __init__(self, width=50):
self.pointer = 0
self.width = width
def __call__(self,x):
# x in percent
self.pointer = int(self.width*(x/100.0))
return "|" + "#"*self.pointer + "-"*(self.width-self.pointer)+\
"|\n %d percent done" % int(x)
テスト機能（Windowsシステムの場合、「クリア」を「CLS」に変更）：
if __== '__main__':
import time, os
pb = ProgressBar()
for i in range(101):
os.system('clear')
print pb(i)
time.sleep(0.1)
次のようなリストのリストをフラット化するには
[['a', 'b'], ['c'], ['d', 'e', 'f']]
に
['a', 'b', 'c', 'd', 'e', 'f']
使用する
[inner
for outer in the_list
for inner in outer]
ネストされたリストと辞書の大幅な高速化：
deepcopy = lambda x: cPickle.loads(cPickle.dumps(x))
アイテムのリストがあり、これらのアイテムをキーとして持つ辞書が必要だとします。 fromkeysを使用：
>>> items = ['a', 'b', 'c', 'd']
>>> idict = dict().fromkeys(items, 0)
>>> idict
{'a': 0, 'c': 0, 'b': 0, 'd': 0}
>>>
Fromkeysの2番目の引数は、新しく作成されたすべてのキーに付与される値です。
行が空かどうか（つまり、サイズ0または空白のみが含まれるかどうか）を調べるには、次のように、条件で文字列メソッドストリップを使用します。
if not line.strip(): # if line is empty
continue # skip it
最新を必要とするリスト内包については、次：
_[fun(curr,next)
for curr,next
in Zip(list,list[1:].append(None))
if condition(curr,next)]
_循環リストZip(list,list[1:].append(list[0]))の場合。
以前は、現在：Zip([None].extend(list[:-1]),list)循環：Zip([list[-1]].extend(list[:-1]),list)
私はこれをディレクトリ内のすべてを圧縮するのが好きです。 instabackupsのホットキー！
import zipfile
z = zipfile.ZipFile('my-archive.Zip', 'w', zipfile.Zip_DEFLATED)
startdir = "/home/johnf"
for dirpath, dirnames, filenames in os.walk(startdir):
for filename in filenames:
z.write(os.path.join(dirpath, filename))
z.close()
現在のディレクトリにある同一のファイルをハードリンクします（UNIXでは、これは物理ストレージを共有することを意味します。つまり、スペースが大幅に少なくなります）。
import os
import hashlib
dupes = {}
for path, dirs, files in os.walk(os.getcwd()):
for file in files:
filename = os.path.join(path, file)
hash = hashlib.sha1(open(filename).read()).hexdigest()
if hash in dupes:
print 'linking "%s" -> "%s"' % (dupes[hash], filename)
os.rename(filename, filename + '.bak')
try:
os.link(dupes[hash], filename)
os.unlink(filename + '.bak')
except:
os.rename(filename + '.bak', filename)
finally:
else:
dupes[hash] = filename
知っておく価値があると思うが、日常的には役に立たないかもしれないものをいくつか紹介します。それらのほとんどはワンライナーです。
リストからの重複の削除
L = list(set(L))
文字列から整数を取得する（スペース区切り）
ints = [int(x) for x in S.split()]
階乗を見つける
fac=lambda(n):reduce(int.__mul__,range(1,n+1),1)
最大の公約数を見つける
>>> def gcd(a,b):
... while(b):a,b=b,a%b
... return a
上記の他の人のように、私は「Wooww !!」と言いました私が発見したときenumerate（）
私はPythonを発見したときに賞賛を歌ったrepr（）正規表現で分析したい文字列の内容を正確に見る可能性を与えてくれた
print '\n'.join(list_of_strings)が'\ n'.join（...）でfor ch in list_of_strings: print chよりもはるかに速く表示されることを発見して、非常に満足しました。splitlines（1）引数を指定すると改行が保持されます
これらの4つの「トリック」を1つのスニペットにまとめると、Webページのコードソースを1行ずつ、各行に番号が付けられ、「\ t」や改行などのすべての特殊文字が解釈されず、改行とともにすばやく表示するのに非常に役立ちます。現在：
import urllib
from time import clock,sleep
sock = urllib.urlopen('http://docs.python.org/')
ch = sock.read()
sock.close()
te = clock()
for i,line in enumerate(ch.splitlines(1)):
print str(i) + ' ' + repr(line)
t1 = clock() - te
print "\n\nIn 3 seconds, I will print the same content, using '\\n'.join(....)\n"
sleep(3)
te = clock()
# here's the point of interest:
print '\n'.join(str(i) + ' ' + repr(line)
for i,line in enumerate(ch.splitlines(1)) )
t2 = clock() - te
print '\n'
print 'first display took',t1,'seconds'
print 'second display took',t2,'seconds'
私のあまり高速ではないコンピュータで、私は得ました：
first display took 4.94626048841 seconds
second display took 0.109297410704 seconds
import tempfile
import cPickle
class DiskFifo:
"""A disk based FIFO which can be iterated, appended and extended in an interleaved way"""
def __init__(self):
self.fd = tempfile.TemporaryFile()
self.wpos = 0
self.rpos = 0
self.pickler = cPickle.Pickler(self.fd)
self.unpickler = cPickle.Unpickler(self.fd)
self.size = 0
def __len__(self):
return self.size
def extend(self, sequence):
map(self.append, sequence)
def append(self, x):
self.fd.seek(self.wpos)
self.pickler.clear_memo()
self.pickler.dump(x)
self.wpos = self.fd.tell()
self.size = self.size + 1
def next(self):
try:
self.fd.seek(self.rpos)
x = self.unpickler.load()
self.rpos = self.fd.tell()
return x
except EOFError:
raise StopIteration
def __iter__(self):
self.rpos = 0
return self
Switchステートメントをエミュレートします。たとえば、switch（x）{..}：
def a():
print "a"
def b():
print "b"
def default():
print "default"
apply({1:a, 2:b}.get(x, default))
実際に作成したばかりですが、非常に便利なデバッグツールになると思います。
def dirValues(instance, all=False):
retVal = {}
for prop in dir(instance):
if not all and prop[1] == "_":
continue
retVal[prop] = getattr(instance, prop)
return retVal
私は通常、pdbコンテキストでdir（）を使用しますが、これははるかに便利だと思います。
(pdb) from pprint import pprint as pp
(pdb) from myUtils import dirValues
(pdb) pp(dirValues(someInstance))
他のリストを乗算するとデカルト積が返されるカスタムリスト...デカルト積はitertools.productのようにではなくインデックス可能であること（ただし、被乗数はイテレータではなくシーケンスである必要があります）。
import operator
class mylist(list):
def __getitem__(self, args):
if type(args) is Tuple:
return [list.__getitem__(self, i) for i in args]
else:
return list.__getitem__(self, args)
def __mul__(self, args):
seqattrs = ("__getitem__", "__iter__", "__len__")
if all(hasattr(args, i) for i in seqattrs):
return cartesian_product(self, args)
else:
return list.__mul__(self, args)
def __imul__(self, args):
return __mul__(self, args)
def __rmul__(self, args):
return __mul__(args, self)
def __pow__(self, n):
return cartesian_product(*((self,)*n))
def __rpow__(self, n):
return cartesian_product(*((self,)*n))
class cartesian_product:
def __init__(self, *args):
self.elements = args
def __len__(self):
return reduce(operator.mul, map(len, self.elements))
def __getitem__(self, n):
return [e[i] for e, i in Zip(self.elements,self.get_indices(n))]
def get_indices(self, n):
sizes = map(len, self.elements)
tmp = [0]*len(sizes)
i = -1
for w in reversed(sizes):
tmp[i] = n % w
n /= w
i -= 1
return tmp
def __add__(self, arg):
return mylist(map(None, self)+mylist(map(None, arg)))
def __imul__(self, args):
return mylist(self)*mylist(args)
def __rmul__(self, args):
return mylist(args)*mylist(self)
def __mul__(self, args):
if isinstance(args, cartesian_product):
return cartesian_product(*(self.elements+args.elements))
else:
return cartesian_product(*(self.elements+(args,)))
def __iter__(self):
for i in xrange(len(self)):
yield self[i]
def __str__(self):
return "[" + ",".join(str(i) for i in self) +"]"
def __repr__(self):
return "*".join(map(repr, self.elements))
Python 2.4+以前の場合：
for x,y in someIterator:
listDict.setdefault(x,[]).append(y)
Python 2.5+には defaultdict を使用する代替方法があります。
任意のサイズ（不明なサイズを含む）の反復可能要素（リスト、セット、ファイル、ストリーム、文字列など）をx要素のチャンクで反復します。
from itertools import chain, islice
def chunks(iterable, size, format=iter):
it = iter(iterable)
while True:
yield format(chain((it.next(),), islice(it, size - 1)))
>>> l = ["a", "b", "c", "d", "e", "f", "g"]
>>> for chunk in chunks(l, 3, Tuple):
... print chunk
...
("a", "b", "c")
("d", "e", "f")
("g",)
デバッグ時に、基本的なエディターで文字列を表示したい場合があります。文字列をメモ帳で表示するには：
import os, tempfile, subprocess
def get_Rand_filename(dir_=os.getcwd()):
"Function returns a non-existent random filename."
return tempfile.mkstemp('.tmp', '', dir_)[1]
def open_with_notepad(s):
"Function gets a string and shows it on notepad"
with open(get_Rand_filename(), 'w') as f:
f.write(s)
subprocess.Popen(['notepad', f.name])