一、类和对象

1.理论上的定义：

• 类：就是拥有相同功能和相同属性的对象的集合（抽象）
• 对象：类的实例（具体）

2.从生活角度

• 如果说人是一个类，具体某个人就是这个类的对象

3.编程方式（思考方式）

• 面向过程编程：以算法为工具
• 函数式编程：以函数为工具
• 面向对象编程：以类和对象为工具（面向生活）

二、类的声明

类

• 对拥有相同功能(方法)和相同属性(属性)的封装

封装效果

• 一个类中可以对多个功能进行封装(多个函数)；封装多个属性

1.类的声明格式

• class 类名(夫类列表)：
• 类的说明文档
• 类的内容

2.说明

• class：声明类的关键字
• 类名：标识符，不能是关键字。驼峰式命名(第一个单词首字母小写，之外每个单词首字母大写)(首字母大写！！！)，见名知义
  列如：Person、StudentSystem
• (父类列表)：这个部分可以省。这个是继承语法，可以多继承
• 冒号：固定的
• 类的内容：包括类的方法和类的属性

3.类中的方法

方法：声明在类的函数

• 对象方法：对象方法需要通过对象来调用，对象.函数名()
  直接写在类中的方法，自带一个self参数
• 类方法
• 静态方法

4.创建对象

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

# 创建一个类
class Person:
    '''人类'''
    def eat(self):
        print('人吃饭')


if __name__ == '__main__':
    # 1.创建对象
    p1 = Person()  # 创建Person类的对象，并且将对象的地址存在p1中
    p2 = Person()  # 一个类可以有多个对象
    p3 = p2  # 只有在调用构造方法的时候才会产生新的对象
    print(id(p1),id(p2),id(p3))

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

三、构造方法和init方法

1.构造方法：

• 系统自动创建的，方法名和类名一样。用来创建对象

2.init:

• init方法的功能是用来做初始化和添加对象属性的
• 当我们通过构造方法去创建对象的时候，系统会自动调用init方法(不需要自动调用)

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


class Person:
    def __init__(self,name,age=18):
        print('人类init方法')
        print(name,age)

if __name__ == '__main__':
    # 创建对象的过程：调用构造方法在内存中开辟空间创建一个对象然后用新建的这个对象去调用init方法，\
    # 来初始化对象的的属性.最后才将对象返回
    dog1 = Dog()
    # 如果类的init方法有参数，通过给构造方法传参类init方法传参
    p1 = Person('小明')
    p2 = Person('小红',20)
    p3 = Person(name = '小涵',age = 23)

四、对象属性和对象方法

类中的内容：属性和方法

1.属性：（保存值）

• 对象的属性：不同的对象，对应的值可能不一样，这就是对象属性
• 格式：类中的对象属性是声明在init方法中的，并且声明格式是：self.属性名 = 初值
• 对象属性的使用：对象.属性名
• 类的字段：属于类的，所有的对应的值是不一样的

2.方法：（保存功能）

• 对象方法
• 类方法
• 静态方法

class Student:
    '''学生类'''
    def __init__(self):
        # 声明对象属性name，age，id
        self.name = '魏世强'
        self.age = 23
        self.id = '001'

class Dog:
    '''狗类'''
    # 创建Dog的对象的时候，必须传类型和颜色
    def __init__(self,type1,color1):
        self.type = type1
        self.color = color1


class Computer:
    def __init__(self,color = '白色',memory = 0):
        self.color = color
        self.memory = memory

class  Rectangle:
    def __init__(self,height,weight):
        self.height1 = height
        self.weight1 = weight



if __name__ == '__main__':
    # stu1就是Student类的对象
    stu1 = Student()
    # 通过对象去使用对象的属性
    print(stu1.name,stu1.age,stu1.id)
    # 通过对象去修改对象的属性
    stu1.name = '王龙'
    print(stu1.name)

    dog1 = Dog('土狗','黄色')
    print(dog1.type,dog1.color)
    dog2 = Dog('傻狗','黑色')
    print(dog2.type,dog2.color)

五、对象属性的增删查改

python是动态语言，python中类的对象的属性可以增删查改的操作

class Person:
    '''人类'''
    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.height = 180


