1. 面向过程编程
   遇到问题直接将逻辑转换成代码，以逻辑思维作为工具
2. 函数式编程
   遇到问题就思考找一个或者写一个拥有相应功能的函数，以函数作为工具
3. 面向对象编程
   遇到问题就考虑可不可以有一个类来给我提供相应的功能和数据，以类和对象作为工具

python既支持函数式编程也支持面向对象编程

1. 什么是类，什么是对象
   类就是拥有相同功能和相同属性的对象的集合；类是抽象的
   对象就是类的实例；对象是具体的

2. 类的声明
   类中的内容包含功能（函数）和属性（变量/属性）。
   a. class 类名（父类）：
   类的内容
   b. 说明：
   class - python声明类的关键字
   类名 - 要求：标识符，不能是关键字
   规范：驼峰式命名（通过首字母大写来区分不同的单词）；第一个字母要大写
   ： - 固定写法
   类的内容 - 包含类的方法和属性和说明文档
   方法：声明在类中的函数
   属性：声明在类里面的变量

3. 对象的声明
   语法：
   类名() - 创建指定类对应的对象并且返回

user_name - pep8
userName - 驼峰式命名
UserName - 类名

class Person:
    """类的说明文档：人类"""
    num = 61    # 类中方法
    # 类中的方法


    def eat(self):
        print('人在吃饭')


def main():
    # 创建Person类的对象；p1就是对象
    p1 = Person()
    print(p1)
    # 同一个类可以创建多个对象
    p2 = Person()
    print(p2)

    p3 = p2
    print(p3)

class 类名：
类中的属性
类中的方法

1. 类中的方法
   声明在类中的函数就是方法
   类中的方法包括：对象方法（实例方法）、类方法、静态方法

2. 对象方法
   a. 什么是对象方法
   直接声明在类中的方法就是对象方法
   有默认参数self
   通过'对象.方法（）'的方式来调用（对象方法要通过对象来调用）

b. 参数self
当我们通过对象调用对方方法的时候，self不需要传参；因为系统会自动将当前对象传递给self。
当前对象：调用当前方法的对象（谁调用对象方法self就是谁）
注意：当前类的对象能做的事情，self都能做

class Person:
    def run(self):
        print('人在跑步')


def main():
    # 创建对象
    p1 = Person()
    # 通过对象p1调用的方法
    print('p1:',p1)
    p1.run()

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

2. 构造方法
   a. 声明构造方法
   函数名和类名一样的就是构造方法，专门用来创建对象
   python中声明类的时候，系统会自动创建这个类对应的构造方法

b. 构造方法的执行过程
当我们构造方法的时候内部会先在内存中开辟空间保存对象，然后用创建的对象去调用init方法
用来对对象进行初始化，init方法调用结束后，返回对象

def Person(x,y):
对象 = 创建对象
对象.init（x,y）
return 对象

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

class Person:
    # 类中__开头并且__结尾的方法叫做魔方方法。不需要主动调用，系统会自动调用。
    def __init__(self):
        print('init被调用')

class Dog():
    def __init__(self,x,y):
        print(x,y)
        print('dog的init')

# 构造方法的伪代码
def my_init(x,y,z=0):
    print(x,y,z)
def my_Dog(*args,**kwargs):
    dog = Dog.__init__()


def main():
    p1 = Person()

    p2 = Dog(10,20)

if __name__ == '__main__':
    main()

1. 什么是对象属性
   类中的属性分为类的字段和对象属性
   a. 对象属性：- 属性值会因为对象不同而不一样，这种属性就应该声明为对象属性
   声明在init方法中 - 位置
   以'self.属性 = 值'的方式来声明（这的属性就是对象属性） - 方式
   通过'对象.属性'的方式来使用 - 使用

b. 类的字段 - 属性的值不会因为对象不同而不同，这种属性就声明为类的字段
直接声明在类的里面，函数的外面的变量，就是函数类的子对
以'字段名 = 值'
通过'类.字段'的方式来使用

class Person:
    # num 就是类的字段
    num = 61
    # 在init方法中声明对象属性

    def __init__(self, name1='', age1=0):
        self.name = name1
        self.age = age1

练习：创建Dog类，有属性名字、类型、年龄
要求创建Dog的对象的时候不能给年龄赋值，可以给类型赋值也可以不用给类型赋值，必须给名字赋值

class Dog:
    def __init__(self, name, type=''):
        self.name = name
        self.type = type
        self.age = 0

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

练习：声明一个矩形类，拥有属性长和宽，拥有方法求面积和周长

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def square(self):
        return self.length * self.width

    def circumference(self):
        return 2 * (self.width + self.length)


r1 = Rectangle(200, 100)
print(r1.circumference())
print(r1.square())

dog = Dog('小花','猪')
dog.eat('骨头')

Person.num = 100
print(Person.num)


def main():
    p1 = Person('小明', 18)
    # 获取对象属性的值
    print(p1.name, p1.age)
    p2 = Person('小红', 20)
    # 修改对象属性的值
    p2.name = '李四'
    print(p2.name)


if __name__ == '__main__':
    main()

python中对象的属性支持增删改查

1. 查（获取对象属性）

属性的增删改查

