python模塊怎么用

這篇文章主要介紹了python模塊怎么用，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

什么是模塊

模塊是一系列功能的集合體
常見的模塊形式（自定義模塊、第三方模塊、內置模塊）：
    1、一個module.py文件就是一個模塊,文件名是module.py,而模塊名是module
    2、一個包含有__init__.py文件的文件夾也是模塊

    3、已被編譯為共享庫或DLL的C或C++擴展
    4、使用C編寫并鏈接到python解釋器的內置模塊

為什么要用模塊

1、用第三方或者內置的模塊是一種拿來主義，可以極大地提升開發效率
2、自定義模塊即將我們自己程序中需要用到的公共的功能寫入一個python文件
    然后程序的各部分組件可以通過導入的方式來引用/重用自定義模塊中的功能

如何用模塊

    大前提：模塊是被執行文件導入使用，模塊的導入必須搞明白誰是執行文件，誰是被導入的模塊

    import
        首次import m1導入模塊都發生三件事：
        1、先創建一個模塊的名稱空間
        2、執行m1.py，將執行過程中產生的名稱都放入模塊的名稱空間中
        3、在當前執行文件中拿到一個名字m1,該名字是指向模塊的名稱空間的

        使用方法：指名道姓地訪問m1名稱空間中的名字func，優點是不會與當前名稱空間中的名字沖突,缺點是每次訪問都需要加上前綴
            m1.func

    from ... import
        首次from m1 import func導入模塊都發生三件事：
        1、先創建一個模塊的名稱空間
        2、執行m1.py，將執行過程中產生的名稱都放入模塊的名稱空間中
        3、在當前執行文件中直接拿到一個功能名func,該名字是直接指向模塊名稱空間中的某一個功能的

        使用方法：直接使用功能即可，優點是無需加任何前綴，缺點是容易與當前名稱空間中的名字沖突
            def func():
                pass
            func()

導入模塊的兩種方式

絕對導入:

參照執行文件的sys.path為基準查找,既可以當作執行文件使用也可以當作被導入的模塊使用
        但文件當作模塊使用必須參照執行文件的環境變量來導入
        格式為  from 文件夾  import 模塊名

相對導入:

.  以當前文件的文件夾為基準查找,只能被當作模塊導入,不能當作執行文件執行
        from . import 模塊名

相對導入一般用在導入包的情況下,

    在導入包的情況下,有3種限制
    1  .的方式不能出包的范圍
    2  .的方式不能當作執行文件執行
    3  .的方式前提只能是包

模塊的搜索路徑

    內存-》內置模塊-》sys.path

import logging 日志模塊

進行基本的日志配置:

 logging.basicConfig(filename='access.log',
                        format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                        datefmt='%Y-%m-%d %H:%M:%S %p',
                        level=10,
                        # stream=True
                         )

日志級別遵循原則：自下而上進行匹配 #debug-》info-》warning-》error-》critical:

             logging.debug('調試信息') #10
             logging.info('正常信息') #20
             logging.warning('不好啦著火啦') #30
             logging.error('報錯信息') #40
             logging.critical('嚴重錯誤信息') #50

問題：

    1、沒有指定日志級別
    2、沒有指定日志格式
    3、只能往屏幕打印，沒有寫入文件

新問題
#1、不能指定字符串編碼
#2、只能往文件中打印

import logging
logging模塊包含四種角色：logger，filter，formatter，handler

• 1、logger：負責產生日志信息
  logger1=logging.getLogger('交易日志')
  logger2=logging.getLogger('用戶相關')

• 2、filter：負責篩選日志

• 3、formatter：控制日志輸出格式
  formatter1=logging.Formatter(
  fmt='%(asctime)s:%(name)s:%(levelname)s:%(message)s',
  datefmt='%Y-%m-%d %X'
  )
  formatter2=logging.Formatter(
  fmt='%(asctime)s:%(message)s',
  datefmt='%Y-%m-%d %X'
  )

• 4、handler：負責日志輸出的目標
  h2=logging.FileHandler(filename='a1.log',encoding='utf-8')
  h3=logging.FileHandler(filename='a2.log',encoding='utf-8')
  sm=logging.StreamHandler()

• 5、綁定logger對象與handler對象
  logger1.addHandler(h2)
  logger1.addHandler(h3)
  logger1.addHandler(sm)

