初学Python——面向对象(二)

简介: 一、抽象类、接口类和抽象接口转自博客园魏恒https://www.cnblogs.com/weihengblog/p/8528967.html(一)接口类  什么是接口类?在继承中,我们可以声明某个子类继承自某基类,这个基类是个接口类,在接口类中定义了接口名(函数名)且并未实现接口的功能,子类继承接口类,并实现接口中的功能。

一、抽象类、接口类和抽象接口

转自博客园魏恒https://www.cnblogs.com/weihengblog/p/8528967.html

(一)接口类

  什么是接口类?在继承中,我们可以声明某个子类继承自某基类,这个基类是个接口类,在接口类中定义了接口名(函数名)且并未实现接口的功能,子类继承接口类,并实现接口中的功能。这又叫做“接口继承”。

  接口继承实质上是规定了一个兼容接口,使得外部调用者无需关心具体细节,可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上,叫做归一化。特点:1.做出良好的抽象类,2.规定兼容接口 3.调用者可以无需关心具体实现细节,可以一视同仁处理实现特定接口的所有对象。

#做出一个良好的抽象
class Payment(object):
    #规定了一个兼容接口
    def pay(self):
        pass

#微信支付
class WeChatPay(Payment):
    def pay(self,money):
        print('微信支付了%s'%money)

#支付宝支付
class AliPay(Payment):
    def pay(self,money):
        print('支付宝支付了%s'%money)

#苹果支付
class ApplePay(Payment):
    def pay(self,money):
        print('苹果支付了%s'%money)

def pay(obj,money):
    obj.pay(money)

weixin = WeChatPay()
alipay = AliPay()
applepay = ApplePay()

#调用者无需关心具体实现细节,可以一视同仁的处理实现了特定接口的所有对象
pay(weixin,100)
pay(alipay,200)
pay(applepay,300)

(二)抽象类

什么是抽象类?

  与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

为什么要有抽象类?

  如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性。

  比如我们有香蕉的类,有苹果的类,有桃子的类,从这些类抽取相同的内容就是水果这个抽象的类,你吃水果时,要么是吃一个具体的香蕉,要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

  从设计角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的。

  从实现角度来看,抽象类与普通类的不同之处在于:抽象类中有抽象方法,该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的

#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法,无需实现功能
        def read(self):
        '子类必须定义读功能'
            pass

    @abc.abstractmethod #定义抽象方法,无需实现功能
        def write(self):
        '子类必须定义写功能'
            pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类,但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

(三)抽象类和接口类

  抽象类的本质还是类,指的是一组类的相似性,包括数据属性和函数属性,而接口强调函数属性的相似性。

  抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特征,可以用来实现归一化设计。

二、静态方法、属性方法、类方法

1.静态方法    

  @staticmethod

  静态方法就是一个普通方法,不能访问实例变量与类变量,与类唯一的联系就是需要通过类名来调用这个方法,所以
  只是名义上归类管。私有方法不能作为静态方法,但受保护类可以作为静态方法。

class Dog(object):
    def __init__(self,name):
        self.name = name

    @staticmethod # 将eat变成了静态方法,作用是将此方法断绝与类的联系,变普通函数
    def eat(self):
        print(" is eating")

d = Dog("ChenRonghua")
d.eat()
# 这样运行会出错,要想不出错
1.调用时,d.eat(d)。已经断绝与类的联系,"self"需要手动传入
2.eat()方法去掉参数self

2.类方法

  @classmethod

  变成类方法后,方法内只能访问类变量,不能访问实例变量。

class Cat(object):
    name = "华仔"
    def __init__(self,name):
        self.name = name
        self.__person = None

    @classmethod # 类方法
    def eat(self,food):
        print('{0}吃{1}' .format(self.name,food))

c1 = Cat("小猫")

c1.eat("")
# 输出结果显示,类方法没有使用实例变量,使用的是类变量

