import logging

logging.warning("user [ps] attempted wrong password more than 3 times")
logging.critical("server is down")

------------
WARNING:root:user [ps] attempted wrong password more than 3 times
CRITICAL:root:server is down

import logging
logging.basicConfig(filename='example.log')
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

import logging
logging.basicConfig(filename='example.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')

import logging
logging.basicConfig(filename='example.log',filemode='w', level=logging.INFO)
logging.warning("filemode='w'")

import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')

------------
12/12/2010 11:46:36 AM is when this event was logged.

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')

def getLogger(name=None):
    """
    Return a logger with the specified name, creating it if necessary.

    If no name is specified, return the root logger.
    """
    if name:
        return Logger.manager.getLogger(name)
    else:
        return root

Logger.manager = Manager(Logger.root)

class Manager(object):
    """
    There is [under normal circumstances] just one Manager instance, which
    holds the hierarchy of loggers.
    """
    def __init__(self, rootnode):
        """
        Initialize the manager with the root node of the logger hierarchy.
        """
        self.root = rootnode
        self.disable = 0
        self.emittedNoHandlerWarning = False
        self.loggerDict = {}
        self.loggerClass = None
        self.logRecordFactory = None

    def getLogger(self, name):
        """
        Get a logger with the specified name (channel name), creating it
        if it doesn't yet exist. This name is a dot-separated hierarchical
        name, such as "a", "a.b", "a.b.c" or similar.

        If a PlaceHolder existed for the specified name [i.e. the logger
        didn't exist but a child of it did], replace it with the created
        logger and fix up the parent/child references which pointed to the
        placeholder to now point to the logger.
        """
        rv = None
        if not isinstance(name, str):
            raise TypeError('A logger name must be a string')
        _acquireLock()
        try:
            if name in self.loggerDict:
                rv = self.loggerDict[name]
                if isinstance(rv, PlaceHolder):
                    ph = rv
                    rv = (self.loggerClass or _loggerClass)(name)
                    rv.manager = self
                    self.loggerDict[name] = rv
                    self._fixupChildren(ph, rv)
                    self._fixupParents(rv)
            else:
                rv = (self.loggerClass or _loggerClass)(name)
                rv.manager = self
                self.loggerDict[name] = rv
                self._fixupParents(rv)
        finally:
            _releaseLock()
        return rv

    def setLoggerClass(self, klass):
        """
        Set the class to be used when instantiating a logger with this Manager.
        """
        if klass != Logger:
            if not issubclass(klass, Logger):
                raise TypeError("logger not derived from logging.Logger: "
                                + klass.__name__)
        self.loggerClass = klass

    def setLogRecordFactory(self, factory):
        """
        Set the factory to be used when instantiating a log record with this
        Manager.
        """
        self.logRecordFactory = factory

    def _fixupParents(self, alogger):
        """
        Ensure that there are either loggers or placeholders all the way
        from the specified logger to the root of the logger hierarchy.
        """
        name = alogger.name
        i = name.rfind(".")
        rv = None
        while (i > 0) and not rv:
            substr = name[:i]
            if substr not in self.loggerDict:
                self.loggerDict[substr] = PlaceHolder(alogger)
            else:
                obj = self.loggerDict[substr]
                if isinstance(obj, Logger):
                    rv = obj
                else:
                    assert isinstance(obj, PlaceHolder)
                    obj.append(alogger)
            i = name.rfind(".", 0, i - 1)
        if not rv:
            rv = self.root
        alogger.parent = rv

    def _fixupChildren(self, ph, alogger):
        """
        Ensure that children of the placeholder ph are connected to the
        specified logger.
        """
        name = alogger.name
        namelen = len(name)
        for c in ph.loggerMap.keys():
            #The if means ... if not c.parent.name.startswith(nm)
            if c.parent.name[:namelen] != name:
                alogger.parent = c.parent
                c.parent = alogger

#---------------------------------------------------------------------------
#   Logger classes and functions
#---------------------------------------------------------------------------

