2. 程式人生 > >python 面向物件（進階篇）

python 面向物件（進階篇）

阿新 • • 發佈：2018-12-17

本篇將詳細介紹Python 類的成員、成員修飾符、類的特殊成員。

類的成員

類的成員可以分為三大類：欄位、方法和屬性

注：所有成員中，只有普通欄位的內容儲存物件中，即：根據此類建立了多少物件，在記憶體中就有多少個普通欄位。而其他的成員，則都是儲存在類中，即：無論物件的多少，在記憶體中只建立一份。

一、欄位

欄位包括：普通欄位和靜態欄位，他們在定義和使用中有所區別，而最本質的區別是記憶體中儲存的位置不同，

  • 普通欄位屬於物件
  • 靜態欄位屬於類

複製程式碼

class Province:

    # 靜態欄位
    country ＝ '中國'

    def __init__(self, name):

        # 普通欄位
        self.name = name


# 直接訪問普通欄位
obj = Province('河北省')
print obj.name

# 直接訪問靜態欄位
Province.country

複製程式碼

由上述程式碼可以看出【普通欄位需要通過物件來訪問】【靜態欄位通過類訪問】，在使用上可以看出普通欄位和靜態欄位的歸屬是不同的。其在內容的儲存方式類似如下圖：

由上圖可是：

  • 靜態欄位在記憶體中只儲存一份
  • 普通欄位在每個物件中都要儲存一份

應用場景： 通過類建立物件時，如果每個物件都具有相同的欄位，那麼就使用靜態欄位

二、方法

方法包括：普通方法、靜態方法和類方法，三種方法在記憶體中都歸屬於類，區別在於呼叫方式不同。

  • 普通方法：由物件呼叫；至少一個self引數；執行普通方法時，自動將呼叫該方法的物件賦值給self；
  • 類方法：由類呼叫； 至少一個cls引數；執行類方法時，自動將呼叫該方法的類
    複製給cls；
  • 靜態方法：由類呼叫；無預設引數；

複製程式碼

class Foo:

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

    def ord_func(self):
        """ 定義普通方法，至少有一個self引數 """

        # print self.name
        print '普通方法'

    @classmethod
    def class_func(cls):
        """ 定義類方法，至少有一個cls引數 """

        print '類方法'

    @staticmethod
    def static_func():
        """ 定義靜態方法 ，無預設引數"""

        print '靜態方法'


# 呼叫普通方法
f = Foo()
f.ord_func()

# 呼叫類方法
Foo.class_func()

# 呼叫靜態方法
Foo.static_func()

複製程式碼

相同點：對於所有的方法而言，均屬於類（非物件）中，所以，在記憶體中也只儲存一份。

不同點：方法呼叫者不同、呼叫方法時自動傳入的引數不同。

三、屬性　　

如果你已經瞭解Python類中的方法，那麼屬性就非常簡單了，因為Python中的屬性其實是普通方法的變種。

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

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

1、屬性的基本使用

複製程式碼

# ############### 定義 ###############
class Foo:

    def func(self):
        pass

    # 定義屬性
    @property
    def prop(self):
        pass
# ############### 呼叫 ###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop   #呼叫屬性

複製程式碼

由屬性的定義和呼叫要注意一下幾點：

  • 定義時，在普通方法的基礎上新增 @property 裝飾器；
  • 定義時，屬性僅有一個self引數
  • 呼叫時，無需括號            方法：foo_obj.func()            屬性：foo_obj.prop

注意：屬性存在意義是：訪問屬性時可以製造出和訪問欄位完全相同的假象

        屬性由方法變種而來，如果Python中沒有屬性，方法完全可以代替其功能。

例項：對於主機列表頁面，每次請求不可能把資料庫中的所有內容都顯示到頁面上，而是通過分頁的功能區域性顯示，所以在向資料庫中請求資料時就要顯示的指定獲取從第m條到第n條的所有資料（即：limit m,n），這個分頁的功能包括：

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

複製程式碼

# ############### 定義 ###############
class Pager:
    
    def __init__(self, current_page):
        # 使用者當前請求的頁碼（第一頁、第二頁...）
        self.current_page = current_page
        # 每頁預設顯示10條資料
        self.per_items = 10 


    @property
    def start(self):
        val = (self.current_page - 1) * self.per_items
        return val

    @property
    def end(self):
        val = self.current_page * self.per_items
        return val

# ############### 呼叫 ###############

