for i in range(3):
  print i

class C(object):

    def __init__(self):
        self.__x = 0

    def getx(self):
        return self.__x

    def setx(self, x):
        if x < 0: x = 0
        self.__x = x

    x = property(getx, setx)

dict = { 'key' : 'value' }
if dict.has_key('key')

print 'abc' * 4   # abcabcabcabc

print u'The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred', other='Georg')

"First, thou shalt count to {0}"              # References first positional argument
"My quest is {name}"                          # References keyword argument 'name'
"Weight in tons {0.weight}"                   # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"               # First element of keyword argument 'players'.
"Harold's a clever {0!s}"                     # Calls str() on the argument first
"Bring out the holy {name!r}"                 # Calls repr() on the argument first
"A man with two {0:{1}}".format("noses", 10)  # 用参数{1}指定{0}的宽度
"hex number 0x{0:x}".format(123456)           # 以十六进制输出

import array
s = array.array('B', list_or_tuple)

bytearray.fromhex('00 01 0203')

obj = globals()["类名"]()

# 2.7 and newer
with self.assertRaises(SomeException):
    do_something()

# 2.7 and newer
with self.assertRaises(SomeException) as cm:
    do_something()

the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

self.assertRaises(SomeException, func, *args, **kwds)

import os
path = os.path.join(os.environ['HOME'], '.abook', 'rc')

import os
(root, ext) = os.path.splitext("path/to/file.ext")

import glob
files = glob.glob('dir/*.sh')
iterator = glob.iglob('dir/*.sh')

import fnmatch
import os

matches = []
for root, dirnames, filenames in os.walk('src'):
  for filename in fnmatch.filter(filenames, '*.c'):
    matches.append(os.path.join(root, filename))

import os
import fnmatch

path = 'C:/Users/sam/Desktop/file1'

configfiles = [os.path.join(dirpath, f)
    for dirpath, dirnames, files in os.walk(path)
    for f in fnmatch.filter(files, '*.txt')]

import os
import shutil
import tempfile

class TemporaryDirectory(object):
    '''
    A temporary directory to be used in a with statement.
    '''
    def __init__(self, suffix='', prefix='', dir=None, keep=False):
        self.suffix = suffix
        self.prefix = prefix
        self.dir = dir
        self.keep = keep

    def __enter__(self):
        self.tdir = tempfile.mkdtemp(self.suffix, self.prefix, self.dir)
        return self.tdir

    def __exit__(self, *args):
        if not self.keep and os.path.exists(self.tdir):
            shutil.rmtree(self.tdir, ignore_errors=True)

class TemporaryFile(object):
    def __init__(self, suffix="", prefix="", dir=None, mode='w+b'):
        if prefix == None:
            prefix = ''
        if suffix is None:
            suffix = ''
        self.prefix, self.suffix, self.dir, self.mode = prefix, suffix, dir, mode
        self._file = None

    def __enter__(self):
        fd, name = tempfile.mkstemp(self.suffix, self.prefix, dir=self.dir)
        self._file = os.fdopen(fd, self.mode)
        self._name = name
        self._file.close()
        return name

    def __exit__(self, *args):
        try:
            if os.path.exists(self._name):
                os.remove(self._name)
        except:
            pass

with TemporaryDirectory('_zipfile_replace') as tdir:
  z.extractall(path=tdir)

with TemporaryFile('_pdf_set_metadata.pdf') as f:
    p.save(f)
    raw = open(f, 'rb').read()
    stream.seek(0)

m = re.compile("^\s*(\S+)\s*=\s*(.*)$").match(line)
if not m or not in_block:
    return []       # not a valid abook datafile

if not in_format_block:
    addr.append(AddressItem(m.group(1), m.group(2)))

from xml.dom import minidom

# New document
xml = minidom.Document()

# Creates user element
userElem = xml.createElement("user")

# Set attributes to user element
userElem.setAttribute("name", "Sergio Oliveira")
userElem.setAttribute("nickname", "seocam")
userElem.setAttribute("email", "[email protected]")
userElem.setAttribute("photo","seocam.png")

# Append user element in xml document
xml.appendChild(userElem)

