一、编程思想

1.面向过程
做法：遇到问题直接将（逻辑和算法）转换为代码
使用工具：逻辑和算法
2.面向函数式编程
做法：遇到问题就想找一个、写一个相应功能的函数
使用工具：函数
3.面向对象
做法：遇到问题就考虑可不可以有一个类来提供相应的功能和数据
使用工具：类和对象
类中的属性 - 对数据的封装
类中的函数 - 对功能的封装

二、类和对象基础

1.类和对象的概念
a.什么是类：
概念：拥有相同功能和相同属性的对象的集合（抽象）
b.什么是对象
概念：类的实例（具体）

2.类的声明
内容：功能（函数）和属性（变量/属性）
a.语法
class 类名（父类）：
 类的内容

b.说明
class: 声明类的关键字
类名：标识符，并且不能是关键字
规范：采用大驼峰式命名
：：规定写法
类的内容：累的方法、属性和说明文档
方法：声明在类中的函数
属性：声明在类中的变量

3.如何声明对象
方法：类名（）
说明：创建指定类的对象并且返回

注意：同一个类可以创建多个对象
示例：

# 声明一个人类
class Person:
    """类的说明文档"""
    num = 61  # 类中的属性

    # 类中的方法
    def eat(self):
        print('人在吃饭！！')
    # 创建Person类的对象；p1就是对象
    p1 = Person()
    print(p1)

    # 同一个类可以创建多个对象
    p2 = Person()
    print(p2)

三、对象方法

声明类的伪代码
class 类名：
  类中的属性
  类中的方法

1.什么是类中的方法
声明在类中的函数就是方法
分类：
指导思想：怎么声明，怎么调用，特点
a.对象方法：
声明：直接声明在类中
特点：有默认参数self,通过对象调用可以不用传参
调用：对象.对象方法名
当前对象：调用当前方法的对象（谁调用对象方法self就是谁）
注意：当前类的对象能做的事情，self都能做

b.类方法：
声明：声明函数前加@classmethod
特点：有默认参数cls,通过类调用时，可以不用传参
调用：类名.类方法名
当前对象：调用当前方法的类（谁调用类方法*cls就是谁）
注意：当前类能做的事情，cls都能做
c.静态方法：
声明：声明函数前加@staticmethod
特点：没有默认参数
调用：类名.静态方法名

实际运用

类中怎么选择使用哪种方法：
对象方法：实现函数功能需要使用对象属性
类方法：
1.不需要使用对象属性为前提
2.需要使用类的字段
静态方法：对象属性和类的字段皆不需要

class Person:
    # 类的字段
    num = 23

    # 对象方法：用到对象属性name
    def __init__(self):
        self.name = '张三'

    # 对象属性和类的字段都有，选择对象方法
    def func4(self):
        # 通过self.name来获取对象的姓名
        print('%s对应的对象' % self.name)
        # 通过 类名.类的字段 来使用类的字段
        print('人类的数量%d亿' % Person.num)

    # 静态方法：对象属性和类的字段都不需要
    @staticmethod
    def func3():

        print('我是静态方法')
    # 类方法：需要使用类的字段
    @classmethod
    def func1(cls):
        # 类能做的事情，cls都能做
        p1 = cls()  # 用cls创建对象
        print(p1)
        cls.num = 100  # 用cls来使用类的字段
        print(cls)
        print('这是一个类方法')

四、init方法和构造方法

1.init方法：init
定义：类中的一个特殊的对象方法
功能：专门用来对象创建的对象进行初始化
过程：当通过类创建对象时，系统就会自动调用init方法

2.构造方法：
定义：函数名和类名一样的函数
功能：专门用来创建对象
原理：
1.声明类时，系统自动创建类对应的构造方法
内部如何实现
2.创建对象时，内部会先在内部开辟空间保存对象；然后用创建的对象去调用init方法，用来对对象进行初始化，init方法结束后，返回对象

def Person(*args, *kwargs):
  对象 = 创建对象
  对象.init（args, **kwargs）
  return 对象

注意：如果类的init方法除了self以外，还有其他参数，那么我们在创建对象的时候，需要通过给构造方法传参，来间接给init方法参数赋值

魔法方法：类中以__开头并且以__结尾的方法
特点：创建对象时，无需主动调用，系统会自动调用

# =========构造方法和init方法的原理=========
# 构造方法的伪代码
def my_init(x, y, z):
    print(x, y, z)
    print('my_init')

def my_Dog(*args, **kwargs):
    my_init(*args, **kwargs)

my_Dog(10, 29, 39)

五、类中属性

分类：类的字段和对象属性
a.对象属性：
特点：属性的值会因为对象不同而不同
声明：init对象方法中
方式：self.属性 = 值（这里属性就是对象属性）
调用：对象.属性

