Python(8)面向对象、设计模式_工厂模式_单例模式

最新推荐文章于 2024-07-27 12:20:46 发布
最新推荐文章于 2024-07-27 12:20:46 发布
阅读量204 收藏
点赞数
分类专栏： Python基础知识 文章标签： python 设计模式 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuan_in/article/details/115263711
版权

文章目录

方法没有重载

在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含 3 个部分：方法名、参数数量、参数类型。
Python 中，方法的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式， 相当于实现了其他语言中的方法的重载。 如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。 建议：不要使用重名的方法！Python 中方法没有重载。

class person:
	def say_hi(self):
		print("hello")
	def say_hi(self,name):
		print("hello {0}".format(self.name))

a=person
#a.say_hi()#不带参，报错：TypeError: say_hi() missing 1 required positional argument: 'name' 。因为重名时只有最后一个方法有效
a.say_hi(“yibo”)
'''result:
hello yibo
'''

方法的动态性

Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

class Person:

    def work(self,name):
        print("{0}努力学习！".format(name))



def play_game(s):
    print("{0}在玩游戏".format(s))

def work2(aa):
    print("好好工作")

#######
Person.play = play_game  #假设play_game的id是123，现在将123赋给Person下的play属性。通过Person.play引用123这个地址，从而可以调用对应的函数方法
print(dir(Person)) #打印类对象Person的所有属性和方法
#######
p = Person() #p是实例对象！！
pp=Person  #pp是类对象！！
print("p的类型：{0},pp的类型：{1},Person的类型：{2}".format(type(p),type(pp),type(Person)))
######
print(p)
p.work('我')
p.play() #解释器翻译为Person.play(p).将p作为参数传给play方法。Person.play和play_game是同一个对象，这个p传给了s

Person.work = work2 #将work2给了Person类下面的work方法，修改了类方法
p.work()

'''result:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'play', 'work']
p的类型：<class '__main__.Person'>,pp的类型：<class 'type'>,Person的类型：<class 'type'>
<__main__.Person object at 0x000001FE38FAA3C8>
我努力学习！
<__main__.Person object at 0x000001FE38FAA3C8>在玩游戏
好好工作
'''

我们可以看到，Person 动态的新增了 play_game 方法(属性？)，以及用 work2 替换了 work 方法。

私有属性和私有方法(实现封装)

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点： 1. 通常我们约定，两个下划线开头的属性（方法）是私有的(private)。其他为公共的(public)。 2. 类内部可以访问私有属性(方法) 3. 类外部不能直接访问私有属性(方法) 4. 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)
【注】**方法本质上也是属性！只不过是可以通过()执行而已。**所以，此处讲的私有属性和公有属性，也同时讲解了私有方法和公有方法的用法。

class person:

    def __init__(self,name,age):
        self.NAME=name #公有属性
        self.AGE=age #公有属性

a=person("yuan",18)
print(a.NAME)
print(a.AGE)
'''result:
yuan
18
'''

class person:

    def __init__(self,name,age):
        self.NAME=name #公有属性
        self.__AGE=age #私有属性

a=person("yuan",18)
print(a.NAME)
print(a.__AGE) #无法访问私有的属性，print(a.AGE)也无法访问私有属性
'''result:
yuan
Traceback (most recent call last):
  File "C:/Users/Ranio/Desktop/ceshi.py", line 9, in <module>
    print(a.AGE)
AttributeError: 'person' object has no attribute '__AGE'
'''

class person:

    def __init__(self,name,age):
        self.NAME=name #公有属性
        self.__AGE=age #私有属性

a=person("yuan",18)
print(a.NAME)
print(a._person__AGE) #可以访问私有属性
print(dir(a))
'''result:
yuan
18
['NAME', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_person__AGE']
#a._person__AGE之所以可以访问私有属性，是因为私有属性就是这样存储的。而公有属性NAME就是存储为“NAME”，所以直接通过a.NAME即可访问

'''