class Logger(Filterer):
    """
    Instances of the Logger class represent a single logging channel. A
    "logging channel" indicates an area of an application. Exactly how an
    "area" is defined is up to the application developer. Since an
    application can have any number of areas, logging channels are identified
    by a unique string. Application areas can be nested (e.g. an area
    of "input processing" might include sub-areas "read CSV files", "read
    XLS files" and "read Gnumeric files"). To cater for this natural nesting,
    channel names are organized into a namespace hierarchy where levels are
    separated by periods, much like the Java or Python package namespace. So
    in the instance given above, channel names might be "input" for the upper
    level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
    There is no arbitrary limit to the depth of nesting.
    """
    def __init__(self, name, level=NOTSET):
        """
        Initialize the logger with a name and an optional level.
        """
        Filterer.__init__(self)
        self.name = name
        self.level = _checkLevel(level)
        self.parent = None
        self.propagate = True
        self.handlers = []
        self.disabled = False

    def setLevel(self, level):
        """
        Set the logging level of this logger.  level must be an int or a str.
        """
        self.level = _checkLevel(level)

    def debug(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'DEBUG'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)
        """
        if self.isEnabledFor(DEBUG):
            self._log(DEBUG, msg, args, **kwargs)

    def info(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'INFO'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.info("Houston, we have a %s", "interesting problem", exc_info=1)
        """
        if self.isEnabledFor(INFO):
            self._log(INFO, msg, args, **kwargs)

    def warning(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'WARNING'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)
        """
        if self.isEnabledFor(WARNING):
            self._log(WARNING, msg, args, **kwargs)

    def warn(self, msg, *args, **kwargs):
        warnings.warn("The 'warn' method is deprecated, "
            "use 'warning' instead", DeprecationWarning, 2)
        self.warning(msg, *args, **kwargs)

    def error(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'ERROR'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.error("Houston, we have a %s", "major problem", exc_info=1)
        """
        if self.isEnabledFor(ERROR):
            self._log(ERROR, msg, args, **kwargs)

    def exception(self, msg, *args, exc_info=True, **kwargs):
        """
        Convenience method for logging an ERROR with exception information.
        """
        self.error(msg, *args, exc_info=exc_info, **kwargs)

    def critical(self, msg, *args, **kwargs):
        """
        Log 'msg % args' with severity 'CRITICAL'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.critical("Houston, we have a %s", "major disaster", exc_info=1)
        """
        if self.isEnabledFor(CRITICAL):
            self._log(CRITICAL, msg, args, **kwargs)

    fatal = critical

    def log(self, level, msg, *args, **kwargs):
        """
        Log 'msg % args' with the integer severity 'level'.

        To pass exception information, use the keyword argument exc_info with
        a true value, e.g.

        logger.log(level, "We have a %s", "mysterious problem", exc_info=1)
        """
        if not isinstance(level, int):
            if raiseExceptions:
                raise TypeError("level must be an integer")
            else:
                return
        if self.isEnabledFor(level):
            self._log(level, msg, args, **kwargs)

    def findCaller(self, stack_info=False):
        """
        Find the stack frame of the caller so that we can note the source
        file name, line number and function name.
        """
        f = currentframe()
        #On some versions of IronPython, currentframe() returns None if
        #IronPython isn't run with -X:Frames.
        if f is not None:
            f = f.f_back
        rv = "(unknown file)", 0, "(unknown function)", None
        while hasattr(f, "f_code"):
            co = f.f_code
            filename = os.path.normcase(co.co_filename)
            if filename == _srcfile:
                f = f.f_back
                continue
            sinfo = None
            if stack_info:
                sio = io.StringIO()
                sio.write('Stack (most recent call last):\n')
                traceback.print_stack(f, file=sio)
                sinfo = sio.getvalue()
                if sinfo[-1] == '\n':
                    sinfo = sinfo[:-1]
                sio.close()
            rv = (co.co_filename, f.f_lineno, co.co_name, sinfo)
            break
        return rv

    def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
                   func=None, extra=None, sinfo=None):
        """
        A factory method which can be overridden in subclasses to create
        specialized LogRecords.
        """
        rv = _logRecordFactory(name, level, fn, lno, msg, args, exc_info, func,
                             sinfo)
        if extra is not None:
            for key in extra:
                if (key in ["message", "asctime"]) or (key in rv.__dict__):
                    raise KeyError("Attempt to overwrite %r in LogRecord" % key)
                rv.__dict__[key] = extra[key]
        return rv

    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
        """
        Low-level logging routine which creates a LogRecord and then calls
        all the handlers of this logger to handle the record.
        """
        sinfo = None
        if _srcfile:
            #IronPython doesn't track Python frames, so findCaller raises an
            #exception on some versions of IronPython. We trap it here so that
            #IronPython can use logging.
            try:
                fn, lno, func, sinfo = self.findCaller(stack_info)
            except ValueError: # pragma: no cover
                fn, lno, func = "(unknown file)", 0, "(unknown function)"
        else: # pragma: no cover
            fn, lno, func = "(unknown file)", 0, "(unknown function)"
        if exc_info:
            if isinstance(exc_info, BaseException):
                exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
            elif not isinstance(exc_info, tuple):
                exc_info = sys.exc_info()
        record = self.makeRecord(self.name, level, fn, lno, msg, args,
                                 exc_info, func, extra, sinfo)
        self.handle(record)

    def handle(self, record):
        """
        Call the handlers for the specified record.

        This method is used for unpickled records received from a socket, as
        well as those created locally. Logger-level filtering is applied.
        """
        if (not self.disabled) and self.filter(record):
            self.callHandlers(record)

    def addHandler(self, hdlr):
        """
        Add the specified handler to this logger.
        """
        _acquireLock()
        try:
            if not (hdlr in self.handlers):
                self.handlers.append(hdlr)
        finally:
            _releaseLock()

    def removeHandler(self, hdlr):
        """
        Remove the specified handler from this logger.
        """
        _acquireLock()
        try:
            if hdlr in self.handlers:
                self.handlers.remove(hdlr)
        finally:
            _releaseLock()

    def hasHandlers(self):
        """
        See if this logger has any handlers configured.

        Loop through all handlers for this logger and its parents in the
        logger hierarchy. Return True if a handler was found, else False.
        Stop searching up the hierarchy whenever a logger with the "propagate"
        attribute set to zero is found - that will be the last logger which
        is checked for the existence of handlers.
        """
        c = self
        rv = False
        while c:
            if c.handlers:
                rv = True
                break
            if not c.propagate:
                break
            else:
                c = c.parent
        return rv

    def callHandlers(self, record):
        """
        Pass a record to all relevant handlers.

        Loop through all handlers for this logger and its parents in the
        logger hierarchy. If no handler was found, output a one-off error
        message to sys.stderr. Stop searching up the hierarchy whenever a
        logger with the "propagate" attribute set to zero is found - that
        will be the last logger whose handlers are called.
        """
        c = self
        found = 0
        while c:
            for hdlr in c.handlers:
                found = found + 1
                if record.levelno >= hdlr.level:
                    hdlr.handle(record)
            if not c.propagate:
                c = None    #break out
            else:
                c = c.parent
        if (found == 0):
            if lastResort:
                if record.levelno >= lastResort.level:
                    lastResort.handle(record)
            elif raiseExceptions and not self.manager.emittedNoHandlerWarning:
                sys.stderr.write("No handlers could be found for logger"
                                 " \"%s\"\n" % self.name)
                self.manager.emittedNoHandlerWarning = True

    def getEffectiveLevel(self):
        """
        Get the effective level for this logger.

        Loop through this logger and its parents in the logger hierarchy,
        looking for a non-zero logging level. Return the first one found.
        """
        logger = self
        while logger:
            if logger.level:
                return logger.level
            logger = logger.parent
        return NOTSET

    def isEnabledFor(self, level):
        """
        Is this logger enabled for level 'level'?
        """
        if self.manager.disable >= level:
            return False
        return level >= self.getEffectiveLevel()

    def getChild(self, suffix):
        """
        Get a logger which is a descendant to this one.

        This is a convenience method, such that

        logging.getLogger('abc').getChild('def.ghi')

        is the same as

        logging.getLogger('abc.def.ghi')

        It's useful, for example, when the parent logger is named using
        __name__ rather than a literal string.
        """
        if self.root is not self:
            suffix = '.'.join((self.name, suffix))
        return self.manager.getLogger(suffix)

