Python基礎知識之二

• 幾個小作業
• 時間下一秒：

timeStart = input()

timeList = timeStart.split(":")

h = int(timeList[0])
m = int(timeList[1])
s = int(timeList[2])
if h > 23 or m > 59 or s > 59:
    print("Input Error")
else:
    s += 1
    if s == 60:
        m += 1
        s = 0
        if m == 60:
            h += 1
            m = 0
            if h == 24:
                h = 0
     print("%.2d:%.2d:%.2d" %(h, m, s))

• 簡單的歌詞處理

musicLrc = """[00:00.08]傳奇
[02:05.00][00:01.74]只因為在人群中多看了你一眼
[02:12.47][00:08.86]再也沒能忘掉你的容顏
[02:19.97][00:16.53]夢想著偶然能有一天再相見
[02:27.36][00:23.89]從此我開始孤單思念
[02:32.40][00:29.51]

[02:34.45][00:31.58]想你時你在天邊
[02:42.00][00:38.30]想你時你在眼前
[02:49.63][00:46.24]想你時你在腦海
[02:57.56][00:53.78]想你時你在心田
[03:04.94][01:01.28]寧願相信我們前世有約
[03:11.37][01:07.75]今生的愛情故事不會再改變
[03:19.85][01:16.25]願用這一生等你發現
[03:29.26][01:22.79]我一直在你身旁從未走遠 
[03:38.08]只是因為在人群中多看了你一眼
[01:33.38]
[01:35.85]
[01:40.22]
[01:49.25]
"""

musicLrcList = musicLrc.splitlines()

lrcDict = {}

for lrcLine in musicLrcList:
    lrcLineList = lrcLine.split("]")
    for index in range(len(lrcLineList) -1 ):
        timeStart = lrcLineList[index][1:]
        timeList = timeStart.split(":")
        time = float(timeList[0]) * 60 + float(timeList[1])
       # print(time)
        lrcDict[time] = lrcLineList[-1]

#print(lrcDict)

allTimeList = []
for t in lrcDict:
    allTimeList.append(t)
allTimeList.sort()
print(allTimeList)

while 1:
    getTime = float(input("Please input a time "))

    for n in range(len(allTimeList)):
        tempTime = allTimeList[n]
        if getTime < tempTime:
            break
    print(lrcDict[allTimeList[n - 1]])

• 嘗試著，使上面能夠自動播放
• set
• 類似於dict，是一組key的集合，但是不儲存value，表示的是無序並且無重複的集合；
• 建立,需要藉助於list或者tuple或者dict作為輸入的集合

//列表建立
s1 = set([1, 2, 3, 4, 5, 5, 5])

print(s1)    //對於重複元素在`set`中會被自動過濾

//元組建立
s1 = set([1, 2, 3, 4, 5, 5, 5])

print(s1)

//字典建立
s1 = set({1:"good", 2:"hello", 3:"hi"})
print(s1)

• set的新增

s1 = set({1:"good", 2:"hello", 3:"hi"})
s1.add(3)

• 允許新增重複元素，但是會自動去重，不支援新增列表，因為list裡面的記憶體是可變物件；所以不允許新增

s1.add([7, 8, 9])
s1.add({1:"1"})

• 但是允許新增

s1.add((7, 8, 9))

• 插入整個list tuple string插入

s1.update([6, 7, 8, 9, 10])
s1.update((9, 10))
s1.update("kali")
print(s1)

//輸出
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'i', 'a', 'k', 'l'}

• 刪除:刪除是不能夠通過下標進行刪除的,也就是不存在索引的

s1.remove(3)

• 可以通過迴圈遍歷得到裡面的元素

for value in s1:
    print(value)

• 可以通過enumerate來查詢裡面的資料

for index, data in enumerate(s1):
    print(index, data)

• set的運算
• 交集

s1 = set([1,2,3,4,5])
s2 = set([3,4,5,6,7,8])

s3 = s1 & s2
print(s3)
print(type(s3))

{3, 4, 5}
<class 'set'>

• 並集

s1 = set([1,2,3,4,5])
s2 = set([3,4,5,6,7,8])

