python函数重写 python函数重构

python 重载和重写的区别

重载和重写,这是两个新概念,是两个令我们容易混淆的概念。方法重载(overloading method)

创新互联公司专注于企业全网营销推广、网站重做改版、石台网站定制设计、自适应品牌网站建设、HTML5建站成都做商城网站、集团公司官网建设、成都外贸网站建设公司、高端网站制作、响应式网页设计等建站业务,价格优惠性价比高,为石台等各大城市提供网站开发制作服务。

是在一个类里面,方法名字相同,而参数不同。返回类型呢?可以相同也可以不同。方法重写(overiding method)

子类不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖。方法重载是让类以统一的方式处理不同类型数据的

一种手段。Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和

类型的参数来决定具体使用哪个方法,

这就是多态性。方法重写:在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定

的修改,这就需要采用方法的重写。方法重写又称方法覆盖。

若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。

如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类重写方法的规则:

参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.

返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载.访问修饰符的限制一定要大于被重写方法的访问修饰符

(publicprotecteddefaultprivate)重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽

泛的检查型异常.例如,父类的一个方法申明了一个检查异常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中为什么重写__new__方法时,不需要声明它是静态方法?

这个不需要纠结,就和你写的 "if" 解释器如何判断它是关键字?一个意思。

这个是解释器自己的逻辑,同样__init__()方法和其他方法也定义也没有区别,为什么实例化先会调用它,也是一个意思。

通俗点讲,你带了几个朋友回家,你要给家里人介绍一下,其中有一个朋友是你们家亲戚,那是不是就可以不用介绍了?

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的三大特征

第一点:封装

隐藏对象的属性和实现细节,仅对外提供公共访问方式,在Python中用双下线开头的方式将属性设置成私有的。

拥有三个好处:将变化隔离,便于使用,提高复用性,提高安全性。

第二点:继承

继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又被称为基类或超类,新建的类称为派生类或子类。即一个派生类继承基类的字段和方法,继承也允许把一个派生类的对象作为一个基类对象对待。

第三点:多态

一种事物的多种体现形式,函数的重写其实就是多态的一种体现。Python中,多态指是父类的引用指向子类的对象。

实现多态的步骤:

1. 定义新的子类;

2. 重写对应的父类方法;

3. 使用子类的方法直接处理,不调用父类的方法;

多态的好处:

1. 增加了程序的灵活性;

2. 增加了程序的可扩展性。

python类方法重写

从父类继承中的方法,如果不满足程序的需求,就需要重写。

方法重写指的是在子类中自定义实现父类中的同名方法。


网站栏目:python函数重写 python函数重构
文章转载:http://pwwzsj.com/article/hidpch.html