文章出處

Python第九天面向對象類定義類的屬性類的方法內部類垃圾回收機制類的繼承裝飾器

面向對象

類和對象
Python類定義
類屬性
類方法

面向過程和面向對象編程
- 面向過程編程：函數式編程，C程序等
- 面向對象編程：C++,Java,Python等

str. ->顯示字符串的方法，屬性
list. ->顯示列表的方法，屬性
tuple. ->顯示元組的方法，屬性
dict. ->顯示字典的方法，屬性

面向對象的主要思想是：
- 封裝
- 繼承
- 多態
這種思想方便解決較為復雜的項目，且維護起來較為容易。

-----------------------------------------

Python類定義
類定義：
類把需要的變量和函數組合成一起，這種包含稱為“封裝”
class A(object): 繼承object這個類，跟C#一樣，object是根對象
類的結構：
class 類名:
成員變量 – 屬性
成員函數 – 方法

類名：每個單詞首字母大寫
函數名：第二個單詞開始首字母大寫

class MyClass(object):
def fun(self):
print "I am function"
類的方法中至少有一個參數self，self表示類本身

定義類有2種方法
一種是不加(object) class A():
一種是加(object) class A(object):
前者是傳統的定義方法，后者是新的風格，建議使用后者，super這個內置函數只支持新風格定義的類，如果父類是舊風格定義的類，那么使用super來繼承的時候就會報錯。

報錯：typeerror：super（） argument 1 must be type，not classobj

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string





class People(object):
    color = 'yellow'
    __age = 30

def think(self):
    self.color = "black"
    print "I am a %s" % self.color
    print "I am a " + self.color
    print "I am a thinker"
    print self.__age



ren = People()
ren.color = '白色人'
print ren.color
ren.think()
print ren.__dict__
print '#' *30
print People.color
print '#' *30
print People.__dict__

-----------------------------------------

對象的創建
創建對象的過程稱之為實例化；當一個對象被創建后，包含三個方面的特性：對象句柄、屬性和方法。
句柄用于區分不同的對象
對象的屬性和方法與類中的成員變量和成員函數對應
obj = MyClass() //創建類的一個實例(對象)
通過對象來調用方法和屬性

-----------------------------------------

類的屬性
類的屬性按使用范圍分為公有屬性和私有屬性，類的屬性范圍取決于屬性的名稱。
- 公有屬性：在類中和類外都能調用的屬性。
公有屬性可以不用實例化對象就可以訪問，classname.attribute，類名.屬性名 print People.color

class People(object):
    color = 'yellow'
    def __init__(self):
        self.dwell = 'Earth'
        print  self.dwell   #公有屬性





pp=People()
print  pp.dwell

- 私有屬性：不能在類外及被類以外的函數調用。定義方式：以”__”雙下劃線開始的成員變量就是私有屬性，可以通過instance._classname__attribute方式訪問，print ren._People__age
實例化對象名._類名__私有屬性名（實際不建議使用實例化對象名._類名__私有屬性名）

- 內置屬性：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__dict__, __module__。
__dict__：打印出類的屬性和方法
實例化對象.__dict__ :只能看到公有屬性
類名.__dict__ ：可以看到私有屬性（實例化對象名._類名__私有屬性名），公有屬性，私有方法，公有方法，靜態方法等等

靜態屬性和動態屬性
實例化對象之后調用的屬性是動態屬性，可以修改屬性值
ren = People()
ren.color = '白色人'
print ren.color
沒有實例化對象用類名直接調用的屬性是靜態屬性，不能修改
print People.color

-----------------------------------------

類的方法

方法的定義和函數一樣，但是需要self作為第一個參數。
類方法為：
- 公有方法
- 私有方法
- 類方法
- 靜態方法
- 內置方法

公有方法：在類中和類外都能調用的方法。
私有方法：不能被類的外部調用，在方法前面加上”__”雙下劃線就是私有方法。
self參數：用于區分函數和類的方法(必須有一個self)，self參數表示執行對象本身。
內置方法：由系統在定義類的時候默認添加的，由前后雙下劃線構成，__str__(self)， __init__(self)

類方法：被classmethod()函數處理過的函數，能被類名所調用，也能被對象所調用(是繼承的關系)
classmethod(函數名)
classmethod(test) test是一個方法

def test(self):
print self.color

cm = classmethod(test)
People.cm()