>>> import time
>>> 
>>> time.time()  #获取时间戳，从1970年1月1日0：00到现在的秒数
1465321187.56645
>>> time.time() - 86400  #可以按需 + - 秒数
1465234811.8091
>>> 
>>> time.ctime()  #返回'Wed Jun  8 01:42:41 2016'格式的日期时间字符串
'Wed Jun  8 01:42:41 2016'
>>> time.ctime() - 86400  #报错！ctime返回的字符串，是不能 + - 的 
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'int'
>>> time.ctime(time.time() - 86400)  #ctime可以接收时间戳参数并转化为日期时间字符串，通过这个功能，可以把时间戳的时间进行 + - 后传递给ctime进行转换
'Tue Jun  7 01:45:09 2016'
>>> 
>>> time.gmtime() #返回一个格式化的时间对象
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=7, tm_hour=17, tm_min=47, tm_sec=1, tm_wday=1, tm_yday=159, tm_isdst=0)
>>> type(time.gmtime())
<class 'time.struct_time'>
>>> time.gmtime(time.time() - 86400)  #也可以通过传递时间戳来更改时间
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=6, tm_hour=17, tm_min=48, tm_sec=27, tm_wday=0, tm_yday=158, tm_isdst=0)
>>> time.gmtime()[0]  #可以通过索引的方式去取值
2016
>>> time.gmtime()[1]
6
>>> time.gmtime()[2]  #问题来了，现在已经是8号了却还显示7，是因为这里显示的是格林威治时间，不是本地时间
7
>>> 
>>> time.localtime()  #本地时间来了！这个方法显示的是本地时区的时间！返回的格式与gmtime是一样的，用法也一样
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=1, tm_min=56, tm_sec=5, tm_wday=2, tm_yday=160, tm_isdst=0)
>>> 
>>> time.mktime(time.localtime())  #该方法接收一个tuple类型的参数，可接收struct_time对象并将其转化为时间戳
1465322289.0
>>> 
>>> time.strftime("%Y-%m-%d", time.localtime())  #将struct_time对象以指定的格式显示
'2016-06-08'
>>> time.strptime('2016-06-08', "%Y-%m-%d")  #将日期字符串以指定的格式转化为struct_time对象
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=160, tm_isdst=-1)
>>> 
>>> time.sleep(4) 
>>> 
>>> time.clock()  #在Unix系统上表示进程时间。在Windows上第一次返回进程时间，第二次返回第一次到第二次之间的时间
29.472588

