一、编程思想

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

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

二、认识类和对象（声明）

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

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

仓鼠是类，小白就是仓鼠的对象。

2.类的声明

类里面的内容包含：功能（函数）、属性（变量/代码）

a.语法：

class 类名(父类):
类的内容

b.说明：

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

3.对象的声明

语法：
类名（） -----创建指定类的对象
例如：

class Persen:
    """类的说明文档：人类"""
    people_num = 180000000  # 类中的属性

    def eat(self):
        '''类中的方法'''
        print('人都会吃饭。')


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

    # 同一个类可以声明多个变量
    p2 = Persen()
    print(p1)

    p3 = p2
    print(p1)


if __name__ == '__main__':
    main()

运行结果：

<__main__.Persen object at 0x000001C19002B780>
<__main__.Persen object at 0x000001C19002B780>
<__main__.Persen object at 0x000001C19002B780>

三、对象方法

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

1.类中的方法

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

2.对象方法

a.什么是对象方法：

（1）直接声明在类里面的方法就是对象方法
（2）有默认参数 self 。
（3）调用时，通过 '对象.方法' 的方式来调用（对象方法要通过对象来调用）

b.参数 self ：

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

例如：

class Person:
    # 声明类时，类里面的内容会执行
    print('=================')

    def run(self):
        print('self:', self)
        print('人会跑，马会跳，老猪会睡觉')

    def eat(self, food):
        self.run()
        print('self2:', self)
        print(food)


def main():
    # 创建对象
    p1 = Person()
    # 通过对象调用对象方法
    print('p1:', p1)
    p1.run()
    # 调用对象方法只需要给出了 self 以外的其它参数就需要传参
    p1.eat('I love CD.')

    p2 = Person()
    print('p2:', p2)


if __name__ == '__main__':
    main()

运行结果：

=================
p1: <__main__.Person object at 0x000001593827B940>
self: <__main__.Person object at 0x000001593827B940>
人会跑，马会跳，老猪会睡觉
self: <__main__.Person object at 0x000001593827B940>
人会跑，马会跳，老猪会睡觉
self2: <__main__.Person object at 0x000001593827B940>
I love CD.
p2: <__main__.Person object at 0x000001593827B908>

四、init 方法和 构造（construction）方法

1.init 方法：init

a.init 方法是类中的一个特殊的方法，专门用来对象创建的对象进行初始化。

b.当通过类创建对象的时候，系统会自动调用 init 方法。

2.构造方法

a.函数名和类名一样的函数就是构造方法，专门用来创建对象。

b.python 中声明类的时候，系统会自动创建这个类创建的构造方法。

c.当我们用构造方法创建对象的时候，内部都会先在内存中开辟空间保存对象，

然后用创建的这个对象去调用 __init__ 方法，用来对对象进行初始化。
__init__ 方法调用结束后，返回对象。
注意：如果类的 __init__ 方法除了 self 以外还有其他参数，
那么在创建对象的时候，需要通过给构造方法来给 __init__ 方法传参。

例如：

# 创建一个类
class Dog:
    def __init__(self, x, y):
        print(x, y)
        print('dog 的 init')


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


def main():
    # 创建对象的时候就会调用 __init__ 方法
    p1 = Person()
    # 创建一次，调用一次 __init__ 方法
    p2 = Person()

    # 构造一个 dog1 方法（构造方法）
    dog1 = Dog(50, 100)
    # print('dog1:', dog1)


if __name__ == '__main__':
    main()

运行结果：

init 被调用咯
init 被调用咯
50 100
dog 的 init

五、对象属性

1.什么是对象属性

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

a.对象属性 -----属性的值会因为对象的不同而不一样，这种属于就应该声明为对象属性。

（1）声明在 init 方法中。
（2）以 'self.属性 = 值' 的方式来声明（这里的属性就是对象属性）。 -----方式
（3）通过 '对象.属性' 的方式来使用。 -----使用

b.类的字段 -----属性的值不会因为对象的不同而不同，这种属性就可以声明成类的字段。

（1）直接声明在类中，函数外面的变量就是类的字段。
（2）以 '变量名 = 值' 的方式来声明。
（3）通过 '类.字段' 的方式来使用。
例如：

class JuXing:
    num1 = 50
    def __init__(self, chang, kuan):
        self.chang = chang
        self.kuan = kuan

    def mian_ji(self):
        mian_ji = self.chang * self.kuan
        print('面积为：', mian_ji, ' m^2')

    def zhou_chang(self):
        zhou_chang = (self.chang + self.kuan) * 2
        print('周长为：', zhou_chang, ' m')


class Dog:
    def __init__(self, name1, type1='萨摩耶'):
        self.age = 3
        self.name = name1
        self.type = type1

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


class Person:
    def __init__(self, name1='', age1=3):
        # name 和 age 就是对象属性。
        self.name = name1
        self.age = age1


def main():
    print(JuXing.num1)

    p1 = Person('泷泽萝拉', 23)
    # 获取对象属性的值。
    print(p1.name, p1.age)

    p2 = Person('阿西吧', 28)
    # 修改对象属性的值。
    p2.name = '苍井空'
    print(p2.name, p2.age)

    dog1 = Dog('阿黄')
    dog1.eat('筎')
    dog2 = Dog('大白', '土狗')
    print(dog2.name, dog2.type)

    p3 = JuXing(2, 3)
    p3.mian_ji()
    p3.zhou_chang()


