一、面向对象编程
什么是面向对象编程？？
1、面向过程编程（逻辑思维）
依赖于算法和逻辑，用代码逐句把功能实现
2、函数式编程（python中模块和函数）
将函数作为工具，依赖于函数
3、面向对象编程（生活思维）
依赖于类和对象，通过类的实例来实现
二、类和对象
1、类的申明
么是类：类是拥有相同属性和相同功能的对象的集合（抽象）
什么是对象：对象就是类的实例（具体）
格式：
class 类名（父类列表）:
类的说明文档
类的内容
说明：class--关键字
类名：标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写
驼峰式命名：如果一个单词由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
eg：userName
PEP8命名规范：如果一个单词由多个单词组成，所有字母小写，多个单词用下划线隔开
eg：user_name
python：类名用驼峰式（首字母大写），函数名和变量名用PEP8
父类列表：继承语法，让申明的类继承括号中的父类
类的内容：包含属性（变量）和方法（函数）
class Person1:
def eat(self,name):
print('self:',self)
print(name)
self.sleep()
def sleep(self):
print("s_self",self)
print("sleep")
2、申明对象
格式：
对象名=类名（）
对象名：变量名
类名：必须是申明过的类
xiaoming=Person1()
xiaoming.eat("糕点")
3、对象方法
类的内容包含属性和方法，方法分为对象方法、类方法、静态方法
（1）对象方法：申明在类中的函数就是对象方法，对象方法有一个默认参数self，通过对象来调用
（2）对象方法的调用：调用对象方法不需要给默认参数self传参，系统西东将当前对象赋值给self
（3）self:当前类的对象，对象能做的事情，self也能做（谁调用当前的对象，self指向谁）
p1=Person1()
print("p1:",p1)
p1.eat("三明治")
4、构造方法和init方法
(1)构造方法：函数名和类名一样的方法，用来创建对象。
Python中的构造方法是在申明类的时候自动创建的，在创建对象的时候自动调用了构造方法
创建对象的过程：
调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法初始化对象
(2)init方法:是一个对象方法，创建完对象后自动调用
(3)带参的init方法：通过构造方法传递给init方法
class Dog:
def __init__(self):
print('init')
dog1=Dog()
class Person2:
def __init__(self,name,age):
print(name,age)
p1=Person2('xiaoming',20)
5、对象的属性
属性可分为对象属性和类的字段
属性：用来在类中去保存数据的变量。（因为对象的不同而变化）
字段：固定的数据，不会因为对象的不同而改变
属性申明：
（1）必须申明在init方法中
（2）格式：self.属性=初值
class Person3():
def __init__(self):
self.name='xiaoming'
self.age=18
self.sex="male"
class Person4():
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
p3=Person3()
print(p3.name)
p4=Person4("xiaozhang",10,'famale')
print(p4.name)
6、对象属性的增删改查
查：
(1)对象.属性-- 属性不存在，会报错
(2)getattr(对象，属性名，默认值)--获取指定属性值，属性不存在会报错
(3)对象.getattribute(属性名)--获取指定属性值，属性不存在会报错
增：只对某一个对象生效
(1)对象.属性=值（属性不存在就增加，存在就修改）
(2)setattr(对象，属性名，默认值)
(3)对象.setattr(属性名)
删：
(1)del 对象.属性
(2)delattr（对象，属性名）
(3)对象.delattr(属性名)
print(p4.name)
print(getattr(p4,'name'))
print(getattr(p4,'name','xiaoming'))
print(p4.__getattribute__("name"))
print("======")
p4.salary=1000
setattr(p4,"salary1",2000)
p4.__setattr__('salary2',3000)
print(p4.salary,p4.salary1,p4.salary2)
del p4.salary
p4.__delattr__('salary1')
delattr(p4,'salary2')
三、对象的使用
python中所有的数据都是对象，所有变量存储的都是对象的地址
只有调用构造函数的时候才创建对象
import copy
class Student:
def __init__(self,name,age,score):
self.name=name
self.age=age
self.score=score
def __str__(self): #定制当前类对象的打印格式，返回值必须是字符串
return str(self.__dict__)
1、对象给别的变量赋值：传地址
stu1=Student("xiaoming",11,90)
stu2=stu1 #赋予对象地址
stu3=copy.copy(stu1)#产生新的对象
print(stu1,stu2,stu3)
2、对象作为列表的元素
students=[Student("xiaoming",12,89),Student("xiaohuang",13,96),Student("xiaohong",13,78)]
#找最大、最小值
max_score=students[0].score
min_score=students[0].score
for stu in students:
if max_scorestu.score:
min_score=stu.score
print(max_score,min_score)
#找最大值
stu=max(students,key= lambda item:item.score)
print(stu.score)
#列表排序（按照分数排序）
students.sort(key= lambda item:item.score,reverse=True)
for stu in students:
print(stu)
print("==============")
#根据姓名查找学生信息
def find_stu(name):
for stu in students:
if stu.name==name:
print(stu)
#根据姓名修改指定学生的年龄：
def set_age(name,age):
for stu in students:
if stu.name==name:
setattr(stu,"age",age)
print(stu)
find_stu("xiaoming")
set_age("xiaohong",22)
四、slots魔法
1、类的字段
属性：对象属性，类的字段
类的字段：申明在类里面，函数外面的变量就是类的字段，使用的时候通过类来使用：类.字段
2、slots魔法
有可能在给对象属性赋值的时候，把属性名写作，则该对象增加了一个属性
用来约束类的属性，定义属性的时候属性名只能是slots元组中的字段
class Dog:
num=10 #num就是类的字段，通过类来使用
__slots__ = ('color','name','type','sex','price','age')
def __init__(self,color,name,tpye):
self.color=color
self.name=name
self.type=type
Dog.num=100
print(Dog.num)
dog1=Dog('黄色',"大黄",'土狗')
#dog1.neme="旺财" #报错，不在slots数组中
五、内置类属性
class Person:
'''human'''
num=10
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def run(self):
print("%s is runing..."% self.name)
p1=Person('xiaoming',19,'male')
#1、__name__ 获取当前类的名字
print(Person.__name__,type(Person.__name__))
#2、__doc__ 获取当前类的说明文档
print(Person.__doc__)
#3、__class__ 获取对象的类，返回的是一个类
my_class=p1.__class__
print(my_class)
p2=my_class('xiaohong',12,'female')
#4、__dict__
'''
对象.__dict__: 获取当前对象所有的属性和其对应的值，以字典的形式返回
类.__dict__：获取当前类的所有类的字段和其对应的值，以字典的形式返回
'''
print(Person.__dict__)
print(p1.__dict__)
#5、__module__
'''
类.__module__:获取当前类所在的模块名,正在执行的模块为'__mian__'
'''
print(Person.__module__)
#6、__bases__
'''
类.__bases__:获取当前类的父类，返回的是一个元组，元组的元素是类
'''
print(Person.__bases__)