包與模塊（五）

時間  2019-11-12
標籤 模塊 简体版
原文   原文鏈接

1.1 模塊

1.1.1 模塊介紹

常見的場景：一個模塊就是一個包含了一組功能的python文件,好比spam.py，模塊名爲spam，能夠經過import spam使用。python

在python中，模塊的使用方式都是同樣的，但其實細說的話，模塊能夠分爲四個通用類別：　mysql

1 使用python編寫的.py文件sql

2 已被編譯爲共享庫或DLL的C或C++擴展json

3 把一系列模塊組織到一塊兒的文件夾（注：文件夾下有一個__init__.py文件，該文件夾稱之爲包）bash

4 使用C編寫並連接到python解釋器的內置模塊oracle

 

1.1.2 爲什麼要使用模塊

一、從文件級別組織程序，更方便管理app

隨着程序的發展，功能愈來愈多，爲了方便管理，咱們一般將程序分紅一個個的文件，這樣作程序的結構更清晰，方便管理。這時咱們不只僅能夠把這些文件當作腳本去執行，還能夠把他們當作模塊來導入到其餘的模塊中，實現了功能的重複利用ide

二、拿來主義，提高開發效率函數

一樣的原理，咱們也能夠下載別人寫好的模塊而後導入到本身的項目中使用，這種拿來主義，能夠極大地提高咱們的開發效率測試

#ps：

若是你退出python解釋器而後從新進入，那麼你以前定義的函數或者變量都將丟失，所以咱們一般將程序寫到文件中以便永久保存下來，須要時就經過python test.py方式去執行，此時test.py被稱爲腳本script。

以spam.py爲例來介紹模塊的使用：文件名spam.py,模塊名spam

#spam.py

print('from the spam.py')

 

money=1000

 

def read1():

    print('spam模塊：',money)

 

def read2():

    print('spam模塊')

    read1()

 

def change():

    global money

    money=0

 

模塊使用.py

import spam

 

money=1

print(spam.money)

 

print(spam.read1)

print(spam.read2)

print(spam.change)

 

 

測試一

money=1

print(spam.money)

 

測試二（絕對導入）：

def read1():

    print('from current')

# spam.read1()

spam.read2()

 

測試三：

money=1

spam.change()

print(money)

spam.read1()

 

1.2 使用模塊之import

1.2.1 import的使用

模塊能夠包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行（import語句是能夠在程序中的任意位置使用的,且針對同一個模塊很import屢次,爲了防止你重複導入，python的優化手段是：第一次導入後就將模塊名加載到內存了，後續的import語句僅是對已經加載到內存中的模塊對象增長了一次引用，不會從新執行模塊內的語句），以下

#test.py

import spam #只在第一次導入時才執行spam.py內代碼,此處的顯式效果是隻打印一次'from the spam.py',固然其餘的頂級代碼也都被執行了,只不過沒有顯示效果.

import spam

import spam

import spam

 

'''

執行結果：

from the spam.py

'''

ps：咱們能夠從sys.module中找到當前已經加載的模塊，sys.module是一個字典，內部包含模塊名與模塊對象的映射，該字典決定了導入模塊時是否須要從新導入。

 

1.2.2 在第一次導入模塊時會作三件事，重複導入會直接引用內存中已經加載好的結果

1.爲源文件(spam模塊)建立新的名稱空間，在spam中定義的函數和方法如果使用到了global時訪問的就是這個名稱空間。

2.在新建立的命名空間中執行模塊中包含的代碼，見初始導入import spam

 提示:導入模塊時到底執行了什麼？

事實上函數定義也是「被執行」的語句，模塊級別函數定義的執行將函數名放入模塊全局名稱空間表，用globals()能夠查看

3.建立名字spam來引用該命名空間

    這個名字和變量名沒什麼區別，都是‘第一類的’，且使用spam.名字的方式

    能夠訪問spam.py文件中定義的名字，spam.名字與test.py中的名字來自

    兩個徹底不一樣的地方。

1.2.3 被導入模塊有獨立的名稱空間

每一個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當作全局名稱空間，這樣咱們在編寫本身的模塊時，就不用擔憂咱們定義在本身模塊中全局變量會在被導入時，與使用者的全局變量衝突

測試一:money與spam.money不衝突

#test.py

import spam

money=10

print(spam.money)

 