if __name__ == '__main__':
    p1 = Person()
    p2 = Person()

    # 1.查(获取属性的值)
    '''
    方法一：对象.属性名
    方法二：def getattr(对象，属性名，default = None)
    方法三：def__getattr__(属性名，值)
    '''
    print(p1.name)
    # print(p1.name2)  属性不存在会报错

    print(getattr(p1,'age'))
    print(getattr(p1,'age2',0)) # 属性不存在可以通过默认值，让程序不崩溃，并返回默认值

    height = p1.__getattribute__('height')
    print(height)


    # 2.改(修改属性的值，值存在就是修改)
    '''
    方法一：对象.属性 = 新值
    方法二：def setattr(对象，属性名，新值)
    方法三：对象.__setattr__(属性名)
    '''
    p1.name = '李四'

    setattr(p1,'age',20)
    print(p1.age)

    p1.__setattr__('height',170)
    print(p1.height)

    # 3.增(添加属性，属性不存在) 添加属性只影响一个对象
    # 注意：添加属性只能给某一个对象添加对应的属性
    '''
    方法一：对象.属性 = 新值
    方法二：def setattr(对象，属性名，新值)
    方法三：对象.__setattr__(属性名，新值)
    '''
    p1.sex = '女'
    print(p1.sex)

    setattr(p1,'weight',45)
    print(p1.weight)

    p1.__setattr__('color','绿色')
    print(p1.color)


    # 4.删(删除对象属性)
    # 注意：删除只针对指定的对象
    '''
    方法一：del 对象.属性
    方法二：delattr(对象，属性名)
    方法三：对象.__delattr__(属性名)
    '''
    del p1.name
    # print(p1.name)

    delattr(p1,'age')
    # print(p1.age)

    p1.__delattr__('height')
    # print(p1.height)
    print(p2.name)

六、对象方法

1.对象方法

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

class Circle:
    def __init__(self,radius1):
        self.radius = radius1

    # 声明一个对象方法area
    # 在这儿，self就是调用area方法的对象，对象可以做的事，self都可以做
    def area(self):
        # print(id(self))
        # print(self.radius)
        # print('求圆的面积')
        return math.pi * self.radius ** 2
if __name__ == '__main__':
    c1 = Circle(3)
    # print(id(c1))
    c1.area()
    print('c1的面积:',c1.area())
    # print(c1.radius)
    c1.radius = 100
    #创建一个半径是5的圆的对象
    c2 = Circle(5)
    print('c2的面积:',c2.area())
# 练习：写一个矩形类，有长和宽，有两个功能，分别是求周长和面积
    class Rectangle:
        def __init__(self, length1, width1):
            self.length = length1
            self.width = width1

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

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

# 练习：写一个班级类，班级里面有多个成绩(一门)，可以获取成绩中的的高分
    class Class:
        def __init__(self, score1):
            self.scort = score1
            self.name = ''

        def max(self):
            if not self.scort:
                return 0
            return max(self.scort)

七、类的字段

1.类的属性叫类的字段

• 类的字段就是声明在类的里面，方法的外面的变量
• 属于类的，对于这个类的所有的对象来说其值是共有的
• 通过类来使用：类.字段

class Person:
    #这个number就是类的字段
    number = 61


# 练习：写一个类，用一个属性来保存这个类创建对象的个数
class Ball:
    count = 0
    # 每次创建球的对象都会调用init方法，所以init方法调用的次数就是Ball创建的对象的个数
    def __init__(self):
        Ball.count += 1

ball1 = Ball()
ball2 = Ball()
print(Ball.count)


if __name__ == '__main__':
    # 通过类获取类的字段的值
    print(Person.number)

    Person.number = 70
    print(Person.number)

八、类的方法

类中的方法

1.对象方法（实例方法）

• 声明的形式：直接声明在类型
• 特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁
• 调用：通过对象来调用

2.类方法

• 声明的形式：声明方法前需要使用@classmethod说明
• 特点：自带默认参数(cls),这个参数调用的时候不需要传值。系统自动给他传。谁调用就指向谁！始终指向当前类
• 调用：通过类来调用 -> 类.类方法()

3.静态方法

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

class Class1:
    # 类字段
    number = 100

    # 声明一个对象方法
    def object_func(self):
        print('对象方法')

    # 声明一个类方法
    @classmethod
    def class_func(cls):
        # 通过cls去使用类的字段
        print('cls:', cls.number)
        # 通过cls去创建对象
        tc = cls()
        tc.object_func()
        print('这是一个类方法')

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



c1 = Class1()
# 调用对象方法
c1.object_func()

print(Class1.number)
# 调用类方法
Class1.class_func()

# 调用静态方法
Class1.static_func()

4.遇到问题怎么来选择使用哪种方法：

• 只要实现方法的功能需要用到对象的属性，我们就使用对象方法
• 不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
• 实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
• 注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然

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

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

    @staticmethod
    def show_numer2():
        print('人类的数据是:%d亿！' % Person.number)

Person.show_numer()
Person.show_numer2()