1.面向过程编程（穷人） ---算法和逻辑

2.函数式编程（小资） ---函数

3.面向对象编程（富豪） --- 类和对象

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

类就是拥有相同功能和相同属性的对象的集合（重要）---抽象的
对象就是类的实例 - 具体的

如果人是类，我是对象，看简书的你也是对象
如果车是类，具体的某一辆车才是对象

2.类的声明 - 用代码描述清楚这个 类是那些相同功能和相同属性的集合

"""
1)语法：
 class  类名：
          类的说明文档
          类的内容

2）说明：
class   -  声明类的关键字，固定写法
类名    - 程序员自己命名
              要求：标识符，不能是关键字
              规范：见名知意；采用驼峰式命名；首字母大写
类的说明文档   -  用""""""引起来的说明性文字
类的内容  -   用来描述共同的功能和属性
                    主要包含方法(声明在类中的函数）和属性（声明在类中的变量）

student_name -> PEP8 studentName -> 驼峰式命名

class Person:
    """人类"""
    def eat(self):
        print('人类吃饭')

    def sleep(self):
        print('人类睡觉')

    def thinking(self):
        print('思考')

    def opertion(self, char):
        print()

3.创建对象

语法：
类（） -创建类的对象并且放回
同一个类可以有多个对象
p2 = Person()
p3 = p2

print(id(p1), id(p2))

1.类中的方法 - 指的就是类中共同的功能

方法 - 声明在类中的函数
类中的方法分为三种：对象方法、类方法、静态方法

2.对象方法

1）怎么声明：直接在类中的函数就是对象方法
2）特点：有个自带参数self，参数self在通过对象调用的时候不用传参，系统会自动将当前对象给self传参
当前对象 -当前调用这个方法
当前类的对象能做的事情，self都可以做
3）怎么调用：需要对象来调用：以对象.对象方法()的形式调用

class Dog:
    # eat就是对象方法
    def eat(self, food='骨头'):
        print(self)
        print("狗吃" + food)
        self.run()

    def run(self):
        print("狗跑步")


dog1 = Dog()  # dog1就是Dog的对象
dog1.eat()
dog2 =Dog()
dog2.eat("屎")

1.init方法和构造函数

1）构造函数 - 当我们在python中声明类的时候，系统会自动声明一个和类同名的函数（这个函数就是构造函数）
用来创建当前类的对象
当我们调用构造函数创建对象的时候，系统会自动调用init方法来初始化对象
2）init方法 - 它是魔法方法；也是一个对象方法。声明的时候函数名不能变，必须是init,并且保证这个方法是对象方法，声明后不用去调用，系统会自动调用
记住：创建对象的时候系统会自动调用init方法
创建对象的时候，构造函数需不要参数，需要几个参数看init方法中除了self参数之外还有几个参数。

class Person:
    def __init__(self):
        print("init方法")


p1 = Person()


class Student:
    def __init__(self, name, age):
        print("学生类的init",name,age)


# stu1 = Student()        # TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

stu2 = Student("小明", 18)

1.类中的属性 - 就是类中保存的数据的变量

类中的属性分为两种：字段、对象属性

2.字段

1）怎么声明：直接在类里面函数外面的变量就是字段
2）怎么使用：通过类来使用；以‘类.字段’的形式去使用
3）什么时候使用：不会因为对象而不一样的属性就声明成字段

3.对象属性

1）怎么声明：声明在init方法中；以‘self.属性名’ = 值的形式来声明
2）怎么使用：通过对象来使用以'对象.属性'的形式来使用
3）什么时候使用：会应对象而不一样的属性就声明成对象属性

class Person:
    # 这个a就是字段
    a = 10

    # name和age就是对象属性
    def __init__(self):
        self.name = "小明"
        self.age = 18


#
# print(Person.a)
# p1 = Person()
# print(p1.name, p1.age)


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


stu1 = Student("小明", score=10)
print(stu1.name, stu1.age, stu1.score)


# 声明一个狗类，拥有属性：品种、名字、年龄性别；功能：吃（xx吃xxx）
class Dog:
    def __init__(self, kind, name, age, sex):
        self.kind = kind
        self.name = name
        self.age = age
        self.sex = sex

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


dog1 = Dog('泰迪', "周泰迪", 21, 'girl')
dog1.eat("火腿")
print(dog1.kind, dog1.age, dog1.name, dog1.sex)

1.类中的方法

类中的方法有3种：对象方法、类方法、静态方法
1）对象方法
a.怎么声明：直接声明在类中的函数
b.怎么调用：通过对象来调用
c.特点：自带一个参数self；self在调用的时候不用传参，指向当前对象
self->当前对象
d.什么时候使用：如果实现函数的功能需要用到对象属性，这个函数就声明成对象方法
2）类方法
a.怎么声明：在函数前面加@classmethod
b.怎么调用：通过类来调用：‘类.方法’
c.特点：自带一个参数cls；cls在调用的时候不用传参，系统会自动将当前类传给cls
cls ->当前类（当前类可以做的，cls都可以做）
d.什么时候调用：实现函数的功能不需要对象属性的前提下，需要类
3）静态方法
a.怎么声明：在函数声明前加@staticmethod
b.怎么调用：通过类来调用；'类.方法'
c.特点：没有自带的参数
d.什么时候用：实现函数的功能 不需要对象属性的前提下，也不需要类

class Student:
    def __init__(self, name, tel, age=8):
        self.name = name
        self.age = age
        self.tel = tel

    # study是对象方法
    def study(self):
        print('%s在学习' % self.name)

    @classmethod
    def func1(cls):
        print('类方法func1')

    @staticmethod
    def func2():
        print("静态方法func2")


stu = Student('小敏敏', 120)
stu.study()

Student.func1()


# 坑1：
# 注意：理论上类中所有方法都可以通过 对对象或者类调用
# 类调用对象方法：用类调用对象方法self失去意义
# 对象调用类方法： 用对象调用类方法是多此一举，cls还是当前类，直接调用更简单


class Math:
    pi = 3.1415926

    @classmethod
    def circle_area(cls, r):
        return cls.pi * r * r

    @staticmethod
    def sum(num1, num2):
        return num1 + num2

---

对象属性的增删改查

"""
1)对象.属性     -  获取对象指定属性的值
2）getattr(对象，属性名:str)  -  获取对象指定属性的值
    getattr(对象，属性名:str,默认值)  -  获取对象指定属性的值
