一、

1、面向过程编程——》算法，逻辑（数学逻辑）
2、函数式编程——》函数
3、面向对象编程——》类和对象（生活）

二、类

1、什么是类

类——是拥有相同属性和相同功能的对象的集合（抽象的）
对象——就是类的实例（具体的）
从生活角度来看类和对象
如果说人是一个类，那么其中的一个人就是对象；
如果说汽车是一个类，那么其中的某辆汽车就是对象；
想要有对象，必须现有类；

2、类的声明

格式：
class 类名（父类列表）:
》》类的说明文档
》》类的内容

说明：
class——》Python中声明类的关键字
类名——》标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写；见名知义；
驼峰式命名：如果一个名字有多个单词组成，第一个单词首字母小写，后面每个单词首字母大写；
PEP8命名规范：所有字母小写，多个单词之间用下划线隔开；
（父类列表）——》继承语法。让声明的类继承括号里的父类。这个结构可省略，让当前类继承Python的基类：object
:——》固定结构
类的说明文档——》注释，对类进行说明。 格式： '''内容'''
类的内容——》包含属性（变量）和方法（声明在类中的函数）
函数声明在类的外面叫函数，在类的里面叫方法；

声明Person类，吃饭睡觉

class Person:
    '''human'''
    def eat(self):
        print('eat_self',self)  #self <__main__.Person object at 0x02091870>  同p1（即调用该方法的对象）的地址
        print('吃饭')
    def sleep(self):
        print('sleep_self',self)  #sleep_self <__main__.Person object at 0x004A1710>  同p2（即调用该方法的对象）的地址
        print('睡觉')

3、对象的声明
格式：
对象名=类名（）
对象名——》变量名
类名——》必须是声明过的类

声明Person类的对象

p1=Person()
p2=Person()

三、对象方法

1、

类的内容包含属性和方法，方法分为对象方法、类方法、静态方法；
对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self，需要通过对象来调用；
对象调用：对象.方法名（）。调用对象方法，不需要给默认参数传参，系统会自动将当前对象传递self；
self：谁调用当前的方法，self就指向谁；

p1.eat()
print(p1) #<__main__.Person object at 0x02091870>

p2.sleep()
print(p2) #<__main__.Person object at 0x004A1710>

四、构造方法和init方法

1、构造方法

构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应的构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用_ init _方法去对这个对象进行初始化；
最后将创建好的对象的地址返回

2、_ init _方法

对象方法
不需要手动调用，创建完对象后，会被自动调用

class Dog:
    def __init__(self):
        print('self',self) #self <__main__.Dog object at 0x006237D0>
        print('汪汪')  #汪汪

d1=Dog()
print(d1)  #<__main__.Dog object at 0x006237D0>
d2=Dog()

3、带其他参数的init方法

init方法的参数要通过构造方法来传。（构造方法的实参会传递给init方法的形参）
init方法的参数要通过构造方法来传。（构造方法的实参，会传递给init方法的形参）

class Person:
    def __init__(self, name='', age=0):
        print(name, age)

p1 = Person('小红', 20) #小红 20
p2 = Person('小明') #小明 0
p3 = Person(age=10) # 0

五、对象的属性

类的内容包含属性和方法，属性又分为对象属性和类的字段
属性：用来在类中去保存数据的变量。
对象属性：属性会因为对象的不同而不同，这种属性就需要声明成对象属性，对象属性要通过对象来使用；比如人的名字，年龄；
类的字段：跟对象属性相反，不会因为对象的不同而不同，这种属性就声明成类的字段；比如人口总数；

1、对象属性的声明（重点）

a、必须声明在init方法中；
b、声明格式：self.属性名=初值

2、使用对象属性：对象.属性

######声明一个人类，要求有名字、年龄、性别属性
class Person:
    def __init__(self):
        self.name="张三"
        self.age=25
        self.sex='男'
p1=Person()
print(p1.name) #张三
print(p1.age)  #25

声明一个人类，要求有名字、年龄、性别属性。要求创建不同对象可以确定不同的属性值。

class Person2:
    def __init__(self,name1,age1=18,sex1="男"):
        self.name=name1
        self.age=age1
        self.sex=sex1
p1=Person2('王二',20,'女')
print(p1.name,p1.age,p1.sex)  #王二 20 女
p2=Person2('雷锋')
print(p2.name,p2.age,p2.sex)  #雷锋 18 男
p2.age=22
print(p2.name,p2.age,p2.sex)  #雷锋 22 男

六、对象属性的增删改查

class Student:
    def __init__(self,name1,age1=18,sex1="男",stu_id1=1):
        self.name=name1
        self.age=age1
        self.sex=sex1
        self.stu_id=stu_id1

1、查（获取对象属性的值）

a、对象.属性——》属性不存在会报错

