01类和对象

1、理论上的定义
类：就是拥有相同功能和相同属性的对象的集合（类是抽象的）
对象：类的实例（对象是具体的）
2、编程思想
面向过程编程：以算法为工具
函数式编程：以函数为工具
面向对象编程：以类和对象为工具

02类的声明

1、类：对拥有相同功能（方法）和相同属性（属性）的封装
封装效果：一个类中可以对多个功能进行封装（多个函数）。封装多个属性

2、类的声明格式

class 类名(父类列表):
    类的说明文档
    类的内容

3、说明：
class :声明类的关键字
类名：标识符，不能是关键字。驼峰式命名（第一个单词首字母小写，其他单词首字母大写），
（父类列表）：这个部分可以省。这个是继承语法，可以多继承。
冒号：固定的
类的内容：包括类的方法和类的属性

4、类中的方法
方法：就是声明在类中的函数
a.对象方法:对象方法需要通过对象来调用，对象.函数名（）
b.类方法:直接写在类中的方法，自带一个self参数。
c.静态方法

5.创建对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法。
构造方法：类名() ---> 创建类对应的对象。

例子：

# 创建一个类
class Person:
    """
    人类：

    """
    def eat(self):
        print('人吃饭')
if __name__ == '__main__':

    # 1、创建对象
    p1 = Person() #创建Person类的对象，并且将对象的地址存到地址p1中。
    # 一个类可以有多个对象
    p2 = Person()
    print(id(p1),id(p2))

    # 2、调用对象方法
    # 通过对象调用对象方法，默认参数self不需要传参。系统会自动传。
    p1.eat()

03-构造方法和init方法

1、构造方法：系统自动创建的，方法名和类名一样。用来创建对象。

2、init：init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法。

class Dog:
    def __init__(self):
        print('init方法')

class Person:
    # init方法可以添加参数
    def __init__(self, name):
        print(name)
        print('人类的init方法')

if __name__ == '__main__':
    # 创建对象的过程：调用构造方法在内存中开辟空间创建一个对象，然后用新建的这个对象去调用init方法，
    #                   来初始化对象的属性，最后才将对象返回。
    dog1 = Dog()
    dog2 = Dog()

    # 如果类的init方法有参数，通过给构造方法传参类init方法传参。
    p1 = Person('小明')

04-对象的属性

1、类中的内容：属性和方法
属性：
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性是对象属性。属于对象
类中的对象属性是声明在init方法中的，并且声明格式是:self.属性名 = 初值；
对象属性的使用：对象.属性名
b.类的字段：属于类的，所有的对象对应的值是一样的
方法：
a.对象方法
b.类方法
c.静态方法

2、python是动态语言，python中类的对象的属性可以进行增删的操作
1）、 查（获取属性的值）

    方法一：对象.属性名
    方法二：getattr(object(对象), name（属性名）, default=None)
    方法三：对象.__getattribute__(属性名)

2、改（修改属性的值）

 方法一：对象.属性 = 新值
 方法二：setattr(p1, 'age', 20)
 方法三：对象.__setattr__(属性名，新值)

3、增（添加属性 ---- 属性不存在）

    方法一：对象.属性 = 新值
    方法二：def setattr(对象，属性名，新值)
    方法三：对象.__setattr__(属性名，新值)

4、删（删除对象属性）

    方法一：del 对象.属性
    方法二：delattr(对象，属性名)
    方法三：对象.__delattr__()

05-对象方法

对象方法：
a、直接声明在类中的函数默认是对象方法，有一个默认参数self。
b、对象方法要通过对象来调用：对象.对象方法()
c、对象方法中默认参数self，不需要传参。因为在调用这个方法的时候系统会自动将当前对象传给self。
哪个对象调用的方法，self就指向谁。

练习1、写一个矩形类，有长和宽，有两个功能，分别是求周长和面积。

class Rect:
    def __init__(self, width, high):
        self.width = width
        self.high = high
    def C(self):
        return 2*(self.width+self.high)
    def Area(self):
        return self.high*self.width
rect1 = Rect(2,3)
print('该矩形的周长是%d,面积是%d'%(rect1.C(),rect1.Area()))

练习2、写一个班级类，班级里面有多个学生的成绩（一门）,班级名，可以获取成绩的最高分

class Class:
    def __init__(self, class_name, score):
        self.class_name = class_name
        self.score = score
    def get_max(self):
        if not self.score:
            return 0
        return max(self.score)
class1 = Class('1班', [35,56,67,78,89,90,43])
print('%s里的最高分是%d'%(class1.class_name,class1.get_max()))

06-类的字段与方法

1、类的属性叫类的字段
a.什么是类的字段
类的字段就是声明在类的里面，方法的外面的变量，
b.什么样的属性声明成类的字段：
属于类的，对于这个类的所有的对象来说，其值是公有的
c.怎么使用：
通过类来使用：类.字段
2、类中的方法
1）.对象方法（实例方法）
声明的形式：直接声明在类型。
特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁。
调用：通过对象来调用。
2）.类方法
声明的形式：声明方法前需要使用@classmethod说明
特点：自带一个默认参数cls,这个参数调用的时候不需要传值。系统自动给他传。谁调用就指向谁。始终指向当前类。

调用：通过类来调用 --- 类.类方法()
3）.静态方法：
声明形式：声明方法前需要使用@staticmethod说明
特点：没有默认的参数
调用：通过类来调用---类.静态方法()
@staticmethod

4）.遇到问题怎么来选择使用哪种方法：
a、大前提：只要实现方法的功能需要用到对象的属性，我们就使用对象方法。否则就使用静态方法或者类方法。
b、不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法。
c、实现功能既不需要对象的属性，又不需要类的字段就使用静态方法。
注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然。

实例：

class Person:
    def object_faunc(self):
        print('对象方法')

    # 声明一个类方法
    @classmethod
    def class_func(cls):
        print('这是一个类方法')

    @staticmethod
    def static_func():
        print('这是一个静态方法')


class Person:
    # 类的字段，存储人类的数量
    number = 61

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

    @staticmethod
    def sho_numbers():
        print('人类的数量是%d亿' % (Person.number))
Person.show_number()
Person.sho_numbers()