一、面向对象编程

什么是面向对象编程？？
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_score<stu.score:
        max_score=stu.score
    if min_score>stu.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__)