网上关于mysq时间、python时间与时间戳等文章很多，翻来翻去找不到头绪，根据不同博客的写法，挑了几个来测试，这里记录一下。

况且，不以实际需求为前提的博文，就是瞎写，估计以后自己都看不懂。

Mysql 时间类型

在数据库建表的时候，通常有5中字段类型让人选择： TIME、DATE、DATETIME、TIMESTAMP、YEAR，它们又各自是什么格式呢？要写的让自己容易记：

1、获取当前时间

import datetime,time
""" 当前时间 """
print(time.time())
print(datetime.datetime.now())
得到的输出结果是：
1516200437.9920225
2018-01-17 22:47:17.992047
2、当前时间格式化
import datetime,time
""" time当前时间 """
localtime = time.localtime(time.time())
print("本地时间为 :", localtime)
gtime = time.strftime('%Y-%m-%d',localtime)
print("可以把时间转换为 :",gtime)
gltime = time.strftime('%Y-%m-%d %H:%M:%S',localtime)
print("可以把时间转换为 :",gltime)
#------------------------------------------------
""" datetime当前时间 """
localtime = datetime.datetime.now()
gtime = datetime.datetime.now().strftime("%Y-%m-%d")
gltime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(localtime)
print(gtime)
print(gltime)
得到的结果是：
本地时间为 : time.struct_time(tm_year=2018, tm_mon=1, tm_mday=17, tm_hour=22, tm_min=55, tm_sec=46, tm_wday=2, tm_yday=17, tm_isdst=0)
可以把时间转换为 : 2018-01-17
可以把时间转换为 : 2018-01-17 22:55:46
#------------------------------------------------
2018-01-18 08:03:18.760582
2018-01-18
2018-01-18 08:03:18
这里可以看出，用两个模块获得的当前时间都不是人类容易阅读的，都需要通过strftime函数进行格式化。
3、文本时间转换
这里我指的是爬虫获取的其他网站的时间，通常有几种格式：
长时间 -- 2018-01-06 18:35:05、2018-01-06 18:35
日期 --  2018-01-06
月时间 -- 2018-01
时间 --  18:35:05
通常，爬虫得到的时间都是人阅读的，只不过分隔符不同。并且在入库的时候，我希望他们的时间格式是统一的，年月日时分秒或者年月日，如果可以就用时间戳，方便计算(年月日时分秒对应年月日时分秒，年月日不可直接转换为年月日时分秒)。
遇到日期类型2018-01-06的时间格式，是不可以用函数直接转成长时间2018-01-06 18:35:05格式的，报错。当遇到这种情况，而我又想将时间统一，只能进行转换。转换又分为两种，相同时间格式转换与不同时间格式转换：
第一种情形
目标：2018-01-06 18:35:05 转换为2018-01-06 18:35:05
它有两种方法可以满足
方法一的逻辑是不同格式的时间转换要先转成时间数组，然后再由时间数组格式化成想要的类型：
import datetime,time
a = "2013-10-10 23:40:00"  # 想要转换成 a = "2013/10/10 23:40:00"
timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
otherStyleTime = time.strftime("%Y/%m/%d %H:%M:%S", timeArray)
print(timeArray)
print(otherStyleTime)
从输出结果：
time.struct_time(tm_year=2013, tm_mon=10, tm_mday=10, tm_hour=23, tm_min=40, tm_sec=0, tm_wday=3, tm_yday=283, tm_isdst=-1)
2013/10/10 23:40:00
可以看到，先通过time.strptime把它转换成时间数组，然后通过time.strftime把时间数组格式化成我想要的格式。
方法二，由于最终格式化的时间也是字符串str，所以当遇到这种情况的时候，还可以直接用replace来进行转换：
a = "2013-10-10 23:40:00"  # 想要转换成 a = "2013/10/10 23:40:00"
print(a.replace("-", "/"))
输出结果为：
2013/10/10 23:40:00
第二种情形
目标：2018-01-06  转换为2018-01-06 18:35:05
它也有两种方法可以满足
它的逻辑是将年月日的字符串拼接上时分秒，然后再按照上面的两种方法进行转换，比如：
a = "2013-10-10 "  # 想要转换成 a = "2013/10/10 23:40:00"
ac = a + "00:00:00"
print(ac.replace("-", "/"))
得到输出结果
2013/10/10 00:00:00
第三种情形
目标：2018-01-06 18:35:05 转换为2018-01-06
思路与第一种一致，先转换为时间数组，然后再由时间数组进行格式化：
import datetime,time
a = "2013-10-10 23:40:00"  # 想要转换成 a = "2013/10/10"
timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
otherStyleTime = time.strftime("%Y/%m/%d", timeArray)
print(type(timeArray))
print(otherStyleTime)
得到结果输出为（可以看到timeArray的类型是time.struct_time）：
<class 'time.struct_time'>
2013/10/10
4、时间的比较运算
都知道字符串是不可以进行比较计算的，那么我们就需要用到其他的格式进行。time的strptime转换成时间数组是不可以进行运算的，但是datetime可以。
第一种 ，时间格式相同
import datetime,time
d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%Y-%m-%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-05 16:41:20', '%Y-%m-%d %H:%M:%S')
delta = d1 - d2
print(type(d1))
print(delta.seconds)
print(delta)
得到的输出是：
<class 'datetime.datetime'>
1:00:00
从结果上可以看到，格式相同的两种时间，可以通过datetime.datetime.strptime进行转换后再运算，在结果中还可以通过.seconds来计算 相差秒数 和通过.days来计算 相差天数
第二种 ，如果时间格式不一样，但是转换后的类型一样，也是可以比较的：
import datetime,time
d1 = datetime.datetime.strptime('2012/03/05 17:41:20', '%Y/%m/%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-05 16:41:20', '%Y-%m-%d %H:%M:%S')
delta = d1 - d2
print(delta.seconds)
print(delta)
这段代码里面时间的字符串形式就不一样，但是通过同样的函数进行转换后就可以比较计算了。
第三种 ，年月日时分秒与年月日的计算，其实原理是一样的，转换后他们的格式都一样，所以也是可以计算的，2012/03/05 17:41:20与2012-03-05的时间相差：
import datetime,time
d1 = datetime.datetime.strptime('2012/03/05 17:41:20', '%Y/%m/%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-01', '%Y-%m-%d')
delta = d1 - d2
print(delta.days,delta.seconds)
print(delta)
print(type(delta))
输出结果是
4 63680
4 days, 17:41:20
<class 'datetime.timedelta'>
通过print的结果可以得到几点信息：

