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)对象属性的增删改查
点的方式操作：
增: 对象.新属性 = 值
删: del 对象.属性
改: 对象.属性 = 新值
查: 对象.属性
attr方式操作：
增: setattr(对象, 属性, 值)
删: delattr(对象, 属性)
改: setattr(对象, 属性, 新值)
查: getattr(对象, 属性, 默认值) 如果查找的属性不存在，返回默认值

4)内置类属性

class Person:
    # 注意：如果设置字段__slots__的值，那么当前类的对象就不能再使用__dict__属性
    # __slots__ = ('name', 'age')  # 实际开发中用的特别少

    def __init__(self, name):
        print('init方法', name)
        self.name = name

    # 定制，单独打印对象的时候的样式 返回值是什么就打印什么(要求返回值的类型必须是字符串)
    def __str__(self):
        # 打印的谁self就是谁
        return '<'+str(self.__dict__)[1:-1]+'>'

    # 定制，单独打印对象的时候的样式 返回值是什么就打印什么(要求返回值的类型必须是字符串)
    def __repr__(self):
        return '<'+str(self.__dict__)[1:-1]+'>'

伪代码：

def Person(*args, **kwargs):
    对象 = 创建对象
    对象.__init__(*args, **kwargs)
    return 对象

p1 = Person(name='xiaoming')
p2 = Person(name='小花')

persons = [p1, p2]

print(p1, p2)
print(persons)

# print(p1.__dict__)

作业讲解

import math
import random

1.声明一个电脑类: 属性:品牌、颜色、内存大小 方法:打游戏、写代码、看视频

a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性

class Computer:
    """说明文档：电脑类"""
    # 属性
    def __init__(self, brand, color, ram):
        self.brand = brand
        self.color = color
        self.cpuSize = ram

    # 方法
    def play_game(self):
        print('玩游戏')

    def Coding(self):
        print('敲代码')

    def watchTV(self):
        print('看视频')

com1 = Computer('联想', '白色', 8)
# 增
# com1.size = 15
setattr(com1, 'size', 15)

# 删
# del com1.color
delattr(com1, 'color')

# 改
# com1.brand = '戴尔'
setattr(com1, 'brand', '戴尔')

# 查
print(com1.brand)
print(getattr(com1, 'brand', '苹果'))

2.声明一个人的类和狗的类:

狗的属性:名字、颜色、年龄
狗的方法:叫唤
人的属性:名字、年龄、狗
人的方法:遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄

class Dog:
    """文档说明：狗类"""
    # 属性
    def __init__(self, name, age=0, color='黄色'):
        self.name = name
        self.color = color
        self.age = age

    # 方法
    def shout(self):
        print('%s:汪汪汪...' % self.name)

class Person:
    """文档说明：人类"""
    # 属性
    def __init__(self, name: str, age=0):
        self.name = name
        self.age = age
        self.dog = None

    # 方法
    def walk_the_dog(self):
        if self.dog:
            print('%s正在遛他的狗%s' % (self.name, self.dog.name))
        else:
            print('没有狗！溜自己！')

p1 = Person('小明', 18)
p1.dog = Dog('大黄', 3)
p1.walk_the_dog()

3.声明一个圆类，自己确定有哪些属性和方法

class Circle:
    """文档说明：圆类"""
    # 属性
    def __init__(self, radius):
        self.radius = radius

    # 方法
    def get_perimeter(self):
        """
        求圆的周长
        :return: 圆的周长
        """
        return 2*math.pi*self.radius

    def get_area(self):
        """
        求圆的面积
        :return: 圆的面积
        """
        return math.pi*self.radius**2

4.创建一个学生类:

属性:姓名，年龄，学号
方法:答到，展示学生信息

创建一个班级类:
属性:学生，班级名
方法:添加学生，删除学生，点名, 求班上学生的平均年龄

class Student:
    """文档说明：学生类"""
    # 属性
    def __init__(self, name, age=18):
        self.name = name
        self.age = age
        self.stu_id = '001'

    # 方法
    def reply(self):
        print('%s, 到！' % self.name)

    def show(self):
        print('姓名:%s,年龄:%d,学号:%s' % (self.name, self.age, self.stu_id))


