python基础知识-第8节

于 2021-05-09 22:27:17 发布
阅读量141 收藏
点赞数
分类专栏： python基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w1015601709/article/details/116567723
版权

文章目录

1.方法没有重载

定义多个同名方法，只有最后一个有效

#测试方法的动态性

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()

2.私有属性、私有方法的使用

#测试私有属性/私有方法
class Employee:
    __company = "百战程序员"
    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("高琪",18)

print(e.name)
# print(e.age)        #私有属性访问不了
print(e._Employee__age)
print(dir(e))
e._Employee__work()
print(Employee._Employee__company)

3. @property装饰器、get、set方法

#测试@property的用法
class Employee:
    @property
    def salary(self):
        print("salary run……")
        return 10000
emp1 = Employee()
emp1.salary()
print(emp1.salary)

#测试@property的用法
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("高琪",30000)
print(emp1.get_salary())
emp1.set_salary(2000)
print(emp1.get_salary())

#测试@property的用法

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这个范围")

emp1 = Employee("高琪",30000)
print(emp1.salary)
emp1.salary = 2000
print(emp1.salary)

4. 封装、继承、多态

4.1 封装

隐藏对象的属性和实现细节，只对外提供必要的方法
python通过“私有属性、私有方法”的方法，实现封装。

4.2 继承

继承可以让子类具有父类的特性，提高代码的重用性
“父类”或“基类”不变时，可以改变“子类”或者“派生类”
代码复用的重要手段
python一个子类可以继承多个父类
class 子类类名（父类1【父类2，……】）
如果没有制定父类，则默认父类是object类，object是所有类的父类

#测试继承的基本使用
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

#Student-->Person-->object类
print(Student.mro())        #打印 类 的层次

s = Student("高琪",18,60)
s.say_age()
print(s.name)
print(dir(s))
print(s._Person__age)

子类继承父类除了构造方法之外的所有成员
子类可以重新定义父类中的方法

#测试方法的重写
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("高琪",18,60)
s.say_age()
s.say_introduce()

dir()可以用来查看所有类的属性
重写__str__()方法

#测试重写object的__str__()
class Person:

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

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

p = Person("高琪")
print(p)

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

#多重继承
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(A,B):
    def cc(self):
        print("cc")

c = C()
c.aa()
print(C.mro())      #打印类的层次结构
c.say()     #解释器寻找方法是“从左到右”的方式寻找，此时会执行A中的say

super（）获得父类的定义

#测试super（），代表父类的定义，而不是父类的对象
class A:

    def say(self):
        print("A：",self)

class B(A):

    def say(self):
        #A.say(self)
        super().say()		#与A.say(self)类似，指代父类的say()
        print("B：",self)

B().say()

4.3 多态

多态是指同一个方法调用由于对象不同产生不同的行为。

#多态
class Man:
    def eat(self):
        print("饿了吃饭啦")

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

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

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

def manEat(m):
    if isinstance(m,Man):
        m.eat()         #多态，一个方法调用，根据对象不同调用不同的方法！
    else:
        print("不能吃饭")

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

4.4 特殊方法和运算符重载

#测试运算符的重载
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("高琪")
p2 = Person("高小一")

x = p1+p2
print(x)
print(p1*3)

4.5 特殊属性

在这里插入图片描述

5. 浅复制和深复制的内存分析

#测试对象的浅拷贝、深拷贝
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("screen对象：",self)

#测试变量幅值
c1 = CPU()
c2 = c1
print(c1)
print(c2)

#测试浅复制
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)

print("测试浅复制")
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

#测试深复制
m3 = copy.deepcopy(m1)

print("测试深复制")
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

6. 组合

“is_a"关系可以使用继承，如：狗是动物
“has_a"关系可以使用组合，如：手机拥有CPU

#测试组合
#使用继承实现代码的复用
class A1:
    def say_a1(self):
        print("a1")

class B1(A1):
    pass

b1 =B1()
b1.say_a1()
#同样效果，使用组合实现代码的复用
class A2:
    def say_a2(self):
        print("a2")

class B2:
    def __init__(self,a):
        self.a = a

a2 =A2()
b2 = B2(a2)
b2.a.say_a2()

#测试has—a关系，使用组合
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("screen对象：",self)

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

6. 工厂模式的实现

设计模式比较流行的是GOF( Goup of Four ) 23种设计模式
初学者常用的模式：工厂模式和单例模式
工程模式可以实现创建者和调用者的分离，使用专门的工厂类将实现类、创造对象进行统一的管理和控制
单例模式确保一个类只有一个实例对象，并提供一个访问该实例的全局访问点。用来降低系统开销。

#测试工厂模式
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")
b = MySingleton("bb")
print(a)
print(b)

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

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.__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)
'''运行结果
init……
<__main__.Benz object at 0x000001C4865EE8C8>
<__main__.BYD object at 0x000001C4865EE888>
<__main__.CarFactory object at 0x000001C4865EE848>
<__main__.CarFactory object at 0x000001C4865EE848>
'''
丑大王
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值