p = Pager(1)
p.start 就是起始值，即：m
p.end   就是結束值，即：n

複製程式碼

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

2、屬性的兩種定義方式

屬性的定義有兩種方式：

  • 裝飾器 即：在方法上應用裝飾器
  • 靜態欄位 即：在類中定義值為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__ ，此引數是該屬性的描述資訊

複製程式碼

class Foo：

    def get_bar(self):
        return 'wupeiqi'

    # *必須兩個引數
    def set_bar(self, value): 
        return return 'set value' + value

    def del_bar(self):
        return 'wupeiqi'

    BAR ＝ property(get_bar, set_bar, del_bar, 'description...')

obj = Foo()

obj.BAR              # 自動呼叫第一個引數中定義的方法：get_bar
obj.BAR = "alex"     # 自動呼叫第二個引數中定義的方法：set_bar方法，並將“alex”當作引數傳入
del Foo.BAR          # 自動呼叫第三個引數中定義的方法：del_bar方法
obj.BAE.__doc__      # 自動獲取第四個引數中設定的值：description...

複製程式碼

 由於靜態欄位方式建立屬性具有三種訪問方式，我們可以根據他們幾個屬性的訪問特點，分別將三個方法定義為對同一個屬性：獲取、修改、刪除

複製程式碼

class Goods(object):

    def __init__(self):
        # 原價
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    def get_price(self):
        # 實際價格 = 原價 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    def set_price(self, value):
        self.original_price = value

    def del_price(self, value):
        del self.original_price

    PRICE = property(get_price, set_price, del_price, '價格屬性描述...')

obj = Goods()
obj.PRICE         # 獲取商品價格
obj.PRICE = 200   # 修改商品原價
del obj.PRICE     # 刪除商品原價

複製程式碼

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

複製程式碼

class WSGIRequest(http.HttpRequest):
    def __init__(self, environ):
        script_name = get_script_name(environ)
        path_info = get_path_info(environ)
        if not path_info:
            # Sometimes PATH_INFO exists, but is empty (e.g. accessing
            # the SCRIPT_NAME URL without a trailing slash). We really need to
            # operate as if they'd requested '/'. Not amazingly nice to force
            # the path like this, but should be harmless.
            path_info = '/'
        self.environ = environ
        self.path_info = path_info
        self.path = '%s/%s' % (script_name.rstrip('/'), path_info.lstrip('/'))
        self.META = environ
        self.META['PATH_INFO'] = path_info
        self.META['SCRIPT_NAME'] = script_name
        self.method = environ['REQUEST_METHOD'].upper()
        _, content_params = cgi.parse_header(environ.get('CONTENT_TYPE', ''))
        if 'charset' in content_params:
            try:
                codecs.lookup(content_params['charset'])
            except LookupError:
                pass
            else:
                self.encoding = content_params['charset']
        self._post_parse_error = False
        try:
            content_length = int(environ.get('CONTENT_LENGTH'))
        except (ValueError, TypeError):
            content_length = 0
        self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
        self._read_started = False
        self.resolver_match = None

    def _get_scheme(self):
        return self.environ.get('wsgi.url_scheme')

    def _get_request(self):
        warnings.warn('`request.REQUEST` is deprecated, use `request.GET` or '
                      '`request.POST` instead.', RemovedInDjango19Warning, 2)
        if not hasattr(self, '_request'):
            self._request = datastructures.MergeDict(self.POST, self.GET)
        return self._request

    @cached_property
    def GET(self):
        # The WSGI spec says 'QUERY_STRING' may be absent.
        raw_query_string = get_bytes_from_wsgi(self.environ, 'QUERY_STRING', '')
        return http.QueryDict(raw_query_string, encoding=self._encoding)
    
    # ############### 看這裡看這裡  ###############
    def _get_post(self):
        if not hasattr(self, '_post'):
            self._load_post_and_files()
        return self._post

    # ############### 看這裡看這裡  ###############
    def _set_post(self, post):
        self._post = post

    @cached_property
    def COOKIES(self):
        raw_cookie = get_str_from_wsgi(self.environ, 'HTTP_COOKIE', '')
        return http.parse_cookie(raw_cookie)

    def _get_files(self):
        if not hasattr(self, '_files'):
            self._load_post_and_files()
        return self._files

    # ############### 看這裡看這裡  ###############
    POST = property(_get_post, _set_post)
    
    FILES = property(_get_files)
    REQUEST = property(_get_request)