>>> datetime.date.today()  #2016-06-08
datetime.date(2016, 6, 8)
>>> print(datetime.date.today())
2016-06-08
>>> 
>>> datetime.date.fromtimestamp(time.time())  #将时间戳转为日期格式
datetime.date(2016, 6, 8)
>>> 
>>> datetime.datetime.now() #返回当前时间
datetime.datetime(2016, 6, 8, 2, 18, 57, 453874)
>>> print(datetime.datetime.now())
2016-06-08 02:19:08.895585
>>> datetime.datetime.now().timetuple()  #转化为struct_time对象
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=2, tm_min=20, tm_sec=17, tm_wday=2, tm_yday=160, tm_isdst=-1)
>>> 
>>> datetime.datetime.now().replace(2015, 5, 9)   #替换指定的日期或时间
datetime.datetime(2015, 5, 9, 2, 21, 39, 897457)
>>> 
>>> datetime.datetime.strptime("09/05/15 7:56", "%d/%m/%y %H:%M")  #将日期时间字符串转为时间格式，并以指定的格式进行显示
datetime.datetime(2015, 5, 9, 7, 56)
>>> 
>>> datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
datetime.datetime(2016, 6, 18, 2, 26, 46, 45019)
>>> datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
datetime.datetime(2016, 5, 29, 2, 26, 53, 536217)
>>> datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时
datetime.datetime(2016, 6, 7, 16, 27, 0, 717995)
>>> datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s
datetime.datetime(2016, 6, 8, 2, 29, 7, 456727)

