Python基础—day8-继承多态工厂模式

最新推荐文章于 2023-07-02 09:49:28 发布
最新推荐文章于 2023-07-02 09:49:28 发布
阅读量135 收藏
点赞数
文章标签： python 开发语言 numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42856170/article/details/128311866
版权

文章目录

一、方法没有重载，方法的动态性

1、方法没有重载

#Python 中没有方法的重载。定义多个同名方法，只有最后一个有效
class Person:
    def say_hi(self):
        print("hello")
    def say_hi(self,name):
        print("{0},hello".format(name))
p1 = Person()
p1.say_hi()
p1.say_hi("xiaoxiao")

在这里插入图片描述

2、方法的动态性

class Person:
    def work(self):
        print("努力上班")

def play_game(s):
    print("{0}在玩游戏".format(s))
def work2(s):
    print("努力上班,好好工作，赚大钱")
Person.play = play_game
p = Person()
p.work()
p.play()

Person.work = work2
p.work()

在这里插入图片描述

二、私有属性

1.私有属性

#测试私有属性

class Employee:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

e = Employee("XIAOZHU",18)

print(e.name)
print(e._Employee__age)

三、私有方法

#测试私有方法

class Employee:
    __company = "chenguxyuan"
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __work(self):
        print("好好工作")
        print("年龄：{0}".format(self.__age))
        print(Employee.__company)
e = Employee("XIAOZHU",18)

print(e.name)
print(e._Employee__age)
print(dir(e))

e._Employee__work()
print(Employee._Employee__company)

在这里插入图片描述

四、@property 装饰器

二级标题

class Employee:
    @property
    def salary(self):
        print("salary...")
        return 100000

emp1 = Employee()
print(emp1.salary)




class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary
    def get_salary(self):
        return self.__salary
    def set_salary (self, salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误，应该再1000 到50000之间")
emp1 = Employee("xiaozhu",30000)
print(emp1.get_salary())
emp1.set_salary(-20000) 
print(emp1.get_salary())




class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary
    @property
    def salary(self):
         return  self.__salary
    @salary.setter
    def salary(self,salary):
        if 1000 < salary < 50000:
            self.__salary = salary
        else:
            print("录入错误，应该再1000 到50000之间")

    # def get_salary(self):
    #     return self.__salary
    # def set_salary (self, salary):
    #     if 1000<salary<50000:
    #         self.__salary = salary
    #     else:
    #         print("录入错误，应该再1000 到50000之间")
emp1 = Employee("xiaozhu",30000)
# print(emp1.get_salary())
# emp1.set_salary(-20000)
# print(emp1.get_salary())
print(emp1.salary)
emp1.salary = 2000
print(emp1.salary)

在这里插入图片描述

五、继承

Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
class 子类类名(父类 1[，父类 2，…])：
类体
如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如：new()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
父类名.init(self, 参数列表)

1、简单的继承

class Person:
    pass

class Student(Person):
    pass

print(Student.mro())

在这里插入图片描述

2、继承的基本使用

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("年龄，我也不知道")

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score

print(Student.mro())
s = Student("xiaozhu",18,60)
s.say_age()
print(s.name)
print(s.age)

在这里插入图片描述

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("年龄，我也不知道")

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score

print(Student.mro())
s = Student("xiaozhu",18,60)
s.say_age()
print(s.name)
# print(s.age)
print(s._Person__age)

在这里插入图片描述

3、方法的重写

#测试方法的重写

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("我的年龄：",self.__age)
    def say_introduce(self):
        print("我的名字是{0}".format(self.name))
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score
    def say_introduce(self):
        """重写父类的方法"""
        print("报告老师，我的名字是{0}".format(self.name))
s = Student("xiaozh",18,80)
s.say_age()
s.say_introduce()

4、object 根类


class Person:  #默认继承object类
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return "名字是：{0}".format(self.name)
p = Person("xiaozhu")
print(p)

5、多重继承

不推荐使用

#多重继承
class A:
    def aa(self):
        print("aa")
class B:
    def bb(self):
        print("bb")
class C(B,A):
    def cc(self):
        print("cc")
c = C()
c.cc()
c.bb()
c.aa()

在这里插入图片描述

六、多态

1、多态简单使用

class Man:
    def eat(self):
        print("饿了，吃饭了")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English(Man):
    def eat(self):
        print("英国人用叉子吃饭")


class Indian(Man):
    def eat(self):
        print("印度人用手吃饭")

def manEat(m):
    if isinstance(m,Man):
        m.eat()
    else:
        print("不能吃饭")

manEat(Chinese())
manEat(English())

在这里插入图片描述

七、运算符重载

#测试运算符的重载
class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self, other):
        if isinstance(other,Person):
            return "{0}--{1}".format(self.name,other.name)
        else:
            return "不是同类对象，不能相加"
    def __mul__(self, other):
        if isinstance(other,int):
            return self.name*other
        else:
            return "不是同类对象，不能相乘"
