包与模块（五）

1.1 模块

1.1.1 模块介绍

常见的场景：一个模块就是一个包含了一组功能的python文件,比如spam.py，模块名为spam，可以通过import spam使用。

在python中，模块的使用方式都是一样的，但其实细说的话，模块可以分为四个通用类别：　

1 使用python编写的.py文件

2 已被编译为共享库或DLL的C或C++扩展

3 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

4 使用C编写并链接到python解释器的内置模块

1.1.2 为何要使用模块

1、从文件级别组织程序，更方便管理

随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

2、拿来主义，提升开发效率

同样的原理，我们也可以下载别人写好的模块然后导入到自己的项目中使用，这种拿来主义，可以极大地提升我们的开发效率

#ps：

如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

以spam.py为例来介绍模块的使用：文件名spam.py,模块名spam

#spam.py

print('from the spam.py')

 

money=1000

 

def read1():

    print('spam模块：',money)

 

def read2():

    print('spam模块')

    read1()

 

def change():

    global money

    money=0

模块使用.py

import spam

 

money=1

print(spam.money)

 

print(spam.read1)

print(spam.read2)

print(spam.change)

测试一

money=1

print(spam.money)

测试二（绝对导入）：

def read1():

    print('from current')

# spam.read1()

spam.read2()

测试三：

money=1

spam.change()

print(money)

spam.read1()

 

1.2 使用模块之import

1.2.1 import的使用

模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下

#test.py

import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.

import spam

import spam

import spam

 

'''

执行结果：

from the spam.py

'''

ps：我们可以从sys.module中找到当前已经加载的模块，sys.module是一个字典，内部包含模块名与模块对象的映射，该字典决定了导入模块时是否需要重新导入。

1.2.2 在第一次导入模块时会做三件事，重复导入会直接引用内存中已经加载好的结果

1.为源文件(spam模块)创建新的名称空间，在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

2.在新创建的命名空间中执行模块中包含的代码，见初始导入import spam

 提示:导入模块时到底执行了什么？

事实上函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放入模块全局名称空间表，用globals()可以查看

3.创建名字spam来引用该命名空间

    这个名字和变量名没什么区别，都是‘第一类的’，且使用spam.名字的方式

    可以访问spam.py文件中定义的名字，spam.名字与test.py中的名字来自

    两个完全不同的地方。

1.2.3 被导入模块有独立的名称空间

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

测试一:money与spam.money不冲突

#test.py

import spam

money=10

print(spam.money)

 

'''

执行结果：

from the spam.py

1000

'''

测试二：read1与spam.read1不冲突

#test.py

import spam

def read1():

    print('========')

spam.read1()

 

'''

执行结果:

from the spam.py

spam->read1->money 1000

'''

测试三：执行spam.change()操作的全局变量money仍然是spam中的

#test.py

import spam

money=1

spam.change()

print(money)

 

'''

执行结果：

from the spam.py

1

'''

1.2.4 为模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用

import spam as sm

print(sm.money)

 

engine=input('>>: ')

if engine == 'mysql':

    import mysql as sql

elif engine == 'oracle':

    import oracle as sql

 

sql.parse()

有两中sql模块mysql和oracle，根据用户的输入，选择不同的sql功能

假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不同的输入格式。可以编写代码来选择性地挑选读取模块

if file_format == 'xml':

    import xmlreader as reader

elif file_format == 'csv':

    import csvreader as reader

data=reader.read_date(filename)

1.2.5 在一行导入多个模块

import sys,os,re

1.2.6 使用模块之from ... import...

1.2.6.1  from ... import... .的使用

from spam import money,read1,read2,change

 

money=1

print(money)

 

read1='read1'

print(read1)

 

money=1

read1()

 

def read1():

    print('from current func')

 

read2()

 

money=1

change()

print(money)

1.2.7 from...import 与import的对比

唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam.

#from...import...的方式有好处也有坏处

    好处：使用起来方便了

    坏处：容易与当前执行文件中的名字冲突

read1=1

print(money,read1,read2,change)

 

print(_money)

print(read1,read2,change)

 

