12.python 模塊使用，面向對象介紹

一.簡介

　　模塊是一個保存了Python代碼的文件。模塊能定義函數，類和變量。模塊裏也能包含可執行的代碼

　　模塊分爲三種：

• 自定義模塊
• 內置標準模塊
• 開源模塊（第三方）

自定義模塊：

　　

模塊導入

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename  
from module.xx.xx import *

導入自定義模塊時注意路徑，查看庫文件sys.path,sys.path.append('路徑')添加自定義路徑

二.內置模塊

time模塊

 

time模塊提供各類操做時間的函數

說明：通常有兩種表示時間的方式:
       1.時間戳的方式(相對於1970.1.1 00:00:00以秒計算的偏移量),時間戳是唯一的
       2.以數組的形式表示即(struct_time),共有九個元素，分別表示，同一個時間戳的struct_time會由於時區不一樣而不一樣

The tuple items are:
  year (including century, e.g. 1998)
  month (1-12)
  day (1-31)
  hours (0-23)
  minutes (0-59)
  seconds (0-59)
  weekday (0-6, Monday is 0)
  Julian day (day in the year, 1-366)
  DST (Daylight Savings Time) flag (-1, 0 or 1)

•  函數

time() -- 返回時間戳
sleep() -- 延遲運行單位爲s
gmtime() -- 轉換時間戳爲時間元組（時間對象）
localtime() -- 轉換時間戳爲本地時間對象
asctime() -- 將時間對象轉換爲字符串
ctime() -- 將時間戳轉換爲字符串
mktime() -- 將本地時間轉換爲時間戳
strftime() -- 將時間對象轉換爲規範性字符串
經常使用的格式代碼：

%Y Year with century as a decimal number.
%m Month as a decimal number [01,12].
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%M Minute as a decimal number [00,59].
%S Second as a decimal number [00,61].
%z Time zone offset from UTC.
%a Locale's abbreviated weekday name.
%A Locale's full weekday name.
%b Locale's abbreviated month name.
%B Locale's full month name.
%c Locale's appropriate date and time representation.
%I Hour (12-hour clock) as a decimal number [01,12].
%p Locale's equivalent of either AM or PM.

strptime() -- 將時間字符串根據指定的格式化符轉換成數組形式的時間
經常使用格式代碼：
   同strftime

• 舉例

  View Code

2.datetime模塊

定義的類有：　
datetime.date　　　　--表示日期的類。經常使用的屬性有year, month, day
datetime.time　　　　--表示時間的類。經常使用的屬性有hour, minute, second, microsecond

datetime.datetime　　--表示日期時間
datetime.timedelta　  --表示時間間隔，即兩個時間點之間的長度

• date類

date類表示日期，構造函數以下 ：

datetime.date(year, month, day);

year (1-9999)

month (1-12)

day (1-31)

date.today()　　--返回一個表示當前本地日期的date對象

date.fromtimestamp(timestamp) --根據給定的時間戮，返回一個date對象

 

  View Code

 

　　　　date.year() 　　--取給定時間的年

　　　　date.month()　　--取時間對象的月

　　　　date.day()　　--取給定時間的日

date.replace()　　--生成一個新的日期對象，用參數指定的年，月，日代替原有對象中的屬性

date.timetuple()　　--返回日期對應的time.struct_time對象

date.weekday()　　--返回weekday,Monday == 0 ... Sunday == 6

date.isoweekday() --返回weekday,Monday == 1 ... Sunday == 7

date.ctime()　　　　--返回給定時間的字符串格式

1 2 3 4 5 6

import  datetime from  dateutil.relativedelta  import  relativedelta # 獲取當前時間的前一個月 datetime.datetime.now()  -  relativedelta(months = + 1 ) # 獲取當天的前一個月 datetime.date.today()  -  relativedelta(months = + 1 )

  View Code

• time 類

time類表示時間，由時、分、秒以及微秒組成

