python常見模組-collections-time-datetime-random-os-sys-序列化反序列化模組(json-pickle)-subprocess-03

• 2019 年 10 月 7 日
• 筆記

 collections模組-數據類型擴展模組

'''  在內置數據類型（dict、list、set、tuple）的基礎上，collections模組還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。      1.namedtuple: 生成可以使用名字來訪問元素內容的tuple      2.deque: 雙端隊列，可以快速的從另外一側追加和推出對象      3.Counter: 計數器，主要用來計數      4.OrderedDict: 有序字典      5.defaultdict: 帶有默認值的字典  '''

namedtuple 具名元組

from collections import namedtuple  point = namedtuple('坐標點', ['x', 'y'])  p = point(1.0, 10.2)  print(p)  # 坐標點(x=1.0, y=10.2)  print(p.x)  print(p.y)  # 1.0  # 10.2      def namedtuple_code():      from collections import namedtuple        # 第一個是類名，第二個是類的各個欄位的名字。後者可以是由數個字元串組成的可迭代對象，或者是由空格分隔開的欄位名組成的字元串      # name_list = ['name', 'country', 'population', 'area']      # City = namedtuple('City', name_list)      City = namedtuple('City', 'name country population area')      # # 注意：元素的個數必須跟namedtuple第二個參數裡面的值對應元素的數量一致      shanghai = City('shanghai', 'China', 24240000, '華東')      beijing = City('beijing', 'China', 21540000, '華北')        print(shanghai)      print(shanghai.name, shanghai.country, shanghai.population, shanghai.area)      print(shanghai[0], shanghai[1], shanghai[2], shanghai[3])  # 可以直接用 .名字 取值，也可以直接用索引取值      # City(name='shanghai', country='China', population=24240000, area='華東')      # shanghai China 24240000 華東      # shanghai China 24240000 華東      print(beijing)      print(beijing.name, beijing.country, beijing.population, beijing.area)      # City(name='beijing', country='China', population=21540000, area='華北')      # beijing China 21540000 華北        target_city = []      target_city.append(shanghai)      target_city.append(beijing)      print(target_city)      # [City(name='shanghai', country='China', population=24240000, area='華東'), City(name='beijing', country='China', population=21540000, area='華北')]

deque 雙端隊列(FIFO: first in first out)

# 特殊點，雙端隊列可以根據索引在任意位置插值（隊列不應該支援任意位置插值，只能在首尾插值）  #   使用list存儲數據時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性存儲，數據量大的時候，插入和刪除效率很低。  #   deque是為了高效實現插入和刪除操作的雙向列表，適合用於隊列和棧

from collections import deque  q = deque(['a', 'b', 'c'])  q.append(1)  # 尾部添加  q.appendleft(2)  # 開頭添加  print(q)  print(q.pop(), q.popleft())  # 尾部出隊， 頭部出隊  print(q)  # deque([2, 'a', 'b', 'c', 1])  # 1 2  # deque(['a', 'b', 'c'])  q.insert(1, '哈哈哈')  print(q)  # deque(['a', '哈哈哈', 'b', 'c'])

擴展：queue隊列模組

import queue  '''  put 往隊列添加值  get 從隊列取值  '''  q = queue.Queue()  # 生成隊列對象  print(q)  # <queue.Queue object at 0x000002D69AF45198>  q.put('first')  # 往隊列里添值  q.put('second')  q.put('third')  print(q.get())  # 從隊列取值  print(q.get())  print(q.get())  # print(q.get())  # 如果隊列中的值取完了，程式會在原地等待，直到從隊列中拿到值才停止  # first  # second  # third  # ---原地等待----

OrderedDict 有序字典

# 跟普通的字典的區別是有序無序（插入順序）  #   OrderedDict的Key會按照插入的順序排列  from collections import OrderedDict  ordered_d1 = OrderedDict([('a', 1), ('b', 2)])  print(ordered_d1)  # OrderedDict([('a', 1), ('b', 2)])  # python自帶字典無序可以在python2.x 中驗證

defalutdict 默認值字典

# defaultdict 默認值字典，後續字典中新建的key對應的值就是括弧里的  #           在使用key取值的時候，如果key不存在，會返回定義時的那個默認值 defaultdict(list)  #           與之前fromkeys 空列表的區別，不會共用同一個列表  from collections import defaultdict  values = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]  my_dict = defaultdict(list)  # 後續該字典中新建的key對應的value默認就是列表  for value in values:      if value > 66:          my_dict['k1'].append(value)      else:          my_dict['k2'].append(value)  print(my_dict)  # defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})    # int 的默認值是0， bool 的默認值是False， tuple的默認值是 ()  my_dict1 = defaultdict(int)  print(my_dict1['xxx'])  print(my_dict1['yyy'])  # 0  # 0  my_dict2 = defaultdict(bool)  print(my_dict2['kkk'])  # False  my_dict3 = defaultdict(tuple)  print(my_dict3['mmm'])  # ()

Counter 計數

# Counter 計數，跟蹤值出現的次數，一個無序的容器類型，以字典的鍵值對形式存儲，其中元素作為key，其計數作為value。  from collections import Counter  l = [1, 3, 'a', 'c', 'aa', 'a', 'b', 'c']  c = Counter(l)  print(c)  # Counter({'a': 2, 'c': 2, 1: 1, 3: 1, 'aa': 1, 'b': 1})