# Print the xml codeprint xml.toxml("UTF-8")
fp = open("file.xml","w")
xml.writexml(fp, "    ", "", "\n", "UTF-8")

# Method's stub
# writexml(self, writer, indent='', addindent='', newl='', encoding=None)

from lxml import etree, cssselect
select = cssselect.CSSSelector("a tag > child")
root = etree.XML("<a><b><c/><tag><child>TEXT</child></tag></b></a>")
[ el.tag for el in select(root) ]

from lxml import etree
broken_html = "<html><head><title>test<body><h1>page title</h3>"
html = etree.HTML(broken_html)
result = etree.tostring(html, pretty_print=True, method="html")
print(result)

from BeautifulSoup import BeautifulSoup
import re

doc = ['<html><head><title>Page title</title></head>',
       '<body><p id="firstpara" align="center">This is paragraph <b>one</b>.',
       '<p id="secondpara" align="blah">This is paragraph <b>two</b>.',
       '</html>']
soup = BeautifulSoup(''.join(doc))

print soup.prettify()

# File: zipfile-example-1.py

import zipfile

file = zipfile.ZipFile("samples/sample.zip", "r")

# list filenames
for name in file.namelist():
    print name,
print

# list file information
for info in file.infolist():
    print info.filename, info.date_time, info.file_size

# File: zipfile-example-2.py

import zipfile

file = zipfile.ZipFile("samples/sample.zip", "r")

for name in file.namelist():
    data = file.read(name)
    print name, len(data), repr(data[:10])

# File: zipfile-example-3.py

import zipfile
import glob, os

# open the zip file for writing, and write stuff to it

file = zipfile.ZipFile("test.zip", "w")

for name in glob.glob("samples/*"):
    file.write(name, os.path.basename(name), zipfile.ZIP_DEFLATED)

file.close()

# open the file again, to see what's in it

file = zipfile.ZipFile("test.zip", "r")
for info in file.infolist():
    print info.filename, info.date_time, info.file_size, info.compress_size

# File: zipfile-example-4.py

import zipfile
import glob, os, time

file = zipfile.ZipFile("test.zip", "w")

now = time.localtime(time.time())[:6]

for name in ("life", "of", "brian"):
    info = zipfile.ZipInfo(name)
    info.date_time = now
    info.external_attr = 0777 << 16L # give full access to included file
    info.compress_type = zipfile.ZIP_DEFLATED
    file.writestr(info, name*1000)

file.close()

# open the file again, to see what's in it

file = zipfile.ZipFile("test.zip", "r")

for info in file.infolist():
    print info.filename, info.date_time, info.file_size, info.compress_size

newEpub = ZipFile(tfile, 'w')
newEpub.writestr('mimetype', 'application/epub+zip', compression=ZIP_STORED)
newEpub.writestr('META-INF/', '', 0700)
newEpub.writestr('META-INF/container.xml', CONTAINER)

import copy

x = copy.copy(y)        # make a shallow copy of y
x = copy.deepcopy(y)    # make a deep copy of y

import subprocess

# Simple command
subprocess.call('ls -l', shell=True)

# Command with shell expansion
subprocess.call('ls -l $HOME', shell=True)

print '\nread:'
proc = subprocess.Popen('echo "to stdout"',
                        shell=True,
                        stdout=subprocess.PIPE,
                        )
stdout_value = proc.communicate()[0]
print '\tstdout:', repr(stdout_value)

subprocess.check_output(["echo", "Hello World!"])
# 'Hello World!\n'

subprocess.check_output("exit 1", shell=True)
# Traceback (most recent call last):
#.Writing to the input of a pipe:

print '\nwrite:'
proc = subprocess.Popen('cat -',
                        shell=True,
                        stdin=subprocess.PIPE,
                        )
proc.communicate('\tstdin: to stdin\n')

print '\npopen2:'

proc = subprocess.Popen('cat -',
                        shell=True,
                        stdin=subprocess.PIPE,
                        stdout=subprocess.PIPE,
                        )
stdout_value = proc.communicate('through stdin to stdout')[0]
print '\tpass through:', repr(stdout_value)

from subprocess import Popen, PIPE
import errno

