1.类的声明
类：对拥有相同功能（方法）和相同属性的封装
封装效果：一个类中可以对多个功能进行封装（多个函数）；封装多个属性
1.类的声明格式
class 类名(父类列表)：
类的说明文档
类的内容
2.说明：
class:声明类的关键字
类名:标识符，不能是关键字。驼峰式命名（第一个单词首字母其他单词首字母都大写），首字母大写！！！，见名知义
例如：Person,StudentSystem
(父类列表):这个部分可以省。这个是继承语法。
冒号：固定的
类的内容：包括类的方法和类的属性
3.类中的方法
方法：就是声明在类的函数
a.对象方法：对象方法需要通过对象来调用，对象.函数名()
直接写在；类中的方法，自带一个self参数
b.类方法:
c.静态方法:
4.创建对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法
构造方法：类名() --->创建类对应的对象
# 创建一个类
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()
输出结果：
30705232 30705136 30705136
人吃饭
2.构造方法和init方法
1.构造方法：系统自动创建的，方法名和类名一样。用来创建对象
- init"init方法的功能是用来初始化和添加赋属性的
当我们通过构造方法去创建对象的时候，系统会自动调用(不用自主调用init方法)
class Dog:
def __init__(self):
print('init方法')
class Person():
#init方法可以添加参数
def __init__(self,name,age = 18):
print(name,age)
print('人类的init方法')
# 创建对象的过程：调用构造方法在内存中开辟一个对象，
# 然后用新建的这个对象去调用init方法，来初始化对象对象的属性。最后才将对象返回
dog1 = Dog()
#如果类的init方法有参数，通过给构造方法传参
p1 = Person('小明')
p2 = Person('小红',20)
输出结果：
init方法
小明 18
人类的init方法
小红 20
人类的init方法
3.对象属性
类中的内容：属性和方法
1.属性：(保存值的)
a.对象的属性:不同的对象，对应的值可能不一样，这样的属性是对象属性
类中的对象属性是声明在init方法中的，并且声明格式是：self.属性名 = 初值
对象属性的使用：对象.属性名
b.类的字段：属于类的，所有的对象对应的值是一样的
2.方法：（保存功能的）
a.对象方法
b.类方法
c.静态方法
class Student:
'''学生类'''
def __init__(self):
# 声明对象属性name，age，id
self.name = 'coco'
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
# 练习：写一个矩形类，拥有属性长和宽
class Rect:
def __init__(self,long = 23,width = 20 ):
self.long = long
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)
输出结果：
coco 0 001
江秀成
土狗 黄色
斗狗 黑色
白色 0
黑色 512
4.对象属性的增删改查
python 是动态语言，python中类的对象的属性可以进行增删的操作
class Person:
def __init__(self):
self.name = 'jxc'
self.age = 28
self.height = 170
if __name__ == '__main__':
#1.查（获取属性的值）
p1 = Person()
"""
方法一：对象.属性名
方法二：def getattr(对象, 属性名, 默认值)
方法三：对象.__getattribute__(属性名)
"""
print(p1.name)
# print(p1.name2) #属性不存在会报错
print(getattr(p1,'name'))
print(getattr(p1,'name2',0)) #属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值
print(p1.__getattribute__('height'))
# 2.改（修改属性的值）
"""
方法一：对象.属性 = 新的值
方法二：def setattr(对象，属性名，新值)
方法三：对象.__setattr__(属性名，新值)
"""
p1.name = '李四'
setattr(p1,'age',20)
print(p1.age)
p1.__setattr__('height',160)
print(p1.height)
#3.增（添加属性--属性不存在）
# 注意：添加属性只能给某一个对象添加对应的属性
"""
方法一：对象.属性 = 新的值
方法二：def setattr(对象，属性名，新值)
方法三：对象.__setattr__(属性名，新值)
"""
p1.sex = '女'
print(p1.sex)
setattr(p1,'weight',40)
print(p1.weight)
p1.__setattr__('color','green')
print(p1.color)
# 4.删（删除对象属性）
# 注意：删除值针对指定的对象
"""
方法一：del 对象.属性
方法二：def delattr(对象, 属性名)
方法三：对象.__delattr__(属性名)
"""
del p1.name
delattr(p1,'age')
p1.__delattr__('height')
输出结果：
jxc
jxc
0
170
20
160
女
40
green
5.对象方法
1.对象方法：
a.什么样的方法是对象方法：直接声明在类的函数默认是对象方法，有一个默认参数self
b.对象方法要通过对象来调用：对象.对象方法()
c.对象方法中默认参数self，不需要传参。因为在调用这个方法时，系统会自动将当前对象传给self
哪个对象调用的方法，self就指向谁
练习1：写一个矩形类，有属性长和宽,有两个功能，求面积和周长
class Rect:
def __init__(self,length,width):
self.length = length
self.width = width
def area(self):
return self.width*self.length
def perimeter(self):
return (self.length+self.width)*2
r1 = Rect(1, 2)
print(r1.area())
r2 = Rect(2, 3)
print(r2.perimeter())
输出结果:
2
10
6.类的字段
类的属性叫类的字段
a.什么是类的字段
类的字段就是声明在类的里面，方法的外面的变量
b.什么样的属性声明成类的字段：
属于类的，对于这个类的所有的对象来说其值是共有的
c.怎么使用：
通过类来使用：类.字段
练习：写一个球类，用一个属性来保存这个类的创建对象的个数
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)
输出结果：
2
7.类的方法
1.对象方法（实例方法）
声明的形式：直接声明在类中
特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁
调用：通过对象来调用
2.类方法
声明的形式：声明方法前需要使用@classmethod
特点：自带一个默认参数cls，这个参数调用的时候不需要传值。系统自动给他传。谁调用就指向谁！始终指向当前类
调用：通过类来调用->类.类方法名（）
3.静态方法
声明形式：声明方法前需要使用@staticmethod说明
特点：没有默认的参数
调用：通过类来调用 -> 类.静态方法（）
4.遇到问题怎么来选择使用哪种方法：
a.大前提：只要实现方法的功能需要用到对象的属性，我们就使用对象方法。否则就使用静态方法或者类方法
b.你不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然
class Person:
#类字段
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 = Person()
c1.object_func()
print(Person.number)
# 调用类方法
Person.class_func()
# 调用静态方法
Person.static_func()
class Person:
# 类的字段，存储人类的数量
number = 61
@classmethod
def shou_numer(cls):
print('人类的数量是：%d亿'%cls.number)
@staticmethod
def show_numer2():
print('人类的数量是：%d亿'%Person.number)