python面向对象:组合、封装、property装饰器、多态

一、组合
二、封装
三、property装饰器
四、多态

一、组合

‘‘‘
1. 什么是组合
    一个对象的属性是来自于另外一个类的对象,称之为组合

2. 为何用组合
    组合也是用来解决类与类代码冗余的问题

3. 如何用组合

‘‘‘
# class Foo:
#     aaa=1111
#     def __init__(self,x,y):
#         self.x=x
#         self.y=y
#
#     def func1(self):
#         print(‘Foo内的功能‘)
#
#
# class Bar:
#     bbb=2222
#     def __init__(self, m, n):
#         self.m = m
#         self.n = n
#
#     def func2(self):
#         print(‘Bar内的功能‘)
#
# obj1=Foo(10,20)
# obj2=Bar(30,40)
#
# obj1.xxx=obj2
#
#
# print(obj1.x,obj1.y,obj1.aaa,obj1.func1)
# print(obj1.xxx.m,obj1.xxx.n,obj1.xxx.bbb,obj1.xxx.func2)

# class OldboyPeople:
#     school = ‘Oldboy‘
#     def __init__(self, name, age, gender,course_name,course_price,course_period):
#         self.name = name
#         self.age = age
#         self.gender = gender
#         self.course_name = course_name
#         self.course_price = course_price
#         self.course_period = course_period
#
# class OldboyStudent(OldboyPeople):

#     def choose_course(self):
#         print(‘%s is choosing course‘ %self.name)
#
# class OldboyTeacher(OldboyPeople):
#     def __init__(self, name, age, gender,level,salary,course_name,course_price,course_period):
#         OldboyPeople.__init__(self, name, age, gender)
#         self.level=level
#         self.salary=salary
#
#
#     def score(self,stu,num):
#         stu.num=num
#         print(‘老师%s给学生%s打分%s‘ %(self.name,stu.name,num))
#
#
# stu1=OldboyStudent(‘egon‘,18,‘male‘,‘Python开发‘,3000,‘5mons‘)
# stu2=OldboyStudent(‘kevin‘,38,‘male‘,‘Python开发‘,3000,‘5mons‘)
#
#
# def tell_course(obj):
#     print(‘课程名:<%s> 价钱:[%s] 周期:[%s]‘ %(obj.course_name,obj.course_price,obj.course_period))
#
# tell_course(stu1)
# tell_course(stu2)

class OldboyPeople:
    school = ‘Oldboy‘
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class OldboyStudent(OldboyPeople):
    def choose_course(self):
        print(‘%s is choosing course‘ %self.name)

class OldboyTeacher(OldboyPeople):
    def __init__(self, name, age, gender,level,salary):
        OldboyPeople.__init__(self, name, age, gender)
        self.level=level
        self.salary=salary

    def score(self,stu,num):
        stu.num=num
        print(‘老师%s给学生%s 打分%s‘ %(self.name,stu.name,num))

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name=course_name
        self.course_price=course_price
        self.course_period=course_period

    def tell_course(self):
        print(‘课程名:<%s> 价钱:[%s] 周期:[%s]‘ % (self.course_name, self.course_price, self.course_period))

python_obj=Course(‘python开发‘,3000,‘5mons‘)
linux_obj=Course(‘linux运维‘,5000,‘3mons‘)

stu1=OldboyStudent(‘egon‘,18,‘male‘)
stu1.courses=[]
stu1.courses.append(linux_obj)
stu1.courses.append(python_obj)
stu1.courses[0].tell_course()

stu2=OldboyStudent(‘kevin‘,38,‘male‘)

二、封装

‘‘‘
1. 什么是封装
    装指的是把属性装进一个容器
    封指的是隐藏的意思,但是这种隐藏式对外不对内的

2. 为何要封装
    封装不是单纯意义的隐藏
    封装数据属性的目的:将数据属性封装起来,类外部的使用就无法直接操作该数据属性了
        需要类内部开一个接口给使用者,类的设计者可以在接口之上附加任意逻辑,从而严格
        控制使用者对属性的操作
    封装函数属性的目的:隔离复杂度

3. 如何封装
    只需要在属性前加上__开头,该属性就会被隐藏起来,该隐藏具备的特点:
        1. 只是一种语法意义上的变形,即__开头的属性会在检测语法时发生变形_类名__属性名
        2. 这种隐藏式对外不对内的,因为在类内部检测语法时所有的代码统一都发生的变形
        3. 这种变形只在检测语法时发生一次,在类定义之后新增的__开头的属性并不会发生变形
        4. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头
‘‘‘
class Foo:
    __x=111 #_Foo__x
    def __init__(self,m,n):
        self.__m=m # self._Foo__m=m
        self.n=n

    def __func(self): #_Foo__func
        print(‘Foo.func‘)

    def func1(self):
        print(self.__m) #self._Foo__m
        print(self.__x) #self._Foo__x