複製程式碼

所以，定義屬性共有兩種方式，分別是【裝飾器】和【靜態欄位】，而【裝飾器】方式針對經典類和新式類又有所不同。

類成員的修飾符

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

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

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

1

2

3

4

5

class C:

def __init__(self):

self.name = '公有欄位'

self.__foo = "私有欄位"

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

靜態欄位

  • 公有靜態欄位：類可以訪問；類內部可以訪問；派生類中可以訪問
  • 私有靜態欄位：僅類內部可以訪問；

複製程式碼

class C:

    name = "公有靜態欄位"

    def func(self):
        print C.name

class D(C):

    def show(self):
        print C.name


C.name         # 類訪問

obj = C()
obj.func()     # 類內部可以訪問

obj_son = D()
obj_son.show() # 派生類中可以訪問

複製程式碼

複製程式碼

class C:

    __name = "公有靜態欄位"

    def func(self):
        print C.__name

class D(C):

    def show(self):
        print C.__name


C.__name       # 類訪問            ==> 錯誤

obj = C()
obj.func()     # 類內部可以訪問     ==> 正確

obj_son = D()
obj_son.show() # 派生類中可以訪問   ==> 錯誤

複製程式碼

普通欄位

  • 公有普通欄位：物件可以訪問；類內部可以訪問；派生類中可以訪問
  • 私有普通欄位：僅類內部可以訪問；

ps：如果想要強制訪問私有欄位，可以通過 【物件._類名__私有欄位明 】訪問（如：obj._C__foo），不建議強制訪問私有成員。

複製程式碼

class C:
    
    def __init__(self):
        self.foo = "公有欄位"

    def func(self):
        print self.foo 　#　類內部訪問

class D(C):
    
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.foo     # 通過物件訪問
obj.func()  # 類內部訪問

obj_son = D();
obj_son.show()  # 派生類中訪問

複製程式碼

複製程式碼

class C:
    
    def __init__(self):
        self.__foo = "私有欄位"

    def func(self):
        print self.foo 　#　類內部訪問

class D(C):
    
    def show(self):
        print self.foo　＃　派生類中訪問

obj = C()

obj.__foo     # 通過物件訪問    ==> 錯誤
obj.func()  # 類內部訪問        ==> 正確

obj_son = D();
obj_son.show()  # 派生類中訪問  ==> 錯誤

複製程式碼

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

ps：非要訪問私有屬性的話，可以通過 物件._類__屬性名

類的特殊成員

上文介紹了Python的類成員以及成員修飾符，從而瞭解到類中有欄位、方法和屬性三大類成員，並且成員名前如果有兩個下劃線，則表示該成員是私有成員，私有成員只能由類內部呼叫。無論人或事物往往都有不按套路出牌的情況，Python的類成員也是如此，存在著一些具有特殊含義的成員，詳情如下：

1. __doc__

　　表示類的描述資訊

複製程式碼