靜態方法：相當于”全局函數”，可以被類名直接調用，也可以用對象調用，可以被所有實例化對象共享，通過staticmethod()定義，靜態方法沒有”self”參數。

def test():
print People.color 訪問類里面屬性

sm = staticmethod(test)
People.sm()

裝飾器：
- @classmethod
- @staticmethod

靜態方法和動態方法
實例化對象之后調用的方法是動態方法，有一個例外，類方法classmethod(函數名)是動態方法，可以訪問實例里的屬性
沒有實例化對象staticmethod() 直接調用的方法是靜態方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#__author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""
class MyClass(object):
    name='test'

    def __init__(self):  #構造函數
        self.func1()
        self.__func2()
        self.classFun()
        self.staticFun()


    def func1(self):
        print self.name,
        print '我是公有方法'

    def __func2(self):
        print self.name,
        print '我是私有方法'

    @classmethod
    def classFun(self):
        print self.name,
        print '我是類方法'

    @staticmethod
    def staticFun():
        print MyClass.name,
        print '我是靜態方法'

mc=MyClass()
MyClass.staticFun()
mc.staticFun()  #類方法和靜態方法既可以實例對象調用又可以類名調用
mc.classFun()
MyClass.classFun()




test 我是公有方法
test 我是私有方法
test 我是類方法
test 我是靜態方法
test 我是靜態方法
test 我是靜態方法
test 我是類方法
test 我是類方法

-----------------------------------------
Python內部類
在類的內部定義的類，主要目的是為了更好的抽象現實世界

內部類的實例化方法
方法1：直接使用外部類調用內部類
object_name = outclass_name.inclass_name()
方法2：先對外部類進行實例化，然后再實例化內部類
out_name = outclass_name()
in_name = out_name.inclass_name()
in_name.method()

--------------------------------------------------------

魔術方法/類內置方法
跟內置屬性一樣，類也有內置方法
__str__(self) ：print 實例對象的時候會自動執行__str__(self)方法，并且__str__(self) 只能用return不能用print

class People(object):
    color = 'yellow'
    __age = 30


    def __str__(self):
        return  'nihao'

    def think(self):
            self.color = "black"
            print "I am a %s" % self.color
            print "I am a " + self.color
            print "I am a thinker"
            print self.__age


ren = People()
ren.color = '白色人'
print ren.color
print  ren

構造函數與析構函數
- 構造函數：
用于初始化類的內部狀態，Python提供的構造函數是__init__()；
__init__()方法是可選的，如果不提供，Python會給出一個默認的__init__方法
初始化傳參

- 析構函數：
用于釋放對象占用的資源，Python提供的析構函數是__del__();
__del__()也是可選的，如果不提供，則Python會在后臺提供默認析構函數

    def __init__(self):
        self.color='aaa'

    def __del__(self):
        self.color='bbb'

-----------------------------------------

垃圾回收機制
Python采用垃圾回收機制來清理不再使用的對象；python提供gc模塊釋放不再使用的對象。
Python采用”引用計數”的算法方式來處理回收，即：當某個對象在其作用域內不再被其他對象引用的時候，python就自動清除對象；
gc模塊的collect()函數可以一次性收集所有待處理的對象(gc.collect)

即使不調用析構函數釋放資源也無所謂def __del__(self): ，python會利用垃圾回收機制回收垃圾

import gc
print gc.collect()

示例腳本

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc


class People(object):
    color = 'yellow'
    __age = 30

class Chinese(object):
    name = "I am chinese"

    def __str__(self):
        return "This is People class"

    def __init__(self, c='white'):
        print "Init..."
        self.color = c
        self.think()
        self.fd = open('/etc/hosts')

    def think(self):
        self.color = "black"
        print "I am a %s" % self.color
        print "I am a thinker"
        print self.__age


    def __talk(self):
        print "I am talking with Tom"

    @classmethod
    def test(self):
        print "this is class method"

    @staticmethod
    def test1():
        print "this is static method"

    def __del__(self):
        print "Del..."
        self.fd.close()

print gc.collect()
jack = People()
print jack.color
print People.color
print 'Main end'
print gc.collect()

-----------------------------------------

類的繼承
繼承是面向對象的重要特性之一；
繼承關系：繼承是相對兩個類而言的父子關系，子類繼承了父類的所有公有屬性和方法
繼承實現了代碼重用。