p = Popen('less', stdin=PIPE)
for x in xrange(100):
    line = 'Line number %d.\n' % x
    try:
        p.stdin.write(line)
    except IOError as e:
        if e.errno == errno.EPIPE or e.errno == errno.EINVAL:
            # Stop loop on "Invalid pipe" or "Invalid argument".
            # No sense in continuing with broken pipe.
            break
        else:
            # Raise any other error.
            raise

p.stdin.close()
p.wait()

print 'All done!' # This should always be printed below any output written to less.

#!/usr/bin/python
import sys
import locale
import codecs
try:
    from pychm import chmlib
except:
    from chm import chmlib

def getfilelist(chmpath):
    '''
    get filelist of the given path chm file
    return (bool,fileurllist)
    '''
    def callback(cf,ui,lst):
        '''
        innermethod
        '''
        lst.append(ui.path)
        return chmlib.CHM_ENUMERATOR_CONTINUE

    assert isinstance(chmpath,unicode)
    chmfile=chmlib.chm_open(chmpath.encode(sys.getfilesystemencoding()))
    lst=[]
    ok=chmlib.chm_enumerate(chmfile,chmlib.CHM_ENUMERATE_ALL,callback,lst)
    chmlib.chm_close(chmfile)
    return (ok,lst)

if __name__ == "__main__":
    sys.stdout = codecs.getwriter(locale.getpreferredencoding())(sys.stdout)
    sys.stderr = codecs.getwriter(locale.getpreferredencoding())(sys.stderr)

    (ok, lst) = getfilelist(unicode(sys.argv[1], locale.getpreferredencoding()))
    print lst

#!/usr/bin/python
try:
    from pychm import chmlib
except:
    from chm import chmlib

def getfiles(chmpath):
    def callback(cf,ui,lst):
        lst.append(ui.path)
        return chmlib.CHM_ENUMERATOR_CONTINUE

    assert isinstance(chmpath,unicode)
    chmfile=chmlib.chm_open(chmpath.encode(sys.getfilesystemencoding()))
    lst=[]
    ok=chmlib.chm_enumerate(chmfile,chmlib.CHM_ENUMERATE_ALL,callback,lst)

    if ok:
        files = {}
        for l in lst:
            result, ui = chmlib.chm_resolve_object(chmfile, l)
            if (result != chmlib.CHM_RESOLVE_SUCCESS):
                print u"Failed to resolve {0}".format(l)
                continue

            size, text = chmlib.chm_retrieve_object(chmfile, ui, 0L, ui.length)
            if (size == 0):
                print u"Failed to retrieve {0}".format(l)
                continue

            files[l] = text

    chmlib.chm_close(chmfile)
    return files

email.Header.decode_header(mail['subject'])

import sys,email,re
for line in sys.stdin:
    m = re.match('^Subject:\s*(.+)$', line)
    if m:
        for str,encoding in email.Header.decode_header(m.group(1)):
            print str.decode(encoding) if encoding else str

import urllib
from chardet.universaldetector import UniversalDetector

usock = urllib.urlopen('http://yahoo.co.jp/')
detector = UniversalDetector()
for line in usock.readlines():
    detector.feed(line)
    if detector.done: break
detector.close()
usock.close()
print detector.result

import glob
from chardet.universaldetector import UniversalDetector

detector = UniversalDetector()
for filename in glob.glob('*.xml'):
    print filename.ljust(60),
    detector.reset()
    for line in file(filename, 'rb'):
        detector.feed(line)
        if detector.done: break
    detector.close()
    print detector.result

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

import requests
import logging

# Enabling debugging at http.client level (requests->urllib3->http.client)
# you will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.
# the only thing missing will be the response.body which is not logged.
try: # for Python 3
    from http.client import HTTPConnection
except ImportError:
    from httplib import HTTPConnection
HTTPConnection.debuglevel = 1

logging.basicConfig() # you need to initialize logging, otherwise you will not see anything from requests
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True

requests.get('http://httpbin.org/headers')

# Scan the web looking for references

import re
import urllib

regex = re.compile(r'href="([^"]+)"')

def matcher(url, max=10):
    "Print the first several URL references in a given url."
    data = urllib.urlopen(url).read()
    hits = regex.findall(data)
    for hit in hits[:max]:
        print urllib.basejoin(url, hit)

matcher("http://python.org")