stu1=Student('马云')
print(stu1.name)
# print(stu1.name2)  #AttributeError: 'Student' object has no attribute 'name2'

b、getattr（对象，属性名，默认值）——》获取指定属性值，如果设置了默认值当属性不存在的时候不会报错， 并且会将默认值作文结果。（如果没有设置默认值，属性不存在还是会报错）

print(getattr(stu1,"age",12))  #18

c、对象getattribute(属性名)——》获取指定属性值，属性值不存在会报错

print(stu1.__getattribute__('sex')) #男

2、增/改（给对象添加属性）

a、对象.属性=值（属性不存在为增，属性存在为改）

b、setattr(对象,属性名,属性值)

c、对象.setattr(属性名,属性值)

给对象添加属性，只能添加到当前对象中。不会影响当前类的其他对象。

stu2=Student('刘强东',20)
print(stu2.name)   #刘强东
stu2.name='川普'  #name存在，功能为改  将刘强东改为川普
print(stu2.name)  #川普
stu2.tel=123456    #tel不存在，功能为增  将属性tel赋值为123456
print(stu2.name,stu2.tel)  #川普 123456
#====================
stu3=Student('任正非')
setattr(stu3,'tel',1234)  #增
print(stu3.tel)  #1234
setattr(stu3,'tel',65432) #改
print(stu3.tel)
stu3.__setattr__('tel',826)#改
print(stu3.tel)
#=======================

3、删（删除对象属性）

删除只删除当前对象属性，对当前类中其他对象无影响

a、del 对象.属性

b、delattr(对象,属性名)

c、对象.delsttr(属性)

del stu2.tel
print(stu2.tel)   #AttributeError: 'Student' object has no attribute 'age'

七、对象的使用

Python中所有的数据都是对象，所有的变量存储的都是对象的地址

import copy
class Student:
    def __init__(self,name1,score,sex1="男",age1=18):
        self.name=name1
        self.age=age1
        self.sex=sex1
        self.score=score
    def __str__(self):
        return str(self.__dict__)

1、将对象给别的变量赋值

stu1=Student('鸣人',60,'boy')
stu2=stu1
stu3=copy.copy(stu1)
stu1.name='佐助';stu1.score=90
print(stu1.name,stu2.name,stu3.name,sep='\n')
#佐助
#佐助
#鸣人

2、将对象作为列表的元素

student=[stu1,stu3,Student('小樱',80,'girl')]
for stu in student:
    print(stu)
# {'name': '佐助', 'age': 18, 'sex': 'boy', 'score': 90}
# {'name': '鸣人', 'age': 18, 'sex': 'boy', 'score': 60}
# {'name': '小樱', 'age': 18, 'sex': 'girl', 'score': 80}

八、slots魔法

1、类的字段

属性：对象属性，类的字段
类的字段:声明在类里面，函数外面的变量就是类的字段。
使用的时候要通过类来使用。类.字段

2、slots :用来约束当前类的对象的属性有哪些

class Dog():
    num=100
    #__slots__ 用来约束当前类的对象的属性有哪些
    __slots__ = ('colar','name','age','sex','price')
    def __init__(self,colar,name,age,sex,price):
        self.colar=colar
        self.name=name
        self.age=age
        self.sex=sex
        self.price=price

print(Dog.num)   #100
Dog.num=10
print(Dog.num)  #10

九、内置类属性

class Person3:
    #类的字段
    num=100
    def __init__(self,name1,sex1="男",age1=18):
        # 对象属性
        self.name=name1
        self.age=age1
        self.sex=sex1
     #对象方法
    def run(self):
        print('%s在跑' %self.name)
p1=Person3('卡卡西')
print(p1.sex,p1.run(),sep='\n')

1、name

类.name ——》获取当前类的名字

2、doc

类.doc ——》获取类的说明文档

3、class

对象.class——》获取对象的类,类能做的事，它都能做

4、dict

类.dict——》获取当前类所有类的字段和其对应的值，并以字典的形式返回值
对象.dict ——》获取当前对象所有属性和其对应的值，以字典形式返回值

5、module

类.module——》获取当前类所在的模块

6、bases

类.bases——》获取当前类的父类，返回的是一个元祖，元素是类

print(Person3.__name__,Person3.__doc__,p1.__class__,
      Person3.__dict__,p1.__dict__,Person3.__module__,Person3.__bases__,sep='\n')
================
Person3
None
<class '__main__.Person3'>
{'__module__': '__main__', 'num': 100, '__init__': <function Person3.__init__ at 0x01E69618>, 'run': <function Person3.run at 0x01E69660>, '__dict__': <attribute '__dict__' of 'Person3' objects>, '__weakref__': <attribute '__weakref__' of 'Person3' objects>, '__doc__': None}
{'name': '卡卡西', 'age': 18, 'sex': '男'}
__main__
(<class 'object'>,)