'''

執行結果：

from the spam.py

1000

'''

 

測試二：read1與spam.read1不衝突

#test.py

import spam

def read1():

    print('========')

spam.read1()

 

'''

執行結果:

from the spam.py

spam->read1->money 1000

'''

測試三：執行spam.change()操做的全局變量money仍然是spam中的

#test.py

import spam

money=1

spam.change()

print(money)

 

'''

執行結果：

from the spam.py

1

'''

 

 

 

1.2.4 爲模塊名起別名

爲已經導入的模塊起別名的方式對編寫可擴展的代碼頗有用

import spam as sm

print(sm.money)

 

engine=input('>>: ')

if engine == 'mysql':

    import mysql as sql

elif engine == 'oracle':

    import oracle as sql

 

sql.parse()

 

有兩中sql模塊mysql和oracle，根據用戶的輸入，選擇不一樣的sql功能

假設有兩個模塊xmlreader.py和csvreader.py，它們都定義了函數read_data(filename):用來從文件中讀取一些數據，但採用不一樣的輸入格式。能夠編寫代碼來選擇性地挑選讀取模塊

if file_format == 'xml':

    import xmlreader as reader

elif file_format == 'csv':

    import csvreader as reader

data=reader.read_date(filename)

 

 

1.2.5 在一行導入多個模塊

import sys,os,re

 

1.2.6 使用模塊之from ... import...

1.2.6.1  from ... import... .的使用

from spam import money,read1,read2,change

 

money=1

print(money)

 

read1='read1'

print(read1)

 

money=1

read1()

 

def read1():

    print('from current func')

 

read2()

 

money=1

change()

print(money)

 

 

1.2.7 from...import 與import的對比

惟一的區別就是：使用from...import...則是將spam中的名字直接導入到當前的名稱空間中，因此在當前名稱空間中，直接使用名字就能夠了、無需加前綴：spam.

#from...import...的方式有好處也有壞處

    好處：使用起來方便了

    壞處：容易與當前執行文件中的名字衝突

 

read1=1

print(money,read1,read2,change)

 

print(_money)

print(read1,read2,change)

 

from spam import _money

print(_money)

 

import spam

spam.read1()

 

import sys

print(sys.path)

 

sys.path.append(r'D:\video\python20期\day5\01_模塊\aaa')

import spam

print(spam.money)

 

 

import spam,time

time.sleep(10)

import spam

print(spam.money)

 

import sys,spam

print('spam' in  sys.modules)

print('time' in sys.modules)

 

import time

print(time)

time.sleep(3)

 

 

1.2.8 from spam import *

#from spam import * 把spam中全部的不是如下劃線(_)開頭的名字都導入到當前位置

#大部分狀況下咱們的python程序不該該使用這種導入方式，由於*你不知道你導入什麼名字，頗有可能會覆蓋掉你以前已經定義的名字。並且可讀性極其的差，在交互式環境中導入時沒有問題。

 

1.3 py文件區分兩種用途:模塊與腳本

寫好的一個python文件能夠有兩種用途：

    一：腳本，一個文件就是整個程序，用來被執行

    二：模塊，文件中存放着一堆功能，用來被導入使用

 

#python爲咱們內置了全局變量__name__，

    當文件被當作腳本執行時：__name__ 等於'__main__'

    當文件被當作模塊導入時：__name__等於模塊名

 

#做用：用來控制.py文件在不一樣的應用場景下執行不一樣的邏輯

    if __name__ == '__main__':

 

1.4 模塊搜索路徑

模塊的查找順序是：內存中已經加載的模塊->內置模塊->sys.path路徑中包含的模塊

模塊的查找順序

一、在第一次導入某個模塊時（好比spam），會先檢查該模塊是否已經被加載到內存中（當前執行文件的名稱空間對應的內存），若是有則直接引用

    ps：python解釋器在啓動時會自動加載一些模塊到內存中，可使用sys.modules查看

二、若是沒有，解釋器則會查找同名的內建模塊

三、若是尚未找到就從sys.path給出的目錄列表中依次尋找spam.py文件。

 

1.5 包

1.5.1 什麼是包

包就是一個包含有__init__.py文件的文件夾，因此其實咱們建立包的目的就是爲了用文件夾將文件/模塊組織起來

須要強調的是：

