day15总结

1. 什么是类，什么是对象
   类就是拥有相同功能相同属性的对象的集合 抽象的概念
   对象是类的实例

2. 类的声明
   class 类名：
   类的说明文档
   属性（字段属性，对象属性）
   方法（对象方法，类方法，静态方法）

3.创建对象
类（）

4.对象方法
a. 怎么声明： 直接声明在类中的函数
b. 特点： 有个自带的参数self 通过对象调用的时候这个参数不用传参。系统会自动将当前对象传给self
c. 怎么调用： 通过对象来调用

5. init方法 和 构造方法

6. 属性
   1）字段：
   a. 怎么定义： 直接声明在类中的变量
   b. 怎么使用： 通过类去使用（类.字段）
   c. 什么时候用： 如果属性值不会因为对象不同而不一样

2）对象属性
a. 怎么定义： 声明在init方法中，以‘self.属性 = 值 ’ 的方式声明的
b. 怎么使用： 通过对象去使用，
c. 什么时候用： 如果属性值会因为对象不同而不一样

3）对象属性的增删改查：

4） 内置属性

注意：如果设置字段slots的值，呢么当前类的对象就不能再使用dict属性

str(self)

定制，单独打印对象的时候的样式，返回值是什么就打印什么（要求返回值的类型必须是字符串）
打印的谁 self就是谁

repr(self)

定制，单独打印对象的时候的样式，返回值是什么就打印什么（要求返回值的类型必须是字符串）
打印的谁 self就是谁

本质上，python中所有的属性和方法都是公开的，在类的外部可以使用也可以被继承。

1. 私有化 --- 让属性和方法只能在类的内部使用，不能再类的外部使用

