python3週末班2期第5天

今日課程大綱： 01 上週內容回顧 02 模塊介紹 03 time模塊 04 random模塊 05 os模塊 06 sys模塊 07 序列化模塊json 08 序列化模塊pickle 09 正則表達式 10 re模塊 11 遞歸函數

 

01 上週內容回顧

  1 #!/usr/bin/env python3
  2 #author:Alnk(李成果)
  3 
  4 # 裝飾器
  5     # 在不改變函數本來調用方式的基礎上添加一些功能
  6     # @裝飾器名
  7     # 如何寫一個裝飾器
  8     # 例子
  9         # 計算函數執行時間
 10         # 用戶認證
 11         # 給函數添加日誌
 12 # def wrapper(func):
 13 #     def inner(*args,**kwargs):
 14 #         '''在被裝飾的函數以前添加功能'''
 15 #         ret = func(*args,**kwargs)
 16 #         '''在被裝飾的函數以後添加功能'''
 17 #         return ret
 18 #     return inner
 19 #
 20 # @wrapper
 21 # def f():
 22 #     print('in f')
 23 # f()
 24 
 25 
 26 # 多個裝飾器裝飾一個函數
 27 # def wrapper1(func):
 28 #     def inner(*args,**kwargs):
 29 #         print('wrapper1 before')
 30 #         ret = func(*args,**kwargs)
 31 #         print('wrapper1 after')
 32 #         return ret
 33 #     return inner
 34 #
 35 # def wrapper2(func):
 36 #     def inner(*args,**kwargs):
 37 #         print('wrapper2 before')
 38 #         ret = func(*args,**kwargs)
 39 #         print('wrapper2 after')
 40 #         return ret
 41 #     return inner
 42 #
 43 # @wrapper2   #wrapeer2 裝飾 wrapper1
 44 # @wrapper1   #wrapper1 裝飾 f
 45 # def f():
 46 #     print('in f')
 47 # f()
 48 
 49 # 考題
 50 # 兩個裝飾器裝飾一個函數，統計func函數的執行時間
 51 # 登陸 -- 裝飾器 auth
 52 # 計算函數的執行時間 -- 裝飾器 timmer
 53 #
 54 # @auth
 55 # @timmer
 56 # def func()
 57 
 58 
 59 # 帶參數的裝飾器
 60 # flag = False
 61 # def outer(flag):
 62 #     def timmer(func):
 63 #         def inner(*args,**kwargs):
 64 #             if flag:
 65 #                 print('wrapper1 before')
 66 #                 ret = func(*args,**kwargs)
 67 #                 print('wrapper1 after')
 68 #             else:
 69 #                 ret = func(*args, **kwargs)
 70 #             return ret
 71 #         return inner
 72 #     return timmer
 73 #
 74 # @outer(flag)       # 把這裏拆分紅@ 和outer(flag)看。先看outer(flag),他就等於timmer 。而後 @outer(flag) = @timmer
 75 # def f1():
 76 #     print('in f1')
 77 #
 78 # @outer(flag)
 79 # def f2():
 80 #     print('in f2')
 81 #
 82 # @outer(flag)
 83 # def f500():
 84 #     print('in f500')
 85 #
 86 # f1()
 87 # f2()
 88 # f500()
 89 
 90 
 91 # 迭代器和生成器
 92 
 93 # 可迭代對象 : list str range
 94 # 能夠經過 for/iter 方法將一個可迭代對象轉換成一個迭代器  ，
 95 
 96 # 迭代器 : 文件句柄
 97 # 使用迭代器 ： 節省內存，迭代器一項一項的取
 98 
 99 # 生成器