s = 'abcdeabcdabcaba'  # 普通python程式碼寫法  d = {}  for i in s:      if i not in d:          d[i] = 1      else:          d[i] += 1  print(d)  # {'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}    # Counter 計數寫法  from collections import Counter  s = Counter('abcdeabcdabcaba')  print(s)  # Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

time模組與datetime模組-日期時間模組（完善中）

和時間有關係的我們就要用到時間模組。在使用模組之前，應該首先導入這個模組。

#常用方法  1.time.sleep(secs)  (執行緒)推遲指定的時間運行。單位為秒。  2.time.time()  獲取當前時間戳

表示時間的三種方式

'''      在Python中，通常有這三種方式來表示時間：時間戳、格式化的時間字元串、結構化時間(struct_time 元組)：        (1)時間戳(timestamp) ：          通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。我們運行「type(time.time())」，返回的是float類型。        (2)格式化的時間字元串(Format String)：          『1999-12-06 12:18:16』，人們平時見得最多的時間格式。        (3)結構化時間(struct_time) ：          struct_time元組共九個元素:(年，月，日，時，分，秒，周幾，一年中第幾天，是否夏令時）  '''

獲取當前時間的三種格式

import time    print(time.localtime())  # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=27, tm_hour=8, tm_min=30, tm_sec=51, tm_wday=5, tm_yday=208, tm_isdst=0)    print(time.time())  # 1564187451.786054    print(time.strftime("%Y-%m-%d %H-%M-%S"))  # 2019-07-27 08-32-06

結構化時間返回值含義

格式化時間的參數含義

'''      %y 兩位數的年份表示（00-99）      %Y 四位數的年份表示（000-9999）      %m 月份（01-12）      %d 月內中的一天（0-31）      %H 24小時制小時數（0-23）      %I 12小時制小時數（01-12）      %M 分鐘數（00=59）      %S 秒（00-59）      %a 本地簡化星期名稱      %A 本地完整星期名稱      %b 本地簡化的月份名稱      %B 本地完整的月份名稱      %c 本地相應的日期表示和時間表示      %j 年內的一天（001-366）      %p 本地A.M.或P.M.的等價符      %U 一年中的星期數（00-53）星期天為星期的開始      %w 星期（0-6），星期天為星期的開始      %W 一年中的星期數（00-53）星期一為星期的開始      %x 本地相應的日期表示      %X 本地相應的時間表示      %Z 當前時區的名稱      %% %號本身  '''

小結：時間戳是電腦能夠識別的時間；格式化時間是人能夠看懂的時間；結構化時間則是用來操作時間的

幾種格式之間的轉換（格式化時間 和 時間戳 之間不能直接轉換）

import time  # ------------------------------------------------------  # 時間戳 --> 結構化時間 gmtime localtime  # time.gmtime(時間戳)   UTC時間  #   與英國倫敦當地時間一致  # time.localtime(時間戳) 當地時間  #   在北京執行：與UTC時間相差8小時，UTC時間+8小時 = 北京時間  # ------------------------------------------------------  # now_time = time.time()  now_time = 1564915435.9014683  print(now_time)  # 1564915435.9014683  print(type(now_time))  # <class 'float'>    print(time.gmtime(now_time))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=10, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=0)    print(time.localtime(now_time))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=18, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=0)  print(type(time.localtime(now_time)))  # <class 'time.struct_time'>      # ------------------------------------------------------  # 結構化時間 --> 時間戳 mktime  # ------------------------------------------------------  tuple_time = time.gmtime(now_time)  print(time.mktime(tuple_time))  # 1564886635.0    tuple_time2 = time.localtime(now_time)  print(time.mktime(tuple_time2))  # 1564915435.0  print(type(time.mktime(tuple_time2)))  # <class 'float'>      # ------------------------------------------------------  # 結構化時間 --> 格式化時間 strftime  # ------------------------------------------------------  #   gmtime --> 格式化時間  print(time.strftime('%Y-%m-%d %H:%M:%S', tuple_time))  # 2019-08-04 10:43:55  #   localtime --> 格式化時間  print(time.strftime('%Y-%m-%d %H:%M:%S', tuple_time2))  # 2019-08-04 18:43:55  print(type(time.strftime('%Y-%m-%d %H:%M:%S', tuple_time2)))  # <class 'str'>    # ------------------------------------------------------  # 格式化時間 --> 結構化時間 strptime  # ------------------------------------------------------  print(time.strptime('2019-08-04 10:43:55', '%Y-%m-%d %H:%M:%S'))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=10, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=-1)  print(time.strptime('2019-08-04 18:43:55', '%Y-%m-%d %H:%M:%S'))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=18, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=-1)  print(type(time.strptime('2019-08-04 18:43:55', '%Y-%m-%d %H:%M:%S')))  # <class 'time.struct_time'>