繼承可以重用已經存在的數據和行為，減少代碼的重復編寫。
Python在類名后使用一對括號來表示繼承關系，括號中的類即為父類。
class Myclass(ParentClass)
如果父類定義了__init__方法，子類可以調用父類的__init__方法也可以不調用：
ParentClass.__init__(self, [args…])
如果子類需要擴展父類的行為，可以添加__init__方法的參數。

示例1

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc





class A:
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        A.__init__(self)
    print "leave B"

b = B()
# 輸出：
# enter B
# enter A
# leave A
# leave B


class A:
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        #A.__init__(self)
    print "leave B"

b = B()
# 輸出：
# enter B
# leave B


class A:
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
   print 'ccc'

b = B()
# 輸出：
# ccc
# enter A
# leave A

示例2

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc



class People(object):
    color = 'yellow'

    def __init__(self, c):
        print "Init..."
        self.color = c
        print "I am a %s" % self.color

    def think(self):
        print "I am a %s" % self.color

    print "I am a thinker"  只要實例化就會執行這個print，因為他不在任何方法里


class Chinese(People):
    def __init__(self):
        # super(Chinese, self).__init__('red')
        People.__init__(self, 'red')

    def think(self):
        print "I like talking"


cn = Chinese()
cn.think()


輸出
I am a thinker
Init...
I am a red
I like talking

super函數

super(子類類名, self).__init__('red') 父類的init函數

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc


class A(object):
    def __init__(self, c):
        print "enter A"
        print c


    print "leave A"


class B(A):
    def __init__(self):
        print "enter B"
        super(B, self).__init__('red')
    print "leave B"

b = B()

輸出
leave A
leave B
enter B
enter A
red

多重繼承

object-》類A-》類B
Python支持多重繼承，即一個類可以繼承多個父類，可以使用父類的所有方法和屬性；
語法：
class class_name(Parent_c1, Parent_c2,…)
注意：
當父類中出現多個自定義的__init__方法時，多重繼承只執行第一個類的__init__方法，其他不執行。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc



class People(object):
    color = 'yellow'

    def __init__(self):
        self.dwell = 'Earth'
        self.color = 'yellow'
        print self.dwell
        print self.color

    def think(self):
        print "I am a %s" % self.color
        print "My home is %s" % self.dwell


class Martian(object):
    color = 'red'

    def __init__(self):
        self.dwell = 'Martian'
        print self.dwell

    def talk(self):
       print "I like talking"


class Chinese(Martian, People):
    def __init__(self):
        People.__init__(self)


cn = Chinese()
cn.think()
cn.talk()
print cn.__dict__


輸出
Earth
yellow
I am a yellow
My home is Earth
I like talking
{'color': 'yellow', 'dwell': 'Earth'}

-----------------------------------------

類的屬性-總結
類屬性，也是共有屬性
類的私有屬性
對象的共有屬性
對象的私有屬性
內置屬性
函數的局部變量
全局變量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc


#對象屬性只能定義在方法內

var6 = "全局變量 var6"  #不在類里面叫全局變量

class MyClass(object):
   var1 = '類屬性，類的公有屬性 var1'  #類可以訪問，對象也可以訪問，類屬性要在類里面或者說在類里面叫公有屬性而不叫全局變量
   __var2 = '類的私有屬性 __var2'

   def func1(self):
        self.var3 = '對象的公有屬性 var3'    #只能對象訪問
        self.__var4 = '對象的私有屬性 __var4'
        var5 = '函數的局部變量 var5'
        print self.__var4
        print var5

   def func2(self):
        print self.var1
        print self.__var2
        print self.var3
        print self.__var4
        print var6



mc = MyClass()
mc.func1() #要訪問var3 這個對象公有屬性要先執行一下func1這個方法
print mc.var3
mc1 = MyClass()
#print mc1.var3  #報錯，因為mc1沒有執行mc1.func1()，所以叫對象公有屬性，因為是針對對象的不是針對類的
print '*' * 50
mc.func1()  #要訪問var3 這個對象公有屬性要先執行一下func1這個方法
mc.func2()
print '*' * 50
print mc.__dict__
print '*' * 50
print MyClass.__dict__