100     # 咱們本身寫的迭代器
101     # 生成器的本質就是迭代器，全部的生成器都是迭代器
102 # 實現生成器的方法 ：
103     # 生成器函數 ：必定帶yield關鍵字 g = func()
104     # 生成器表達式 : 用小括號表示的推導式
105 # 生成器的特色：
106     # 1.能夠用next/send方法從中取值
107     # 2.生成器中的數據只能從頭至尾取一次 ***
108     # 3.惰性運算 ：不取生成器是不工做的 ***
109 
110 # 考題
111 # def demo():
112 #     for i in range(4):
113 #         yield i
114 # g = demo()
115 #
116 # g2 = (i for i in g)
117 # g1 = (i for i in g)
118 #
119 # print(list(g1))  # [0，1，2，3]   # 這一步纔開始從g1中取值
120 # print(list(g2))  # []
121 
122 
123 # 列表推導式(排序)
124     # [i**2 for i in lst]
125     # [i**2 for i in lst if i%2 ==0]
126 # 生成器表達式(不能排序)
127     # (i**2 for i in lst)
128     # (i**2 for i in lst if i%2 ==0)
129 
130 
131 # 匿名函數
132     # lambda 參數1,參數2,參數3 : 返回值/返回值相關的表達式
133 
134 # 內置函數
135     # min max map filter sorted   單記，能夠和 lambda 連用。考點 用匿名函數實現某些功能的時候
136     # reduce --> functool   2.7中，3.x放到functool中去了
137     # zip sum enumerate
138 
139 # min max
140 # l1 = [('a',3), ('b',2), ('c',1)]
141 # # def func(x):
142 # #     return x[1]
143 # # ret = min(l1,key=func)  # 注意這裏 min 會先把l2列表中的每一個元素傳遞到func函數中去，而後在取最小的
144 # # print(ret)
145 # # 改爲lambda
146 # ret = min(l1,key=lambda x : x[1])
147 # print(ret)
148 
149 # filter 函數用於過濾序列。過濾掉不符合條件的元素，返回一個迭代器對象
150 # 該接收兩個參數，第一個爲函數，第二個爲序列，序列的每一個元素做爲參數傳遞給函數進行判
151 # 而後返回 True 或 False，最後將返回 True 的元素放到新列表中
152 # l1 = [1,2,3,4,5,6,7,8,9,10,]
153 # def is_odd(n):
154 #     return n % 2 == 1
155 # g = filter(is_odd, l1)
156 # for i in g:
157 #     print(i)
158 
159 # sorted   排序
160 # l1 = [1,2,8,7,5]
161 # print(sorted(l1))
162 # l2 = [('c',2),('b',3),('a',1)]
163 # print( sorted(l2, key=lambda x:x[1]) )  # 這個和 min max 有點相似
164 
165 # zip 拉鍊方法，會以最短的那個列表或其餘的 去組合。生成一個迭代器
166 # l1 = [1,2,3,4]
167 # tu1 = ('a','b','c')
168 # g = zip(l1,tu1)
169 # print(next(g))
170 # print(next(g))
171 # print(next(g))
172 # 雙排拉鍊方法
173 # l1 = [1,2,3,4]
174 # tu1 = ('a','b','c')
175 # tu2 = ('a1','b1','c1')
176 # g1 = zip(l1,tu1,tu2)      # 也能夠多個元素組合
177 # for i in g1:
178 #     print(i)
179 
180 # enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，同時列出數據和數據下標，
181 # 通常用在 for 循環當中。
182 # l1 = ['a','b','c','d']
183 # for index,i in enumerate(l1):
184 #     print(index,i)

 

02 模塊介紹

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 # 爲何要有模塊？(內置函數不夠用)
 5 # 和操做系統打交道
 6 # 和python解釋器打交道
 7 # 和時間打交道
 8 # 如何利用python發郵件
 9 # 如何利用python圖像識別
10 
11 # 都是完成好的功能
12 # 能夠被封裝成函數
13 # 能夠成爲內置的函數
14 # 佔用內存空間
15 
16 # 整理分類，把相同的功能放在一個文件中
17 # 咱們在開發的過程當中，用到哪一個功能直接導入使用就能夠了
18 # 不使用的功能不會進入內存佔用沒必要要的空間
19 # 使用的功能咱們能夠自由的選擇
20 
21 # 模塊的本質
22 # 就是封裝了不少不少函數、功能的一個文件
23 
24 # 導入模塊 就是 import
25 
26 # 模塊的分類
27 # 內置模塊 不須要咱們進行額外的安裝、隨着解釋器的安裝直接就可使用的模塊
28 # 擴展模塊/第三方模塊 咱們安裝了python解釋器以後 若是要使用這些模塊還要單獨安裝
29     # https://pypi.org/
30     # 豆瓣的 python源
31 # 自定義模塊
32     # 本身寫的模塊

 

03 time模塊

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 # 和時間打交道的模塊
 5 import time
 6 
 7 # 1.時間戳時間 time.time()
 8 # print(time.time())
 9 # 1548645816.011941 時間戳格式