import time  now_time = 1564915435.9014683  tuple_time = time.gmtime(now_time)  tuple_time2 = time.localtime(now_time)  # ------------------------------------------------------  # 格式化時間 --> 結構化時間 strptime  # ------------------------------------------------------  print(time.strptime('2019-08-04 10:43:55', '%Y-%m-%d %H:%M:%S'))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=10, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=-1)  print(time.strptime('2019-08-04 18:43:55', '%Y-%m-%d %H:%M:%S'))  # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=4, tm_hour=18, tm_min=43, tm_sec=55, tm_wday=6, tm_yday=216, tm_isdst=-1)  print(type(time.strptime('2019-08-04 18:43:55', '%Y-%m-%d %H:%M:%S')))  # <class 'time.struct_time'>      # ------------------------------------------------------  # 結構化時間 轉 %a %b %d %H:%M:%S %Y  # ------------------------------------------------------  print(time.asctime(tuple_time))  print(time.asctime(tuple_time2))  print(time.asctime())  # Sun Aug  4 10:43:55 2019  # Sun Aug  4 18:43:55 2019  # Sun Aug  4 20:11:50 2019    # ------------------------------------------------------  # 時間戳 --> %a %b %d %H:%M:%S %Y  # ------------------------------------------------------  print(time.ctime(now_time))  print(time.ctime())  # Sun Aug  4 18:43:55 2019  # Sun Aug  4 20:11:50 2019    print(type(time.asctime()))  # <class 'str'>  print(type(time.ctime()))  # <class 'str'>

案例計算兩日期之間的日期間隔

'''      計算紀念日過去了多久小案例  '''  import time    target_time = time.mktime(time.strptime('2017-11-21 21:11:34', '%Y-%m-%d %H:%M:%S'))  # 紀念日時間（將格式化時間轉換為結構化時間再轉換為時間戳）  # now_time = time.mktime(time.strptime('2017-09-12 11:00:00', '%Y-%m-%d %H:%M:%S'))  # 當前時間或指定時間（算之間的時間距離）  now_time = time.time()  # 當前時間(當前時間時間戳)  dif_time = now_time - target_time  # 相距時間  struct_time = time.gmtime(dif_time)  # 將時間戳轉換為結構化時間  print('距離目標日期過去了%d年%d月%d天%d小時%d分鐘%d秒'        % (struct_time.tm_year - 1970,           struct_time.tm_mon - 1,           struct_time.tm_mday - 1, struct_time.tm_hour,           struct_time.tm_min, struct_time.tm_sec))  # 將結構化時間轉換為格式化時間（人能看得懂的時間格式）  # 距離目標日期過去了1年8月3天23小時59分鐘10秒

datetime模組

import datetime    # 自定義日期  res = datetime.date(2019, 7, 15)  print(res)  # 2019-07-15    # 獲取本地時間  # 年月日  now_date = datetime.date.today()  print(now_date)  # 2019-07-01  # 年月日時分秒  now_time = datetime.datetime.today()  print(now_time)  # 2019-07-01 17:46:08.214170    # 無論是年月日，還是年月日時分秒對象都可以調用以下方法獲取針對性的數據  # 以datetime對象舉例  print(now_time.year)  # 獲取年份2019  print(now_time.month)  # 獲取月份7  print(now_time.day)  # 獲取日1  print(now_time.weekday())  # 獲取星期(weekday星期是0-6) 0表示周一  print(now_time.isoweekday())  # 獲取星期(weekday星期是1-7) 1表示周一    # timedelta對象  # 可以對時間進行運算操作  import datetime    # 獲得本地日期 年月日  tday = datetime.date.today()  # 定義操作時間 day=7 也就是可以對另一個時間對象加7天或者減少7點  tdelta = datetime.timedelta(days=7)    # 列印今天的日期  print('今天的日期:{}'.format(tday))  # 2019-07-01  # 列印七天後的日期  print('從今天向後推7天:{}'.format(tday + tdelta))  # 2019-07-08  # 總結:日期對象與timedelta之間的關係  """  日期對象 = 日期對象 +/- timedelta對象  timedelta對象 = 日期對象 +/- 日期對象    驗證:    """  # 定義日期對象  now_date1 = datetime.date.today()  # 定義timedelta對象  lta = datetime.timedelta(days=6)  now_date2 = now_date1 + lta  # 日期對象 = 日期對象 +/- timedelta對象  print(type(now_date2))  # <class 'datetime.date'>  lta2 = now_date1 - now_date2  # timedelta對象 = 日期對象 +/- 日期對象  print(type(lta2))  # <class 'datetime.timedelta'>      # 小練習 計算舉例今年過生日還有多少天  birthday = datetime.date(2019, 12, 21)  now_date = datetime.date.today()  days = birthday - now_date  print('生日：{}'.format(birthday))  print('今天的日期：{}'.format(tday))  print('距離生日還有{}天'.format(days))      # 總結年月日時分秒及時區問題  import datetime    dt_today = datetime.datetime.today()  dt_now = datetime.datetime.now()  dt_utcnow = datetime.datetime.utcnow()  # UTC時間與我們的北京時間cha ju    print(dt_today)  print(dt_now)  print(dt_utcnow)

