1 类

1.1 类的简介

• 1.理论上的定义
  类：就是拥有相同功能和相同属性的对象的集合
  对象：类的实例

• 2.从生活角度
  如果说人是一个类，马云就是一个对象
  如果说电脑是一个类，桌上的这台电脑就是一个对象
  如果说车是一个类，具体的一辆车就是一个对象

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

1.2 类的声明

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

• 类的声明格式：
  class 类名（父类列表）：
  　　类的说明文档
  　　类的内容

例如，声明一个狗的类

class Dog:
    """狗类"""
    def run():
        print('奔跑的狗')

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

1.3 构造方法和init方法

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

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

class Person:
    # 创建对象的过程：
    # 调用构造方法在内存中开辟空间创建一个对象，
    # 然后用新建的这个对象去调用init方法，来初始化对象的属性。
    # 最后才将对象返回
    # init方法可以添加参数

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

# 如果类的init方法有参数，通过给构造方法传参类init方法传参 
p1 = Person('小明')
p2 = Person('小红', 20)
p3 = Person(age=21, name='小花')

输出结果为：

小明 18
人类init方法
小红 20
人类init方法
小花 21
人类init方法

1.4 对象属性和对象方法

1.4.1 对象属性

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

以下是学生、狗电脑类的示例写法

class Student:
    """学生类"""
    def __init__(self):
        # 声明对象属性name，age，id
        self.name = '张三'
        self.age = 0
        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

• python是动态语言，python中的类的对象的属性可以进行增加和删除的操作

声明一个人的类，并给定名字、年龄、身高等属性，并实例化对象p1：

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

• 查（获取属性的值）
  方法一：对象、属性名
  方法二：def getattr(对象, 属性名, default=None)。方法一属性名书写错误时，会报错；方法二如果给了default值就不会报错。
  方法三：对象.__getattribute__(属性名)

    print(p1.name)
    # print(p1.name2)  # 属性不错在会报错
    print(getattr(p1, 'age', 0))  # 属性不存在可以通过设置默认值，让程序不崩溃，并且 返回默认值
    print(getattr(p1, 'age'))  # 属性不存在会报错
    height= p1.__getattribute__('height')
    print(height)

输出结果为：

张三
18
18
160

• 2.改（修改属性的值）
  方法一：对象.属性 = 新值
  方法二：def setattr(对象, 属性名, 新值)
  方法三：对象.__setattr__(属性名，新值)

    p1.name = '李四'
    setattr(p1, 'age', 20)
    print(p1.age)
    p1.__setattr__('height', 180)
    print(p1.height)

输出结果为：

李四
20
180

• 3.增（添加属性）
  注意：添加属性只能给某一个对象添加对应的属性
  方法一：对象.属性 = 值
  方法二：def setattr(对象, 属性名, 值)
  方法三：对象.setattr(属性名，值)

    p1.sex = '女'
    print(p1.sex)
    setattr(p1, 'weight', 45)
    print(p1.weight)
    p1.__setattr__('color', '绿色')
    print(p1.color)

输出结果为：

女
45
绿色

• 删（删除对象属性）
  注意：删除只针对指定的对象
  方法一： del 对象.属性
  方法二：delattr(对象, 属性名)
  方法三：p1.delattr(属性名)

 del p1.name
    print(p1, name)
    delattr(p1, 'age')
    print(p1.age)
    p1.__delattr__('height')

1.4.2 对象方法

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

写一个矩形类,有长和宽，有两个功能，分别是求周长和面积：

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

1.5 类的字段

类的属性叫类的字段
a.什么是类的字段：类的字段就是声明在类的里面，方法的外面的变量。
b.什么样的属性声明成类的字段：属于类的，对于这个类的所有的对象来说其值是共有的。
c.怎么使用：通过类来使用：类，字段。

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

1.6 类的方法

类中的方法：

• 1.对象方法（示例方法）
  声明的形式：直接声明在类型
  特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁

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

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

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

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(cls.number)
        print('这是一个类方法')

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