python 基础-爬虫-数据处理，全部方法

生成时间戳

1. time.time()
输出 1515137389.69163
=====================

生成格式化的时间字符串

1. time.ctime()
输出 Fri Jan  5 15:34:00 2018
=============================
2. time.strftime("%Y-%m-%d %H:%M:%S")
输出 2018-01-05 15:34:27
========================

生成结构化时间

1. time.gmtime()
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=7, tm_min=34, tm_sec=57, tm_wday=4, tm_yday=5, tm_isdst=0)
===========================================================================================================================
2. time.localtime()
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=35, tm_sec=59, tm_wday=4, tm_yday=5, tm_isdst=0)
============================================================================================================================

时间戳转结构化时间

1. time.gmtime(time.time()
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=7, tm_min=36, tm_sec=40, tm_wday=4, tm_yday=5, tm_isdst=0)
===========================================================================================================================
2. time.localtime(time.time())
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=37, tm_sec=32, tm_wday=4, tm_yday=5, tm_isdst=0)
============================================================================================================================

时间戳转格式化时间字符串

1. time.ctime(time.time())
输出 Fri Jan  5 15:38:14 2018
=============================

结构化时间转时间戳

1. time.mktime(time.localtime())
输出 1515138003.0
=================

结构化时间转格式化的时间字符串

1. time.asctime(time.localtime())              # 第一个参数是默认参数
输出 Fri Jan  5 15:40:22 2018
=============================
2. time.strftime(‘%Y-%m-%d‘,time.localtime())  # 第二个参数是默认参数
输出 2018-01-05
===============

格式化的时间字符串转结构化时间

1. time.strptime(time.strftime("%Y-%m-%d %H:%M:%S"), ‘%Y-%m-%d %H:%M:%S‘)
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=41, tm_sec=35, tm_wday=4, tm_yday=5, tm_isdst=-1)
=============================================================================================================================
2. time.strptime(time.ctime(), ‘%a %b %d %H:%M:%S %Y‘)
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=42, tm_sec=7, tm_wday=4, tm_yday=5, tm_isdst=-1)
============================================================================================================================

格式化时间转时间戳

1. time.mktime(time.strptime(time.ctime(), "%a %b %d %H:%M:%S %Y"))
输出 1515138182.0
=================
2. time.mktime(time.strptime(time.strftime("%Y-%m-%d %H:%M:%S"), "%Y-%m-%d %H:%M:%S"))
输出 1515138201.0
=================
time%*参数
格式 含义
%a 本地（locale）简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%c 本地相应的日期和时间表示
%d 一个月中的第几天（01 - 31）
%H 一天中的第几个小时（24小时制，00 - 23）
%I 第几个小时（12小时制，01 - 12）
%j 一年中的第几天（001 - 366）
%m 月份（01 - 12）
%M 分钟数（00 - 59）
%p 本地am或者pm的相应符
%S 秒（01 - 61）
%U 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。
%w 一个星期中的第几天（0 - 6，0是星期天）
%W 和%U基本相同，不同的是%W以星期一为一个星期的开始
%x 本地相应日期
%X 本地相应时间
%y 去掉世纪的年份（00 - 99）
%Y 完整的年份
%Z 时区的名字（如果不存在为空字符）
%% ‘%‘字符

Datetime模块

<class ‘datetime.datetime‘>对象

1. datetime.datetime.now()
输出 2018-01-05 15:45:32.334965
===============================
2. datetime.datetime(year=2018,month=1,day=3,hour=4, minute=32, second=23, microsecond=22222)
输出 2018-01-03 04:32:23.022222
===============================

<class ‘datetime.timedelta‘>对象

1. datetime.timedelta(days=5,seconds=1,microseconds=22222,minutes=11,hours=11,weeks=2)
输出 19 days, 11:11:01.022222
=============================

<class ‘datetime.date‘>对象

1. datetime.date(year=2018,month=1,day=3)
输出 2018-01-03
===============

<class ‘datetime.time‘>对象