# time  """  三種表現形式      1.時間戳      2.格式化時間(用來展示給人看的)      3.結構化時間  """  import time  # print(time.time())    # print(time.strftime('%Y-%m-%d'))  # print(time.strftime('%Y-%m-%d %H:%M:%S'))  # print(time.strftime('%Y-%m-%d %X'))  # %X等價於%H:%M:%S  # print(time.strftime('%H:%M'))  # print(time.strftime('%Y/%m'))    # print(time.localtime())    # print(time.localtime(time.time()))  # res = time.localtime(time.time())  # print(time.time())  # print(time.mktime(res))  # print(time.strftime('%Y-%m',time.localtime()))  # print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m'))            # datetime  import datetime  # print(datetime.date.today())  # date>>>:年月日  # print(datetime.datetime.today())  # datetime>>>:年月日 時分秒  # res = datetime.date.today()  # res1 = datetime.datetime.today()  # print(res.year)  # print(res.month)  # print(res.day)  # print(res.weekday())  # 0-6表示星期  0表示周一    # print(res.isoweekday())  # 1-7表示星期 7就是周日  """  (******)  日期對象 = 日期對象 +/- timedelta對象  timedelta對象 = 日期對象 +/- 日期對象  """  # current_time = datetime.date.today()  # 日期對象  # timetel_t = datetime.timedelta(days=7)  # timedelta對象  # res1 = current_time+timetel_t  # 日期對象  #  # print(current_time - timetel_t)  # print(res1-current_time)      # 小練習 計算今天距離今年過生日還有多少天  # birth = datetime.datetime(2019,12,21,8,8,8)  # current_time = datetime.datetime.today()  # print(birth-current_time)    # UTC時間  # dt_today = datetime.datetime.today()  # dt_now = datetime.datetime.now()  # dt_utcnow = datetime.datetime.utcnow()  # print(dt_utcnow,dt_now,dt_today)

計算日期時間案例

'''      計算過去了多少天小案例  '''  import datetime    target_time = datetime.datetime(2017, 11, 21, 21, 11, 34)  current_time = datetime.datetime.today()  dif_time = current_time - target_time  print(f"距離目標日期過去了{dif_time.days}天")  # 距離目標日期過去了612天

random模組-隨機模組

python產生隨機數的（無規律）模組， # 此部分的列印結果僅供參考（因為是隨機的，所以可能每次都會不同）

import random    # random 隨機生成 0-1之間的小數  print(random.random())  # 0.322594699359685    # randint(1, 5)隨機生成1-5之間的整數（包含1和5）  print(random.randint(1, 5))  # 2    # choice 隨機返回傳入的迭代對象中的一個值  print(random.choice([1, '23', [4, 5]]))  # [4, 5]    # shuffle 打亂傳入列表的元素順序  item = [1, 3, 5, 6, 7]  print(random.shuffle(item), item)  # None [6, 7, 1, 3, 5]  print(random.shuffle(item), item)  # None [6, 7, 5, 1, 3]

import random    # uniform(1, 3) 隨機返回一個大於1小於3的小數  print(random.uniform(1, 3))  # 2.2101994265961986    # randrange(1, 10, 2) 隨機返回一個大於1且小於10之間的奇數  print(random.randrange(1, 10, 2))  # 3    # sample(可迭代對象, 返回個數) 隨機選擇指定個數（第二個參數）的元素返回（放在列表裡）  print(random.sample([1, '23', [4, 5]], 2))  # [[4, 5], 1]

生成指定位數驗證碼demo

'''  要求： 5位數的隨機字元串驗證碼（組成：大寫字母 小寫字母 數字）      寫成函數，用戶輸入幾，就生成幾位        print(ord('a'), ord('z'))      # 97 122      print(ord('A'), ord('Z'))      # 65 90      print(ord('0'), ord('9'))      # 48 57  '''

import random      def get_code(n):      code = ''      for i in range(n):          # 先生成隨機的大寫字母 小寫字母 數字          upper_str = chr(random.randint(65, 90))          lower_str = chr(random.randint(97, 122))          random_int = str(random.randint(0, 9))          # 從上面三個中隨機選擇一個作為隨機驗證碼的某一位          code += random.choice([upper_str, lower_str, random_int])      return code      n = int(input("Please input the count of you want>>>:").strip())  # 假定用戶輸入的都是合法數字  res = get_code(n)  print(res)  # Please input the count of you want>>>:5  # P5SSZ

# 生成所有0-9數字字元列表  num_list = [chr(i) for i in range(48, 57+1)]  # 生成所有小寫字母列表  lower_letter_list = [chr(i) for i in range(97, 122+1)]  # 生成所有大寫字母列表  upper_letter_list = [chr(i) for i in range(65, 90+1)]    # 將大小寫字母以及數字都放到一個大列表裡去  verify_char_list = []  verify_char_list.extend(num_list)  verify_char_list.extend(lower_letter_list)  verify_char_list.extend(upper_letter_list)  # print(verify_char_list)  # # ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']      # 根據用戶輸入的次數,生成指定位數的隨機字元串  def get_verify_code(count):      # 寫法一      # random_code = []      # for i in range(count):      #     # 隨機取一個字元，並放到驗證碼的列表裡      #     random_code.append(random.choice(verify_char_list))      # return ''.join(random_code)  # 將列表裡的所有字元拼起來，返回給調用者        # 寫法二 （有bug，這樣生成的驗證碼，每一位都不同，不太符合常規）      random_code = random.sample(verify_char_list, count)      return ''.join(random_code)        count = int(input("Please input the count of your verify code>>>:").strip())  print(get_verify_code(count))  # Please input the count of your verify code>>>:8  # Ht1ixiea

os模組-作業系統的文件系統

 os模組是與作業系統交互的一個介面

常見方法