class person:
    __company="公司" #私有的类属性
    def __init__(self,name,age):
        self.NAME=name #公有实例属性
        self.__AGE=age #私有实例属性
    def __work(self): #私有实例方法
        print("好好学习")
        print("age:{0}".format(self.__AGE))#在类内部可以这样调用私有实例属性
        #print("age:{0}".format(self._person__AGE))这样也可以调用私有实例属性
        print(person.__company)#在类内部可以这样调用私有类属性
        #print(person._person__company)#这样也可以调用私有类属性
a=person("yuan",18)
print(a.NAME) #外部调用公有属性
print(a._person__AGE)#外部调用私有属性
print(dir(a))
#a.work() #调用公有方法
a._person__work()#外部调用私有方法
print("%%%%%%%%%")
print(person._person__company)#外部调用私有类属性

'''result:
yuan
18
['NAME', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_person__AGE', '_person__company', '_person__work']
好好学习
age:18
公司
%%%%%%%%%
公司
'''

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。

#测试@property的最简化的使用
class Employee:

    @property
    def salary(self):
        print("salary run...")
        return 30000

emp1 = Employee() #创建实例对象
#emp1.salary()#加了@property后这样调用实例方法报错'int' object is not callable
emp1.salary#加了@property后就可以像调用属性一样调用方法
print("%%%%")
print(type(emp1.salary))

emp1.salary=40000#@property 修饰的属性，如果没有加 setter 方法，则为只读属性。不能直接修改
'''result：
Traceback (most recent call last):
  File "C:/Users/Ranio/Downloads/Python/mypro_obj/myoo_05_5.py", line 16, in <module>
    emp1.salary=40000
AttributeError: can't set attribute
salary run...
%%%%
salary run...
<class 'int'>

'''

不使用装饰器也可以完成salary的读和写：

class person:
    def __init__(self,a,b):
        self.__name=a #私有实例属性
        self.__salary=b#私有实例属性

    def get_salary(self):
        print(self.__salary)

    def set_salary(self,money):
        if money>0:
            self.__salary=money
            print(self.__salary)
        else:
            print('输入错误，请输入大于0的数字')

sss=person("yuan",20000)
sss.get_salary()
sss.set_salary(30000)
#sss.set_salary(-1)
'''result:
20000
30000
输入错误，请输入大于0的数字
'''

使用装饰器的进行salary的读和写

class person:
    def __init__(self,a,b):
        self.__name=a
        self.__salary=b
    @property # 将money()方法转化成同名只读属性.与 getter 方法一样
    def money(self):
        print(self.__salary)

    @money.setter#money这个名字要和@property下的一样。#相当于money属性的 setter 方法
    def money(self,s):
        if s>0:
            self.__salary=s
            print(self.__salary)
        else:
            print("输入错误，请输入大于0的数字")

a=person("yuan",20000)
a.money#使用了装饰器@property后，方法可以i选哪个属性一样调用。这里就是调用@property下面的money来获得salary的值
a.money=30000 #使用了@money.setter后可以直接修改
a.money=-1
'''result:
20000
30000
输入错误，请输入大于0的数字
'''

面向对象进阶

面向对象的三大特征

Python 是面向对象的语言，也支持面向对象编程的三大特性：封装（隐藏）、继承、多态。 ·
封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。 通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python 追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。
继承
继承可以让子类具有父类的特性，提高了代码的重用性。 从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆 是：同样是休息方法，人不同休息方法不同。

继承

继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。 如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。子类继承了父类除构造方法之外的所有成员（属性、方法）。

语法格式

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

class Student(Person):

    def __init__(self,name,age,score): #子类构造方法。
        Person.__init__(self,name,age) #子类构造函数中包含调用父类构造函数__init__()的显示表达。根据需要，不是必须。 子类并不会自动调用父类的__init__()，如果需要调用必须显式的调用它
        self.score = score


#Student-->Person-->object类
print(Student.mro())