# print(Foo.__dict__)
# Foo.__x
# Foo.__func
# print(Foo._Foo__x)
# print(Foo._Foo__func)

obj=Foo(10,20)
# print(obj.__dict__)
# print(obj.n)
# print(obj.__m)
# print(obj._Foo__m)

# obj.func1()

# obj.__yyy=3333
# print(obj.__dict__)
# print(obj.__yyy)

# Foo.__zzz=444
# print(Foo.__dict__)
# print(Foo.__zzz)

# class Foo:
#     def __f1(self): #_Foo__f1
#         print(‘Foo.f1‘)
#
#     def f2(self):
#         print(‘Foo.f2‘)
#         self.__f1() #self._Foo__f1
#
# class Bar(Foo):
#     def __f1(self): #_Bar__f1
#         print(‘Bar.f1‘)
#
# obj=Bar()
# obj.f2()

# 封装数据属性的真实意图
# class People:
#     def __init__(self,name,age):
#         self.__name=name
#         self.__age=age
#
#     def tell_info(self):
#         print(‘<name:%s age:%s>‘ %(self.__name,self.__age))
#
#     def set_info(self,new_name,new_age):
#         if type(new_name) is not str:
#             print(‘名字必须是str类型傻叉‘)
#             return
#         if type(new_age) is not int:
#             print(‘年龄必须是int类型傻叉‘)
#             return
#         self.__name=new_name
#         self.__age=new_age
#
#     def clear_info(self):
#         del self.__name
#         del self.__age
#
# obj=People(‘egon‘,18)
#
# obj.tell_info()
# obj.set_info(‘egon‘,18)

# 封装函数属性的真实意图
# class ATM:
#     def __card(self):
#         print(‘插卡‘)
#     def __auth(self):
#         print(‘用户认证‘)
#     def __input(self):
#         print(‘输入取款金额‘)
#     def __print_bill(self):
#         print(‘打印账单‘)
#     def __take_money(self):
#         print(‘取款‘)
#
#     def withdraw(self):
#         self.__card()
#         self.__auth()
#         self.__input()
#         self.__print_bill()
#         self.__take_money()
#
# a=ATM()
# a.withdraw()

三、property装饰器

‘‘‘
例一:BMI指数(bmi是计算而来的,但很明显它听起来像是一个属性而非方法,如果我们将其做成一个属性,更便于理解)

成人的BMI数值:
过轻:低于18.5
正常:18.5-23.9
过重:24-27
肥胖:28-32
非常肥胖, 高于32
  体质指数(BMI)=体重(kg)÷身高^2(m)
  EX:70kg÷(1.75×1.75)=22.86
‘‘‘
# class People:
#     def __init__(self,name,weight,height):
#         self.name=name
#         self.weight=weight
#         self.height=height
#
#     @property
#     def bmi(self):
#         return self.weight / (self.height ** 2)
#
# obj=People(‘egon‘,70,1.82)
# obj.height=1.85
#
# print(obj.bmi)

# 需要了解的property的用法
# class People:
#     def __init__(self,name):
#         self.__name=name
#
#     @property
#     def name(self):
#         return ‘<name:%s>‘ %self.__name
#
#     @name.setter
#     def name(self,new_name):
#         if type(new_name) is not str:
#             print(‘名字必须是str类型‘)
#             return
#         self.__name=new_name
#
#     @name.deleter
#     def name(self):
#         del self.__name
#
# obj=People(‘egon‘)
# print(obj.name)
#
# # obj.name=123
# # print(obj.name)
#
# del obj.name
# print(obj.__dict__)

class People:
    def __init__(self,name):
        self.__name=name

    def xxx_name(self):
        return ‘<name:%s>‘ %self.__name

    def yyy_name(self,new_name):
        if type(new_name) is not str:
            print(‘名字必须是str类型‘)
            return
        self.__name=new_name

    def zzz_name(self):
        del self.__name

    name=property(xxx_name,yyy_name,zzz_name)

obj=People(‘egon‘)
print(obj.name)

# obj.name=123
# print(obj.name)

del obj.name
print(obj.__dict__)

四、多态

‘‘‘
1. 什么是多态
    同一种事物的多种形态

2. 为何要用多态
    多态性:指的是可以在不用考虑对象具体类型的前提下而直接使用对象下的方法

3. 如何用多态

‘‘‘
# import abc
#
# class Animal(metaclass=abc.ABCMeta):
#     @abc.abstractmethod
#     def speak(self):
#         pass
#
# # Animal() # 父类不能实例化,因为父类本身就是用来制定标准的
# class People(Animal):
#     def speak(self):
#         print(‘say hello‘)
#     # def jiao(self):
#     #     print(‘say hello‘)
#
# class Dog(Animal):
#     def speak(self):
#         print(‘汪汪汪‘)
#
# class Pig(Animal):
#     def speak(self):
#         print(‘哼哼哼‘)
#
#
# peo=People()
# dog1=Dog()
# pig1=Pig()
# #
# #
# peo.speak()
# dog1.speak()
# pig1.speak()
def speak(animal):
    animal.speak()

