5.Python基础学习笔记day5-栈队列、模块包、与时间模块

5.Python基础学习笔记day5-栈队列、模块包、与时间模块

一、栈与队列

'''
栈：先进后出
'''
#创建栈，使用列表来模仿栈
mystack = []
# 入栈
mystack.append(1)
#出栈
print(mystack.pop())

# # 1、递归遍历文件夹


def getalldir(path, str1=""):
    listdir = os.listdir(path)
    str1 += "\t"
    for filename in listdir:
        fileabspath = os.path.join(path, filename)
        if os.path.isdir(fileabspath):
            print(str1+"目录："+filename)
            getalldir(fileabspath, str1)
        else:
            print(str1+"文件："+filename)



# # 2、栈模拟递归遍历目录(深度遍历)
def getstackdir(path):
    # 创建栈
    mystack = []
    # 将根目录入栈
    mystack.append(path)
    # 判断栈是否为空
    while mystack:
        print(mystack)
        # 将栈中元素出栈
        filepath = mystack.pop()
        # 列举当前目录下所有的文件
        fileList = os.listdir(filepath)
        # 循环遍历
        for filename in fileList:
            # 获取绝对路径
            abspath = os.path.join(filepath,filename)
            # 判断是否为目录
            if os.path.isdir(abspath):
                # 打印
                print("目录",filename)
                # 将目录进行入栈处理
                mystack.append(abspath)
            else:
                print("文件",filename)
                

 '''
队列：先进先出
'''
import collections

# 创建队列
queue = collections.deque()

#入队
queue.append(1)

# 出队
print(queue.popleft())

import os
import collections

# # 3、队列模拟递归遍历目录(广度遍历)
def getqueuedir(path):
    # 创建队列
    queue = collections.deque()
    print(queue)
    # 将根目录入队
    queue.append(path)
    while queue:
        # 将路径出队
        filepath = queue.popleft()
        # 列举指定路径下所有文件
        filenameList = os.listdir(filepath)
        # 遍历所有的文件
        for filename in filenameList:
            # 获取绝对路径
            abspath = os.path.join(filepath,filename)
            # 判断该路径是否为目录
            if os.path.isdir(abspath):
                print("目录",filename)
                queue.append(abspath)
            else:
                print("文件",filename)

二、模块、包

'''
模块
定义：在python中一个.py文件就是一个模块。

模块划分：
内置模块：无须自己定义，无须安装，可以直接导入使用的模块，我们称之为内置模块
自定义模块：需要自己定义py文件
第三方模块：无须自己定义，但是需要安装的模块，我们称之为第三方模块。

模块优点：
1.提高代码的可维护性
2.提高代码的复用性
3.可以引入其他模块
4.可以避免函数名以及变量名的冲突
'''
'''
1、模块的导入[整体引入]
import 模块名
一次性导入多个模块：
import 模块1,模块2,模块3,...

引用模块中的函数以及变量
模块名.函数名(参数列表)
模块名.变量名

若模块名比较长的情况下，为了方便调用，我们可以给模块取一个别名
语法：
import 模块名 as 别名
函数的调用以及变量的使用：
别名.函数名(参数列表)
别名.变量

2、模块的导入【局部引入】
from 模块名  import 函数名,类名,变量名
使用此方式引入：
引用函数以及变量的时候语法:
函数名(参数列表)
变量名
注意：
使用这种方式导入，优点方便函数的调用，缺点可能会引起函数名的冲突
【因此使用此方式导入在给函数以及变量命名的时候要注意不要出现重名】

3、模块导入之*
from 模块名 import *
*：代表导入模块中所有函数以及变量
函数的引用
函数名(参数列表)
变量名
注意：一般情况下，不建议使用【特别容易造成函数名变量名的冲突】
'''


'''
包：为了解决模块名的冲突，python引入目录来组织模
块的方法，我们称之为包。
每个包目录下都会包含一个__init__.py文件，这个文件必须
存在，若不存在python会将其当成一个普通目录，而不是一个包
__init__.py文件可以是一个空文件也可以有内容。

自定义模块的时候，需要注意不能跟python自带的模块名冲突
自定义模块取名的时候，可以使用多个单词拼接的方式来取名
'''

三、时间模块

'''
UTC(世界协调时间)：格林尼治天文时间，世界标准时间，在中国来说是UTC+8
DST(夏令时)：是一种节约能源而人为规定时间制度，在夏季调快1个小时

时间的表示形式：
1、时间戳
以整型或浮点型表示时间的一个以秒为单位的时间间隔。这个时间间隔的基础值是从1970年1月1日领带开始算起

2、元组
一种Python的数据结构表示，这个元组有9个整型内容
year
month
day
hours
minutes
seconds
weekday
Julia day
flag  (1 或 -1 或0)

3、格式化字符串
%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  时区的名字（如果不存在为空字符）
%%  ‘%’字符

'''
'''
4、time模块
'''