s = Student("yuan",18,97)
s.say_age() #继承了父类的方法
print(s.name)#继承了父类的属性
#print(s.age) #这样无法调用私有属性
print(dir(s))
print(s._Person__age) #可以调用父类的私有属性
'''result:
[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
%%%%%%%%%%%%
yuan
['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']
18
'''

方法重写

子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

#测试方法的重写

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("yuan",18,97)
s.say_age()
s.say_introduce()
'''result:
我的年龄: 18
报告老师，我的名字是：yuan
'''

查看类的继承层次结构

通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。

class a:
    pass
class b(a):
    pass
class c(b):
    pass

print(c.mro())
print(c.__mro__)
'''result:
[<class '__main__.c'>, <class '__main__.b'>, <class '__main__.a'>, <class 'object'>]
(<class '__main__.c'>, <class '__main__.b'>, <class '__main__.a'>, <class 'object'>)
'''

object 根类与dir()

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。我们显然有必要深入研究一下 object 类的结构。对于我们继续深入学习 Python 很有好处。为了深入学习对象，我们先学习内置函数 dir()，它可以让我们方便的看到指定对象所有的属性

class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_age(self):
        print(self.say_age())

obj=object()
print(dir(obj))
s2 = person("yuan",18) 
print(dir(s2))
'''result:
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']


['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'say_age']

'''

从上面我们可以发现这样几个要点：

  1. person 对象增加了六个属性： dict module weakref age name say_age
  2. object 的所有属性，person 类作为 object 的子类，显然包含了所有的属性。
  3. 我们打印 age、name、say_age，发现 say_age 虽然是方法，实际上也是属性。只不过， 这个属性的类型是“method”而已。

age <class ‘int’>
name <class ‘str’>
say_age <class ‘method’>

重写object 的__str__()方法

object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str() 经常用于 print()方法，帮助我们查看对象的信息。str()可以重写。

#测试重写object的__str__()

class Person:       #默认继承object类

    def __init__(self,name):
        self.name = name
p = Person("yuan")
print(p)
'''result:
<__main__.Person object at 0x000002BCB34FE808>
'''

class Person:       #默认继承object类

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return "名字是：{0}".format(self.name)

p = Person("yuan")
print(p)
'''result:
名字是：yuan
'''

多重继承

Python 支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用.

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()
'''result:
cc
bb
aa
'''

MRO()

Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将 “从左向右”按顺序搜索。 MRO（Method Resolution Order）：方法解析顺序。 我们可以通过 mro()方法获得 “类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

class A:
    def aa(self):
        print("aa")

    def say(self):
        print("say AAA!")

class B:
    def bb(self):
        print("bb")

    def say(self):
        print("say BBB!")
class C(B,A):
    def cc(self):
        print("cc")

c = C()
print(C.mro()) #打印类的层次结构
print(C.__mro__)#打印类的层次结构
c.say()                 #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()
'''result:
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
say BBB!
'''

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。
super()代表父类的定义，不是父类对象。

#测试super()，代表父类的定义，而不是父类的对象

class A:

    def say(self):
        print("AAA")

class B(A):

    def say(self):
        #A.say(self) #调用父类的 say 方法
        super().say()#通过 super()调用父类的方法
        print("BBB")
        
B().say()
'''result:
AAA
BBB
'''

多态

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。在现实生活中，我们有很多例子。比如：同样是调用人的休息方法，张三的休息是睡觉，李四的休 息是玩游戏
关于多态要注意以下 2 点：

  1. 多态是方法的多态，属性没有多态。
  2. 多态的存在有 2 个必要条件：继承、方法重写。
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())
'''result:
中国人用筷子吃饭
英国人用叉子吃饭
'''

特殊方法和运算符重载

Python 的运算符实际上是通过调用对象的特殊方法实现的。
e.g.: c = a+b实际上是a.add(b) 。
常见的特殊方法统计如下：
在这里插入图片描述
每个运算符实际上都对应了相应的方法，统计如下：
在这里插入图片描述
在这里插入图片描述
我们可以重写上面的特殊方法，即实现了“运算符的重载”。