10 # float 小數
11 # 爲何時間要用這種格式(1548558746.5218766)表示？
12     # 是給計算機看的
13 # '2019/1/27 11:13'
14 # 1970 1 1 0:0:0 英國倫敦的時間 0時區
15 # 1970 1 1 8:0:0 北京的時間 東8區
16 
17 
18 # 2.格式化時間 time.strftime('%Y-%m-%d %H:%M:%S')
19 # t1 = time.strftime('%Y-%m-%d %H:%M:%S')
20 # t1 = time.strftime('%Y+%m+%d %H:%M:%S %a')
21 # t1 = time.strftime('%Y+%m+%d %H:%M:%S %A %b %B')
22 # t1 = time.strftime('%y+%m+%d %H:%M:%S %A %b %B')
23 # t1 = time.strftime('%c')
24 # print(t1)
25 
26 
27 # 3.結構化時間（時間元組） time.localtime()
28 # print(time.localtime())
29 # tm_year=2019 --- 年
30 # tm_mon=1   ---月
31 # tm_mday=28,   ---日
32 # tm_hour=11,  ---時
33 # tm_min=33,  ---分
34 # tm_sec=1,   ---秒
35 # tm_wday=0,  --- 一週的第幾天，星期一爲0
36 # tm_yday=28,  ---  一年的第幾天
37 # tm_isdst=0  --- 是不是夏令時，默認不是
38 
39 
40 # 轉換隻能經過結構化時間進行轉換 ：時間戳格式 <---> 結構化時間 <---> 格式化時間
41 # 1548558746.5218766                        '2019/1/27 11:13'
42 #   計算機能看懂的    (爲了進行數據轉換)    人能看懂的
43 #   時間戳時間         結構化時間           格式化時間
44 #   time.time()       time.localtime()      time.strftime('%Y-%m-%d %H:%M:%S')
45 
46 
47 # 舉例1
48 # 格式化時間 2018-8-8  ---> 時間戳時間
49 # 先把格式化時間 轉化成 元組時間
50 # str_time = '2018-8-8'
51 # struct_time = time.strptime(str_time, '%Y-%m-%d')
52 # print(struct_time)
53 # # 在轉化成時間戳
54 # stamp_time = time.mktime(struct_time)
55 # print(stamp_time)
56 
57 # 舉例2
58 # 2000000000 轉化爲格式化時間
59 # stamp_t = 2000000000
60 # # 先把時間戳時間轉化爲元組時間
61 # struct_t = time.localtime(stamp_t)
62 # print(struct_t)
63 # # 再把元組時間轉爲格式化時間
64 # strftime_t = time.strftime('%Y-%m-%d %H:%M:%S', struct_t)
65 # print(strftime_t)
66 
67 # 小練習1
68 # 拿到本月時間1號的時間戳時間
69 # strftime_t = time.strftime('%Y-%m')
70 # print(strftime_t)
71 # struct_t = time.strptime(strftime_t, '%Y-%m')
72 # print(struct_t)
73 # stamp_t = time.mktime(struct_t)
74 # print(stamp_t)
75 
76 # 小練習2
77 # '2017-09-11 08:30:00' '2017-09-12 11:00:00' 計算這兩個時間段的時間差
78 # 先把格式化時間--->元組時間
79 # t1 = time.mktime(time.strptime('2017-09-11 08:30:00', '%Y-%m-%d %H:%M:%S'))
80 # t2 = time.mktime(time.strptime('2018-09-13 08:30:10', '%Y-%m-%d %H:%M:%S'))
81 # ret = t2 - t1
82 # struct_t = time.gmtime(ret)
83 # print(struct_t)
84 # print('過去了%d年%d月%d天%d小時%d分鐘%d秒'%(struct_t.tm_year-1970,struct_t.tm_mon-1,
85 #                                  struct_t.tm_mday-1,struct_t.tm_hour,
86 #                                  struct_t.tm_min,struct_t.tm_sec))

 

 

04 random模塊

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 import random
 4 # 和隨機相關的內容 random模塊
 5 
 6 # # 隨機小數
 7 # print(random.random())  #(0,1)
 8 # print(random.uniform(1,2))  #(n,m)
 9 
10 # 隨機整數
11 # print(random.randint(1,2))  # [1,2] 包含了2
12 # print(random.randrange(1,2))    # [1,2) 不包含2
13 # print(random.randrange(1,5,2))  # 不長爲2
14 
15 # 隨機從一個列表中取一個值
16 # ret = random.choice([1, 2, 3, ('k', 'v'), {'name':'alex'}])
17 # print(ret)
18 
19 # 隨機從一個列表中取2個值
20 # ret2 = random.sample([1, 2, 3, ('k', 'v'), {'name':'alex'}], 2)
21 # print(ret2)
22 
23 # 打亂順序  洗牌
24 # l1 = [1, 2, 3, 4, 5]
25 # random.shuffle(l1)
26 # print(l1)
27 
28 # 驗證碼例子
29 # def my_code(n=6, flag=True):
30 #     code = ''
31 #     for i in range(n):
32 #         num = random.randint(0, 9)
33 #         # 注意這裏的小技巧
34 #         if flag:
35 #             alp = chr(random.randint(65, 90))
36 #             num = random.choice([num, alp])
37 #         code += str(num)
38 #     return code
39 #
40 # ret = my_code()
41 # print(ret)
42 
43 
44 # 紅包例子
45 # 思路：
46 # 1.須要肯定紅包個數，紅包總金額
47 # 2.最低金額爲0.01元
48 # 3.每抽中一次，須要用紅包當前總金額減去抽中的金額，而後在繼續在該區間內隨機抽取
49 # 4.最小金鵝爲
50 # def hb(num, money):
51 #     # 定義空列表用來存儲抽獎金額
52 #     lst = []
53 #     # 金額乘以100，便於計算，後續加入到列表在除以100
54 #     money = money * 100
55 #     # 判斷傳遞參數的合法性
56 #     if type(num) is int and num >=1 and (type(money) is int or type(money) is float):
57 #         # for循環應該比num少一次,例如2個紅包個數，for循環1次就能夠
58 #         for i in range(num-1):
59 #             # 保證不出現抽中0元的現象
60 #             p = random.randint(1, money-1*(num-1))
61 #             lst.append(p/100)
62 #             # 須要減去已經抽取的紅包金額
63 #             money = money - p
64 #             # 這裏的意思是沒抽一次，沒抽過的人減小1
65 #             num -= 1
66 #         else:
67 #             # 循環結束了，把剩餘的紅包總金額放入到一個紅包內
68 #             lst.append(money/100)
69 #         return lst
70 #     else:
71 #         print('參數有誤!')
72 #
73 # ret = hb(1,1.1)
74 # print(ret)

 

