一、面向对象编程

说明：

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

#声明Person类，吃饭和睡觉
class Person:
    ''' 人类'''
    def eat(self):
        print('吃饭')
    def sleep(self):
        print('睡觉')

3.对象的说明

对象=类名（）

说明：
对象名->变量名
类名->必须是声明过的类

# 声明Person类的对象p1和p2
p1=Person
p2=Person

二、面向对类的说明

1.类的内容包含属性和方法，方法分为对象方法、类方法和静态方法

对象方法：直接声明在类中的函数就是对象方法，对象方法都有一个默认参数self
需要使用对象来调用
对象调用：对象.方法名().调用对象方法的时候，不需要给默认参数self 传参。
系统会自动将当前对象传给self。
self:谁调用当前的对象方法，self就指向谁。self就是当前类的对象，类能做的事情，self都能做

class Person:
    ''' 人类'''
    def eat(self):
        print('吃饭')
        self.sleep()
    def sleep(self):
        print('睡觉')

# 声明对象
p1=Person()
print(p1)
p1.eat()

self就是调用对象象编程

三、构造方法和init方法

1.构造方法

构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应的构造方法

创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法去对这个对象进行初始化，最后将创建好的对象的地址返回

2.init方法

对象方法

class Dog:
    '''类'''
    def __init__(self):
        print(self)
        print('init方法')
dog1=Dog()
print(dog1)

dog2=Dog()

3.带参其他参数的init方法

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

四、对象的属性

类的内容包含属性和方法，属性又分为对象属性和类的字段

属性：用来在类中去保存数据的变量。
对象属性：属性的值会因为对象不同而不同，这种属性就需要声明 对象属性，列如：人的名字，人的年龄等
对象属性要通过对象来使用
1.对象属性的声明（重点！！）
a.必须声明在init方法中
b.声明格式：self.属性名=初值

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

声明一个人类，要求有名字，年龄，性别属性

class Person:
    def __init__(self):
        self.name='张三'
        self.age=18
        self.sex='男'
p1=Person()
print(p1.name)   #张三
p2=Person()
print(p2.name)   #张三

声明一个人类，有名字，年龄，性别三个属性。要求创建不同的对象的时候就可以直接确定不同的属性

class Person2:
    def __init__(self,name1,age1,sex1):
        self.name=name1
        self.age=age1
        self.sex=sex1
p1=Person2('小明',30,'男')
print(p1.name)

p1.name='xiaoming'
p1.id='002'
print(p1.name,p1.age)
print(p1.id)

五、对象的增删改查

class Student:
    def __init__(self,name='',age=0,study_id='001'):
        self.name=name
        self.age=age
        self.study_id=study_id

stu1=Student('小明')

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

方法1：对象.属性-->获取指定属性值，属性不存在会报错
print(stu1.name)

方法2.
getattr(对象，属性名，默认值）-->获取指定属性值，如果设置了默认值，当属性名不存在的时候不会报错，
并且会将默认值作为结果。（当没有设置默认值的时候，属性不存在还是会报错

print(getattr(stu1,'name'))
print(getattr(stu1,'name2','张三'))

方法3
对象.getattribute(属性名)-->获取指定属性值，属性不存在报错

print(stu1.getattribute('study_id'))

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

方法1：对象.属性=值 （属性不存在的时候增加，属性存在的时候修改）
方法2.getattr(对象,属性名,属性值)-- 属性不存在的时候增加，属性存在的时候修改
方法3.对象.setattribute(属性名，属性值)
注意：给对象添加属性只能添加到当前对象中，不会影响到当前类的其他对象

stu1.sex='man'

stu1.name='李四'
print(stu1.name)

3.删除

注意：删除只能删除当前对象的属性，对当前类的其他对象没有影响
方法1.del对象.属性
方法2.delattr(对象，属性名）
方法3.对象.delattr（属性名）

del stu1.age

delattr(stu1.sex)

六、对象的使用

import copy

python中所有的数据都是对象，

class Student:
    def __init__(self,name,age,sex,score):
        self.name=name
        self.age=age
        self.sex=sex
        self.score=score

      #定制当前类对象的打印格式，函数的返回值必须是字符串
    def __str__(self):
        return  str(self.__dict__)

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

stu1=Student('xiaohua',18,'man',90)
stu2=stu1  #赋对象地址
stu3=copy.copy(stu1)   #产生新的对象，将新的地址赋值

stu1.name='张三'
print(stu2.name)    #张三
print(stu3.name)    #xiaohua

students=[stu1,stu2,stu3]
def find(name,age):
    for stu in  students:
        if name==stu.name:
            stu.age=age

find('张三',99)
print(stu1.age)

七、slot类的属性

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

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

class Dog:
    num=10
    __slots__ = ('color','name','type','sex','price','age')
    def __init__(self,color,name,type,sex):
        self.color=color
        self.name=name
        self.type=type
        self.sex=sex
print(Dog.num)

八、内置类属性

class Person:
    '''人类'''
    #类的字段
    num=61

    #对象属性
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    #对象方法
    def run(self):
        print('%s在跑'%self.name)

p1=Person('小明',18,90)

1.name

类.name-->获取当前类的名字

print(Person.__name__,type(Person.__name__))

2.doc

类. _doc_-->获取类的说明文档

3.class

对象._class_-->获取对象的类，类能做的事情他都可以做

my_class=p1.__class__
# p2=Person('小花',18,90)
p2=my_class('小花',18,90)
print(p2.name)

4.dict

类._dict_-->获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
对象._dict_-->获取当前对象的所有的属性和其对应的值，以字典的形式返回

print(Person.__dict__)
print(p1.__dict__)

5.module

类._module_-->获取当前类所在的模块名

print(Person.__module__)
from datetime import datetime
print(datetime.__module__)

6.bases

类._bases_-->获取当前类的父类，返回的是一个元祖，元祖的元素是类

print(Person.__bases__)