DataWhale7月学习——Python入门

Task8：模块与datetime模块

本节我们初步学习Python语法中的模块与datetime模块。文章给出了一些重点知识的.py程序便于读者深入理解。本文的程序编写基于Python3.0+，安装环境使用的是PyCharm。

模块

模块是一个包含所有定义的函数和变量的文件，其后缀是.py。模块可以被别的程序引入，以使用该模块中的函数等功能，这也是Python标准库的方法。
容器–>数据的封装
函数–>语句的封装
类–>方法和语句的封装
模块–>程序文件

创建模块和命名空间

创建一个hello.py文件

# hello.py
def hi():
   print('Hi everyone, I love lsgogroup!')

命名空间因对象的不同，也有所区别，分为以下几种：
内置命名空间：内置函数的命名空间都属于内置命名空间，可以在任何程序中直接运行它们，比如id()
全局命名空间：每个模块创建它所拥有的全局命名空间，不同模块的全局命名空间彼此独立，不同模块相同名称的命名空间，也会因为模块的不同而不相互打扰
本地命名空间：模块中有函数或者类，每个函数或者类所定义的命名空间就是本地命名空间。如果函数返回了结果或者抛出异常，则本地命名空间也结束了

import hello

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

导入模块

创建一个模块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. import 模块名 as 新名字

import TemperatureConversion as tc
print('32摄⽒度 = %.2f华⽒度' % tc.c2f(32))
print('99华⽒度 = %.2f摄⽒度' % tc.f2c(99))
# 32摄⽒度 = 89.60华⽒度
# 99华⽒度 = 37.22摄⽒度

if name == ‘main’

if name == 'main’的意思是：当.py文件被直接运行时，if name == 'main’之下的代码块将被运行，当.py文件以模块形式被导入时，if name == 'main’之下的代码块将不被运行
假设我们有一个const.py文件

PI = 3.14
def main():
   print("PI:", PI)
main()
# PI: 3.14

写一个用于计算圆面积的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()也运行了，我们不希望它被运行，此时就要用到if name == ‘main’：

PI = 3.14
def main():
   print("PI:", PI)
if __name__ == "__main__":
   main()

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

import const
print(__name__)
# __main__
print(const.__name__)
# const

包(Package)

包是一种管理Python模块命名空间的形式，采用“点模块名称”
创建包分为三个步骤：
1.创建一个文件夹，用于存放相关模块，文件夹的名字即为包的名字
2.在文件夹中创建一个__init__.py的莫魁岸文件，内容为空
3.将相关文件放入文件夹中
导入一个包时，Python会根据sys.path中的目录来寻找这个包中包含的子目录
目录只有一个包含__init__.py的文件才被认为是一个包（最简单的情况是放一个空的__init__.py）
导入子模块sound.effects.echo：

import sound.effects.echo

必须使用全名取访问：

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

导入子模块echo：

from sound.effects import echo
echo.echofilter(input, output, delay=0.7, atten=4)

还有一种方法是直接导入一个函数或者变量：

from sound.effects.echo import echofilter
echofilter(input, output, delay=0.7, atten=4)

注意：当使用from package import item这种形式时，对应的item既可以是包里面的子模块（子包），或者包里面其他定义的名称，如函数、类或者变量
导入语句遵循以下规则：如果包定义文件__init__.py存在一个叫做__all__的列表变量，那么在使用from package import *的时候就不会导入sound.effects里任何的子模块，只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

上例中，from…import前， 包sound.effects中的echo和surround模块都被导入到当前的命名空间中

datetime模块

datetime模块是Python中处理日期的标准模块，提供了四种对日期和实践处理的类：datetime、date、time和timedelta

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.now(tz=None)获取当前的日期时间，顺出顺序为：年、月、日、时、分、秒、微秒
datetime.timestamp()获取以1970年1月1日为起点记录的秒数
datetime.fromtimestamp(tz=None)使用unixtimestamp创建一个datetime