if __name__ == '__main__':
    main()

运行结果：

50
泷泽萝拉 23
苍井空 28
阿黄 在吃 筎
大白 土狗
面积为： 6  m^2
周长为： 10  m

六、对象属性的增删改查

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

1.查（获取对象属性）

对象.属性 -----获取指定对象指定属性值；当属性不存在的时候，会报错。
getattr(对象, 属性名：str, 默认值) -----获取指定对象指定属性值；当属性不存在的时候，没赋默认值，会报错；
如果给默认值属性赋了值，程序不会报错，并且将默认值作为结果。

2.增/改

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

3.删除

del 对象.属性
delattr(对象.属性名)

4. slots 魔法

约束类里面的属性的多少，可以删除，添加的不在后面的范围内就加不了。
建议不用

例如：

class Dog:
    # 约束当前类的对象最多能拥有哪些个属性
    # __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
    dog1.name = '客家话'
    dog1.name1 = 'hhh'

    p1 = Person()
    p2 = Person()
    # 1.查
    # 对象.属性                 -----获取指定对象指定属性值；当属性不存在的时候，会报错。
    # getattr(对象, 属性名：str, 默认值)       -----获取指定对象指定属性值；当属性不存在的时候，没赋默认值，会报错；
    #                                               如果给默认值属性赋了值，程序不会报错，并且将默认值作为结果。
    print(p1.name)
    attr = input('属性：')
    print(getattr(p1, attr))
    # 属性不确定时，可以使用 getattr
    print(getattr(p1, 'name', None))
    print(getattr(p1, 'name1', None))

    # 2.增/改
    p1.name = 'xiaohua'
    print(p1.name)
    p1.height = 180
    print(p1.height)

    setattr(p1, 'age', 18)
    print(p1.age)
    setattr(p1, 'weight', 72)
    print(p1.weight)

    # 3.删除
    del p1.sex
    delattr(p1, 'age')
    # 删除后用不了

    # 注意：对象属性的操作，只针对操作的那一个对象，不会影响其他对象。
    print(p2.age)


if __name__ == '__main__':
    main()

运行结果：

哈哈哈
属性：name
哈哈哈
哈哈哈
None
xiaohua
180
18
72
0

七、内置属性

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

1. name

类.name -----获取类的名字，返回值是一个字符串。

2.class

对象.class -----获取对象对应的类（结果是类）。

3.doc

类.doc -----获取类的说明文档(结果是字符串)

4.dict

对象.dict -----将对象转换成字典。将属性和值转换成字典键值对。
注意：当给 slots 属性赋值后，对象的 dict 属性就不能用

5.module

类.module -----获取当前类所在的模块的模块名。

6.bases

类.bases -----获取当前类的父类。
例如：

class Person:
    num1 = 50

    # __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(self.name, '在吃', food)

    # 定制对象的打印格式（当我们通过 print 打印一个对象的时候，实质就是打印对象调用 __repr__ 函数）
    # 这个函数的返回值必须是字符串
    def __repr__(self):
        return '{ %s.%s at %s}' % (self.__class__.__module__, self.__class__.__name__, hex(id(self)))


def main():
    # 获取类的名字，返回值是一个字符串
    p1 = Person('xiaoming', 18)
    print(Person)
    class_name = Person.__name__
    print(Person, class_name)
    print(class_name.upper())

    my_class = p1.__class__
    # 获取对象对应的类（结果是类）。
    print(my_class)
    p2 = my_class
    print(my_class.num1)

    print(Person.__doc__)
    print(float.__doc__)

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

    # 将对象转换成字典。将属性和值转换成字典键值对。
    print(p1.__dict__)
    print(Person.__dict__)

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

    # 获取当前类的父类。
    print(Person.__bases__)             # (<class 'object'>,)


if __name__ == '__main__':
    main()

运行结果：

<class '__main__.Person'>
<class '__main__.Person'> Person
PERSON
<class '__main__.Person'>
50
None
float(x) -> floating point number

Convert a string or number to a floating point number, if possible.
None
{'name': 'xiaoming', 'age': 18, 'sex': '男'}
{'__module__': '__main__', 'num1': 50, '__init__': <function Person.__init__ at 0x000002235D01D7B8>, 'eat': <function Person.eat at 0x000002235D01D840>, '__repr__': <function Person.__repr__ at 0x000002235D01D8C8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
__main__
(<class 'object'>,)

八、类方法和静态方法

1.对象方法

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

2.类方法：

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

3.静态方法

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

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

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

例如：

class Person:
    num1 = 50

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

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

        cls.num1 = 1000         # 用 cls 来使用类的字段

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

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

    @classmethod
    def func2(cls):
        print('这是方法二。')


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


if __name__ == '__main__':
    main()

运行结果：

<class '__main__.Person'>
<__main__.Person object at 0x00000256CAC6B8D0>
这是方法二。
cls: <class '__main__.Person'>
这是一个类方法
静态方法