1. datetime.time(hour=4, minute=32, second=23, microsecond=22222)
输出 04:32:23.022222
====================

字符串转datetime对象

1. datetime.datetime.strptime(time.strftime("%Y-%m-%d %H:%M:%S"), "%Y-%m-%d %H:%M:%S")
输出 2018-01-05 15:48:42
========================
2. datetime.datetime.strptime(time.ctime(), "%a %b %d %H:%M:%S %Y")
输出 2018-01-05 15:49:04
========================

时间戳转datetime对象

1. datetime.datetime.fromtimestamp(time.time())
输出 2018-01-05 15:49:21.308415
===============================
2. datetime.datetime.utcfromtimestamp(time.time())
输出 2018-01-05 07:49:57.526658
===============================

datetime对象转格式化时间字符

1. datetime.datetime(2018, 1, 5, 15, 19, 59).strftime("%Y-%m-%d %H:%M:%S")
输出 2018-01-05 15:19:59
========================

datetime对象转结构化时间

1. datetime.datetime(2018, 1, 5, 15, 19, 59).timetuple()
输出 time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=15, tm_min=19, tm_sec=59, tm_wday=4, tm_yday=5, tm_isdst=-1)
=============================================================================================================================

1、python3日期和时间

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳

>>> import time
>>> print(time.time())
1508312234.7298932
#时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

2、时间元组

很多Python函数用一个元组装起来的9组数字处理时间

字段 属性 值
4位年数 tm_year 2017
月 tm_mon 1到12
日 tm_mday 1到31
小时 tm_hour 0到23
分钟 tm_min 0到59
秒 tm_sec 0到61（60或61是润秒）
一周的第几日 tm_wday 0到6(0是周一)
一年的第几日 tm_yday 1到366,一年中的第几天
夏令时 tm_isdst 是否为夏令时，值为1时是夏令时，值为0时不是夏令时，默认为-1 

#从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数
>>> print(time.localtime(time.time()))
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=18, tm_hour=15, tm_min=40, tm_sec=59, tm_wday=2, tm_yday=291, tm_isdst=0)#当前时间为：2017年，10月，18日，15时，40分，59秒，星期三，一年中的291天，不是夏令

3、获取格式化的时间

可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime()

>>> import time
>>> print(time.asctime(time.localtime(time.time())))
Wed Oct 18 16:03:24 2017
#wed为星期三，oct为october十月的缩写，18日，时间，年

4、格式化日期

可以使用 time 模块的 strftime 方法来格式化日期

python中时间日期格式化符号：

  • %y 两位数的年份表示（00-99）
  • %Y 四位数的年份表示（000-9999）
  • %m 月份（01-12）
  • %d 月内中的一天（0-31）
  • %H 24小时制小时数（0-23）
  • %I 12小时制小时数（01-12）
  • %M 分钟数（00=59）
  • %S 秒（00-59）
  • %a 本地简化星期名称
  • %A 本地完整星期名称
  • %b 本地简化的月份名称
  • %B 本地完整的月份名称
  • %c 本地相应的日期表示和时间表示
  • %j 年内的一天（001-366）
  • %p 本地A.M.或P.M.的等价符
  • %U 一年中的星期数（00-53）星期天为星期的开始
  • %w 星期（0-6），星期天为星期的开始
  • %W 一年中的星期数（00-53）星期一为星期的开始
  • %x 本地相应的日期表示
  • %X 本地相应的时间表示
  • %Z 当前时区的名称
  • %% %号本身

>>> import time
>>> print(time.strftime(‘%Y‘,time.localtime()))  #获取完整年份
2017
>>> print(time.strftime(‘%y‘,time.localtime()))  #获取简写年份
17
>>> print(time.strftime(‘%m‘,time.localtime()))  #获取月
10
>>> print(time.strftime(‘%d‘,time.localtime()))  #获取日
18
>>> print(time.strftime(‘%Y-%m-%d‘,time.localtime()))  #获取年-月-日
2017-10-18