不同格式的时间在转化后是可以进行比较运算的

可以通过.days和.seconds来进行天数与时分秒的展示

计算后得到的数据类型是 'datetime.timedelta' 而不是str类型
比如计算3天后的时间：
import datetime,time
now = datetime.datetime.now()
delta = datetime.timedelta(days=3)
n_days = now + delta
print(type(n_days))
print(n_days.strftime('%Y-%m-%d %H:%M:%S'))
得到的结果是：
<class 'datetime.datetime'>
2018-01-21 10:26:14
用datetime.timedelta取得3天时间，然后将当前时间加上3天，得到的是'datetime.datetime'类型数据，变成人类阅读的格式则需要strftime函数进行格式化，最终得到想要的2018-01-21 10:26:14。
5、时间戳
把字符串时间转换为时间戳：
import datetime,time
a = "2013-10-10 23:40:00"
# 转换为时间数组
timeArray = time.strptime(a, "%Y-%m-%d %H:%M:%S")
# 转换为时间戳:
timeStamp = time.mktime(timeArray)
print(timeArray)
print(timeStamp)
输出结果为：
time.struct_time(tm_year=2013, tm_mon=10, tm_mday=10, tm_hour=23, tm_min=40, tm_sec=0, tm_wday=3, tm_yday=283, tm_isdst=-1)
1381419600.0
可以看到time的时间数组与时间戳并不是同一样东西，他们是有区别的
6、strftime与strptime
这两个是python中常用的
strftime函数：
函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定。
time.strftime(format[, t])
format -- 格式字符串。t -- 可选的参数t是一个struct_time对象。
返回以可读字符串表示的当地时间。
import time
t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)
t = time.mktime(t)
print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(t)))
得到结果输出：
2009-02-17 09:03:38
strptime()

函数根据指定的格式把一个时间字符串解析为时间元组。

time.strptime(string[, format])

string -- 时间字符串。format -- 格式化字符串。