import os  # os模組主要用來與文件系統打交道  # os.path.dirname() 獲取上級目錄  BASE_DIR = os.path.dirname(os.path.dirname(__file__))    # os.path.join() 拼接路徑專用（不需要自己處理window與linux等平台的目錄分隔符（/）不同問題）  name = 'jason'  print(os.path.join(BASE_DIR, f'{name}.json'))  # E:/PyCharm 2019.1.3/ProjectFile/day010jason.json  my_path = os.path.join(BASE_DIR, 'db', 'db2', 'CodeMan', f'{name}.json')  # 可傳多個參數，依次拼接  print(my_path)  # E:/PyCharm 2019.1.3/ProjectFile/day010dbdb2CodeManjason.json    # os.listdir() 列出指定目錄下的所有文件  print(os.listdir(os.path.dirname(__file__)))  # ['.idea', ..省略大量文件..., 'sys模組鞏固.py', 'test.py', 'test2.py', '__pycache__']    # os.path.split() 將path分割成目錄和文件名二元組返回  print(os.path.split(my_path))  # ('E:/PyCharm 2019.1.3/ProjectFile/day010\db\db2\CodeMan', 'jason.json')    print(os.path.abspath(__file__))  # 獲取當前文件的絕對路徑  # E:PyCharm 2019.1.3ProjectFileday010day022os模組鞏固練習.py    os.remove(my_path)  # 刪除指定文件  os.rename(my_path, 'new_name')  # 重命名指定文件  # 上面兩個方法可以組合用在修改文件內容上，先刪除，再重命名    # os.mkdir('tank老師精選')  # 自動創建文件夾，文件存在時會報錯  print(os.path.exists(r'E:PyCharm 2019.1.3ProjectFileday010day016作品'))  # 判斷文件是否存在  # False  print(os.path.exists(r'E:PyCharm 2019.1.3ProjectFileday010day016作品tank老師.txt'))  # 判斷文件是否存在  # True  print(os.path.isfile(r'E:PyCharm 2019.1.3ProjectFileday010day016tank老師精選'))  # 只能判斷文件 不能判斷文件夾  # False  print(os.path.isfile(r'E:PyCharm 2019.1.3ProjectFileday010day016作品tank老師.txt'))  # 只能判斷文件 不能判斷文件夾  # True    # os.rmdir(r'D:Python項目day16作品')  # 會報錯，只能刪空文件夾    print(os.getcwd())  # 獲取當前工作目錄  # E:PyCharm 2019.1.3ProjectFileday010day016  print(os.chdir(r'E:PyCharm 2019.1.3ProjectFileday010day016老師們的作品'))  # 切換當前所在的目錄， 找不到會報錯  # None  print(os.getcwd())  # E:PyCharm 2019.1.3ProjectFileday010day016作品    print(os.path.getsize(r'E:PyCharm 2019.1.3ProjectFileday010day016作品tank老師.txt'))  # 位元組大小，找不到報錯  # 22  with open(r'E:PyCharm 2019.1.3ProjectFileday010day016作品tank老師.txt', encoding='utf-8') as f:      print(len(f.read()))  # f.read在r 模式下默認讀取的是字元數哦（1個字元的中文是3個位元組）  # 10    # -------------------------------------------------  # 其他可能用到的方法參考（用到相關的直接來查就行了）  # -------------------------------------------------  '''  os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄  os.removedirs('dirname1')    若目錄為空，則刪除，並遞歸到上一級目錄，如若也為空，則刪除，依此類推  os.mkdir('dirname')    生成單級目錄；相當於shell中mkdir dirname  os.rmdir('dirname')    刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname  os.listdir('dirname')    列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式列印  os.remove()  刪除一個文件  os.rename("oldname","newname")  重命名文件/目錄  os.stat('path/filename')  獲取文件/目錄資訊    os.system("bash command")  運行shell命令，直接顯示  os.popen("bash command).read()  運行shell命令，獲取執行結果  os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑  os.chdir("dirname")  改變當前腳本工作目錄；相當於shell下cd    os.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)  如果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.getatime(path)  返回path所指向的文件或者目錄的最後訪問時間  os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間    '''

其餘不太重要的