time.min（)　　--最小表示時間

time.max()　　--最大表示時間

time.resolution()　　--微秒

 

  View Code

 

• datetime類

datetime是date與time的結合體，包括date與time的全部信息

datetime.max()　　--最大值

datetime.min()　　--最小值

datetime.resolution() --datetime最小單位

datetime.today()　　--返回一個表示當前本地時間

datetime.fromtimestamp()　　--根據給定的時間戮，返回一個datetime對象

datetime.year()　　--取年

datetime.month()　　--取月

datetime.day()　　--取日期

datetime.replace()　　--替換時間

datetime.strptime()　　--將字符串轉換成日期格式

datetime.time()　　--取給定日期時間的時間　　

  View Code

 

3.sys模塊

   用於提供對解釋器相關的訪問及維護，並有很強的交互功能

經常使用函數：

sys.argv --傳參，第一個參數爲腳本名稱即argv[0]

sys.path --模塊搜索路徑

sys.moudule --加載模塊字典

sys.stdin　　--標準輸入

sys.stdout　　--標準輸出

sys.stderr　　--錯誤輸出

sys.platform --返回系統平臺名稱

sys.version　　--查看python版本

sys.maxsize　　--最大的Int值

舉例:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#傳參
import sys

print(sys.argv[0])
print(sys.argv[1])
print(sys.argv[2])


##運行
python argv.py argv0 argv1
argv.py
argv0
argv1

 

  View Code

#sys.exit()系統返回值 

>>> import sys
>>> sys.exit(0)

C:\>echo %ERRORLEVEL%
0

#windows查看系統返回值命令
echo %ERRORLEVEL%
#linux查看系統返回值命令
echo $?

  View Code

  View Code

4.pickle模塊

　　pickle，用於python特有的類型 和 python的數據類型間進行轉換

 pickle模塊提供了四個功能：dumps、dump、loads、load

Functions:

    dump(object, file)
    dumps(object) -> string
    load(file) -> object
    loads(string) -> object

pickle.dumps(obj)--把任意對象序列化成一個str，而後，把這個str寫入文件
pickle.loads(string)　　--反序列化出對象
pickle.dump(obj,file)　　--直接把對象序列化後寫入文件
pickle.load(file)　　--從文件中反序列化出對象

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
accounts = {
    1000: {
        'name':'USERA',
        'email': 'lijie3721@126.com',
        'passwd': 'abc123',
        'balance': 15000,
        'phone': 13651054608,
        'bank_acc':{
            'ICBC':14324234,
            'CBC' : 235234,
            'ABC' : 35235423
        }
    },
    1001: {
        'name': 'USERB',
        'email': 'caixin@126.com',
        'passwd': 'abc145323',
        'balance': -15000,
        'phone': 1345635345,
        'bank_acc': {
            'ICBC': 4334343,
        }
    },
}
#把字典類型寫入到文件中
f = open('accounts.db','wb')
f.write(pickle.dumps(accounts))
f.close()

#2，反序列出對象並修改其內容，並將修改內容從新寫入文件
file_name = "accounts.db"
f = open(file_name,'rb')
account_dic = pickle.loads(f.read())
f.close()

account_dic[1000]['balance'] -= 500
f = open(file_name,'wb')
f.write(pickle.dumps(account_dic))
f.close()


#3,反序列化對象並查看其內容

f = open('accounts.db','rb')
acountdb = pickle.loads(f.read())
print(acountdb)

dic = {
    'k1': [1,2],
    'k2': [3,4]
}
#1.將對象寫入文件
f = open('test','wb')
pickle.dump(dic,f)
f.close()
#2.將文件中內容反序列化，並讀出
f = open('test','rb')
dic2 = pickle.load(f)
print(dic2)
f.close()

 

5.os模塊

做用：

　　用於提供系統級別的操做