輸出
對象的私有屬性 __var4
函數的局部變量 var5
對象的公有屬性 var3
**************************************************
對象的私有屬性 __var4
函數的局部變量 var5
類屬性，類的公有屬性 var1
類的私有屬性 __var2
對象的公有屬性 var3
對象的私有屬性 __var4
全局變量 var6
**************************************************
{'_MyClass__var4': '\xe5\xaf\xb9\xe8\xb1\xa1\xe7\x9a\x84\xe7\xa7\x81\xe6\x9c\x89\xe5\xb1\x9e\xe6\x80\xa7 __var4', 'var3': '\xe5\xaf\xb9\xe8\xb1\xa1\xe7\x9a\x84\xe5\x85\xac\xe6\x9c\x89\xe5\xb1\x9e\xe6\x80\xa7 var3'}
**************************************************
{'func2': <function func2 at 0x00000000022BDD68>, '__module__': '__main__', 'var1': '\xe7\xb1\xbb\xe5\xb1\x9e\xe6\x80\xa7\xef\xbc\x8c\xe7\xb1\xbb\xe7\x9a\x84\xe5\x85\xac\xe6\x9c\x89\xe5\xb1\x9e\xe6\x80\xa7 var1', '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, 'func1': <function func1 at 0x00000000022BDCF8>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '_MyClass__var2': '\xe7\xb1\xbb\xe7\x9a\x84\xe7\xa7\x81\xe6\x9c\x89\xe5\xb1\x9e\xe6\x80\xa7 __var2', '__doc__': None}

類的方法-總結
公有方法
私有方法
類方法 --動態 @classmethod
靜態方法 --靜態 @staticmethod
內置方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __author__="huazai"
"""
pycharm 使用指南
Date:2016.08.12
"""

import os
import sys
import string
import gc



class MyClass(object):
    name = 'Test'


    def __init__(self):
        self.func1()
        self.__func2()
        self.classFun()   #可以被類調用 也可以被對象調用
        self.staticFun()  #可以被類調用 也可以被對象調用


    def func1(self):
        print self.name,
        print "我是公有方法"


    # self.__func2()

    def __func2(self):
        print self.name,
        print "我是私有方法"


    @classmethod
    def classFun(self):
        print self.name,
        print "我是類方法"


    @staticmethod
    def staticFun():  #靜態方法不能用self
        print MyClass.name,   #使用類名來引用公有屬性
        print "我是靜態方法"

mc = MyClass()

輸出
Test 我是公有方法
Test 我是私有方法
Test 我是類方法
Test 我是靜態方法

函數/方法、類、模塊的幫助 help函數

In [1]: help('aa'.strip())
no Python documentation found for 'aa'

需要把后面的括號去掉，即這樣：help('aa'.strip)
如果帶括號是看'aa'.strip()的返回結果幫助了 help('aa'.strip())。
所有看函數/方法、類、模塊的幫助都不需要后面的括號。

查看一個模塊的幫助
help('sys')

之后它回打開這個模塊的幫助文檔

查看一個數據類型的幫助
help('str')

返回字符串的方法及詳細說明
a = [1,2,3]
help(a)

這時help(a)則會打開list的操作方法
help(a.append)

S.strip([chars]) -> string or unicode 去除前后的空格和換行符，制表符，\t \n
Return a copy of the string S with leading and trailing whitespace removed.

查看一個類的幫助的時候要看類的構造函數

p=subprocess.Popen(['dir'],stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,shell=True)
help(p.communicate)

help(Popen)
Help on class Popen in module subprocess:

class Popen(__builtin__.object)
| Methods defined here:
|
| __del__(self, _maxint=2147483647)
|
| __init__(self, args, bufsize=0, executable=None, stdin=None, stdout=None, s
derr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, u
iversal_newlines=False, startupinfo=None, creationflags=0)
| Create new Popen instance.
|
| communicate(self, input=None)
| Interact with process: Send data to stdin. Read data from
| stdout and stderr, until end-of-file is reached. Wait for
| process to terminate. The optional input argument should be a
| string to be sent to the child process, or None, if no data
| should be sent to the child.
|
| communicate() returns a tuple (stdout, stderr).
|
| kill = terminate(self)
|
| poll(self)
|
| send_signal(self, sig)
| Send a signal to the process
|
| terminate(self)
| Terminates the process
|
| wait(self)
| Wait for child process to terminate. Returns returncode
| attribute.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)

文章列表

不含病毒。www.avast.com

大師兄

IT工程師數位筆記本

大師兄發表在痞客邦留言(0) 人氣()

E-mail轉寄

IT工程師數位筆記本

If you give someone a program , you will frustrate them for a day; if you teach them how to program, you will frustrate them for a lifetime.IT 這段話的意思是，如果你交給某人一隻程式，你將折磨他一整天;如果你教會某人如何寫程式，你將折磨他一輩子。

BloggerAds