import pure_pcapy as pcapy
from impacket.ImpactPacket import TCP
from impacket.ImpactDecoder import EthDecoder
import struct

cap = pcapy.open_offline(u'test.pcap')

(header, payload) = cap.next()

orders = list()
reports = list()

while header:
    eth = EthDecoder().decode(payload)
    ip = eth.child()

    if ip.get_ip_p() != TCP.protocol:
        continue

    sec, us = header.getts()
    packet_time = pd.to_datetime(sec * 1000000000 + us * 1000) + pd.Timedelta(hours=8)

    tcp = ip.child()

    data = tcp.get_data_as_string()
    packet_no, body_len = struct.unpack(MSG_HEADER_FMT, data[:MSG_HEADER_SIZE])

    ...

    (header, payload) = cap.next()

import optparse

parser = optparse.OptionParser()
parser.add_option('-a', action="store_true", default=False)
parser.add_option('-b', action="store", dest="b")
parser.add_option('-c', action="store", dest="c", type="int")

print parser.parse_args(['-a', '-bval', '-c', '3'])

import optparse

parser = optparse.OptionParser()
parser.add_option('--noarg', action="store_true", default=False)
parser.add_option('--witharg', action="store", dest="witharg")
parser.add_option('--witharg2', action="store", dest="witharg2", type="int")

print parser.parse_args([ '--noarg', '--witharg', 'val', '--witharg2=3' ])

import optparse

parser = optparse.OptionParser()
parser.add_option('-v', '--verbose', action="count", dest="verbose", default=0)

options, remainder = parser.parse_args(['-v', '--verbose', '-v'])
print options.verbose

import time
from yaspin import yaspin

# Context manager:
with yaspin():
    time.sleep(3)  # time consuming code

# Function decorator:
@yaspin(text="Loading...")
def some_operations():
    time.sleep(3)  # time consuming code

from ghost import Ghost
ghost = Ghost()

self.ghost.click('#prompt-button')
# Opens the web page
ghost.open('http://www.openstreetmap.org/')
# Waits for form search field
ghost.wait_for_selector('input[name=query]')
# Fills the form
ghost.fill("#search_form", {'query': 'France'})
# Submits the form
ghost.call("#search_form", "submit")
# Waits for results (an XHR has been called here)
ghost.wait_for_selector(
    '#search_osm_nominatim .search_results_entry a')
# Clicks first result link
ghost.click(
    '#search_osm_nominatim .search_results_entry:first-child a')
# Checks if map has moved to expected latitude
lat, resources = ghost.evaluate("map.center.lat")
assert float(lat.toString()) == 5860090.806537

# 保留原索引
pandas.concat([df1, df2])
# 重新编索引
pandas.concat([df1, df2], ignore_index=True)

df['bar'] = df.bar.map(str) + " is " + df.foo

df.reset_index()

indexed_df = df.set_index(['A', 'B'])
indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])
indexed_df3 = df.set_index([[0, 1, 2, 0, 1, 2]])

pd.options.display.float_format = '${:,.2f}'.format

df.loc[5]   # 5只作为label，不作为position
df.loc['a']
df.loc['a', 'b', 'c']
df.loc['a':'c']
df.loc[boolean数组]

df.iloc[5]   # 5是从0开始的position
df.iloc[1, 3, 5]
df.iloc[2:4]
df.iloc[boolean数组]

df1 = df.ix[:,0:2]

pd.MultiIndex.from_arrays
pd.MultiIndex.from_tuples
pd.MultiIndex.from_product

pv_state.index.names = [None, None]

df.index = df.index.droplevel(2)

df.reorder_level([1, 0], axis=1)
df.sort_index()

A.merge(B, left_on='lkey', right_on='rkey', how='outer')

df.groupby(u'地区').size()

df.groupby('OpenTime')['KnockIndex'].apply(lambda x: np.round(x * 100 / x.size))

# Create an example dataframe
data = {'name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
        'year': [2012, 2012, 2013, 2014, 2014],
        'reports': [4, 24, 31, 2, 3]}

#List unique values in the df['name'] column
pd.unique(df.name.ravel())

pd.isin()
df['col1'].isin(set)

all['地区'] = np.where(all['Location']=='1',u'托管机房',all[u'地区'])

