一，Import的基本用法

import

1.執行對應的檔案

2.引入變數名

3.當一個檔案被import，索貝import中的程式碼會被執行一遍，例如當 import cal  ##cla中有inport("xxx")，則會輸出

 

## Import引用方法

# cal.py檔案中
def add(x,y)
    return x + y

---

# test.py檔案中
# 引用方法1
import cal
print(cal.add(1,2))        # 如果用import直接引用，則只能用cal.add方式呼叫add方法

# 引用方法2
from cal import
 
 add
print(add(1,2))        # 直接可以使用add方法

 ## import的路徑問題

1.例如當檔案test.py執行時，會將自己的上層目錄傳到sys.path中，通過上層目錄可找到下層的目錄檔案

2.當前的執行檔案為test.py，且test.py所在的資料夾為Hello，則檔案Hello為sys.path中唯一識別的路徑，只能通過該路徑進行查詢其它所要引入的檔案

## 多個檔案巢狀問題

add為cal.py中的方法，cal.py在檔案dir2中，dir2在dir1中，dir1在dir中

# 方法1
from dir.dir1.dir2 import
 
 cal
print(cal.add(1,2))

# 方法2
from dir.dir1.dir2.cal import add
print(add(2,3))

# 方法3（不建議使用）
from dir.dir1 import dir2
print(dir2.cal.add  (3,4))

 

## __name__ 的作用

1，當在執行檔案中直接執行 print(__name__) 　　　　　  　# 輸出字串 __main__

2，當在呼叫檔案（在cal檔案中）中執行 print(__name__) 　# 輸出的為當引用檔案的路徑  dir.dir1.dir2.cal

3，判斷檔案是否為執行檔案 if __name__ = "__main__" 　　# 如果當前的檔案為執行檔案

二，各個模組

 模組：功能模組是指資料說明、可執行語句等程式元素的集合，它是指單獨命名的可通過名字來訪問的過程、函式，子程式或巨集呼叫。功能模組化是將程式劃分成若干個功能模組，每個功能模組完成了一個子功能，再把這些功能模組總起來組成一個整體。以滿足所要求的整個系統的功能。

## time模組

 

# 時間戳 
time.time()    # 1543898846.79   表示從1970.1.1經歷的秒數（1970是unix誕生日期）

---

# 結構化時間當地時間
time.localtime()    # 得到一個結構化時間（可以操作具體的某個值）
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=15, tm_min=2, tm_sec=59, tm_wday=1, tm_yday=352, tm_isdst=0)

t = time.localtime()
print(t.tm_yday)    # 顯示tm_yday 325

---

# 結構化時間，世界標準時間UTC
time.gmtime()
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=7, tm_min=6, tm_sec=0, tm_wday=1, tm_yday=352, tm_isdst=0)

---

# 將時間戳轉成結構化時間
time.localtime(time.time())

---

# 將結構化時間轉為時間戳
time.mktime(time.localtime())

---

# 將結構化時間轉換成字串時間
time.strftime("%Y-%m-%d %X",time.localtime())    # %X代表 時分秒        2018-12-18 15:08:43

---

# 將字串時間轉為結構化時間
time.strptime("2018:10:10:10:10:10","%Y:%m:%d:%X")
# time.struct_time(tm_year=2018, tm_mon=10, tm_mday=10, tm_hour=10, tm_min=10, tm_sec=10, tm_wday=2, tm_yday=283, tm_isdst=-1)

---

# 執行緒推遲指定是將執行，單位秒
time.sleep(x)

---

import datetime()
print(datetime.datetime()) # 顯示為 2016-12-12 17.50.36.316449

 

## random模組

random.random()                        # 生成0~1的浮點數

random.randint(1,5)                    # [1,5]

random.randrange(1,5)                # [1,5)

random.choice([11,22,33])            # 對可迭代物件中的元素中的進行隨機取得

random.sample(([11,22,33,44]),2)    # 隨機在可迭代物件中選取兩個

random.uniform(1,3)                    # 取得範圍中隨機的浮點型 2.4779013205711236

ret = [12,3,4,5,6]
random.shuffle(ret)                    # 進行隨機排列
print(ret)

---

# 隨機驗證碼
import random

def verofication():
    res = ""
    for i in range(5):
        num = random.randint(0,9)
        letter = chr(random.randint(61,122))
        code =str(random.choice([num,letter]))
        res+=code
    return res

print(verofication())

 

## os模組

os.getcwd()                    # 獲取當前的工作路徑 

os.chdir("dirname")            # 改變當前的工作目錄，在原本目錄下新增新的目錄

os.curdir                   　　# 返回當前目錄

os.pardir                      # ".." 獲取當前目錄的父目錄字串名

os.makedirs('name1/name2')     # 可生成多層遞迴目錄

os.removedirs('name')          # 若該目錄為空，則刪除，並遞迴到上一級目錄，如若也為空，則刪除

os.mkdir('dirname')            # 生成單級目錄

os.rmdir('dirname')            # 刪除單級空目錄，若目錄不為空則無法刪除，報錯