　　1. 在python3中，即便包下沒有__init__.py文件，import 包仍然不會報錯，而在python2中，包下必定要有該文件，不然import 包報錯

 

　　2. 建立包的目的不是爲了運行，而是被導入使用，記住，包只是模塊的一種形式而已，包的本質就是一種模塊

1.5.2 爲什麼要使用包

包的本質就是一個文件夾，那麼文件夾惟一的功能就是將文件組織起來

隨着功能越寫越多，咱們沒法將因此功能都放到一個文件中，因而咱們使用模塊去組織功能，而隨着模塊愈來愈多，咱們就須要用文件夾將模塊文件組織起來，以此來提升程序的結構性和可維護性

注意事項：

#1.關於包相關的導入語句也分爲import和from ... import ...兩種，可是不管哪一種，不管在什麼位置，在導入時都必須遵循一個原則：凡是在導入時帶點的，點的左邊都必須是一個包，不然非法。能夠帶有一連串的點，如item.subitem.subsubitem,但都必須遵循這個原則。但對於導入後，在使用時就沒有這種限制了，點的左邊能夠是包,模塊，函數，類(它們均可以用點的方式調用本身的屬性)。

#二、import導入文件時，產生名稱空間中的名字來源於文件，import 包，產生的名稱空間的名字一樣來源於文件，即包下的__init__.py，導入包本質就是在導入該文件

#三、包A和包B下有同名模塊也不會衝突，如A.a與B.a來自倆個命名空間

1.5.3 包的使用之import

建立包package1,在package1建立package2

在包package1中建立文件init.py

# print('__init__.py')

 

x=1

# m1='m1'

# import m1 #錯誤

from package1 import m1

 

 

# package2='package2'

# import package2 #錯誤,單獨導入包名稱時不會導入包中全部包含的全部子模塊

from package1 import package2

 

在包package1中建立文件m1.py

def f1():

    print('from f1 func')

 

在包package2中建立文件m2.py

def f2():
    print('f2')

 

須要注意的是from後import導入的模塊，必須是明確的一個不能帶點，不然會有語法錯誤，如：from a import b.c是錯誤語法

1.6 絕對導入和相對導入

咱們的最頂級包glance是寫給別人用的，而後在glance包內部也會有彼此之間互相導入的需求，這時候就有絕對導入和相對導入兩種方式：

絕對導入：以glance做爲起始

相對導入：用.或者..的方式最爲起始（只能在一個包中使用，不能用於不一樣目錄內）

1.6.1 相對導入

包的使用.py

# import package1

#

# # package1.f1()

# package1.f2()

 

import sys

sys.path.append(r'D:\video\python20期\day5\02_包\測試三（相對導入）\aaa')

 

import package1

package1.f2()

m1.py

def f1():

    print('from f1 func')

 

 

包1_init_.py

from .m1 import f1

from .package2.m2 import f2

 

m2.py

from ..m1 import f1

def f2():

    f1()

    print('f2')

 

1.6.2 絕對導入

包的使用.py

import package1

 

package1.f1()

package1.f2()

 

# import sys

#

# # sys.path.append(r'D:\video\python20期\day5\02_包\測試二（絕對導入）\package1\package2')

# # sys.path.append(r'D:\video\python20期\day5\02_包\測試二（絕對導入）\package1')

#

 

m1.py

def f1():
    print('from f1 func')

包1_init_.py

from package1.m1 import f1

from package1.package2.m2 import f2

m2.py

def f2():

    print('f2')

 

包2_init_.py

from package1.package2 import m2

 

1.7 軟件開發規範

 

 

圖1-1  

 

#===============>star.py

import sys,os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)

 

from core import src

 

if __name__ == '__main__':

    src.run()

 

#===============>settings.py

import os

 

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

DB_PATH=os.path.join(BASE_DIR,'db','db.json')

LOG_PATH=os.path.join(BASE_DIR,'log','access.log')

LOGIN_TIMEOUT=5

 

"""

logging配置

"""

# 定義三種日誌輸出格式

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'

 

# 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）傳遞

        },

    },

}

 

 

#===============>src.py

from conf import settings

from lib import common

import time

 

logger=common.get_logger(__name__)

 

current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}