df[df.columns[::-1]].cumsum(axis=1)[df.columns]

pd.to_datetime(orders.TransacTime, format='%Y%m%d%H%M%S%f')
pd.to_datetime(1489541395312290, unit='us')
pd.to_datetime(1489541395312290*1000)
pd.to_datetime(1489541395312290*1000).tz_localize(tzlocal.get_localzone())

pd.to_datetime(orders.TransacTime, format='%Y%m%d%H%M%S%f')

td.astype('timedelta64[s]')
td.astype('timedelta64[ms]')
td.astype('timedelta64[us]')

all['OpenTime'] = all['OpenTime'].map(pd.datetime.time)

all['datetime'] = all['time'].apply(
    lambda t: pd.datetime.combine(datetime.date.today(), t)
    )

all['OpenTime'].dt.time

all['OpenTime'].dt.round('3s')

import pandas as pd

TIME_ZONE = 'Asia/Shanghai'
tracked['start'] = pd.to_datetime(tracked['start']).dt.tz_localize('UTC').dt.tz_convert(TIME_ZONE)

import pandas as pd
import tzlocal

# 把时间转换为UTC，但去掉时区信息 tz_convert(None)
line_time = pd.to_datetime(m.group('datetime')).tz_localize(
    tzlocal.get_localzone()).tz_convert(None)

if dt.tzinfo:
    # timezone aware
else:

now = pd.Timestamp.utcnow()

import tzlocal

tzlocal.get_localzone()

df["Status"] = df["Status"].astype("category")
df["Status"].cat.set_categories(["won","pending","presented","declined"],inplace=True)

all['KnockState'] = all['KnockState'].astype('category')
all['KnockState'].cat.set_categories(
    pd.unique(
        ['rejected','succeed','retry'] + all['KnockState'].ravel().tolist()),
    inplace=True, ordered=True)

pd.pivot_table(df,index=["Manager","Rep"],values=["Price"],
               columns=["Product"],aggfunc=[np.sum],fill_value=0)

pd.pivot_table(df,index=["Manager","Rep","Product"],
               values=["Price","Quantity"],
               aggfunc=[np.sum,np.mean],fill_value=0,margins=True)

df.pivot_table(columns='a', aggfunc=lambda x: np.percentile(x, 50))

import pandas as pd
import numpy as np

np.random.seed(0)
a = np.random.randint(1, 4, 100)
b = np.random.randint(1, 4, 100)
df = pd.DataFrame(dict(A=a,B=b,Val=np.random.randint(1,100,100)))
table = pd.pivot_table(df, index='A', columns='B', values='Val', aggfunc=sum, fill_value=0, margins=True)
print(table)

multi_level_column = pd.MultiIndex.from_arrays([['A', 'A', 'A', 'All_B'], [1,2,3,'']])
multi_level_index = pd.MultiIndex.from_arrays([['B', 'B', 'B', 'All_A'], [1,2,3,'']])
table.index = multi_level_index
table.columns = multi_level_column
print(table)

# 所有敲门委托距离平台开放时间的分布图
fig = plt.figure(figsize=FIG_SIZE, dpi=FIG_DPI)
time_diff_bins = np.unique(all['TimeDiff'].ravel())

succeed_knocks = all[(all['KnockState']=='succeed') & (all['GatewayIndex']==1)]
failed_knocks = all[(all['KnockState']=='rejected') & (all['GatewayIndex']==1)]

ax = succeed_knocks['TimeDiff'].hist(bins=time_diff_bins)
failed_knocks['TimeDiff'].hist(bins=time_diff_bins, ax=ax)

bin_width = time_diff_bins[1] - time_diff_bins[0]

# 对最大的几个值进行标注
for x, y in pd.concat([failed_knocks, succeed_knocks])['TimeDiff'].value_counts().sort_values(ascending=False).head().iteritems():
    ax.annotate(
        str(y), xy=(x + bin_width / 2, y), xycoords='data', va='bottom', ha='center')

fig.savefig('knock_time_diff.png')

for area, df in knocks.groupby(u'地区'):
    ax.plot(df['GatewayNum'], df['KnockPercent'], marker='.', linestyle='', label=area)

