day18-面向对象进阶

day18-面向对象进阶

1.对象属性的增删改查

(1) 查 - 获取属性值
  • 对象.属性 - 获取对象指定属性的值,如果属性不存在会报错
  • getattr(对象,属性名) - 获取对象指定属性的值,如果属性不存在会报错
  • getattr(对象,属性名,默认值) - 获取对象指定属性的值,如果属性不存在返回默认值
print(stu1.name)
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name', '无名氏'))
(2) 增、改
  • 对象.属性 = 值 - 当属性存在的时候修改属性的值,当属性不存在的时候添加属性
  • getattr(对象,属性名,值) - 当属性存在的时候修改属性的值,不存在的时候添加属性
stu1.name = '张三'
print(stu1)       # <{'name': '张三', 'age': 18, 'study_id': '000'}>

stu1.gender = '女'
print(stu1)        # <{'name': '张三', 'age': 18, 'study_id': '000', 'gender': '女'}>
print(stu1.gender)       # 女

setattr(stu1, 'age', 30)
print(stu1.age)        # 30

setattr(stu1, 'score', 100)
print(stu1)            # <{'name': '张三', 'age': 30, 'study_id': '000', 'gender': '女', 'score': 100}>
print(stu1.score)      # 100
(3) 删
  • del 对象.属性 - 删除指定对象的指定属性
  • delattr(对象,属性名) - 删除指定对象的指定属性
del stu1.age
print(stu1)       # <{'name': '张三', 'study_id': '000', 'gender': '女', 'score': 100}>

delattr(stu1, 'study_id')
print(stu1)
class A:
    # __slots__属性的值就是当前类的对象最多能拥有的对象属性,如果为空,那么这个类的对象就不能有对象属性
    # 注意: 如果给类设置了__slots__,那么这个类的对象就不能再使用__dict__属性
    __slots__ = ('x', 'y', 'z')

    def __init__(self):
        self.x = 10


a = A()
a.y = 100
a.z = 200
# a.m = 300

2.内置属性

class A:
    """还是计算机是"""
    pass
(1) doc - 类的说明文档
print(int.__doc__)
print(int(10).bit_length())
(2) module - 获取类所在的模块
print(int.__module__)
print(A.__module__)
(3) class - 获取对象的类型,功能和type()
a =A()
print(a.__class__)
print(type(a))
(4)
  • dict - 获取类所有类属性和对应的值,以字典的形式返回
  • dict - 获取对象所有的对象属性和对应的值,以字典的形式返回(对象属性)
print(a.__dict__)
(5) name - 获取类的名字(类属性)
print(A.__name__)        # 'A'
  • 是 ? 数据的类型
print(f'是{a.__class__.__name__}的类型')
(6)
  • base - 获取当前类的父类
  • bases - 获取当前类的父类们
print(A.__base__)      # <class 'object'>   -   基类
print(A.__bases__)     # <class 'object'>

3.运算符重载

from copy import copy

print(10 + 29)
print('abc' + '34')
print([10, 34] + [239, 0, 'abc'])

print(10 - 9)
print({23, 89} - {23})


# 10 + 29   ==  10.__add__(29)
# 'abc' + '34'   ==  'abc'.__add__('34')
(1) python 中的运算符
  • python 中每个运算符都对应一个固定的魔法方法,哪个类型中实现对应的魔法方法,哪个类型的数据就支持对应的运算符
  • python 中某种数据是否支持某种运算符就看这个类中是否定义了运算符对应的魔法方法
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # self + other
    def __add__(self, other):
        return self.age + other.age

    # self *  other
    def __mul__(self, other):
        return [copy(self) for _ in range(other)]

    # self > other
    def __gt__(self, other):
        return self.age > other.age

    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}, id: {id(self)}>'
        # return str(self.__dict__)
stu1 = Student('小明', 18)
stu2 = Student('小花', 20)

a = stu1 + stu2     #  a = stu1.__add__(stu2)
print(a)
print(stu1 * 4)

# print(stu1 in stu2)

stu_list = [stu1, stu2, Student('张三', 12)]
print(stu_list)

# print(max(stu_list, key=lambda item: item.age))
print(max(stu_list))

4.继承

(1) 继承
  • 继承就是让子类直接拥有父类的属性和方法
  • 子类 - 继承者
  • 父类 - 被继承者,又叫超类
(2) 继承的用法
  • class 类名(父类):

    ​ 说明文档

    ​ 类的内容

  • class 类名(父类1,父类2,…):

    ​ 说明文档

    ​ 类的内容

  • 注意:如果定义类的时候没有写继承关系,那么这个类默认继承基类 object

  • class 类名: == class 类名(object)

(3) 添加新属性和方法
  • 添加方法和添加类属性:直接在子类中定义新的类属性和方法
  • 添加对象属性
class Person:
    num = 61

    def __init__(self,):
        self.name = '张三'
        self.age = 30
        self.gender = '男'

    def eat(self, food):
        print(f'{self.name}在吃{food}')

    @staticmethod
    def func1():
        print('静态方法')