import json

d = {'k1': 'v1'}
print(d, type(d))

result = json.dump(d, open('a.json', 'w'))
print(result, type(result))

------------
{'k1': 'v1'} <class 'dict'>
None <class 'NoneType'>

import json

d = json.load(open('a.json', 'r'))
print(d, type(d))

------------
{'k1': 'v1'} <class 'dict'>

import pickle

class User(object):
    pass

u = User()
ret = pickle.dumps(u)
print(ret, type(ret))

------------
b'\x80\x03c__main__\nUser\nq\x00)\x81q\x01.' <class 'bytes'>

import pickle

class User(object):
    pass

u = User()
ret = pickle.dumps(u)
print(ret, type(ret))

o = pickle.loads(ret)
print(o, type(o))

------------
b'\x80\x03c__main__\nUser\nq\x00)\x81q\x01.' <class 'bytes'>
<__main__.User object at 0x101b78a90> <class '__main__.User'>

import pickle

u = (1, 2, 3)
ret = pickle.dump(u, open('a.pkl', 'wb'))
print(ret, type(ret))

------------
None <class 'NoneType'>

import pickle

o = pickle.load(open('a.pkl', 'rb'))
print(o, type(o))

------------
(1, 2, 3) <class 'tuple'>

import yaml

o = yaml.load(open('conf.yml'))
print(o, type(o))

------------
{'host1': {'app': ['httpd', 'mysql', 'php'], 'IP': '192.168.1.1', 'memory': '16G'}, 'host2': {'app': ['logstash', 'kibana', 'elasticsearch', 'kafka', 'zookeeper'], 'IP': '192.168.1.2', 'memory': '128G'}} <class 'dict'>

import yaml

o = yaml.load(open('conf.yml'))

o['host3'] = {'app': ['docker', 'jenkins'], 'IP': '192.168.1.3', 'memory': '64G'}
yaml.dump(o, open('conf.yml', 'w'))

import yaml

o = yaml.load(open('conf.yml'))

o['host3'] = {'app': ['docker', 'jenkins'], 'IP': '192.168.1.3', 'memory': '64G'}
#yaml.dump(o, open('conf.yml', 'w'))
yaml.dump(o, open('conf.yml', 'w'), default_flow_style=False)

def func():
    yield 1
    yield 2
    yield 3
    yield 4

f = func()

print(type(f))
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())

------------
1
2
3
4
Traceback (most recent call last):
  File "/Users/lvrui/PycharmProjects/untitled/5/test.py", line 85, in <module>
    print(f.__next__())
StopIteration

def mylist(li):
    for i in range(len(li) - 1):
        yield (li[i], li[i + 1])

li = [1, 2, 3, 4, 5, 6]

generator_list = mylist(li)
print(generator_list)

for i in generator_list:
    print(i)
    
------------
<generator object mylist at 0x101380888>
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)

>>> i = iter([1,2,3,4,5])
>>> i
<list_iterator object at 0x1032fa390>
>>> dir(i)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']

def a():
    print('Polar Snow')

def b():
    return a()

def c():
    return b()

def d():
    return c()

d()

------------
Polar Snow

def func(n):
    n += 1
    if n >= 4:
        return 'end'
    return func(n)

r = func(1)
print(r)

------
end

def cal(n):
    if n == 0:
        return 1
    return n * cal(n-1)

print(cal(7))

------------
5040

def cal(n):
    if n == 7:
        return n
    return n * cal(n+1)

print(cal(1))

------------
5040

>>> s = 'My name is %s, I am %d.' % ('Polar Snow', 25)
>>> s
'My name is Polar Snow, I am 25.'

>>> s = 'My name is %(name)s, I am %(age)d.' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am 25.'

>>> s = 'My name is %(name)s, Hello %(name)s.' % {'name': 'Polar Snow'}
>>> s
'My name is Polar Snow, Hello Polar Snow.'

