01.类和对象的介绍：
1.理论定义：
类：就是拥有相同功能和相同属性的对象的集合（类是抽象的）
对象：类的实例（对象是具体的）
2.生活角度：
如果人是一个类，我是一个对象，你也是一个对象，他也是人这个类的对象
如果电脑是一个类，我手上的电脑是一个对象，老师的电脑也是一个对象
如果车是一个类，具体的一辆车才是它的对象，奔驰车、宝马车只是子类，不是对象
3.编程思想：
面向过程编程：以算法为工具 打地基
函数式编程：以函数为工具 调用函数
面向对象编程：以类和对象为工具（面向生活）声明类，拥有某种功能
02.类的声明
类：对拥有相同功能（方法）和相同属性（属性）的封装
封装效果：一个类中可以对多个功能进行封装（多个函数）；封装多个属性
1.类的声明格式：
class 类名（父类列表）：
类的说明文档
类的内容
2.说明：
class：python中声明类的关键字
类名：标识符，不能是关键字。类名是驼峰式命名.首字母大写！！！
1）驼峰式命名：（第一个单词首字母小写，其他的单词首字母都大写）
例如：Person、StudentSystem
(父类列表):可以省略。这个是继承语法，可以多继承
冒号：固定的
类的内容：包括类的方法和类的属性
3.类中的方法:
方法：就是声明在类中的函数
a.对象方法：对象方法需通过对象来调用，对象().函数名()直接写在类中的方法，自带一个self参数
b.类方法
c.静态方法
4.创建对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法
构造方法：类名（）--->创建类对应的对象
# 创建类
class Person:
"""人类"""
def eat(self):
print('人吃饭')
# 创建Person类的对象，并且将对象的地址存到p1中
p1 = Person()
#一个类可以有多个对象
p2 = Person()
# 只有在调用构造方法的时候才会产生新的对象
p3 = p2
print(id(p1),id(p2),id(p3))
5.调用对象方法：
通过对象调用对象方法，默认参数self不需要传参。系统会自动传！
p1.eat()
Person().eat()
03.构造方法和init方法
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方法')
# 创建对象的过程：调用构造方法在内存中开辟空间创建一个对象，
#然后用新建的这个对象去调用init方法来初始化对象的属性。最后
#才将对象返回
dog1=Dog()
dog2=Dog()
Dog()
# 如果类的init方法有参数，通过给构造方法传参类init方法传参
p1=Person('XM',18)
Person('小红')
Person(age=21,name='xiao')
04.对象属性和对象方法
类中的内容：属性和方法
1.属性：(用来保存值的)
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性是对象属性。属于对象类中的对象属性是声明在init方法中的，并且声明格式是：self.属性名 = 初值
对象属性的使用：对象.属性名
b.类的字段：属于类的，所有的对象对应的值是一样的
2.方法：(保存功能的)
a.对象方法
b.类的方法
c.静态方法
class Student:
def __init__(self):
# 声明对象属性name，age，id
self.name='zs'
self.age = 0
self.id = '001'
# stu1就是Student类的对象
stu1 = Student()
print(stu1.name,stu1.age,stu1.id)
Student().name
# 通过对象去修改对象的属性
stu1.name = 'zzz'
print(stu1.name)
class Dog:
"""狗类"""
# 创建Dog的对象的时候，必须传类型和颜色
def __init__(self,type,color):
self.type = type
self.color = color
dog1=Dog('土狗','黄的')
print(dog1.type,dog1.color)
dog2=Dog('斗狗','黑的')
print(dog2.type,dog2.color)
class Computer:
"""电脑类"""
# 创建对象的时候，可以让属性使用默认值，也可以自己定义
def __init__(self,color='白色',memory=0):
self.color=color
self.memory=memory
comp1=Computer()
print(comp1.color,comp1.memory)
comp2=Computer('黑色',999)
print(comp2.color,comp2.memory)
练习：写一个矩形类，拥有属性长和宽
class Rectangle:
"""矩形"""
def __init__(self,lenght=0,width=0):
self.lenght=lenght
self.width=width
rec1=Rectangle()
print(rec1.lenght,rec1.width)
rec2=Rectangle(8,9)
print(rec2.lenght,rec2.width)
05.对象属性的增删改查
python是动态语言，python中类的对象的属性可以进行增删的操作
class Person:
"""人类"""
def __init__(self):
self.name = '张三'
self.age = 18
self.height = 666
1.查（获取属性的值）
p1 = Person()#创建对象
p2 = Person()
"""
方法1.对象.属性名
方法2.def getattr(object对象,name属性名,default=None)
方法3.对象.__getattribute__(属性名)
"""
print(p1.name)
# print(p1.name2) #属性不存在会报错
print(Person().name)
print(getattr(p1,'age'))
print(getattr(p1,'age2'))
#属性不存在会报错
print(getattr(p1,'age2',0))
#属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值
height=p1.__getattribute__('height')
print(height)
2.改（修改属性的值,前提属性值存在）
"""
方法1. 对象.属性 = 新值
方法2. def setattr(对象，属性名，新值)
方法3. 对象.__setattr__(属性名，新值)
"""
p1.name = '李四'
setattr(p1,'age',20)
print(p1.age)
p1.__setattr__('height',999)
print(p1.height)
3.增（添加属性,前提属性值不存在）
注意：添加属性只能给某一个对象添加对应的属性
"""
方法1. 对象.属性 = 新值
方法2. def setattr(对象，属性名，新值)
方法3. 对象.__setattr__(属性名，新值)
"""
p1.sex = '女'
print(p1.sex)
setattr(p1,'weight',40)
print(p1.weight)
p1.__setattr__('color','黑色')
print(p1.color)
# print(p2.color) #添加属性只影响一个对象
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)
06.对象方法
1.对象方法：
a.对象方法是什么样的方法？
直接声明的函数默认叫对象方法，有一个默认参数self
b.对象方法要通过对象来调用：对象.对象方法（）
c.对象方法中默认参数self，不需要传参。在调用方法时，系统会自动将当前对象传给self哪个对象调用的方法，self就指向谁
import math
class Circle:
def __init__(self,radius):
self.radius = radius
# 声明了一个对象方法area
# 在此处，self就是调用area方法的对象。对象能做的事self也能做。
def area(self):
# print(id(self))
# print(self.radius)
# self.radius =100
# print('求圆的面积')
return pi*(self.radius**2)
# 创建半径为3的圆
c1 = Circle(3)#构造方法
print(id(c1))
print(c1.area())
print(c1.radius)
c1.radius = 100
c2 = Circle(5)
print(c2.area())
练习1：写一个矩形类，有属性长和宽，有两个功能，分别计算面积和周长
class Rectangle:
def __init__(self,long,width):
self.long=long
self.width=width
def area(self):
return self.long*self.width
def perimeter(self):
return (self.long+self.width)*2
a1=Rectangle(9,8)
print('面积为：',a1.area())
print('周长为：',a1.perimeter())
练习2：写一个班级类，班级有多个学生的成绩（一门），功能可以获取班级成绩中的最高分
class Class_student:
def __init__(self,name):
self.scores=[]
self.name=name
def max (self):
if not self.scores:
return 0
# max（序列）---> 获取序列中元素的最大值
# min（序列）---> ·············最小值
return max(self.scores)
b1=Class_student('python1806')
b1.scores = [45,67,87,9,99]
print("最高分：",b1.max())
07.类的字段
1.类的属性叫类的字段
a.类的字段的含义：
类的字段就是声明在类中，方法（函数）的外的变量
b.什么样的属性声明成类的字段：
属于类的，对于类的所有对象而言其值是共有的。
c.怎么使用：
通过类来使用：类.字段
class Person:
# 这个number就是类的字段
number=99
# 通过类获取类的字段的值
print(Person.number) #99
# 修改类字段里的值
Person.number = 66
print(Person.number) #66
练习：写一个类，用一个属性来保存这个类的创建对象个数
class Football:
sum1=0
# 每次创建球的对象都会调用init方法，所以init方法调用的次数就是Ball创建的对象的个数
def __init__(self):
Football.sum1+=1
ball1=Football()
ball2=Football()
ball3=Football()
print(Football.sum1)
08.类的方法：
类中的方法
1.对象方法（实例方法）
声明的形式：直接声明在类型
特点：自带一个不需要主动传参的默认参数self,谁来调用指向谁
调用：通过对象来调用
2.类方法
声明的形式：声明方法前需要使用 @classmethod说明
特点：自带参数cls，这个参数调用的时候不需要传值。系统自动传值，谁调用指向谁，始终指向当前类
调用：通过类来调用 -> 类.类方法（）
3.静态方法
声明的形式：声明方法前需要使用 @staticmethod说明
特点：没默认参数
调用：通过类来调用 -> 类.静态方法（）
4.遇到问题如何选择哪种方法的使用：
a.大前提：只要实现方法的功能需要用到对象的属性，我们就使用对象方法。
b.不使用对象方法的前提下，如果实现功能需要用到类的字段或者类的其他方法就使用类方法。
c.实现功能既不需要对象属性又不需要类的字段就使用静态方法。
注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然
class Person:
number=999
# 声明一个对象方法
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)
# 调用类方法
print(Person.Class_func())
# 调用静态方法
print(Person.Static_func())