# -------------------------------------------------  # 了解知識（用到相關的直接來查就行了）  # -------------------------------------------------  print(os.stat(r'E:PyCharm 2019.1.3ProjectFileday010day022os模組鞏固練習.py'))  # os.stat_result(st_mode=33206, st_ino=844424930417653, st_dev=3050226722, st_nlink=1, st_uid=0, st_gid=0, st_size=3842, st_atime=1564143417, st_mtime=1564143417, st_ctime=1564140424)  '''  上述返回參數      st_mode: inode 保護模式      st_ino: inode 節點號。      st_dev: inode 駐留的設備。      st_nlink: inode 的鏈接數。      st_uid: 所有者的用戶ID。      st_gid: 所有者的組ID。      st_size: 普通文件以位元組為單位的大小；包含等待某些特殊文件的數據。      st_atime: 上次訪問的時間。      st_mtime: 最後一次修改的時間。      st_ctime: 由作業系統報告的"ctime"。在某些系統上（如Unix）是最新的元數據更改的時間，在其它系統上（如Windows）是創建時間（詳細資訊參見平台的文檔）。  '''    print(os.sep)  # 輸出當前作業系統的路徑分隔符  #   print(os.linesep)  # 輸出當前平台使用的行終止符，win下為"rn",Linux下為"n"（windows下是rn 所以控制台列印了兩個空行）  #  #  print(os.pathsep)  # 輸出用於分割文件路徑的字元串 win下為;,Linux下為:  # ;  print(os.name)  # 輸出字元串指示當前使用平台。win->'nt'; Linux->'posix'  # nt      # os.system('ping www.baidu.com')  # 執行命令行命令（中文會亂碼）Execute the command in a subshell.  # # ���� Ping www.a.shifen.com [61.135.169.121] ���� 32 �ֽڵ�����:  # # ���� 61.135.169.121 �Ļظ�: �ֽ�=32 ʱ��=43ms TTL=54  # # ���� 61.135.169.121 �Ļظ�: �ֽ�=32 ʱ��=26ms TTL=54  # # ���� 61.135.169.121 �Ļظ�: �ֽ�=32 ʱ��=26ms TTL=54  # # ���� 61.135.169.121 �Ļظ�: �ֽ�=32 ʱ��=25ms TTL=54  # 按了 Ctrl + C 終止  # #  # # 61.135.169.121 �� Ping ͳ����Ϣ:  # #     ���ݰ�: �ѷ��� = 4���ѽ��� = 4����ʧ = 0 (0% ��ʧ)��  # # �����г̵Ĺ���ʱ��(�Ժ���Ϊ��λ):  # #     ��� = 25ms��� = 43ms��ƽ�� = 30ms      my_path = r'E:PyCharm 2019.1.3ProjectFileday010day022os模組鞏固練習.py'  print(os.path.getatime(my_path))  # 返回path所指向的文件或者目錄的最後訪問時間（時間戳）  # 1564144609.6118524  print(os.path.getmtime(my_path))  # 返回path所指向的文件或者目錄的最後一次修改時間（時間戳）  # 1564144609.6118524  print(os.path.getctime(my_path))  # 返回path所指向的文件或者目錄的創建時間（時間戳）  # 1564140424.6713605  import time  struct_time = time.gmtime(os.path.getmtime(my_path))  print(struct_time)  # 時區原因，差了八個小時  # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=26, tm_hour=12, tm_min=43, tm_sec=23, tm_wday=4, tm_yday=207, tm_isdst=0)  print(time.strftime("%Y-%m-%d %H:%M:%S"))  # 2019-07-26 20:43:23

sys模組-python解釋器

 sys模組是與python解釋器交互的一個介面

import sys    print(sys.version)  # 獲取當前使用python解釋器的版本  # 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)]    print(sys.platform)  # 獲取作業系統平台名稱（不知道什麼原理，我的是window64位）  # win32    print(sys.path)  # 獲取當前python解釋內的環境變數（查找自定義模組時的查找目錄）  # ['E:\......\day022', ..省略一大串...  'E:\....\pycharm_matplotlib_backend']      print(sys.modules)  # 存放了記憶體中已載入的模組，載入模組時會在這裡面找，找不到再去按照查找順序載入  '''  {'builtins': ....., '__main__': <module '__main__' ..省略大段...  from 'E:/....../sys模組鞏固.py'>, 'os': <module 'os' from .. os.py'>}  '''  # print(sys.modules['test'])  # 模組還沒有載入，此時會直接報錯，KeyError: 'test'  import test  print(sys.modules['test'])  # <module 'test' from 'E:\PyCharm 2019.1.3\ProjectFile\day010\day022\test.py'>    # sys.argv  # 命令行參數List，第一個元素是程式本身路徑    # 獲取當前文件系統的字元編碼  print(sys.getfilesystemencoding())  # utf-8    print(sys.getrecursionlimit())  # 獲取python遞歸函數的遞歸深度  # 1000  print(sys.setrecursionlimit(200))  # 自定義python遞歸函數的遞歸深度  # None  print(sys.getrecursionlimit())  # 獲取python遞歸函數的遞歸深度  # 200    print(sys.exit(0))  # sys.exit(0)直接結束程式，後面的程式碼不會執行  正常退出時exit(0),錯誤退出sys.exit(1)  print("halo~")

import sys  try:      sys.exit(1)  except SystemExit as e:      print(e)

import sys    print(sys.argv)  # 命令行啟動文件 可以做身份的驗證  if len(sys.argv) <= 1:      print('請輸入用戶名和密碼')  else:      username = sys.argv[1]      password = sys.argv[2]      if username == 'jason' and password == '123':          print('歡迎使用')          # 當前這個py文件邏輯程式碼      else:          print('用戶不存在 無法執行當前文件')

json與pickle模組-反序列化模組

序列：序列就是指字元串

序列化：其它數據類型轉換為字元串的過程

為什麼要序列化

'''  為什麼要序列化：      寫入文件的數據必須是字元串或者二進位（數據類型中只有字元串可以encode可以變成二進位）      各個語言（python java c++）的數據類型不一樣（數據之間要共用，傳遞）      基於網路傳輸的數據必須是二進位  '''

兩個過程： # 序列化：把其它數據類型轉換成字元串 ， # 反序列化：把字元串轉成其它數據類型

在python中兩個序列化模組的特點

'''  json模組（*********）      所有的程式語言都支援json 格式      支援的python數據類型很少，字元串、列表、字典、整型、元組（轉成列表了）（對象、函數 不是所有語言都能相通）    pickle模組      只支援python 一門語言      python所有的數據類型都支援  '''