p1 = Person("xiaozhu")
p2 = Person("xiaoxiaozhu")
x = p1 + p2
print(x)
print(p1*3)

在这里插入图片描述

八、特殊属性

class A:
    def aa(self):
        print("aa")
class B:
    def bb(self):
        print("bb")
class C(B,A):
    def __init__(self,nn):
        self.nn = nn
    def cc(self):
        print("cc")
c = C(3)
c.cc()
c.bb()
c.aa()

print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__base__)
print(C.mro())
print(A.__subclasses__())

结果：
[‘class’, ‘delattr’, ‘dict’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘getstate’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘le’, ‘lt’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘aa’, ‘bb’, ‘cc’, ‘nn’]
{‘nn’: 3}
<class ‘main.C’>
<class ‘main.B’>
[<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class ‘object’>]
[<class ‘main.C’>]

九、继承对象的浅拷贝和深拷贝

import copy
class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
        print("算个 12345")
        print("CPU 对象:", self)

class Screen:
    def show(self):
        print("显示一个好看的画面)
        print("屏幕对象：",self)


c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()
n = m #两个变量，但是指向了同一个对象
print(m,n)
m2 = copy.copy(m) #m2 是新拷贝的另一个手机对象
print(m,m2)
m.cpu.calculate()
m2.cpu.calculate() #m2 和 m 拥有了一样的 cpu 对象和 screen 对象
m3 = copy.deepcopy(m)
m3.cpu.calculate() #m3 和 m 拥有不一样的 cpu 对象和 screen对象

结果：
CPU 对象: <main.CPU object at 0x000002A1FCD15F10>
<main.MobilePhone object at 0x000002A1FCD16050> <main.MobilePhone object at 0x000002A1FCD16050>
<main.MobilePhone object at 0x000002A1FCD16050> <main.MobilePhone object at 0x000002A1FCD16210>
计算，算个 12345
CPU 对象: <main.CPU object at 0x000002A1FCD15F10>
计算，算个 12345
CPU 对象: <main.CPU object at 0x000002A1FCD15F10>
计算，算个 12345
CPU 对象: <main.CPU object at 0x000002A1FCD16190>

十、组合

二级标题

#测试组合
class  A1:
    def say_a1(self):
        print("a1,a1,a1")

class B1(A1):
    pass

b1 = B1()
b1.say_a1()

class  A2:
    def say_a2(self):
        print("a2,a2,a2")

class B2:
    def __init__(self,a):
        self.a = a
a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

在这里插入图片描述
“is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有 CPU。 MobilePhone has a CPU。

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
        print("计算，算个 12345")
        print("CPU 对象:", self)

class Screen:
    def show(self):
        print("显示一个好看的画面，亮瞎你的钛合金大眼")
        print("屏幕对象：",self)


c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()
m.screen.show()

在这里插入图片描述

十一、设计模式_工厂模式实现

#测试工厂模式
class CarFactory:
    def create_car(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "宝马":
            return BMW()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌无法创建"

class Benz:
    pass
class BMW:
    pass
class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)

在这里插入图片描述

#单例模式
class MySingleton:
    __obj = None
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self, name):
        if MySingleton.__init_flag:
            print("init....")
            self.name = name
            MySingleton.__init_flag = False
a = MySingleton("aa")
print(a)
b = MySingleton("bb")
print(b)

在这里插入图片描述

总结