• 6、綁定handler對象與formatter對象
  h2.setFormatter(formatter1)
  h3.setFormatter(formatter1)
  sm.setFormatter(formatter2)

• 7、設置日志級別：可以在兩個關卡進行設置logger與handler:

  logger1.setLevel(10)
  h2.setLevel(10)
  h3.setLevel(10)
  sm.setLevel(10)
  
  logger1.info('Egon借給李杰100W')

  最終的用法:

  LOG_PATH = os.path.join(BASE_DIR, 'log', 'user.log')
      standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                          '[%(levelname)s][%(message)s]'  # 其中name為getlogger指定的名字
  
      simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
  
      id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
  
      # 定義日志輸出格式 結束
  
      # 如果不存在定義的日志目錄就創建一個
      if not os.path.isdir(DB_PATH):
          os.mkdir(DB_PATH)
  
      # log文件的全路徑
      # logfile_path = os.path.join(DB_PATH, 'log')
  
      # log配置字典
      LOGGING_DIC = {
          'version': 1,
          'disable_existing_loggers': False,
          'formatters': {
              'standard': {
                  'format': standard_format
              },
              'simple': {
                  'format': simple_format
              },
          },
          'filters': {},
          'handlers': {
              # 打印到終端的日志
              'console': {
                  'level': 'DEBUG',
                  'class': 'logging.StreamHandler',  # 打印到屏幕
                  'formatter': 'simple'
              },
              # 打印到文件的日志,收集info及以上的日志
              'default': {
                  'level': 'DEBUG',
                  'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
                  'formatter': 'standard',
                  'filename': LOG_PATH,  # 日志文件
                  'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
                  'backupCount': 5,
                  'encoding': 'utf-8',  # 日志文件的編碼，再也不用擔心中文log亂碼了
              },
          },
          'loggers': {
              # logging.getLogger(__name__)拿到的logger配置
              '': {
                  'handlers': ['default', 'console'],  # 這里把上面定義的兩個handler都加上，即log數據既寫入文件又打印到屏幕
                  'level': 'DEBUG',
                  'propagate': True,  # 向上（更高level的logger）傳遞
              },
          },
      }
  
  import logging.config
  def get_logger(name):
      """
      日志格式
      :return:
      """
      logging.config.dictConfig(settings.LOGGING_DIC)
      logger = logging.getLogger(name)  # 這里的name 指的文件名
      return logger

json 模塊

import json

with open('db1.json','rt',encoding='utf-8') as f:
        json.load(f) # load用在文件的讀,反序列化

json.loads('{"name":"egon"}') # loads用在字典的序列化,

with open('db.json','wt',encoding='utf-8') as f:
        l=[1,True,None]
        json.dump(l,f)  # dump用在 序列化到文件中

x = json.dumps('name': 'egon')  #dumps用在序列化 

用json反序列化
with open('db.json','rt',encoding='utf-8') as f:
        l=json.load(f)
        print(l)

pickle模塊

import pickle

反序列化

    1、從文件中讀取pickle格式
    with open('db.pkl','rb') as f:
            pkl=f.read()
    2、將json_str轉成內存中的數據類型 
     dic=pickle.loads(pkl)
     print(dic['a'])

    1和2可以合作一步
     with open('db.pkl','rb') as f:
             dic=pickle.load(f)

     print(dic['a'])

序列化

    dic={'a':1,'b':2,'c':3}

    1 序列化
    pkl=pickle.dumps(dic)
     print(pkl,type(pkl))

    2 寫入文件
    with open('db.pkl','wb') as f:
            f.write(pkl)

    1和2可以合作一步
    with open('db.pkl','wb') as f:
            pickle.dump(dic,f)