os.listdir('dirname')          # 列出指定目錄下的所有檔案和子目錄，包括隱藏檔案，以列表方式輸出

os.remove("name")              # 刪除一個檔案

os.rename("old","new")         # 重新命名檔案或目錄

os.stat('path/filename')       # 獲取檔案或目錄資訊

                               # 輸出中有檔案建立時間，檔案修改時間

os.sep                         # 輸出作業系統特定的路徑分隔符，win下為"\\",Linux下為"/"（使用sep方便與在win與Linux中轉換程式）

os.linesep                     # 輸出當前平臺使用的行終止符，win下為"\r\n",Linux下為"\n"

os.pathsep                     # 輸出用於分割檔案路徑的字串 win下為";",Linux下為":",環境變數中的分割方式

os.name                        # 輸出字串指示當前使用平臺。win->'nt'; Linux->'posix'

os.system("bash command")      # 執行shell命令，直接顯示

os.environ                     # 獲取系統環境變數path環境變數

os.path.abspath(path)          # 返回path規範化的絕對路徑

os.path.split(path)            # 將path分割成目錄和檔名二元組返回，將檔案路徑和檔名分開

os.path.dirname(path)          # 返回path的目錄。其實就是os.path.split(path)的第一個元素

os.path.basename(path)        # 返回path最後的檔名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素

os.path.exists(path)          # 路徑如果存在，返回True；如果path不存在，返回False

os.path.isabs(path)           # 如果path是絕對路徑，返回True

os.path.isfile(path)          # 如果path是一個存在的檔案，返回True。否則返回False

os.path.isdir(path)          # 如果path是一個存在的目錄，則返回True。否則返回False

os.path.join(path1[, path2[, ...]])  # 將多個路徑組合後返回，第一個絕對路徑之前的引數將被忽略os.path.join(a,b)    # 將路徑a 和路徑b拼接起來

os.path.getatime(path)      # 檔案或者目錄的最後存取時間

os.path.getmtime(path)      # 檔案或者目錄的最後修改時間

 

## sys模組

sys.argv           # ['F:/Python_Project/Test/sys模組.py']  命令列引數List，第一個元素是程式本身路徑

---

sys.exit(n)        # 退出程式，正常退出時exit(0)

---

sys.version        # 獲取Python解釋程式的版本資訊  

3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)]

---

sys.maxint         # 最大的Int值

---

sys.path           # 返回模組的搜尋路徑，初始化時使用PYTHONPATH環境變數的值['F:\\Python_Project\\Test',
'F:\\Python_Project\\Test',
'F:\\Python_Project\\Test\\Scripts\\python37.zip',
'C:\\Python3\\DLLs', 'C:\\Python3\\lib', 
'C:\\Python3', 
'F:\\Python_Project\\Test\\lib\\site-packages', 
'F:\\Python_Project\\Test\\lib\\site-packages\\setuptools-39.1.0-py3.7.egg', 
'F:\\Python_Project\\Test\\lib\\site-packages\\pip-10.0.1-py3.7.egg', 
'D:\\Software\\PyCharm 2018.2.2\\helpers\\pycharm_matplotlib_backend']

---

sys.platform       # win32 返回作業系統平臺名稱，不同的平臺顯示不同的值（判斷什麼系統，執行什麼操作）

 

 ## 進度條

import sys,time

for i in range(50):
    sys.stdout.write("#")
    time.sleep(2)
    sys.stdout.flush()      # 重新整理

 

 

## json模組

# json可以進行任何語言間的資料交換

1：將資料中的單引號或三引號轉為雙引號

2：將dic轉成json型別字串

3：所有的資料型別均可以轉為json型別字串

import json

dic = {'name':'henry'}
data = json.dumps(dic)
print(data)         # {"name": "henry"}
print(type(data))   # <class 'str'>

 

# 將json型別的字串重新轉為字典型別

new_data = json.loads(data)
print(new_data)             # {'name': 'henry'}
print(type(new_data))       # <class 'dict'>

 

# dumps與loads的用法

# 寫：將一個字典轉成json形式字串再寫到檔案hello中
dic = {"name":"henry"}
f = open("hello","w")
dic_str = json.dumps(dic)
f.write(dic_str)

---

# 讀：將檔案hello中的字串資料讀取出來，並轉成字典形式
f_read = open("hello","r")
data = json.loads(f_read.read())
print(data)         # {'name': 'henry'}

 

# dump與load用法

# 寫
dic = {"name":"henry"}
f = open("hello","w")
json.dump(dic,f)    # 一步相當於做了兩件事

---

# 讀
f_read = open("hello","r")
data = json.load(f_read)        # 一步相當於兩步
print(data)

 

## 注：dumps與loads不一定要配合使用，當檔案中的資料沒以dumps寫入，但格式符合json規範（以雙引號包含），用loads就能進行讀取

## pickle模組

1：pickle在使用上與json並無區別，有四個方法 dumps loads dump load
2：pickle的區別：json序列化後為字串，pickle序列化後為位元組形式
3：pickle支援的資料型別更多，pickle可以序列化函式，類...

## 序列化與反序列化