s3 = s1 | s2

print(s3)
print(type(s3))

{1, 2, 3, 4, 5, 6, 7, 8}
<class 'set'>

• set多用於型別轉換,以及去重操作;

l1 = [1, 2, 3, 4, 5, 6]
s1 = set(l1)

l2 = list(s1)

t1 = (1, 2, 3, 4, 5, 6)
s2 = set(t1)

t1 = tuple(s2)

• 快速去重操作

list = list(set(list1))

• 迭代器:
  • 可迭代物件:表示可以直接作用於for迴圈的物件成為可迭代物件,(Iterable)可以使用isinstance()來判斷是否是Iterable;
  • 可以作用於for的資料型別一般分為兩種:
    • 1.集合資料型別,例如list tuple dict set string
    • 2.是generator,包括生成器和yeid的generator function

from collections import Iterable

print(isinstance([],Iterable))
print(isinstance({},Iterable))
print(isinstance((),Iterable))
print(isinstance("",Iterable))
print(isinstance((x for x in range(10)),Iterable))

True
True
True
True
True

• 迭代器:不但可以作用於for迴圈,還可以被next()函式不斷地呼叫,並且返回下一個值;迭代器最後會丟擲一個StopIteration錯誤,表示無法繼續返回下一個值;
• 迭代器就是可以被next()函式呼叫並且不斷的返回下一個值的物件成為迭代器,同樣可以使用isinstance()函式判斷一個物件是否是Iteratior物件,

print(isinstance([],Iterator))
print(isinstance({},Iterator))
print(isinstance((),Iterator))
print(isinstance("",Iterator))
print(isinstance((x for x in range(10)),Iterator))

False
False
False
False
True

• 迭代器的例子

value = (x for x in [1, 2, 3, 4, 5])
print(next(value))
print(next(value))
print(next(value))

1
2
3

• 將list tuple dict string都可以轉換成iter

list1 = [1, 2, 3, 4, 5, 6]
a = iter(list1)
print(next(a))

print(isinstance(iter([]),Iterator))
print(isinstance(iter({}),Iterator))
print(isinstance(iter(()),Iterator))
print(isinstance(iter(""),Iterator))

True
True
True
True

• 對於指定的換行符

endstr = "end"
str = ""

for line in iter(input, endstr):
    str += line + "\n"
print(str)

• 函式
• 函式概述:在一個完整的專案中,某些功能會反覆的使用,可以通過將這個功能封裝起來,當需要使用這個功能的時候,直接呼叫這個函式就可以了;
• 函式本質上就是對於功能的封裝;
• 1.函式簡化了程式碼結構,增加了程式碼的複用度;
• 2.如果需要修改某些功能,或者修改某個BUG,只要修改對應的函式;
• 定義函式:

def function name(arg, arg,...)

• 對於函式名需要遵循識別符號規則,傳入函式的引數必須和引數列表對應;():表示的引數列表的開始和結束;
• 函式功能使用:進行封裝;
• 語句:表示的函式封裝的功能
• return:一般用於結束函式,並且返回資訊給函式的呼叫者,如果省略,返回值就是None;return後面的程式碼是不會被列印的;
• 函式的呼叫:格式: 函式名(引數列表)
• 函式呼叫本質上就是實參給形參複製的過程;
• 函式的引數

def newPrint(str,age):
    print(str,age)
newPrint("today is a new day", 18)

• 形參:在定義函式時,()裡面的變數,本質上是變數;

• 實參:呼叫函式時,給函式傳遞的引數;

• 形參和實參個數不匹配時,就會出錯;

• 引數傳遞的分類:

  • 值傳遞:傳遞的是不可變型別,也就是常量型別,string tuple number

def newprint(value):
    print(id(value))
    value = 10
    print(id(value))
temp = 20
print(id(temp))

newprint(temp)
print(temp)


94471953863072
94471953863072
94471953862752
20

• 這種操作並不會改變,變數的值;

• 引用傳遞:傳遞的是可變型別,例如list dict set
  

def func2(lis):
    lis[0] = 100