```

對比json 和pickle

• 什么是序列化/反序列化
  序列化就是將內存中的數據結構轉換成一種中間格式存儲到硬盤或者基于網絡傳輸
  發序列化就是硬盤中或者網絡中傳來的一種數據格式轉換成內存中數據結構

• 為什么要有
  1、可以保存程序的運行狀態
  2、數據的跨平臺交互

• json
  優點：
  跨平臺性強
  缺點：
  只能支持/對應python部分的數據類型

• pickle
  優點：
  可以支持/對應所有python的數據類型
  缺點：
  只能被python識別，不能跨平臺

time模塊

時間分為三種格式

1、時間戳

    start= time.time()
    time.sleep(3)
    stop= time.time()
    print(stop - start)
    輸出結果:
    3.000129222869873

2、格式化的字符串形式

    print(time.strftime('%Y-%m-%d %X'))
    print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
    輸出結果:
    2018-07-30 18:04:27
    2018-07-30 18:04:27 PM

3、 結構化的時間/時間對象

    t1=time.localtime()
    print(t1)
    print(type(t1.tm_min))
    print(t1.tm_mday)

    t2=time.gmtime()
    print(t1)
    print(t2)

獲取格式化字符串形式的時間麻煩
時間戳與格式化時間之間的轉換麻煩
獲取之前或者未來的時間麻煩.所以用到了 datetime模塊

datetime模塊

    print(datetime.datetime.now())  # 現在的時間
    print(datetime.datetime.fromtimestamp(1231233213))

    print(datetime.datetime.now() + datetime.timedelta(days=3))  # 現在的時間加上未來的3天
    print(datetime.datetime.now() + datetime.timedelta(days=-3))  # 現在的時間減去3天前

    s=datetime.datetime.now()
    print(s.replace(year=2020))  # 修改年份

random 模塊

 import random

  print(random.random())#(0,1)----float    大于0且小于1之間的小數

  print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之間的整數

 print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之間的整數

  print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]

  print(random.sample([1,'23',[4,5]],2))#列表元素任意2個組合

 print(random.uniform(1,3))#大于1小于3的小數，如1.927109612082716 

 item=[1,3,5,7,9]
 random.shuffle(item) #打亂item的順序,相當于"洗牌"
 print(item)

產生隨機號碼

def make_code(size=7):
    res = ''
    for i in range(size):
        # 循環一次則得到一個隨機字符（字母/數字）
        s = chr(random.randint(65, 90))
        num = str(random.randint(0, 9))
        res += random.choice([s, num])
    return res

res=make_code()
print(res)

os模塊

os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir("dirname")  改變當前腳本工作目錄；相當于shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')
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.sep    輸出操作系統特定的路徑分隔符，win下為"\\",Linux下為"/"
os.linesep    輸出當前平臺使用的行終止符，win下為"\t\n",Linux下為"\n"
os.pathsep    輸出用于分割文件路徑的字符串 win下為;,Linux下為:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")  運行shell命令，直接顯示
os.environ  獲取系統環境變量
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(path2[, path3[, ...]])  將多個路徑組合后返回，第一個絕對路徑之前的參數將被忽略
os.path.getatime(path)  返回path所指向的文件或者目錄的最后存取時間
os.path.getmtime(path)  返回path所指向的文件或者目錄的最后修改時間
os.path.getsize(path) 返回path的大小

打印進度條

import time

def make_progress(percent,width=50):
    if percent > 1:
        percent=1
    show_str=('[%%-%ds]' % width) % (int(percent * width) * '#')
    print('\r%s %s%%' %(show_str,int(percent * 100)),end='')

total_size=1025
recv_size=0
while recv_size < total_size:
    time.sleep(0.1) # 模擬經過了0.5的網絡延遲下載了1024個字節
    recv_size+=1024
    # 調用打印進度條的功能去打印進度條
    percent=recv_size / total_size
    make_progress(percent)

re模塊

pattern=re.compile('alex')
print(pattern.findall('alex is SB,alex is bigSB'))  # 匹配所有的'alex'
print(pattern.search('alex is SB,alex is bigSB').group())  # 從行首開始匹配,沒有就返回None.有就可以通過group拿到
print(re.match('alex','123alex is SB,alex is bigSB'))#以什么結尾,有就返回這個值,沒有就返回None
結果如下:
['alex', 'alex']
alex
None

subprocess模塊

import subprocess

obj=subprocess.Popen(
    'tasklist',
    shell=True,
    stdout=subprocess.PIPE, # 正確的管道
    stderr=subprocess.PIPE  #  錯誤的管道

)
print(obj)
stdout_res = obj.stdout.read()  # 得到正確管道中的數據
print(stdout_res.decode('gbk'))
print(stdout_res)

stderr_res1=obj.stderr.read()  #得到錯誤管道中的數據
stderr_res2=obj.stderr.read()  # 管道中的信息只能取一次
stderr_res3=obj.stderr.read()
print(stderr_res1.decode('gbk'))
print(stderr_res1)
print(stderr_res2)
print(stderr_res3)

hash模塊

• 什么是hash
  hash是一種算法，該算法接受傳入的內容，經過運算得到一串hash值
  如果把hash算法比喻為一座工廠
  那傳給hash算法的內容就是原材料
  生成的hash值就是生產出的產品

• 為何要用hash算法
  hash值/產品有三大特性：
  1、只要傳入的內容一樣，得到的hash值必然一樣
  2、只要我們使用的hash算法固定，無論傳入的內容有多大，
  得到的hash值的長度是固定的
  3、不可以用hash值逆推出原來的內容

  基于1和2可以在下載文件時做文件一致性校驗
  基于1和3可以對密碼進行加密

• 怎么用
  import hashlib
  1、造出hash工廠
  m=hashlib.sha512('你'.encode('utf-8'))

  2、運送原材料
  m.update('好啊美sadfsadf麗asdfsafdasdasdfsafsdafasdfasdfsadfsadfsadfsadfasdff的張銘言'.encode('utf-8'))

  3、產出hash值
  print(m.hexdigest()) #2ff39b418bfc084c8f9a237d11b9da6d5c6c0fb6bebcde2ba43a433dc823966c

  import shutil  #壓縮模塊

  with open('old.xml','r') as read_f,open('new.xml', 'w') as write_f:
  shutil.copyfileobj(read_f,write_f)

  shutil.make_archive("data_bak", 'gztar', root_dir='D:\SH_fullstack_s2\day04')

import tarfile    #  解壓

t=tarfile.open('data_bak.tar.gz','r')
t.extractall('D:\SH_fullstack_s2\day20\dir')
t.close()

import xml

import xml.etree.ElementTree as ET

tree = ET.parse("a.xml")  # 打開一個xml的文件
root = tree.getroot()   # 用getroot 拿到樹根

對于任何標簽都有三個特征：標簽名、標簽屬性、標簽的文本內容
print(root.tag)# 標簽名
print(root.attrib)# 標簽屬性
print(root.text)# 文本內容

print(list(root.iter('year'))) #全文搜索,找到所有
for year in root.iter('year'):
    print(year.tag)
    print(year.attrib)
    print(year.text)
    print('='*100)

print(root.find('country').attrib) #在root的子節點找，只找一個
print([country.attrib for country in root.findall('country')]) #在root的子節點找，找所有

root.iter('year')   #全文搜索
root.findall('country')  # 在root的子節點找,找所有
root.find('country')  # 在root的子節點找,只找一個

1、查
遍歷整個文檔
for country in root:
    print('============>國家 %s' %country.attrib)
    for item in country:
        print(item.tag)
        print(item.attrib)
        print(item.text)

2、改
for year in root.iter('year'):
    print(year.tag)
    year.attrib={'updated':'yes'}
    year.text=str(int(year.text)+1)

tree.write('a.xml')

3、增
for country in root:
    rank=country.find('rank')
    if int(rank.text) > 50:
        # print('符號條的國家',country.attrib)
        tag=ET.Element('egon')
        tag.attrib={'updated':'yes'}
        tag.text='NB'
        country.append(tag)

tree.write('a.xml')
4、刪

for country in root:
    tag=country.find('egon')
  #print(tag,bool(tag))
    if tag is not None:
        print('====>')
        country.remove(tag)
tree.write('a.xml')

import configparser   # 解析文件模塊

config = configparser.ConfigParser()
config.read('config.ini')  # a.cfg  a.ini a.cnf

print(config.sections())  # 去除標題
print(config.options('egon'))   # 把這個目錄下的k取出來
print(config.items('egon'))  # 取出 這個目錄下的所有,放到元組中

res = config.get('egon','age')
res = config.getint('egon', 'age')
print(res, type(res))

res = config.getfloat('egon', 'salary')
print(res, type(res))

res = config.getboolean('egon', 'is_beautiful')
print(res, type(res))

輸出結果如下:
['egon', 'alex']
['pwd', 'age', 'sex', 'salary', 'is_beautiful']
[('pwd', "'123'"), ('age', '18'), ('sex', "'male'"), ('salary', '3.1'), ('is_beautiful', 'True')]
18 <class 'int'>
3.1 <class 'float'>
True <class 'bool'>

感謝你能夠認真閱讀完這篇文章，希望小編分享的“python模塊怎么用”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!