#测试运算符的重载
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) #这里之所以能写other.name是因为这个判断条件已经确认other是Person类的，所以这个other是有name属性的
        else:
            return "不是同类对象，不能相加"

    def __mul__(self, other):
        if isinstance(other,int):
            return  self.name*other
        else:
            return "不是同类对象，不能相乘"

p1 = Person("yi")#实例对象的p1的name属性是yi
p2 = Person("bo")#实例对象的p2的name属性是bo
#上面两步的主要作用是为了让p1和p2都是Person类的，从而达到if的条件，能够相加
x = p1 + p2 #实际上是p1.__add__(p2)，即p1调用__add__方法，p1是self。p2作为__add__()的参数传给other
print(x)
print(p1*3)
'''result:
yi--bo
yiyiyi
'''

特殊属性

Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这 里我们列出常见的特殊属性：
在这里插入图片描述

class A:
    pass

class B:
    pass

class C(B,A):

    def __init__(self,nn):
        self.nn = nn

    def cc(self):
        print("cc")

c = C(3)

print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())
'''result:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cc', 'nn']
{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]
'''

对象的浅拷贝和深拷贝

·变量的赋值操作 只是形成两个变量，实际还是指向同一个对象。
·浅拷贝Python 拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象 和拷贝对象会引用同一个子对象。
·深拷贝使用 copy 模块的 deepcopy 函数，递归拷贝对象中包含的子对象。源对象和拷贝对象 所有的子对象也不同。

import copy

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("计算")
        print("cpu对象：",self)

class Screen:
    def show(self):
        print("显示一个好看的画面")
        print("screen对象：",self)
#测试变量赋值
c1 = CPU()
c2 = c1
print(c1)
print(c2)
print("测试浅复制....")
#测试浅复制
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)
#测试深复制
print("测试深复制....")
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)
'''result:
<__main__.CPU object at 0x0000025C09F4A708>
<__main__.CPU object at 0x0000025C09F4A708>
测试浅复制....
<__main__.MobilePhone object at 0x0000025C09F4A748> <__main__.CPU object at 0x0000025C09F4A708> <__main__.Screen object at 0x0000025C09F4A848>
<__main__.MobilePhone object at 0x0000025C09F4AF48> <__main__.CPU object at 0x0000025C09F4A708> <__main__.Screen object at 0x0000025C09F4A848>
测试深复制....
<__main__.MobilePhone object at 0x0000025C09F4A748> <__main__.CPU object at 0x0000025C09F4A708> <__main__.Screen object at 0x0000025C09F4A848>
<__main__.MobilePhone object at 0x0000025C09F4A7C8> <__main__.CPU object at 0x0000025C09F4AF88> <__main__.Screen object at 0x0000025C09F60588>
'''

组合

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

测试组合

#使用继承实现代码的复用
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()
'''result:
a1,a1,a1
a2,a2,a2
'''

#测试has-a关系，使用组合

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen


class CPU:
    def calculate(self):
        print("计算")
        print("cpu对象：",self)

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


m = MobilePhone(CPU(),Screen())
m.cpu.calculate()
m.screen.show()
'''result:
计算
cpu对象： <__main__.CPU object at 0x0000020FC0DFA408>
显示一个好看的画面
screen对象： <__main__.Screen object at 0x0000020FC0DFA4C8>
'''

设计模式_工厂模式实现

设计模式是面向对象语言特有的内容，是我们在面临某一类问题时候固定的做法，设计 模式有很多种，比较流行的是：GOF（Goup Of Four）23 种设计模式。当然，我们没有必要全部学习，学习几个常用的即可。 对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

