python類重寫

❶ python怎麼重寫集合方法

class Set(object):
def __init__(self,data=None):
if data == None:
self.__data = []
else:
if not hasattr(data,'__iter__'):
#提供的數據不可以迭代，實例化失敗
raise Exception('必須提供可迭代的數據類型')
temp = []
for item in data:
#集合中的元素必須是可哈希
hash(item)
if not item in temp:
temp.append(item)
self.__data = temp

#析構函數
def __del__(self):
del self.__data

#添加元素，要求元素必須可哈希
def add(self, other):
hash(other)
if other not in self.__data:
self.__data.append(other)
else:
print('元素已存在，操作被忽略')

#刪除元素
def remove(self,other):
if other in self.__data:
self.__data.remove(other)
print('刪除成功')
else:
print('元素不存在，刪除操作被忽略')

#隨機彈出並返回一個元素
def pop(self):
if not self.__dat:
print('集合已空，彈出操作被忽略')
return
import random
item = random.choice(self.__data)
self.__data.remove(item)
return item

#運算符重載，集合差集運算
def __sub__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
#空集合
result = Set()
#如果一個元素屬於當前集合而不屬於另一個集合，添加
for item in self.__data:
if item not in other.__data:
result.__data.append(item)
return result

#提供方法，集合差集運算，復用上面的代碼
def difference(self,other):
return self - other

#｜運算符重載，集合並集運算
def __or__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
result = Set(self.__data)
for item in other.__data:
if item not in result.__data:
result.__data.append(item)
return result

#提供方法，集合並集運算
def union(self,otherSet):
return self | otherSet

#&運算符重載，集合交集運算
def __and__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
result = Set()
for item in self.__data:
if item in other.__data:
result.__data.append(item)
return result

#^運算符重載，集合對稱差集
def __xor__(self, other):
return (self-other) | (other-self)

#提供方法，集合對稱差集運算
def symetric_difference(self,other):
return self ^ other

#==運算符重載，判斷兩個集合是否相等
def __eq__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
if sorted(self.__data) == sorted(other.__data):
return True
return False

#>運算符重載，集合包含關系
def __gt__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
if self != other:
flag1 = True
for item in self.__data:
if item not in other.__data:
#當前集合中有的元素不屬於另一個集合
flag1 = False
break
flag2 = True
for item in other.__data:
if item not in self.__data:
#另一集合中的元素不屬於當前集合
flag2 = False
break
if not flag1 and flag2:
return True
return False

#>=運算符重載，集合包含關系
def __ge__(self, other):
if not isinstance(other,Set):
raise Exception('類型錯誤')
return self == other or self > other

#提供方法，判斷當前集合是否為另一個集合的真子集
def issubset(self,other):
return self<other

#提供方法，判斷當前集合是否為另一集合的超集
def issuperset(self,other):
return self > other

#提供方法，清空集合所有元素
def clear(self):
while self.__data:
del self.__data[-1]
print('集合已清空')

#運算符重載，使得集合可迭代
def __iter__(self):
return iter(self.__data)

#運算符重載，支持in運算符
def __contains__(self, item):
return item in self.__data

#支持內置函數len()
def __len__(self):
return len(self.__data)

#直接查看該類對象時調用該函數
def __repr__(self):
return '{'+str(self.__data)[1:-1]+'}'

#使用print()函數輸出該類對象時調用該函數
__str__ = __repr__

❷ python怎麼給導入模塊的類重寫其中部分類方法啊

要重寫ca.py中Test類的test方法，可以這樣做：
from ca import *
def t(self,mu):self.b=mu
Test.test=t

當然也可以重寫__init__方法：
from ca import *
def __init__(self):self.a,self.b=0,0
Test.__init__=__init__

❸ python的三大特徵

第一點：封裝
隱藏對象的屬性和實現細節，僅對外提供公共訪問方式，在Python中用雙下線開頭的方式將屬性設置成私有的。
擁有三個好處：將變化隔離，便於使用，提高復用性，提高安全性。
第二點：繼承
繼承是一種創建新類的方式，在Python中，新建的類可以繼承一個或多個父類，父類又被稱為基類或超類，新建的類稱為派生類或子類。即一個派生類繼承基類的欄位和方法，繼承也允許把一個派生類的對象作為一個基類對象對待。
第三點：多態
一種事物的多種體現形式，函數的重寫其實就是多態的一種體現。Python中，多態指是父類的引用指向子類的對象。
實現多態的步驟：
1. 定義新的子類;
2. 重寫對應的父類方法;
3. 使用子類的方法直接處理，不調用父類的方法;
多態的好處：
1. 增加了程序的靈活性;
2. 增加了程序的可擴展性。

❹ python 重載和重寫的區別

