一：认识类和对象
1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合；类是抽象的
对象就是类的实例；对象是具体的
人是类，，单个人就是具体的对象
电脑是类，单个电脑是对象
2.类的声明
类中的内容包含功能（函数）和属性（变量/属性）
a.语法
class 类名：
类的内容
b.说明
class - python声明类的关键字
类名 - 要求：标识符，不能是关键字 例：UserName - 类名
规范：驼峰式命名（通过首字母大写来区分不同的单词）；第一个字母必须大写。
： - 固定写法
类的内容 - 包含类的方法、属性、说明文档
方法：声明在类中的函数
属性：声明在类中的变量
3.对象的声明
语法：
类名（） - 创建指定类的对象并且返回
声明一个类
class Person:
类的说明文档：人类
num = 23 #类中的属性
def eat(self):
print('人在吃饭')
def main():
# 创建Person的对象；p1就是对象
p1 = Person()
# 同一个类可以创建多个对象。p1和p2是两个不同的对象
p2 = Person()
if __name__ == '__main__':
main()
二：对象方法
class 类名：
类中的属性
类中的方法
1.类中的方法
声明在类中的函数就是方法
类中的方法包括：对象方法（实例方法）、类方法、静态方法
2.对象方法：
a.什么是对象方法
直接声明在类里面的方法就是对象方法
有默认参数self
通过‘对象.方法（）’的方式来调用（对象方法要通过对象来调用）
b.参数self
当我们通过对象调用对象方法的时候，self是不需要传参的，因为系统会自动将当前对象传递给self.
当前对象：调用当前方法的对象（谁调用对象方法self就是谁）
注意：当前类的对象能做的事情，self都可以做。
class Person: #声明类的时候会执行类里面的内容
def run(self):
print('人在跑步')
def eat(self,food):
self.run()
print(food)
def main():
# 创建对象
p1 = Person()
# 通过对象p1调用对象方法
p1.run()
# 调用对象方法只需要给除了self以外的其他参数传参
p1.eat(100) #两个p1和self是一样的
if __name__ == '__main__':
main()
三：init方法和构造方法
1.init方法：init
init方法是类中的一个特殊的对象方法，专门用来对创建的对象进行初始化
当通过类创建对象的时候，系统就会自动调用init方法。（每次创建对象都会被调用）
2.构造方法
a.什么是构造方法
函数名和类名一样的函数就是构造方法，专门用来创建对象
python中声明类的时候，系统会自动创建这个类对应的构造方法。
b.构造方法的执行过程
当我们调用构造方法的时候内部会先在内存中开辟空间保存对象，然后用创建的这个对象去调用init方法，用来对对象进行初始化
init方法调用结束后，返回对象。
def Person(arge,*kwargs): #内部做的事情过程
对象 = 创建对象
对象.init()
return 对象
注意：如果类的__init__方法除了self以外还有其他参数，那么我们在创建对象的时候需要通过构造方法给__init__方法传参
class Person:
# 类中__开头并且__结尾的方法叫魔法方法，不需要主动调用，系统会自动调用
def __init__(self):
print('init被调用了')
class Dog:
def __init__(self,x,y):
print('=====')
def main():
#人类
p1 = Person() #类中的init被自动调用了
#p1 后面的 Person() 就是构造方法
#dog
dog1 = Dog(10,23)
if __name__ == '__main__':
main()
四：对象属性
1.什么是对象属性
类中的属性分为类的字段和对象属性
a.对象属性 - 属性的值会因为对象不同而不一样，这种属性就应该声明为对象属性
声明在init方法中 - 位置
以‘self.属性 = 值’的方式来声明（这儿的属性就是对象属性） - 方式
通过‘对象.属性’的方式来使用 - 使用
b.类的字段 - 属性的值不会因为对象不同而不同，这种属性就声明成类的字段
直接声明在类的里面，函数的外面的变量就是类的字段
以‘字段名 = 值’声明
通过‘类名.字段’的方式来使用
class Person:
# num就是类的字段
num = 23
# 在init方法中声明对象属性
def __init__(self,name1,age1):
# self.name = '楚留香'
# self.age = 18
self.name = name1
self.age = age1
print(Person.num)
练习：创建Dog类，有属性名字、类型、年龄。
要求创建狗的对象的时候不能给年龄赋值，可以给类型赋值也可以不用赋值，
但必须给名字赋值
对象方法eat:打印XX在吃什么
class Dog:
def __init__(self,name,class1='大狗'):
self.name = name
self.class1 = class1
self.age = 0
def eat(self,food):
#self = p1 ,food = 骨头
print('%s在吃%s' % (self.name,food))
p1 = Dog('小灰')
p1.eat('骨头')
print(p1.name,p1.class1,p1.age)
练习：声明矩形类，拥有属性长和宽，拥有方法求面积和求周长
class Juxin:
def __init__(self,chang,kuan):
self.chang = chang
self.kuan = kuan
def jumian(self):
return self.chang * self.kuan
def zhouc(self):
return (self.chang + self.kuan) * 2
ju = Juxin(4,3)
print('面积',ju.jumian())
print('周长',ju.zhouc())
def main():
p1 = Person('楚留香',18)
#获取对象属性的值
print(p1.name)
p1.name = '香帅' #修改对象属性的值
if __name__ == '__main__':
main()
五：对象属性的增删改查
class Person:
# 约束当前类的对象最多拥有那些属性
__slots__ = ('name','age','sex') #这句约束init的属性只能有这三个以内
#有了这句后，可以删除。。要加在括号里加
def __init__(self, name='', age=0, sex='女'):
self.name = name
self.age = age
self.sex = sex
def main():
p1 = Person('花儿')
p2 = Person('小美')
# 改了p1的属性，p2再调用的时候无影响，还是原来的属性
print(p1.name)
print(getattr(p1, 'name', None))
attr = input('属性：') # 属性不确定的时候，可以使用getattr
print(getattr(p1, attr))
1.查（获取对象属性）
对象.属性 - 获取指定对象指定属性值,当属性不存在的时候会报错
getattr(对象,属性名：str，默认值) - 获取指定对象指定属性值,当属性不存在的时候，
如果给默认值赋了值，程序不会报错，并且将默认值作为结果
print(p1.name)
print(getattr(p1,'name'))
attr = input('属性：') #属性不确定的时候，可以使用getattr
print(getattr(p1,attr))
p1.name = '花红月圆' # 修改属性
setattr(p1, 'age', 18) # 存在时修改，不存在时添加
2.增改
对象.属性 = 值 --当属性存在时修改属性的值，属性不存在的时候添加属性
setattr(对象，属性名，值) - 当属性存在时修改属性的值，属性不存在的时候添加属性。
3. 删除
del 对象.属性
delattr(对象，属性名)
注意：对象属性的操作，只针对操作的那一个对象，不会影响其他对象。
if __name__ == '__main__':
main()
六：类的内置属性
内置属性指的是我们创建类的时候系统自动给我们添加的属性（其实是通过继承获取到的）
class Person:
"""说明文档，哈哈哈"""
num = 44 # 类的字段
def __init__(self, name='', age=0, sex='男'): # 对象属性
self.name = name
self.age = age
self.sex = sex
def eat(self, food):
print('%s在吃%s' % (self.name, food))
定制对象的打印格式（当我们通过print打印对象的时候，实质就是打印对象调用repr函数的返回值）
这个函数的返回值必须是字符串
def __repr__(self):
#return '<%s.%s object at %s>' % (self.__class__.__module__,
self.__class__.__name__,hex(id(self)))
return str(self.__dict__)[1:-1]
def main():
p1 = Person('小明',18)
#1.类.__name__ - 获取类的名字（字符串）
print(Person)
print(Person.__name__) #值是字符串
print('专门的', p1) #类似打印__repr__
#2. 对象.__class__ - 获取对象对应的类（结果是类）
# 获取对象p1的类
my_class = p1.__class__
print(my_class) #可以将my_class当成类来使用
# 3. 类.__doc__ - 获取类的说明文档(字符串)
print(Person.__doc__)
# 获取对象p1对应的类的说明文档
print(p1.__class__.__doc__)
# 4. 对象.__dict__ - 将对象转换成字典，将属性(key)和值作为字典的键值对。
# 注意：当给__slots__属性赋值后，对象.__dict__属性就不能使用
print(p1.__dict__) #打印出p1的对象属性，是字典
print(Person.__dict__) #打印出类的属性
# 5. 类.__module__ - 获取当前类所在的模块的模块名
print(Person.__module__) #模块名默认是标题，这里设置的__main__
# 6. 类.__bases__ - 获取当前类的父类（元组）
print(Person.__bases__)
if __name__ == '__main__':
main()
七：类方法和静态方法
1.对象方法：
a.怎么声明：直接声明在类中
b.特点：自带self参数，调用的时候不用传参，谁调用指向谁
c.怎么调用： 对象.方法（）
2.类方法：
a.怎么声明：声明函数前加@classmethod
b.特点：自带默认参数cls; 调用的时候不用传参，系统会自动将调用当前函数的类传给它
（cls是谁调用指向谁，类方法只能通过类来调用，所以cls是当前类）
类能做的事情，cls都能做
c.怎么调用：通过类来调用， 类.方法（）
3.静态方法
a.怎么声明：声明函数前加@staticmethod
b.特点：没有默认参数
c.怎么调用：通过类来调用， 类.方法（）
4.在类中怎么选择使用哪种方法：
如果实现类中的函数的功能需要使用对象的属性，那么这个函数就要声明对象方法
实现函数的功能不需要对象属性的前提下，如果需要类的字段，就声明成类方法
实现函数功能即不需要对象属性也不需要类的字段就声明成静态方法
class Person:
num = 60
@staticmethod
def func3():
Person.num = 99
print('去时朝露无觅处')
@classmethod
def func2(self):
print('我是func2')
@classmethod
def func1(cls):
p1 = cls() #用cls来创建对象
print('这是一个类方法')
cls.num = 100
cls.func2() # 用cls调用类方法
cls.num = 123 #用cls来使用类的字段
def main():
Person.func1()
if __name__ == '__main__':
main()