创建一个datetime对象

import datetime
dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=23, second=59)
print(dt) # 2020-06-25 11:23:59
print(dt.timestamp()) # 1593055439.0
dt = datetime.datetime.fromtimestamp(1593055439.0)
print(dt) # 2020-06-25 11:23:59
print(type(dt)) # <class 'datetime.datetime'>
dt = datetime.datetime.now()
print(dt) # 2020-06-25 11:11:03.877853
print(type(dt)) # <class 'datetime.datetime'>

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

import datetime
dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=51, second=49) 
s = dt.strftime("'%Y/%m/%d %H:%M:%S")
print(s) # '2020/06/25 11:51:49
s = dt.strftime('%d %B, %Y, %A')
print(s) # 25 June, 2020, Thursday

将给定日期转换为“mmm-dd,YYYY”的格式

import datetime
d1 = datetime.date(2010, 9, 28)
print(d1.strftime('%b-%d,%Y'))
# Sep-28,2010

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

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

在处理含有字符串日期的数据集或表格时，使用dateutil中的parser模块自动解析字符串，将其转换为datetime对象
parser.parse(timestr, parserinfo=None, **kwargs)

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

将字符串日期转换为datetime对象：

from dateutil import parser
s1 = "2010 Jan 1"
s2 = '31-1-2000'
s3 = 'October10, 1996, 10:40pm'
dt1 = parser.parse(s1)
dt2 = parser.parse(s2)
dt3 = parser.parse(s3)
print(dt1) # 2010-01-01 00:00:00
print(dt2) # 2000-01-31 00:00:00
print(dt3) # 1996-10-10 22:40:00

计算下列表中连续的天数：

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]

date类

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

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

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

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

例：将给定日期转换为当天开始的时间

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

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

将两个datetime对象相减可以得到改时间间隔的timedelta对象；
将两个时间间隔相减也可以得到timedelta对象

练习题

模块

1.怎么查出通过 from xx import xx导⼊的可以直接调⽤的⽅法？
当包内的__init__.py模块下有__all__列表时，则为__all__列表内定义的所有子模块。没有__all__列表时，需要看__init__.py内的代码做具体判断
2.了解Collection模块

from collections import Counter
def most_element(language):
    """ Return a list of lines after inserting a word in a specific line. """
    obj = Counter(language)
    ret = obj.most_common(1)
    return (ret[0][0])
    # your code here

language = ['PHP', 'PHP', 'Python', 'PHP', 'Python', 'JS', 'Python', 'Python','PHP', 'Python']
final = most_element(language)
print(final)

datetime模块

import re
from datetime import datetime, timezone, timedelta

def to_timestamp(dt_str, tz_str):
    # 首先，获取用户输入的时间的datetime
    input_dt = datetime.strptime(dt_str, '%Y-%m-%d %H:%M:%S')

    # 上面得到的datetime是没有时区的，因此设置用户输入的对应时区
    # 那么此时需要利用正则获取用户输入的时区
    time_zone_num = re.match(r'UTC([+|-][\d]{1,2}):00', tz_str).group(1)
    time_zone = timezone(timedelta(hours=int(time_zone_num)))  # 创建时区UTC-？？

    # 将上面得到的datetime强制设置为UTC-？？
    input_dt_tz = input_dt.replace(tzinfo=time_zone)
    
    return input_dt_tz.timestamp()

t1 = to_timestamp('2015-6-1 08:10:30', 'UTC+7:00')
assert t1 == 1433121030.0, t1
t2 = to_timestamp('2015-5-31 16:10:30', 'UTC-09:00')
assert t2 == 1433121030.0, t2

from datetime import date, timedelta

def all_sundays(year):
   d = date(year, 1, 5)                    # January 5th
   d += timedelta(days = 6 - d.weekday())  # First Sunday
   while d.year == year:
      yield d
      d += timedelta(days = 7)

for d in all_sundays(2020):
   print(d)