class Class:
    """文档说明：班级类"""
    # 属性
    def __init__(self, name: str):
        self.students = []
        self.name = name
        self.id_creater = ('stu'+str(x).zfill(3) for x in range(1, 101))

    # 方法
    def add_student(self):
        # 输入信息
        name = input('姓名:')
        age = int(input('年龄:'))
        stu_id = next(self.id_creater)

        # 创建学生
        stu = Student(name, age)
        stu.stu_id = stu_id

        self.students.append(stu)

    def del_student(self, name):
        flag = False
        for stu in self.students[:]:
            if stu.name == name:
                flag = True
                stu.show()
                value = input('是否删除(Y/N):')
                if value == 'Y':
                    self.students.remove(stu)

        if not flag:
            print('没有找到该学生！')

    def call_the_roll(self):
        for stu in self.students:
            # print(stu.name)
            if random.randint(0, 1) == 1:
                # 答到
                stu.reply()

c1 = Class('py1902')

print('===添加学生===')
for _ in range(5):
    c1.add_student()

print('===删除学生===')
c1.del_student('小明')

print('===点名===')
c1.call_the_roll()

property

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

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

1. 语法:
   声明属性或者方法的时候，在属性名或者方法名前加'__'

2. python私有化
   python并不能像java一样从访问权限上去限制属性和方法，没有真正的私有属性和方法
   私有化只是在两个下划线开头的名字前加前缀'_类名',导致不能直接通过原名进行访问

class Person:
    __num = 30

    def __init__(self, name, age=10):
        self.name = name
        self.age = age
        self.__gender = '男'

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

    def __run(self):
        print('%s在跑步' % self.name)

p1 = Person('小明')

# print(Person.num)
print(p1.name)
p1.eat()

# print(Person.__num)
# print(p1.__gender)

# p1.run()

print(p1.__dict__, p1._Person__gender)

2.对象属性的保护: 不要直接访问或者修改对象属性的值，而是通过属性访问器(getter)和修改器(setter)去操作对象属性

需要添加getter和setter的对象属性，属性命名的时候需要在最前面加''
(添加''的目的是为了告诉使用者，这个属性添加了getter或者setter)

1. getter - 获取属性(间接取值)
   a.语法：

@property
def 函数名(self):
    其他语句
    return 属性值

b.说明:
函数名 - 对应的属性名去掉下划线
属性值 - 和对应的有下划线的属性值有关联
(方便将内存中的数据进行某些操作后再返回:比如内存中存储的1到7，返回值为周一到周天)
而且输出的时候只需要通过'对象.属性'来输出属性值(而实际上是调用的函数)

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

2)setter - 给属性赋值(间接赋值)
想要添加setter必须先添加getter
a.语法：

@属性值.setter
def 函数名(self, value):
    其他语句

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

print('=====getter和setter=====')
class Student:
    def __init__(self, name1):
        self._name = name1  # 对象._属性 在外面可以访问数据，但是这种访问方式是不推荐的
        self._week = 1
        self._age = 1
    
    @property
    def name(self):
        return self._name
    
    @property
    def week(self):
        if self._week == 1:
            return '星期一'
        elif self._week == 2:
            return '星期二'
        elif self._week == 3:
            return '星期三'
        elif self._week == 4:
            return '星期四'
        elif self._week == 5:
            return '星期五'
        elif self._week == 6:
            return '星期六'
        elif self._week == 7:
            return '星期天'
    
    @property
    def age(self):
        return self._age
    
    @age.setter
    def age(self, value):
        if isinstance(value, int):
            if value < 0 or value > 200:
                print('年龄范围只能在0~200')
            else:
                self._age = value
        else:
            print('年龄只能是整数！')
            self._age = 0

stu = Student('小明')
# print(stu._name)  # 可以访问数据，但是不推荐这样访问数据
print(stu.name)  # 通过不带下划线去获取属性的值的时候，本质是在调用属性对应的getter方法，结果是getter的返回值
print(stu.week)

stu.age = 10
stu.age = 222

print('===================')
class Circle:
    def __init__(self, r):
        self.r = r
        self._area = None
    
    @property
    def area(self):
        return self.r**2*3.1415926