json模組

'''  序列化時 python中的數據類型與json中的轉換關係      +-------------------+---------------+      | Python            | JSON          |      +===================+===============+      | dict              | object        |      +-------------------+---------------+      | list, tuple       | array         |      +-------------------+---------------+      | str               | string        |      +-------------------+---------------+      | int, float        | number        |      +-------------------+---------------+      | True              | true          |      +-------------------+---------------+      | False             | false         |      +-------------------+---------------+      | None              | null          |      +-------------------+---------------+  '''

import json    # dumps 序列化：將一個傳入的數據類型序列化（轉換）為字元串  dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}  str_dic = json.dumps(dic)  print(str_dic, type(str_dic))  # json轉換的字元串類型的字典的字元是由 "" 表示的（不管你是單引號還是雙引號）  # {"k1": "v1", "k2": "v2", "k3": "v3"} <class 'str'>    l = [1, 2, 45, 6, 7]  str_l = json.dumps(l)  print(str_l, type(str_l))  # [1, 2, 45, 6, 7] <class 'str'>    t = (13, 2, 45, 66, 7)  str_t = json.dumps(t)  print(str_t, type(str_t))  # json中沒有元組類型，python中的list、tuple序列化後都會成為（json里數組類型的）字元串  # [13, 2, 45, 66, 7] <class 'str'>      # loads 反序列化：將json字元串反序列化（轉換）回python的對應數據類型  str_dic = json.loads(str_dic)  print(str_dic, type(str_dic))  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>    str_l = json.loads(str_l)  print(str_l, type(str_l))  # [1, 2, 45, 6, 7] <class 'list'>    # 已經返不回tuple元組了（json列表反序列化的python中的list列表）  str_t = json.loads(str_t)  print(str_t, type(str_t))  # [13, 2, 45, 66, 7] <class 'list'>

# fp 形參，代表文件句柄對象  '''  dump load 是與文件一起操作的  '''  dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}  # 沒有這個文件沒關係，w模式會自動創建  with open('userinfo.txt', 'w', encoding='utf-8') as f:      json.dump(dic, f)  # 將python數據類型序列化為字元串並自動寫入文件  with open('userinfo.txt', 'r', encoding='utf-8') as f:      res = json.load(f)  # 將字元串反序列化成python數據類型      print(res, type(res))  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>

看完上面dump load，在你實際操作時可能會遇到有多個字典反序列化不回來的情況，可以這樣處理

案例一：用戶資訊存儲

按下面的目錄建好文件，右鍵運行即可（此部分程式碼僅有一個註冊功能，主要目的是演示json 序列化反序列化數據到文件中）

[{"username": "tank", "pwd": "59f471f262ab586fb959ded0e2c7b94f", "operation": []}, {"username": "jason", "pwd": "59f471f262ab586fb959ded0e2c7b94f", "operation": []}, {"username": "egon", "pwd": "59f471f262ab586fb959ded0e2c7b94f", "operation": []}]

[{      "username": "tank",      "pwd": "59f471f262ab586fb959ded0e2c7b94f",      "operation": []  }, {      "username": "jason",      "pwd": "59f471f262ab586fb959ded0e2c7b94f",      "operation": []  }, {      "username": "egon",      "pwd": "59f471f262ab586fb959ded0e2c7b94f",      "operation": []  }]

import os  import json  BASE_DIR = os.path.dirname(os.path.dirname(__file__))  DB_DIR = os.path.join(BASE_DIR, 'db')  admin_file = os.path.join(DB_DIR, "admin.json")      def select(admin_name):      if os.path.exists(admin_file):          with open(admin_file, mode='r', encoding='utf-8') as f:              all = json.load(f, encoding='utf-8')              for line in all:                  if admin_name in line.get('username'):                      return True      else:          return False      def save_admin(admin_dict):      admins = []      if os.path.exists(admin_file) and os.path.getsize(admin_file):          with open(admin_file, mode='r', encoding='utf-8') as f:              has_admin = False              all = json.load(f, encoding='utf-8')  # 通過json.load將文件的所有內容反序列化成python中的數據類型              for line in all:                  if admin_dict['username'] in line.get('username'):                      admins.append(admin_dict)                      has_admin = True                  else:                      admins.append(line)              if not has_admin:                  admins.append(admin_dict)      else:          admins.append(admin_dict)      with open(admin_file, mode='w', encoding='utf-8') as f:          json.dump(admins, f, ensure_ascii=False)  # 將python的數據類型通過json.dump序列化成json中的數據存入文件      return True

from db import admin_db_handler  from lib import common      def check_admin_exits(admin_name):      return admin_db_handler.select(admin_name)      def register_admin(username, pwd):      pwd = common.get_md5(pwd)      admin_dict = {          'username': username,          'pwd': pwd,          'operation': [],      }      flag = admin_db_handler.save_admin(admin_dict)      return flag