>>> print(time.strftime(‘%H‘,time.localtime()))  #获取时，24小时制
16
>>> print(time.strftime(‘%l‘,time.localtime()))  #获取时，12小时制
 4
>>> print(time.strftime(‘%M‘,time.localtime()))  #获取分
33
>>> print(time.strftime(‘%S‘,time.localtime()))  #获取秒
31
>>> print(time.strftime(‘%H:%M:%S‘,time.localtime()))  #获取时:分:秒
16:34:28

>>> print(time.strftime(‘%a‘,time.localtime()))  #本地简化星期
Wed
>>> print(time.strftime(‘%A‘,time.localtime()))  #本地完整星期
Wednesday
>>> print(time.strftime(‘%b‘,time.localtime()))  #本地简化月份
Oct
>>> print(time.strftime(‘%B‘,time.localtime()))  #本地完整月份
October
>>> print(time.strftime(‘%c‘,time.localtime()))  #本地日期和时间表示
Wed Oct 18 16:37:46 2017

>>> print(time.strftime(‘%j‘,time.localtime())) #一年中的第几天
291
>>> print(time.strftime(‘%p‘,time.localtime())) #P.M等价符
PM
>>> print(time.strftime(‘%U‘,time.localtime())) #一年中的第几个星期，星期天为星期的开始
42
>>> print(time.strftime(‘%w‘,time.localtime()))  #星期几,星期天为星期的开始
3
>>> print(time.strftime(‘%W‘,time.localtime()))  #一年中的第几个星期，星期一为星期的开始
42
>>> print(time.strftime(‘%x‘,time.localtime()))  #本地日期表示
10/18/17
>>> print(time.strftime(‘%X‘,time.localtime()))  #本地时间表示
17:16:17
>>> print(time.strftime(‘%Z‘,time.localtime()))  #当前时区
CST
>>> print(time.strftime(‘%%‘,time.localtime()))  #输出%本身
%

>>> print(time.strftime(‘%Y-%m-%d %H:%M:%S %w-%Z‘,time.localtime()))
2017-10-18 17:25:39 3-CST   #完整日期，时间，星期，时区

5、获取月日历

Calendar模块有很广泛的方法用来处理年历和月历

>>> import calendar
>>> cal=calendar.month(2017,10)
>>> print(cal)
    October 2017
Mo Tu We Th Fr Sa Su
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31

#calendar.calendar(2017)
#返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。
每日宽度间隔为w字符。
每行长度为21* W+18+2* C。l是每星期行数。
>>> c = calendar.calendar(2017)
>>> print(c)
                                  2017

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5             1  2  3  4  5
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       6  7  8  9 10 11 12
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      13 14 15 16 17 18 19
16 17 18 19 20 21 22      20 21 22 23 24 25 26      20 21 22 23 24 25 26
23 24 25 26 27 28 29      27 28                     27 28 29 30 31
30 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2       1  2  3  4  5  6  7                1  2  3  4
 3  4  5  6  7  8  9       8  9 10 11 12 13 14       5  6  7  8  9 10 11
10 11 12 13 14 15 16      15 16 17 18 19 20 21      12 13 14 15 16 17 18
17 18 19 20 21 22 23      22 23 24 25 26 27 28      19 20 21 22 23 24 25
24 25 26 27 28 29 30      29 30 31                  26 27 28 29 30

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                   1  2  3
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       4  5  6  7  8  9 10
10 11 12 13 14 15 16      14 15 16 17 18 19 20      11 12 13 14 15 16 17
17 18 19 20 21 22 23      21 22 23 24 25 26 27      18 19 20 21 22 23 24
24 25 26 27 28 29 30      28 29 30 31               25 26 27 28 29 30
31

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                   1             1  2  3  4  5                   1  2  3
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       4  5  6  7  8  9 10
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      11 12 13 14 15 16 17
16 17 18 19 20 21 22      20 21 22 23 24 25 26      18 19 20 21 22 23 24
23 24 25 26 27 28 29      27 28 29 30               25 26 27 28 29 30 31
30 31