05 os模塊

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 # import os
 4 # os和操做系統打交道的
 5 
 6 # 和文件、文件夾相關的
 7 # os.makedirs('dirname1/dirname2')    # 可生成多層遞歸目錄
 8 # os.removedirs('dirname1/dirname2')    # 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
 9 # os.mkdir('dirname')    # 生成單級目錄；至關於shell中mkdir dirname
10 # os.rmdir('dirname')    # 刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
11 # ret = os.listdir(r'E:\python3週末班2期筆記\05 day05\03 筆記整理')
12 #  列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
13 # print(ret)
14 # os.remove('test.py')  # 刪除一個文件
15 # os.rename("test.py","test2.py")  # 重命名文件/目錄
16 # ret = os.stat(r'E:\python3週末班2期筆記\05 day05\03 筆記整理')  # 獲取文件/目錄信息
17 # print(ret)
18 
19 
20 # 和執行系統命令相關
21 # os.system("dir")  # 運行shell命令，直接顯示
22 # ret = os.popen('dir').read()  # 運行shell命令，獲取執行結果
23 # print(ret)
24 # ret = os.getcwd() # 獲取當前工做目錄，即當前python腳本工做的目錄路徑
25 # print(ret)
26 # os.chdir(r"E:\python3週末班2期筆記")  # 改變當前腳本工做目錄；至關於shell下cd
27 # ret = os.getcwd()
28 # print(ret)
29 # 所謂工做目錄 文件在哪一個目錄下運行 工做目錄就是哪裏
30 # 和這個文件自己所在的路徑沒有關係
31 # 1.工做目錄與文件所在位置無關
32 # 2.工做目錄和全部程序中用到的相對目錄都相關
33 
34 # 和路徑相關的
35 # os.path
36 # ret = os.path.abspath(__file__) # 返回path規範化的絕對路徑
37 # print(ret)
38 # ret = os.path.split(__file__) # 將path分割成目錄和文件名二元組返回
39 # print(ret)
40 # os.path.dirname(path) # 返回path的目錄。其實就是os.path.split(path)的第一個元素
41 # os.path.basename(path) # 返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
42 # ret = os.path.exists(r'E:\python')  # 若是path存在，返回True；若是path不存在，返回False
43 # print(ret)
44 # ret = os.path.isabs('E:\python3週末班2期筆記\05 day05\03 筆記整理')  # 若是path是絕對路徑，返回True
45 # print(ret)
46 # ret = os.path.isfile('E:\python3週末班2期筆記\05 day05\03 筆記整理')  # 若是path是一個存在的文件，返回True。不然返回False
47 # print(ret)
48 # ret = os.path.isdir('E:\python3週末班2期筆記')  # 若是path是一個存在的目錄，則返回True。不然返回False
49 # print(ret)
50 # ret = os.path.join('E:\python3週末班2期筆記', 'abc', 'def')  # 將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
51 # print(ret)
52 # os.path.getatime(path)  返回path所指向的文件或者目錄的最後訪問時間
53 # os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間
54 # ret = os.path.getsize(r'E:\python3週末班2期筆記\05 day05\03 筆記整理\00 今日課程大綱.py')
55 #  返回path的大小,文件夾的大小不許確
56 # print(ret)
57 
58 
59 # 練習題
60 # 使用python代碼 計算文件夾的大小
61 # 這個文件夾裏可能還有文件夾
62 # import os
63 # total_size=0
64 # def file_size(path):
65 #     global total_size
66 #     path=os.path.abspath(path)
67 #     print('path',path)
68 #     file_list=os.listdir(path)
69 #     print('list',file_list)
70 #     for i in file_list:
71 #         i_path = os.path.join(path, i)
72 #         if os.path.isfile(i_path):
73 #             total_size += os.path.getsize(i_path)
74 #         else:
75 #             try:
76 #                 file_size(i_path)
77 #             except RecursionError:
78 #                 print('遞歸操做時超出最大界限')
79 #     return total_size
80 #
81 # print(file_size(r'E:\02'))

 

06 sys模塊

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 import sys
 5 # sys模塊是和 python解釋器打交道的
 6 
 7 # sys.exit()    # 退出
 8 # print(123)
 9 # print(sys.version) # 版本
10 # print(sys.platform)  # 平臺 操做系統
11 
12 # print(sys.path)  # 模塊搜索路徑
13 # 包含的內容
14 # 1.內置的python安裝的時候就規定好的一些內置模塊所在的路徑
15     # 內置模塊
16     # 擴展模塊
17 # 2.當前被執行的文件所在的路徑
18     # 自定義的模塊
19 
20 # 須要在CMD執行
21 # python py文件的目錄 參數1 參數2
22 # print(sys.argv)   # []
23 # if sys.argv[1] == 'alex' and sys.argv[2] == 'alexsb':
24 #     print('登錄成功')
25 # else:
26 #     print('登錄失敗')
27 #     sys.exit()
28 # print('登錄成功後的全部代碼')

 