import pandas as pd
import numpy as np

N = 100
df = pd.DataFrame(
    {'date': pd.date_range('2000-1-1', periods=N, freq='H'),
     'value': np.random.random(N)})

index = pd.DatetimeIndex(df['date'])
df.iloc[index.indexer_between_time('8:00','21:00')]

import numpy as np
import quaternion

from mako.template import Template

mytemplate = Template(filename='/docs/mytmpl.txt', module_directory='/tmp/mako_modules')
print mytemplate.render()

from mako.template import Template
from mako.lookup import TemplateLookup

mylookup = TemplateLookup(directories=['/docs'], output_encoding='utf-8', encoding_errors='replace')

mytemplate = mylookup.get_template("foo.txt")
print mytemplate.render()

from mako import exceptions

try:
    template = lookup.get_template(uri)
    print template.render()
except:
    print exceptions.text_error_template().render()

isinstance("abc", str)

print obj.__class__.__name__

encoding = locale.getpreferredencoding()

import sys
import codecs
import locale
sys.stdout = codecs.getwriter(locale.getpreferredencoding())(sys.stdout);

def string_width(text):
    """
    text必须是unicode
    """
    import unicodedata
    s = 0
    for ch in text:
        if isinstance(ch, unicode):
            if unicodedata.east_asian_width(ch) in ('F', 'W', 'A'):
                s += 2
            else:
                s += 1
        else:
            s += 1
    return s

def urldecode(url):
    rex = re.compile('%([0-9a-hA-H][0-9a-hA-H])',re.M)
    return rex.sub(lambda m: chr(int(m.group(1),16)), url.encode("utf-8")).decode("utf-8")

import getopt
import locale

if __name__ == "__main__":
    sys.stdout = codecs.getwriter(locale.getpreferredencoding())(sys.stdout)
    sys.stderr = codecs.getwriter(locale.getpreferredencoding())(sys.stderr)

    try:
        opts, args = getopt.getopt(sys.argv[1:], u"t:a:vs", [u"title=", u"author=", u"verbose", u"silent"])
    except getopt.GetoptError:
        sys.stderr.write(usage())
        sys.exit(1)

    args = [unicode(arg, DEFAULT_ENCODING) for arg in args]
    opts = [(unicode(opt[0], DEFAULT_ENCODING), unicode(opt[1], DEFAULT_ENCODING)) for opt in opts]

    title   = ''
    author  = ''

    for opt, arg in opts:
        if opt in ('-t', '--title'):
            title = arg
        elif opt in ('-a', '--author'):
            author = arg
        elif opt in ('-v', '--verbose'):
            verbose = True
        elif opt in ('-s', '--silent'):
            silent = True

    if len(args) < 1:
        sys.stderr.write(usage())
        sys.exit(2)

import locale
import logging
import argparse

if __name__ == "__main__":
    sys.stdin  = codecs.getreader(locale.getpreferredencoding())(sys.stdin)
    sys.stdout = codecs.getwriter(locale.getpreferredencoding())(sys.stdout)
    sys.stderr = codecs.getwriter(locale.getpreferredencoding())(sys.stderr)

    parser = optparse.ArgumentParser(
        description="""\
    Convert chm books into epub format.""",
        version=VERSION)

    parser.add_argument('chm_file', action="store", help="CHM filename")
    parser.add_argument('-t', '--title',   action="store", type=string, dest="title", help="Book title. If omit, guest from filename")
    parser.add_argument('-a', '--author',  action="store", type=string, dest="author", help="Book author. If omit, guest from filename")
    parser.add_argument('-v', '--verbose', action="store_false", dest="verbose", help="Be moderatery verbose")
    parser.add_argument('-s', '--silent',  action="store_false", dest="silent", help="Only show warning and errors")

    args = parser.parse_args()

    for k in vars(args):
        if isinstance(getattr(args, k), str):
            setattr(args, k, unicode(getattr(args, k), locale.getpreferredencoding()).strip())

    if args.silent:
        logging.basicConfig(level=logging.WARNING)
    elif args.verbose:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.debug)

    bookinfo = read_index(args.chm_file)

    if args.title:
        bookinfo.title = args.title

    if args.author:
        bookinfo.author = args.author

