Python DAY 13 属性私有化 继承 重写 多态 常用特殊属性方法 单例设计模式 __str__ 和 __repr__

最新推荐文章于 2024-04-29 04:56:09 发布
最新推荐文章于 2024-04-29 04:56:09 发布
阅读量186 收藏
点赞数
分类专栏： Python 文章标签： python 面向对象编程 多态 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Galahad_Lin/article/details/107812091
版权

Python DAY13 重点知识归纳 属性私有化 继承 重写 多态 常用特殊属性方法 单例设计模式 str 和 repr

一 属性私有化

  1. 限制属性 _ slots_
    slots的用法在昨天的文章中有写道 主要是限制在同一个类内的可用属性 规定的属性名字放在slots后的元组内 元组内未出现的属性名称在后面不能使用以及调用 如果使用则会报错
# 限制属性
class Pig:
    __slots__ = ('name')  # 限制属性只能由name

    def __init__(self, name, age):
        self.name = name
        self.age = age  # 这个slots里面没有 如果调用则会报错
        print(name, age)  # 'Pig' object has no attribute 'age'


pig = Pig('佩奇', 10)
  1. 属性私有化
    1. 面向对象 特点： 1.封装 2.继承 3.多态 4.抽象
    2. 封装：
      1. 类可以封装属性和方法
      2. 某些语言内有 private protect public 等关键字 而Python 内没有这三种关键字 并且只有两种状态 公有和私有(public private)
        tips：_类名__属性名 这种方法可以调用私有属性或者私有方法 但是最好不要这么用
class Person:
	def __init__(self,name,age,sex):
		self.name = name # 公有属性 可以用任意对象调用
		self.__age = age # 私有属性 只能在当前类内使用
		self._sex = sex # 公有属性 但是不建议这么写
	def other(self):
		print(self.__age)
		self.__eat() # eat
	# 私有方法
	def __eat(self):
		print('eat')
# 对象
p = Person('鹿晗',30,'男') 
print(p.name) # 鹿晗
p.other()	# 30
# print(p.__age) # 'Person' object has no attribute '__age'
# print(p.age) # 'Person' object has no attribute 'age'
print(p._sex) # 男
# p.__eat() # 报错，__eat()是私有方法 在类的外面不能直接调用 但是在类内可以使用

# 下面的方式可以调用私有属性或者私有方法 但是最好不要这么用
print(p._Person__age) # 30
p._Person__eat() # eat

# tips: 初期先全部写成公有 写完后再根据需求将部分部分写成私有
  1. property 装饰器
class Person:
    def __init__(self,name,wechat):
        self.name = name
        self.__wechat =wechat

    # # getter 间接获取私有属性
    # def get_wechat(self): # 获得私有属性的操作
    #     return self.__wechat
    #
    # # setter 间接修改私有属性
    # def set_wechat(self,new_wechat):
    #     self.__wechat = new_wechat

    @property  # 作用：让wechat函数可以当成属性来调用
    def wechat(self):
        return self.__wechat # 这里必须得有返回值

    @wechat.setter # 作用： 设置新的wechat 注意 这个东西不能单独存在 必须在@property存在的时候存在 不然会报错
    def wechat(self,new_wechat):
        self.__wechat = new_wechat

    @property # 只要这边里有return 那么就可以使用property
    def photo(self):
        s = self.name +  self.__wechat
        return s
# 对象
p =Person('刘亦菲','110')
# print(p.get_wechat()) # 110

# p.set_wechat('119')
# print(p.get_wechat())

print(p.wechat) # 110
# p.wechat = 120 # 报错 @property只是用于getter 而不能setter
print(p.photo) # tips: 使用了property 就不需要在函数后打括号了 如果是没有property 则需要使用括号

print(Person.photo) # <property object at 0x000002AC490F9C28>

print(str(Person.photo)) # <property object at 0x000001DD7AD49C28>