"""
print(p1.name)
# print(p1.name1)         # AttributeError: 'Person' object has no attribute 'name1'
print(getattr(p1, 'name', "无名氏"))

print(getattr(p1, 'name1', "无名氏"))  # 无名氏

attr = 'name'
print(getattr(p1,attr))


# 2.修改属性和增加属性
"""
1)对象.属性 = 值    当属性存在的时候就是修改，属性不存在的时候是增加
2）setattr(对象，属性名，值）  当属性存在的时候就是修改；属性不存在的时候就是增加
"""
# 改
p1.age = 28
print(p1.age)
setattr(p1,'age',55)

# 增
p1.height = 170
print(p1.height)
setattr(p1,'weight',50)
print(p1.weight)


# 3.删除对象属性
"""
1)del 对象.属性         -   删除对象中指定的属性

2) delattr(对象，属性名)  - 删除对象中指定的属性
"""

del p1.name
# print(p1.name)          # AttributeError: 'Person' object has no attribute 'name'

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


# 注意：属性的增删改查只针对指定对象有效，不会影响别的对象
print(p2.name)

---

内置属性

1.内置类属性 - 声明类的时候系统提供的属性

class Dog:
    """狗类 """
    num = 100
    # __slots__ 是用来约束当前类最多能够拥有的对象属性，写了slots之后不能使用__dict__
    # __slots__ = ('name', 'age', 'gender','height','weight')

    def __init__(self, name, age=3, gender='公狗'):
        self.name = name
        self.age = age
        self.gender = gender

    def func1(self):
        print('对象方法', self.name)

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

    @staticmethod
    def func3():
        print("静态方法")

---

dog1 = Dog("大黄")
# 1.  类.__name__      -     获取类的名字
print(Dog.__name__)
print(Dog)

# 2.对象.__class__     -     获取对象对应的类（和type（对象）功能一样）
print(type(dog1))
print(dog1.__class__)

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

# 4.__dict__
# 类.__dict__        -  获取类中所有的字段和字段对应的值，以字典的形式放回
# print(Dog.__dict__)

# （掌握!)  对象.__dict__     -  获取对象所有的属性和对应的值，以字典的形式返回
# 注意：如果设置了__slots__,对象的__dict__就不能用
print(dog1.__dict__)

#  5.类.__module__             -获取当前这个类是那个模块中声明的，返回的是模块名
print(Dog.__module__)
print(int.__module__)

# 6.类.__bases__         -  获取当前类的父类
# object是python的基类
print(Dog.__bases__)            # (<class 'object'>,)
print(Dog.__base__)             # <class 'object'>