Task08：模块与datetime模块(2天)

正文

一、模块

1.什么是模块

1 容器 -> 数据的封装
2 函数 -> 语句的封装
3 类 -> 方法和属性的封装
4 模块 -> 程序文件

也就是说模块就是一个程序文件

# 创造一个hello.py文件
def hi():
    print('Hi everyone, I love lsgogroup!')

2.命名空间

1 内置命名空间（Built-in Namespaces）：Python 运行起来，它们就存在了。内置函数的命名空间都属于内置命名空间，所以，我们可以在任何程序中直接运行它们，比如id(),不需要做什么操作，拿过来就直接使用了。
2 全局命名空间（Module：Global Namespaces）：每个模块创建它自己所拥有的全局命名空间，不同模块的全局命名空间彼此独立，不同模块中相同名称的命名空间，也会因为模块的不同而不相互干扰。
3 本地命名空间（Function & Class：Local Namespaces）：模块中有函数或者类，每个函数或者类所定义的命名空间就是本地命名空间。如果函数返回了结果或者抛出异常，则本地命名空间也结束了。

程序在查询上述三种命名空间的时候，就按照从里到外的顺序，即：Local Namespaces --> Global Namesspaces --> Built-in Namesspaces。

import hello

hello.hi()  # Hi everyone, I love lsgogroup!
hi()  # NameError: name 'hi' is not defined

3.导入模块

首先创建一个模块TemperatureConversion.py

# TemperatureConversion.py
def c2f(cel):
    fah = cel * 1.8 + 32
    return fah


def f2c(fah):
    cel = (fah - 32) / 1.8
    return cel

（1）import 模块名

import TemperatureConversion

