总结

一.内置类属性

内置类属性就是魔法属性
魔法属性就是属性名前后都有两个下划线,魔法方法就是方法前后都有两个下划线

import datetime
class Person:
    """人类"""
    # 类的字段
    number = 61
    def __init__(self, name1, age1, height1):
        # 对象的属性
        self.name = name1
        self.age = age1
        self.height = height1
    # 对象方法
    def run(self):
        print('%s在跑步' % self.name)
    # 类方法
    @classmethod
    def show_number(cls):
        print('人类的数量为%d亿'%cls.number)

    # 静态方法
    @staticmethod
    def destory():
        print('人类在破坏环境!')
if __name__ == '__main__':
    p1 = Person('张三', 28, 170)
    # 1.__name__属性  --> 类的名字(是个字符串)
    name = Person.__name__
    print(name, type(name), type(Person))

    # 2.__class__属性  --> 获取对象对应的类(是个类)
    # 对象的属性
    # my_class是一个类,之前类能做的他都能做
    my_class = p1.__class__
    p2 = my_class('小明', 20, 180)
    print(p2.name, my_class.__name__)

    # 3.__dict__属性  --> 将对象和类的属性及其对应的值转换成键值对存到一个字典中
    # print(Person.__dict__)
    print(p1.__dict__)      # {'name':'张三','age':28,'height':170}


    # 4.__doc__属性  --> 获取类的说明文档
    # 类的属性
    doc = Person.__doc__
    print(doc)

    # 5.__module__属性  --> 获取类所在的模块对应的名字
    print(Person.__module__)
    print(datetime.datetime.__module__)

    # 6.__bases__属性  --> 获取当前类的父类
    # 类的属性
    print(Person.__bases__)

二.slots魔法

class Person:

    # 通过__slots__中存的元素的属性的值来约束当前这个类的对象的属性
    # 对象的属性只能比元祖中的元素少,不能多!!!
    __slots__ = ('name', 'age', 'face')
    def __init__(self):
        # 对象的属性
        self.name = '张三'
        self.age = 18
        self.face = 70
        # self.sex = 'boy'  # __slots__中并没有sex

if __name__ == '__main__':
    p1 = Person()
    # p1.sex = 'girl'
    # print(p1.sex)

    # p1.neme = '小明'
    print(p1.name)

注意:一旦在类中给slots属性赋值,那么这个类的对象的dict属性就不能使用了

print(p1.__dict__)

三.属性的私有化

python中并没有真正的私有化

1.私有化

a.类中的属性和方法都可以通过在属性名和方法名前加两个下划线来让属性和方法变成私有的
b.私有的属性和方法只能在当前的类中使用

2.私有化原理

在前面有两个下划线的属性名和方法名前添加了'_类名'来阻止外部通过直接访问属性名来使用属性

class Dog:
    # 类的字段
    number = 100
    __count = 200

    def __init__(self):
        # 对象的属性
        self.color = '黄色'
        self.age = 3
        self.name = '大黄'
        self.__sex = '公狗'

    # 对象方法
    def __eat(self):
        print('%s在吃屎~' % self.name)

    def eat(self):
        # 在类中可以使用私有的属性和方法
        self.__eat()
        print('%s在吃屎~' % self.name)

    # 类方法
    @classmethod
    def shout(cls):
        print('count:', cls.__count, Dog.__count)
        print('汪汪汪~~~')

    @classmethod
    def __shout(cls):
        print('count:', cls.__count, Dog.__count)
        print('汪汪汪~~~')

    @staticmethod
    def function():
        print('看家!!')

# python的类中默认的属性和方法都是公开的
dog1 = Dog()
print(Dog.number)
dog1.eat()
Dog.shout()

# 在类的外面不能直接使用私有的属性

四.属性的getter和setter

1.保护类型的属性:
a.就是在声明对象属性的时候在属性名前加一个下划线来代表这个属性是受保护的属性
那么以后访问这个属性时就不要直接访问,要通过getter来获取这个属性的值,setter来给这个属性赋值
b.如果一个属性已经声明称保护类型的属性,那么我们就需要给这个属性添加getter,也可以添加setter

2.添加getter
添加getter其实就是声明一个没有参数有一个返回值的函数,作用是获取属性的值
a.格式:
@property
def 去掉下划线的属性名(self):
函数体
将属性相关的值返回

b.使用场景
场景一:如果想要获取对象的某个属性的值之前,想要再干点儿别的事情（做额外的处理）。就可以给这个属性添加getter
场景二:想要拿到某个属性被使用的时刻

3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值
a.格式
b.使用场景
在给属性赋值前想要再干点儿别的实行，就给属性添加setter

