❶ python 有沒有方法的重載

Python 類可以定義專用方法,專用方法是在特殊情況下或當使用特別語法時由 Python 替你調用的，而不是在代碼中直接調用（象普通的方法那樣）。
.1 __init__
類似於構造函數
#!/usr/local/bin/python
class Study:
def __init__(self,name=None):
self.name = name
def say(self):
print self.name
study = Study("Badboy")
study.say()

.2 __del__
類似於析構函數
#!/usr/local/bin/python
class Study:
def __init__(self,name=None):
self.name = name
def __del__(self):
print "Iamaway,baby!"
def say(self):
print self.name
study = Study("zhuzhengjun")
study.say()

.3__repr__
使用repr(obj)的時候，會自動調用__repr__函數，該函數返回對象字元串表達式，
用於重建對象，如果eval(repr(obj))會得到一個對象的拷貝。
#!/usr/local/bin/python
class Study:
def __init__(self,name=None):
self.name = name
def __del__(self):
print "Iamaway,baby!"
def say(self):
print self.name
def __repr__(self):
return "Study('jacky')"
study = Study("zhuzhengjun")
study.say()
print type(repr(Study("zhuzhengjun"))) # str
print type(eval(repr(Study("zhuzhengjun")))) # instance

study = eval(repr(Study("zhuzhengjun")))

study.say()

.4__str__
Python能用print語句輸出內建數據類型。有時，程序員希望定義一個類，要求它的對象也能用print語句輸出。Python類可定義特殊方法__str__，為類的對象提供一個不正式的字元串表示。如果類的客戶程序包含以下語句：

print objectOfClass
那麼Python會調用對象的__str__方法，並輸出那個方法所返回的字元串。

#!/usr/local/bin/python

class PhoneNumber:
def __init__(self,number):
self.areaCode=number[1:4]
self.exchange=number[6:9]
self.line=number[10:14]

def __str__(self):
return "(%s) %s-%s"%(self.areaCode,self.exchange,self.line)

def test():
newNumber=raw_input("Enter phone number in the form. (123) 456-7890: \n")
phone=PhoneNumber(newNumber)
print "The phone number is:"
print phone

if__name__=="__main__":
test()

方法__init__接收一個形如"(xxx) xxx-xxxx"的字元串。字元串中的每個x都是電話號碼的一個位數。方法對字元串進行分解，並將電話號碼的不同部分作為屬性存儲。

方法__str__是一個特殊方法，它構造並返回PhoneNumber類的一個對象的字元串表示。解析器一旦遇到如下語句：
print phone

就會執行以下語句：

print phone.__str__()

程序如果將PhoneNumber對象傳給內建函數str(如str(phone)),或者為PhoneNumber對象使用字元串格式化運算符%(例如"%s"%phone),Python也會調用__str__方法。

.5__cmp __
比較運算符，0：等於 1：大於 -1：小於
class Study:
def __cmp__(self, other):
if other > 0 :
return 1
elif other < 0:
return - 1
else:
return 0

study = Study()
if study > -10:print 'ok1'
if study < -10:print 'ok2'
if study == 0:print 'ok3'

列印：ok2 ok3
說明:在對類進行比較時，python自動調用__cmp__方法，如-10 < 0 返回 -1，也就是說study 應該小與 -10，估列印ok2

.6__getitem__
__getitem__ 專用方法很簡單。象普通的方法 clear，keys 和 values 一樣，它只是重定向到字典，返回字典的值。
class Zoo:
def __getitem__(self, key):
if key == 'dog':return 'dog'
elif key == 'pig':return 'pig'
elif key == 'wolf':return 'wolf'
else:return 'unknown'

zoo = Zoo()
print zoo['dog']
print zoo['pig']
print zoo['wolf']

列印 dog pig wolf

.7__setitem__
__setitem__ 簡單地重定向到真正的字典 self.data ，讓它來進行工作。
class Zoo:
def __setitem__(self, key, value):
print 'key=%s,value=%s' % (key, value)

zoo = Zoo()
zoo['a'] = 'a'
zoo['b'] = 'b'
zoo['c'] = 'c'
列印：
key=a,value=a
key=b,value=b
key=c,value=c

.8 __delitem__
__delitem__ 在調用 del instance[key] 時調用 ，你可能記得它作為從字典中刪除單個元素的方法。當你在類實例中使用 del 時，Python 替你調用 __delitem__ 專用方法。
class A:
def __delitem__(self, key):
print 'delete item:%s' %key

