欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

python持久性管理pickle模塊詳細介紹

 更新時間:2015年02月18日 16:45:49   投稿:junjie  
這篇文章主要介紹了python持久性管理pickle模塊詳細介紹,本文講解了什么是持久性、一些經(jīng)過 pickle 的 Python等內(nèi)容,并講給出了18個使用示例,需要的朋友可以參考下

持久性就是指保持對象,甚至在多次執(zhí)行同一程序之間也保持對象。通過本文,您會對 Python對象的各種持久性機制(從關系數(shù)據(jù)庫到 Python 的 pickle以及其它機制)有一個總體認識。另外,還會讓您更深一步地了解Python 的對象序列化能力。
什么是持久性?

持 久性的基本思想很簡單。假定有一個 Python 程序,它可能是一個管理日常待辦事項的程序,您希望在多次執(zhí)行這個程序之間可以保存應用程序?qū)ο螅ùk事項)。換句話說,您希望將對象存儲在磁盤上,便于 以后檢索。這就是持久性。要達到這個目的,有幾種方法,每一種方法都有其優(yōu)缺點。

例如,可以將對象數(shù)據(jù)存儲在某種格式的文本文件中,譬如 CSV 文件?;蛘呖梢杂藐P系數(shù)據(jù)庫,譬如 Gadfly、MySQL、PostgreSQL 或者 DB2。這些文件格式和數(shù)據(jù)庫都非常優(yōu)秀,對于所有這些存儲機制,Python 都有健壯的接口。

這 些存儲機制都有一個共同點:存儲的數(shù)據(jù)是獨立于對這些數(shù)據(jù)進行操作的對象和程序。這樣做的好處是,數(shù)據(jù)可以作為共享的資源,供其它應用程序使用。缺點 是,用這種方式,可以允許其它程序訪問對象的數(shù)據(jù),這違背了面向?qū)ο蟮姆庋b性原則 — 即對象的數(shù)據(jù)只能通過這個對象自身的公共(public)接口來訪問。

另外,對于某些應用程序,關系數(shù)據(jù)庫 方法可能不是很理想。尤其是,關系數(shù)據(jù)庫不理解對象。相反,關系數(shù)據(jù)庫會強行 使用自己的類型系統(tǒng)和關系數(shù)據(jù)模型(表),每張表包含一組元組(行),每行包含具有固定數(shù)目的靜態(tài)類型字段(列)。如果應用程序的對象模型不能夠方便地轉(zhuǎn) 換到關系模型,那么在將對象映射到元組以及將元組映射回對象方面,會碰到一定難度。這種困難常被稱為阻礙性不匹配(impedence- mismatch)問題。

一些經(jīng)過 pickle 的 Python

pickle 模塊及其同類模塊 cPickle 向 Python 提供了 pickle 支持。后者是用 C 編碼的,它具有更好的性能,對于大多數(shù)應用程序,推薦使用該模塊。我們將繼續(xù)討論 pickle ,但本文的示例實際是利用了 cPickle 。由于其中大多數(shù)示例要用 Python shell 來顯示,所以先展示一下如何導入 cPickle ,并可以作為 pickle 來引用它:

復制代碼 代碼如下:

>>> import cPickle as pickle

現(xiàn)在已經(jīng)導入了該模塊,接下來讓我們看一下 pickle 接口。 pickle 模塊提供了以下函數(shù)對: dumps(object) 返回一個字符串,它包含一個 pickle 格式的對象; loads(string) 返回包含在 pickle 字符串中的對象; dump(object, file) 將對象寫到文件,這個文件可以是實際的物理文件,但也可以是任何類似于文件的對象,這個對象具有 write() 方法,可以接受單個的字符串參數(shù); load(file) 返回包含在 pickle 文件中的對象。

缺省情況下, dumps() 和 dump() 使用可打印的 ASCII 表示來創(chuàng)建 pickle。兩者都有一個 final 參數(shù)(可選),如果為 True ,則該參數(shù)指定用更快以及更小的二進制表示來創(chuàng)建 pickle。 loads() 和 load() 函數(shù)自動檢測 pickle 是二進制格式還是文本格式。