class Student(Person):
    x = '学生'

    def __init__(self):
        # 调用当前类的父类的__init__方法
        super().__init__()
        self.study_id = '0001'
        self.subject = 'python'

    def study(self):
        print('好好学习,天天向上!')

    @classmethod
    def func2(cls):
        print('学生的类方法')


stu = Student()
print(stu.name, stu.age, stu.gender)
stu.eat('包子')

print(Student.num)
Student.func1()

print(Student.x)
stu.study()
Student.func2()
print(stu.study_id, stu.subject)


class A:
    def __init__(self, x, y):
        self.x = x
        self.y = y


class B(A):
    def __init__(self, m, n, x=10, y=20):
        super().__init__(x, y)
        self.m = m
        self.n = n


a = A(200, 300)

b = B(1, 2)
print(b.x, b.y)
# b.x = 3
# b.y = 4

5.继承细节问题

(1) 子类和父类有相同方法(重写)
class A:
    def func1(self):
        print('A的func1')

        
class B(A):
    def func1(self):
        print('B的func1')


B().func1()
A().func1()
(2) super 的用法
  • super(类,对象).方法() - 调用指定类的父类的指定方法
  • 注意:() 中的对象必须是 () 里面类的对象
class A:
    def func1(self):
        print('A的func1')


class B(A):
    def func2(self):
        super(B, self).func1()
        print('B的func2')


B().func2()


class A:
    def func1(self):
        print('A的func1')

    def func2(self):
        print('A的func2')


class B(A):
    def func1(self):
        print('B的func1')


class C:
    def func1(self):
        print('C的func1')


class D(C):
    def func1(self):
        super(B, B()).func2()
        print('D的func1')


d = D()
d.func1()

(3) 多继承:子类只能继承第一个父类的对象属性(方法和类属性都可以继承)

class AA:
    num = 100

    def __init__(self):
        self.x = 100
        self.y = 200

    def func1(self):
        print('对象方法AA')


class BB:
    message = '你好'

    def __init__(self):
        self.m = 100
        self.n = 200

    def func2(self):
        print('对象方法BB')


class CC(AA, BB):
    pass


c = CC()

print(CC.num, CC.message)

c.func1()
c.func2()

print(c.x, c.y)
# print(c.m, c.n)   # AttributeError: 'CC' object has no attribute 'm'
(4) 私有化
  • 访问权限(属性和方法的权限):公开的、保护的、私有的
  • 公开的 - 在类的外部可以使用、类的内部可以使用、也可以被继承
  • 保护的 - 在类的外部不可以使用、类的内部可以使用、也可以被继承
  • 私有的 - 只有类的内部可以使用、不能被继承、也不能在外部使用
  • python 中类的内容的权限只有一种:公开的
  • python 的私有化:想让属性和方法变成私有的只需要在名字前面加__(但是不能同时用__结尾)
  • python 私有化的本质:就存储数据的时候在私有化名字前加 ‘_类名’
  • python 中的保护:在名字前加_
class A:
    m = 100
    __n = 200

    @staticmethod
    def func1():
        print(A.m, A.__n)
        A.__func2()

    @staticmethod
    def __func2():
        print('私有方法')


print(A.m)
A.func1()

# print(A.__n)
# A.__func2()

print(A._A__n)
  • python 之锤

6.拷贝

from copy import copy, deepcopy
(1) 拷贝
  • 直接赋值:直接将变量中的地址赋值给另外一个变量,赋值后两个变量指向同一块内存区域,并且相互影响

  • 浅拷贝:列表切片、列表.copy()、字典、copy()等都是浅拷贝、copy()

    ​ : 复制原数据产生一个新的数据,降薪数据的地址返回;如果原数据中有子对象(有可变数据),不会复制子对象

  • 深拷贝:deepcopy

    ​ :复制原数据产生一个新的数据,将新的数据的地址返回,如果原数据中有子对象,子对象也会被复制

class Dog:
    def __init__(self, name, gender='公'):
        self.name = name
        self.gender = gender

    def __repr__(self):
        return str(self.__dict__)


class Person:
    def __init__(self, name, age=18, dog=None):
        self.name = name
        self.age = age
        self.dog = dog

    def __repr__(self):
        return str(self.__dict__)


p1 = Person('小明', dog=Dog('财财'))
p2 = p1
p3 = copy(p1)
p4 = deepcopy(p1)

print(f'p1:{p1}, id:{id(p1)}')
print(f'p2:{p2}, id:{id(p2)}')
print(f'p3:{p3}, id:{id(p3)}')
print(f'p4:{p4}, id:{id(p4)}')
print('-------------------------------------------------')
p1.name = '小花'
p1.dog.name = '大黄'
print(f'p1:{p1}, id:{id(p1)}')
print(f'p2:{p2}, id:{id(p2)}')
print(f'p3:{p3}, id:{id(p3)}')
print(f'p4:{p4}, id:{id(p4)}')
(2) 内存管理
  • 内存的申请:定义变量保存数据的时候系统会自动申请;如果定义变量保存的时候是可变数据;每次都会申请新的内容,如果是不可变的数据,会检查这个数据

  • 释放:如果一个数据的引用计数(引用的个数)为0,那么这个数据就会被自动释放

  • 引用:保存数据地址的对象就是这个数据的引用

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值