>>> s = 'My name is %(name)s, I am %(age)+d.' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am +25.'
------
>>> s = 'My name is %(name)s, I am %(age)+d.' % {'name': 'Polar Snow', 'age': -25}
>>> s
'My name is Polar Snow, I am -25.'

>>> s = 'My name is %(name)s, I am %(age)-d.' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am 25.'
------
>>> s = 'My name is %(name)s, I am %(age)-d.' % {'name': 'Polar Snow', 'age': -25}
>>> s
'My name is Polar Snow, I am -25.'

>>> s = 'My name is %(name)s, I am [%(age) d].' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am [ 25].'
------
>>> s = 'My name is %(name)s, I am [%(age) d].' % {'name': 'Polar Snow', 'age': -25}
>>> s
'My name is Polar Snow, I am [-25].'

>>> s = 'My name is %(name)s, I am %(age)0d.' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am 25.'
------
>>> s = 'My name is %(name)s, I am %(age)0d.' % {'name': 'Polar Snow', 'age': -25}
>>> s
'My name is Polar Snow, I am -25.'

>>> s = 'My name is %(name)s, I am [%(age)05d].' % {'name': 'Polar Snow', 'age': -25}
>>> s
'My name is Polar Snow, I am [-0025].'
------
>>> s = 'My name is %(name)s, I am [%(age)05d].' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am [00025].'

>>> s = 'My name is %(name)s, I am [%(age)+5d].' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am [  +25].'
------
>>> s = 'My name is %(name)s, I am [%(age) 5d].' % {'name': 'Polar Snow', 'age': 25}
>>> s
'My name is Polar Snow, I am [   25].'

>>> s = 'My name is %(name)s, I am [%(age) 9.3f].' % {'name': 'Polar Snow', 'age': 25.2525252525}
>>> s
'My name is Polar Snow, I am [   25.253].'

>>> s = 'My name is {}, I am {}.'.format('Polar Snow', 25.2525252525)
>>> s
'My name is Polar Snow, I am 25.2525252525.'
------
>>> s = 'My name is {}, I am {}.'.format('Polar Snow', 25)
>>> s
'My name is Polar Snow, I am 25.'
------
>>> s = 'My name is {name}, I am {age}.'.format(name='Polar Snow', age=25)
>>> s
'My name is Polar Snow, I am 25.'

>>> s = 'My name is {}, I am {}.'.format(*['Polar Snow', 25])
>>> s
'My name is Polar Snow, I am 25.'
------
>>> s = 'My name is {name}, I am {age}.'.format(**{'name': 'Polar Snow', 'age': 25})
>>> s
'My name is Polar Snow, I am 25.'

# 首先从最简单的开始
>>> s = 'My name is {}, I am {}.'.format('Polar Snow', 25)
>>> s
'My name is Polar Snow, I am 25.'
# 列表的形式传值
>>> s = 'My name is {}, I am {}.'.format(*['Polar Snow', 25])
>>> s
'My name is Polar Snow, I am 25.'
# 指定值列表的索引
>>> s = 'My name is {0}, I am {1}.'.format('Polar Snow', 25)
>>> s
'My name is Polar Snow, I am 25.'
>>> s = 'My name is {0}, I am {0}.'.format('Polar Snow', 25)
>>> s
'My name is Polar Snow, I am Polar Snow.'
# 甚至可以在嵌套中取值
>>> s = 'My name is {0[0]}, I am {0[1]}.'.format(['Polar Snow', 'Larry'], 25)
>>> s
'My name is Polar Snow, I am Larry.'
------
# 设置占位符名称
>>> s = 'My name is {name}, I am {age}.'.format(name='Polar Snow', age=25)
>>> s
'My name is Polar Snow, I am 25.'
# 字典的形式传值
>>> s = 'My name is {name}, I am {age}.'.format(**{'name': 'Polar Snow', 'age': 25})
>>> s
'My name is Polar Snow, I am 25.'
------
# format最省心的是不需要指定字符串类型，但是你也可以选择去指定
>>> s = "i am {:s}, age {:d}, money {:f}".format("seven", 25, 88888.1)
>>> s
'i am seven, age 25, money 88888.100000'
# 保留两位小数
>>> s = "i am {:s}, age {:d}, money {:.2f}".format("seven", 25, 88888.1)
>>> s
'i am seven, age 25, money 88888.10'
# 保留两位小数并在数字中用,分隔
>>> s = "i am {:s}, age {:d}, money {:,.2f}".format("seven", 25, 88888.1)
>>> s
'i am seven, age 25, money 88,888.10'
------
# 居中显示，插入[]是为了展示居中的效果更直观
>>> s = "i am {:s}, age [{:^10d}], money {:,.2f}".format("seven", 25, 88888.1)
>>> s
'i am seven, age [    25    ], money 88,888.10'
------
# 数字的展示
>>> s = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
>>> s
'numbers: 1111,17,15,f,F, 1500.000000%'
>>> s = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
>>> s
'numbers: 1111,17,15,f,F, 1500.000000%'

