1. 程式人生 > >023-2018-1009 序列化+configparser

023-2018-1009 序列化+configparser

1.今日內容大綱

一. 上節課內容回顧
     1. collections
        namedtuple: 命名元組. 建立類
        Counter: 計數器
        deque: 雙向佇列
            stack: 棧  先進後出
            queue: 佇列  先進先出
        OrderedDict 有序字典. 浪費記憶體
        defaultdict:  預設值字典
            d = defaultdict(callable)
            ret = d.get("周潤發")

            ret是 callable()

     2. time模組
        1. 時間戳. float 數字. 1970-01-01 00:00:00
        2. 格式化時間. %Y-%m-%d %H:%M:%S      %Y-%m-%d
        3. 結構化時間. 把時間拆分了。
        時間戳 -> 格式化時間
            f = 10086
            st = time.localtime(f)
            s = time.strftime("%Y-%m-%d %H:%M:%S", st)
        格式化時間 -> 時間戳
            s = "2018-01-01 12:58:46"
            st = time.strptime(s, "%Y-%m-%d %H:%M:%S")
            f = time.mktime(st)

        sleep()

     3. random
        random.randint(start, end) [start, end]隨機整數
        random.choice() 隨機選擇
        random.sample() 隨機選擇n個
     4. os和sys
        os 和作業系統相關
        sys  和直譯器相關的
        sys.path.clear()

二. 作業

三. 今日主要內容
    1. 序列化
        把物件打散成bytes或者字串。 方便儲存和傳輸 序列化
        把bytes或者字串轉換回物件。 反序列化

    2. pickle(比較重要)
        把python中所有的物件都可以轉化成bytes。進行儲存和傳輸
        dumps()  序列化。 不寫檔案
        loads() 反序列化, 不讀檔案
        dump()
        load()

    3. shelve
        小型資料庫. 操縱的是檔案型別的字典.
        shelve.open(檔案, writeback=True)

    4. json(重點)
        前後端資料互動的通用的資料格式。
        dumps() 把字典轉化成字串
        loads() 把字元轉化成字典

        處理中文
            ensure_ascii = False

    5. configparser
        處理配置檔案的。
        把配置檔案作為一個大字典來處理就型了

    明天預習:
        正則表示式
        re模組

2.練習

from collections import defaultdict
def chi():
    print("劉偉走了? 大陽哥來了")
    return 123
d = defaultdict(chi)
print(d["jay"]) # dict()

import time
# print("大陽哥要睡覺了")
# time.sleep(10)
# print("大陽哥醒了")
while 1:
    s = time.strftime("%Y-%m-%d %H:%M:%S")
    print(s)
    time.sleep(1)

# 在這裡之前。 很多模組已經匯入進記憶體了。 自己的模組不要和python的模組衝突.
import sys
import builtins
print(sys.path) # 搜尋模組的路徑, django . flask
print(sys.modules.keys())
sys.path.clear() # 尋找模組的路徑給刪了. 但是。 記憶體裡的面的模組還在
import json # 這裡會報錯.
import os
def copy(source, path):
    path = os.path.join(path, os.path.basename(source))
    with open(source, mode="rb") as f1, open(path, mode="wb") as f2:
        for line in f1:
            f2.write(line)

copy("c:\\timg.jpg","d:\\")

# 計算時間差(使用者輸入起始時間和結束時間. 計算時間差(小時),
#  		例如, 使用者輸入2018-10-08 12:00:00   2018-10-08 14:30:00 輸出2小時30分
import time
start_str = "2018-10-08 12:00:00"
end_str = "2018-10-08 14:30:00"

start_float = time.mktime(time.strptime(start_str, "%Y-%m-%d %H:%M:%S"))
end_float = time.mktime(time.strptime(end_str, "%Y-%m-%d %H:%M:%S"))

diff_second = end_float - start_float # 計算相差的秒數

diff_min = diff_second // 60 # 計算出分鐘  150

show_hour = diff_min // 60
show_min = diff_min % 60

print(show_hour, show_min)

import random

# 獲取[m, n]的隨機整數

import os