#calendar.firstweekday返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
>>> calendar.firstweekday()
0
#calendar.setfirstweekday设置每周的起始日期码。0（星期一）到6（星期日）。
>>> calendar.setfirstweekday(1)
>>> calendar.firstweekday()
1

# calendar.isleap是闰年返回True，否则为false。
>>> calendar.isleap(2017)
False
>>> print(calendar.isleap(2020))
True

#calendar.leapdays返回在两年之间的闰年总数，但不包括末年
>>> print(calendar.leapdays(2016,2020))
1
>>> print(calendar.leapdays(2016,2021))
2

#calendar.monthcalendar返回一个整数的单层嵌套列表，每个子列表装载代表一个星期，月外的日期设为0
>>> print(calendar.monthcalendar(2017,10))
[[0, 0, 0, 0, 0, 0, 1], [2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22], [23, 24, 25, 26, 27, 28, 29], [30, 31, 0, 0, 0, 0, 0]]
>>> print(calendar.month(2017,10))
    October 2017
Mo Tu We Th Fr Sa Su
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31

#calendar.monthrange返回两个整数，第一个为该月的首日的星期（0-6），第二个为该月的总天数
>>> print(calendar.monthrange(2017,10))
(6, 31)

#calendar.timegm接受一个时间元组形式struct_time，返回该时刻的时间辍（1970纪元后经过的浮点秒数）
>>> print(calendar.timegm((2017,10,19,14,50,0,0,0,0)))
1508424600
>>> print(calendar.timegm((2017,10,19,14,50,50,0,0,0)))
1508424650
>>> print(time.localtime(time.time()))
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=19, tm_hour=14, tm_min=49, tm_sec=44, tm_wday=3, tm_yday=292, tm_isdst=0)

#calendar.weekday返回给定日期的星期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。
>>> print(calendar.weekday(2017,10,19))
3
>>> print(calendar.weekday(2017,10,20))
4

6、Time模块

Time 模块包含了以下内置函数，既有时间处理相的，也有转换时间格式的：

#time.altzone
#返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
>>> import time
>>> print(time.altzone)
-28800

#time.asctime([tupletime])
#接受时间元组并返回一个可读的形式为"Thu Oct 19 15:07:31 2017"（2017年10月19日 周四15时07分31秒）的24个字符的字符串。
>>> print(time.asctime(time.localtime()))
Thu Oct 19 15:07:31 2017

#time.clock()
#用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
>>> import time
>>> def procedure():
...   time.sleep(2.5)
...
>>> t0 = time.clock()
>>> procedure()
>>> print(time.clock() - t0)
0.010000000000000009
>>> print(time.clock() - t0)
0.020000000000000004

#time.ctime()作用相当于asctime(localtime(secs))，未给参数相当于asctime()
>>> import time
>>> print(time.ctime())
Thu Oct 19 19:24:24 2017
>>> print(time.asctime(time.localtime()))
Fri Oct 20 11:10:00 2017
>>> print(time.asctime())
Fri Oct 20 11:10:19 2017

#time.gmtime()以元组方式返回格林威治时间
>>> print(time.gmtime())
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=20, tm_hour=3, tm_min=27, tm_sec=30, tm_wday=4, tm_yday=293, tm_isdst=0)

#time.localtime()以元组方式返回本地当前时间
>>> print(time.localtime())
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=20, tm_hour=11, tm_min=30, tm_sec=33, tm_wday=4, tm_yday=293, tm_isdst=0)

#time.mktime()将元组时间转换为时间戳
>>> x = time.localtime()
>>> x
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=20, tm_hour=11, tm_min=32, tm_sec=8, tm_wday=4, tm_yday=293, tm_isdst=0)
>>> time.mktime(x)
1508470328.0

#time.strftime(fmt[,tupletime])
#接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
>>> print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime()))
2017-10-20 17:29:08

