1.面向过程编程 - 遇到问题直接将逻辑转换成代码；逻辑思维，算法

2.函数式编程  - 遇到问题就想找一个、写一个拥有相应功能的函数；以函数作为工具

3.面向对象编程 - 遇到问题就考虑可不可以有一个类来给我提供相应的功能和数据；以类和对象为工具

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

---

---

---

01-认识类和对象

1.什么是类，什么是对象

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

人是类，何志成就是人类的对象
车是类，具体的车就是对象
电脑是类，具体的电脑就是对象

2.类的声明

类中的内容包含功能（函数）和属性（变量/属性）

a.语法
class 类名：
   类的内容

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

3.对象的声明

语法：
类名（） - 创建指定的类的对象并且返回

看一个类有多少对象，就看它创建几个对象

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

    # 类中的方法
    def eat(self):
        print('人在看电视')


def main():
    # 创建person类的对象；p1就是对象
    p1 = Person()
    print(p1)

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

---

---

---

02-对象方法

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

1.类中的方法

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

2.对象方法：

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

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

class Person:
    # self = p1
    def run(self):
        print('self:', self)
        print('人在跑步')
        # print('人吃%s' % food)

    def eat(self, food):
        self.run()
        print('self:', self)
        # print('人在跑步')
        print('人吃%s' % food)


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

---

---

---

03-init方法和构造方法

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 Car:
    def color(self):
        print('红色')


# ==============构造方法和init的关系（了解）======================
# 构造方法的伪代码
def my_init(a, b):
    print(a, b)
    print('my_init')


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


my_Dog(20, b=30)


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


def main():
    # 人类
    p1 = Person()

    # 狗类
    p2 = Dog(10, 20)

    p3 = Car()

---

---

---

04-对象属性

1.什么是对象属性

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

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

class Person:
    num = 60

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


# 练习：创建Dog类，有属性名字、类型、年龄
# 要求创建Dog的对象的时候，不能给年龄赋值，可以给类型赋值也可以不给类型赋值，必须给名字赋值
# 对象方法eat：打印xxx在吃什么
class Dog:
    def __init__(self, name, type='土狗'):
        self.name = name
        self.age = 2
        self.type = type

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


# 练习：声明矩形类，拥有属性长和宽
class Rectangle:
    def __init__(self, long, width):
        self.long = long
        self.width = width

    def area(self):
        area1 = self.long * self.width
        print('面积是%s' % area1)

    def perimeter(self):
        perimeter = self.long * 2 + self.width * 2
        print('周长是%s' % perimeter)


def main():
    Person.num = 100

    p1 = Person('憨猜猜', 21)
    # 获取对象属性的值
    print(p1.name, p1.age)

    p2 = Person('剩菜', 20)
    # 修改对象属性的值
    p2.name = '憨猜猜'
    print(p2.name, p2.age)

    dog1 = Dog('小黑')
    dog1.eat('骨头')
    dog2 = Dog('旺财')
    print(dog1.name, dog2.age, dog2.type)
    dog2.eat('便便')

    e1 = Rectangle(10, 20)
    e1.area()
    e1.perimeter()

---

---

---

05-对象属性的增删改查

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

class Dog:
    # __slots__魔法方法
    # 约束当前类的对象最多能拥有那个属性
    __slots__ = ('name','color')
    def __init__(self, name='', color='黑色'):
        self.name = name
        self.color = color


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


def main():
    dog1 = Dog('大黄','黄色')
    # dog1.age = 2  # AttributeError: 'Dog' object has no attribute 'age'
    print('======================person===================================')
    p1 = Person('憨猜猜')
    p2 = Person('剩菜')
    # 1.查（获取对象属性）
    """
    对象.属性 - 获取指定对象指定属性值;当属性不存在的时候会报错
    getattr(对象，属性名：str，默认值) - 获取指定对象指定属性值；
    当属性不存在的时候如果给默认值赋了值，程序不会报错，并且将默认值作为结果
    """
    print(p1.name)
    # 属性不确定的时候可以使用getattr
    print(getattr(p1, 'name', None))
    print(getattr(p1, 'name1', None))

    # 增/改
    """
    对象.属性 = 值 - 当属性存在的时候是修改属性的值；属性不存在的时候添加属性
    setattr（对象，属性名，值） - 当属性存在的时候是修改属性的值；属性不存在的时候添加属性
    """
    print('===============增改==================')
    # 修改属性
    p1.name = '傻逼'
    print(p1.name)
    # 增加属性
    p1.height = 200
    print(p1.height)
    # 修改属性
    setattr(p1, 'age', 25)
    print(p1.age)
    # 添加属性
    setattr(p1, 'weight', 150)
    print(p1.weight)

    # 删
    """
    del 对象.属性
    delattr(对象，属性名)
    """
    print('=============删==================')
    del p1.sex

    delattr(p1, 'age')
    # 注意：对象属性的操作，只针对操作的那个对象，不会影响其他对象

---

---

---

06-内置属性

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

class Person:
    """说明文档：人类"""
    # 类的字段
    num = 61

    # __slots__ = ('name', 'age', 'sex')

    # 对象属性
    def __init__(self, name='', age=0, 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))+'>'

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

    # 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__  - 将对象转换成字典将属性和值作为字典的键值对
    print(p1.__dict__)
    # 注意：当给__slots__属性赋值后，对象的__dict__属性就不能使用
    # print(Person.__dict__)

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

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

---

---

---

07-静态方法和类方法

1.对象方法

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

2.类方法：

a.怎么声明：声明函数前加@classmethod
b.特定：自带默认参数cls;调用的不用传参，系统会自动将调用当前函数的类传给它
  （cls是谁调用就指向谁，类方法只能通过类来调用，所以cls就是当前类）
c.怎么调用：通过类来调用，类.方法（）

3.静态方法

a.怎么声明：声明函数前加@staticmethod
b.特点：没有参数
c.怎么调用：通过类来调用，类.方法（）

4.在类中怎么选择使用哪种方法：

如果类中的函数的功能需要使用对象属性就要使用对象方法，
如果类中的函数功能不需要使用对象属性的前提下，如果需要类的字段，就声明成类方法
实现函数的功能既不需要对象属性也不需要类的字段就声明称静态方法

class Person:
    num = 61

    @staticmethod
    def func3():
        print('我是静态方法')

    @classmethod
    def func2(cls):
        print('我是类方法2')

    @classmethod
    def func1(cls):
        # 类能做的，cls都能做
        p1 = cls()  # 用cls来创建对象
        print(p1)

        cls.num = 100  # 用cls来使用类的字段

        cls.func2()  # 用cls调用类方法

        print('cls:', cls)
        print('这是一个类方法')


def main():
    Person.func1()
    Person.func3()