3.pickle模組

import pickle

#  dumps 序列化。 把物件轉化成bytes
#  loads 反序列化。 把bytes轉化成物件
#  dump 序列化。 把物件轉化成bytes並寫入檔案
#  load 反序列化。把檔案中的bytes讀取。轉化成物件

class Cat:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def catchMouse(self):
        print(self.name, self.age, "抓老鼠")


c = Cat("jerry", 18)
c.catchMouse()


# # dumps 把物件轉化成bytes  序列化
bs = pickle.dumps(c)
print(bs)

# 把bytes 轉換回物件  反序列化
ccc = pickle.loads(bs)
ccc.catchMouse()

dic = {"jay": "周杰倫", "jj": "大陽哥"}
bs = pickle.dumps(dic)
print(bs)

d = pickle.loads(bs)
print(d)





c = Cat("jerry", 18)
f = open("pickle-test", mode="wb")
pickle.dump(c, f) # 結果人是看不了的。

f.close()
f = open("pickle-test", mode="rb")
c = pickle.load(f)
c.catchMouse()

lst = [Cat("貓1", 10), Cat("貓2", 9), Cat("貓3", 9), Cat("貓4", 9), Cat("貓5", 9)]

f = open("pickle-test", mode="wb")
pickle.dump(lst, f)
# for el in lst:
#     pickle.dump(el, f)

f.flush()
f.close()

f = open("pickle-test", mode="rb")
while 1:
    try:
        c1 = pickle.load(f)
        c1.catchMouse()
    except EOFError:
        break





4.shelve

import shelve

# 開啟一個檔案
f = shelve.open("大陽哥", writeback=True)
f['jj'] = "林俊杰"
f['dyg'] = "大陽哥"
f['zzr'] = "周芷若"

f = {}
# 像操作字典一樣操作檔案
f["jay"] = "周杰倫"
print(f['jay'])



f["jay"] = {'name': "周杰倫", 'age': 38, "hobby": "吃喝拉撒睡"}

f['jay']['name'] = "胡辣湯"
print(f['jay']['name'])
print(f['jay'])

# f.close()




f = shelve.open("大陽哥")
print(f.keys())
for k in f.keys(): # 可以獲取到所有的key
    print(k)

for k in f:
    print(k)

for k, v in f.items():
    print(k, v)

5.json

wf = {
    "name": "汪峰",
    "age": 18,
    "hobby": "搶頭條",
    "wife": {
        "name": "子怡",
        "age": 19,
        "hobby":["唱歌", "跳舞", "演戲"]
    }
}

wf['wife']['hobby']
class Person:
    def __init__(self, name, age, hobby, wife):
        self.name = name

import json
dic = {"a": '理查德姑媽', "b": "找到你", "c": "看不見的客人"}

# s = json.dumps(dic) # 如果你的key或者value超出了ascii範疇。 就會顯示成\uxxxxx
s = json.dumps(dic, ensure_ascii=False) # 幹掉ascii碼
print(repr(s), type(s))


# 把字串解析成 字典
dic1 = json.loads(s)
print(dic1, type(dic1))

# 寫入
f = open("waimai.json", mode="w", encoding="utf-8")
json.dump(dic, f, ensure_ascii=False)   # 把json寫入到檔案中
f.close()

# 讀出
f = open("waimai.json", mode="r", encoding="utf-8")
s = json.load(f) # 把檔案中的json串。讀取成字典
print(s, type(s))

lst = [{"a": "胡辣湯"},{"b":"吱吱冒油的大豬蹄子"},{"c": "蓋澆飯"},{"d":"馬拉"},{"e":"法國大蝸牛"}]
f = open("menu.json", mode="w", encoding="utf-8")
for dic in lst:
    json.dump(dic, f, ensure_ascii=False)
f.close()

f = open("menu.json", mode="r", encoding="utf-8")
s = json.load(f)
print(s)