c1 = Circle(2)
print(c1.area)

c1 = Circle(10)
print(c1.area)

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

并且不能修改周长和面积的值(如果主动给周长和面积赋值，程序直接报错)

print('=====练习=====')
class WriteError(Exception):
    def __str__(self):
        return '尝试修改一个只读的属性！'

class Rect:
    """矩形类"""
    def __init__(self, long, width):
        self._long = long
        self._width = width
        self._perimeter = (long + width)*2
        self._area = long * width
    
    # 1.long
    @property
    def long(self):
        return self._long
    
    @long.setter
    def long(self, value):
        self._long = value
        self._perimeter = (self._long + self._width)*2
        self._area = self._long * self._width
    
    # 2.width
    @property
    def width(self):
        return self._width
    
    @width.setter
    def width(self, value):
        self._width = value
        self._perimeter = (self._long + self._width) * 2
        self._area = self._long * self._width
    
    # 3.perimeter
    @property
    def perimeter(self):
        return self._perimeter
    
    @perimeter.setter
    def perimeter(self, value):
        raise WriteError
    
    # 4.area
    @property
    def area(self):
        return self._area
    
    @area.setter
    def area(self, value):
        raise WriteError

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

r1.long = 10
print(r1.long, r1.width)
print(r1.perimeter, r1.area)
# r1.perimeter = 20

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

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

2. 类方法
   a.怎么声明：声明函数前添加@classmethod装饰器
   b.特点：有默认参数cls; 调用的时候不用传参，系统将调用这个方法的类传给它，指向当前类
   c.怎么调用：通过类来调用
   d.什么时候使用：在不需要对象属性的前提下，需要类的字段，就使用类方法(比起静态方法，更灵活)

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

class Person:
    num = 61

    def __init__(self, name='张三', age=0):
        self.name = name
        self.age = age

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

    # 类方法
    @classmethod
    def show_count(cls):
        print('类方法', cls)

        # cls:当前类，当前类能做的事情，cls都能做
        print(cls.num)  # 使用类的字段

        p = cls()  # 创建对象
        print(p)

    # 静态方法
    @staticmethod
    def static():
        print('静态方法', Person.num)

class Student(Person):
    num = 30

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

继承

1.继承

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

1)语法：

class 类名(父类):
    类的内容

2.在子类中添加内容

1. 在子类中添加字段和方法
   直接在子类中声明新的字段和方法
2. 添加对象属性
   在子类中实现init方法，并且添加新属性 同时需要通过super().init()去调用父类的init方法

补充：类中的函数的调用过程
先看当前类中是否有这个方法，如果有直接调用自己的方法；没有就去看父类有没有这个方法，如果有就调用父类的方法；
如果也没有就找父类的父类，以此类推，如果找到object都没有找到这个方法，才报错

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

3.重写

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

class Person:
    num = 61

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

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

    @staticmethod
    def run():
        print('人在跑步')

    def func(self):
        print('这是一个对象方法', self.name)

class Student(Person):
    # 1.添加字段和方法
    num = 60
    id_pre = 'stu'

    @staticmethod
    def study():
        print('好好学习，天天向上')

    # 2.添加对象属性
    def __init__(self):
        # 调用当前类的父类的__init__方法
        super().__init__()
        self.stu_id = '001'
        self.score = 0

    # 3.重写方法
    @classmethod
    def run(cls):
        print('=====')
        # super().run()  # 调用父类方法
        # cls.__bases__[0].run()  # __bases__获取所有的父类(返回一个元组)
        print('学生在跑步')
        print('=====')

    def func(self):
        super().func()
        # self.__class__.__bases__[0]().func()
        print('+++++')

stu = Student()
# 继承
# print(Student.num)
# print(stu.name, stu.age, stu.gender)
# stu.eat('面条')

# 添加字段和方法
# print(Student.id_pre)
# Student.study()

# 添加对象属性
print(stu.stu_id, stu.score)
print(stu.name)  # 在子类未调用super方法之前，是没有继承父类的属性的(即不可用)

Student.run()
Person.run()

stu.func()

print(Student.__bases__, Person.__bases__)