def auth(func):

    def wrapper(*args,**kwargs):

        if current_user['user']:

            interval=time.time()-current_user['login_time']

            if interval < current_user['timeout']:

                return func(*args,**kwargs)

        name = input('name>>: ')

        password = input('password>>: ')

        db=common.conn_db()

        if db.get(name):

            if password == db.get(name).get('password'):

                logger.info('登陸成功')

                current_user['user']=name

                current_user['login_time']=time.time()

                return func(*args,**kwargs)

        else:

            logger.error('用戶名不存在')

 

    return wrapper

 

@auth

def buy():

    print('buy...')

 

@auth

def run():

 

    print('''

    1 購物

    2 查看餘額

    3 轉帳

    ''')

    while True:

        choice = input('>>: ').strip()

        if not choice:continue

        if choice == '1':

            buy()

 

#===============>db.json

{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}}

 

#===============>common.py

from conf import settings

import logging

import logging.config

import json

 

def get_logger(name):

    logging.config.dictConfig(settings.LOGGING_DIC)  # 導入上面定義的logging配置

    logger = logging.getLogger(name)  # 生成一個log實例

    return logger

 

 

def conn_db():

    db_path=settings.DB_PATH

    dic=json.load(open(db_path,'r',encoding='utf-8'))

    return dic

 

#===============>access.log

[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登陸成功]

[2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登陸成功]

[2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用戶名不存在]

[2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用戶名不存在]

[2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用戶名不存在]

[2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用戶名不存在]

[2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登陸成功]

[2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用戶名不存在]

[2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登陸成功]

[2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登陸成功]

 

#介紹

# 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

# )

#

# logging.debug('debug') # 10

# logging.info('info') # 20

# logging.warning('warn') #30

# logging.error('error') #40

# logging.critical('critial') #50

 

1.8 經常使用模塊

1.8.1 日誌模塊的詳細用法：

import logging

1.8.2 Logger：產生日誌

logger1=logging.getLogger('訪問日誌')

# logger2=logging.getLogger('錯吳日誌')

1.8.3 Filter：幾乎不用

1.8.4 Handler：接收Logger傳過來的日誌，進行日誌格式化，能夠打印到終端，也能夠打印到文件

sh=logging.StreamHandler() #打印到終端

fh1=logging.FileHandler('s1.log',encoding='utf-8')

fh2=logging.FileHandler('s2.log',encoding='utf-8')

 

1.8.5 Formatter：日誌格式