重載和重寫，這是兩個新概念，是兩個令我們容易混淆的概念。方法重載(overloading method)
是在一個類裡面，方法名字相同，而參數不同。返回類型呢？可以相同也可以不同。方法重寫(overiding method)
子類不想原封不動地繼承父類的方法，而是想作一定的修改，這就需要採用方法的重寫。方法重寫又稱方法覆蓋。方法重載是讓類以統一的方式處理不同類型數據的
一種手段。Java的方法重載，就是在類中可以創建多個方法，它們具有相同的名字，但具有不同的參數和不同的定義。調用方法時通過傳遞給它們的不同個數和
類型的參數來決定具體使用哪個方法,
這就是多態性。方法重寫：在Java中，子類可繼承父類中的方法，而不需要重新編寫相同的方法。但有時子類並不想原封不動地繼承父類的方法，而是想作一定
的修改，這就需要採用方法的重寫。方法重寫又稱方法覆蓋。
若子類中的方法與父類中的某一方法具有相同的方法名、返回類型和參數表，則新方法將覆蓋原有的方法。
如需父類中原有的方法，可使用super關鍵字，該關鍵字引用了當前類的父類重寫方法的規則:
參數列表必須完全與被重寫的方法的相同,否則不能稱其為重寫而是重載.
返回的類型必須一直與被重寫的方法的返回類型相同,否則不能稱其為重寫而是重載.訪問修飾符的限制一定要大於被重寫方法的訪問修飾符
（public>protected>default>private）重寫方法一定不能拋出新的檢查異常或者比被重寫方法申明更加寬
泛的檢查型異常．例如，父類的一個方法申明了一個檢查異常IOException，在重寫這個方法是就不能拋出Exception，只能拋出
IOException的子類異常，可以拋出非檢查異常．重載的規則：必須具有不同的參數列表；可以有不同的返回類型，只要參數列表不同就可以
了；可以有不同的訪問修飾符；可以拋出不同的異常；注意，Java的方法重載要求同名的方法必須有不同的參數表，僅有返回類型不同是不足以區分兩
個重載的方法。重寫方法只能存在於具有繼承關系中,重寫方法只能重寫父類非私有的方法。下面分別舉一個例子來說明方法重載：public class
TestOverLoad{ public static void main(String[] args) {Test test = new
Test(); test.print(null); } }class Test{ public void print(String
some){System.out.println("String version print"); } public void
print(Object some){ System.out.println("Object version print");
}}該程序輸出的結果是String version print。

❺ Python自定義的類，為什麼需要重寫

首先，自定義的類在不繼承任何基類的情況下，也具有__str__屬性：

[python] view plain
class RoundFloatManual(object):
... def __init__(self, val):
... assert isinstance(val, float), \
... "Value must be a float!"
... self.value = round(val, 2)
rfm = RoundFloatManual(5.590464)
dir(rfm)

返回：
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__mole__', '__new__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'value']
__str__ 是 Python 類中的特殊方法，他的回傳值就是使用 str(x) 所得到的值， 而 print(x) 其實就等於是print(str(x))．其實再講細一點，當我們呼叫 str(x) 的時候其實是呼叫x.__str__()
也就是說我們可以這樣想像:

print(x) === print(str(x)) === print(x.__str__())
一般我們 自定義的類，__str__ 方法的回傳值是默認的字串，比如說: <__main__.Mylist object at 0x0071A470> 用以說明 namespace, class name 和位置．如果要改變__str__ 的回傳值，我們必須要覆寫他．

❻ 在Python中為什麼重寫__new__方法時，不需要聲明它是靜態方法

這個不需要糾結，就和你寫的 "if" 解釋器如何判斷它是關鍵字？一個意思。
這個是解釋器自己的邏輯，同樣__init__()方法和其他方法也定義也沒有區別，為什麼實例化先會調用它，也是一個意思。
通俗點講，你帶了幾個朋友回家，你要給家裡人介紹一下，其中有一個朋友是你們家親戚，那是不是就可以不用介紹了？

❼ Python 一個可以靈活修改類變數的結構

開發 Python 程序總會遇到，需要修改類或者實例變數的值的情況，雖然 @property 可以實現，但是，不免有點繁瑣。本文介紹一種更便捷的方式：

具體的使用，可以看如下的示例：

這里的類 Pen 便有直接修改實例變數的功能：

輸出：

也可以在實例方法中修改實例變數：

調用：

也許會有人疑問，不使用 ParamDict 類似也可以達到同樣的效果？但是，您可能忽略一個問題，如果想要對其進行改寫將會十分繁瑣。比如下面的寫法是沒有問題的：

但是，如果想要在屬性值前添加前綴，則需要為 change_color 與 change_line_width 函數同時添加該功能，而使用 ParamDict 則可以避免修改 change_color 與 change_line_width 函數，只需要這樣：

再次調用：

輸出為：

是不是很方便？只需要修改 ParamDict ，而不需要改變功能函數便可修改功能。

為可以直接提供類的重寫，可以這樣：

最後，以一個 PyQt5 的例子結束本文：

輸出：

❽ python類方法重寫

從父類繼承中的方法，如果不滿足程序的需求，就需要重寫。

方法重寫指的是在子類中自定義實現父類中的同名方法。

❾ 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

網頁鏈接