修改、查看私有屬性、名字重整

如下，Test類定義 一個私有屬性 __name? 實例化一個對象 a ，無法調用該屬性，

打印 a.__dict__（ 可以檢查一個對象的所有屬性 ）查看?，發現__name存在并且名字變為? _Test__name （無法調用的原因，名字被改變）

改變規則：私有屬性前添加類名，再在類名前添加一個下劃線 （ 名字重整 ）

我們驗證一下，打印修改后的屬性，如下

?

這里有個疑問，既然無法直接打印，那我們為什么可以直接修改？

修改測試一下，打印輸出，此時__name 并不是私有屬性了，此時的 __name 只是添加了一個屬性，可以直接調用

這里就沒有什么私有公有之說了，所謂的公有私有，是指類中的屬性，實例對象無法直接調用

? ? ? ? ? ? ?

另外補充一下 __dict__屬性，Test類也是一個對象，查看其屬性：每個魔法屬性對應值或函數

?

?

魔法屬性、方法

無論人或事物往往都有不按套路出牌的情況，Python的類屬性也是如此。存在一些具有特殊含義的屬性

如上圖，對應的魔法屬性：

?

1. __doc__ ：表示類的描述信息，help()方法也可以輸出類的描述信息

            
              class Test():
    """
    This is a description of a class
    """
    pass


print(Test.__doc__)
print("*" * 15)
print(help(Test))
            
          

?

2. __module__? 和 __class__ ：__module__表示當前操作在哪個模塊，__class__表示當前操作的對象的類是什么

            
              # -*- coding:utf-8 -*-


# test.py
class Person(object):
    def __init__(self):
        self.name = 'laowang'
            
          

            
              

from test import Person


# main.py
obj = Person()
print(obj.__module__)  # 輸出創建該對象的對應模塊  test
print(obj.__class__)  # 輸出創建該對象的對應模塊中的類    test.Person
            
          

?

3. __init__ ：初始化方法（不建議稱其為構造方法，可以說__init__ 和 __new__ 方法一起完成了構造方法的功能），通過類創建對象時，自動觸發執行

            
              class Person:
    def __init__(self, name):
        self.name = name
        self.age = 18


obj = Person('laowang')  # 自動執行類中的 __init__ 方法

            
          

?

4. __del__：當對象在內存中被釋放時，自動觸發執行

注：此方法無需定義，因為python是一門高級語言，程序員在使用時，無需關系內存的分配和釋放，因為此工作都是交給Python的解釋器來執行，所以，__del__的調用是有解釋器在進行垃圾回收時自動觸發執行的。

            
              class Foo:
    def __del__(self):
        pass
            
          

?

5. __call__：對象后面加括號，觸發執行? （用于裝飾器）

注：__init__方法的執行是由創建對象觸發的，即 對象 = 類名() ; 而對于__call__ 方法執行是由對象后加括號觸發的，即

對象()? 或 類()

            
              class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 執行 __init__
obj()  # 執行 __call__
            
          

?

6. __dict__ ：?類或對象中的所有屬性? ? ? ? ?

類的實例屬性屬于對象；類中的類屬性和方法等屬于類，即：

            
              class Province(object):
    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func')

# 獲取類的屬性，即：類屬性、方法、
print(Province.__dict__)
# 輸出：{'__dict__': 
              
                , '__module__': '__main__', 'country': 'China', '__doc__': None, '__weakref__': 
                
                  , 'func': 
                  
                    , '__init__': 
                    
                      }

obj1 = Province('山東', 10000)
print(obj1.__dict__)
# 獲取 對象obj1 的屬性
# 輸出：{'count': 10000, 'name': '山東'}

obj2 = Province('山西', 20000)
print(obj2.__dict__)
# 獲取 對象obj1 的屬性
# 輸出：{'count': 20000, 'name': '山西'}
                    
                  
                
              
            
          

?

7.?__str__：如果一個類中定義了__str__方法，那么在打印 對象 時，默認輸出該方法的返回值

            
              class Foo:
    def __str__(self):
        return 'laowang'


obj = Foo()
print(obj)
# 輸出：laowang
            
          

?

8.?__getitem__、__setitem__、__delitem__ ：用于索引操作，如字典。以上分別表示獲取、設置、刪除數據

            
              # -*- 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'] = 'laowang'   # 自動觸發執行 __setitem__
del obj['k1']           # 自動觸發執行 __delitem__
            
          

9.?__getitem__、__setitem__、__delitem__ ：該三個方法用于分片操作，如：列表

            
              # -*- 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__
            
          

