14总 类和对象

1.理论上的定义

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

2.从生活角度
如果说人是一个类，余婷就是一个对象，肖老师是另外一个对象，马云也是人这个类的对象
如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果说车是一个类，具体的一辆车才是它的对象

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

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

2.类的声明格式

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

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

2.类中的方法
方法：就是声明在类的函数

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

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

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

def eat(self):
print('人吃饭')

1.创建对象
p1 = Person() 创建Person类的对象，并且将对象的地址存到p1中

一个类可以有多个对象
p2 = Person()
只有在调用构造方法的时候才会产生新的对象
p3 = p2
print(id(p1), id(p2), id(p3))

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

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

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

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


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

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

4.属性和方法：

类中的内容：属性和方法
1.属性：(保存值的)
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性是对象属性。属于对象
类中的对象属性是声明在init方法中的，并且声明格式是：self.属性名 = 初值
对象属性的使用：对象.属性名

b.类的字段：属于类的，所有的对象对应的值是一样的

2.方法：（保存功能的）
a.对象方法
b.类方法
c.静态方法

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, color1='白色', memory1=0):
self.color = color1
self.memory = memory1

练习：写一个矩形类，拥有属性长和宽
class Rectangle:
def init(self, length, width):
self.length = length
self.width = width

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)

comp1 = Computer()
print(comp1.color, comp1.memory)
comp2 = Computer('黑色', 512)
print(comp2.color, comp2.memory)

5.对象属性的增删改查：

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

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


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

1.查(获取属性的值)

方法一: 对象.属性
方法二: def getattr(对象, 属性名, 默认值)
方法三：对象.getattribute(属性名)

   print(p1.name)
   print(p1.name2)   # 属性不存在会报错

   print(getattr(p1, 'age'))
  print(getattr(p1, 'age2'))   # 属性不存在会报错
   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)

print(p2.sex) # 添加属性只影响一个对象

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, p2.age)

6.对象的方法：

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

import math


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

声明一个对象方法area
在这儿，self就是调用area方法的对象。对象能做的事情，self都可以做
    def area(self):
        print(id(self))
     print(self.radius)
       self.radius = 100
      print('求圆的面积')
        return math.pi * (self.radius ** 2)

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

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

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

class Class:
    """班级类"""
    def __init__(self, name):
        self.scores = []
        self.name = name

    def highest_score(self):
        if not self.scores:
            return 0
        # max(序列) ---> 获取序列中元素的最大值
        # min(序列) ---> 获取序列中元素的最小值
        return max(self.scores)


class1 = Class('python1806')
class1.scores = [23, 45, 77, 54, 89, 90, 34]
print(class1.highest_score())

if __name__ == '__main__':
  创建一个半径是3的圆的对象
    c1 = Circle(3)
    print(id(c1))

    print('c1的面积:',c1.area())
    print(c1.radius)
    c1.radius = 100

  创建一个半径是5的圆的对象
    c2 = Circle(5)
    print('c2的面积:',c2.area())

7.类的字段：

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

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)

通过类获取类的字段的值

print(Person.number)

Person.number = 70
print(Person.number)

8.类的方法：

类中的方法：
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.遇到问题怎么来选择使用哪种方法：
a.只要实现方法的功能需要用到对象的属性，我们就使用对象方法
b.不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然

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()