1.类和对象

1.理论上的定义
类：就是拥有相同功能和相同属性的对象的集合（类是抽象的）
对象：类的实例（对象是具体的）
2.从生活的角度
如果说人是一个类，江秀成这个人就是一个对象
如果说电脑是一个类，桌上的这台电脑就是一个对象
如果说车是一个类，具体的以辆车就是一个对象
3.编程方式
面向过程：以算法为工具
函数式编程：以函数为工具
面向对象编程：以类和对象为工具（面向生活）

2.类的声明

类：对拥有相同功能（方法）和相同属性（属性）的封装
封装效果：一个类中可以对多个功能进行封装（多个函数）；封装多个属性
1.类的格式声明
class 类名（父类列表）：
类的内容
2.说明：
class:声明类的关键字
类名：标识符，不能使关键字。驼峰式命名（第一个单词首字母小写，其他单词首字母大写），首字母大写，见名知意
（父类列表）：这个部分可以省，这个是继承语法，可以多继承
冒号：固定的
类的内容：包括类的方法和类的属性
类中的方法：
方法：就是声明在类的函数
a.对象方法：对象方法需要通过对象来调用，对象.函数名()
直接写在类中的方法，自带一个self参数
b.类方法
c.静态方法
4.创建对象
创建类的事实，系统会默认给我们创建这个类对应的构造方法
构造方法:类名()------->创建类对应的对象

class Person:
    def eat(self):
        print("chi")


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

p2 = Person()
#只有在调用构造方法的时候才会产生新的对象
p3 = p2
print(id(p1),id(p2))
#2.调用对象方法
#通过对象调用对象方法，默认参数self不需要传参，系统会自动传
p1.eat()
输出:
31880688 31881680
chi

3.构造方法和init方法

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

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

class Person:
    def __init__(self,name, age = 18):
        print(name)
        print("人类的init方法")
    #创建对象的过程：调用构造方法在内存中开辟空间创建一个对象，
    #然后用新建的这个对象来初始化对象的属性，最后才将对象返回
dog1 = Dog()
dog2 = Dog()

    #如果类的init方法有参数，通过给构造方法传参类init方法传参
p1 = Person("球")
p2 = Person("xiaohong",20)

4.对象属性

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

class Student:
    """学生类"""
    def __init__(self):
        #声明对象属性name,age,id
        self.name = "张山"
        self.age = "18"
        self.id = "001"

class Dog:
    """狗类"""
    def __init__(self,type1,color1):  #type1,color1形参
        self.type = type1
        self.color = color1

class Computer:
    def __init__(self,color = "白色",memory = 0):
        self.color = type
        self.memory = memory
if __name__ == '__main__':
    stu1 = Student()
    print(stu1.name,stu1.age,stu1.id)
输出：张山 18 001
    #通过对象去修改对象的属性
    stu1.name = "江有才"
    print(stu1.name)
输出：江有才
    dog1 = Dog("中华田园犬","黄色")
    print(dog1.type,dog1.color)
输出：中华田园犬 黄色

    comp1 = Computer()
    print(comp1.color,comp1.memory)
    comp2 = Computer("黑色",1024)
    print(comp2.color,comp2.memory)
输出：
白色 1000
黑色 1024

5对象属性的增删改查

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

class Person:
    """人类"""
    def __init__(self):
        self.name = "张山"
        self.age = 20
        self.height = 159
p1 = Person()
p2 = Person()

1.查（获取属性的值）
方法1：对象.属性名
方法2:def getattr(object, name, default=None)
方法3：对象.getattribute(属性名)
方法3：

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

print(getattr(p1,"age"))   #方法2
#print(getattr(p1,"age2"))   #属性不存在会报错
print(getattr(p1,"age2",0))  #属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值


height = p1.__getattribute__("height")
print(height)
输出：
张山
20
0
159

2.改（修改属性的值）

方法1:对象.属性 = 新值
方法2：def setattr(对象, 属性名, 新值)
方法3：对象.setattr(属性名，新值)