str = raw_input("prompt")

class flushfile(file):
  def __init__(self, f):
    self.f = f
  def write(self, x)
    self.f.write(x)
    self.f.flush()

import sys
sys.stdout = flushfile(sys.stdout)

def toRSTtable(self,rows, header=True, vdelim="  ", padding=1, justify='right'):
    """ Outputs a list of lists as a Restructured Text Table

    - rows - list of lists
    - header - if True the first row is treated as a table header
    - vdelim - vertical delimiter betwee columns
    - padding - padding nr. of spaces are left around the longest element in the
      column
    - justify - may be left,center,right
    """
    border="=" # character for drawing the border
    justify = {'left':string.ljust,'center':string.center, 'right':string.rjust}[justify.lower()]

    # calculate column widhts (longest item in each col
    # plus "padding" nr of spaces on both sides)
    cols = zip(*rows)
    colWidths = [max([len(str(item))+2*padding for item in col]) for col in cols]

    # the horizontal border needed by rst
    borderline = vdelim.join([w*border for w in colWidths])

    # outputs table in rst format
    print borderline
    for row in rows:
        print vdelim.join([justify(str(item),width) for (item,width) in zip(row,colWidths)])
        if header: print borderline; header=False
    print borderline

print self.__class__.__name__

import re

##
# Removes HTML markup from a text string.
#
# @param text The HTML source.
# @return The plain text.  If the HTML source contains non-ASCII
#     entities or character references, this is a Unicode string.

def strip_html(text):
    def fixup(m):
        text = m.group(0)
        if text[:1] == "<":
            return "" # ignore tags
        if text[:2] == "&#":
            try:
                if text[:3] == "&#x":
                    return unichr(int(text[3:-1], 16))
                else:
                    return unichr(int(text[2:-1]))
            except ValueError:
                pass
        elif text[:1] == "&":
            import htmlentitydefs
            entity = htmlentitydefs.entitydefs.get(text[1:-1])
            if entity:
                if entity[:2] == "&#":
                    try:
                        return unichr(int(entity[2:-1]))
                    except ValueError:
                        pass
                else:
                    return unicode(entity, "iso-8859-1")
        return text # leave as is
    return re.sub("(?s)<[^>]*>|&#?\w+;", fixup, text)

import re, htmlentitydefs

##
# Removes HTML or XML character references and entities from a text string.
#
# @param text The HTML (or XML) source text.
# @return The plain text, as a Unicode string, if necessary.

def unescape(text):
    def fixup(m):
        text = m.group(0)
        if text[:2] == "&#":
            # character reference
            try:
                if text[:3] == "&#x":
                    return unichr(int(text[3:-1], 16))
                else:
                    return unichr(int(text[2:-1]))
            except ValueError:
                pass
        else:
            # named entity
            try:
                text = unichr(htmlentitydefs.name2codepoint[text[1:-1]])
            except KeyError:
                pass
        return text # leave as is
    return re.sub("&#?\w+;", fixup, text)

import time
import datetime

def string_to_time(strtime):
    t_tuple = time.strptime(strtime,"%Y-%m-%d %H:%M:%S")
    return time.mktime(t_tuple)

def string_to_time2(strtime):
    dt = datetime.datetime.strptime(strtime,"%Y-%m-%d %H:%M:%S")
    t_tuple = dt.timetuple()
    return time.mktime(t_tuple)

def time_to_string(timestamp):
    t_tuple = time.localtime(timestamp)
    dt = datetime.datetime(*t_tuple[:6])
    return dt.strftime("%Y-%m-%d %H:%M:%S")

def get_yesterday():
    d = datetime.datetime(*time.localtime()[:6])
    t = datetime.timedelta(days=1)
    return  (d-t)

time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

import os
print os.getpid()

import thread
print thread.get_ident()

import inspect

def lineno():
    """Returns the current line number in our program."""
    return inspect.currentframe().f_back.f_lineno

#生成一个Population
pop = [chr(i) for i in xrange(33, 126 + 1)]

#sample随机选取，然后再Join
print "".join(random.sample(pop, 64))

import itertools
a = [1,2,3,4,5]
b = [1,2,3]
print zip(a, itertools.cycle(b))

import collections