# 返回当前时间的时间戳，浮点数形式，不需要参数
c = time.time()
print(c)  # 1560949768.4027708

# 将时间戳转为UTC时间元组
t = time.gmtime(c)
print(t)  # time.struct_time(tm_year=2019, tm_mon=6, tm_mday=19, tm_hour=13, tm_min=9, tm_sec=28, tm_wday=2, tm_yday=170, tm_isdst=0)

# 将时间戳转为本地时间元组
b = time.localtime(c)
print(b)  # time.struct_time(tm_year=2019, tm_mon=6, tm_mday=19, tm_hour=21, tm_min=9, tm_sec=28, tm_wday=2, tm_yday=170, tm_isdst=0)


# 将时间元组转换成给定格式的字符串，参数2为时间元组，如果没有参数2，默认转当前时间
q = time.strftime("%Y-%m-%d %X")
print(q)  # 2019-06-19 21:10:48
print(type(q))  # <class 'str'>



# 将时间字符串转为时间元组
w = time.strptime(q, "%Y-%m-%d %X")
print(w)  # time.struct_time(tm_year=2019, tm_mon=6, tm_mday=19, tm_hour=21, tm_min=17, tm_sec=14, tm_wday=2, tm_yday=170, tm_isdst=-1)


# 将本地时间元组转成时间戳
m = time.mktime(b)
print(m)  # 1560950234.0

'''
5、datetime模块
'''
'''
datetime.now()
功能：获取当前系统时间，返回datetime类型

datetime(year,mon,day,hour,min,sec)
功能：将指定的时间转为datetime对象

dt.strftime("%Y-%m-%d %X")
功能：将datetime对象格式化为时间字符串

dtime = dt-dt2
功能：两个datetime对象相减返回一个时间间隔对象

dtime.days 两个时间相隔的天数
dtime.seconds 除天数之外剩余的秒数

'''

dt = datetime.now()  
print(dt)  # 2019-06-20 19:51:48.555544
print(type(dt))  # <class 'datetime.datetime'>

dtstr = str(dt)  
print(dtstr)  # 2019-06-20 19:51:48.555544
print(type(dtstr))  # <class 'str'>

dt2 = datetime(2019,6,16,10,10,10)
print(dt2)  # 2019-06-16 10:10:10

strdt = dt.strftime("%Y-%m-%d %X")
print(strdt)  # 2019-06-20 19:51:48

print("*"*50)
print(datetime.strptime("2019-06-20", "%Y-%m-%d"))  # 2019-06-20 00:00:00

dtime = dt-dt2
print(dtime)  # 4 days, 9:41:38.555544
print(type(dtime))  # <class 'datetime.timedelta'>
print(dtime.days)  # 4
print(dtime.seconds)  # 34898



'''
calendar模块
'''
'''
calendar.calendar(year)
功能:返回指定年份的日历（以字符串的形式）

calendar.month(year,mon)
功能：返回指定月份的日历（以字符串的形式）


calendar.isleap(year)
功能：判断指定年份是否为闰年，若是则返回True，否则返回False

calendar.leapdays(year1,year2)
功能：返回[year1,year2)中闰年的个数

calendar.monthrange(year,mon)
功能：返回该月第一天的星期码与该月的天数，以元组的形式返回。

calendar.monthcalendar(year,mon)
功能：返回某月以每一周为元素的序列，若这天没有则使用0来进行占位

calendar.weekday(year,mon,day)
功能：返回指定日期的星期码
'''

import calendar

year = calendar.calendar(2019)
print(year)
'''
                                  2019

      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  2  3  4  5  6                   1  2  3                   1  2  3
 7  8  9 10 11 12 13       4  5  6  7  8  9 10       4  5  6  7  8  9 10
14 15 16 17 18 19 20      11 12 13 14 15 16 17      11 12 13 14 15 16 17
21 22 23 24 25 26 27      18 19 20 21 22 23 24      18 19 20 21 22 23 24
28 29 30 31               25 26 27 28               25 26 27 28 29 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  3  4  5  6  7             1  2  3  4  5                      1  2
 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9
15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16
22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23
29 30                     27 28 29 30 31            24 25 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  3  4  5  6  7                1  2  3  4                         1
 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8
15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15
22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22
29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29
                                                    30

      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  2  3  4  5  6                   1  2  3                         1
 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8
14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15
21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22
28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29
                                                    30 31

'''
print(type(year))  # <class 'str'>

mon = calendar.month(2019,6)
print(mon)
'''
     June 2019
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
'''
print(calendar.isleap(2100))  # False

print(calendar.leapdays(2000, 2019))  # 5

print(calendar.monthrange(2019,6))  # (5, 30)
print(calendar.monthrange(2019,7))  # (0, 31)
print(calendar.monthcalendar(2019,6))  
# [[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]]

print(calendar.weekday(2019, 6, 17))  # 0