函數：　

 1 os.getcwd()                 獲取當前工做目錄，即當前python腳本工做的目錄路徑
 2 os.chdir("dirname")         改變當前腳本工做目錄；至關於shell下cd
 3 os.curdir                   返回當前目錄: ('.')
 4 os.pardir                   獲取當前目錄的父目錄字符串名：('..')
 5 os.makedirs('dir1/dir2')    可生成多層遞歸目錄
 6 os.removedirs('dirname1')   若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
 7 os.mkdir('dirname')         生成單級目錄；至關於shell中mkdir dirname
 8 os.rmdir('dirname')         刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
 9 os.listdir('dirname')       列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
10 os.remove()                 刪除一個文件
11 os.rename("oldname","new")  重命名文件/目錄
12 os.stat('path/filename')    獲取文件/目錄信息
13 os.sep                      操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
14 os.linesep                  當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
15 os.pathsep                  用於分割文件路徑的字符串
16 os.name                     字符串指示當前使用平臺。win->'nt'; Linux->'posix'
17 os.system("bash command")   運行shell命令，直接顯示
18 os.environ                  獲取系統環境變量
19 os.path.abspath(path)       返回path規範化的絕對路徑
20 os.path.split(path)         將path分割成目錄和文件名二元組返回
21 os.path.dirname(path)       返回path的目錄。其實就是os.path.split(path)的第一個元素
22 os.path.basename(path)      返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
23 os.path.exists(path)        若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)         若是path是絕對路徑，返回True
25 os.path.isfile(path)        若是path是一個存在的文件，返回True。不然返回False
26 os.path.isdir(path)         若是path是一個存在的目錄，則返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
28 os.path.getatime(path)      返回path所指向的文件或者目錄的最後存取時間
29 os.path.getmtime(path)      返回path所指向的文件或者目錄的最後修改時間

6.hashlib模塊

　　做用：

　　用於加密相關的操做，代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法　

  View Code

　　加密算法缺陷，即：經過撞庫能夠反解。因此，有必要對加密算法中添加自定義key再來作加密

  View Code

　　7.random

　　做用：

　　生成隨機變量

import random
 
print(random.random())
print(random.randint(1, 2))
print(random.randrange(1, 10))

import random
checkcode = ''
for i in range(4):
    current = random.randrange(0,4)
    if current != i:
        temp = chr(random.randint(65,90))
    else:
        temp = random.randint(0,9)
    checkcode += str(temp)
print checkcode

 

 

參考連接

https://i.cnblogs.com/EditPosts.aspx?opt=1

 

python 面向對象（進階篇）

 

成員

類的成員能夠分爲三大類：字段、方法和屬性

注：全部成員中，只有普通字段的內容保存對象中，即：根據此類建立了多少對象，在內存中就有多少個普通字段。而其餘的成員，則都是保存在類中，即：不管對象的多少，在內存中只建立一份。

1、字段

字段包括：普通字段和靜態字段，他們在定義和使用中有所區別，而最本質的區別是內存中保存的位置不一樣，

• 普通字段屬於對象
• 靜態字段屬於類

  字段的定義和使用

由上述代碼能夠看出【普通字段須要經過對象來訪問】【靜態字段經過類訪問】，在使用上能夠看出普通字段和靜態字段的歸屬是不一樣的。其在內容的存儲方式相似以下圖：

由上圖但是：

• 靜態字段在內存中只保存一份
• 普通字段在每一個對象中都要保存一份

應用場景： 經過類建立對象時，若是每一個對象都具備相同的字段，那麼就使用靜態字段

2、方法

方法包括：普通方法、靜態方法和類方法，三種方法在內存中都歸屬於類，區別在於調用方式不一樣。

• 普通方法：由對象調用；至少一個self參數；執行普通方法時，自動將調用該方法的對象賦值給self；
• 類方法：由類調用； 至少一個cls參數；執行類方法時，自動將調用該方法的類複製給cls；
• 靜態方法：由類調用；無默認參數；

  方法的定義和使用