'''  前言：      管理員系統與普通用戶系統相隔離，管理員系統作為後台，不向用戶公開  '''  from interface import admin_interface      def register():      while True:          admin_name = input("請輸入管理員用戶名>>>:").strip()          if admin_name == 'q':              break          if admin_interface.check_admin_exits(admin_name):              print("該管理員用戶名已存在，請重新輸入")              continue          pwd = input("請輸入密碼>>>:").strip()          repwd = input("請再次輸入密碼>>>:").strip()          if pwd != repwd:              print("兩次密碼不一致，請重新輸入")              continue            if admin_interface.register_admin(admin_name, pwd):              print(f"{admin_name}用戶註冊成功")              break      def login():      pass      def lock_user():      pass      def unlock_user():      pass      def change_user_balance():      pass      def reset_user_password():      # 管理員可以直接根據用戶名設置新密碼      pass      func_list = {      "1": register,      "2": login,      "3": lock_user,      "4": unlock_user,      "5": change_user_balance,      "6": reset_user_password,  }      current_admin = {      'username': None,      'pwd': None,      'operation': [],  }      def run():      while True:          print("""          1.註冊          2.登錄                3.凍結用戶          4.解凍用戶      5.更改用戶餘額         6.重置用戶密碼          """)          choice = input("請選擇功能編號>>>:").strip()          if choice == 'q':              print("感謝您的使用，祝您生活愉快~")              break          elif choice in func_list:              func_list[choice]()          else:              print("正確輸入功能編號！")

import os  import sys  BASE_DIR = os.path.dirname(os.path.dirname(__file__))  sys.path.append(BASE_DIR)      from core import admin_src  if __name__ == '__main__':      admin_src.run()

import hashlib  import logging.config  from conf import settings      # 字元串md5加密（密碼加密）  def get_md5(string: str) -> str:      md = hashlib.md5()      md.update('md5_salt'.encode('utf-8'))      md.update(string.encode('utf-8'))      return md.hexdigest()

案例二

#   用 loads 來分行處理字元串，然後再返回  import json  dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}  with open('userinfo.txt', 'w', encoding='utf-8') as f:      json_str = json.dumps(dic)      # 放兩邊，存兩個字典      f.write('%sn' % json_str)      f.write('%sn' % json_str)    with open('userinfo.txt', 'r', encoding='utf-8') as f:      for line in f:          # 一行一行反序列化回字元串          res = json.loads(line)          print(res, type(res))  t = (1, 2, 3, 4)  print(json.dumps(t))  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>  # [1, 2, 3, 4]

d1 = {'name': '孫堅強超堅強'}  print(json.dumps(d1))  print(json.dumps(d1, ensure_ascii=False))  # 通過指定 ensure_ascii=False來避免  # {"name": "u5b59u575au5f3au8d85u575au5f3a"}  # {"name": "孫堅強超堅強"}

pickle模組

大體上與json模組一致（支援的語言種類不同，pickle只支援python，數據序列化成二進位數據）

import pickle  # pickle 模組支援python中的所有數據類型，但是他只能支援python一門語言    # dumps loads 序列化反序列化，序列化的結果是二進位  d = {'name': 'Arson'}  res = pickle.dumps(d)  # 將對象直接轉成二進位  print(pickle.dumps(d))  # b'x80x03}qx00Xx04x00x00x00nameqx01Xx05x00x00x00Arsonqx02s.'    res1 = pickle.loads(res)  print(res1, type(res1))  # {'name': 'Arson'} <class 'dict'>

import pickle    """  用pickle操作文件的時候 文件的打開模式必須是b模式（b模式不能加encoding哦）  """  # dump load 配合文件使用的序列化反序列化  with open('userinfo_1.txt', 'wb') as f:      pickle.dump(d, f)    with open('userinfo_1.txt', 'rb') as f:      res = pickle.load(f)      print(res, type(res))  # {'name': 'Arson'} <class 'dict'>

subprocess模組

 subprocess模組，子進程模組

遠程操作電腦的歩鄹：

# 遠程操作電腦  #     1.用戶通過網路連接上了這台電腦  #     2.用戶輸入相應的命令，基於網路發送給了你這台電腦上的某個程式  #     3.獲取用戶命令，利用subprocess模組執行該命令  #     4.將執行結果再基於網路再發送給用戶  #     這樣就實現了 用戶遠程操作你這台電腦的操作

import subprocess  # 執行傳入的第一個參數(如果參數是錯誤命令,則會列印 stderr 資訊)  obj = subprocess.Popen('tasklist', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)  print(obj)  # <subprocess.Popen object at 0x00000200D3CC8668>  print('正確命令返回的結果stdout', obj.stdout.read().decode('GBK'))  # 沒錯誤就返回（Windows終端默認編碼GBK）  # stdout  # 映像名稱                       PID 會話名              會話#       記憶體使用  # ========================= ======== ================ =========== ============  # System Idle Process              0 Services                   0          8 K  # System                           4 Services                   0        140 K  # Registry                        96 Services                   0     34,416 K  # ........省略大量資訊  print('錯誤命令返回的提示資訊stderr', obj.stderr.read().decode('GBK'))  # 在第一個參數不存在的時候，stderr才會輸出資訊  # stderr 'dfsfs' 不是內部或外部命令，也不是可運行的程式  # 或批處理文件。

小案例，在python命令行執行作業系統命令

while True:      cmd = input('cmd>>>:').strip()      import subprocess        obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)      # print(obj)      print('正確命令返回的結果stdout', obj.stdout.read().decode('gbk'))      print('錯誤命令返回的提示資訊stderr', obj.stderr.read().decode('gbk'))