class CarFactory:
    def creatcar(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.creatcar("奔驰")
c2=factory.creatcar("宝马")
c3=factory.creatcar("迈巴赫")
print(c1)
print(c2)
print(c3)
'''result:
<__main__.Benz object at 0x00000222FA4B9488>
<__main__.BMW object at 0x00000222FA4B94C8>
未知品牌，无法创建
'''

设计模式_单例模式实现

单例模式（Singleton Pattern)的核心作用是确保一个类只有一个实例，并且提供一 个访问该实例的全局访问点。 单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久驻留内存中，从而极大的降低开销。 单例模式有多种实现的方式，我们这里推荐重写__new__()的方法。

#测试单例模式
#定义单例时，通常需要重写__new__()和__init__()方法
class MySingleton:

    __obj = None           #类属性
    __init_flag = True

    def __new__(cls, *args, **kwargs): #cls是当前的类对象
        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")
b = MySingleton("bb")
print(a)
print(b)
c = MySingleton("cc")
print(c)
'''result:
init.....
<__main__.MySingleton object at 0x00000177CDF18448>
<__main__.MySingleton object at 0x00000177CDF18448>
<__main__.MySingleton object at 0x00000177CDF18448>
'''

设计模式称之为“模式”，就是一些固定的套路。我们很容易用到其他场景上，比如前面讲 的工厂模式，我们需要将工厂类定义成“单例”，只需要简单的套用即可实现：

#测试工厂模式和单例模式的整合使用

class CarFactory:
    __obj = None           #类属性
    __init_flag = True


    def create_car(self,brand):
        if brand =="奔驰":
            return Benz()
        elif brand =="宝马":
            return BMW()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌，无法创建"


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

        return cls.__obj

    def __init__(self):
        if CarFactory.__init_flag:
            print("init CarFactory....")
            CarFactory.__init_flag = False

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

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