相同點：對於全部的方法而言，均屬於類（非對象）中，因此，在內存中也只保存一份。

不一樣點：方法調用者不一樣、調用方法時自動傳入的參數不一樣。

3、屬性　　

若是你已經瞭解Python類中的方法，那麼屬性就很是簡單了，由於Python中的屬性實際上是普通方法的變種。

對於屬性，有如下三個知識點：

• 屬性的基本使用
• 屬性的兩種定義方式

一、屬性的基本使用

  屬性的定義和使用

由屬性的定義和調用要注意一下幾點：

• 定義時，在普通方法的基礎上添加 @property 裝飾器；
• 定義時，屬性僅有一個self參數
• 調用時，無需括號
             方法：foo_obj.func()
             屬性：foo_obj.prop

注意：屬性存在乎義是：訪問屬性時能夠製造出和訪問字段徹底相同的假象

        屬性由方法變種而來，若是Python中沒有屬性，方法徹底能夠代替其功能。

實例：對於主機列表頁面，每次請求不可能把數據庫中的全部內容都顯示到頁面上，而是經過分頁的功能局部顯示，因此在向數據庫中請求數據時就要顯示的指定獲取從第m條到第n條的全部數據（即：limit m,n），這個分頁的功能包括：

• 根據用戶請求的當前頁和總數據條數計算出 m 和 n
• 根據m 和 n 去數據庫中請求數據 

  View Code

從上述可見，Python的屬性的功能是：屬性內部進行一系列的邏輯計算，最終將計算結果返回。

二、屬性的兩種定義方式

屬性的定義有兩種方式：

• 裝飾器 即：在方法上應用裝飾器
• 靜態字段 即：在類中定義值爲property對象的靜態字段

裝飾器方式：在類的普通方法上應用@property裝飾器

咱們知道Python中的類有經典類和新式類，新式類的屬性比經典類的屬性豐富。（ 若是類繼object，那麼該類是新式類 ）
經典類，具備一種@property裝飾器（如上一步實例）

# ############### 定義 ############### class Goods: @property def price(self): return "wupeiqi" # ############### 調用 ############### obj = Goods() result = obj.price # 自動執行 @property 修飾的 price 方法，並獲取方法的返回值

新式類，具備三種@property裝飾器

# ############### 定義 ############### class Goods(object): @property def price(self): print '@property' @price.setter def price(self, value): print '@price.setter' @price.deleter def price(self): print '@price.deleter' # ############### 調用 ############### obj = Goods() obj.price # 自動執行 @property 修飾的 price 方法，並獲取方法的返回值  obj.price = 123 # 自動執行 @price.setter 修飾的 price 方法，並將 123 賦值給方法的參數 del obj.price # 自動執行 @price.deleter 修飾的 price 方法

 

注：經典類中的屬性只有一種訪問方式，其對應被 @property 修飾的方法
      新式類中的屬性有三種訪問方式，並分別對應了三個被@property、@方法名.setter、@方法名.deleter修飾的方法

因爲新式類中具備三種訪問方式，咱們能夠根據他們幾個屬性的訪問特色，分別將三個方法定義爲對同一個屬性：獲取、修改、刪除

class Goods(object): def __init__(self): # 原價 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 實際價格 = 原價 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deltter def price(self, value): del self.original_price obj = Goods() obj.price # 獲取商品價格 obj.price = 200 # 修改商品原價 del obj.price # 刪除商品原價

靜態字段方式，建立值爲property對象的靜態字段

當使用靜態字段的方式建立屬性時，經典類和新式類無區別

class Foo:

    def get_bar(self):
        return 'wupeiqi' BAR = property(get_bar) obj = Foo() reuslt = obj.BAR # 自動調用get_bar方法，並獲取方法的返回值 print reuslt

property的構造方法中有個四個參數