重点注意：
1. @property @setter 这样的装饰器实在类下 实际上只有当某些对象属性出现私有属性的时候才会调用
2. @property 使用时 会将之前函数内的属性转化为方法 即可以将函数当成对象属性来调用 注意：在使用property装饰器时 必须得有return 而且只要有return 那就可以使用property装饰器 在调用时 不用加使用括号
3. @（porperty的那个属性）.setter 使用时 可以更改私有属性的参数 重新设置新的参数 注意：这个东西不能单独存在 必须要在@property存在的时候存在 不然会报错
4. 其实property和setter 与以下的实现内容相似 但是有着本质的差别 前者本质是一个对象的属性 而后者相当于一个对象的方法 所以在调用后者时 需要加括号来调用

    # getter 间接获取私有属性
    def get_wechat(self): # 获得私有属性的操作
        return self.__wechat

    # setter 间接修改私有属性
    def set_wechat(self,new_wechat):
        self.__wechat = new_wechat
  1. 类方法和静态方法
    1. 类方法 @classmethod
      1. 可以用类和对象调用 推荐使用类调用
      2. 类方法内部是不可以使用对象属性和其他成员的方法和私有方法
      3. 类方法内部可以使用其他的类方法或者类属性
    2. 静态方法 @ staticmethod
      1. 可以使用类方法和对象调用 推荐使用类来调用 可以节省内存
      2. 类方法内部是不可以使用对象属性和其他的成员的方法和私有方法
      3. 也不建议使用类属性和类方法 一般写成静态方法的就是一个普通的函数 只不过把他放在类里面
        3.tips：
      4. 类方法的使用实际上可以看成一个类属性 因为这个可以由每一个对象调用 也可以使用类调用 关键的部分就是类方法是一个函数 而非一个赋值的变量 仅此而已
      5. 静态方法一般不使用
class Dog:
    def __init__(self,name):
        self.name = name

    def run(self):
        print('成员方法/公有方法')

    def __eat(self):
        print('私有方法：只能在当前类内部使用')

    # 类方法
    #   1. 可以用类和对象调用 推荐用类调用
    #   2. 类方法内部是不可以使用对象属性和其他成员方法或私有方法
    #   3. 类方法内部可以使用其他的 类方法或者类属性

    @classmethod # 类方法
    def sleep(cls): # cls 也是形参 一般使用cls而已 cls = class
        print('类方法',cls == Dog) # 类方法 Ture

    # 静态方法：
    #   1. 可以用类方法和对象调用 推荐用类调用 可以节省内存
    #   2. 类方法内部是不可以使用对象属性和其他成员方法或私有方法
    #   3. 也不建议使用类属性和类方法，一般写成静态方法的就是一个普通函数 只是放在类里面
    @staticmethod
    def swim():
        print('静态方法') # 在外面使用Dog.swim() # 静态方法


# 创建对象
dog = Dog('哮天犬')
dog.sleep() # 类方法 True
Dog.sleep() # 类方法 True

# Dog.run() # run() missing 1 required positional argument: 'self'
# Dog.run(1) 也可以调用 主要是self在这里就相当于一个形参了

Dog.swim()

二 继承

  1. 概述

    1. 单继承 只有一个父类的继承 称为单继承
    2. 多继承 由多个父类 一个子类继承多个父类
    3. 父类 又称为基类 子类 又称为派生类
    4. 子类在继承的时候 需要在类名之后加括号 括号内写上需要继承的父类的名字
    5. 继承父类的初始属性： 一般放在子类的最开头进行继承 继承需要写自己的init 并且使用显示调用（父类名._ init_(self,‘父类的属性名’)） 或者隐式调用（super()._ init_(‘父类的属性名’)）后面即使用父类的属性
    6. 子类可以多层继承 多层继承指的是 （父类=>子类1/父类2 => 子类2） 这是一个线性的结构 从上到下 只有一条链

  2. 单继承 以及 单继承中的多层继承

# 单继承

# 父类 / 基类
class Ipad(object):
    def __init__(self,price):
        self.price =  price

    def move(self):
        print('看电影')

