python成員函數定義

『壹』 python的成員函數問題

1. join() 是str類中的一個成員函數，它是類成員。
   

   
   

2. python中視一切為對象，所以a其實是一個字元串對象，具有成員函數join，可以用dir(a)查看。

3. a.join() 就是字元對象a調用其成員函數 join()

『貳』 python中的函數和類的區別

樓上說錯了哦，類可以有類方法（查查什麼是classmethod），不需實例化也可以使用的。python的類和函數的區別主要在於類可以有變數和各種方法，而函數沒有。函數只能被運行，返回或者不返回值都可以。模塊如果沒有把類聲明為私有，其他模塊就可以使用這個類，方法是import這個模塊，然後用"模塊名.類名"來調用。

『叄』 Python中類的定義規是什麼

類的概念：

類 Class: 用來描述具體相同的屬性和方法的對象的集合。定義了該集合中每個對象所共有的屬性和方法。對象是類的示例。

類變數：類變數在整個實例化的對象中是公用的。類變數定義在類中且在函數體之外。類變數通常不作為實例變數使用。

實例變數：定義在方法中的變數，只作用於當前實例的類。

數據成員：類變數或者實例變數用於處理類及其實例對象的相關數據。

方法：類中定義的函數。在類內部，使用 def 關鍵字來定義一個方法，與一般函數定義不同，類方法必須包含參數 self, 且為第一個參數，self 代表的是類的實例。

構造函數：即__init()__，特殊的方法，在對象創建的時候被自動調用。

析構函數：即__del()__，特殊的方法，在對象被銷毀時被自動調用。

實例化：創建一個類的實例，類的具體對象。就是將創建的類賦值給另一個變數。理解為賦值即可，a = class()，這個過程，就叫做實例化

對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變數和實例變數）和方法。

繼承：即一個派生類（derived class）繼承基類（base class）的欄位和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬」是一個（is-a）」關系（例圖，Dog是一個Animal）。

方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其 進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

————————————————

原文鏈接：https://blog.csdn.net/f156207495/article/details/81166252

網頁鏈接

『肆』 python如何在類外定義成員函數

類的外面可以定類的屬性值。按理也可以定義類外定義函數。一定可以。比如

class a:
pass

def hello(self,name):
print "Hello %s"%name

a.hello=hello
a().hello("somebody")

這個代碼測試通過。

『伍』 python類和函數的區別

一、主體不同

1、類：是面向對象程序設計實現信息封裝的基礎。

2、函數：是指一段在一起的、可以做某一件事兒的程序。也叫做子程序、（OOP中）方法。

二、特點不同

1、類：是一種用戶定義的引用數據類型，也稱類類型。每個類包含數據說明和一組操作數據或傳遞消息的函數。類的實例稱為對象。

2、函數：分為全局函數、全局靜態函數；在類中還可以定義構造函數、析構函數、拷貝構造函數、成員函數、友元函數、運算符重載函數、內聯函數等。

三、規則不同

1、類：實質是一種引用數據類型，類似於byte、short、int(char)、long、float、double等基本數據類型，不同的是它是一種復雜的數據類型。

2、函數：函數必須聲明後才可以被調用。調用格式為：函數名（實參）調用時函數名後的小括弧中的實參必須和聲明函數時的函數括弧中的形參個數相同。

『陸』 python 函數是不是描述符

在Python中，訪問一個屬性的優先順序順序按照如下順序:
1.類屬性
2.數據描述符
3.實例屬性
4.非數據描述符
5.__getattr__()方法。這個方法的完整定義如下所示:

[python] view plain
def __getattr__(self,attr) :#attr是self的一個屬性名
pass;

先來闡述下什麼叫數據描述符。

數據描述符是指實現了__get__,__set__,__del__方法的類屬性(由於Python中，一切皆是對象，所以你不妨把所有的屬性也看成是對象)

PS:個人覺得這里最好把數據描述符等效於定義了__get__,__set__,__del__三個方法的介面。

闡述下這三個方法:

__get__的標準定義是__get__(self,obj,type=None)，它非常接近於JavaBean的get

第一個函數是調用它的實例，obj是指去訪問屬性所在的方法，最後一個type是一個可選參數，通常為None(這個有待於進一步的研究)

例如給定類X和實例x，調用x.foo，等效於調用:

type(x).__dict__["foo"].__get__(x,type(x))

調用X.foo，等效於調用:

type(x).__dict__["foo"].__get__(None,type(x))

第二個函數__set__的標準定義是__set__(self,obj,val)，它非常接近於JavaBean的set方法，其中最後一個參數是要賦予的值

第三個函數__del__的標準定義是__del__(self,obj)，它非常接近Java中Object的Finailize()方法，指
Python在回收這個垃圾對象時所調用到的析構函數，只是這個函數永遠不會拋出異常。因為這個對象已經沒有引用指向它，拋出異常沒有任何意義。

接下來，我們來一一比較這些優先順序.

首先來看類屬性

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''
class A(object):
foo=3

print A.foo
a=A()
print a.foo
a.foo=4
print a.foo
print A.foo

上面這段代碼的輸出如下：

3
3
4
3

從輸出可以看到，當我們給a.foo賦值的時候，其實與類實例的那個foo是沒有關系的。a.foo=4 這句話給a對象增加了一個屬性叫foo。其值是4。