from spam import _money

print(_money)

 

import spam

spam.read1()

 

import sys

print(sys.path)

 

sys.path.append(r'D:videopython20期day51_模块aaa')

import spam

print(spam.money)

 

 

import spam,time

time.sleep(10)

import spam

print(spam.money)

 

import sys,spam

print('spam' in  sys.modules)

print('time' in sys.modules)

 

import time

print(time)

time.sleep(3)

 

1.2.8 from spam import *

#from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置

#大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

 

1.3 py文件区分两种用途:模块与脚本

写好的一个python文件可以有两种用途：

    一：脚本，一个文件就是整个程序，用来被执行

    二：模块，文件中存放着一堆功能，用来被导入使用

#python为我们内置了全局变量__name__，

    当文件被当做脚本执行时：__name__ 等于'__main__'

    当文件被当做模块导入时：__name__等于模块名

#作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

    if __name__ == '__main__':

1.4 模块搜索路径

模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

模块的查找顺序

1、在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用

    ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看

2、如果没有，解释器则会查找同名的内建模块

3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

1.5 包

1.5.1 什么是包

包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

需要强调的是：

　　1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

　　2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

1.5.2 为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来

随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

注意事项：

#1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。

#2、import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

#3、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

1.5.3 包的使用之import

创建包package1,在package1创建package2

在包package1中创建文件init.py

# print('__init__.py')

 

x=1

# m1='m1'

# import m1 #错误

from package1 import m1

 

# package2='package2'

# import package2 #错误,单独导入包名称时不会导入包中所有包含的所有子模块

from package1 import package2

在包package1中创建文件m1.py

def f1():

    print('from f1 func')

在包package2中创建文件m2.py

def f2():
    print('f2')

需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

1.6 绝对导入和相对导入

我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以glance作为起始

相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

1.6.1 相对导入

包的使用.py

# import package1

#

# # package1.f1()

# package1.f2()

 

import sys

sys.path.append(r'D:videopython20期day52_包测试三（相对导入）aaa')

 

import package1

package1.f2()

m1.py

def f1():

    print('from f1 func')

 

包1_init_.py

from .m1 import f1

from .package2.m2 import f2

m2.py

from ..m1 import f1

def f2():

    f1()

    print('f2')

1.6.2 绝对导入

包的使用.py

import package1

 

package1.f1()

package1.f2()

 

# import sys

#

# # sys.path.append(r'D:videopython20期day52_包测试二（绝对导入）package1package2')

# # sys.path.append(r'D:videopython20期day52_包测试二（绝对导入）package1')

#

m1.py

def f1():
    print('from f1 func')

包1_init_.py

from package1.m1 import f1

from package1.package2.m2 import f2

m2.py

def f2():

    print('f2')

包2_init_.py

from package1.package2 import m2

1.7 软件开发规范

 

图1-1  

#===============>star.py

import sys,os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)

 

from core import src

 

if __name__ == '__main__':

    src.run()

#===============>settings.py

import os

 

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

DB_PATH=os.path.join(BASE_DIR,'db','db.json')

LOG_PATH=os.path.join(BASE_DIR,'log','access.log')

LOGIN_TIMEOUT=5

 

"""

logging配置

"""

# 定义三种日志输出格式

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 

                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# log配置字典

LOGGING_DIC = {

    'version': 1,

    'disable_existing_loggers': False,

    'formatters': {

        'standard': {

            'format': standard_format

        },

        'simple': {

            'format': simple_format

        },

    },

    'filters': {},

    'handlers': {

        #打印到终端的日志

 'console': {

            'level': 'DEBUG',

            'class': 'logging.StreamHandler',  # 打印到屏幕

            'formatter': 'simple'

        },

        #打印到文件的日志,收集info及以上的日志

       

 'default': {

            'level': 'DEBUG',

            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件

            'formatter': 'standard',

            'filename': LOG_PATH,  # 日志文件

            'maxBytes': 1024*1024*5,  # 日志大小 5M

            'backupCount': 5,

            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了

        },

    },

    'loggers': {

        #logging.getLogger(__name__)拿到的logger配置

      

  '': {

            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕

            'level': 'DEBUG',

            'propagate': True,  # 向上（更高level的logger）传递

        },

    },

}