print('32摄氏度 = %.2f华氏度' % TemperatureConversion.c2f(32))
print('99华氏度 = %.2f摄氏度' % TemperatureConversion.f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

（2）from 模块名import 函数名

from TemperatureConversion import c2f, f2c

print('32摄氏度 = %.2f华氏度' % c2f(32))
print('99华氏度 = %.2f摄氏度' % f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

（3）from 模块名import *

from TemperatureConversion import *

print('32摄氏度 = %.2f华氏度' % c2f(32))
print('99华氏度 = %.2f摄氏度' % f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

（4）import 模块名 as 新名字

import TemperatureConversion as tc

print('32摄氏度 = %.2f华氏度' % tc.c2f(32))
print('99华氏度 = %.2f摄氏度' % tc.f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

4. if name == 'main'

对于很多编程语言来说，程序都必须要有一个入口，而 Python 则不同，它属于脚本语言，不像编译型语言那样先将程序编译成二进制再运行，而是动态的逐行解释运行。也就是从脚本第一行开始运行，没有统一的入口

假设我们有一个 const.py 文件，内容如下：

PI = 3.14

def main():
    print("PI:", PI)

main()
# PI: 3.14

现在，我们写一个用于计算圆面积的 area.py 文件，area.py 文件需要用到 const.py 文件中的 PI 变量。从 const.py 中，我们把 PI 变量导入 area.py：

from const import PI

def calc_round_area(radius):
    return PI * (radius ** 2)

def main():
    print("round area: ", calc_round_area(2))

main()

'''
PI: 3.14
round area:  12.56
'''

我们看到 const.py 中的 main 函数也被运行了，实际上我们不希望它被运行，因为 const.py 提供的 main 函数只是为了测试常量定义。这时if __name__ == '__main__'派上了用场，我们把 const.py 改一下，添加if __name__ == "__main__"：

PI = 3.14

def main():
    print("PI:", PI)

if __name__ == "__main__":
    main()

运行 const.py，输出如下：

PI: 3.14

运行 area.py，输出如下：

round area:  12.56

__name__：是内置变量，可用于表示当前模块的名字。

import const

print(__name__)
# __main__

print(const.__name__)
# const

由此我们可知：如果一个 .py 文件（模块）被直接运行时，其__name__值为__main__，即模块名为__main__。

所以，if __name__ == '__main__'的意思是：当 .py 文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当 .py 文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

5.搜索路径

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

import sys

print(sys.path)

# ['C:\\ProgramData\\Anaconda3\\DLLs', 'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages',...]

我们使用 import 语句的时候，Python 解释器是怎样找到对应的文件的呢？

这就涉及到 Python 的搜索路径，搜索路径是由一系列目录名组成的，Python 解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

搜索路径是在 Python 编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量中。

6.包（package）

包是一种管理 Python 模块命名空间的形式，采用"点模块名称

创建包分为三个步骤：

1 创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字。
2 在文件夹中创建一个 __init__.py 的模块文件，内容可以为空。
3 将相关的模块放入文件夹中。

导入方式和模块差不多

二、datetime模块

1.datetime类

class datetime(date):
    def __init__(self, year, month, day, hour, minute, second, microsecond, tzinfo)
        pass
    def now(cls, tz=None):
        pass
    def timestamp(self):
        pass
    def fromtimestamp(cls, t, tz=None):
        pass
    def date(self):
        pass
    def time(self):
        pass
    def year(self):
        pass
    def month(self):
        pass
    def day(self):
        pass
    def hour(self):
        pass
    def minute(self):
        pass
    def second(self):
        pass
    def isoweekday(self):
        pass
    def strftime(self, fmt):
        pass
    def combine(cls, date, time, tzinfo=True):
        pass

方法整理如下：

要记住，前面要加上datetime.

 1 datetime.now(tz=None) 获取当前的日期时间，输出顺序为：年、月、日、时、分、秒、微秒。
 2 datetime.timestamp() 获取以 1970年1月1日为起点记录的秒数。也就是说要接受一个日期时间，然后使用这个日期时间去减19700101，返回的是相减的秒数
 3 datetime.fromtimestamp(tz=None) 使用 unixtimestamp 创建一个 datetime。要接受一个时间戳（相差的秒数），返回的是对应的日期，可以说是上面的逆操作
 4 datetime.strftime(fmt) 格式化 datetime 对象，即是可以变成你想要的展示格式
 5 datetime.date() Return the date part.
 6 datetime.time() Return the time part, with tzinfo None.
 7 datetime.year 年
 8 datetime.month 月
 9 datetime.day 日
10 datetime.hour 小时
11 datetime.minute 分钟
12 datetime.second 秒
13 datetime.isoweekday 星期几
14 parser.parse(timestr, parserinfo=None, **kwargs)

例子

import datetime as dt
dt.datetime.now()
dt.datetime.timestamp()  #TypeError: descriptor 'timestamp' of 'datetime.datetime' object needs an argument
dt.datetime.now().timestamp()    #1597042527.040217  化成时间戳，
dt.datetime.fromtimestamp()  #TypeError: fromtimestamp() missing required argument 'timestamp' (pos 1)，要接受一个时间戳参数
dt.datetime.fromtimestamp(1597042527.040217)  #datetime.datetime(2020, 8, 10, 14, 55, 27, 40217)

也可以这样子表达

import datetime as dt
dt.datetime.now()
dt.datetime.timestamp(dt.datetime.now())  #1600840990.871466

`datetime.strftime(fmt)` 格式化 datetime 对象

 1 %a    本地简化星期名称（如星期一，返回 Mon）
 2 %A    本地完整星期名称（如星期一，返回 Monday）
 3 %b    本地简化的月份名称（如一月，返回 Jan）
 4 %B    本地完整的月份名称（如一月，返回 January）
 5 %c    本地相应的日期表示和时间表示
 6 %d    月内中的一天（0-31）
 7 %H    24小时制小时数（0-23）
 8 %I    12小时制小时数（01-12）
 9 %j    年内的一天（001-366）
10 %m    月份（01-12）
11 %M    分钟数（00-59）
12 %p    本地A.M.或P.M.的等价符
13 %S    秒（00-59）
14 %U    一年中的星期数（00-53）星期天为星期的开始
15 %w    星期（0-6），星期天为星期的开始
16 %W    一年中的星期数（00-53）星期一为星期的开始
17 %x    本地相应的日期表示
18 %X    本地相应的时间表示
19 %y    两位数的年份表示（00-99）
20 %Y    四位数的年份表示（0000-9999）
21 %Z    当前时区的名称（如果是本地时间，返回空字符串）
22 %%    %号本身

如何将 datetime 对象转换为任何格式的日期

import datetime
#datetime.datetime的参数如下：
datetime.datetime(year=2020, month=6, day=25, hour=11, minute=51, second=49)
dt=datetime.datetime.now()
dt.strftime('%Y-%m-%d %H:%M:%S')  #'2020-08-10 15:04:41'
dt.strftime('%Y%m%d %H:%M:%S')  #'20200810 15:04:41'
dt.strftime('%d %B, %Y, %A')  #'10 August, 2020, Monday'
dt.strftime('%B-%d, %Y') #  'August-10, 2020'

也可以接受日期时间的参数

dt.datetime.strftime(dt.datetime.now(),'%Y-%m-%d %H:%M:%S')
#'2020-09-23 14:05:18'

datetime 对象包含很多与日期时间相关的实用功能

如果想要得到一个datetime.datetime类型的日期，这要这样表达，而不可以直接输入一个日期

import datetime

dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=51, second=49)
type(dt)
#datetime.datetime
datetime.datetime('2020-09-23')
#TypeError: an integer is required (got type str)

import datetime

dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=51, second=49)
print(dt.date())  # 2020-06-25
print(type(dt.date()))  # <class 'datetime.date'>
print(dt.time())  # 11:51:49
print(type(dt.time()))  # <class 'datetime.time'>
print(dt.year)  # 2020
print(dt.month)  # 6
print(dt.day)  # 25
print(dt.hour)  # 11
print(dt.minute)  # 51
print(dt.second)  # 49
print(dt.isoweekday())  # 4

在处理含有字符串日期的数据集或表格时，我们需要一种自动解析字符串的方法，无论它是什么格式的，都可以将其转化为 datetime 对象。这时，就要使用到 dateutil 中的 parser 模块。

parser.parse(timestr, parserinfo=None, **kwargs)

如何在 python 中将字符串解析为 datetime对象？

from dateutil import parser

s = '2020-06-25'
dt = parser.parse(s)
print(dt)  # 2020-06-25 00:00:00
print(type(dt))  # <class 'datetime.datetime'>

s = 'March 31, 2010, 10:51pm'
dt = parser.parse(s)
print(dt)  # 2010-03-31 22:51:00
print(type(dt))  # <class 'datetime.datetime'>

计算以下列表中连续的天数。

import numpy as np
from dateutil import parser

dateString = ['Oct, 2, 1869', 'Oct, 10, 1869', 'Oct, 15, 1869', 'Oct, 20, 1869', 'Oct, 23, 1869']
dates = [parser.parse(i) for i in dateString]
td = np.diff(dates)
print(td)
# [datetime.timedelta(days=8) datetime.timedelta(days=5)
#  datetime.timedelta(days=5) datetime.timedelta(days=3)]
d = [i.days for i in td]
print(d)  # [8, 5, 5, 3]

2.date类

class date:
    def __init__(self, year, month, day):
        pass
    def today(cls):
        pass

date.today() 获取当前日期信息

如何在 Python 中获取当前日期和时间？

import datetime

d = datetime.date(2020, 6, 25)
print(d)  # 2020-06-25
print(type(d))  # <class 'datetime.date'>

d = datetime.date.today()
print(d)  # 2020-06-25
print(type(d))  # <class 'datetime.date'>

如何统计两个日期之间有多少个星期六？

import datetime

d1 = datetime.date(1869, 1, 2)
d2 = datetime.date(1869, 10, 2)
dt = (d2 - d1).days
print(dt)
print(d1.isoweekday())  # 6
print(dt // 7 + 1)  # 40

讲义里面就只有这些信息，我觉得不够，就找了点资料补充一下

date类是一个日期类，由年、月、日组成。由于Python也是面向对象编程语言，所以针对类，就会有构造函数，该类的构造函数如下：
class datetime.date(year, month, day):
year : 表示年,范围[MINYEAR, MAXYEAR]，即[1, 9999]
month : 表示月，范围[1, 12]
day ：一月中第几天，最大值根据给定的year，month参数来决定。例如闰年2月份有29天

datetime.date.max和print datetime.date.min：date对象所能表示的最大最小日期，返回的是datetime.date类型的对象

import datetime
datetime.date.max  #datetime.date(9999, 12, 31)
datetime.date.min  #datetime.date(1, 1, 1)

datetime.date.today()：返回一个当前本地日期的date类型的对象

datetime.date.today()  #datetime.date(2020, 8, 10)

date.fromtimestamp()函数：根据给定的时间戳，返回一个date对象

import time
datetime.date.fromtimestamp(time.time())
#datetime.date(2020, 8, 10)

date.weekday()函数：参数必须是一个date类型的对象，返回该日期是一周中的第几天。返回值是一个整型。星期一，返回0；星期二，返回1。。。

 s=datetime.date.today()
 type(s)  #<type 'datetime.date'>
 datetime.date.weekday(s)  #0

date.isoweekday()函数：该函数需要一个datetime.date类型的参数。返回weekday中的星期几，星期一，返回1；星期二，返回2；以此类推

s=datetime.date.today()
datetime.date.isoweekday(s)  #1

date.isocalendar（）函数：该函数需要一个datetime.date类型的参数。返回date类型对象中的year（年），week（周），weekday（一周中的第几天），返回值是一个元组

 s=datetime.date.today()
 datetime.date.isocalendar(s)  #(2020, 33, 1)
 datetime.date.isocalendar(s)[1]   #第几周  33

date.strftime(fmt) 返回自定义格式的时间字符串。fmt是自定义的时间格式（前面有，不赘述了）

.replace(year, month, day)：生成一个新的日期对象用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）

s=datetime.date.today()
s.replace(year=2017)  #datetime.date(2017, 8, 10)
s  #datetime.date(2020, 8, 10)

日期的其他操作--日期加上一个时间间隔（datetime.timedela类的对象)

s=datetime.date.today()
s+datetime.timedelta(days=10)  #Out[231]: datetime.date(2020, 8, 20)
s-datetime.timedelta(days=10)  #datetime.date(2020, 7, 31)

日期的其他操作--两个date类型对象相减。返回两个日期的间隔对象，即：datetime.timedelta类型的对象

date1=datetime.date.today()
date2=date1.replace(day=19)
date1-date2  #datetime.timedelta(days=-9)

3.time类

class time:
    def __init__(self, hour, minute, second, microsecond, tzinfo):
        pass

如何使用 datetime.time() 类？

import datetime

t = datetime.time(12, 9, 23, 12980)
print(t)  # 12:09:23.012980
print(type(t))  # <class 'datetime.time'>

注意：

1秒 = 1000 毫秒（milliseconds）
1毫秒 = 1000 微妙（microseconds）

如何将给定日期转换为当天开始的时间？

import datetime

date = datetime.date(2019, 10, 2)
dt = datetime.datetime(date.year, date.month, date.day)
print(dt)  # 2019-10-02 00:00:00

dt = datetime.datetime.combine(date, datetime.time.min)
print(dt)  # 2019-10-02 00:00:00

4.timedelta类

timedelta 表示具体时间实例中的一段时间。你可以把它们简单想象成两个日期或时间之间的间隔。

它常常被用来从 datetime 对象中添加或移除一段特定的时间。

class timedelta(SupportsAbs[timedelta]):
    def __init__(self, days, seconds, microseconds, milliseconds, minutes, hours, weeks,):
        pass
    def days(self):
        pass
    def total_seconds(self):
        pass

如何使用 datetime.timedelta() 类？

import datetime

td = datetime.timedelta(days=30)
print(td)  # 30 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>
print(datetime.date.today())  # 2020-07-01
print(datetime.date.today() + td)  # 2020-07-31

dt1 = datetime.datetime(2020, 1, 31, 10, 10, 0)
dt2 = datetime.datetime(2019, 1, 31, 10, 10, 0)
td = dt1 - dt2
print(td)  # 365 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>

td1 = datetime.timedelta(days=30)  # 30 days
td2 = datetime.timedelta(weeks=1)  # 1 week
td = td1 - td2
print(td)  # 23 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>

【练习】

距离你出生那天过去多少天了？
距离你今年的下一个生日还有多少天？
将距离你今年的下一个生日的天数转换为秒数。

from dateutil import parser
import datetime

bDay = 'Oct 2, 1969'
dt1 = parser.parse(bDay).date()
dt2 = datetime.date.today()
dt3 = datetime.date(dt2.year, dt1.month, dt1.day)
print(dt1)  # 1969-10-02
print(dt2)  # 2020-07-01
print(dt3)  # 2020-10-02

td = dt2 - dt1
print(td.days)  # 18535
td = dt3 - dt2
print(td.days)  # 93
print(td.days * 24 * 60 * 60)  # 8035200
print(td.total_seconds())  # 8035200.0

练习题：

1、假设你获取了用户输入的日期和时间如2020-1-21 9:01:30，以及一个时区信息如UTC+5:00，均是str，请编写一个函数将其转换为timestamp：

题目说明:

2、编写Python程序以选择指定年份的所有星期日。

题目说明:

def all_sundays(year):
    import datetime 
    dt1=datetime.date(year,1,1)
    dt2=datetime.date(year,12,31)
    for i in range((dt2-dt1).days+1):
        if datetime.date.isoweekday(dt1+datetime.timedelta(days=i))==7:
            print((dt1+datetime.timedelta(days=i)).strftime('%Y-%m-%d'))

            
all_sundays(2020)

posted on 2020-08-07 17:44 小小喽啰阅读(385) 评论(0) 编辑收藏举报

Task08：模块与datetime模块(2天)

目录

正文

一、模块

1.什么是模块

2.命名空间

3.导入模块

（1）import 模块名

（2）from 模块名import 函数名

（3）from 模块名import *

（4）import 模块名 as 新名字

4. if name == 'main'

5.搜索路径

6.包（package）

二、datetime模块

1.datetime类

要记住，前面要加上datetime.

`datetime.strftime(fmt)` 格式化 datetime 对象

如何将 datetime 对象转换为任何格式的日期

如果想要得到一个datetime.datetime类型的日期，这要这样表达，而不可以直接输入一个日期

如何在 python 中将字符串解析为 datetime对象？

2.date类

3.time类

4.timedelta类

搜索

常用链接

最新随笔

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

Task08：模块与datetime模块(2天)

目录

正文

一、模块

1.什么是模块

2.命名空间

3.导入模块

（1）import 模块名

（2）from 模块名import 函数名

（3）from 模块名import *

（4）import 模块名 as 新名字

4. if __name__ == '__main__'

5.搜索路径

6.包（package）

二、datetime模块

1.datetime类

要记住，前面要加上datetime.

datetime.strftime(fmt) 格式化 datetime 对象

如何将 datetime 对象转换为任何格式的日期

如果想要得到一个datetime.datetime类型的日期，这要这样表达，而不可以直接输入一个日期

如何在 python 中将字符串解析为 datetime对象？

2.date类

3.time类

4.timedelta类

搜索

常用链接

最新随笔

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

4. if name == 'main'

`datetime.strftime(fmt)` 格式化 datetime 对象