07 序列化模塊json

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 # 序列化模塊
 5 # 序列化
 6 # 序列 ： list str tuple bytes
 7 # 可迭代的都是序列？ 字典？集合？無序的，散列。不是序列
 8 # 狹義的序列 ：str / bytes
 9 # 序列化？把。。。變得有序，把。。。變成str或者是bytes
10 # 反序列化？把str/bytes 還原回原來的 。。。
11 
12 # 爲何要有序列化？
13 # 1.存儲在文件中 長久保存到硬盤
14 # 2.在網絡上傳遞，只能用字節
15 
16 # 序列化模塊
17 import json
18 # 可以支持全部的計算機高級語言
19 # 對數據類型的要求很是嚴格
20 # dic = {"key":"value"}
21 # ret = json.dumps(dic)   # 序列化方法
22 # print(dic,type(dic))
23 # print(ret,type(ret))
24 # with open('json_file','w') as f:
25 #     f.write(ret)
26 
27 # with open('json_file') as f:
28 #     content = f.read()
29 # d = json.loads(content)    # 反序列化方法
30 # print(d)
31 # print(d['key'])
32 
33 # 坑1：json格式規定全部的key必須是字符串數據類型
34 # dic = {1:2}
35 # ret = json.dumps(dic)
36 # print(dic[1])
37 # print(ret)
38 # new_dic = json.loads(ret)
39 # print(new_dic)
40 
41 # 坑2 ： json中的全部tuple都會被看成list處理
42 # dic = {1:(1,2,3)}
43 # ret = json.dumps(dic)
44 # print(ret)
45 # new_dic = json.loads(ret)
46 # print(new_dic)
47 
48 # dic = {(1,2):(1,2,3)}
49 # ret = json.dumps(dic)
50 # print(ret)
51 # new_dic = json.loads(ret)
52 # print(new_dic)
53 
54 # 特性3： json能支持的數據類型很是有限，字符串 數字 列表 字典
55 
56 
57 # dumps loads   字符串 和 其餘基礎數據類型之間轉換
58 # dump  load    文件   和 其餘基礎數據類型之間轉換
59 #
60 # dump load
61 # dic = {"key":"value"}
62 # with open('json_file2','w') as f:
63 #     json.dump(dic,f)
64 #
65 # with open('json_file2') as f:
66 #     ret = json.load(f)
67 # print(ret['key'])
68 
69 
70 # json不能夠dump屢次
71 # dic = {"key":"value"}
72 # with open('json_file2','w') as f:
73 #     json.dump(dic,f)
74 #     json.dump(dic,f)
75 #
76 # with open('json_file2', 'r') as f:
77 #     ret = json.load(f)
78 
79 
80 # 若是須要dump屢次，按照下面的方法
81 # str_dic = {"name": "alex","sex":None}
82 # ret = json.dumps(str_dic)
83 # with open('json_file2','w') as f:
84 #     f.write(ret+'\n')
85 #     f.write(ret+'\n')
86 #
87 # with open('json_file2', 'r') as f:
88 #     for line in f:
89 #         print(json.loads(line), type(json.loads(line)))

 

08 序列化模塊pickle

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 
 4 import pickle
 5 
 6 # 1.支持幾乎全部python中的數據類型
 7 # 2.只在python語言中通用
 8 # 3.pickle適合bytes類型打交道的
 9 # s = {1,2,3,4}
10 # ret = pickle.dumps(s)
11 # print(ret)
12 #
13 # ret2 = pickle.loads(ret)
14 # print(ret2)
15 
16 
17 # pickle：序列化時候數據是什麼類型，反序列化之後數據仍是原來的類型，這點和 json 有點不同
18 # d = {1:2,3:4}
19 # ret = pickle.dumps(d)
20 # print(ret)
21 # new_d = pickle.loads(ret)
22 # print(new_d)
23 #
24 # s = {(1,2,3):2,3:4}
25 # result = pickle.dumps(s)
26 # print(result)
27 # with open('pickle_file','wb') as f:
28 #     f.write(result)
29 #
30 # with open('pickle_file','rb') as f:
31 #     content = f.read()
32 # ret = pickle.loads(content)
33 # print(ret,type(ret))
34 
35 
36 # pickle 能夠支持多個對象放入文件
37 # pickle 能夠dump屢次，也能夠load屢次
38 # s1 = {1,2,3}
39 # s2 = {1:2,3:4}
40 # s3 = ['k','v',(1,2,3),4]
41 # with open('pickle_file2','wb') as f:
42 #     pickle.dump(s1,f)
43 #     pickle.dump(s2,f)
44 #     pickle.dump(s3,f)
45 #
46 # with open('pickle_file2','rb') as f:
47 #     count = 1
48 #     while count <= 3:
49 #         try:
50 #             content = pickle.load(f)
51 #             print(content)
52 #             count += 1
53 #         except EOFError:
54 #             break
55 
56 
57 # json      ---實際上使用json更多。優先選擇
58 # 若是你是要跨平臺溝通，那麼推薦使用json
59 # key只能是字符串
60 # 不能屢次load和dump
61 # 支持的數據類型有限
62 
63 # pickle
64 # 若是你是隻在python程序之間傳遞消息，而且要傳遞的消息是比較特殊的數據類型
65 # 處理文件的時候 rb/wb
66 # 支持屢次dump/load

 