#time.strptime()
#根据fmt的格式把一个时间字符串解析为时间元组。
>>> print(time.strptime(‘23 Oct 2017‘,‘%d %b %Y‘))
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=23, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=296, tm_isdst=-1)
>>> print(time.strptime(‘23 Oct 2017 14 03 00‘,‘%d %b %Y %H %M %S‘))
time.struct_time(tm_year=2017, tm_mon=10, tm_mday=23, tm_hour=14, tm_min=3, tm_sec=0, tm_wday=0, tm_yday=296, tm_isdst=-1)

#time.time
#返回当前时间的时间戳（1970年经过的秒数）
>>> print(time.time())
1508739061.9443805

#time.timezone
#是当地时区距离格林威治偏移的秒数
>>> print(time.timezone)
-28800

#time.tzname
#输出一个包含一个不包含夏令时的本地时区名称
>>> print(time.tzname)
(‘CST‘, ‘CST‘)

1、获取当前时间和时区

>>> now = time.time()  # 当前时间 float类型
>>> time.strftime("%Y-%m-%d %H:%M:%S")  #当前时间 str
  ‘2016-11-04 15:29:58‘

>>> time.ctime()   # 当前时间 english str
  ‘Fri Nov 4 15:40:42 2016‘

>>> time.time()
1478244363.875308
>>> time.localtime()   # 当前时间 time结构体
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=4, tm_hour=15, tm_min=26, tm_sec=9, tm_wday=4, tm_yday=309, tm_isdst=0)

>>> time.localtime(now)  # float -> struct_time
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=4, tm_hour=15, tm_min=26, tm_sec=1, tm_wday=4, tm_yday=309, tm_isdst=0)

>>> time.strftime(‘%Z‘, time.localtime())   # 显示当前时区 China standard timezone
‘CST‘
>>> time.gmtime()    # 显示UTC标准时间 跟中国相差8个钟
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=4, tm_hour=7, tm_min=26, tm_sec=28, tm_wday=4, tm_yday=309, tm_isdst=0)

其中time.time()返回的一个float型，是从1970年1月1日0时起到当前经过的秒数，注意这里是分时区的

time.localtime()返回的是一个time结构体，其中包括tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst=0（夏令时间标志）

　　2、时间字符串转成time格式