3.属性方法

  @property

  可以把一个方法变成静态属性。也就是将原本的方法变成了静态属性,不能传参数,不能修改属性值,也不能删除

先来看一下

class Cat(object):
    name = "华仔"
    def __init__(self,name):
        self.name = name
        self.person = None

    @property
    def talk(self):
        print("{0} is talking with {1}".format(self.name,self.person))

c1 = Cat("小猫")

c1.talk
#输出:小猫 is talking with None

  ·这时,想要对self.person进行修改是不可以的,会报错。

  若非要修改,也是可以通过特殊方法来修改的,

  #在上述代码的基础上加上如下代码(在原eat方法的下面,类的里面) 
    @talk.setter   # 修改属性方法的值需要这样做
    def talk(self,person):
        print("{0} is talking with {1}".format(self.name,person))
        self.person = person

c1.talk = "Jack"
c1.talk   # 再次访问,发现真正修改了它
# 输出:
小猫 is talk with Jack

  同样,若非要删除,也可以

    @talk.deleter  # 删除属性方法的值需要这样做
    def talk(self):
        del self.person
        print("已删除talk")

del c1.talk
c1.talk # 删除后再访问运行出错!

  这时相信你会有个疑问,为什么还需要属性方法的存在呢?直接定义一个静态变量不就行了吗?属性方法和属性有什么不同呢?

  属性方法的本质还是方法(函数),只是变得特殊了,我们知道属性方法具有以下两点特征:

    1.属性方法内可以对内部属性进行访问

    2.属性方法不能被随意修改删除,防止误改误删,保证了安全性。

  在实际应用中,有这样的需求:已经写好了具有特定功能的方法,作用是返回一个数值。而要经过一系列的动作才能得到这个值,这显然不是变量可以完成的。用户调用它时只需要像对待静态变量一样就可以得到一个值,中间的过程用户不需要关心。

三、反射

  在实际应用中,我们需要根据用户输入来做出相应的工作,比如输入1调用a方法,输入2调用b方法,输入2调用c方法.....,这些我们可以用if else分支语句来判断并执行,但显而易见,如果用户输入的种类非常多,if else语句的代码量就非常可观了,不美观,也不便于维护。怎么办呢?

  1.需要用到反射函数hasattr()来判断对象是否有这个方法

  2.如果有这个方法,则可以用getatter()函数来找到对象方法的内存地址

  3.加上括号即可调用  

class Dog(object):
    def __init__(self,name):
        self.name = name
    
    def eat(self,name):
        print("{0} is eating {1}".format(self.name,name))

def bulk(self):
    print("{0} is yelling".format(self.name))

d = Dog("Alex")


chioce = input("请输入操作:").strip()
If hasattr(d,chioce) == True:
    fun = getattr(d,chioce)
    a = input("what does the dog want eating ?")
    fun(a)
else:
    setattr(d,chioce,bulk) # 将类外部的函数加入了类的内部
    v = getattr(d,chioce)
    v(d)

  so,什么叫反射?通过字符串来运行或修改程序运行时的状态、属性、方法

  一共有四个方法:

    1.hasattr(obj,str)  obj是对象,str是字符串,判断对象是否有此方法(属性),返回True或False

    2.getattr(obj,str)  obj是对象,str是字符串,返回对象中方法(属性)的内存地址

    3.setattr(x,y,z)     (x,y=z)x是对象,y是字符串,z是方法的内容,设置一个新的方法(属性),或修改方法(属性)

    4.delattr(obj,str)  obj是对象,str是字符串,删除属性(不能删除原有的方法?)

chioce = input("请输入操作:").strip()
setattr(d,chioce,18) # 创建属性并赋值
print(d.talk)
setattr(d,"name","Chen") # 修改已存在的name属性
print(d.name)

delattr(d,"name") # 删除name属性
#print(d.name)  # 报错