formatter1=logging.Formatter(

    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

formatter2=logging.Formatter(

    fmt='%(asctime)s : %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

formatter3=logging.Formatter(

    fmt='%(asctime)s : %(module)s : %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

 

 

1.8.6 、爲handler綁定日誌格式

sh.setFormatter(formatter1)

fh1.setFormatter(formatter2)

fh2.setFormatter(formatter3)

 

1.8.7 、爲logger綁定handler

logger1.addHandler(sh)

logger1.addHandler(fh1)

logger1.addHandler(fh2)

 

1.8.8 設置日誌級別:logger對象的日誌級別應該＜＝handler的日誌界別

# logger1.setLevel(50)

logger1.setLevel(10) #

sh.setLevel(10)

fh1.setLevel(10)

fh2.setLevel(10)

 

1.8.9 測試

logger1.debug('測試着玩')

logger1.info('運行還算正常')

logger1.warning('可能要有bug了')

logger1.error('很差了，真tm出bug了')

logger1.critical('完犢子，推倒重寫')

 

1.9 日誌的繼承

import logging

1.9.1 Logger：產生日誌

logger1=logging.getLogger('root')

logger2=logging.getLogger('root.child1')

logger3=logging.getLogger('root.child1.child2')

 

1.9.2 Filter：幾乎不用

 

1.9.3 Handler：接收Logger傳過來的日誌，進行日誌格式化，能夠打印到終端，也能夠打印到文件

sh=logging.StreamHandler() #打印到終端

 

1.9.4 Formatter：日誌格式

formatter1=logging.Formatter(

    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    datefmt='%Y-%m-%d %H:%M:%S %p',

)

 

 

1.9.5 爲handler綁定日誌格式

sh.setFormatter(formatter1)

 

1.9.6 爲logger綁定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

 

1.9.7 設置日誌級別:logger對象的日誌級別應該＜＝handler的日誌界別

# logger1.setLevel(50)

logger1.setLevel(10) #

logger2.setLevel(10) #

logger3.setLevel(10) #

sh.setLevel(10)

 

1.9.8 測試

logger1.debug('爺爺')

logger2.debug('爸爸')

logger3.debug('孫子')

 

1.10 正則模塊

import re

 

# print(re.findall('\w','egon 123 + _ - *'))

# print(re.findall('\W','egon 123 + _ - *'))

# print(re.findall('\s','ego\tn 12\n3 + _ - *'))

# print(re.findall('\S','ego\tn 12\n3 + _ - *'))

# print(re.findall('\d','ego\tn 12\n3 + _ - *'))

# print(re.findall('\D','ego\tn 12\n3 + _ - *'))

# print(re.findall('\n','ego\tn 12\n3 + _ - *'))

# print(re.findall('\t','ego\tn 12\n3 + _ - *'))

# print(re.findall('e','ego\tn 12\n3 +hello _ - *'))

# print(re.findall('^e','ego\tn 12\n3 +hello _ - *'))

# print(re.findall('o$','ego\tn 12\n3 +hello'))

 

#重複：.|?|*|+|{m,n}|.*|.*?

#.表明任意一個字符

# print(re.findall('a.b','a1b a b a-b aaaaaab'))

                    #   a.b

# print(re.findall('a.b','a1b a b a\nb a-b aaaaaab',re.DOTALL))

                    #   a.b

 

 

#?:表明?號左邊的字符出現0次或者1

# print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']

#                       #                  ab?

 

#*:表明*號左邊的字符出現0次或者無窮次

# print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']

                      #                  ab*

 

#+:表明+號左邊的字符出現1次或者無窮次

# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

#                       #                  ab+

 

# {m,n}:表明左邊的字符出現m次到n次

# print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']

# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 

# print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']

 

 

#.*:貪婪匹配

# print(re.findall('a.*b','xxxy123a123b456b'))

                        #        a.*b

 

#.*?:非貪婪匹配

# print(re.findall('a.*?b','xxxy123a123b456b'))

 

#|:或者

# print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))

# print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))

                                 #                                                                         compan(y|iess)

 

# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">點擊我</a>'))

 

#rawstring：

# print(re.findall(r'a\\c','a\c a1c aBc')) #a\\c->a\c

 

#[]:取中括號內任意的一個

# print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))

# print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b'))

 

#re模塊的其餘方法

#re.search :只匹配成功一次就返回

# print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))

# print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group())

 

# re.match:從開頭取

# print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))

# print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

# print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

 

# re.split

# print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))

# 'root:x:0:0::/root:/bin/bash'.split(':')

 

# re.sub

# print(re.sub('root','admin','root:x:0:0::/root:/bin/bash',1))

 

#瞭解

# print(re.sub('^([a-z]+)([^a-z]+)(.*?)([^a-z]+)([a-z]+)$',r'\5\2\3\4\1','root:x:0:0::/root:/bin/bash'))

 

# re.compile

obj=re.compile('a\d{2}b')

print(obj.findall('a12b a123b a12345b abbb'))

print(obj.search('a12b a123b a12345b abbb').group())

 

1.11 時間模塊

import time

#掌握

# print(time.time())

 

# print(time.localtime())

# print(time.localtime().tm_mday)

# print(time.gmtime())

 

# print(time.strftime('%Y-%m-%d %H:%M:%S'))

# print(time.strftime('%Y-%m-%d %X'))

 

#瞭解

# print(time.localtime(11111111))

# print(time.localtime(time.time()))

# print(time.gmtime(time.time()))

 

# print(time.mktime(time.localtime()))

 

# print(time.strftime('%Y-%m-%d',time.localtime()))

# print(time.strptime('2017-03-01','%Y-%m-%d'))

 

# print(time.asctime(time.localtime()))

# print(time.ctime(111111))

 

 

#datetime

import datetime

# print(datetime.datetime.now())

# print(datetime.datetime.fromtimestamp(111111111))

 

# print(datetime.datetime.now()+datetime.timedelta(days=3))

# print(datetime.datetime.now()+datetime.timedelta(days=-3))

# print(datetime.datetime.now()+datetime.timedelta(hours=3))

# print(datetime.datetime.now()+datetime.timedelta(minutes=3))

# print(datetime.datetime.now()+datetime.timedelta(seconds=3))

 

# print(datetime.datetime.now().replace(year=1999,hour=12))
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程