育林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python自学教程-02-了解多态.ev4.rar
12-26
Python自学教程-02-了解多态.ev4.rar
Python中的动态继承
weixin_30457551的博客
12-21 764
所谓动态继承，是指代码运行时再决定某个类的父类。某些场景下会用到，比如threading.Thread和multiprocessing.Process这两个类有很多同名的接口，可以实现某个子类动态继承这两个类中的某一个，以便测试多线程或多进程的效率问题。 1：使用工厂函数 def createClass(cls): class CustomizedClass(cls): ...
十一、python中继承和属性动态操作
python自动化学习记录
02-22 524
继承和属性动态操作 私有属性：仅供类的内部使用（不要在外部调用） _单下划线开头：表示这是一个私有属性（没有真正的私有化，外部依然可以调用） __双下划线开头： 表示这是一个私有属性（类外部不可以调用） 私有方法：仅供类的内部使用（不要在外部调用） _单下划线开头：表示这是一个私有方法（没有真正的私有化，外部依然可以调用） __双下划线开头： 表示这是一个私有方法（类外部不可以调用） 实例方法： ​ 1、只能通过对象调用（第一个参数self：代表对象本身）、 ​ 2、...
在 Python 中如何实现类的继承，方法重载及重写？
AI科技大本营
05-27 8579
作者 | 苏凉.py来源 | CSDN博客今天我们将进入类的继承以及对类的方法重写及重载的学习！话不多说直接进入正题！！类的继承如果要编写的类是另一个现成类的特殊版本，那我们就可以使用继承。一个类继承另一个类时，将自动获得另一个类的所有属性和方法，原有的类称为父类，而新的类称为子类，子类继承父类的所有属性和方法，同时还可以定义自己的属性和方法。继承的特点如果在子类中需要父...
python 类的动态继承
qq_24487005的博客
03-29 1110
python类动态继承，是代码运行后，根据条件决定继承某个类。 比如threading.Thread和multiprocessing.Process这两个类有很多同名的接口，可以实现某个子类 动态继承这两个类中的某一个，以便测试多线程或多进程的效率问题。 实现方式： 1、条件判断需要继承的父类 class A: #code for the class A... class B: #code for the class B... class MyClass( A if (condi
工厂方法模式（python）
qq_51179608的博客
12-07 996
工厂方法模式，软件开发必学
Python自学教程-03-体验多态思路分析.ev4.rar
最新发布
12-26
Python自学教程-03-体验多态思路分析.ev4.rar
Python面向对象之继承和多态用法分析
09-19
主要介绍了Python面向对象之继承和多态用法,结合实例形式分析了Python面向对象程序设计中继承与多态的原理及相关操作技巧,需要的朋友可以参考下
Python面向对象编程之继承与多态详解
09-20
主要介绍了Python面向对象编程之继承与多态,结合实例形式详细分析了Python面向对象编程中继承与多态的概念、使用方法及相关注意事项,需要的朋友可以参考下
Python 的类、继承和多态详解
12-23
类的定义 假如要定义一个类 Point，表示二维的坐标点： # point.py class Point: def __init__(self, x=0, y=0): self.x, self.y = x, y 最最基本的就是 __init__ 方法，相当于 C++ / Java 的构造函数。...
Python - 继承(Inheritance) 详解 及 代码
Mystra
03-03 7244
继承(Inheritance) 详解 及 代码 本文地址: http://blog.csdn.net/caroline_wendy/article/details/20357767 继承可以使代码重用, 是类型和子类型的关系; Python中, 继承是在类名的括号中填入继承的基类, 即class DerivedClass(BaseClass): 基类初始化需要使用self变量, 即BaseClass.__init__(
python继承父类属性_python继承和动态属性
weixin_39588104的博客
12-03 703
一、私有属性私有属性： __开头或者_开头，即双下划线开头的叫做私有属性，不能再类外部使用，只能在类里面使用私有方法：__开头或者_开头注意点：以后看到_下划线开头的属性或者方法，都不要去动或者使用classSOS:attr= 100_attr= 222 #这是单下划线，在外部访问，但是不要在类外部使用__attr = 999 #这是双下划线，强制拒绝外部访问print(SOS.attr) ...
类的继承python事例_Python动态继承：如何在创建实例时选择基类？
weixin_39944595的博客
12-09 152
IntroductionI have encountered an interesting case in my programming job that requires me to implement a mechanism of dynamic class inheritance in python. What I mean when using the term "dynamic inhe...
python继承方案_python中的动态调度和继承
weixin_40007668的博客
12-13 87
我正在尝试修改Guido的多方法(动态调度代码)：处理继承和可能的乱序参数.例如(继承问题)class A(object):passclass B(A):pass@multimethod(A,A)def foo(arg1,arg2):print 'works'foo(A(),A()) #worksfoo(A(),B()) #fails有没有比迭代检查每个项目的super()更好的方法,直到找到一个...
2020年6月8日---python类的继承，多态和动态属性设置
henry_rhy的博客
06-09 383
# ================================ # -*- coding:utf-8 -*- # @Author：henry # @Time：2020/6/8 17:09 # Email：[email protected] # @File: 2020-06-08python类的继承，多态和动态属性设置.py # ================================= """ 实例方法 必须掌握 类方法 单元测试用的多 静态方法 基本不用 """ #
Python动态继承类的方法
weixin_43343144的博客
12-24 1462
参考：https://www.cnblogs.com/gqtcgq/p/8081210.html """ Python创建动态继承类的方法 """ class A: pass def test(A): class Test001(A): def __init__(self): print("创建一个类") re...
Python 之继承详解
一直努力
08-07 2093
继承详解 一、面向对象OPP（Object Oriented Programming） 1.1、什么是面向对象 Python中万物皆对象 面向对象是一种对现实世界理解和抽象的方法 面向对象的方法：封装、继承、多态 1.2、对象的基本概念 对象： 对象是存在的具体实体，具有明确定义的状态（属性）和行为（方法） 1.3、类 基本概念： 具有相同属性的方法和方法的一组对象的集合 类是对象的模板/图纸，可以规定对象的特征（属性和方法） 例：老师类、学生类、玩家类、管理员类 等等 1.4、类和对象的关系 类是抽象的概
「python」继承
LFSenior
09-07 510
继承 继承示例 # 定义一个父类，如下: class Cat(object): def __init__(self, name, color="白色"): self.name = name self.color = color def run(self): print("%s--在跑"%self.name) # 定义一
python中继承
初遇我ㄖ寸の热情呢？
07-02 1676
继承： 1.继承关系可以是多个父类 注意点，子类初始化方法里面，需要调用父类的初始化方法 class NorthTiger(Tiger): color = “yellow white” def init(self,weight): Tiger.init(self.weight) 可以把继承关系继续下去 ...
Python 中封装，继承，多态面试
05-23
好的，下面是关于Python中封装、继承和多态的面试题： 1. 什么是封装？如何实现？ 封装是面向对象编程中的一种重要概念，它指的是将数据和方法包装在类中，对外部世界隐藏类的内部细节，从而提高了代码的安全性和可维护性。在Python中，可以通过将属性设置为私有属性，并提供公有的访问方法来实现封装。 2. 什么是继承？如何实现？ 继承是面向对象编程中的一种重要机制，它指的是一个类可以通过继承另一个类的属性和方法来扩展自己。在Python中，可以通过在类定义中指定要继承的父类来实现继承。 3. 什么是多态？如何实现？ 多态是面向对象编程中的一种重要特性，它指的是同一个方法可以被不同的对象调用，产生不同的结果。在Python中，可以通过方法重写和方法重载来实现多态。方法重写指的是子类重写父类的方法，从而实现不同的功能；方法重载指的是在同一个类中定义多个同名方法，但参数类型和个数不同，调用时编译器会根据实际参数类型和个数选择调用哪个方法。 4. 在Python中如何实现接口？ 在Python中，没有像Java和C#等语言中的接口概念。但是可以通过抽象基类（Abstract Base Class，简称ABC）来实现类似于接口的功能。ABC是Python中的一种特殊类，它不能被实例化，只能被继承，子类必须实现指定的抽象方法，从而保证了程序的正确性和可维护性。 以上就是关于Python中封装、继承和多态的面试题，希望能对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值