简述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函数重命名
链接URL：http://pwwzsj.com/article/hdggjs.html