• 第一個參數是方法名，調用 對象.屬性 時自動觸發執行方法
• 第二個參數是方法名，調用 對象.屬性 ＝ XXX 時自動觸發執行方法
• 第三個參數是方法名，調用 del 對象.屬性 時自動觸發執行方法
• 第四個參數是字符串，調用 對象.屬性.__doc__ ，此參數是該屬性的描述信息

  View Code

 因爲靜態字段方式建立屬性具備三種訪問方式，咱們能夠根據他們幾個屬性的訪問特色，分別將三個方法定義爲對同一個屬性：獲取、修改、刪除

  實例

 注意：Python WEB框架 Django 的視圖中 request.POST 就是使用的靜態字段的方式建立的屬性

  Django源碼

因此，定義屬性共有兩種方式，分別是【裝飾器】和【靜態字段】，而【裝飾器】方式針對經典類和新式類又有所不一樣。

類成員的修飾符

類的全部成員在上一步驟中已經作了詳細的介紹，對於每個類的成員而言都有兩種形式：

• 公有成員，在任何地方都能訪問
• 私有成員，只有在類的內部才能方法

私有成員和公有成員的定義不一樣：私有成員命名時，前兩個字符是下劃線。（特殊成員除外，例如：__init__、__call__、__dict__等）

1 2 3 4 5

class  C:        def  __init__( self ):          self .name  =  '公有字段'          self .__foo  =  "私有字段"

私有成員和公有成員的訪問限制不一樣：

靜態字段

• 公有靜態字段：類能夠訪問；類內部能夠訪問；派生類中能夠訪問
• 私有靜態字段：僅類內部能夠訪問；

  公有靜態字段

  私有靜態字段

普通字段

• 公有普通字段：對象能夠訪問；類內部能夠訪問；派生類中能夠訪問
• 私有普通字段：僅類內部能夠訪問；

ps：若是想要強制訪問私有字段，能夠經過 【對象._類名__私有字段明 】訪問（如：obj._C__foo），不建議強制訪問私有成員。

  公有字段

  私有字段

方法、屬性的訪問於上述方式類似，即：私有成員只能在類內部使用

ps：非要訪問私有屬性的話，能夠經過 對象._類__屬性名

類的特殊成員

上文介紹了Python的類成員以及成員修飾符，從而瞭解到類中有字段、方法和屬性三大類成員，而且成員名前若是有兩個下劃線，則表示該成員是私有成員，私有成員只能由類內部調用。不管人或事物每每都有不按套路出牌的狀況，Python的類成員也是如此，存在着一些具備特殊含義的成員，詳情以下：

1. __doc__

　　表示類的描述信息

  View Code

2. __module__ 和  __class__ 

　　__module__ 表示當前操做的對象在那個模塊

　　__class__     表示當前操做的對象的類是什麼

  lib/aa.py

  index.py

3. __init__

　　構造方法，經過類建立對象時，自動觸發執行。

  View Code

4. __del__

　　析構方法，當對象在內存中被釋放時，自動觸發執行。

注：此方法通常無須定義，由於Python是一門高級語言，程序員在使用時無需關心內存的分配和釋放，由於此工做都是交給Python解釋器來執行，因此，析構函數的調用是由解釋器在進行垃圾回收時自動觸發執行的。

  View Code

5. __call__

　　對象後面加括號，觸發執行。

注：構造方法的執行是由建立對象觸發的，即：對象 = 類名() ；而對於 __call__ 方法的執行是由對象後加括號觸發的，即：對象() 或者 類()()

  View Code

6. __dict__

　　類或對象中的全部成員

上文中咱們知道：類的普通字段屬於對象；類中的靜態字段和方法等屬於類，即：

  View Code

 7. __str__

　　若是一個類中定義了__str__方法，那麼在打印 對象 時，默認輸出該方法的返回值。

  View Code

八、__getitem__、__setitem__、__delitem__