# 子类 / 派生类
class Iphone(Ipad): # 子类的括号里得写上父类的名字
    def __init__(self, color, price):
        Ipad.__init__(self,price) # 显示调用 可以看到父类的名字的
        # 需要调用父类的init方法 ： 对父类属性进行初始化
        # super().__init__(price) 隐式调用 不可以看到父类的名字
        self.color = color

# mine = Ipad(2000)
# print(mine.price)
# mine.move()
#
# print('*'*100)

iphone = Iphone('blue',10000 )
print(iphone.price,iphone.color) # 10000 blue
iphone.move() # 看电影

# 子类 多层继承
class Iwatch(Iphone):
    def __init__(self,price,color,size): # 每一次继承 需要在初始化的时候 将父辈的参数初始化了
        super().__init__(price,color) # 一般来说初始化父类是排在前面的
        self.size = size
    # @property
    # def price(self):
    #     return self.__price # 子类不能使用父类的私有属性和私有方法 即私有方法和私有属性只能在本类中调用和使用


iwatch = Iwatch(2000,2,'black')
print(iwatch.price,iwatch.color,iwatch.size) # 2 2000 black
iwatch.move() # 看电影   把爷爷辈的属性拿来了
print('*' * 100)
  1. 多继承
    1. 多继承和单继承相似的地方是 在继承父类的时候也需要调用父类的属性 在init中设置
    2. 不同的地方是 在创建class的时候 需要申明所有的父类 且在申明的时候的顺序对后面的调用很有关系
    3. 在申明父类中的属性的时候 运用的两种方法分别是显示调用和 隐式调用 显示调用较容易理解 而隐式调用的顺序和申明的顺序有直接关系 最后的使用_ mro_ 打印继承链可以辅助了解
    4. 与单继承相同的是 父类中使用的方法 无需申明也可在子类的对象中调用使用 tips：如果说父类和子类中有相同的方法(即相同的函数名) 那么在子类创造对象之后 调用改名函数将会优先使用子类之中的函数 如果子类中没有和父类中同名的函数 那么将会自动调用父类中的函数
# 多继承

# 父类1
class Father:
    def __init__(self,name):
        self.name = name

    def run(self):
        print('会跑步')

# 父类2
class Mother:
    def __init__(self,age):
        self.age =age

    def cook(self):
        print('会做饭')

# 子类
class Son(Father,Mother): # 父类在括号内的顺序有关系
    def __init__(self,name,age,height):

        # 显示调用 这个好理解一些
        # Father.__init__(self,name)
        # Mother.__init__(self,age)

        # 隐式调用 这个不好理解 最下面使用__mro__ 打印继承链 可以辅助了解
        super(Son, self).__init__(name) # 继承Father的 init
        super(Father, self).__init__(age) # 继承了Mother的 init

        self.height = height


# 子类对象
son = Son('小刚',8,1.3)
print(son.name) #小刚
print(son.age)  #8
print(son.height)  #1.3

son.run() #会跑步
son.cook() #会做饭


print(Son.__mro__) # 打印继承链 解释隐式调用
# (
# <class '__main__.Son'>,
# <class '__main__.Father'>,
# <class '__main__.Mother'>,
# <class 'object'>
# )

三 重写[掌握]

重写： 方法重写
如上面的tips相同的描述 重写的意思即为针对于子类和父类相同的函数名的情况 出现该情况时 在子类中创建的对象会优先调用子类中的函数 而自动屏蔽掉了父类中的同名函数（方法） 这个不能理解为更改了父类中函数方法 只能理解为一个覆盖的作用 称之为方法重写
如果子类中没有出现和父类中相同的函数 在子类创建的对象中会调用父类中该函数
ps： 很多语言中有重载的概念 但是python中没有重载的概念 不要将重载和重写混在一起理解
下面是运用实例：

# 重写： 方法重写

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

    def jump(self):
        print('跳2米远')

class Player(Person):
    def __init__(self,name):
        super().__init__(name)

    # 把父类的jump方法重写了 覆盖了父类的该变量名属性的方法 但是并没有修改父类的该变量名的方法的值
    def jump(self):
        print('跳4米远')
    # 如果把子类的jump注释掉 那么p2打印出来的则会是 '跳2米远'