09 正則表達式

  1 #!/usr/bin/env python3
  2 #author:Alnk(李成果)
  3 
  4 # 咱們使用的模塊和這個模塊要完成的功能是分不開的
  5 # re模塊 ：是用來在python中操做 正則表達式 的
  6 # 要先知道正則表達式是什麼？作什麼用的？怎麼用
  7 
  8 # 正則表達式檢測網站
  9 # http://tool.chinaz.com/regex/
 10 
 11 # 郵箱地址
 12 # 用戶名 密碼
 13 # 要檢測一個用戶輸入的內容是否符合個人規則
 14 
 15 # 用戶輸入的內容對於程序員來講都是字符串
 16 # 一個文件是一堆字符串，有不少內容
 17 
 18 # 檢測某一個字符串是否符合規則 -- 本質 -- 需求一
 19 # 從一大段文字中找到符合規則的字符串 -- 需求二
 20 
 21 # 正則表達式  --> 字符串規則匹配的
 22 # 1.判斷某一個字符串是否符合規則
 23 # 2.從一段文字中提取出符合規則的內容
 24 
 25 
 26 # 初識正則表達式
 27 #
 28 # 字符組的概念。
 29 # [ ]表示字符組，一個[ ]表示一個字符組
 30 # [1-9]
 31 # [0-9]
 32 # [1-5]
 33 # [a-z]
 34 # [a-f]
 35 # 1.對字母來講 區分大小寫
 36 # 2.a-f能夠 f-a不行
 37 # 一個字符位置上能夠出現的內容是匹配數字或字母：[0-9a-zA-Z]
 38 # 匹配一個兩位數:# [1-9][0-9]
 39 
 40 
 41 # 元字符
 42 # \d    數字
 43 # \w    數字 字母 下劃線
 44 # \s    空格 回車 製表符
 45 # \t    製表符
 46 # \n    回車
 47 # \b    匹配一個單詞的邊界。例如 hello world  o\b會匹配hello的o
 48 #
 49 # \D    非數字
 50 # \W    非數字字母下劃線
 51 # \S    非空白
 52 
 53 
 54 # ^      一個字符串的開始
 55 # $      一個字符串的結尾
 56 # ^xxxx$  約束的了整個字符串中的內容必須一一與表達式對應上
 57 # 例如: hello hello hello
 58 # ^hello 只能匹配第一個hello
 59 # hello$ 只能匹配最後一個hello
 60 # hello^  不能匹配任何字符串。由於 ^ 是開頭，沒有可能在開頭在出現字符。
 61 
 62 # |       表示或
 63 # 例子：匹配ab或abc  要這樣寫 abc|ab  把長的表達式寫在前面
 64 
 65 # ()      分組
 66 #     # a(b|c)d
 67 #例子：www.baidu.com www.baide.com  表達式 www.baid(u|e).com
 68 
 69 # . 表示除了換行符之外的任意字符
 70 
 71 # 非 字符組
 72 # [^ABC] 只要不是ABC都能匹配
 73 
 74 
 75 # 量詞
 76 # {n}   在這個量詞前面的一個元字符出現n次
 77 # {n,}  在這個量詞前面的一個元字符出現n次或n次以上
 78 # {n,m}  在這個量詞前面的一個元字符出現n次到m次以上
 79 #
 80 # ?     在這個量詞前面的一個元字符出現0次或者1次
 81 # +     在這個量詞前面的一個元字符出現1次或者屢次
 82 # *     在這個量詞前面的一個元字符出現0次或者屢次
 83 #
 84 # 例子：
 85 # 1.匹配一個整數：\d+
 86 # 2.匹配一個小數：\d+\.\d+
 87 # 3.匹配整數或者小數： 表達式 \d+(\.\d+)?   括號裏面的被量詞?問號約束，約束了一組字符的出現次數
 88 
 89 # 小練習
 90 # 正則表達式默認都是貪婪匹配
 91 # 貪婪匹配：會盡可能多的幫咱們匹配內容
 92 # 例子 待匹配字符：李傑和李蓮英和李二棍子  正則表達式：李.?   匹配結果：李傑  李蓮  李二 匹配到這3條
 93 
 94 # 回溯算法下的貪婪匹配
 95 # 例子：待匹配字符:<a>bbbb<a> 正則表達式:<.*> 匹配結果:<a>bbbb<a>
 96 
 97 # 非貪婪模式，
 98 # 在量詞後面加一個問號，開啓非貪婪模式
 99 # 惰性匹配：儘可能少的匹配