def dict_merge(dct, *merge_dcts):
    """ Recursive dict merge. Inspired by :meth:``dict.update()``, instead of
    updating only top-level keys, dict_merge recurses down into dicts nested
    to an arbitrary depth, updating keys. The ``merge_dct`` is merged into
    ``dct``.
    :param dct: dict onto which the merge is executed
    :param merge_dcts: dicts merged into dct
    :return: dct
    """
    for merge_dict in merge_dcts:
        for k, v in merge_dct.iteritems():
            if (k in dct and isinstance(dct[k], dict)
                    and isinstance(merge_dct[k], collections.Mapping)):
                dict_merge(dct[k], merge_dct[k])
            else:
                dct[k] = merge_dct[k]

    return dct

def add_thousands_sep(num):
    """把数字转换为带千位分隔符的字符串

    Args:
        num: 要转换的数字。如果是小数，则只为整数部分加上千位分隔符

    Returns:
        字符串，转换结果
    """
    parts = str(num).split('.')
    s = parts[0][::-1] # 反转
    parts[0] = ",".join([s[i:i+3] for i in range(0,len(s),3)])   # 每三个数字加一个逗号
    parts[0] = parts[0][::-1] # 再反转为正常顺序

    return ".".join(parts)

from collections import OrderedDict
items = [1, 2, 0, 1, 3, 2]
list(OrderedDict.fromkeys(items))

seen = set()
[x for x in seq if x not in seen and not seen.add(x)]

i = int(s)
f = float(s)

from distutils.util import strtobool

import operator
mytable = (
    ('Joe', 'Clark', '1989'),
    ('Charlie', 'Babbitt', '1988'),
    ('Frank', 'Abagnale', '2002'),
    ('Bill', 'Clark', '2009'),
    ('Alan', 'Clark', '1804'),
    )
# itemgetter取出指定的列
table = sorted(table, key=operator.itemgetter(2,1))

import collections
isinstance(val, collections.Sequence)

try:
    Work()

except KeyboardInterrupt:
    # here you put any code you want to run before the program
    # exits when you press CTRL+C
    print "\n", counter # print value of counter

except:
    # this catches ALL other exceptions including errors.
    # You won't get any error messages for debugging
    # so only use it once your code is working
    print "Other error or exception occurred!"

finally:
    CleanUp()

import os
import sys

sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'lib')))

import some_util

import socket,struct

def ip_in_network(ip,net):
   "Is an address in a network"
   ipaddr = struct.unpack('L',socket.inet_aton(ip))[0]
   netaddr,bits = net.split('/')
   netmask = struct.unpack('L',socket.inet_aton(netaddr))[0] & ((2L<<int(bits)-1) - 1)
   return ipaddr & netmask == netmask

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k, v in s:
    d[k].append(v)
# d.items()
# [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

def group(a, *ns):
  for n in ns:
    a = [a[i:i+n] for i in range(0, len(a), n)]
  return a

def join(a, *cs):
  return [cs[0].join(join(t, *cs[1:])) for t in a] if cs else a

def hexdump(data):
  toHex = lambda c: '{:02X}'.format(c)
  toChr = lambda c: chr(c) if 32 <= c < 127 else '.'
  make = lambda f, *cs: join(group(list(map(f, data)), 8, 2), *cs)
  hs = make(toHex, '  ', ' ')
  cs = make(toChr, ' ', '')
  for i, (h, c) in enumerate(zip(hs, cs)):
    print ('{:010X}: {:48}  {:16}'.format(i * 16, h, c))


with (open ('tohex.py','br')) as file:
  data=file.read()
  hexdump(data)

def onerror(func, path, exc_info):
    """
    Error handler for ``shutil.rmtree``.

    If the error is due to an access error (read only file)
    it attempts to add write permission and then retries.

    If the error is for another reason it re-raises the error.

    Usage : ``shutil.rmtree(path, onerror=onerror)``
    """
    import stat
    if not os.access(path, os.W_OK):
        # Is the error an access error ?
        os.chmod(path, stat.S_IWUSR)
        func(path)
    else:
        raise

csv = ![command]

try:
   from io import StringIO
except ImportError:
   from StringIO import StringIO

df = pandas.read_csv(StringIO(csv.n))