>>> a = ‘2016-11-04 15:29:58‘
>>> time.strptime(a, "%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2016, tm_mon=11, tm_mday=4, tm_hour=15, tm_min=29, tm_sec=58, tm_wday=4, tm_yday=309, tm_isdst=-1)

　　3、时间字符串转成float类型

>>> a = ‘2016-11-04 15:29:58‘
>>> time.mktime(time.strptime(a, "%Y-%m-%d %H:%M:%S"))
1478244598.0

　　4、time tuple格式转成字符串

>>> time_tuple = (2016, 11, 04, 13, 51, 18, 2, 317, 0)
>>> time.strftime("%Y-%m-%d %H:%M:%S", time_tuple)
‘2016-11-04 13:51:18‘

　　5、float类型转成时间字符串

>>> a = 1478244598.0
>>> b = time.localtime(a)
>>> time.strftime("%Y-%m-%d %H:%M:%S", b)
‘2016-11-04 15:29:58‘

　　6、时间和日期格式化符号说明

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）

%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

　　二、datetime

　　1、获取当前时间

>>> datetime.datetime.now()    # datetime tuple
datetime.datetime(2016, 11, 4, 15, 52, 17, 680405)

>>> time.mktime(datetime.datetime.now().timetuple())   # float类型
1478245984.0
>>> datetime.datetime.now().replace(second=0, microsecond=0)  # 秒数为0 毫秒数为0
  datetime.datetime(2016, 11, 4, 15, 54)

>>> datetime.date.today()   # 当前天
  datetime.date(2016, 11, 4)

　　2、datetime tuple转成时间字符串

>>> now = datetime.datetime.now()
>>> now.strftime("%Y-%m-%d %H:%S:%M")
‘2016-11-04 16:06:00‘

　　3、datetime tuple转成float类型

>>> now = datetime.datetime.now()
>>> time.mktime(now.timetuple())
1478246406.0

　　4、datetime date和time转换

>>> a = datetime.date(2016, 11, 4)
>>> datetime.datetime.strptime(str(a),‘%Y-%m-%d‘)
datetime.datetime(2016, 11, 4, 0, 0)
>>> a
datetime.date(2016, 11, 4)

　　5、获取当前时间的前一段时间

now = datetime.datetime.now()

# 前一小时
a = now - datetime.timedelta(hours=1)
print a.strftime("%Y-%m-%d %H:%S:%M")

# 前一天
b = now - datetime.timedelta(days=1)
print b.strftime("%Y-%m-%d %H:%S:%M")

# 上周日
c = now - datetime.timedelta(days=now.isoweekday())
print c.strftime("%Y-%m-%d %H:%S:%M")# 上周一
d = c - datetime.timedelta(days=6)
print d.strftime("%Y-%m-%d %H:%S:%M")# 上个月最后一天
e = now - datetime.timedelta(days=now.day)
print e.strftime("%Y-%m-%d %H:%S:%M")

# 上个月第一天
print datetime.datetime(e.year, e.month, 1)

# python中时间日期格式化符号：

# %y 两位数的年份表示（00-99）

# %Y 四位数的年份表示（000-9999）

# %m 月份（01-12）

# %d 月内中的一天（0-31）

# %H 24小时制小时数（0-23）

# %I 12小时制小时数（01-12）

# %M 分钟数（00=59）

# %S 秒（00-59）

# # %a 本地简化星期名称

# %A 本地完整星期名称

# %b 本地简化的月份名称

# %B 本地完整的月份名称

# %c 本地相应的日期表示和时间表示

# %j 年内的一天（001-366）

# %p 本地A.M.或P.M.的等价符

# %U 一年中的星期数（00-53）星期天为星期的开始

# %w 星期（0-6），星期天为星期的开始

# %W 一年中的星期数（00-53）星期一为星期的开始

# %x 本地相应的日期表示

# %X 本地相应的时间表示

# %Z 当前时区的名称

# %% %号本身

import time
print time.time()
输出的结果是：
1279578704.6725271

但是这样是一连串的数字不是我们想要的结果，我们可以利用time模块的格式化时间的方法来处理：
time.localtime(time.time())
用time.localtime()方法，作用是格式化时间戳为本地的时间。
输出的结果是：
time.struct_time(tm_year=2010, tm_mon=7, tm_mday=19, tm_hour=22, tm_min=33, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)

现在看起来更有希望格式成我们想要的时间了。
time.strftime(‘%Y-%m-%d‘,time.localtime(time.time()))

最后用time.strftime()方法，把刚才的一大串信息格式化成我们想要的东西，现在的结果是：
2010-07-19

time.strftime里面有很多参数，可以让你能够更随意的输出自己想要的东西：
下面是time.strftime的参数：
strftime(format[, tuple]) -> string
将指定的struct_time(默认为当前时间)，根据指定的格式化字符串输出
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12） 
%M 分钟数（00=59）
%S 秒（00-59）

%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

原文地址：https://www.cnblogs.com/duanlinxiao/p/9835376.html

时间： 2024-11-05 19:37:29

python 基础-爬虫-数据处理，全部方法的相关文章

python写爬虫使用urllib2方法

python写爬虫使用urllib2方法 整理了一部分urllib2的使用细节. 1.Proxy 的设置 urllib2 默认会使用环境变量 http_proxy 来设置 HTTP Proxy. 如果想在程序中明确控制 Proxy 而不受环境变量的影响,可以使用代理. 新建test14来实现一个简单的代理Demo: import urllib2 enable_proxy = True proxy_handler = urllib2.ProxyHandler({"http" : 'htt

Python基础爬虫

搭建环境: win10,Python3.6,pycharm,未设虚拟环境 之前写的爬虫并没有架构的思想,且不具备面向对象的特征,现在写一个基础爬虫架构,爬取百度百科,首先介绍一下基础爬虫框架的五大模块功能,包括爬虫调度器,URL管理器,HTML下载器,HTML解析器,数据存储器,功能分析如下: >>爬虫调度器主要负责统筹其他四个模块的协调工作 >>URL管理器负责管理URL链接,维护已经爬取的URL集合和未爬取的URL集合,提供获取新URL链接的接口 >>HTML下载器

python基础爬虫的框架和运行流程

网络爬虫是什么? 网络爬虫就是:请求网站并提取数据的自动化程序 网络爬虫能做什么? 网络爬虫被广泛用于互联网搜索引擎或其他类似网站,可以自动采集所有其能够访问到的页面内容,以获取或更新这些网站的内容和检索方式. 网络爬虫还被用于爬取各个网站的数据,进行分析.预测近几年来,大量的企业和个人开始使用网络爬虫采集互联网的公开数据,进行数据分析,进一步达到商业目的. 利用网络爬虫能从网上爬取什么数据? 可以好不吹嘘的说,平时从浏览器浏览的所有数据都能被爬取下来. 网络爬虫是否合法? 上面说到了爬虫可以爬

零python基础--爬虫实践总结

网络爬虫,是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本. 爬虫主要应对的问题:1.http请求 2.解析html源码 3.应对反爬机制. 觉得爬虫挺有意思的,恰好看到知乎有人分享的一个爬虫小教程:https://zhuanlan.zhihu.com/p/20410446 立马学起! 主要步骤: 1.按照教程下载python.配置环境变量,学习使用pip命令.安装开发ide:pycharm 2.学习使用python发送请求获取页面 3.使用chrome开发者工具观察页面结构特征,使用b

Python基础第五天方法

双层装饰器 字符串格式化 python字符串格式有2种方式:百分号方式.format方式:建议使用format方式 1.百分号方式 格式:%[(name)][flags][width].[precision]typecode (name)可选,用来选择指定的key或者变量 >>> s = "my name is %(name)s" % {"name":'xiaoming'} >>> print(s) my name is xiao

python基础-生成随机字符串方法

python解释器示例 1 >>> import uuid 2 >>> uuid.uuid1() 3 UUID('ae6822e6-c976-11e6-82e0-0090f5f61084') 4 >>> uuid.uuid1() 5 UUID('af72c0a2-c976-11e6-b69e-0090f5f61084') 6 >>> uuid.uuid1() 7 UUID('afd03ab6-c976-11e6-8475-0090f5

Python基础（数字,字符串方法）

数字: 1 #二进制转十进制 2 a='100' 3 v=int(a,base=2) 4 print(v) 进制转换 1 #当前数字的二进制至少有多少位 2 b=2 3 v2=b.bit_length() 4 print(v2) 数值二进制表示位数 字符串: 1 #首字母大写 2 a="kelvin" 3 v=a.capitalize() 4 print(v) 首字母大写 1 #终极无敌'大写'变'小写'---->casefold 2 b="KELVIN" 3

Python基础 —— 目录

Python基础 Python基础 -- 基本数据类型 Python基础 -- 基本数据类型的方法总结 Python基础 -- 比较运算符 + 逻辑运算符 Python基础 -- 异常处理 Python基础 -- 常用模块 Python基础 -- 模块和包 Python基础 -- PIL模块 Python基础 -- 装饰器函数 Python基础 -- 内置函数 Python基础 -- range()/xrange() 面向对象 -- 特殊且重要的双下方法 面向对象 -- 类的成员.成员修饰符.特

Python基础教程（第九章 魔法方法、属性和迭代器）

本文内容全部出自<Python基础教程>第二版,在此分享自己的学习之路. ______欢迎转载:http://www.cnblogs.com/Marlowes/p/5437223.html______ Created on Marlowes 在Python中,有的名称会在前面和后面都加上两个下划线,这种写法很特别.前面几章中已经出现过一些这样的名称(如__future__),这种拼写表示名字有特殊含义,所以绝不要在自己的程序中使用这样的名字.在Python中,由这些名字组成的集合所包含的方法称