#===============>src.py

from conf import settings

from lib import common

import time

 

logger=common.get_logger(__name__)

 

current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}

def auth(func):

    def wrapper(*args,**kwargs):

        if current_user['user']:

            interval=time.time()-current_user['login_time']

            if interval < current_user['timeout']:

                return func(*args,**kwargs)

        name = input('name>>: ')

        password = input('password>>: ')

        db=common.conn_db()

        if db.get(name):

            if password == db.get(name).get('password'):

                logger.info('登录成功')

                current_user['user']=name

                current_user['login_time']=time.time()

                return func(*args,**kwargs)

        else:

            logger.error('用户名不存在')

 

    return wrapper

 

@auth

def buy():

    print('buy...')

 

@auth

def run():

 

    print('''

    1 购物

    2 查看余额

    3 转账

    ''')

    while True:

        choice = input('>>: ').strip()

        if not choice:continue

        if choice == '1':

            buy()

 

 

#===============>db.json

{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}}

 

#===============>common.py

from conf import settings

import logging

import logging.config

import json

 

def get_logger(name):

    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入上面定义的logging配置

    logger = logging.getLogger(name)  # 生成一个log实例

    return logger

 

 

def conn_db():

    db_path=settings.DB_PATH

    dic=json.load(open(db_path,'r',encoding='utf-8'))

    return dic

#===============>access.log

[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]

[2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登录成功]

[2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登录成功]

#介绍

# import logging

# logging.basicConfig(

#     # filename='access.log',

#     format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

#     datefmt='%Y-%m-%d %H:%M:%S %p',

#     level=10

# )

#

# logging.debug('debug') # 10

# logging.info('info') # 20

# logging.warning('warn') #30

# logging.error('error') #40

# logging.critical('critial') #50

 

1.8 常用模块

1.8.1 日志模块的详细用法：

import logging

1.8.2 Logger：产生日志

logger1=logging.getLogger('访问日志')

# logger2=logging.getLogger('错吴日志')

1.8.3 Filter：几乎不用

1.8.4 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件

sh=logging.StreamHandler() #打印到终端

fh1=logging.FileHandler('s1.log',encoding='utf-8')

fh2=logging.FileHandler('s2.log',encoding='utf-8')

1.8.5 Formatter：日志格式