用於索引操做，如字典。以上分別表示獲取、設置、刪除數據

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#!/usr/bin/env python # -*- coding:utf-8 -*-   class  Foo( object ):        def  __getitem__( self , key):          print  '__getitem__' ,key        def  __setitem__( self , key, value):          print  '__setitem__' ,key,value        def  __delitem__( self , key):          print  '__delitem__' ,key     obj  =  Foo()   result  =  obj[ 'k1' ]       # 自動觸發執行 __getitem__ obj[ 'k2' ]  =  'wupeiqi'    # 自動觸發執行 __setitem__ del  obj[ 'k1' ]            # 自動觸發執行 __delitem__

九、__getslice__、__setslice__、__delslice__

 該三個方法用於分片操做，如：列表

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#!/usr/bin/env python # -*- coding:utf-8 -*-   class  Foo( object ):        def  __getslice__( self , i, j):          print  '__getslice__' ,i,j        def  __setslice__( self , i, j, sequence):          print  '__setslice__' ,i,j        def  __delslice__( self , i, j):          print  '__delslice__' ,i,j   obj  =  Foo()   obj[ - 1 : 1 ]                    # 自動觸發執行 __getslice__ obj[ 0 : 1 ]  =  [ 11 , 22 , 33 , 44 ]     # 自動觸發執行 __setslice__ del  obj[ 0 : 2 ]                 # 自動觸發執行 __delslice__

10. __iter__ 

用於迭代器，之因此列表、字典、元組能夠進行for循環，是由於類型內部定義了 __iter__ 

  第一步

  第二步

  第三步

以上步驟能夠看出，for循環迭代的實際上是  iter([11,22,33,44]) ，因此執行流程能夠變動爲：

1 2 3 4 5 6 7

#!/usr/bin/env python # -*- coding:utf-8 -*-   obj  =  iter ([ 11 , 22 , 33 , 44 ])   for  i  in  obj:      print  i

  For循環語法內部

11. __new__ 和 __metaclass__

閱讀如下代碼：

1 2 3 4 5 6

class  Foo( object ):        def  __init__( self ):          pass   obj  =  Foo()    # obj是經過Foo類實例化的對象

上述代碼中，obj 是經過 Foo 類實例化的對象，其實，不只 obj 是一個對象，Foo類自己也是一個對象，由於在Python中一切事物都是對象。

若是按照一切事物都是對象的理論：obj對象是經過執行Foo類的構造方法建立，那麼Foo類對象應該也是經過執行某個類的 構造方法 建立。

1 2	print  type (obj)  # 輸出：<class '__main__.Foo'>     表示，obj 對象由Foo類建立 print  type (Foo)  # 輸出：<type 'type'>              表示，Foo類對象由 type 類建立

因此，obj對象是Foo類的一個實例，Foo類對象是 type 類的一個實例，即：Foo類對象 是經過type類的構造方法建立。

那麼，建立類就能夠有兩種方式：

a). 普通方式

1 2 3 4

class  Foo( object ):        def  func( self ):          print  'hello wupeiqi'

b).特殊方式（type類的構造函數）

1 2 3 4 5 6 7

def  func( self ):      print  'hello wupeiqi'   Foo  =  type ( 'Foo' ,( object ,), { 'func' : func}) #type第一個參數：類名 #type第二個參數：當前類的基類 #type第三個參數：類的成員

＝＝》 類 是由 type 類實例化產生

那麼問題來了，類默認是由 type 類實例化產生，type類中如何實現的建立類？類又是如何建立對象？

答：類中有一個屬性 __metaclass__，其用來表示該類由 誰 來實例化建立，因此，咱們能夠爲 __metaclass__ 設置一個type類的派生類，從而查看 類 建立的過程。

class MyType(type): def __init__(self, what, bases=None, dict=None): super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 第一階段：解釋器從上到下執行代碼建立Foo類 # 第二階段：經過Foo類建立obj對象 obj = Foo()

 

 

 

參考連接 

https://www.cnblogs.com/wupeiqi/p/4766801.html