# 输入:talk
输出:
18
Chen
Chen is yelling

 四、动态导入模块

  如何使用字符串导入模块呢?

  之前讲过一个方法,使用__import__()内置函数;第二个方法是动态导入模块

  • __import__()内置函数:
'''导入lib包,调用包下aa模块的text()函数'''
b = __import__("lib.aa")
b.aa.text()
"这是解释器内部用的,一般不建议用这个,建议用下面的"
#output:
from lib.aa.text()
  • 动态导入
vimport importlib
c = importlib.import_module("lib.aa")
"导入lib.aa。b 代表 lib.aa "
c.text()
#output:
from lib.aa.text()

五、异常处理

name = ["alex","jack"]
data = {}
try:
    a=5
    f = open("123","r")   #会触发异常Exception,这个包括了所有个异常
    name[3]         # 会触发异常indexError
    data["name"]  # 会触发异常KeyError
except KeyError as e:
    print("没有此信息",e)
except IndexError as e:
    print("列表索引超出范围",e)
except Exception as e:
    print("未知错误",e)
else: # 一切正常的情况下会执行后面的语句
    print("OK")
finally:
    print("不管有没有错误,都会执行的语句") 
#输出:

未知错误 [Errno 2] No such file or directory: '123'
不管有没有错误,都会执行的语句

  上面的输出结果是因为,按照执行的顺序,首先执行打开文件出现异常,后面的语句没有被执行的机会。

  想要一条语句抓住两种错误,可以这样写:

 

try:
    name[3]
    data["name"]
except (KeyError,IndexError) as e:
    print("没有此信息",e)

  能抓住所有错误的写法:

try:
    name[3]
    data["name"]
except Exception as e: # 一劳永逸,无论出现什么错误都会异常处理
    print("出错了",e)

   有一种错误没办法抓住:缩进错误,例如

try:
    name1 = 10
     b = 20
except Exception as e:
    print("错误!")

# output:
 File "F:/Python Files/Learning Log/day7/异常处理.py", line 44
    b = 20
    ^
IndentationError: unexpected indent

断言:

class A(object):
    def __init__(self,name):
        self.name = name
a = A("Alex")
try:
    assert type(a.name) is str # 意为:断定A.name的类型是字符串
except AssertionError:
    print("is not str")

 断言的作用是:可以做一些检查,增强安全性

 

相关文章
|
1月前
|
Java 程序员 C++
Python 面向对象详解!
本文详细介绍了Python中的面向对象编程(OOP),包括类、对象、继承、封装、多态和抽象等核心概念。通过具体示例,解释了如何使用类定义对象的属性和方法,以及如何通过继承实现代码重用。文章还探讨了封装和多态的重要性,并介绍了私有属性和抽象类的使用方法。最后,总结了OOP的四大支柱:封装、抽象、继承和多态,强调了这些概念在Python编程中的应用。适合Java程序员扩展Python编程知识。
62 2
|
18天前
|
Python
Python面向对象(2)
【10月更文挑战第14天】
Python面向对象(2)
|
3月前
|
Python
你真的会面向对象吗!解密Python“魔术方法”
你真的会面向对象吗!解密Python“魔术方法”
37 0
|
19天前
|
设计模式 程序员 C语言
Python面向对象
【10月更文挑战第13天】
Python面向对象
|
5月前
|
Python
Python进阶第一篇(Python的面向对象)
Python进阶第一篇(Python的面向对象)
|
2月前
|
前端开发 Python
Python编程的面向对象有哪些(二)
Python编程的面向对象(二)—类的多态
|
6月前
|
存储 算法 安全
Python编程实验六:面向对象应用
Python编程实验六:面向对象应用
101 1
|
2月前
|
IDE Java 开发工具
Python类与面向对象
Python类与面向对象
|
1月前
|
Python
Python编程-关于面向对象的一些
Python编程-关于面向对象的一些
|
6月前
|
人工智能 自然语言处理 开发者
Python基础教程——面向对象
Python基础教程——面向对象