class Car:
    def __init__(self):
        self.color = '黄色'
        self.type = '自行车'
        # _price属性是保护类型
        self._price = 2000

    # 给_price属性添加getter
    @property
    def price(self):
        print('在使用_price属性')
        return self._price

    # 想要给一个属性添加setter,必须先给这个属性添加getter
    @price.setter
    def price(self, price):
        if isinstance(price, int) or isinstance(float):
            self._price = price
        else:
            self._price = 0

# 练习:声明一个员工类,其中有一个属性是是否已婚(bool),获取值之前根据存的值返回'已婚'/'未婚'
class Staff:
    def __init__(self, name, salary):
        self.name = name
        self.salary =salary
        self._is_marry = False

    @property
    def is_marry(self):
        if self._is_marry:
            return '已婚'
        return '未婚'

    @is_marry.setter
    def is_marry(self,marry):
        self.is_marry = marry

s1 = Staff('xx', 5000)
print(s1.is_marry)

s1._is_marry = True
print(s1.is_marry)

五.继承

python中类可以继承,并且支持多继承
程序中的继承:就是让子类直接拥有父类的属性和方法(继承后父类中的内容不会因为被继承而减少)

1.继承的语法
class 类名(父类):
类的内容
注意:声明类的时候没有写继承,那么这个类会自动继承python的基类,object,相当于写的是class 类名(object):
python中所有的类都是直接或间接的继承object

2.能继承啥
a.所有的属性和方法都能继承
b.slots的值不会继承,但是会影响子类对象的dict属性,不能获取到父类继承下来的属性

class Person(object):
    """人类"""
    # 字段
    number = 61

    # 对象属性
    def __init__(self, name1='张三', age1=18):
        self.name = name1
        self.age = age1
        self._height = 160

    # 对象方法
    def show_message(self):
        print('姓名:%s 年龄:%d' % (self.name, self.age))

    # 类方法
    @classmethod
    def show_number(cls):
        print('人类的数量%d亿'%cls.number)

    # 静态方法
    @staticmethod
    def complaint():
        print('人类殴打小动物!')

class Student(Person):
    """学生类"""
    pass



if __name__ == '__main__':
    # 创建Person类的对象
    p = Person()
    # p.sex = 'boy'
    # print(p.__dict__)

    # 创建Student类的对象
    stu1 = Student()

    print(Student.number)
    stu1.name = '李四'
    print(stu1.name)
    stu1.show_message()
    Student.show_number()
    Student.complaint()

    stu1.sex = 'girl'
    print(stu1.__dict__)

六.方法的重写

1.添加方法
直接在子类声明中声明相应的方法
2.添加对象属性
对象的属性是通过继承父类的init方法而继承下来
如果想要在保留父类的对象的同时添加自己的对象属性,需要在子类的init方法中通过super()去调用父类的方法

3.方法的重写
在子类中重新实现父类的方法,就是重写
方式1:直接覆盖父类的实现
方式2:保留父类的功能再添加其他功能

4.类中方法的调用过程
先在当前这个类中去找,没有就去父类中找,找不到再去父类的父类中找,以此类推,如果在基类中都没有找到才崩溃
在第一次找到的位置,去调用
注意:使用super时必须是通过super()来代替父类或父类对象

class Animal:
    def __init__(self):
        self.age = 0
        self.sex = '雌'

    def shout(self):
        print('嗷嗷叫')

class Cat(Animal):

    def __init__(self):
        # 调用父类的init方法
        super().__init__()
        self.name = '小花'
    foot = '鱼'

    def shout(self):
        print(super())
        print('喵喵~')




class Dog(Animal):
    def shout(self):
        # 通过super()调用父类的方法,保留父类的功能
        super().shout()
        print('汪汪汪')

cat1 =Cat()
print(cat1.age)
print(cat1.name)
cat1.shout()

dog1 = Dog()
dog1.shout()

if __name__ == '__main__':
    pass

七.运算符的重载

定义:
如果希望类的对象支持相应的运算符操作(例如:加减乘除,大于等于小于),就必须实现相应的魔法方法
+:add

:gt
...
一般情况需要对>或<进行重载,重载后可以通过sort方法直接对对象的列表进行排序

class Student:
    def __init__(self,name='',age=0,score=0):
        self.name = name
        self.age = age
        self.score = score

    # self:+前面的对象,other:+后面的对象
    def __add__(self, other):
        return self.score+other.score

    # 重载 > 符号
    # 注意:重载>和<可以只重载一个,另外一个对应的功能自动取反
    def __gt__(self, other):
        return self.age>other.age

    # 重写魔法方法__str__,用来定制对象的打印样式
    def __str__(self):
        return 'Student: %s %d %d'%(self.name,self.age,self.score)

if __name__ == '__main__':
    s1 = Student('小明',18,90)
    s2 = Student('老王',29,84)

    print(s1>s2)
    print(s1+s2)