p = Person('宝强')
p.jump() # 跳2米远

p2 = Player('姚明')
p2.jump() # 跳4米远

# 在很多语言中有重载的概念 但是python中没有重载的概念

四 多态

首先先声明 python中没有严格意义上的多态

  1. 概述
    多态： 在继承的基础上 多个子类重写父类的一个方法 在不同的子类中写不同的功能 那么用父类的对象指向不同的子类 调用该方法 可以实现不同的功能
    1. 强类型的语言中 多态体现的很明显 而在python中 没有严格意义上的多态
    2. 弱类型
      在python中 如：a = 10 a = ‘hello’ 在定义a的变量的时候 不需要指明a的变量类型
    3. 强类型
      如c语言 int a =10 那么就强制a变量在使用中只能是整数 在变量成立之初 将类型定义下来

接下来是实例：

# 父类
class Animal:
    def eat(self):
        pass

# 子类
class Dog(Animal):
    def eat(self):
        print('吃骨头')

class Cat(Animal):
    def eat(self):
        print('吃鱼')

class Cow(Animal):
    def eat(self):
        print('吃草')

#
class Person:
    def __init__(self,name):
        self.name = name
    def keep(self,animal):
        print(f'{self.name}养了一直小动物')
        animal.eat()

# 创建对象
dog = Dog()
cat = Cat()
cow = Cow()
p = Person('小明') # 小明养了一直小动物
p.keep(dog) # 吃骨头
# 在这里 定义不同的对象进入p.keep() 中 可以实现不同的输出结果 这就是所谓的python中的多态
五 常用的特殊属性和方法[多记多用]
class Man:
    pass

class Boy(Man):
    # __init__():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    # __add__ 运算符重载(了解)
    #  + 加法
    def __add__(self, other):
        # return self.age + other.age
        return Boy(b.name + other.name,b.age + other.age)

# 对象
b = Boy('易烊千玺', 19)

# 常用方法
print(__name__) # __main__ 表示当前模块名字
print(Boy.__name__) # Boy 得到类的名字

print(b.__dict__) # {'name': '易烊千玺', 'age': 19}
print(b.__module__) # __main__ 该对象所在的模块
print(Boy.__module__) # __main__ 对象和类都是在当前的模块里
print(b.__class__) # <class '__main__.Boy'> 可以得到这个对象实在哪个类里
print(b) # <__main__.Boy object at 0x0000020441BB01D0>
print(Boy.__bases__) # (<class '__main__.Man'>,) base表示基类 显示出所有的父类 如果有多个父类则储存在元组内

b2 = Boy('王源',18)
print(b+b2)
b3 = b + b2
print(b3.name,b3.age) # 易烊千玺王源 37
六 单例设计模式[了解]

在本单例设计模式下 主要是在项目中 如果有需要调用的 需要一个类只存在一个对象 可能就会使用这样的模式 这样的模式主要特点就是不管调用多少次类 只会产生一个对象

class Person:
    #init: 初始化时调用
    def __init__(self,name):
        print('__init__',name)
        self.name = name

    # 类属性
    instance = None
    # new: 创建对象时调用
    @classmethod
    def __new__(cls, *args, **kwargs):
        print('__new__')

        if cls.instance ==None:
            print('----创建新对象----')
            # 利用父类新建对象
            cls.instance =  super().__new__(cls)
        return cls.instance

# 对象
p1 = Person('李四')
p2 = Person('王五')
p3 = Person('赵六')

print(p1 == p2) # True
print(p2 == p3) # True
print(id(p1) == id(p2))  # True
print(p1.name,p2.name,p3.name)
六 _str _ 和 _repr _

这两个主要是使用该方法返回字符串 就不需要在类外面一个一个函数慢慢调用了
tips： 1. 必须返回字符串 2.作用是让打印的对象的值是这里的返回值
ps：repr 和 str 的作用很相似 而且str和repr在同一个类中 会优先打印str的部分 而忽略repr的部分
下面是实例:

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


    # 1.必须返回字符串
    # 2. 作用是让打印的对象的值是这里的返回值
    def __str__(self):
        return f'名字：{self.name},年龄：{self.age}'

    # 这个和__str__作用很像 而且和str在一起会优先打印__str__
    # def __repr__(self):
    #     return f'名字2：{self.name},年龄2：{self.age}'