最後兩個語句明確的表明了，我們輸出a.foo和A.foo的值，他們是不同的。

但是為什麼a=A()語句後面的print
a.foo輸出了3呢？這是因為根據搜索順序找到了類屬性。當我們執行a.foo=4的時候，我們讓a對象的foo屬性指向了4這個對象。但是並沒有改變
類屬性foo的值。所以最後我們print A.foo的時候，又輸出了3。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''
class A(object):
foo=3

a=A()
a.foo=4
print a.foo
del a.foo
print a.foo

上面的代碼，我給a.foo賦值為4，在輸出一次之後就del了。兩次輸出，第一次輸出的是a對象的屬性。第二次是類屬性。不是說類屬性的優先順序比
實例屬性的高嗎。為啥第一次輸出的是4而不是3呢？還是上面解釋的原因。因為a.foo與類屬性的foo只是重名而已。我們print
a.foo的時候，a的foo指向的是4，所以輸出了4。

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

然後我們來看下數據描述符這一全新的語言概念。按照之前的定義，一個實現了__get__,__set__,__del__的類都統稱為數據描述符。我們來看下一個簡單的例子。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):

def __get__(self,obj,type=None):
pass

def __set__(self,obj,val):
pass

def __del__(self,obj):
pass

class A(object):
foo=simpleDescriptor()

print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo

上面例子的輸出結果如下：

[plain] view plain
{'__dict__': <attribute '__dict__' of 'A' objects>, '__mole__': '__main__', 'foo': <__main__.simpleDescriptor object at 0x005511B0>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
None
None
None

從輸出結果看出，print語句列印出來的都是None。這說明a.foo都沒有被賦值內容。這是因為__get__函數的函數體什麼工作都沒有做。直接是pass。此時，想要訪問foo，每次都沒有返回內容，所以輸出的內容就是None了。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):

def __get__(self,obj,type=None):
return "hi there"

def __set__(self,obj,val):
pass

def __del__(self,obj):
pass

class A(object):
foo=simpleDescriptor()

print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo

把__get__函數實現以下，就可以得到如下輸出結果：

[plain] view plain
{'__dict__': <attribute '__dict__' of 'A' objects>, '__mole__': '__main__', 'foo': <__main__.simpleDescriptor object at 0x00671190>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
hi there
hi there
hi there

為了加深對數據描述符的理解，看如下例子：

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = 13;
print a.foo;

上面代碼的輸出是

16

6

第一個16為我們在對a.foo賦值的時候，人為的將13加上3後作為foo的值，第二個6是我們在返回a.foo之前人為的將它減去了10。

所以我們可以猜測，常規的Python類在定義get,set方法的時候，如果無特殊需求，直接給對應的屬性賦值或直接返回該屬性值。如果自己定義類，並且繼承object類的話，這幾個方法都不用定義。

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

在這里看一個題外話。

看代碼

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
if isinstance(val,str):
assert False,"int needed! but get str"
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = "13";
print a.foo;

上面代碼在__set__ 函數中檢查了參數val，如果val是str類型的，那麼要報錯。這就實現了我們上一篇文章中要實現的，在給屬性賦值的時候做類型檢查的功能。

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

下面我們來看下實例屬性和非數據描述符。

[python] view plain
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29

@author: naughty
'''

class B(object):
foo = 1.3
b = B()
print b.__dict__
b.bar = 13
print b.__dict__
print b.bar

上面代碼輸出結果如下：

{}
{'bar': 13}
13

那麼什麼是非數據描述符呢？

簡單的說，就是沒有實現get,set,del三個方法的所有類。

讓我們任意看一個函數的描述：

def call():

pass

執行print dir(call)會得到如下結果：

[plain] view plain
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__mole__', '__name__', '__new__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

先看下dir的幫助。

dir列出給定對象的屬性或者是從這個對象能夠達到的對象。

回到print dir(call)方法的輸出，看到，call方法，有輸出的那麼多個屬性。其中就包含了__get__函數。但是卻沒有__set__和__del__函數。所以所有的類成員函數都是非數據描述符。

看一個實例數據掩蓋非數據描述符的例子：

[python] view plain
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type

class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo

看輸出：

('get', <__main__.simpleDescriptor object at 0x02141190>,
<__main__.D object at 0x025CAF50>, <class '__main__.D'>)
15

可見，實例數據掩蓋了非數據描述符。

如果改成數據描述符，那麼就不會被覆蓋了。看下面：

[python] view plain
'''''
Created on 2013-3-29

@author: naughty
'''

class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type
def __set__(self,obj,type=None) :
pass
def __del__(self,obj,type=None) :
pass

class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo

代碼的輸出如下：

[plain] view plain
('get', <__main__.simpleDescriptor object at 0x01DD1190>, <__main__.D object at 0x0257AF50>, <class '__main__.D'>)
('get', <__main__.simpleDescriptor object at 0x01DD1190>, <__main__.D object at 0x0257AF50>, <class '__main__.D'>)

由於是數據描述符，__set __函數體是pass，所以兩次輸出都是同樣的內容。

最後看下__getatrr__方法。它的標準定義是:__getattr__(self,attr)，其中attr是屬性名

『柒』 python class成員函數沒有實現

pythonclass成員函數沒有實現是因為：
def是定義函數,就是封裝一段代碼,執行特定功能。class是定義對象,對象有自己的成員變數和成員函數。