list1 = [1, 2, 3, 4, 5]

func2(list1)

print(list1)

[100, 2, 3, 4, 5]

• 檢視變數這樣的一個過程

a = 10
b = 10

print(id(a), id(b))

b = 20

print(id(a), id(b))

a = 20

print(id(a), id(b))



94036689133664 94036689133664
94036689133664 94036689133984
94036689133984 94036689133984

• 關鍵字引數
• 如果定義的是關鍵字引數,那麼允許函式呼叫時的引數和定義時不一致

def newPrint(str, age):
    print(str, age)

newPrint(age = 10, str = "today is a new day")

today is a new day 10

• 預設引數:呼叫函式時,如果沒有傳遞引數,就是用預設引數,在使用預設引數時,應該將預設引數放在最後;

def newPrint(str = "hello", age = "12"):  
    print(str, age)

newPrint()

hello 12

• 不定長引數:傳遞的實參格式是不確定的,使用*變數的方式存放所有未命名的變數引數,如果在函式呼叫時,沒有指定引數,就是一個空元素;

def func(name, *arr):
    print(name)
    for x in arr:
        print(x)

func("xiaoxiao", "tiaodao", "handsom")

• 傳參多使用這種方式

def sumnum(*value):      
    sum = 0
    for x in value:
        sum += x
    return sum

print(sumnum(1,2,3,4,5))

15

• 如果需要傳遞字典關鍵字引數

def func(**kwargs):    //表示的鍵值對的引數字典;
    print(kwargs)
    print(type(kwargs))

func(x=1, y=2, z=3)

{'z': 3, 'y': 2, 'x': 1}
<class 'dict'>

• 匿名函式
• 不適用def這樣的語句定義函式,使用lambda來建立匿名函式,lambda只是一個表示式,函式體比def簡單;
• lambda的主體是一個表示式,而不是程式碼塊,僅僅只能在lambda表示式中封裝簡單的邏輯;
• lambda函式有自己的名稱空間,並且不能夠訪問自有引數列表之外的或者全域性名稱空間的引數;
• lambda和c和c++函式的行內函數不同;
• lambda格式

lambda 引數1,引數2,.... :expression

sum = lambda num1, num2:num1 + num2

print(sum(1, 2))

3

• 裝飾器
• 裝飾器本質上就是一個閉包,把函式當做引數返回一個替代版本的函式,本質上就是一個返回函式的函式;
• 底下這個是一個最簡單的裝飾器

def func1():
    print("sunck is a good man")

def func2(func):
    def inner():
        print("**********")
        func()
    return inner()

f = func2(func1)
f()

• 帶有變數傳參的裝飾器

def say(age):
    print("the number is %d" %(age))