清單 1 顯示了一個交互式會話,這里使用了剛才所描述的 dumps() 和 loads() 函數(shù):


清單 1. dumps() 和 loads() 的演示

復制代碼 代碼如下:

Welcome To PyCrust 0.7.2 - The Flakiest Python Shell
Sponsored by Orbtech - Your source for Python programming expertise.
Python 2.2.1 (#1, Aug 27 2002, 10:22:32)
[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)] on linux-i386
Type "copyright", "credits" or "license" for more information.
>>> import cPickle as pickle
>>> t1 = ('this is a string', 42, [1, 2, 3], None)
>>> t1
('this is a string', 42, [1, 2, 3], None)
>>> p1 = pickle.dumps(t1)
>>> p1
"(S'this is a string'\nI42\n(lp1\nI1\naI2\naI3\naNtp2\n."
>>> print p1
(S'this is a string'
I42
(lp1
I1
aI2
aI3
aNtp2
.
>>> t2 = pickle.loads(p1)
>>> t2
('this is a string', 42, [1, 2, 3], None)
>>> p2 = pickle.dumps(t1, True)
>>> p2
'(U\x10this is a stringK*]q\x01(K\x01K\x02K\x03eNtq\x02.'
>>> t3 = pickle.loads(p2)
>>> t3
('this is a string', 42, [1, 2, 3], None)

注:該文本 pickle 格式很簡單,這里就不解釋了。事實上,在 pickle 模塊中記錄了所有使用的約定。我們還應該指出,在我們的示例中使用的都是簡單對象,因此使用二進制 pickle 格式不會在節(jié)省空間上顯示出太大的效率。然而,在實際使用復雜對象的系統(tǒng)中,您會看到,使用二進制格式可以在大小和速度方面帶來顯著的改進。

接下來,我們看一些示例,這些示例用到了 dump() 和 load() ,它們使用文件和類似文件的對象。這些函數(shù)的操作非常類似于我們剛才所看到的 dumps() 和 loads() ,區(qū)別在于它們還有另一種能力 — dump() 函數(shù)能一個接著一個地將幾個對象轉(zhuǎn)儲到同一個文件。隨后調(diào)用 load() 來以同樣的順序檢索這些對象。清單 2 顯示了這種能力的實際應用:

清單 2. dump() 和 load() 示例

復制代碼 代碼如下:

>>> a1 = 'apple'
>>> b1 = {1: 'One', 2: 'Two', 3: 'Three'}
>>> c1 = ['fee', 'fie', 'foe', 'fum']
>>> f1 = file('temp.pkl', 'wb')
>>> pickle.dump(a1, f1, True)
>>> pickle.dump(b1, f1, True)
>>> pickle.dump(c1, f1, True)
>>> f1.close()
>>> f2 = file('temp.pkl', 'rb')
>>> a2 = pickle.load(f2)
>>> a2
'apple'
>>> b2 = pickle.load(f2)
>>> b2
{1: 'One', 2: 'Two', 3: 'Three'}
>>> c2 = pickle.load(f2)
>>> c2
['fee', 'fie', 'foe', 'fum']
>>> f2.close()

Pickle 的威力

到目前為止,我們講述了關于 pickle 方面的基本知識。在這一節(jié),將討論一些高級問題,當您開始 pickle 復雜對象時,會遇到這些問題,其中包括定制類的實例。幸運的是,Python 可以很容易地處理這種情形。

可移植性

從 空間和時間上說,Pickle 是可移植的。換句話說,pickle 文件格式獨立于機器的體系結(jié)構(gòu),這意味著,例如,可以在 Linux 下創(chuàng)建一個 pickle,然后將它發(fā)送到在 Windows 或 Mac OS 下運行的 Python 程序。并且,當升級到更新版本的 Python 時,不必擔心可能要廢棄已有的 pickle。Python 開發(fā)人員已經(jīng)保證 pickle 格式將可以向后兼容 Python 各個版本。事實上,在 pickle 模塊中提供了有關目前以及所支持的格式方面的詳細信息:


清單 3. 檢索所支持的格式

復制代碼 代碼如下:

>>> pickle.format_version
'1.3'
>>> pickle.compatible_formats
['1.0', '1.1', '1.2']

多個引用,同一對象

在 Python 中,變量是對象的引用。同時,也可以用多個變量引用同一個對象。經(jīng)證明,Python 在用經(jīng)過 pickle 的對象維護這種行為方面絲毫沒有困難,如清單 4 所示:

清單 4. 對象引用的維護

復制代碼 代碼如下:

>>> a = [1, 2, 3]
>>> b = a
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 4]
>>> c = pickle.dumps((a, b))
>>> d, e = pickle.loads(c)
>>> d
[1, 2, 3, 4]
>>> e
[1, 2, 3, 4]
>>> d.append(5)
>>> d
[1, 2, 3, 4, 5]
>>> e
[1, 2, 3, 4, 5]

循環(huán)引用和遞歸引用

可以將剛才演示過的對象引用支持擴展到 循環(huán)引用(兩個對象各自包含對對方的引用)和 遞歸引用(一個對象包含對其自身的引用)。下面兩個清單著重顯示這種能力。我們先看一下遞歸引用:

>清單 5. 遞歸引用

復制代碼 代碼如下:

>>> l = [1, 2, 3]
>>> l.append(l)
>>> l
[1, 2, 3, [...]]
>>> l[3]
[1, 2, 3, [...]]
>>> l[3][3]
[1, 2, 3, [...]]
>>> p = pickle.dumps(l)
>>> l2 = pickle.loads(p)
>>> l2
[1, 2, 3, [...]]
>>> l2[3]
[1, 2, 3, [...]]
>>> l2[3][3]
[1, 2, 3, [...]]

現(xiàn)在,看一個循環(huán)引用的示例:

清單 6. 循環(huán)引用

復制代碼 代碼如下:

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> b.append(a)
>>> a
[1, 2, [3, 4, [...]]]
>>> b
[3, 4, [1, 2, [...]]]
>>> a[2]
[3, 4, [1, 2, [...]]]
>>> b[2]
[1, 2, [3, 4, [...]]]
>>> a[2] is b
>>> b[2] is a
>>> f = file('temp.pkl', 'w')
>>> pickle.dump((a, b), f)
>>> f.close()
>>> f = file('temp.pkl', 'r')
>>> c, d = pickle.load(f)
>>> f.close()
>>> c
[1, 2, [3, 4, [...]]]
>>> d
[3, 4, [1, 2, [...]]]
>>> c[2]
[3, 4, [1, 2, [...]]]
>>> d[2]
[1, 2, [3, 4, [...]]]
>>> c[2] is d
>>> d[2] is c

注意,如果分別 pickle 每個對象,而不是在一個元組中一起 pickle 所有對象,會得到略微不同(但很重要)的結(jié)果,如清單 7 所示:


清單 7. 分別 pickle vs. 在一個元組中一起 pickle

復制代碼 代碼如下:

>>> f = file('temp.pkl', 'w')
>>> pickle.dump(a, f)
>>> pickle.dump(b, f)
>>> f.close()
>>> f = file('temp.pkl', 'r')
>>> c = pickle.load(f)
>>> d = pickle.load(f)
>>> f.close()
>>> c
[1, 2, [3, 4, [...]]]
>>> d
[3, 4, [1, 2, [...]]]
>>> c[2]
[3, 4, [1, 2, [...]]]
>>> d[2]
[1, 2, [3, 4, [...]]]
>>> c[2] is d
>>> d[2] is c

相等,但并不總是相同

正如在上一個示例所暗示的,只有在這些對象引用內(nèi)存中同一個對象時,它們才是相同的。在 pickle 情形中,每個對象被恢復到一個與原來對象相等的對象,但不是同一個對象。換句話說,每個 pickle 都是原來對象的一個副本:


清單 8. 作為原來對象副本的被恢復的對象

復制代碼 代碼如下:

>>> j = [1, 2, 3]
>>> k = j
>>> k is j
>>> x = pickle.dumps(k)
>>> y = pickle.loads(x)
>>> y
[1, 2, 3]
>>> y == k
>>> y is k
>>> y is j
>>> k is j

同時,我們看到 Python 能夠維護對象之間的引用,這些對象是作為一個單元進行 pickle 的。然而,我們還看到分別調(diào)用 dump() 會使 Python 無法維護對在該單元外部進行 pickle 的對象的引用。相反,Python 復制了被引用對象,并將副本和被 pickle 的對象存儲在一起。對于 pickle 和恢復單個對象層次結(jié)構(gòu)的應用程序,這是沒有問題的。但要意識到還有其它情形。

值得指出的是,有一個選項確實允許分別 pickle 對象,并維護相互之間的引用,只要這些對象都是 pickle 到同一文件即可。 pickle 和 cPickle 模塊提供了一個 Pickler (與此相對應是 Unpickler ),它能夠跟蹤已經(jīng)被 pickle 的對象。通過使用這個 Pickler ,將會通過引用而不是通過值來 pickle 共享和循環(huán)引用:


清單 9. 維護分別 pickle 的對象間的引用

復制代碼 代碼如下:

>>> f = file('temp.pkl', 'w')
>>> pickler = pickle.Pickler(f)
>>> pickler.dump(a)
<cPickle.Pickler object at 0x89b0bb8>
>>> pickler.dump(b)
<cPickle.Pickler object at 0x89b0bb8>
>>> f.close()
>>> f = file('temp.pkl', 'r')
>>> unpickler = pickle.Unpickler(f)
>>> c = unpickler.load()
>>> d = unpickler.load()
>>> c[2]
[3, 4, [1, 2, [...]]]
>>> d[2]
[1, 2, [3, 4, [...]]]
>>> c[2] is d
>>> d[2] is c

不可 pickle 的對象

一 些對象類型是不可 pickle 的。例如,Python 不能 pickle 文件對象(或者任何帶有對文件對象引用的對象),因為 Python 在 unpickle 時不能保證它可以重建該文件的狀態(tài)(另一個示例比較難懂,在這類文章中不值得提出來)。試圖 pickle 文件對象會導致以下錯誤:


清單 10. 試圖 pickle 文件對象的結(jié)果

復制代碼 代碼如下:

>>> f = file('temp.pkl', 'w')
>>> p = pickle.dumps(f)
Traceback (most recent call last):
  File "<input>", line 1, in ?
  File "/usr/lib/python2.2/copy_reg.py", line 57, in _reduce
    raise TypeError, "can't pickle %s objects" % base.__name__
TypeError: can't pickle file objects


類實例

與 pickle 簡單對象類型相比,pickle 類實例要多加留意。這主要由于 Python 會 pickle 實例數(shù)據(jù)(通常是 _dict_ 屬性)和類的名稱,而不會 pickle 類的代碼。當 Python unpickle 類的實例時,它會試圖使用在 pickle 該實例時的確切的類名稱和模塊名稱(包括任何包的路徑前綴)導入包含該類定義的模塊。另外要注意,類定義必須出現(xiàn)在模塊的最頂層,這意味著它們不能是嵌套 的類(在其它類或函數(shù)中定義的類)。

當 unpickle 類的實例時,通常不會再調(diào)用它們的 _init_() 方法。相反,Python 創(chuàng)建一個通用類實例,并應用已進行過 pickle 的實例屬性,同時設置該實例的 _class_ 屬性,使其指向原來的類。

對 Python 2.2 中引入的新型類進行 unpickle 的機制與原來的略有不同。雖然處理的結(jié)果實際上與對舊型類處理的結(jié)果相同,但 Python 使用 copy_reg 模塊的 _reconstructor() 函數(shù)來恢復新型類的實例。

如果希望對新型或舊型類的實例修改缺省的 pickle 行為,則可以定義特殊的類的方法 _getstate_() 和 _setstate_() ,在保存和恢復類實例的狀態(tài)信息期間,Python 會調(diào)用這些方法。在以下幾節(jié)中,我們會看到一些示例利用了這些特殊的方法。

現(xiàn)在,我們看一個簡單的類實例。首先,創(chuàng)建一個 persist.py 的 Python 模塊,它包含以下新型類的定義:

清單 11. 新型類的定義

復制代碼 代碼如下:

class Foo(object):
    def __init__(self, value):
        self.value = value

現(xiàn)在可以 pickle Foo 實例,并看一下它的表示:

清單 12. pickle Foo 實例

復制代碼 代碼如下:

>>> import cPickle as pickle
>>> from Orbtech.examples.persist import Foo
>>> foo = Foo('What is a Foo?')
>>> p = pickle.dumps(foo)
>>> print p
ccopy_reg
_reconstructor
p1
(cOrbtech.examples.persist
Foo
p2
c__builtin__
object
p3
NtRp4
(dp5
S'value'
p6
S'What is a Foo?'
sb.
>>>

可以看到這個類的名稱 Foo 和全限定的模塊名稱 Orbtech.examples.persist 都存儲在 pickle 中。如果將這個實例 pickle 成一個文件,稍后再 unpickle 它或在另一臺機器上 unpickle,則 Python 會試圖導入 Orbtech.examples.persist 模塊,如果不能導入,則會拋出異常。如果重命名該類和該模塊或者將該模塊移到另一個目錄,則也會發(fā)生類似的錯誤。

這里有一個 Python 發(fā)出錯誤消息的示例,當我們重命名 Foo 類,然后試圖裝入先前進行過 pickle 的 Foo 實例時會發(fā)生該錯誤:


清單 13. 試圖裝入一個被重命名的 Foo 類的經(jīng)過 pickle 的實例

復制代碼 代碼如下:

>>> import cPickle as pickle
>>> f = file('temp.pkl', 'r')
>>> foo = pickle.load(f)
Traceback (most recent call last):
  File "<input>", line 1, in ?
AttributeError: 'module' object has no attribute 'Foo'

在重命名 persist.py 模塊之后,也會發(fā)生類似的錯誤:

清單 14. 試圖裝入一個被重命名的 persist.py 模塊的經(jīng)過 pickle 的實例

復制代碼 代碼如下:

>>> import cPickle as pickle
>>> f = file('temp.pkl', 'r')
>>> foo = pickle.load(f)
Traceback (most recent call last):
  File "<input>", line 1, in ?
ImportError: No module named persist

我們會在下面 模式改進這一節(jié)提供一些技術(shù)來管理這類更改,而不會破壞現(xiàn)有的 pickle。

特殊的狀態(tài)方法

前面提到對一些對象類型(譬如,文件對象)不能進行 pickle。處理這種不能 pickle 的對象的實例屬性時可以使用特殊的方法( _getstate_() 和 _setstate_() )來修改類實例的狀態(tài)。這里有一個 Foo 類的示例,我們已經(jīng)對它進行了修改以處理文件對象屬性:

清單 15. 處理不能 pickle 的實例屬性

復制代碼 代碼如下:

class Foo(object):
    def __init__(self, value, filename):
        self.value = value
        self.logfile = file(filename, 'w')
    def __getstate__(self):
        """Return state values to be pickled."""
        f = self.logfile
        return (self.value, f.name, f.tell())
    def __setstate__(self, state):
        """Restore state from the unpickled state values."""
        self.value, name, position = state
        f = file(name, 'w')
        f.seek(position)
        self.logfile = f

模式改進

隨 著時間的推移,您會發(fā)現(xiàn)自己必須要更改類的定義。如果已經(jīng)對某個類實例進行了 pickle,而現(xiàn)在又需要更改這個類,則您可能要檢索和更新那些實例,以便它們能在新的類定義下繼續(xù)正常工作。而我們已經(jīng)看到在對類或模塊進行某些更改 時,會出現(xiàn)一些錯誤。幸運的是,pickle 和 unpickle 過程提供了一些 hook,我們可以用它們來支持這種模式改進的需要。

在 這一節(jié),我們將探討一些方法來預測常見問題以及如何解決這些問題。由于不能 pickle 類實例代碼,因此可以添加、更改和除去方法,而不會影響現(xiàn)有的經(jīng)過 pickle 的實例。出于同樣的原因,可以不必擔心類的屬性。您必須確保包含類定義的代碼模塊在 unpickle 環(huán)境中可用。同時還必須為這些可能導致 unpickle 問題的更改做好規(guī)劃,這些更改包括:更改類名、添加或除去實例的屬性以及改變類定義模塊的名稱或位置。

類名的更改

要 更改類名,而不破壞先前經(jīng)過 pickle 的實例,請遵循以下步驟。首先,確保原來的類的定義沒有被更改,以便在 unpickle 現(xiàn)有實例時可以找到它。不要更改原來的名稱,而是在與原來類定義所在的同一個模塊中,創(chuàng)建該類定義的一個副本,同時給它一個新的類名。然后使用實際的新類 名來替代 NewClassName ,將以下方法添加到原來類的定義中:

清單 16. 更改類名:添加到原來類定義的方法

復制代碼 代碼如下:

def __setstate__(self, state):
    self.__dict__.update(state)
    self.__class__ = NewClassName

當 unpickle 現(xiàn)有實例時,Python 將查找原來類的定義,并調(diào)用實例的 _setstate_() 方法,同時將給新的類定義重新分配該實例的 _class_ 屬性。一旦確定所有現(xiàn)有的實例都已經(jīng) unpickle、更新和重新 pickle 后,可以從源代碼模塊中除去舊的類定義。

屬性的添加和刪除

這些特殊的狀態(tài)方法 _getstate_() 和 _setstate_() 再一次使我們能控制每個實例的狀態(tài),并使我們有機會處理實例屬性中的更改。讓我們看一個簡單的類的定義,我們將向其添加和除去一些屬性。這是是最初的定義:


清單 17. 最初的類定義

復制代碼 代碼如下:

class Person(object):
    def __init__(self, firstname, lastname):
        self.firstname = firstname
        self.lastname = lastname

假定已經(jīng)創(chuàng)建并 pickle 了 Person 的實例,現(xiàn)在我們決定真的只想存儲一個名稱屬性,而不是分別存儲姓和名。這里有一種方式可以更改類的定義,它將先前經(jīng)過 pickle 的實例遷移到新的定義:

復制代碼 代碼如下:

class Person(object):
    def __init__(self, fullname):
        self.fullname = fullname
    def __setstate__(self, state):
        if 'fullname' not in state:
            first = ''
            last = ''
            if 'firstname' in state:
                first = state['firstname']
                del state['firstname']
            if 'lastname' in state:
                last = state['lastname']
                del state['lastname']
            self.fullname = " ".join([first, last]).strip()
        self.__dict__.update(state)

在這個示例,我們添加了一個新的屬性 fullname ,并除去了兩個現(xiàn)有的屬性 firstname 和 lastname 。當對先前進行過 pickle 的實例執(zhí)行 unpickle 時,其先前進行過 pickle 的狀態(tài)會作為字典傳遞給 _setstate_() ,它將包括 firstname 和 lastname 屬性的值。接下來,將這兩個值組合起來,并將它們分配給新屬性 fullname 。在這個過程中,我們刪除了狀態(tài)字典中舊的屬性。更新和重新 pickle 先前進行過 pickle 的所有實例之后,現(xiàn)在可以從類定義中除去 _setstate_() 方法。

模塊的修改

在概念上,模塊的名稱或位置的改變類似于類名稱的改變,但處理方式卻完全不同。那是因為模塊的信息存儲在 pickle 中,而不是通過標準的 pickle 接口就可以修改的屬性。事實上,改變模塊信息的唯一辦法是對實際的 pickle 文件本身執(zhí)行查找和替換操作。至于如何確切地去做,這取決于具體的操作系統(tǒng)和可使用的工具。很顯然,在這種情況下,您會想備份您的文件,以免發(fā)生錯誤。但 這種改動應該非常簡單,并且對二進制 pickle 格式進行更改與對文本 pickle 格式進行更改應該一樣有效。

結(jié)束語

對象持久性依賴于底層編程語言的對象序列化能力。對于 Python 對象即意味著 pickle。Python 的 pickle 為 Python 對象有效的持久性管理提供了健壯的和可靠的基礎。在下面的 參考資料中,您將會找到有關建立在 Python pickle 能力之上的系統(tǒng)的信息。

相關文章

  • python實現(xiàn)繪制樹枝簡單示例

    python實現(xiàn)繪制樹枝簡單示例

    這篇文章主要介紹了python實現(xiàn)繪制樹枝簡單示例,有助于讀者加深對Python繪圖的認識,需要的朋友可以參考下
    2014-07-07
  • pygame游戲之旅 python和pygame安裝教程

    pygame游戲之旅 python和pygame安裝教程

    這篇文章主要為大家詳細介紹了pygame游戲之旅,分享python和pygame的安裝教程,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2018-11-11
  • Python中按鍵來獲取指定的值

    Python中按鍵來獲取指定的值

    今天小編就為大家分享一篇關于Python中按鍵來獲取指定的值,小編覺得內(nèi)容挺不錯的,現(xiàn)在分享給大家,具有很好的參考價值,需要的朋友一起跟隨小編來看看吧
    2019-03-03
  • 跟老齊學Python之模塊的加載

    跟老齊學Python之模塊的加載

    這篇文章主要介紹了跟老齊學Python之模塊的加載,需要的朋友可以參考下
    2014-10-10
  • 深入了解PyQt5中的圖形視圖框架

    深入了解PyQt5中的圖形視圖框架

    PyQt5中圖形視圖框架主要包含三個類:QGraphicsItem圖元類、QGraphicsScene場景類和QGraphicsView視圖類。本文將通過示例詳細講解一下這三個類,感興趣的可以學習一下
    2022-03-03
  • python自動化報告的輸出用例詳解

    python自動化報告的輸出用例詳解

    本文通過用例給大家介紹了python自動化報告的輸出,非常不錯,具有一定的參考借鑒價值,需要的朋友可以參考下
    2018-05-05
  • python的命名規(guī)則知識點總結(jié)

    python的命名規(guī)則知識點總結(jié)

    在本篇文章里小編給大家分享的是關于python的命名規(guī)則知識點總結(jié),有需要的朋友們可以參考下。
    2019-10-10
  • 給大家整理了19個pythonic的編程習慣(小結(jié))

    給大家整理了19個pythonic的編程習慣(小結(jié))

    這篇文章主要介紹了給大家整理了19個pythonic的編程習慣(小結(jié)),文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2019-09-09
  • python中函數(shù)默認值使用注意點詳解

    python中函數(shù)默認值使用注意點詳解

    下面小編就為大家?guī)硪黄猵ython中函數(shù)默認值使用注意點詳解。小編覺得挺不錯的,現(xiàn)在就分享給大家,也給大家做個參考。一起跟隨小編過來看看吧
    2016-06-06
  • Django ForeignKey與數(shù)據(jù)庫的FOREIGN KEY約束詳解

    Django ForeignKey與數(shù)據(jù)庫的FOREIGN KEY約束詳解

    這篇文章主要介紹了Django ForeignKey與數(shù)據(jù)庫的FOREIGN KEY約束詳解,具有很好的參考價值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2020-05-05

最新評論