# 对象
cat = Cat('汤姆',3)
print(cat) # <__main__.Cat object at 0x000001B004702278>
# 加上了str之后 # 名字：汤姆,年龄：3
Galahad_Lin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day13_上 Class类的封装 继承 重写 及多态
CSDN_Hy007的博客
10-09 419
一、封装【private】 1.概念 广义的封装：函数和类的定义本身，就是封装的体现 狭义的封装：一个类的某些属性，在使用的过程 中，不希望被外界直接访问，而是把这个属性给作为私有的【只有当前类持有】，然后暴露给外界一个访问的方法即可【间接访问属性】 封装的本质：就是属性私有化的过程 封装的好处：提高了数据的安全性，提高了数据的复用性 2.属性私有化 如果想让成员变量不被外界直接访问，则可以在属性名称的前面添加两个下划线__,成员变量则被称为私有成员变量 私有属性的特点：只能在类的内部直接被访问，在外
汽车租赁python面向对象_PYTHON1.面向对象_day03
weixin_39718286的博客
12-14 379
课程：Python面向对象进度：day3上次内容回顾1. 多态1)什么是多态：同一个方法，在不同子类中有不同的表现2)方法的重写来实现3)保持程序的扩展性、灵活性2. 面向对象的技术特性1)构造方法与析构方法a)构造：__init__()调用时机：对象被创建时自动调用作用：创建对象属性，并赋值注意：子类构造方法显示调用父类构造方法b)析构方法：__del__()调用时机：对象被销毁时调用作用：对象...
【愚公系列】2023年02月 .NET CORE工具案例-FastEndpoints轻量级WebApi框架
时光隧道
02-08 9084
FastEndpoints是Minimal API和MVC的开发人员友好替代品，它是基于REPR设计模式（请求-端点-响应），以便创建方便且可维护的端点，几乎没有样板文件。FastEndpoints的性能与Minimal API 相当，甚至它更快，使用更少的内存并且每秒请求数比基准测试中的MVC控制器更高。对于比如：中间件、认证、授权、日志，依赖注入这些常用功能都支持，甚至有些还进行了加强。设计主要是分为两种模式分层模式：mvc、mvp、mvvm等垂直模式：REPR设计模式。
精华**2006设计师必备网址全集**精华
热门推荐
grace_yan的专栏
07-03 2万+
 分目录如下：一、创意，创意，创意贴子网址全集二、百家经典画册欣赏网址三、世界顶尖百家品牌平面广告集网址四、世界百家广告公司平面作品集网址五、全球及国内各广告大赛作品集合网址六、经典海报招贴贴子归类集合网址七、公益广告类欣赏网址人、中国百家楼书经典网址九、明星代言平面广告集合网址十、国内外设计大师作品贴子归类集合网址十一，史上最全面的视频集合（待整理）十二，100套VI欣赏下载网址========