# 寫入的時候
# 1. 迴圈
# 2. 用dumps把字典轉化成字串, 然後手工在後面加一個\n
# 3. 寫出
f = open("new_menu.json", mode="w", encoding="utf-8")
lst = [{"a": "胡辣湯"},{"b":"吱吱冒油的大豬蹄子"},{"c": "蓋澆飯"},{"d":"馬拉"},{"e":"法國大蝸牛"}]
for el in lst:
    s = json.dumps(el, ensure_ascii=False) + "\n"
    f.write(s)

f.flush()
f.close()


# 讀取的時候
# 1. for line in f:
# 2. strip()去掉空白
# 3. loads()變成字典

f = open("new_menu.json", mode="r", encoding="utf-8")
for line in f:
    line = line.strip()
    dic = json.loads(line)
    print(dic)

6.configparser

import configparser

conf = configparser.ConfigParser()
conf["DEFAULT"] = {
    "session-time-out":30,
    "user-alive": 60,
    "connect-alive":10
}

conf["189-DB"] = {
    "ip": "189.135.63.12",
    "port": 3306,
    "uname": "root",
    "password": "root"
}


conf["166-DB"] = {
    "ip": "189.135.63.12",
    "port": 3306,
    "uname": "root",
    "password": "root"
}


conf["163-DB"] = {
    "ip": "189.135.63.12",
    "port": 3306,
    "uname": "root",
    "password": "root"
}

f = open("db.ini", mode="w")
conf.write(f) # 把檔案扔進去。 寫到這個檔案裡


# 讀取內容
conf = configparser.ConfigParser()
conf.read("db.ini")
print(conf.sections()) # 獲取到章節 keys()
print(conf['166-DB']["ip"])  # 可以像字典一樣操作
print(conf["166-DB"]["port"])
print(conf["166-DB"]["uname"])
print(conf["166-DB"]["password"])

for key in conf['163-DB']:
    print(key)

for key, value in conf['163-DB'].items():
    print(key, value)


# 增刪改操作
conf = configparser.ConfigParser()
conf.read("db.ini") # 讀取出來

conf['163-DB']['uname'] = "alex"
# del conf['163-DB']["password"]
conf.set("163-DB", "wangermazi", "189") # setattr

conf.add_section("jay")
conf.write(open("db.ini", mode="w"))


7.其他補充

<1>. db.ini


[DEFAULT]
session-time-out = 30
user-alive = 60
connect-alive = 10

[189-DB]
ip = 189.135.63.12
port = 3306
uname = root
password = root

[166-DB]
ip = 189.135.63.12
port = 3306
uname = root
password = root

[163-DB]
ip = 189.135.63.12
port = 3306
uname = alex
wangermazi = 189

[jay]

<2>. menu.json

{"a": "胡辣湯","m":{"a":"1"}}
{"b": "吱吱冒油的大豬蹄子"}
{"c": "蓋澆飯"}
{"d": "馬拉"}
{"e": "法國大蝸牛"}

<3>. new_menu.josn

{"a": "胡辣湯"}
{"b": "吱吱冒油的大豬蹄子"}
{"c": "蓋澆飯"}
{"d": "馬拉"}
{"e": "法國大蝸牛"}

<4>. out.json

{"a": "理查德姑媽", "b": "找到你", "c": "看不見的客人"}

<5>. wf.xml

<?xml version="1.0" encoding="utf-8" ?>
<wf>
    <name>汪峰</name>
    <age>18</age>
    <hobby>搶頭條</hobby>
    <wife>
        <name></name>
    </wife>
</wf>

<6>. orange_hero.bak

'jay', (0, 81)
'jj', (512, 19)
'dyg', (1024, 19)
'zzr', (1536, 19)

<7>. orange_hero.dir

'jay', (0, 81)
'jj', (512, 19)
'dyg', (1024, 19)
'zzr', (1536, 19)

8.小試牛刀

  1. 整理部落格和筆記.
  2. 隨機生成4位驗證碼(包含數字, 字母)
  3. 模擬發紅包. 不需要考慮權重問題. 純隨機.

         例如, 小紅髮了100塊紅包. 發給30人. 請給出每個人能收到的錢數

明日默寫內容.

使用json模組完成:

  1. 字典-> 字串
  2. 字串 -> 字典