一、属性的私有化

属性的访问权限:公开、保护(python中没有)、私有
公开:指的是在类的外部可以直接使用(默认的是公开的)
公开属性:属性名是普通单词(就是不以两个下划线开头的属性)

私有:只能在类的内部直接使用
私有属性:属性名以两个下划线(__)开头，不以两个下划线结束

  class Person:
    """人类"""
    def __init__(self, name='', age=0):
        # name属性是公开属性
        self.name = name
        # __age属性是私有属性
        self.__age = age

    def show(self):
        print(self.name)
        # 私有属性可以在类的内部使用
        print(self.__age)

p1 = Person('小明')
print(p1.name)

# 私有属性不能在类的外部使用
# print(p1.__age)   报错:AttributeError

# 可以在内部使用
p1.show()

二、假的私有属性

实际开发中，声明类的属性很少会使用正真的私有属性(前面加两个下划线)。

实际对属性的要求:1.可以通过点语法方便的给属性赋值或者拿到它的值(不能是私有的)
2.给属性赋值的时候，需要对赋过来的值进行规范，不能直接让值赋给属性(不是直接的公开属性)

满足要求:就使用假的私有属性+getter和setter

步骤：
1.声明属性，属性名前加一个下划线
(这是规范，不是语法:带一个下划线的属性，不要直接通过一个下划线对应的属性名去访问)
2.通过给属性添加getter和setter来限制赋值和获取值的过程
a.添加getter:-->限制获取属性值的操作
getter的作用:返回属性值

@property
def 属性名去掉下划线(self):
    其他任何操作
    return self.带下划线的属性名

b.添加setter:-->给限制获取的属性值赋值

@属性名去掉下划线.setter
def 属性名去掉下划线(self, 参数):
    其他任何操作
    self.带下划线的属性 = 参数

3.在类的外部通过不带下划线的属性去获取属性的值或者给属性赋值

class Person:
    def __init__(self, name='', age=0):
        # 声明属性的时候，在属性名前加_是为了告诉别人，
        # 这个属性不要直接访问，要通过getter或setter去访问
        self._name = name
        self._age = age

    # 给_name属性添加getter
    @property
    def name(self):
        if len(self._name) == 0:
            return '无名氏'
        return self._name

    # 给_name属性添加setter
    @name.setter
    def name(self, name1):
        # 可以在赋值前给它其他操作
        if isinstance(name1, str):
            self._name = name1
        else:
            self._name = ''

    @property
    def age(self):
        if self._age > 18:
            return '哈哈哈'
        return self._age

    @age.setter
    def age(self, age1):
        if isinstance(age1, int):
            self._age = age1
        else:
            self._age = 0

p1 = Person('小明', 10)
# print(p1._name)   # 不会报错，但是不推荐使用

# 获取
print(p1.name)  # 小明
print(p1.age)   # 10

# 赋值
p1.name = '娜美'
print(p1.name)  # 娜美
p1.age = 15
print(p1.age)   # 15

实例二:getter和setter的使用以及关系

1.getter一般要添加，setter可以不用写
2.如果要添加setter，必须添加getter
注意:如果是要给赋值添加条件就必须在setter里去添加条件

class Cat:
    """猫"""
    def __init__(self, name='', color=''):
        self._name = name
        self._color = color

    @property
    def name(self):
        if isinstance(self._name, str):
        return self._name
        else:
            return ''

cat1 = Cat('小花', 'yellow')
cat1._name = '喵喵'  # 推荐
# print(cat1._name)   # 不推荐

练习:写一个学生类，有名字、成绩两个属性，要求成绩是数字、名字是字符串

class Student:
    """学生类"""
    def __init__(self, name='', sex=0):
        self._name = name
        self._sex = sex

    # 在getter中限制
    @property
    def name(self):
        # 方法1
        # if isinstance(self._name, str):
        #     return self._name
        # else:
        #     return ''

        # 方法2
        return str(self._name)

    @property
    def sex(self):
            return self._sex

    @sex.setter
    def sex(self, sex):
        if isinstance(sex, int) or isinstance(sex, float):
            self._sex = sex
        else:
            self._sex = 0

stu1 = Student('小明', 100)
stu1._name = 123
print(stu1.name)

stu1.sex = 'abc'
print(stu1.sex)

三、类字段和类方法

1.类字段就是类属性:要通过类去获取
类字段是声明在类里面，函数外面的变量

2.类方法:通过类去调用
开发中怎么确定声明方法是对象方法还是类方法:
看实现功能是否需要对象属性来支持，如果需要就必须声明成对象方法

class Person:
    """人类"""
    # 这个person_num就是一个类字段
    person_num = 0

    # 用@classmethod来说明下面的函数是一个类方法
    # 所有的类方法都有一个默认参数cls,这个参数不需要传参，
    # 系统会自动调用方法的类传给它(谁调用指向谁)
    @classmethod   # -->函数修饰符
    def hurt_earth(cls):
        print(cls)
        print('人类伤害地球', Person.person_num, cls.person_num)
        # 可以通过Person.person_num, cls.person_num来调用

# 类字段要用类去使用
print(Person.person_num)

Person.hurt_earth()  # <class '__main__.Person'>   人类伤害地球 0 0
print(Person)   # <class '__main__.Person'>