'''

1. 语法：
   声明属性或者方法的时候，在属性名或者方法名前加‘__’ （只在前面加两个下划线）

2）python私有化的原理
python并不能像Java一样从访问权限上去限制属性和方法，没有真正的私有属性和方法

私有化只是在两个下划线开头的名字前加前缀‘_类名’， 导致不能直接通过原名进行访问

class Person:

    __num = 90 # num 已经私有化了

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

    def eat(self,food='米饭'):
        print('%s在吃%s' % (self.name,food))
        print(Person.__num)


# print(Person.__num)    会报错

p1 = Person('xiaoming',20)
p1.eat()

2. 对象属性的保护

不要直接访问或者修改对象属性的值，而是通过属性访问器（getter）和修改器（setter）去操作对象属性

class Student:
    def __init__(self, name1):
        self._name = name1

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,value):
        if isinstance(value, str):
            self._name = value
        else:
            print('请输入正确的名字')

需要添加getter或者setter的对象属性，属性命名的时候需要在前面加‘_’。
(添加下划线的目的是告诉使用者，这个属性我给他添加了getter或者setter)

1） 属性访问器（getter） --- 获取属性的值（间接）
a. 语法：
@property
def 函数名（self）
其他语句
return 属性值

b. 说明
函数名 -- 是对应的属性名去掉下划线
属性值 -- 和对应的有下划线的属性值有关联

c. 什么时候用
如果希望在获取某个属性的值之前干点别的事情，就给这个属性添加getter。

2）属性修改器（setter） --- 给属性赋值（间接）
要添加setter，必须先有getter

a. 语法：
@getter名.setter
def 函数名(self,参数):
其他语法
self.属性 = 值

c. 什么时候使用
如果在给属性赋值之前干点别的事情，就给这个属性添加setter

练习： 声明矩形类，属性有长、宽、周长、面积 ；要求修改长和款的值得时候，周长和面积自动发生改变。

并且不能修改给周长和面积赋值，如果主动给周长和面积赋值就报错

class WriteError(Exception):
    def __str__(self):
        return '尝试修改一个只读的属性!'


class Rect:
    def __init__(self, length, width):
        self._length = length
        self._width = width
        self._perimeter = (length + width) * 2
        self._area = length * width

    # 1.length
    @property
    def length(self):
        return self._length

    @length.setter
    def length(self, value):
        self._length = value
        self._perimeter = (self._length + self._width)*2
        self._area = self._length * self._width

    # 2.width
    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        self._width = value
        self._perimeter = (self._length + self._width) * 2
        self._area = self._length * self._width

    # 3.perimeter
    @property
    def perimeter(self):
        return self._perimeter

    @perimeter.setter
    def perimeter(self, value):
        print('周长不能直接改修！')
        raise WriteError

    # 4.area
    @property
    def area(self):
        return self._area

    @area.setter
    def area(self, value):
        print('面积不能直接改修！')
        raise WriteError


r1 = Rect(4, 5)
print(r1.perimeter, r1.area)

r1.width = 10
print(r1.perimeter, r1.area)

r1.length = 10
print(r1.perimeter, r1.area)

# r1.perimeter = 300
# print(r1.width, r1.length)
# r1.perimeter = 200
# r1.area = 300
print(r1.perimeter)

r1.perimeter = 10

1. 类中的方法： 对象方法、类方法、静态方法

1） 对象方法
a. 怎么声明： 直接声明在类中
b. 特点： 有默认参数 self ；调用的时候不用传参，指向当前对象
c. 怎么调用： 通过对象来调用 对象.对象方法
d. 什么时候使用：如果实现函数的功能，需要使用对象属性，就用对象方法

2. 类方法
   a. 怎么声明： 声明函数前添加 @classmethod
   b. 特点： 有个默认参数 cls ；调用的时候不用传参,系统将调用这个方法的类传给他，指向的是当前类。
   c. 怎么调用： 通过类来调用
   d. 什么时候使用： 在不需要对象属性的前提下，需要类的字段就使用类方法。

3. 静态方法
   a. 怎么声明： 声明函数前加 @staticmethod
   b. 特点： 没有默认参数
   c. 怎么调用： 通过类来调用
   d. 什么时候使用： 既不需要对象属性，也不需要类的字段，就使用静态方法。

class Person:

    num = 99

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

    #   对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name,food))


#     类方法
    @classmethod
    def show_count(cls):
        # cls：当前类，当前类能做的事情，cls都可以做
        print('类方法')
        print(cls.num)  # 使用类的字段

        p = cls('小明')       # 创建对象
        print(p)

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

p1 =Person('小明')
p1.show_count()

Person.static()  # 通过类来调用

继承

'''
继承者 --- 子类

被继承者 --- 父类

继承 --- 让子类直接拥有父类的属性和方法

1. 语法：
   class 类名(父类):
   类的内容

class Person:
    num = 61

    def __init__(self):
        self.name = '小明'
        self.age = 19
        self.gender = '男'

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))


class Student(Person):
    num = 21
    id_pre = 'stu'

    # @staticmethod
    @classmethod
    def study(cls):
        super().eat(cls)
        print('好好学习')

    def __init__(self):
        super().__init__()
        self.stu_id = '001'
        self.score = 90


print(Student.num)
stu = Student()
print(stu.name)

2. 在子类中添加内容

1. 在子类中添加字段和方法
   直接在子类中声明新的字段和方法

2） 添加对象属性
在子类中实现init 方法，并且添加新属性。同时需要通过super().init 去调用父类的init方法

3. 重写方法
   在子类中重写实现父类的函数 ; 可以通过super()去调用父类中的方法
   注意： super()不能再静态方法中使用，只能在对象方法和类方法中使用。

python中所有的类默认都是继承object，object是python中所有类的基类

补充： 类中的函数调用过程

先看当前类中是否有这个方法，如果有 就直接调用自己的方法；

没有 就去看父类有没有这个方法

如果有就调用父类的方法； 如果父类也没有，就找父类的父类

直到找到object都没有找到这个方法，才报错