python函数重写为类,python函数重命名
简述python面向对象编程中函数重载和重写的区别
这个基本是没有一点关联。。。只是名字容易混淆而已 重写就是对父类的方法重写,改变方法体中的语句。。。。 重载就是同一个函数名,参数个数、类型、排列顺序不同,jvm根据参数来决定调用哪一个方法
专注于为中小企业提供网站设计、网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业岷县免费做网站提供优质的服务。我们立足成都,凝聚了一批互联网行业人才,有力地推动了千余家企业的稳健成长,帮助中小企业通过网站建设实现规模扩充和转变。
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 selfother
#提供方法,判断当前集合是否为另一集合的超集
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自定义的类,为什么需要重写
首先,自定义的类在不继承任何基类的情况下,也具有__str__属性:
[python] view plain copy
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__', '__module__', '__new__', '__reduce__', '__reduce_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函数里定义的类
#Python 2.5
#这个可以用修饰器来完成
#但是一般不会限制参数类型
#给你个思路:
def argfilter(*types):
def deco(func): #这是修饰器
def newfunc(*args): #新的函数
if len(types)==len(args):
correct = True
for i in range(len(args)):
if not isinstance(args[i], types[i]): #判断类型
correct = False
if correct:
return func(*args) #返回原函数值
else:
raise TypeError
else:
raise TypeError
return newfunc #由修饰器返回新的函数
return deco #返回作为修饰器的函数
@argfilter(int, str) #指定参数类型
def func(i, s): #定义被修饰的函数
print i, s
#之后你想限制类型的话, 就这样:
#@argfilter(第一个参数的类名, 第二个参数的类名, ..., 第N个参数的类名)
#def yourfunc(第一个参数, 第一个参数, ..., 第N个参数):
# ...
#
#相当于:
#def yourfunc(第一个参数, 第一个参数, ..., 第N个参数):
# ...
#yourfunc = argfilter(第一个参数的类名, 第二个参数的类名, ..., 第N个参数的类名)(yourfunc)
python中将函数和变量封装成类的好处
封装成类的好处,总结归纳有2个:一个是保护隐私,一个是降低程序复杂度
python类方法重写
从父类继承中的方法,如果不满足程序的需求,就需要重写。
方法重写指的是在子类中自定义实现父类中的同名方法。
当前文章:python函数重写为类,python函数重命名
当前链接:http://myzitong.com/article/hdggjs.html