100 # 例子：待匹配字符:<a>bbbb<a> 正則表達式:<.*?> 匹配結果:<a>    <a>  這兩條
101 
102 # 例子 待匹配字符：李傑和李蓮英和李二棍子  正則：李[傑蓮英二棍子]*    匹配結果：李傑 李蓮英 李二棍子
103 # 例子 待匹配字符：李傑和李蓮英和李二棍子  正則：李[^和]*             匹配結果：李傑 李蓮英 李二棍子
104 
105 # 例子
106 # 身份證號碼是一個長度爲15或18個字符的字符串，若是是15位則所有🈶️數字組成，首位不能爲0；
107 # 若是是18位，則前17位所有是數字，末位多是數字或x
108 # ^[1-9]\d{14}(\d{2}[x\d])?$
109 # ^([1-9]\d{16}[\dx]|[1-9]\d{14})$
110 
111 # 轉義符例子
112 # r'\\n' 匹配 '\n'
113 
114 # .*?x   ：爬蟲經常使用 ，表示匹配任意字符，直到碰見x中止
115 
116 
117 # 練習題
118 # 一、 匹配一段文本中的每行的郵箱
119 #       http://blog.csdn.net/make164492212/article/details/51656638
120 #
121 # 二、 匹配一段文本中的每行的時間字符串，好比：‘1990-07-12’；
122 #
123 #    分別取出1年的12個月（^(0?[1-9]|1[0-2])$）、
124 #    一個月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$
125 #
126 # 三、 匹配qq號。(騰訊QQ號從10000開始)  ［1,9］[0,9]{4,}
127 #
128 # 四、 匹配一個浮點數。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*
129 #
130 # 五、 匹配漢字。             ^[\u4e00-\u9fa5]{0,}$
131 #
132 # 六、 匹配出全部整數

 

 

10 re模塊

 1 #!/usr/bin/env python3
 2 #author:Alnk(李成果)
 3 import re
 4 
 5 # findall()
 6 # ret = re.findall('\d+','h2b3123') # 匹配全部
 7 # print(ret)
 8 
 9 # search()
10 # ret = re.search('\d+','h2b3123')  # 只匹配從左到右的第一個
11 # print(ret)  # 變量
12 # print(ret.group())
13 #
14 # ret = re.search('\d+','aaaab123')  # 只匹配從左到右的第一個
15 # if ret:
16 #     print(ret.group())
17 
18 # compile() # 節省時間
19 # '\d+'  --> 正則規則 --> python代碼 --> 將字符串按照代碼執行匹配
20 # re.findall('\d+','ahkfgilWIVKJBDKvjgheo')
21 # re.findall('\d+','ahkfgilsk0194750dfjWIVKJBDKvjgheo')
22 # re.findall('\d+','ahkfgilsk0vv194750dfjWIVKJBDKvjgheo')
23 #
24 # ret = re.compile('\d+')
25 # ret.findall('ahkfgilWIVKJBDKvjgheo')
26 # ret.search('ahkfgilsk0194750dfjWIVKJBDKvjgheo')
27 #
28 # ret = re.finditer('\d+','dskh1040dsvk034fj048d3g5h4j')
29 # for r in ret:
30 #     print(r.group())
31 
32 # search
33 # findall
34 # compile 節省時間 一條正則表達式用屢次
35 # finditer 節省空間 結果的條數不少的時候
36 
37 
38 # ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
39 # print(ret)
40 # 分組遇到findall，優先顯示分組中匹配到的內容
41 # 如何取消分組優先？  ?:
42 
43 
44 # 練習題
45 # 匹配標籤
46 #
47 # s = '<h1>abc</h1>'
48 # ret = re.search('<(\w+)>', s)
49 # print(ret.group())
50 # 分組
51 # ret = re.search('<(\w+)>(.*?)<(/\w+)>',s)
52 # print(ret.group(1))
53 # print(ret.group(2))
54 # print(ret.group(3))
55 
56 
57 # s = '<h1>abc</h1>'
58 # ret = re.search('<(?P<tag>\w+)>(.*?)<(/\w+)>',s)
59 # print(ret.group('tag'))
60 # s = '<h1>abc</h1>'
61 # ret = re.search('<(?P<tag>\w+)>(.*?)</(?P=tag)>',s)
62 # print(ret)
63 
64 
65 
66 # 匹配標籤
67 # ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
68 # #還能夠在分組中利用?<name>的形式給分組起名字
69 # #獲取的匹配結果能夠直接用group('名字')拿到對應的值
70 # print(ret.group('tag_name'))  #結果 ：h1
71 # print(ret.group())  #結果 ：<h1>hello</h1>
72 #
73 # ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
74 # #若是不給組起名字，也能夠用\序號來找到對應的組，表示要找的內容和前面的組內容一致
75 # #獲取的匹配結果能夠直接用group(序號)拿到對應的值
76 # print(ret.group(1))
77 # print(ret.group())  #結果 ：<h1>hello</h1>

 