返回struct_time对象。
import datetime,time
d1 = datetime.datetime.strptime('20120305 17:41:20', '%Y%m%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-01', '%Y-%m-%d')
print(d1)
print(d2)
得到结果：
2012-03-05 17:41:20
2012-03-01 00:00:00
时间格式与入库
前面铺垫了这么多，最终的目的还是需要入库。这里以4种数据库时间类型为例：
字段名 => 数据类型
r_time       =>        time
r_date         =>     date
r_datetime  =>    datetime
r_timestamp  => timestamp
根据最上方所写的Mysql时间类型，可以得出对应的时间格式为：
时间格式 => 数据类型
17:35:05      =>        time
2018-3-1         =>     date
2018/3/1 17:35  =>    datetime
2018/3/1 17:35  => timestamp
time类型
time类型的格式指定为17:35:05，不可替换为（17-35-05或者17/35/05）,会报错
可以简写成17:35，数据库会自动补全后面的00,入库后最终数据17:35:00
如果简写成17，则入库后变成00:00:17
当然，如果更奇葩的写法17:,17:35:这种是会报错的
date类型
date类型的格式指定为2018-3-1与2018/3/1，最终入库格式是（2018-03-01），它会自动补全
可以简写成[18/3/1]、[17/3/1]、[07/3/1]、[97/3/1]，数据库会自动补全前面的年份,入库后最终数据2018-03-01、2017-03-01、2007-03-01、1997-03-01
不可简写成[2017]、[2017/3]，会报错，必须是完整的日期格式
datetime类型
datetime类型的格式指定为2018-3-1 17:35:00和2018/3/1 17:35:00，最终入库格式是2018-03-01 17:35:00
它是date与time的结合，有很多共同特性
可以简写成[18/3/1 17:35:05]、[17/3/1 17:35]、[07/3/1 17]、[97/3/1 17]，数据库会自动补全前面的年份,入库后最终数据2018-03-01 17:35:05、2017-03-01 17:35:00、2007-03-01  17:00:00、1997-03-01 17:00:00。可以看到它自动将时间格式补全成统一格式，这里与time不同的是，如果只写17不写分秒，time会默认将17当成秒，这里则是默认当成小时。
与date一样，年月日不可省略，必须以年月日格式出现
timestamp类型
根据上面的描述，timestamp的入库格式与datetime是一样的，不同的是时间范围和存储空间，它的格式与用法跟datetime一致
                Python全栈开发（五）——python数据库MySQL
            
今天简单说说MySQL，我们存储数据，直接用本地文件即可，但是，本地文件不利于存放海量数据，也不利于用程序对文件的数据进行查询与管理，我们可以使用数据库。
                使用Python解析并“篡改”MySQL的Binlog---发表到爱可生开源社区
            
MySQL 的 Binlog 记录着 MySQL 数据库的所有变更信息，了解 Binlog 的结构可以帮助我们解析Binlog，甚至对 Binlog 进行一些修改，或者说是“篡改”，例如实现类似于 Oracle 的 flashback 的功能，恢复误删除的记录，把 update 的记录再还原回去等。
                【Python】【MySQL】Python将JSON数据以文本形式存放到MySQL的Text类型字段中
            
【Python】【MySQL】Python将JSON数据以文本形式存放到MySQL的Text类型字段中
                基于python（Django、Mysql）的超市管理系统的设计与实现
            
Python语言功能强大，可以运用在诸多方面，其中在Web开发方向也有一系列十分成功的应用，同时为了方便开发，提升开发效率出现了一系列的开发框架，其中 Django 就是一个典型的重量级选手，它帮助我们解决了开发中很多问题，比如模板、数据处理等等，这些使得我们只需要使用 Django 就可以完成大多数的开发任务。
数据库采用MySQL，它是一种关系型数据库管理系统，关系数据库将数据保存在不
                开心档-软件开发入门之Python MySQL - mysql-connector 驱动
            
MySQL 是最流行的关系型数据库管理系统，如果你不熟悉 MySQL，可以阅读我们的  MySQL 教程。
本章节我们为大家介绍使用 mysql-connector 来连接使用 MySQL， mysql-connector 是 MySQL 官方提供的驱动器。
本文我们为大家介绍 Python3 使用 PyMySQL 连接数据库，并实现简单的增删改查。
PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库，Python2 中则使用 mysqldb。
PyMySQL 遵循 Python 数据库 API v2.0 规范，并包含了 pure-Python MySQL 客户端库。