p1.name = "江秀"

setattr(p1,"age",19)
print(p1.age)

p1.__setattr__("height",160)
print(p1.height)
输出：
19
160

3.增（添加属性--属性不存在）
注意：添加属性只能给某一个对象添加对应的属性
方法1:对象.属性 = 值
方法2：def setattr(对象, 属性名, 值)
方法3：对象.setattr(属性名，值)

p1.sex = "女"
print(p1.sex)

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

p1.__setattr__("color","绿色")
print(p1.color)
#print(p2.sex)  #添加属性只影响一个对象
输出：
女
45
绿色

4.删（删除对象属性）
注意：删除只针对指定的对象
方法1:del 对象.属性
方法2：delattr(对象，属性名)
方法3：对象.delattr(属性名)

del p1.name
#print(p1.name)

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

p1.__delattr__("height")
#print(p1.height)          #删除后打印会报错
print(p2.name,p2.age)
输出:
张山 20

6.对象方法

对象方法：
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("求圆的面积")
        return math.pi *(self.radius ** 2)
c1 = Circle(3)
print(c1.radius)
print("c1的面积：",c1.area())
c2 = Circle(5)
print("c2的面积：",c2.area())
输出:
c1的面积： 28.274333882308138
c2的面积： 78.53981633974483

#写一个矩形类，有长和宽，有两个功能，求面积和周长

class Rect:
    def __init__(self,length1,width1):
        self.length = length1
        self.width = width1
    def area(self):
        return self.length * self.width
    def meter(self):
        return 2*(self.length + self.width)

r1 = Rect(4,5)
print("r1的面积：",r1.area())
print("r1的周长:",r1.meter())
输出：
r1的面积： 20
r1的周长: 18

写一个班级类，班级里有多个学生的成绩（一门），可以获取班级成绩里的最高分

class PythonClass:
    def __init__(self,name):
        self.grade = []
        self.name = name
    # def __init__(self,class_name1,*grade1):
    #     self.class_name = class_name1
    #     self.grade = grade1
    def max_grade(self):
        if not self.grade:
            return 0
        return max(self.grade)
c3 = PythonClass("Python1806")
c3.grade = [89,70,60,90,94,92]
print(c3.max_grade())
输出:
94

7.类的字段

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

class Person:
    #这个number就是类的字段
    number = 10
#通过类获取类的字段的值
print(Person.number)

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



Person.number = 250
print(Person.number)
输出：
10
2
250

7.类的方法

类中的方法：
1.对象方法（实例方法）
声明的形式：直接声明在类中
特点：自带一个不需要主动传参的默认函数self,谁来调用指向谁
调用：通过对象来调用
2.类方法
声明的形式：声明方法前需要使用@classmethod说明
特点：自带一个默认参数cls，这个参数调用的时候不需要传值，系统自动传，谁调用就指向谁，始终指向当前类
调用：通过类来调用---->类.类方法()
3.静态方式
声明的形式：声明方法前需要使用@staticmethod说明
特点:没有默认参数
调用：通过类来调用--->类.静态方法()
4.遇到问题怎么来选择使用哪种方法：
a.只要实现方法的功能需要用到对象的属性，我们就使用对象方法，否则就使用静态方法或类方法
b.不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就用静态方法
注意：静态方法和类方法划分不用那么严格，静态方法能做的可以做，反之亦然

class Class1:
    number = 1000
    #对象方法
    def object_func(self):
        print("对象方法")
    #声明类方法
    @classmethod
    def class_func(cls):
        print("cls:",cls.number)
        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()



class Person:
    number2 = 250
    @classmethod #类方法
    def show_number2(cls):
        print("人类的数量是:%d亿" % cls.number2)

    @staticmethod #静态方法
    def show_number3():
        print("人类的数量:%d亿" % Person.number2)
Person.show_number2()
Person.show_number3()
输出:
对象方法
1000
cls: 1000
对象方法
类方法
静态方法
人类的数量是:250亿
人类的数量:250亿