编程方式
面向过程:以算法为工具
函数式编程:以函数为工具
面向对象编程:以类和对象为工具
1.类的声明
类：对拥有相同功能和相同属性的对象的集合
对象:类的实例
封装效果:一个类中可以对多个功能进行封装（多个函数）
类声明格式:
class 类名(父类列表):
类的内容
2.说明:
class:声明类的关键字
类名:标识符，不能是关键字，驼峰式命名(第一个单词首字母小写，其他的单词首字母大写)首字母大写！！！，见名知义
例如:Person、StudentSystem
(父类列表):这个部分可以省略，这个是继承语法，可以有多继承
冒号:固定写法
类的内容:类的内容包括类的方法和类的属性
3.类中的方法：就是声明在类中的函数
方法：
a.对象方法:对象方法需要通过对象来调用，对象.函数名()
直接写在类中的方法，自带一个self参数
b.创建类的时候，系统会默认给我们创建这个类对应的构造方法
构造方法:类名()--->创建类对应的对象，只有在调用构造方法的时候才会产生新的对象
调用对象方法:对象.方法()
1).构造方法：系统自动创建的，方法名和类名一样，用来创建对象
2).init:init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法
class Person:
def __init__(self):
print('初始化...')
def eat(self):
print('吃饭')
if __name__ =='__main__':
p1=Person() #创建Person类的对象，并且将对象的地址存到p1中
p1.eat() #调用对象方法
创建对象的过程：调用构造方法在内存中开辟一个对象，然后用新建的这个对象去调用init方法
来初始化对象的属性，最后才将对象返回
class Person:
#init方法可以添加参数
def __init__(self,name):
print(name)
if __name__=='__main__':
p1=Person('hello')
4 .类字段和类方法
类中的内容:属性和方法
1).属性：
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性时对象属性，属于对象
b.类的字段：属于类的，所有的对象对应的值是一样的
类中对象的属性声明再init方法中的，并且声明格式是:self.属性名 = 初值
***对象的属性必须是全部传入的
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def print_info(self):
print(self.name,end='')
print(self.age)
if __name__ == '__main__':
s1=Student('张三',18)
s1.print_info()
s2=Student('李四',20)
s2.print_info()
***对象的属性时默认的
class Student:
def __init__(self):
self.name = '张三'
self.age = 18
self.id = 1
def print_info(self):
print(self.name,self.age,self.id)
if __name__ == '__main__':
s1 = Student()
s1.print_info()
s1.name = '李四'
s1.age = 20
s1.id = 2
s1.print_info()
***对象的属性部分传入部分默认
class Person:
class_p ='white person'
def __init__(self,id):
self.name = '张三'
self.age = '20'
self.id = id
if __name__ == '__main__':
p = Person(10)
print(Person.class_p)
print(p.class_p)
对象的属性通过(对象.属性)去使用对象的属性，也可以通过(对象.属性)去修改对象的属性
练习：写一个矩形类，拥有属性长和宽
class Rect:
def __init__(self,width,height):
self.height=height
self.width=width
def print_info(self):
print(self.width,self.height)
if __name__ == '__main__':
r = Rect(20,30)
r2 = Rect(30,40)
r.print_info()
r2.print_info()
5.对象属性的增删改查
python是动态语言，python中类的对象的属性可以进行增删的的操作
class Person:
def __init__(self):
self.name ='张三'
self.age = 18
self.height = 160
if __name__=='__main__':
p1 = Person()
#查（获取属性的的值）
'''
方法一:对象.属性名，当这个属性名不存在的时候，会报AttributeError错误
'''
print(p1.name)
'''
方法二:通过内置函数getattr(object,name,default=None)
object:指定对象
name:属性名字,字符串
defalut:如果设置了默认值，而要取的属性不存在，会取回默认值，程序不会崩溃，
如果没有设置默认值，要取的属性不存在，会报错AttributeError
'''
print(getattr(p1,'name',0)) #0
print(getattr(p1,'name')) #Attribute
'''
方法三对象.__getattribute__(属性名)
属性名:是一个字符串
'''
print(p1.__getattribute__('name'))
#2.改（修改属性的值）
'''
方法一：对象.属性 = 新值
方法二: def setattr(对象，属性名，新值)
方法三:对象.__setattr__(属性名，新值)
'''
p1.name = 'hello'
print(p1.name)
setattr(p1,'name','world')
print(p1.name)
p1.__setattr__('name','python')
print(p1.name)
'''
3.增加(添加属性)
增加的语法和修改的语法一模一样，属性值存在就是修改，属性值不存在的时候就是添加
方法一：对象.新属性 = 初值
方法二: def setattr(对象，新属性名，初值)
方法三:对象.__setattr__(新属性名，初值)
注意：添加属性只能给某一个对象添加属性
p1.sex = '女'
print(p1.sex)
setattr(p1,'weight',45)
print(p1.weight)
p1.__setattr__('color','red')
print(p1.color)
类也可以以这样的方式添加属性
'''
'''
4.删除
方法一:del 对象.属性
方法二:delattr(objject,属性名)
第一个参数是对象，第二个参数是属性名
delattr(p1,'age')
方法三:对象.__delattr__(属性名)
注意：删除只针对某一个单独的对象
'''
del p1.name
print(p1.name)
delattr(p1,'age')
print(p1.age)
p1.__delattr__('name')
print(p1.name)
6.对象方法
a.什么是对象方法:对象方法就是写在类里面的方法默认全部是对象方法，对象方法有一个默认参数self
b.对象方法要通过对象来调用：对象.对象方法()
c.对象方法中默认参数self，不需要传参，因为在调用这个方法的时候系统会自动将当前对象传给self，谁调用self，self就是谁
import math
class Circle:
pi = math.pi
def __init__(self,radius):
self.radius = radius
#声明一个对象方法area
#在这儿，self就是调用area方法的对象，对象能做的事，self都可以做，相当于java里的this.
def area(self):
print(id(self))
return self.radius**2*Circle.pi
if __name__ == '__main__':
c1 =Circle(10)
print(id(c1))
print(c1.area())
练习1:写一个矩形类有属性长和宽，有两个功能分别是求周长和面积
class Rect:
def __init__(self,length,width):
self.length = length
self.width = width
#对象方法是否需要额外参数，看实现函数的功能需不需要除了对象属性以外的其他的数据
def perimeter(self):
return (self.length+self.width)*2
def area(self):
return self.length*self.width
练习2：写一个班级类，班级里面有多个学生的成绩(一门)，可以获取班级成绩中的最高分
class Class:
'''
班级类
'''
def __init__(self,classname):
self.scores = []
self.classname = classname
def get_high_score(self):
if self.scores:
return max(self.scores)
return None
if __name__=='__main__':
c1=Class('001')
c1.scores=[10,20,5,25,76,1]
print(c1.get_high_score())
d.类的字段
类的属性叫类的字段
a.什么是类的字段:类的字段就是声明在类中，函数的外面的变量，叫做类的字段
class Person:
#这个number就是类的字段
number = 10
if __name__ == '__main__':
print(Person.number)
b.什么样的属性声明成类的字段
不同的对象对应的值都是一样的，他是属于所有对象公有的属性，是属于类的。
c.怎么使用
通过类来使用:类.字段
练习:写一个类，用一个属性来保存这个类创建的对象的个数
class Person:
count = 0
def __init__(self):
Person.count +=1
if __name__=='__main__':
p1=Person()
p1=Person()
p1=Person()
p1=Person()
print(Person.count)
e.类的方法
类中的方法：
1.对象方法（实例方法）
直接声明再类中，自带一个不需要主动传参的默认参数self,谁来调用指向谁
调用:通过对象来调用
2.类方法
声明方法前需要使用@classmethod说明
特点:自带一个默认参数cls,这个参数调用的时候不需要传值，系统自动给他传，谁调用就指向谁，始终指向当前类
调用:通过类来调用->类.类方法
cls:就是当前类，可以创建对象，调用类的属性和方法
3.静态方法
声明方法前需要使用@staticmethod说明
特点:没有默认参数,静态方法不能在继承中修改
调用：通过类来调用-->类.静态方法()
类方法声明格式
Class Person:
#声明一个对象方法
def object_func(self):
print('对象方法')
#声明类方法
@classmethod
def class+func(cls):
print('这是一个类方法')
#声明静态方法
@staticmethod()
def static_func():
print('这是一个静态方法')
4.遇到问题怎么来选择使用哪种方法：
a.大前提:只要实现方法的功能需要用到对象的属性，我们就使用对象方法
b.不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意:静态方法和类方法划分不用那么严格，静态方法能做的类方法也可以做，反之亦然
class Person:
#类的字段，存储人类的数量
number = 100
@classmethod
def show_number(cls):
print('人类的数量是:%d亿'%cls.number)
@staticmethod
def show_number():
print('人类的数量是:%d亿'%Person.nmber)
Person.show_number()