11 遞歸函數

  1 #!/usr/bin/env python3
  2 #author:Alnk(李成果)
  3 
  4 # 在講今天的內容以前，咱們先來說一個故事，講的什麼呢？從前有座山，山裏有座廟，廟裏有個老和尚講故事，
  5 # 講的什麼呢？從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麼呢？
  6 # 從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麼呢？
  7 # 從前有座山，山裏有座廟，廟裏有個老和尚講故事，講的什麼呢......
  8 # 這個故事大家不喊停我能講一天！
  9 # 咱們說，生活中的例子也能被寫成程序，剛剛這個故事，讓大家寫，大家怎麼寫呀？
 10 #
 11 # def story():
 12 #     s = """
 13 #     從前有個山，山裏有座廟，廟裏老和尚講故事，
 14 #     講的什麼呢？
 15 #     """
 16 #     print(s)
 17 #     story()
 18 # story()
 19 
 20 
 21 # 遞歸的定義——在一個函數裏再調用這個函數自己
 22 # 如今咱們已經大概知道剛剛講的story函數作了什麼，就是在一個函數裏再調用這個函數自己，這種魔性的使用函數的方式就叫作遞歸。
 23 #
 24 # 遞歸的最大深度——997
 25 # def foo(n):
 26 #     print(n)
 27 #     n += 1
 28 #     foo(n)
 29 # foo(1)
 30 # 由此咱們能夠看出，未報錯以前能看到的最大數字就是997.固然了
 31 #
 32 # 咱們固然還能夠經過一些手段去修改它
 33 # import sys
 34 # print(sys.setrecursionlimit(100000))
 35 # 咱們能夠經過這種方式來修改遞歸的最大深度，剛剛咱們將python容許的遞歸深度設置爲了10w
 36 # 至於實際能夠達到的深度就取決於計算機的性能了
 37 # 不過咱們仍是不推薦修改這個默認的遞歸深度，
 38 # 由於若是用997層遞歸都沒有解決的問題要麼是不適合使用遞歸來解決要麼是你代碼寫的太爛
 39 
 40 
 41 # 例一
 42 # 如今大家問我，alex老師多大了？我說我不告訴你，但alex比 egon 大兩歲。
 43 # 你想知道alex多大，你是否是還得去問egon？egon說，我也不告訴你，但我比武sir大兩歲。
 44 # 你又問武sir，武sir也不告訴你，他說他比金鑫大兩歲。
 45 # 那你問金鑫，金鑫告訴你，他40了。。。
 46 # 這個時候你是否是就知道了？alex多大？
 47 #
 48 # 1    金鑫　　    40
 49 # 2    武sir　　    42
 50 # 3    egon　　    44
 51 # 4    alex　　　  46
 52 # 你爲何能知道的？
 53 # 首先，你是否是問alex的年齡，結果又找到egon、武sir、金鑫，你挨個兒問過去，
 54 # 一直到拿到一個確切的答案，而後順着這條線再找回來，
 55 # 才獲得最終alex的年齡。這個過程已經很是接近遞歸的思想。咱們就來具體的我分析一下，這幾我的之間的規律
 56 #
 57 # age(4) = age(3) + 2
 58 # age(3) = age(2) + 2
 59 # age(2) = age(1) + 2
 60 # age(1) = 40
 61 # 函數應該怎麼寫呢
 62 # def age(n):
 63 #     if n == 1:
 64 #         return 40
 65 #     else:
 66 #         return age(n-1)+2
 67 #
 68 # print(age(4))
 69 
 70 
 71 # 例二
 72 # 遞歸函數與三級菜單
 73 '''
 74 menu = {
 75     '北京': {
 76         '海淀': {
 77             '五道口': {
 78                 'soho': {},
 79                 '網易': {},
 80                 'google': {}
 81             },
 82             '中關村': {
 83                 '愛奇藝': {},
 84                 '汽車之家': {},
 85                 'youku': {},
 86             },
 87             '上地': {
 88                 '百度': {},
 89             },
 90         },
 91         '昌平': {
 92             '沙河': {
 93                 '老男孩': {},
 94                 '北航': {},
 95             },
 96             '天通苑': {},
 97             '回龍觀': {},
 98         },
 99         '朝陽': {},
100         '東城': {},
101     },
102     '上海': {
103         '閔行': {
104             "人民廣場": {
105                 '炸雞店': {}
106             }
107         },
108         '閘北': {
109             '火車戰': {
110                 '攜程': {}
111             }
112         },
113         '浦東': {},
114     },
115     '山東': {},
116 }
117 '''
118 
119 # def digui(dic):
120 #     while 1:
121 #         for k in dic:
122 #             print(k)
123 #         choice = input('>>>:').strip()
124 #
125 #         if choice == 'b' or choice =='q':
126 #             return choice
127 #
128 #         elif dic.get(choice):
129 #             ret = digui(dic[choice])
130 #             if ret == 'q':
131 #                 return
132 #
133 # digui(menu)