class Foo:
    """ 描述類資訊，這是用於看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#輸出：類的描述資訊

複製程式碼

2. __module__ 和  __class__ 

　　__module__ 表示當前操作的物件在那個模組

　　__class__     表示當前操作的物件的類是什麼

複製程式碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class C:

    def __init__(self):
        self.name = 'wupeiqi'

複製程式碼

from lib.aa import C

obj = C()
print obj.__module__  # 輸出 lib.aa，即：輸出模組
print obj.__class__      # 輸出 lib.aa.C，即：輸出類

3. __init__

　　構造方法，通過類建立物件時，自動觸發執行。

複製程式碼

class Foo:

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


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

複製程式碼

4. __del__

　　析構方法，當物件在記憶體中被釋放時，自動觸發執行。

注：此方法一般無須定義，因為Python是一門高階語言，程式設計師在使用時無需關心記憶體的分配和釋放，因為此工作都是交給Python直譯器來執行，所以，解構函式的呼叫是由直譯器在進行垃圾回收時自動觸發執行的。

class Foo:

    def __del__(self):
        pass

5. __call__

　　物件後面加括號，觸發執行。

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

複製程式碼

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print '__call__'


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

複製程式碼

6. __dict__

　　類或物件中的所有成員

上文中我們知道：類的普通欄位屬於物件；類中的靜態欄位和方法等屬於類，即：

複製程式碼

class Province:

    country = 'China'

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

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

# 獲取類的成員，即：靜態欄位、方法、
print Province.__dict__
# 輸出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print obj1.__dict__
# 獲取 物件obj1 的成員
# 輸出：{'count': 10000, 'name': 'HeBei'}

obj2 = Province('HeNan', 3888)
print obj2.__dict__
# 獲取 物件obj1 的成員
# 輸出：{'count': 3888, 'name': 'HeNan'}

複製程式碼

 7. __str__

　　如果一個類中定義了__str__方法，那麼在列印 物件 時，預設輸出該方法的返回值。

複製程式碼

class Foo:

    def __str__(self):
        return 'wupeiqi'


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

複製程式碼

8、__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__

9、__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__ 

複製程式碼

class Foo(object):
    pass


obj = Foo()

for i in obj:
    print i
    
# 報錯：TypeError: 'Foo' object is not iterable

複製程式碼

複製程式碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):
    
    def __iter__(self):
        pass

obj = Foo()

for i in obj:
    print i

# 報錯：TypeError: iter() returned non-iterator of type 'NoneType'

複製程式碼

複製程式碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):

    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:
    print i

複製程式碼

以上步驟可以看出，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

複製程式碼

#!/usr/bin/env python
# -*- coding:utf-8 -*-

obj = iter([11,22,33,44])

while True:
    val = obj.next()
    print val

複製程式碼

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()

以上就是面向物件進階篇的所有內容，歡迎拍磚... 

相關推薦

python 面向物件（進階篇）

本篇將詳細介紹Python 類的成員、成員修飾符、類的特殊成員。 類的成員 類的成員可以分為三大類：欄位、方法和屬性 注：所有成員中，只有普通欄位的內容儲存物件中，即：根據此類建立了多少物件，在記憶體中就有多少個普通欄位。而其他的成員，則都是儲存在類中，即：無論物件

Python開發【第七篇】：面向物件（進階篇）

上一篇《Python 面向物件（初級篇）》文章介紹了面向物件基本知識： 面向物件是一種程式設計方式，此程式設計方式的實現是基於對 類 和 物件 的使用 類 是一個模板，模板中包裝了多個“函式”供使用（可以講多函式中公用的變數封裝到物件中） 物件，根據模板

Python sys模組（進階篇）

本文針對原文做了少量修改和大量的補充。。。 這篇文章主要介紹了Python標準庫之sys模組使用詳解,講解了使用sys模組獲得指令碼的引數、處理模組、 使用sys模組操作 模組搜尋路徑、使用sys模組查詢內建模組、使用sys模組查詢已匯入的模組，重定向輸出以及重定向錯誤等

Python進階---面向對象第三彈（進階篇）

python對象 one iss pri each super left connect ext 　Python對象中一些方法 一、__str__ class Teacher: def __init__(self,name,age): self.name

python 面向對象（進階篇）

關心 __iter__ nvi class nic 詳情 mit remove 類名 類的成員 類的成員可以分為三大類：字段、方法和屬性 註：所有成員中，只有普通字段的內容保存對象中，即：根據此類創建了多少對象，在內存中就有多少個普通字段。而其他的成員，則都是保存在類中，

零基礎掌握百度地圖興趣點獲取POI爬蟲（python語言爬取）（進階篇）

好，現在進入進階篇教程。 1.獲取昆明市的bounds值 看到下面這個東西了吧？在文字框裡寫入昆明市，或者其他的行政區劃地名，北京市、朝陽區、大河溝子村什麼的。 這也是通過呼叫百度地圖開放平臺API實現的。 實現起來很簡單，把下面這段程式碼複製到一個

Mysql 入門，增刪改查（進階篇）

bsp com pre sco height name 數據 mysql from 主要已以下兩個表students與students_score，進行數據的增刪改查操作！ 1、SELECT 1）select id,tel from students

freenas的CIFS/SMB的使用（進階篇）

img 大小 ifs 退出 freenas 什麽 數據 用戶名 鏡像 這裏是對freenas的進一步使用，關於freenas的介紹與安裝請查看上一篇隨筆：http://www.cnblogs.com/hjc4025/p/7079364.html 我們先來看一下如何使用fre

編碼原則實例------c++程序設計原理與實踐（進階篇）

組類型 運算 奇怪 head 不能 gui 簡單的 版本 布局 編碼原則： 一般原則 預處理原則 命名和布局原則 類原則 函數和表達式原則 硬實時原則 關鍵系統原則 （硬實時原則、關鍵系統原則僅用於硬實時和關鍵系統程序設計） （嚴格原則都用一個大寫字母R及其編號標識，而

有符號數和無符號數------c++程序設計原理與實踐（進階篇）

效果 進階 str 二進制位 bsp () 都是 有符號 重新 有符號數與無符號數的程序設計原則： 當需要表示數值時，使用有符號數（如 int）。 當需要表示位集合時，使用無符號數（如unsigned int）。 有符號數和無符號數混合運算有可能會帶來災難性的後果。例如

動態內存分配存在的問題（內存空洞）------c++程序設計原理與實踐（進階篇）

我們 程序 動態 height ++ idt 很多 alt 空間 new的問題究竟在哪裏呢？實際上問題出在new和delete的結合使用上。考察下面程序中內存分配和釋放過程： while(1){ Big* p=new big;　　//...... Smal

數值限制------c++程序設計原理與實踐（進階篇）

c++程序 its positive size true 設置 malle 設計原理 硬件 每種c++的實現都在<limits>、<climits>、<limits.h>和<float.h>中指明了內置類型的屬性，因此程序

實現求解線性方程（矩陣、高斯消去法）------c++程序設計原理與實踐（進階篇）

ipy 類型 cat sys sca solution gaussian 拷貝 img 步驟： 其中A是一個n*n的系數方陣 向量x和b分別是未知數和常量向量： 這個系統可能有0個、1個或者無窮多個解，這取決於系數矩陣A和向量b。求解線性系統的方法有很多，這裏使用一種經典

（c++11）隨機數------c++程序設計原理與實踐（進階篇）

ber linear 而在 希望 double 元素 light eal 區間 　　隨機數既是一個實用工具，也是一個數學問題，它高度復雜，這與它在現實世界中的重要性是相匹配的。在此我們只討論隨機數哦最基本的內容，這些內容可用於簡單的測試和仿真。在<random>

python 面向對象(進階篇)

property 命名 int col code call ssm 有一種 信息 類的成員 字段 普通字段 保存在對象當中,執行只能通過對象訪問 靜態字段 保存在類當中, 執行可以通過類訪問也可以通過對象訪問 方法 普通方法 保存在類當中,由對象來調用 靜態

iOS開發者如何在枯燥的工作中尋求技術的提升（進階篇）

調用 loaded 剛才 高可用 package 如果 sql 讀寫 大牛 技術成長是很多同學面臨的問題，一些工作了幾年的同學會遇到成長瓶頸，覺得自己進步緩慢，無論是公司業務的原因還是個人原因，覺得自己的技術水平得不到成長了。或者一些剛工作沒多久的同學和在找工作的同學，都想

【原創】python學習筆記（進階1）-- 自學，爬蟲備註--先佔坑

  Request：使用者將自己的資訊通過瀏覽器（socket client）傳送給伺服器（socket server） Response：伺服器接收請求，分析使用者發來的請求資訊，然後返回資料（返回的資料中可能包含其他連結，如：圖片，js，css等） ps：瀏覽器在接收Res

spring Security4 和 oauth2整合 註解+xml混合使用（進階篇）

Spring Security4 和 oauth2整合使用者密碼授權模式 上篇已經可以正常運行了，不過拿來測試還不夠，下面介紹如何測試oauth2的使用者密碼模式，授權碼模式下一篇說。 不想看這些亂七八糟的，可以直接把程式碼拉下來。 git地址：https://gitee.com/x

HenCoder Android 自定義 View 1-7：屬性動畫 Property Animation（進階篇）

這期是 HenCoder 自定義繪製的第 1-7 期：屬性動畫（進階篇） 簡介 上期的內容，對於大多數簡單的屬性動畫場景已經夠用了。這期的內容主要針對兩個方面： 針對特殊型別的屬性來做屬性動畫； 針對複雜的屬性關係來做屬性動畫。 TypeEvaluator

無業務不伸縮之二，雲監控搭配SLB及ESS（進階篇）

雲端計算ESS彈性伸縮課程 無業務不伸縮之二，雲監控搭配SLB及ESS（進階篇） 連載雲端計算文章主題 後續的連載如下1、 無業務不伸縮之一，雲端計算有ESS2、 無業務不伸縮之二，雲監控搭配SLB及ESS3、無互動不加速，雲端計算有CDN4、無對像不儲存，雲端計算有OSS5、無檔案不儲存，雲端計算有”