>>> abs(-59)
59

l1 = [1, '1', True]
print(all(l1))

l2 = [0, '1', True]
print(all(l2))

------------
True
False
#0为假，可迭代对象中只要全为真才返回为真

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

l1 = [1, '1', True]
print(any(l1))

l2 = [0, '1', True]
print(any(l2))

l3 = [0, '', False]
print(any(l3))

-----------
True
True
False

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

class c():
    def __repr__(self):
        return 'repr'

print(ascii(c()))

------------
repr

>>> ascii('极地瑞雪')
"'\\u6781\\u5730\\u745e\\u96ea'"
>>> ascii('Polar Snow')
"'Polar Snow'"

>>> repr('极地瑞雪')
"'极地瑞雪'"
>>> repr('Polar Snow')
"'Polar Snow'"

>>> str('极地瑞雪')
'极地瑞雪'
>>> str('Polar Snow')
'Polar Snow'

>>> ascii('极地瑞雪')
"'\\u6781\\u5730\\u745e\\u96ea'"
>>> ascii('Polar Snow')
"'Polar Snow'"
>>> ascii(59)
'59'
------------
>>> repr('极地瑞雪')
"'极地瑞雪'"
>>> repr('Polar Snow')
>>> "'Polar Snow'"
>>> repr(59)
'59'

>>> repr('极地瑞雪')
"'极地瑞雪'"
>>> repr('Polar Snow')
>>> "'Polar Snow'"
>>> repr(59)
'59'
------------
>>> str('极地瑞雪')
'极地瑞雪'
>>> str('Polar Snow')
'Polar Snow'
>>> str(59)
'59'

>>> bin(59)
'0b111011'

>>> oct(59)
'0o73'

>>> hex(59)
'0x3b'

>>> bytes('极地瑞雪', encoding='utf-8')
b'\xe6\x9e\x81\xe5\x9c\xb0\xe7\x91\x9e\xe9\x9b\xaa'
>>> str(b'\xe6\x9e\x81\xe5\x9c\xb0\xe7\x91\x9e\xe9\x9b\xaa', encoding='utf-8')
'极地瑞雪'
------------
>>> bytes('极地瑞雪', encoding='gbk')
b'\xbc\xab\xb5\xd8\xc8\xf0\xd1\xa9'
>>> str(b'\xbc\xab\xb5\xd8\xc8\xf0\xd1\xa9', encoding='gbk')
'极地瑞雪'

u = bytes('吕瑞', encoding='utf-8')
s = str(u, encoding='gbk')
print(s)

######运行结果
鍚曠憺

def f1():
    pass
# f1()

f2 = 123
# f2()

print(callable(f1))
print(callable(f2))

------------
True
False

>>> chr(59)
';'
>>> chr(8364)
'€'
>>> chr(201559)
'\U00031357'

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

>>> class C:
...     @classmethod
...     def f(cls):
...             print "This is a class method"
...
>>> C.f()
This is a class method
>>> c = C()
>>> c.f()
This is a class method
>>> class D:
...     def f(self):
...             print " This is not a class method "
...
>>> D.f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method f() must be called with D instance as first argument (got nothing instead)
>>> d = D()
>>> d.f()
This is not a class method

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...