#_*_coding:utf-8_*_

 __author__ = 'Alex Li'

 import time

 # print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来

 # print(time.altzone)  #返回与utc时间的时间差,以秒计算\

 # print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",

 # print(time.localtime()) #返回本地时间 的struct time对象格式

 # print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式

 # print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",

 #print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上

 # 日期字符串 转成  时间戳

 # string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式

 # print(string_2_struct)

 # #

 # struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳

 # print(struct_2_stamp)

 #将时间戳转为字符串格式

 # print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式

 # print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式

 #时间加减

 import datetime

 # print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925

 #print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19

 # print(datetime.datetime.now() )

 # print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天

 # print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天

 # print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时

 # print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

 #

 # c_time  = datetime.datetime.now()

 # print(c_time.replace(minute=3,hour=2)) #时间替换

 def copyfileobj(fsrc, fdst, length=16*1024):

     """copy data from file-like object fsrc to file-like object fdst"""

     while 1:

         buf = fsrc.read(length)

         if not buf:

             break

         fdst.write(buf)

 def copyfile(src, dst):

     """Copy data from src to dst"""

     if _samefile(src, dst):

         raise Error("`%s` and `%s` are the same file" % (src, dst))

     for fn in [src, dst]:

         try:

             st = os.stat(fn)

         except OSError:

             # File most likely does not exist

             pass

         else:

             # XXX What about other special files? (sockets, devices...)

             if stat.S_ISFIFO(st.st_mode):

                 raise SpecialFileError("`%s` is a named pipe" % fn)

     with open(src, 'rb') as fsrc:

         with open(dst, 'wb') as fdst:

             copyfileobj(fsrc, fdst)

 def copymode(src, dst):

     """Copy mode bits from src to dst"""

     if hasattr(os, 'chmod'):

         st = os.stat(src)

         mode = stat.S_IMODE(st.st_mode)

         os.chmod(dst, mode)

 def copystat(src, dst):

     """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""

     st = os.stat(src)

     mode = stat.S_IMODE(st.st_mode)

     if hasattr(os, 'utime'):

         os.utime(dst, (st.st_atime, st.st_mtime))

     if hasattr(os, 'chmod'):

         os.chmod(dst, mode)

     if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):

         try:

             os.chflags(dst, st.st_flags)

         except OSError, why:

             for err in 'EOPNOTSUPP', 'ENOTSUP':

                 if hasattr(errno, err) and why.errno == getattr(errno, err):

                     break

             else:

                 raise

 def copy(src, dst):

     """Copy data and mode bits ("cp src dst").

     The destination may be a directory.

     """

     if os.path.isdir(dst):

         dst = os.path.join(dst, os.path.basename(src))

     copyfile(src, dst)

     copymode(src, dst)

 def copy2(src, dst):

     """Copy data and all stat info ("cp -p src dst").

     The destination may be a directory.

     """

     if os.path.isdir(dst):

         dst = os.path.join(dst, os.path.basename(src))

     copyfile(src, dst)

     copystat(src, dst)

 def ignore_patterns(*patterns):

     """Function that can be used as copytree() ignore parameter.

     Patterns is a sequence of glob-style patterns

     that are used to exclude files"""

     def _ignore_patterns(path, names):

         ignored_names = []

         for pattern in patterns:

             ignored_names.extend(fnmatch.filter(names, pattern))

         return set(ignored_names)

     return _ignore_patterns

 def copytree(src, dst, symlinks=False, ignore=None):

     """Recursively copy a directory tree using copy2().

     The destination directory must not already exist.

     If exception(s) occur, an Error is raised with a list of reasons.

     If the optional symlinks flag is true, symbolic links in the

     source tree result in symbolic links in the destination tree; if

     it is false, the contents of the files pointed to by symbolic

     links are copied.

     The optional ignore argument is a callable. If given, it

     is called with the `src` parameter, which is the directory

     being visited by copytree(), and `names` which is the list of

     `src` contents, as returned by os.listdir():

         callable(src, names) -> ignored_names

     Since copytree() is called recursively, the callable will be

     called once for each directory that is copied. It returns a

     list of names relative to the `src` directory that should

     not be copied.

     XXX Consider this example code rather than the ultimate tool.

     """

     names = os.listdir(src)

     if ignore is not None:

         ignored_names = ignore(src, names)

     else:

         ignored_names = set()

     os.makedirs(dst)

     errors = []

     for name in names:

         if name in ignored_names:

             continue

         srcname = os.path.join(src, name)

         dstname = os.path.join(dst, name)

         try:

             if symlinks and os.path.islink(srcname):

                 linkto = os.readlink(srcname)

                 os.symlink(linkto, dstname)

             elif os.path.isdir(srcname):

                 copytree(srcname, dstname, symlinks, ignore)

             else:

                 # Will raise a SpecialFileError for unsupported file types

                 copy2(srcname, dstname)

         # catch the Error from the recursive copytree so that we can

         # continue with other files

         except Error, err:

             errors.extend(err.args[0])

         except EnvironmentError, why:

             errors.append((srcname, dstname, str(why)))

     try:

         copystat(src, dst)

     except OSError, why:

         if WindowsError is not None and isinstance(why, WindowsError):

             # Copying file access times may fail on Windows

             pass

         else:

             errors.append((src, dst, str(why)))

     if errors:

         raise Error, errors

 def rmtree(path, ignore_errors=False, onerror=None):

     """Recursively delete a directory tree.

     If ignore_errors is set, errors are ignored; otherwise, if onerror

     is set, it is called to handle the error with arguments (func,

     path, exc_info) where func is os.listdir, os.remove, or os.rmdir;

     path is the argument to that function that caused it to fail; and

     exc_info is a tuple returned by sys.exc_info().  If ignore_errors

     is false and onerror is None, an exception is raised.

     """

     if ignore_errors:

         def onerror(*args):

             pass

     elif onerror is None:

         def onerror(*args):

             raise

     try:

         if os.path.islink(path):

             # symlinks to directories are forbidden, see bug #1669

             raise OSError("Cannot call rmtree on a symbolic link")

     except OSError:

         onerror(os.path.islink, path, sys.exc_info())

         # can't continue even if onerror hook returns

         return

     names = []

     try:

         names = os.listdir(path)

     except os.error, err:

         onerror(os.listdir, path, sys.exc_info())

     for name in names:

         fullname = os.path.join(path, name)

         try:

             mode = os.lstat(fullname).st_mode

         except os.error:

             mode = 0

         if stat.S_ISDIR(mode):

             rmtree(fullname, ignore_errors, onerror)

         else:

             try:

                 os.remove(fullname)

             except os.error, err:

                 onerror(os.remove, fullname, sys.exc_info())

     try:

         os.rmdir(path)

     except os.error:

         onerror(os.rmdir, path, sys.exc_info())

 def move(src, dst):

     """Recursively move a file or directory to another location. This is

     similar to the Unix "mv" command.

     If the destination is a directory or a symlink to a directory, the source

     is moved inside the directory. The destination path must not already

     exist.

     If the destination already exists but is not a directory, it may be

     overwritten depending on os.rename() semantics.

     If the destination is on our current filesystem, then rename() is used.

     Otherwise, src is copied to the destination and then removed.

     A lot more could be done here...  A look at a mv.c shows a lot of

     the issues this implementation glosses over.

     """

     real_dst = dst

     if os.path.isdir(dst):

         if _samefile(src, dst):

             # We might be on a case insensitive filesystem,

             # perform the rename anyway.

             os.rename(src, dst)

             return

         real_dst = os.path.join(dst, _basename(src))

         if os.path.exists(real_dst):

             raise Error, "Destination path '%s' already exists" % real_dst

     try:

         os.rename(src, real_dst)

     except OSError:

         if os.path.isdir(src):

             if _destinsrc(src, dst):

                 raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)

             copytree(src, real_dst, symlinks=True)

             rmtree(src)

         else:

             copy2(src, real_dst)

             os.unlink(src)

 def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,

                  dry_run=0, owner=None, group=None, logger=None):

     """Create an archive file (eg. zip or tar).

     'base_name' is the name of the file to create, minus any format-specific

     extension; 'format' is the archive format: one of "zip", "tar", "bztar"

     or "gztar".

     'root_dir' is a directory that will be the root directory of the

     archive; ie. we typically chdir into 'root_dir' before creating the

     archive.  'base_dir' is the directory where we start archiving from;

     ie. 'base_dir' will be the common prefix of all files and

     directories in the archive.  'root_dir' and 'base_dir' both default

     to the current directory.  Returns the name of the archive file.

     'owner' and 'group' are used when creating a tar archive. By default,

     uses the current owner and group.

     """

     save_cwd = os.getcwd()

     if root_dir is not None:

         if logger is not None:

             logger.debug("changing into '%s'", root_dir)

         base_name = os.path.abspath(base_name)

         if not dry_run:

             os.chdir(root_dir)

     if base_dir is None:

         base_dir = os.curdir

     kwargs = {'dry_run': dry_run, 'logger': logger}

     try:

         format_info = _ARCHIVE_FORMATS[format]

     except KeyError:

         raise ValueError, "unknown archive format '%s'" % format

     func = format_info[0]

     for arg, val in format_info[1]:

         kwargs[arg] = val

     if format != 'zip':

         kwargs['owner'] = owner

         kwargs['group'] = group

     try:

         filename = func(base_name, base_dir, **kwargs)

     finally:

         if root_dir is not None:

             if logger is not None:

                 logger.debug("changing back to '%s'", save_cwd)

             os.chdir(save_cwd)

     return filename

 <?xml version="1.0"?>

 <data>

     <country name="Liechtenstein">

         <rank updated="yes">2</rank>

         <year>2008</year>

         <gdppc>141100</gdppc>

         <neighbor name="Austria" direction="E"/>

         <neighbor name="Switzerland" direction="W"/>

     </country>

     <country name="Singapore">

         <rank updated="yes">5</rank>

         <year>2011</year>

         <gdppc>59900</gdppc>

         <neighbor name="Malaysia" direction="N"/>

     </country>

     <country name="Panama">

         <rank updated="yes">69</rank>

         <year>2011</year>

         <gdppc>13600</gdppc>

         <neighbor name="Costa Rica" direction="W"/>

         <neighbor name="Colombia" direction="E"/>

     </country>

 </data>

 import xml.etree.ElementTree as ET

 tree = ET.parse("xmltest.xml")

 root = tree.getroot()

 #修改

 for node in root.iter('year'):

     new_year = int(node.text) + 1

     node.text = str(new_year)

     node.set("updated","yes")

 tree.write("xmltest.xml")

 #删除node

 for country in root.findall('country'):

    rank = int(country.find('rank').text)

    if rank > 50:

      root.remove(country)

 tree.write('output.xml')

 import xml.etree.ElementTree as ET

 new_xml = ET.Element("namelist")

 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})

 age = ET.SubElement(name,"age",attrib={"checked":"no"})

 sex = ET.SubElement(name,"sex")

 sex.text = ''

 name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})

 age = ET.SubElement(name2,"age")

 age.text = ''

 et = ET.ElementTree(new_xml) #生成文档对象

 et.write("test.xml", encoding="utf-8",xml_declaration=True)

 ET.dump(new_xml) #打印生成的格式

 >>> import configparser

 >>> config = configparser.ConfigParser()

 >>> config.sections()

 []

 >>> config.read('example.ini')

 ['example.ini']

 >>> config.sections()

 ['bitbucket.org', 'topsecret.server.com']

 >>> 'bitbucket.org' in config

 True

 >>> 'bytebong.com' in config

 False

 >>> config['bitbucket.org']['User']

 'hg'

 >>> config['DEFAULT']['Compression']

 'yes'

 >>> topsecret = config['topsecret.server.com']

 >>> topsecret['ForwardX11']

 'no'

 >>> topsecret['Port']

 ''

 >>> for key in config['bitbucket.org']: print(key)

 ...

 user

 compressionlevel

 serveraliveinterval

 compression

 forwardx11

 >>> config['bitbucket.org']['ForwardX11']

 'yes'

 [section1]

 k1 = v1

 k2:v2

 [section2]

 k1 = v1

 import ConfigParser

 config = ConfigParser.ConfigParser()

 config.read('i.cfg')

 # ########## 读 ##########

 #secs = config.sections()

 #print secs

 #options = config.options('group2')

 #print options

 #item_list = config.items('group2')

 #print item_list

 #val = config.get('group1','key')

 #val = config.getint('group1','key')

 # ########## 改写 ##########

 #sec = config.remove_section('group1')

 #config.write(open('i.cfg', "w"))

 #sec = config.has_section('wupeiqi')

 #sec = config.add_section('wupeiqi')

 #config.write(open('i.cfg', "w"))

 #config.set('group2','k1',11111)

 #config.write(open('i.cfg', "w"))

 #config.remove_option('group2','age')

 #config.write(open('i.cfg', "w"))

 import hashlib

 m = hashlib.md5()

 m.update(b"Hello")

 m.update(b"It's me")

 print(m.digest())

 m.update(b"It's been a long time since last time we ...")

 print(m.digest()) #2进制格式hash

 print(len(m.hexdigest())) #16进制格式hash

 '''

 def digest(self, *args, **kwargs): # real signature unknown

     """ Return the digest value as a string of binary data. """

     pass

 def hexdigest(self, *args, **kwargs): # real signature unknown

     """ Return the digest value as a string of hexadecimal digits. """

     pass

 '''

 import hashlib

 # ######## md5 ########

 hash = hashlib.md5()

 hash.update('admin')

 print(hash.hexdigest())

 # ######## sha1 ########

 hash = hashlib.sha1()

 hash.update('admin')

 print(hash.hexdigest())

 # ######## sha256 ########

 hash = hashlib.sha256()

 hash.update('admin')

 print(hash.hexdigest())

 # ######## sha384 ########

 hash = hashlib.sha384()

 hash.update('admin')

 print(hash.hexdigest())

 # ######## sha512 ########

 hash = hashlib.sha512()

 hash.update('admin')

 print(hash.hexdigest())

 import logging

 #create logger

 logger = logging.getLogger('TEST-LOG')

 logger.setLevel(logging.DEBUG)

 # create console handler and set level to debug

 ch = logging.StreamHandler()

 ch.setLevel(logging.DEBUG)

 # create file handler and set level to warning

 fh = logging.FileHandler("access.log")

 fh.setLevel(logging.WARNING)

 # create formatter

 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

 # add formatter to ch and fh

 ch.setFormatter(formatter)

 fh.setFormatter(formatter)

 # add ch and fh to logger

 logger.addHandler(ch)

 logger.addHandler(fh)

 # 'application' code

 logger.debug('debug message')

 logger.info('info message')

 logger.warn('warn message')

 logger.error('error message')

 logger.critical('critical message')

 import logging

 from logging import handlers

 logger = logging.getLogger(__name__)

 log_file = "timelog.log"

 #fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)

 fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)

 formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')

 fh.setFormatter(formatter)

 logger.addHandler(fh)

 logger.warning("test1")

 logger.warning("test12")

 logger.warning("test13")

 logger.warning("test14")