formatter1=logging.Formatter(

    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

formatter2=logging.Formatter(

    fmt='%(asctime)s : %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

formatter3=logging.Formatter(

    fmt='%(asctime)s : %(module)s : %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

1.8.6 、为handler绑定日志格式

sh.setFormatter(formatter1)

fh1.setFormatter(formatter2)

fh2.setFormatter(formatter3)

1.8.7 、为logger绑定handler

logger1.addHandler(sh)

logger1.addHandler(fh1)

logger1.addHandler(fh2)

1.8.8 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

sh.setLevel(10)

fh1.setLevel(10)

fh2.setLevel(10)

1.8.9 测试

logger1.debug('测试着玩')

logger1.info('运行还算正常')

logger1.warning('可能要有bug了')

logger1.error('不好了，真tm出bug了')

logger1.critical('完犊子，推倒重写')

1.9 日志的继承

import logging

1.9.1 Logger：产生日志

logger1=logging.getLogger('root')

logger2=logging.getLogger('root.child1')

logger3=logging.getLogger('root.child1.child2')

1.9.2 Filter：几乎不用

1.9.3 Handler：接收Logger传过来的日志，进行日志格式化，可以打印到终端，也可以打印到文件

sh=logging.StreamHandler() #打印到终端

1.9.4 Formatter：日志格式

formatter1=logging.Formatter(

    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

1.9.5 为handler绑定日志格式

sh.setFormatter(formatter1)

1.9.6 为logger绑定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

1.9.7 设置日志级别:logger对象的日志级别应该＜＝handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

logger2.setLevel(10) #

logger3.setLevel(10) #

sh.setLevel(10)

1.9.8 测试

logger1.debug('爷爷')

logger2.debug('爸爸')

logger3.debug('孙子')

1.10 正则模块

import re

 

# print(re.findall('w','egon 123 + _ - *'))

# print(re.findall('W','egon 123 + _ - *'))

# print(re.findall('s','ego	n 12
3 + _ - *'))

# print(re.findall('S','ego	n 12
3 + _ - *'))

# print(re.findall('d','ego	n 12
3 + _ - *'))

# print(re.findall('D','ego	n 12
3 + _ - *'))

# print(re.findall('
','ego	n 12
3 + _ - *'))

# print(re.findall('	','ego	n 12
3 + _ - *'))

# print(re.findall('e','ego	n 12
3 +hello _ - *'))

# print(re.findall('^e','ego	n 12
3 +hello _ - *'))

# print(re.findall('o$','ego	n 12
3 +hello'))

 

#重复：.|?|*|+|{m,n}|.*|.*?

#.代表任意一个字符

# print(re.findall('a.b','a1b a b a-b aaaaaab'))

                    #   a.b

# print(re.findall('a.b','a1b a b a
b a-b aaaaaab',re.DOTALL))

                    #   a.b

#?:代表?号左边的字符出现0次或者1

# print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']

#                       #                  ab?

 

#*:代表*号左边的字符出现0次或者无穷次

# print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']

                      #                  ab*

 

#+:代表+号左边的字符出现1次或者无穷次

# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

#                       #                  ab+

 

# {m,n}:代表左边的字符出现m次到n次

# print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']

 

#.*:贪婪匹配

# print(re.findall('a.*b','xxxy123a123b456b'))

                        #        a.*b

#.*?:非贪婪匹配

# print(re.findall('a.*?b','xxxy123a123b456b'))

#|:或者

# print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))

# print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))

                                 #                                                                         compan(y|iess)

 

# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击我</a>'))

#rawstring：

# print(re.findall(r'a\c','ac a1c aBc')) #a\c->ac

#[]:取中括号内任意的一个

# print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b'))

 

#re模块的其他方法

#re.search :只匹配成功一次就返回

# print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))

# print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group())

 

# re.match:从开头取

# print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))

# print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

# print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

 

# re.split

# print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))

# 'root:x:0:0::/root:/bin/bash'.split(':')

 

# re.sub

# print(re.sub('root','admin','root:x:0:0::/root:/bin/bash',1))

#了解

# print(re.sub('^([a-z]+)([^a-z]+)(.*?)([^a-z]+)([a-z]+)$',r'52341','root:x:0:0::/root:/bin/bash'))

# re.compile

obj=re.compile('ad{2}b')

print(obj.findall('a12b a123b a12345b abbb'))

print(obj.search('a12b a123b a12345b abbb').group())

 

1.11 时间模块

import time

#掌握

# print(time.time())

 

# print(time.localtime())

# print(time.localtime().tm_mday)

# print(time.gmtime())

 

# print(time.strftime('%Y-%m-%d %H:%M:%S'))

# print(time.strftime('%Y-%m-%d %X'))

 

#了解

# print(time.localtime(11111111))

# print(time.localtime(time.time()))

# print(time.gmtime(time.time()))

 

# print(time.mktime(time.localtime()))

 

# print(time.strftime('%Y-%m-%d',time.localtime()))

# print(time.strptime('2017-03-01','%Y-%m-%d'))

 

# print(time.asctime(time.localtime()))

# print(time.ctime(111111))

 

#datetime

import datetime

# print(datetime.datetime.now())

# print(datetime.datetime.fromtimestamp(111111111))

 

# print(datetime.datetime.now()+datetime.timedelta(days=3))

# print(datetime.datetime.now()+datetime.timedelta(days=-3))

# print(datetime.datetime.now()+datetime.timedelta(hours=3))

# print(datetime.datetime.now()+datetime.timedelta(minutes=3))

# print(datetime.datetime.now()+datetime.timedelta(seconds=3))

 

# print(datetime.datetime.now().replace(year=1999,hour=12))