序列化：將物件或變數從記憶體中變為可儲存或可傳輸的過程稱為序列化

反序列化：將變數或內容從序列化的物件重新讀到記憶體中的過程稱為反序列化 

json：

如果要在不同的程式語言中進行傳遞物件，就必須將物件序列化為標準格式，比如XML，但更好的是將其序列換為JSON，因為利用Json序列後的物件就是一個字串格式，能被所有的程式語言進行讀取，也方便進行儲存或進行傳輸，Json為標準格式，且傳輸的熟讀比XML塊

# 序列化
dic = {"name":"henry"}
f = open("hello","w")
dic_str = json.dumps(dic)
print(dic_str)　　　　# <class 'str'>
f.write(dic_str)

---

# 反序列化
f_read = open("hello","r")
data = json.loads(f_read.read())
print(data)　　　　　　# <class 'dic'>
print(data)         # {'name': 'henry'}

 

## shelve模組

在使用json或pickle來進行儲存資料時，能dump多次，當load只能取到最新的dump資料，因為先前的資料已經被覆蓋掉了，這裡就能使用到shelve模組

shelve模組可以持久化所有pickle支援的資料型別

# 資料持久化

import shelve,datetime

dic_list = {"name":"henry","age":18}    # 字典
list_list = ["Python","Java","C++"]     # 列表
t = datetime.datetime.now()             # 時間型別

with shelve.open("test_shelve") as f:
    f["dic_list_t"] = dic_list
    f["list_list_t"] = list_list
    f["t_t"] = t
f.close()

 

# 執行程式碼後產生三個檔案

# test_shelve.bak
'dic_list_t', (0, 43)
'list_list_t', (512, 42)
't_t', (1024, 44

---

# test_shelve.dat
�}q (X   nameq
X   henryqX   ageqKu.                                                                           
�]q (X   Pythonq
X   JavaqX   C++qe.
�cdatetime
datetime
q C
�4��q
�qRq.

---

# test_shelve.dir
'dic_list_t', (0, 43)
'list_list_t', (512, 42)
't_t', (1024, 44)

 

 

# 用get進行讀取

with shelve.open("test_shelve") as f:
    print(f.get("dic_list_t"))
    print(f.get("list_list_t"))
    print(f.get("t_t"))

## xml模組

 

# test_xml.xml檔案中的內容

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

 

# 獲取文件樹的跟

import xml.etree.ElementTree as ET

tree = ET.parse("test_xml.xml")
root = tree.getroot()       # 獲得文件樹的根data
print(root)                 # <Element 'data' at 0x000002BB4668CA98>

 

# 遍歷xml文件

for child in root:
    print(child.tag,child.attrib)   # child.tag為root下一層標籤名，child.attrib為root下一層中所有的屬性及名稱
    for i in child:
        print(i.tag,i.attrib)　　　　# i.tag為child下一層標籤名，i.attrib為child下一層中所有的屬性及名稱
# 輸出
country {'name': 'Liechtenstein'}
rank {'updated': 'yes'}
year {}
gdppc {}
neighbor {'name': 'Austria', 'direction': 'E'}
neighbor {'name': 'Switzerland', 'direction': 'W'}
country {'name': 'Singapore'}
rank {'updated': 'yes'}
year {}
gdppc {}
neighbor {'name': 'Malaysia', 'direction': 'N'}
country {'name': 'Panama'}
rank {'updated': 'yes'}
year {}
gdppc {}
neighbor {'name': 'Costa Rica', 'direction': 'W'}
neighbor {'name': 'Colombia', 'direction': 'E'}

 

 

# 中遍歷xml檔案中的year節點

for i in root.iter("year"):
    print(i.tag,i.text)    # 節點名稱 節點值

# 輸出
year 2008
year 2011
year 2011

 

# 修改標籤的值

for i in root.iter("year"):
    new_year = int(i.text) + 1
    i.text = str(new_year)
tree.write("test_xml.xml")　# 將修改後的資料重新寫到新的檔案中，可以以原檔案同名

 

# 給標籤新增屬性和值

for i in root.iter("year"):
    i.set("new_attrib","new_value")
tree.write("test_xml.xml")
# 修改後的值
<year new_attrib="new_value" new_year="year111">2008</year>
<year new_attrib="new_value" new_year="year111">2011</year>
<year new_attrib="new_value" new_year="year111">2011</year>

 

 

# 刪除

for countr in root.findall("country"):
    rank = int(countr.find("rank").text)
    if rank > 50:
        root.remove(countr)
tree.write("test_xml.xml")

 

# 建立一個xml檔案

import xml.etree.ElementTree as ET

new_xml = ET.Element("root_name")　　# 根節點
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"cheeked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = "男"

name = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name,"age",attrib={"cheeked":"yes"})
age.text = "18"
sex = ET.SubElement(name,"sex")
sex.text = "女"

et = ET.ElementTree(new_xml)　　# 生成文件物件
et.write("text.xml",encoding="UTF-8",xml_declaration=True)# 檔名，字元編碼，是否顯示頭資訊

## re模組（正則表示式）