a = A()
del a['key']

❷ 關於python的重載問題

沒有來重載，但是可以有源默認參數和不定長參數，可以判斷默認值和參數長度來處理。
比如:
def range(start, end = -1):
if end == -1:
end = start
start = 0
或
def range(*args):
if len(args) == 1:
start = 0
end = args[0]
elif len(args) == 2:
start, end = args[0], args[1]

❸ python運算符重載問題

將__div__換成__truediv__試試
因為在python 2.x.x 裡面 / 是classic division 所以LOVESOO的回答沒有問題
在python 3.x.x / 對應的是 true division 所以試試定義 __truediv__
http://legacy.python.org/dev/peps/pep-0238/ 搜 API Changes

❹ python是否支持函數重載

python 是動態腳本型語言，設計的機制就是按函數名來保存函數入口，而不是函數名+參數。
你調用函數的時候，可以多傳參數，一樣的會調用到只是函數名匹配的那個函數。
python 雖然不支持函數重載，但是可以通過傳遞容器類型的參數（list、tuple、set、dict）來實現類似的功能。
相關推薦：《Python平台》
為了考慮為什麼 python 不提供函數重載，首先我們要研究為什麼需要提供函數重載。
函數重載主要是為了解決兩個問題。
1、可變參數類型。
2、可變參數個數。
另外，一個基本的設計原則是，僅僅當兩個函數除了參數類型和參數個數不同以外，其功能是完全相同的，此時才使用函數重載，如果兩個函數的功能其實不同，那麼不應當使用重載，而應當使用一個名字不同的函數。
好吧，那麼對於情況 1 ，函數功能相同，但是參數類型不同，python 如何處理？答案是根本不需要處理，因為 python 可以接受任何類型的參數，如果函數的功能相同，那麼不同的參數類型在 python 中很可能是相同的代碼，沒有必要做成兩個不同函數。
那麼對於情況 2 ，函數功能相同，但參數個數不同，python 如何處理？大家知道，答案就是預設參數。對那些缺少的參數設定為預設參數即可解決問題。因為你假設函數功能相同，那麼那些缺少的參數終歸是需要用的。
好了，鑒於情況 1 跟 情況 2 都有了解決方案，python 自然就不需要函數重載了。

❺ 簡述python面向對象編程中函數重載和重寫的區別

這個基本是沒有一點關聯。。。只是名字容易混淆而已 重寫就是對父類的方法重寫，改變方法體中的語句。。。。 重載就是同一個函數名，參數個數、類型、排列順序不同，jvm根據參數來決定調用哪一個方法

❻ 怎麼理解Python中重載通俗理解是

python裡面沒有重載吧？
正常的重載說的應該是函數方法的重載,即兩個函數的名稱相回同但答是參數不同是重載，會出現重載的情況一般是函數實現相同功能時，遇到參數類型可能不同的情況，會出現重載，如比較常見的對於加法的實現，如果輸入兩個整數相加則直接使用整數加法，如果兩個字元串相加則使用字元串的拼接。輸入的參數類型不同，其實是兩個不同的函數，這在那種強類型語言中是可以利用函數重載來實現的，而python中函數類型是動態的各種各樣的，所以不需要重載這個機制。相同函數名就是表示同一個方法。

❼ python 運算符重載

class indexer:
def __getitem__(self, index): #iter override
return index ** 2
X = indexer()
X[2]
for i in range(5):
print X[i]

❽ Python一種實現類似於重載的方法，*k是什麼意思

*k表示可變參數，通過可變參數實現類似於重載的方法。
通常我們要定義一個專函數的時候，必須要預屬先定義這個函數需要多少個參數（或者說可以接受多少個參數）。一般情況下這是沒問題的，但是也有在定義函數的時候，不能知道參數個數的情況（想一想C語言里的printf函數），在Python里，帶*的參數就是用來接受可變數量參數的。看一個例子
def funcD(a, b, *c):
print a
print b
print "length of c is: %d " % len(c)
print c
調用funcD(1, 2, 3, 4, 5, 6)結果是
1
2
length of c is: 4
(3, 4, 5, 6)
我們看到，前面兩個參數被a、b接受了，剩下的4個參數，全部被c接受了，c在這里是一個tuple。我們在調用funcD的時候，至少要傳遞2個參數，2個以上的參數，都放到c里了，如果只有兩個參數，那麼c就是一個empty tuple。