class Person:
    def __init__(self, name='', age=0, sex='女'):
        self.name = name
        self.age = age
        self.sex = sex


class Dog:
    __slots__ = ('name', 'color')  # __slots__约束当前类的对象最多能拥有哪些属性

    def __init__(self, name='', color='黑色'):
        self.name = name
        self.color = color


dog1 = Dog('大黄', '黄色')

p1 = Person('小花')
p2 = Person('小红')

1.查（获取对象属性）
对象.属性 - 获取指定对象指定属性值
getattr(对象，属性名:str，默认值) - 获取指定对象指定属性值,当属性不存在的时候如果给默认值赋了值，程序不会报错，标签将默认值作为结果
当属性不确定的时候可以使用getattr

print(p1.name)
# print(p1.name1)   AttributeError: 'Person' object has no attribute 'name1'
print(getattr(p1, 'name', None))
print(getattr(p1, 'name1', None))

增、改

对象.属性 = 值 - 当属性存在的时候修改属性的值；属性不存在的时候添加属性
setattr(对象，属性名，值) - 当属性存在的时候修改属性的值；属性不存在的时候添加属性

p1.name = 'xiaohua'
print(p1.name)
p1.height = 180
print(p1.height)
setattr(p1, 'age', 18)
print(p1.age)
setattr(p1, 'weight', 200)
print(p1.weight)

删

del 对象.属性

delattr(对象，属性名)

del p1.sex
# print(p1.sex)         AttributeError: 'Person' object has no attribute 'sex'
delattr(p1, 'age')

注意：对象属性的操作，只针对操作的哪一个对象，不会影响其他对象

内置属性指的是我们创建类的时候系统自动给我们添加的属性（其实是通过继承获取来的）6种

class Person:
    # 类的字段
    num = 61
    #__slots__ = ('name', 'age', 'sex')
    # 对象属性

    def __init__(self,name='',age='',sex=''):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self,food):
        print('%s在吃%s'%(self.name,food))


    # 定制对象的打印格式（当我们通过print打印一个对象的时候，实质就是打印对象调用__repr__函数的返回值）
    # 这个函数的返回值必须是字符串
    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))


class Car:
    def __init__(self,name='汽油车',color='黑色',speed='200'):
        self.name = name
        self.color = color
        self.speed = speed

    def __repr__(self):
        return '{对象所在模块%s类%s内容%s}'%(self.__class__.__module__,self.__class__.__name__,self.__dict__)


def main():
    p1 = Person('小明', 18)
    # 1. 类.__name__ - 获取的名字（字符串）
    print(Person)
    class_name = Person.__name__
    print(Person.__name__, type(Person.__name__), type(Person))
    # 值是一个字符串，可以当成字符串来用
    print(class_name.upper())

    # 2. 对象.__class__ - 获取对象对应的类（结果为类）
    # 获取对象p1的类
    my_class = p1.__class__
    print(my_class)
    # 可以将my_class当成类来使用
    p2 = my_class('小花')
    print(my_class.num)

    # 3. 类.__doc__ - 获取类的说明文档
    print(Person.__doc__)
    print(int.__doc__)

    # 获取对象p1对应的类的说明文档
    print(p1.__class__.__doc__)

    # 4.对象.__dict__ - 将对象转换成字典，将属性和值作为字典的键值对
    # 注意：当给__slots__赋值后，对象的dict属性就不能使用
    print(p1.__dict__)

    # 5. 类.__module__ - 获取当前类所在的模块的模块名
    print(Person.__module__)

    # 6. 类.__bases__ - 获取当前类的父辈(元祖)
    print(Person.__bases__)



if __name__ == '__main__':
    main()

对象方法：
a. 怎么声明：直接声明在类型
b. 特定：字典self参数，调用的时候不用传参，谁调用指向谁
c. 怎么调用：对象.方法（）

2. 类方法：
   a. 怎么声明：声明函数前加@classmethod
   b. 特定：自带默认参数cls；调用的时候不用传参，系统会自动将调用当前函数的类传给它
   (cls是谁调用就指向谁，类方法只能通过类来调用，所有cls就是当前类)
   类能做的事情，cls都能做
   c. 怎么调用：通过类来调用，类.方法()

3.静态方法
a. 怎么声明：声明函数前加@staticmethod
b. 特点：没有默认参数
c. 怎么调用：通过类来调用，类.方法()

4. 在类中怎么选择使用哪种方法：
   如果实现类中的函数的功能需要使用对象的属性，那么这个函数就要声明成对象方法；
   实现函数的功能不需要对象属性的前提下，如果需要类的字段，就声明成类方法
   实现函数的功能既不需要对象属性也不需要类的字段，就声明成静态方法。

class Person:
    @staticmethod
    def func3():
        print('我是静态方法')
    @classmethod
    def func1(cls):
        print('我是类方法2')
    @classmethod
    def func2(cls):
        # 类能做的，cls都能做
        p1 = cls()  # 用cls来创建对象
        print('这是一个类方法')
        cls.num = 100  # 用cls来使用类的字段
        print('cls:',cls)
        cls.func2()   # 用cls来使用类的调用
        Person.func3()
def main():
    Person.func1()


if __name__ == '__main__':
    main()