factory2 = CarFactory()
print(factory)
print(factory2)
'''result:
init CarFactory....
<__main__.Benz object at 0x00000147A30CA608>
<__main__.BYD object at 0x00000147A30CA5C8>
<__main__.CarFactory object at 0x00000147A30CA588>
<__main__.CarFactory object at 0x00000147A30CA588>

'''
yyuan_in
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 程序语言设计模式思路-创建型模式：单例模式，确保一个类的唯一实例（装饰器）面向对象编程、继承
05-21
单例模式（Singleton Pattern）作为创建型模式中的一种，旨在确保一个类在系统中只有一个实例，并提供全局访问点。
Python编程 -设计模式-从入门到实践
03-14
当我们谈论“Python编程 - 设计模式 - 从入门到实践”时，这意味着我们将探讨如何在Python编程中应用这些模式来提高软件开发的效率和质量。 首先，让我们理解什么是设计模式。设计模式并不特定于任何一种编程语言，...
python工厂模式_python设计模式之工厂模式
weixin_39538687的博客
11-30 109
一.理解工厂模式在面向对象编程中，术语“工厂”表示一个负责创建替他类型对象的类。通常情况下，作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法，之后，工厂会据此创建所需类型的对象，然后将它们返回给客户端。简单理解：工厂模式依然是一种创建型设计模式，作为工厂，它所关心的是产品的产生，也就是对象的创建，我们利用工厂来创建对象，而不必我们亲自创建对象，我们无需去理解如何创建对...
python 工厂模式
人生苦短，何妨一试
11-27 600
设计模式_工厂模式实现 设计模式是面向对象语言特有的内容； 常用模式：工厂模式和单例模式 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类，创建对象进行统一管理和控制 class School: def Student(self,child): if child == '男孩': return Scientist() elif child == '男青年': re...
Python23.1_面向对象之解耦实例（简单工厂模式与工厂方法模式）
qq_34873298的博客
05-28 365
需求：设计4s店 class CarStore(object): def order(self, car_type): if car_type == "索拉塔": return Suonata() elif car_type == "名图": return Mingtu() elif car_t...
【二】python工厂模式
勿忘初心方得始终
01-06 4040
在面向对象编程中，术语“工厂”表示一个负责创建替他类型对象的类。通常情况下，作为一个工厂的类有一个对象以及与它关联的多个方法。客户端使用某些参数调用此方法，之后，工厂会据此创建所需类型的对象，然后将它们返回给客户端。工厂模式在实际的应用场景举例：假如有一个消息通知的功能，需要实现根据不同的消息内容发送到邮件、微信等渠道。我们就可以利用工厂模式来进行解耦，以后如果新增了短信等其他通知方式，就可以轻松应对，对原有代码侵入较低，可以方便的进行扩展功能。
python中类的输出或类的实例输出为__main__类名 object at xxxx这种形式的原因
12-26
原因： __str__（）这个特殊方法将对象转换为字符串的结果 效果图： 代码：　 # 定义一个Person类 class Person(object): """人类""" def __init__(self, name , age): self.name = name self.age = age p = Person(‘小黑‘,18) print(p) print(‘\n\n\n\n\n‘) # 定义一个Person类 class Person(object): """人类""" def __init__(self, name , age): s
python面向对象设计模式_python面向对象之设计模式
weixin_39643255的博客
12-05 107
单例模式意图 单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。适用性当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。#coding=utf-8classSingleton(object):def__new__(cls,*args,**kw):#new的cls放前面ifno...
【Python高阶技巧】设计模式（单例模式、工厂模式）
咖喱年糕的博客
12-27 1016
什么是设计模式设计模式就是一种编程套路。使用特定的套路得到特定的效果什么是单例设计模式单例模式就是对一个类，只获取其唯一的类实例对象，持续复用它。节省内存节省创建对象的开销什么是工厂模式将对象的创建由使用原生类本身创建，转换到由特定的工厂方法来创建用工厂模式好处大批量创建对象的时候有统一的入口，易于代码维护当发生修改，仅修改工厂类的创建方法即可符合现实世界的模式，即由工厂来制作产品(对象)
举例讲解Python设计模式编程中对抽象工厂模式的运用
12-24
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 优点：易于交换“产品系列”，只要更改相应的工厂即可。 缺点：建立产品的时候很繁琐，需要增加和修改很多东西。 优化1：为了...
Python的设计模式学习案例
05-27
在Python中，这些模式可以通过面向对象特性如继承、封装和多态来实现。例如，单例模式可以通过装饰器实现，而工厂模式则可以利用类的动态性。通过深入理解和应用这些设计模式，开发者可以写出更加灵活、可扩展和易于...
python单例模式.zip_图形图像处理_Python_
08-09
在Python中，虽然面向对象的特性使得单例模式的应用不如其他语言那么必要，但在某些场景下，如管理共享资源、全局配置或GUI编程中，单例模式仍然有其价值。 Python GUI编程，即使用Python进行图形用户界面的开发，...
设计模式之抽象工厂模式以及与工厂模式区别
Eamon
11-10 2921
文章目录定义举个栗子抽象工厂模式的优点抽象工厂模式的缺点简单工厂、工厂模式、抽象工厂小结简单工厂工厂方法模式抽象工厂模式 Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 定义 为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。 相信挺多人第一次看到这个定义都有点懵，这都什么和什么。那么通过一个案
linux python modules,PYTHON模块modules
weixin_42525385的博客
05-15 224
一个module不过是一些函数，class放在一个文件中。例如：在当期目录中创建了一个文件叫testmodule.py:"""this only is a very simple test module"""age=0 # a sample attributedef sayHello(): # a sample function in a moduleprint "Hello"if __name_...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
最新发布
qq_64603703的博客
07-27 648
详细解说数据分析pandas库中的常用方法
随机数种子的作用
帆的博客
07-23 1289
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 759
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 463
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
安卓手机部署大模型实战
奇舞周刊
07-25 608
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
面向对象设计模式：复用与编程高手的基石
在面向对象编程中，设计模式通常分为创建型、结构型和行为型三大类，例如单例模式、工厂模式、适配器模式、装饰者模式、策略模式等。这些模式不仅提高了代码的灵活性，还增强了软件的可维护性和扩展性。 面向对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值