b.类的字段
特点：属性的值不会因为对象的不同而不同
声明：在类中，但在函数外
方式：类的字段名 = 值
调用：类名.类的字段名

class Person:
    # 类的字段
    num = 33

    # 在init方法中声明对象属性
    def __init__(self, name1='', age1=0):
        self.name = name1
        self.age = age1

对象属性的增删改查

1.查（获取对象属性）
方法一：
对象.属性
功能：获取指定对象的指定属性值;属性不存在报错
错误类型：AttributeError 属性错误

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex
print(p1.name)
# print(p1.name1)  # AttributeError 属性错误

方法二：
getattr(对象，属性名）
功能：获取指定对象的指定属性值;
特点：属性不存在，给默认值赋值，不会报错，并且将默认值作为结果返回
应用场景：不确定属性值是否存在时使用

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex
# 属性不确定，可以使用getattr
    # attr = input('属性：')
    # print(getattr(p1, attr))
print(getattr(p1, 'name', None))
print(getattr(p1, 'name1', None))

2.增（添加属性）/ 改（修改属性的值）
方法一：
对象.属性 = 值
功能：
1.属性存在，修改属性值
2.属性不存在，添加属性
方法二：
setattr(对象，属性名，值）
功能：
1.属性存在，修改属性值
2.属性不存在，添加属性

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex
# 修改属性
p1.name = '啊帅'
print(p1.name)
# 添加属性
p1.height = 180
print(p1.height)

# 修改属性
setattr(p1, 'age', 300)
print(p1.age)
# 添加属性
setattr(p1, 'weight', 200)
print(p1.weight)

3.删（删除属性）
方法一：
del 对象.属性
功能：删除对象属性
方法二：
delattr(对象，属性名）
输入：2个，对象、属性名
功能：删除对象属性

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex
del p1.sex
# print(p1.sex)  # AttributeError: 'Person' object has no attribute 'sex'
delattr(p1, 'age')
# print(p1.age)  # AttributeError: 'Person' object has no attribute 'age'

注意：对象属性的操作只针对于当前对象，不会影响其他对象

补充：__slots__魔法方法

功能：约束当前对象能够拥有的属性个数
特点：init方法里对象属性的个数少于或者等于slots方法的个数

class Dog:
    # __slots__魔法
    # 约束当前对象最多能拥有的那个属性
    __slots__ = ('name', 'color', 'sex', 'age')  # 下边声明的属性比这里少就行

    def __init__(self, name= '', color='黑色'):
        self.name = name
        self.color = color
dog1 = Dog('大话', '黄色')
    dog1.name = 'sss'
    del dog1.color

六、内置属性

定义：创建对象时，系统自动给我们添加的属性（通过继承得到）

• __name__
  功能：获取类的名字
  返回值：字符串
  调用：类名.__name__
  补充：获取的字符串可以当做字符串来用

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
print(Person)  # <class '__main__.Person'>
print(Person.__name__, type(Person.__name__))  # Person <class 'str'>
 # 值是一个字符串，可以当做字符串来用
print(Person.__name__.upper())  # PERSON

• __class__
  功能：获取对象对应的类
  返回值：类名
  调用：对象.__class__
  补充：可以将获取的类名当做类来用

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
p1 = Person()
my_class = p1.__class__
print(my_class)  # <class '__main__.Person'>
# 可以将my_class当做类使用
p2 = my_class('笑素数')
print(p2.num)  # 62

• __doc__
  功能：获取类的说明文档
  返回值：字符串
  调用：类名.__doc__

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
print(Person.__doc__)  # 说明文档：人类
# 获取p1对应的说明文档
p1 = Person()    
print(p1.__class__.__doc__)  # 说明文档：人类

• __dict__
  功能：将对象属性转化为字典，属性作为key，值作为value
  返回值：字典
  调用：对象.__dict__

坑：当给slots属性赋值后，对象的dict属性就不能使用

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
p1 = Person()  
print(p1.__dict__)  # {'name': '', 'age': 0, 'sex': '男'}

• __bases__
  功能:获取当前类的父类
  返回值：元祖
  调用：类名.__bases__

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
print(Person.__bases__)  # (<class 'object'>,)

补充：__repr__

原理：当通过print打印一个对象的时候，实质是打印对象调用__repr__函数的返回值
功能：定制对象的打印格式
返回值：字符串
声明：类中的对象魔法方法

class Person:
    """说明文档：人类"""
    num = 62
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex

    def __repr__(self):
    # 系统默认的打印格式
    return '<%s.%s object at %s>' % (self.__class__.__module__, self.__class__.__name__, hex(id(self)))
    return str(self.__dict__)[1:-1] + 'at' + hex(id(self))  # 定制