Day13_Python_继承和属性
Hiraphael的博客
08-08 324
一、封装【private】 1、概念 广义的封装：函数和类的定义本身，就是封装的体现 狭义的封装：一个类的某些属性，在使用的过程 中，不希望被外界直接访问，而是把这个属性给作为私有的【只有当前类持有】，然后暴露给外界一个访问的方法即可【间接访问属性】 封装的本质：就是属性私有化的过程 封装的好处：提高了数据的安全性，提高了数据的复用性 2、属性私有化 如果想让成员变量不被外界直接访问，则可以在属性名称的前面添加两个下划线__,成员变量则被称为私有成员变量 私有属性的特点：只能在类的内部直接被访问，在外界不能
Python中面向对象（学习笔记）_面相对象程序设计python的笔记
最新发布
m0_61549591的博客
04-29 771
passd = Doctor(“张医生”, 30, “male”)
python基础——方法、重载、继承、多态
qq_41068750的博客
07-01 734
python 基础
python_study
flowerqt的博客
02-24 3582
python 基础学习
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
标题中的"CPP.rar_多态 .cpp_继承与多态_继承与多态C++"表明这个压缩包文件包含了关于C++编程语言中多态性（Polymorphism）和继承（Inheritance）的概念示例。多态性和继承是面向对象编程（Object-Oriented ...
ATM.rar_ATM machine_VC++6.0取款机_atm_atm继承性代码_继承多态
09-14
通过继承，子类可以获取父类的所有属性和方法，并且可以添加自己的特有功能。在这个ATM机项目中，可能会有一个基类`ATM`，它包含基本的交易操作如存款、取款、查询余额等。然后，可以有特定类型的ATM机，如`...
xm_LeakMax_MainProg.rar_multistate_多态系统 matlab_多态贝叶斯_贝叶斯网络
07-13
多态系统的贝叶斯网络模型的参数学习算法，基于Noisy-Max模型
python.rar_python simple code_python 教程_python 环境_python代码_pytho
07-14
Python还支持面向对象编程，可以创建类和对象，实现继承、封装和多态。对于网络编程，Python有`socket`模块可以创建网络连接，而`requests`库则简化了HTTP请求。对于数据分析和可视化，`pandas`和`matplotlib`是非常...
java and python的面试总结.zip_Python 面试_Python面试_python总结_面试
09-20
5. **设计模式**：熟悉常见的设计模式，如单例、工厂、观察者等，并能结合实际场景进行应用。 6. **IO/NIO**：输入输出流的使用，非阻塞IO（New IO，NIO）的优势及使用场景。 7. **JVM调优**：了解如何分析和调整...
Anacoda&Jupyter DAY 01 数据清洗入门 numpy
Galahad_Lin的博客
08-18 954
Anacoda&Jupyter DAY 01 数据清洗工具入门 numpy 一 Jupyter 入门操作 前言:该部分建立在下载并安装 Anacoda Navigator 的基础上使用的操作 其中使用的Jupyter的部分操作也是建立在此 安装后并配置好环境变量即可操作 这里就不详细解释安装和配置了 一 启动程序 启动程序 打开cmd 输入 activate root 使用cmd命令提示符(cd等) 进入到需要编辑的项目文件夹 输入 jupyter notebook 二 Ipython的帮助文档
Anacoda&Jupyter DAY 05 Pandas绘图&Scipy
Galahad_Lin的博客
08-21 806
Anacoda&Jupyter DAY 05 重点知识总结 Pandas绘图&Scipy 一 pandas绘图 Series 和 DataFrame 都有一个用于生成各类图标的plot方法 默认情况下 他们都是线型图 import numpy as np import pandas as pd from pandas import Series,DataFrame import matplotlib.pylot as plt 一 线形图 二维折线图 s = Series(data = n
Anacoda&Jupyter DAY 04 pandas合并补充&pandas数据处理
Galahad_Lin的博客
08-20 658
Anacoda&Jupyter DAY 04 重点知识总结 pandas合并补充&pandas数据处理 一 pandas合并之 pd.merge() merge()和concat()的区别在于 merge需要依据某一共同的行或者列来进行合并 使用pd.merge()合并时 会自动根据两者相同的columns名称的那一列 作为key来进行合并 注意每一列的元素顺序不要求一致 一般来说 最普通的合并方式分为一对一合并 多对一合并 多对多合并 一对一合并 只有一列是有关联的 并且列索引的名
Python DAY 14 异常处理&文件操作&复制文件&CSV文件读写
Galahad_Lin的博客
08-06 560
Python DAY 14 重点知识总结 异常处理&文件操作&复制文件&CSV文件读写 一 异常处理 错误： Error 异常： Exception 错误实例： 1a = 10 # SyntaxError: invalid syntax 无效的语法 即语法错误 print(a) # NameError: name 'a' is not defined 变量没有定义 [][0] # IndexError: list index out of range 列表越界 1 +
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值