编程思想

1.面向过程编程 --- 遇到问题直接将逻辑转换成代码；逻辑思维和算法为工具。
2.函数式编程 --- 遇到问题就想找一个、写一个拥有相应功能的函数；以函数为工具。
3.面向对象编程 --- 遇到问题就考虑可不可以有一个类，来提供相应的功能和数据；以类和对象为工具。
补充：python既支持函数式编程也支持面向对象编程。

认识类和对象（声明）

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

类 就是拥有相同功能和相同属性的对象的集合；类是抽象的。
对象 就是类的实例；对象是具体的，有具体的属性，具体的功能。
例如：
人是类，鲁迅就是人类的对象
车是类，楼下十字路口旁的车就是对象
电脑是类，我桌上这台黑色的电脑就是对象

2.类的声明

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

3.对象的声明

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

注意：创建类的对象时，是调用类的构造方法，这个方法调用了多少次，就有多少个对象。

对象方法

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

1.类中的方法

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

2.对象方法：

a.什么是对象方法
1.直接声明在类中的方法就是对象方法，只能通过类的对象来调用
2.有默认参数self
3.通过对象.方法()的方式来调用（对象方法要通过对象来调用）
b.参数self
1.当我们通过对象调用对象方法的时候，self是不需要传参的；因为系统会自动将当前对象传递给self
2.当前对象：调用当前方法的对象（谁调用方法，self就是谁）
注意：当前类的对象能做的事情，self都可以做

补充：1.声明类的时候会执行里面的内容 2.调用对象方法，要给除了self以外的形参传参。

init方法和构造方法

1.init方法：__ init __

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

2.构造方法

a.函数名和类名一样的函数就是构造方法，专门用来创建对象。
b.python中声明类的时候，系统会自动创建这个类对应的构造方法。当我们调用构造方法创建对象的时候，内部会先在内存中开辟空间保存对象，然后用创建的对象去调用__ init__方法，用来对对象进行初始化；经过初始化后，对象就具有了需要的属性。__ init__方法调用结束后，返回对象。

创建对象的过程如下：

def Person():
    对象 = 创建对象
    对象.__init__()
    return 对象

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

构造方法的伪代码

# 构造方法的伪代码
def my_init(a,b):
    print('a',a, b)
    print('my_init')

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

dog1 = my_Dog(*args, **kwargs)

调用创建对象时调用my_Dog函数并传参数，my_Dog函数会调用my_init函数，将之前获得的参数传给my_init函数。

补充：1.在类当中，__开头并且 __结尾的方法叫魔法方法。不需要主动调用，系统会自动调用。2.init方法只有在创建对象时才会被调用。3.构造方法的参数由init方法的参数决定，且一一对应。

对象属性

类中的属性分为类的字段和对象属性

1.对象属性

a.对象属性：属性的值会因为对象不同而不一样，这种属性就应该声明为对象属性。例如：人的名字不同
声明的位置：声明在init方法中
声明的方式：以'self.属性名 = 值'的方式来声明（这儿的属性名就是对象属性，值就是属性的字面量）
使用方法：对象属性要通过'对象.属性'的方式来使用。

2.类的字段儿

b.类的字段儿：属性的值不悔因为对象的不同而不同，这种属性就声明成类的字段儿。例如：人类都会思考。
声明的位置：直接声明在类的里面，函数的外面的变量就是类的字段儿。
声明的方式：'字段名 = 值'
使用方法：通过'类.字段儿'的方式来使用

补充：在init方法中声明对象属性，就是给对象进行初始化。self.name为对象中的name属性，name1为name属性的字面量。name1和age1都是由构造方法类（）传过来的。

    # 在init方法中声明对象属性
    def __init__(self, name1='', age1=0): # 给对象属性赋默认值，这就是对象的初始化
        self.name = name1 # name是属性名，name1是参数
        self.age = age1

对象属性的增删改查

python中对象的属性，也就是对象属性支持增删改查。

补充：在init方法上方添加__ slots__魔法，可以约束当前类的对象最多能拥有哪个属性。且写在init方法中的参数，只能比slots中的少，不能多。

1.查（获取对象属性）

对象.属性 --- 获取指定对象指定属性值；当属性不存在的时候会报错。和字典[key]一样。
getattr(对象，属性名：str，默认值) --- 获取指定对象指定属性值；当属性不存在的时候如果给默认值赋了值，程序不会报错，且返回默认值。如果不写默认值，程序也会报错。

2.增/改

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

3.删除

del 对象.属性
delattr(对象，属性名:str)
补充：del 可以删除任意类型数据

注意：getattr,setattr,delattr三个方法中，属性名都得是字符串类型。

内置属性

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

补充：打印一个对象print(p1)实际上打印的是这个对象所在的模块，类，和地址；实质就是打印对象调用__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))

old_input:<__main__.Person object at 0x0000000001E7FCF8>
new_input:'name': '小明', 'age': 18, 'sex': '男'at 0x1e6fdd8

1. 类.__name __ --- 获取类的名字（结果是字符串）

print(Person)
class_name = Person.__name__
print(Person, class_name)

input:
<class 'main.Person'>
<class 'main.Person'> Person
注意：打印出来的class_name是字符串类型，可以当成字符串来使用。

2.对象.__ class__ --- 获取对象对应的类（结果是类）

 my_class = p1.__class__
    print(my_class)

3. 类.__ doc__ --- 获取类的说明文档（结果是字符串）

print(Person.__doc__)
    print(int.__doc__)

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

4.对象.__dict __ --- 将对象转换成字典，将属性和值作为字典的键值对。（结果是字典）

注意：当给了__ solts __ 属性赋值后，对象的 __ dict __属性就不能使用

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

5.类.__module __ --- 获取当前类所在的模块的模块名（结果是字符串）

print(Person.__module__)

6.类.__ base__ --- 获取当前类的父类/支持多继承，所以返回结果是元组。

print(Person.__bases__)

类方法和静态方法

1.对象方法

a.怎么声明：在类中直接声明
b.特点：自带默认参数self，调用的时候self不用传参，谁调用指向谁。
c.怎么调用：对象.方法() --- 通过对象来调用

2.类方法

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

3.静态方法

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

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

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