speak(peo)
speak(dog1)
speak(pig1)

class Memory:
    def read(self):
        print(‘mem read‘)

    def write(self):
        print(‘mem write‘)

class Disk:
    def read(self):
        print(‘disk read‘)

    def write(self):
        print(‘disk write‘)

class Cpu:
    def read(self):
        print(‘cpu read‘)

    def write(self):
        print(‘cpu write‘)

obj1=Memory()
obj2=Disk()
obj3=Cpu()

obj1.read()
obj2.read()
obj3.read()

# ‘‘.__len__()
# [].__len__()
# len([1,2,3]) #[1,2,3].__len__()

原文地址:https://www.cnblogs.com/wuzhengzheng/p/10136682.html

时间: 2024-10-03 07:12:41

python面向对象:组合、封装、property装饰器、多态的相关文章

Python中,关于@property装饰器

1.为什么使用@property装饰器?br/>在类中,当我么不想在外界直接调用到类的属性,或者不想展示属性的真实内容时,可以用到@property.它规定了我们直接用 对象名.属性名 获取对象属性时并不会直接取得对象的属性,而是通过调用@property装饰过的属性函数来给调用者反馈. 2.我们为什么不使用特定的方法来进行上面的操作?原因是因为太繁琐.例: class Person: def __init__(self, username, password) -> None: self.u

Python 面向对象 组合-多态与多态性-封装-property

面向对象-组合 1.什么是组合 组合指的是某一个对象拥有一个属性,该属性的值是另外一个类的对象 1 class Foo: 2 xxx = 111 3 4 class Bar: 5 yyy = 222 6 7 obj = Foo() 8 obj.attr = Bar() 9 10 print(obj.xxx) 11 >>>111 12 print(obj.attr.yyy) 13 >>>222 2.为何要用组合 通过为某一个对象添加属性(属性的值是另外一个类的对象)的方式

面向对象之封装 及@property装饰器使用

目录 封装 1.封装的定义 2.封装的目的: 3.封装的三种方式 4.封装的优点 5.访问限制(封装) @property 装饰器 封装 1.封装的定义 ? 将复杂的丑陋的,隐私的细节隐藏到内部,对外提供简单的使用接口, 对外隐藏内部实现细节,并提供访问的接口; 2.封装的目的: 封装的目的: 面向对象的核心是对象二字,精髓在于整合,封装的目的其实就是把一堆数据属性和方法属性整合到对象中,我们可以把对象比喻成一个容器,其实就是为了把数据存入一个容器中.存的目的就是为了取的,那封装到对象中的好处就

python staticmethod,classmethod方法的使用和区别以及property装饰器的作用

class Kls(object): def __init__(self, data): self.data = data def printd(self): print(self.data) @staticmethod def smethod(*arg): print('Static:', arg) @classmethod def cmethod(*arg): print('Class:', arg) >>> ik = Kls(23) >>> ik.printd()

python @property装饰器

@property装饰器 @property装饰器就是负责把一个方法变成属性调用把一个getter方法变成属性,只需要加上@property就可以了,此时,@property本身又创建了另一个装饰器@score.setter,负责把一个setter方法变成属性赋值class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isin

面向对象——property装饰器

property装饰器 property装饰器的作用,其实就是将将函数属性伪装成为属性的的装饰器 class People: def __init__(self,name,weight,height): self.name = name self.weight =weight self.height=height @property def bmi(self): return self.weight/(self.height**2) msj = People('msj',82,1.84) pri

Python面向对象特性 - 封装

类中的私有属性 私有属性包括私有变量和私有方法,在 Python 中,在变量名或者方法名前面加上双下划线,这个属性就成为了类的私有属性.? class Person: def __init__(self, name, age): self.__name = name self.__age = age def __fun(self): print(self.__class__) def say(self): self.__fun() # 自动转换为 调用 _Person__fun 方法 print

Python基础(八)装饰器

今天我们来介绍一下可以提升python代码逼格的东西——装饰器.在学习装饰器之前我们先来复习一下函数的几个小点,方便更好的理解装饰器的含义. 一.知识点复习 1, 在函数中f1和f1()有什么不同,f1:表示的是将整个函数看作一个整体:f1():表示执行f1函数,下面通过一个例子来看一下: 1 2 3 4 5 def f1():     print('f1') f1                    #代表函数体本身,什么也不操作 f1()                  #代表执行函数

一段小代码说明@property装饰器的用法

#coding:utf-8 """ 一段小代码说明@property装饰器的用法.__name是私有变量 外部不能通过foo.__name访问,但可以通过foo._Foo__name访问. 如果想通过点运算符设置和访问实例属性怎么办,@property派上用途了, 先将一个方法头上加上@property,这个方法就变成实例属性了,再加上这个@get_name.setter 装饰器(@属性名.setter)就可以通过赋值来设置属性. python北京周末培训班 https://