def outter(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner

say = outter(say)
say(-10)

the number is 0

• 對於上面裝飾器規範的寫法

def outter(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner

@outter       //使用@將裝飾器應用到函式
def say(age):
    print("the number is %d" %(age))

say(-10)

• 通用裝飾器
• 對於函式的引數是沒有限制的,但是不建議超過6 7個

def outter(func):
    def inner(*args, **kwargs):

        func(*args, **kwargs)
    return inner

@outter
def say(name, age):
    print("the number is %d, the name is %s" %(age, name))

say("hello", 10)

• 偏函式
• 偏函式是用於實現對於某些引數值上面進行的一些控制

def intTranslate2(str, base = 2):
   return int(str, base)

print(intTranslate2("10010"))

• 偏函式是不需要自己進行定義的,通過使用內建的模組進行定義

import functools

intTranslate = functools.partial(int, base = 3)

value = intTranslate("10101")
print(value)

• 變數的作用域

• 作用域表示變數可以使用的範圍,變數並不是在在所有位置都能夠使用的,訪問的許可權決定於變數的位置

• 區域性作用域:

• 函式作用域:

• 全域性作用域:

• 內建作用域:

• 異常處理

• 異常表示的是對於某些特殊情況導致的程式有可能不能夠正常執行,需要處理這些異常,使程式能夠順利的執行下去,不至於因為異常崩潰;

• try.......except.....else

try 
	語句
except 錯誤碼 as e:
	語句2
.
.
else:
	語句

• else語句可有可無;用於檢測try語句中的錯誤,從而讓except語句來進行捕獲,從而進行處理;

• 當程式執行到try-except-else時:

  • 1.如果當try 語句執行出錯時,會匹配第一個錯誤碼,如果匹配上就會執行對應的語句;
  • 2.如果當錯誤碼都沒有匹配到,就會向上拋異常;
  • 3.如果沒有出現異常,就不會匹配異常,但是會執行else異常

• 常見的異常處理,是不使用錯誤型別的,都是希望跳過異常

• 使用except處理多個異常

try:
    pass
except (NameError,ZeroDivisionError):
    print("this is error")

• 異常的另一種方式

try:
    pass
except NameError as e:
    print("this is NameError")
except ZeroDivisionError as e:
    print("this is zero number")
else:
    print("Success")

• 上面都是常見的異常處理

• 常見的異常
  

• 對於下面這種異常捕獲

try:
    print(5 / 0)
except BaseException as e:
    print("Base error")
except ZeroDivisionError as e:
    print("Zero error")
else:
    print("success")

• 異常在實現上面就是類,所有的錯誤都繼承自BaseException,所以在捕獲的時候,它捕獲了該型別的所有錯誤;

• 對於記憶體異常必須進行捕獲,並且進行處理;

• 在跨越多層函式進行呼叫時,在呼叫時,應該捕獲異常

• 異常的另一種格式try....except....finally,也就是說無論如何,都會執行finally對應的語句,這種情況下,多用於捕獲,多用於檔案處理;

try:
    print(1 / 0)
except ZeroDivisionError as e:
    print("Zero number")
finally:
    print("do this")

• 斷言
• 這些機制都使用與程式的除錯

def func(num, div):
    assert (div != 0),"Div is not 0"
    return num / div

print(func(10, 9))

• 檔案的操作
• 對於檔案的操作一般是通過檔案描述符來完成的
• 讀檔案的過程:
  • 開啟檔案open(path, flag, encoding, Errors)
  • path:表示開啟檔案的路徑;
  • flag:表示開啟檔案的方式;
    • r:表示以只讀的方式開啟檔案,檔案的描述符在檔案的開頭;
    • rb:以二進位制檔案格式開啟,並且只讀,檔案描述符在開頭;
    • r+:表示可以進行讀寫,檔案描述符在開頭;
    • w:開啟一個檔案,只用於寫入操作,檔案描述符在開頭,如果檔案存在,寫入的內容覆蓋原有的內容;如果不存在,建立一個檔案;
    • wb:開啟一個檔案,只用於寫入二進位制,如果檔案存在,寫入的內容覆蓋原有的內容;如果不存在,建立一個檔案;
    • w+:開啟檔案用於讀寫,果檔案存在,寫入的內容覆蓋原有的內容;如果不存在,建立一個檔案;
    • a+:開啟一個檔案用於追加,如果檔案存在,檔案描述符會放在末尾;
  • encoding:表示編碼格式,常見的為UTF-8
• 檔案內容的讀取
• 1.讀取檔案的全部內容

filestr = fileopen.read()   //適合於小檔案的讀取
print(filestr)

//控制檔案讀寫的大小
filestr = fileopen.read(20)
print(filestr)
filestr = fileopen.read(20)
print(filestr)

USER       PID %CPU 
%MEM    VSZ   RSS TT

//讀取整行,包括"\n"字元
filestr1 = fileopen.readline()
print(filestr1)
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

//讀取指定的字元數
filestr1 = fileopen.readline(20)
print(filestr1)
USER       PID %CPU

//讀取所有行,並且返回列表
filestr1 = fileopen.readlines()
print(filestr1)

//如果給定的數值與0 返回實際某行大小的位元組數

filestr1 = fileopen.readlines(10)
print(filestr1)

['USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND\n']

//修改描述符的位置
fileopen.seek(0)

• 關閉檔案

• 一個完整的過程

try:
    fileopen = open(path, "r", encoding="utf-8")
    fileopen.read()
finally:
    if fileopen:
        fileopen.close()


//建議使用下面這種方法,檔案時會自動關閉的
with open(path, "r", encoding="utf-8") as f2:
    print(f2.read())

• 檔案的寫操作

• 檔案的寫操作,一般首先是寫入記憶體的快取區,然後重新整理緩衝區,就可以進行檔案的寫入;

• 檔案在檔案描述符關閉,緩衝區溢位,以及手動重新整理緩衝區,裡面的內容會同步到檔案的裡面;在遇到\n時,也會自動重新整理緩衝區

• 關於二進位制檔案的讀寫

path = "/root/PycharmProjects/test/file1.txt"
with open(path, "wb") as fileopen:
    str = "today is a good day"
    fileopen.write(str.encode("utf-8"))

with open(path,"rb") as fileread:
    readdata = fileread.read()
    print(readdata)
    print(type(readdata))
    //對上面讀取的資料進行解碼
     dataprint = readdata.decode("utf-8")
    print(type(dataprint))
    print(dataprint)

b'today is a good day'     //表示是二進位制格式的檔案
<class 'bytes'>
<class 'str'>
today is a good day

• 關於list tuple dict set等檔案的操作
• 需要匯入一個模組pickle,表示的是資料永續性模組,也就是將資料儲存在磁碟

path = "/root/PycharmProjects/test/file2.txt"
NewList = [1, 2, 3, 4, 5, "Today is a goo day"]
fileopen = open(path,"wb")

pickle.dump(NewList,fileopen)

fileopen.close()

fileopenList = open(path,"rb")
tempList = pickle.load(fileopenList)
print(tempList)

fileopenList.close()

[1, 2, 3, 4, 5, 'Today is a goo day']

• 當然list也可以更改為其他的資料型別

path = "/root/PycharmProjects/test/file2.txt"
NewList = (1, 2, 3, 4, 5, "Today is a goo day")
fileopen = open(path,"wb")

pickle.dump(NewList,fileopen)

fileopen.close()

fileopenList = open(path,"rb")
tempList = pickle.load(fileopenList)
print(tempList)

fileopenList.close()

(1, 2, 3, 4, 5, 'Today is a goo day')

• 關於OS模組

• 包含了普遍的作業系統的功能;

• 系統型別的列印

print(os.name)  

posix    //unix型別或者Linux
nt       //Windows

• 獲取作業系統詳細的資訊

print(os.uname())

posix.uname_result(sysname='Linux', nodename='westos', release='4.14.0-deepin2-amd64', version='#1 SMP PREEMPT Deepin 4.14.12-2 (2018-01-06)', machine='x86_64')

• 用於獲取作業系統中的環境變數

print(os.environ)

environ({'PATH': '/root/PycharmProjects/hello/venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin', 'LS_OPTIONS': '--color=auto', 'PS1': '(venv) ', 'PYTHONUNBUFFERED': '1', 'COLORTERM': 'truecolor', 'SHELL': '/bin/bash', 'TERM': 'xterm-256color', 'PYTHONIOENCODING': 'UTF-8', 'XAUTHORITY': '/home/westos/.Xauthority', '_JAVA_OPTIONS': '  -Dawt.useSystemAAFontSettings=gasp', 'S_COLORS': 'auto', 'HOME': '/root', 'LOGNAME': 'root', '_': './bin/pycharm.sh', 'VIRTUAL_ENV': '/root/PycharmProjects/hello/venv', 'MAIL': '/var/mail/root', 'LANGUAGE': 'zh_CN', 'USER': 'root', 'LANG': 'zh_CN.UTF-8', 'OLDPWD': '/usr/local/pycharm-community-2018.1.4/bin', 'PYCHARM_HOSTED': '1', 'PWD': '/root/PycharmProjects/test', 'SHLVL': '1', 'DISPLAY': ':0', 'XDG_DATA_DIRS': '/root/.local/share/flatpak/exports/share:/var/lib/flatpak/exports/share:/usr/local/share:/usr/share', 'PYTHONPATH': '/root/PycharmProjects/test'})

• 獲取指定環境變數

print(os.environ.get("_JAVA_OPTIONS"))
-Dawt.useSystemAAFontSettings=gasp

• 當前目錄名

print(os.curdir)
print(os.getcwd())

• 返回指定列表中的檔案

print(os.listdir())
['first.py', '.idea', 'file.txt', 'file2.txt', 'file1.txt']

• 在當前目錄下面建立新的目錄

os.mkdir("test")     //可以指定絕對路徑

• 刪除目錄

os.rmdir("test")

• 獲取檔案屬性

print(os.stat("first.py"))

os.stat_result(st_mode=33188, st_ino=1593548, st_dev=2065, st_nlink=1, st_uid=0, st_gid=0, st_size=252, st_atime=1528903986, st_mtime=1528903985, st_ctime=1528903985)

• 檔案的重新命名

os.remove("file.txt", "hello.txt")

• 刪除檔案

os.remove("filename")

• 執行shell命令

os.system("ls")

• 檢視當前的絕對路徑

print(os.path.abspath("."))

/root/PycharmProjects/test

• 路徑拼接

path1 = "/root/PycharmProjects/test"
path2 = "today"    //這個引數裡面開始不要存在/

print(os.path.join(path1,path2))

/root/PycharmProjects/test/today

• 拆分路徑

print(os.path.split("/root/PycharmProjects/test/today"))

//拆分的結果是一個元組
('/root/PycharmProjects/test', 'today')
//用於獲取檔案的副檔名
print(os.path.splitext("root/PycharmProjects/test/today.txt"))

('root/PycharmProjects/test/today', '.txt')

• 判斷是否是目錄

print(os.path.isdir("/root/PycharmProjects/test/"))

True

• 判斷檔案是否存在

print(os.path.isfile("/root/PycharmProjects/test/file1.txt"))

True

• 判斷目錄是否存在

os.path.exists("path")

• 獲得檔案大小

print(os.path.getsize("/root/PycharmProjects/test/file1.txt"))
19 

• 用於獲取目錄名或者檔名

print(os.path.dirname("/root/PycharmProjects/test/file1.txt"))
print(os.path.basename("/root/PycharmProjects/test/file1.txt"))

/root/PycharmProjects/test
file1.txt

• 關於遞迴的知識

• 遞迴表示函式呼叫函式自己本身,凡是迴圈能夠乾的事,遞迴都是可以完成的;

• 1. 首先確定了臨界條件
• 2. 找出這一個次和上一次的關係
• 3. 假設當前函式已經能用,呼叫自身計算上一次的結果,在求出本次的結果;

• 一個最簡單的遞迴

def sum(n):
    if n == 1:
        return 1
    else:
        return n + sum(n - 1)

print(sum(5))

• 資料結構之棧
• 關於棧的基本操作

stack = []

stack.append("A")

print(stack)

stack.append("B")

print(stack)

stack.append("C")

print(stack)

res = stack.pop()

print(res)
print(stack)

• 特點是先進,後出;
• 資料結構之佇列
• 佇列是先進先出,存資料在一段,取資料在另一端;
• 簡單的程式碼

import collections

queue = collections.deque()

print(queue)

queue.append("A")

print(queue)

queue.append("B")
queue.append("C")

res = queue.popleft()

print(res)
print(queue)

• 遞迴遍歷目錄底下的所有檔案

import os

def getDirrRecur(path, printForamt = ""):
    fileList = os.listdir(path)
    printForamt += "-"
    for FileName in fileList:
        nextFilePath = os.path.join(path, FileName)
        if os.path.isdir(nextFilePath):
            print(printForamt, "dir ", FileName)
            getDirr(nextFilePath, printForamt)
        else:
            print(printForamt, "file ", FileName)

path = "/root/temp/"
getDirr(path)

• 使用棧模擬遞迴深層遍歷目錄

import os

def getDirDeep(path):
    stack = []
    stack.append(path)
    while len(stack) != 0:
        dirPath = stack.pop()
        fileList = os.listdir(dirPath)

        for fileName in fileList:
            filePath = os.path.join(dirPath, fileName)
            if os.path.isdir(filePath):
                stack.append(filePath)
                print("dir ", fileName)
            else:
                print("file ", fileName)

path = "/root/temp/"
getDirDeep(path)

• 廣度遍歷
• 使用佇列模擬遍歷目錄,佇列的特性是先進先出,實現的是廣度遍歷;

import os
import collections


def getAllDirWidth(path):
    queue = collections.deque()
    queue.append(path)
    while len(queue) != 0:
        dirpath = queue.popleft()
        filelist = os.listdir(dirpath)
        for filename in filelist:
            filecompath = os.path.join(dirpath, filename)
            if os.path.isdir(filecompath):
                print("Dir " + filename)
                queue.append(filecompath)
            else:
                print("file " + filename)

path = "/root/temp/"
getAllDirWidth(path)

• time模組
• UTC:世界協調時間,格林尼治天文時間;
• DST:表示夏令時,是一種節約能源,人為規定的時間制度,在夏季調快一個小時;
• 時間的表現形式:
• 時間戳:使用整型或者浮點型表示時間的一個以秒為單位的時間間隔,基礎時間為1970 1 1凌晨的時間的秒;
• 元組:是Python的資料結構,這個元組存在9個整型依次是:year, month, day, hours, minutes, seconds, weekday, Julia day flag[1 | -1 | 0];
• 格式化字串:

  %%	一個文字的 %
  %a	當前locale 的星期名縮寫(例如： 日，代表星期日)
  %A	當前locale 的星期名全稱 (如：星期日)
  %b	當前locale 的月名縮寫 (如：一，代表一月)
  %B	當前locale 的月名全稱 (如：一月)
  %c	當前locale 的日期和時間 (如：2005年3月3日 星期四 23:05:25)
  %C	世紀；比如 %Y，通常為省略當前年份的後兩位數字(例如：20)
  %d	按月計的日期(例如：01)
  %D	按月計的日期；等於%m/%d/%y
  %e	按月計的日期，新增空格，等於%_d
  %F	完整日期格式，等價於 %Y-%m-%d
  %g	ISO-8601 格式年份的最後兩位 (參見%G)
  %G	ISO-8601 格式年份 (參見%V)，一般只和 %V 結合使用
  %h	等於%b
  %H	小時(00-23)
  %I	小時(00-12)
  %j	按年計的日期(001-366)
  %k   hour, space padded ( 0..23); same as %_H
  %l   hour, space padded ( 1..12); same as %_I
  %m   month (01..12)
  %M   minute (00..59)
  %n   a newline
  %N   nanoseconds (000000000..999999999)
  %p   locale's equivalent of either AM or PM; blank if not known
  %P   like %p, but lower case
  %q   quarter of year (1..4)
  %r   locale's 12-hour clock time (e.g., 11:11:04 PM)
  %R   24-hour hour and minute; same as %H:%M
  %s   seconds since 1970-01-01 00:00:00 UTC
  %S	秒(00-60)
  %t	輸出製表符 Tab
  %T	時間，等於%H:%M:%S
  %u	星期，1 代表星期一
  %U	一年中的第幾周，以週日為每星期第一天(00-53)
  %V	ISO-8601 格式規範下的一年中第幾周，以週一為每星期第一天(01-53)
  %w	一星期中的第幾日(0-6)，0 代表週一
  %W	一年中的第幾周，以週一為每星期第一天(00-53)
  %x	當前locale 下的日期描述 (如：12/31/99)
  %X	當前locale 下的時間描述 (如：23:13:48)
  %y	年份最後兩位數位 (00-99)
  %Y	年份
  %z +hhmm		數字時區(例如，-0400)
  %:z +hh:mm		數字時區(例如，-04:00)
  %::z +hh:mm:ss	數字時區(例如，-04:00:00)
  %:::z			數字時區帶有必要的精度 (例如，-04，+05:30)
  %Z			按字母表排序的時區縮寫 (例如，EDT)

• 關於時間的操作
• 獲取當前時間戳

c = time.time()

print(c)

1529041196.717221

• 將時間戳,轉為UTC時間元組

t = time.gmtime(c)

time.struct_time(tm_year=2018, tm_mon=6, tm_mday=15, tm_hour=5, tm_min=41, tm_sec=23, tm_wday=4, tm_yday=166, tm_isdst=0)
t

• 轉換為當地時間

b = time.localtime(c)

print(b)

time.struct_time(tm_year=2018, tm_mon=6, tm_mday=15, tm_hour=13, tm_min=41, tm_sec=23, tm_wday=4, tm_yday=166, tm_isdst=0)

• 將本地時間轉換為時間戳

m = time.mktime(b)
print(m)

• 將時間元組轉換成字串

s = time.asctime(b)
print(s)

Fri Jun 15 13:44:20 2018

• 將時間戳轉換為字串

p = time.ctime(c)
print(p)

Fri Jun 15 13:45:54 2018

• 限定字串的格式

print(time.strftime("%Y-%m-%d %H:%M:%S"))

2018-06-15 13:47:58

• 將時間元組轉換成給定格式的字串,引數2為時間元組,預設轉換當前時間

b = time.localtime(c)
print(time.strftime("%Y-%m-%d %X", b))

2018-06-15 13:50:23

• 將時間字串轉換成時間元組

w = time.strptime(q, "%Y-%m-%d %X")
print(w)

time.struct_time(tm_year=2018, tm_mon=6, tm_mday=15, tm_hour=13, tm_min=53, tm_sec=31, tm_wday=4, tm_yday=166, tm_isdst=-1)

• 一張圖說明字串的使用
  
• 延遲一段時間,支援整型,浮點型

time.sleep(4.0)

• 返回當前程式的CPU時間,unix始終返回全部的執行時間,Windows從第二次開始,都是以第一個呼叫此函式的開始的時間戳作為基數;

print(time.clock())

0.062498

• 時間測試的完整程式碼

import time
import datetime

c = time.time()

print(c)

t = time.gmtime(c)
print(t)

b = time.localtime(c)

print(b)

m = time.mktime(b)
print(m)

s = time.asctime(b)

print(s)

p = time.ctime(c)
print(p)

q = time.strftime("%Y-%m-%d %H:%M:%S")

print(q)
print(type(q))

print(time.strftime("%Y-%m-%d %X", b))

w = time.strptime(q, "%Y-%m-%d %X")
print(w)

time.sleep(4.0)
print(time.clock())

time.clock()

sum = 0

for i in range(100000000):
    sum += i
print(time.clock())

• datetime相比time高階了不少,提供了更加實用的函式,提供的介面更加直觀,更加容易呼叫;裡面包含了常見的五個類:

• datetime:包含時間和日期;

• timedelta:主要用於計算時間的跨度;

• time:表示只關注於時間

• date:只關注於日期

• 獲取當前時間完整時間

timenow = datetime.datetime.now()
print(timenow)

• 獲取指定時間

datetimeformat = datetime.datetime(2018, 6, 15, 14, 22, 23, 123456)
print(datetimeformat)

datetimestr = datetimeformat.strftime("%Y-%m-%d %X")
print(datetimestr)
print(type(datetimestr))

2018-06-15 14:22:23.123456
2018-06-15 14:22:23
<class 'str'>

• 將格式化字串轉換為datetime物件

datetimestr = datetimeformat.strftime("%Y-%m-%d %X")
print(datetimestr)
print(type(datetimestr))

datetimeformat1 = datetime.datetime.strptime(datetimestr, "%Y-%m-%d %X")

print(datetimeformat1)

2018-06-15 14:22:23

• 時間的加減

nowdate1 = datetime.datetime(2018, 6, 14, 17, 25, 43, 123456)
nowdate = datetime.datetime.now()

print(datetime.datetime.now())
date = nowdate - nowdate1

print(date)
print(type(date))

2018-06-15 17:17:26.013561
23:51:42.890086
<class 'datetime.timedelta'>

• 同樣的還可以提取到間隔的天數

print(date.days)

3

• 提取間隔的秒數

print(date.seconds)

86046