?

?

With、上下文管理器

對于系統資源如文件、數據庫連接、socket 而言，應用程序打開這些資源并執行完業務邏輯之后，必須做的一件事就是要關閉（斷開）該資源。

比如 Python 程序打開一個文件，往文件中寫內容，寫完之后，就要關閉該文件，否則會出現什么情況呢？極端情況下會出現 "Too many open files" 的錯誤，因為系統允許你打開的最大文件數量是有限的。

同樣，對于數據庫，如果連接數過多而沒有及時關閉的話，就可能會出現 "Can not connect to MySQL server Too many connections"，因為數據庫連接是一種非常昂貴的資源，不可能無限制的被創建。

普通版：

            
              def m1():
    f = open("output.txt", "w")
    f.write("python之禪")
    f.close()
            
          

這樣寫有一個潛在的問題，如果在調用 write 的過程中，出現了異常進而導致后續代碼無法繼續執行，close 方法無法被正常調用，因此資源就會一直被該程序占用者釋放。

?

進階版：

            
              def m2():
    f = open("output.txt", "w")
    try:                      
        f.write("python之禪")
    except IOError:            # except 未捕獲到對應異常，依然會崩
        print("oops error")
    finally:
        f.close()
            
          

改良版本的程序是對可能發生異常的代碼處進行 try 捕獲，使用 try/finally 語句，該語句表示如果在 try 代碼塊中程序出現了異常，后續代碼就不再執行，而直接跳轉到 except 代碼塊。而無論如何，finally 塊的代碼最終都會被執行。因此，只要把 close 放在 finally 代碼中，文件就一定會關閉。

?

高級版：

            
              def m3():
    with open("output.txt", "r") as f:
        f.write("Python之禪")
            
          

一種更加簡潔、優雅的方式就是用 with 關鍵字。 open 方法的返回值賦值給變量 f，當離開 with 代碼塊的時候，系統會自動調用 f.close() 方法， with 的作用和使用 try/finally 語句是一樣的。那么它的實現原理是什么？在講 with 的原理前要涉及到另外一個概念，就是 上下文管理器（Context Manager） 。

?

上下文(context)

上下文在不同的地方表示不同的含義，要感性理解。context其實說白了，和文章的上下文是一個意思，通俗一點，理解為環境

?

上下文管理器

任何實現了 __enter__() 和 __exit__() 方法的對象都可稱之為上下文管理器 ，上下文管理器對象可以使用 with 關鍵字。顯然，文件（file）對象也實現了上下文管理器。

那么文件對象是如何實現這兩個方法的呢？我們可以模擬實現一個自己的文件類，讓該類實現 __enter__() 和 __exit__() 方法。

            
              class File():

    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        print("entering")
        self.f = open(self.filename, self.mode)
        return self.f

    def __exit__(self, *args):
        print("will exit")
        self.f.close()
            
          

__enter__() 方法返回資源對象，這里就是你將要打開的那個文件對象，__exit__() 方法處理一些清除工作。

因為 File 類實現了上下文管理器，現在就可以使用 with 語句了。

            
              with File('out.txt', 'w') as f: 
# 實例化File對象，執行__init__方法，filename屬性對應out.txt，w對應mode屬性
# with判斷其是否是一個上下文管理器(實現對應的方法)，然后自動調用 __enter__()方法 
# __enter__()方法返回值是什么，對應的 f 就是什么，而當結束或者出現異常時，會自動調用 __exit__()
# 方法
    print("writing")
    f.write('hello, python')
            
          

這樣，你就無需顯示地調用 close 方法了，由系統自動去調用，哪怕中間遇到異常 close 方法也會被調用。

?

實現上下文管理器的另外方式（了解）

Python 還提供了一個 contextmanager 的裝飾器，更進一步簡化了上下文管理器的實現方式。通過 yield 將函數分割成兩部分，yield 之前的語句在 __enter__ 方法中執行，yield 之后的語句在 __exit__ 方法中執行。緊跟在 yield 后面的值是函數的返回值。

            
              from contextlib import contextmanager

@contextmanager
def my_open(path, mode):
    f = open(path, mode)
    yield f
    f.close()
調用

with my_open('out.txt', 'w') as f:
    f.write("hello , the simplest context manager")
            
          

?

?

總結

Python 提供了? with 語法用于簡化資源操作的后續清除操作，是 try/finally 的替代方法，實現原理建立在上下文管理器之上。 此外，Python 還提供了一個 contextmanager 裝飾器，更進一步簡化上下管理器的實現方式。

?

?

?

?