写一个数学类，提供数据的加/减/乘/除的功能

class Math:
    @classmethod
    def add(cls, *num):
        sum1 = 0
        for x in num:
            sum1 += x
        return sum1

sum2 = Math.add(10, 2, 3)
print(sum2)

四、静态函数

静态函数:在类中声明，由类来调用的方法

实例一：静态方法

class Math:
    """数学类"""
    # multiply就是一个静态方法
   @staticmethod
    def multiply(num1, num2):
        return num1 * num2

# 静态方法需要通过类来调用
sum1 = Math.multiply(10, 2)
print(sum1)

实例二：静态方法和类方法的区别
静态方法和类方法都是通过类去调用

区别:
1.类方法都有一个默认参数cls指向调用方法的类，但是静态方法没有
2.类型不一样，静态方法的类型是function，类方法的类型是method

class Download:
    """下载类"""

    @staticmethod
    def download_image(image_file):
        print('下载%s下的图片' % (image_file))

    @classmethod
    def download_movie(cls, movie_file):
        print('下载电影:%s' % (movie_file))

    # 类中的普通函数也是通过类来调用(就是一个静态方法)，不建议使用
    def download(num):
        print('aaa', num)

Download.download_image('aa/123.png')  # 下载aa/123.png下的图片
print(Download.download_image)   # <function                   
Download.download_image at 0x03163810>

Download.download_movie('aa/abc.mp4')   # 下载电影:aa/abc.mp4
print(Download.download_movie)   # <bound method           
Download.download_movie of <class '__main__.Download'>>

print(Download.__dict__)

Download.download(100)   # aaa 100
print(Download.download)   # <function Download.download at 0x03363738>

五、类的继承

继承:就是让子类去拥有父类的属性和方法
子类:继承者
父类(超类):被继承者

什么时候用继承:在写一个类的时候，发现这个类中的部分属性和方法另一个类都拥有，
这个时候就不用去声明这些属性和方法，直接从另一个类中继承下来就可以

实例一:怎么继承

class 子类(父类):
    子类内容

class Person:
    """人类"""
    def __init__(self, name='aaa', age=0):
        self.name = name
        self.age = age

class Student(Person):
    pass

stu1 = Student()
print(stu1.name)

实例二:可以继承哪些东西
1.公开的属性可以继承
2.私有的属性不可以继承
3.公开的对象方法可以继承，私有的不行
4.类的字段可以继承
5.类的方法和静态方法都可以

总结:属性和方法 除了私有的都可以继承

class Animal:
    # 1.对象的属性
    def __init__(self, name='abc'):
        self.name = name
        self.__age = 18

    def run(self):
        print(self.__age)

    # 2.对象方法
    def eat(self):
        print('吃东西')

    # 私有的对象方法，只能类的内部调用
    def __shout(self):
        print('叫')

    # 3.类字段
    count = 100

    # 4.类方法
    @classmethod
    def class_func(cls):
        print('class_func')

    # 5.静态方法
    @staticmethod
    def static_func():
        print('static_func')

class Dog(Animal):
    pass

dog1 = Dog()
print(dog1.name)
dog1.eat()
print(Dog.count)
Dog.class_func()
Dog.static_func()

六、类的继承重写

声明一个类，如果不声明其父类，那么这个类默认继承自object这个类
object类是python中所有类直接或者间接的父类

实例一:什么是重写
重新实现从父类继承下来的方法--->重写

class Animal(object):
    def __init__(self, name=''):
        self.name = name

    def shout(self):
        print('%s叫唤' % (self.name))

    def be_beat(self):
        print(self.name, '在跑')
        print('跑的时候嗷嗷叫')

class Dog(Animal):

    # 重写父类的shout方法，然后通过Dog对象调用shout执行的是子类的方法
    def shout(self):
        print('%s:汪汪汪' % (self.name))

    # 重写父类的be_beat方法，保留了父类实现的功能，并且添加新的功能
    def be_beat(self):
        # super()指的就是父类对象
        super().be_beat()
        print('奋起反抗')

dog1 = Dog('大黄')
dog1.shout()   # 大黄:汪汪汪
dog1.be_beat()

实例二:init方法的继承和重写

class Person:
    """人"""
    def __init__(self, name='', age=0):
        self.name = name
        self.age = age

class Student(Person):

    # 重写init方法要注意:
    # 1.如果需要继承父类的对象属性，
    # 就通过super().__init__()去保留父类的对象属性，然后在添加新的属性
    def __init__(self, name='', age=0, study_id=''):
        super().__init__(name, age)
        self.study_id = study_id

person = Person()
stu1 = Student('name1', 18, '001')
print(stu1.name)

练习:写一个正方形类，拥有方法:求面积，周长，拥有的属性是边长
写一个长方形类，拥有方法:面积，周长，拥有的属性是长和宽

class Rectangle:
    """长方形"""
    def __init__(self, length=0, width=0):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return (self.length + self.width) * 2

class Square(Rectangle):
    """正方形"""
   def __init__(self, length=0, width=0):
        super().__init__(length, width)
        self._side = 0

    @property
    def side(self):
        return self._side

    @side.setter
    def side(self, side):
        self.width = side
        self.length = side
        self._side = side

s1 = Square()
s1.side = 10
print(s1.area())
print(s1.perimeter())