object_oriented&class

编程思想

面向过程编程：一遇到问题就考虑通过代码一步一步的去解决问题
函数时编程：一遇到问题就考虑是否能够有这样功能的一个函数
面向对象编程：一遇到问题就考虑是否有这样一个类，拥有相应的功能和属性

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

1.1.什么是类：类是拥有相同功能和相同属性的对象的集合（抽象的）

1.2.什么是对象：对象就是类的实例（具体）

2.类的声明

python所有的数据类型都是类，每种眉形对应的数据都是对象；
int类是所有整数的集合（每个单独的整数都是int的对象）

声明类就是自定义类型。

2.1.语法：

class 类名：
类的内容

2.2.说明

class - 声明类的关键字
类名 - 自己命名，表示符不能是关键字；
见名知义；首字母大写，并且采用驼峰式命名
: - 固定写法
类的内容 - 主要包含：类的说明文档、属性、方法（功能）
补充：什么是方法 - 声明在类中的函数（方法就是函数）

class Person:
    """类的说明文档：人类"""
    def eat(self):
        print('吃东西')
    def run(self):
        print('跑步')

3.创建对象

对象是通过类来创建的

3.1.语法

类() - 创建指定类对应的对象

p1 = Person()
print(p1)

p2 = Person()
print(p2)
"""
<__main__.Person object at 0x101e5b860>
<__main__.Person object at 0x101e5b908>
"""

class

1.类中的方法

类中的方法其实就是声明在类中的函数；类中的方法分为三种：对象方法、类方法、静态方法

2.对象方法

直接声明在类中的函数就是对象方法，有个默认参数self，需要使用'对象.'的方法去调用

p1.eat()
"""
吃东西
"""

注意：对象方法从语法上来说可以使用'类.'的方式去使用，但这样self无意义，不会这样使用

2.1.self

对象方法中的默认参数self，在通过对象调用的时候，这个参数不用传参，系统会自动将当前对象传递给它。
哪个对象调用的当前方法，self就是谁。
self本质就是当前类的对象，所以对象能做的事情self都可以做

class Person:
    """类的说明文档：人类"""

    def eat(self):
        print('吃东西')
        self.run()

    def run(self):
        print('跑步～')
        print(self)


p1 = Person()
p1.eat()
p1.run()
p2 = Person()
p2.run()
"""
吃东西
跑步～
<__main__.Person object at 0x107650940>
跑步～
<__main__.Person object at 0x107650940>
跑步～
<__main__.Person object at 0x1076509e8>
"""

init方法

1.init方法

python所有的类中都有一个特殊的对象方法：__init__
当通过类去创建对象的时候，系统会自动调用__init__方法，来对对象进行初始化操作。
补充：python中以'__'开头并且以'__'结尾的方法叫魔法方法。所有的魔法都不需要程序员手动调用。系统会在需要的情况下自动调用

2.构造方法

def Dog(*args, **kwargs):
    """伪代码"""
    对象 = 创建对象（在内存中开辟空间创建对象）
    对象.\_\_init\_\_(*args, **kwargs)
    return 对象

函数名和类名一样的方法就是构造方法。

python中，当我们声明类的时候，系统会自动给我们创建这个类的构造方法。
方法中会先在内存中开辟空间创建对象，然后用创建好的对象去调用__init__方法对对象进行初始化。
初始化完成后才将对象返回。

创建对象的时候需不需要参数，需要几个参数，看init方法

"""模仿init方法"""
def __init__(name):
    print('模仿init方法', name)


def Dog1(*args, **kwargs):
    __init__(*args, **kwargs)


Dog1(name='张三')

Property（属性）

类：拥有相同属性和相同功能的对象的集合

1.属性(property)

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

1.1.类的字段

a.声明：直接声明在类中的变量就是类的字段
b.怎么使用：通过'类.'的方法去使用
c.什么时候用：属性的值不会因为对象的不同而不同，就使用类的字段

1.2.对象属性

a.声明：对象属性需要声明在init方法中，以'self.属性=值'的方式来声明
b.怎么使用：通过'对象.'的方式去使用
c.什么时候用：属性的值会因为对象不同而不同，就使用对象属性

class Person:
    """类的说明文档：人类"""
    def __init__(self, name, age=0):
            # 这的name和age就是Person类的对象属性
        self.name = name
        self.age = age

human1 = Person('张三', 25)
print(human1.name, human1.age, sep='')
"""
张三25
"""

练习：

class Dog:
    def __init__(self, name, color, age=0):
        """
        """
        self.name = name
        self.age = age
        self.color = color
        self.king = ''

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


your_dog = Dog('旺财', '白色', 3)
your_dog.eat('骨头')

his_dog = Dog('狗狗', '黑色', 5)
his_dog.king = '智障'
his_dog.eat('鸡肉')
print(his_dog.king)
"""
旺财正在吃骨头
狗狗正在吃鸡肉
智障
"""

propertyOperation

1.对象属性的增删改查

1.1.查 - 获取对象属性的值

a.对象.属性 - 属性不存在会报错
b.getattr(对象，属性名，默认值) - 获取对象属性的值，属性不存在不会报错，并且返回默认值

class Student:
    def __init__(self, name, age=18):
        self.name = name
        self.age = age
        self.stu_id = (x for x in range(1, 11))


student1 = Student('张三', 20)
student2 = Student('李四')
print(student1.name)
print(getattr(student1, 'name'))
temp_attr = 'age2'
print(getattr(student1, temp_attr, '未找到'))
"""
张三
张三
未找到
"""

1.2.增/改 - 添加/修改属性

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

student1.name = '王二麻子'
student1.gender = '男'
print(student1.name)
print(student1.gender)

temp_attr = 'name'
setattr(student1, temp_attr, '狗神sb')
print(student1.name)
setattr(student2, 'gender', '女')
print(student2.gender)
"""
王二麻子
男
狗神sb
女
"""

1.3.删 - 删除对象属性

a.del 对象.属性
b.delattr（对象，属性名）

del student1.gender
# print(student1.gender)
delattr(student2, 'gender')
# print(student2.gender)

注意：对象属性的增删改查只针对单个对象

2.__slots__魔法

class Human:

        # 在类中可以通过给__slots__赋值来约束当前类的对象有哪些属性
    __slots__ = ('name', 'age', 'gender')

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


human1 = Human('jaz', 23)
setattr(human1, 'gender', 'man')
print(human1.gender)
setattr(human1, 'hobby', 'basketball')  
# AttributeError: 'Human' object has no attribute 'hobby'

内置类属性

1.内置类属性：声明类的时候系统自动给类添加的属性

1.1.__name__

字段，获取类的类名

class Car:
    """说明文档：车类"""
    num = 100

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.speed = 100

    def stop(self):
        self.speed = 0


print(Car.__name__, type(Car.__name__))
"""
Car <class 'str'>
"""

1.2.__doc__

字段，获取类的说明文档

print(Car.__doc__)
"""
说明文档：车类
"""

1.3.__class__

对象属性，获取对象的类

car1 = Car('audi', 'a4', '2019')
print(car1.__class__)
print(car1.make.__class__)
print([1, 2].__class__)
C1 = car1.__class__
car2 = C1('Benz', 'glc260', '2019')
print(car2.make)
"""
<class '__main__.Car'>
<class 'str'>
<class 'list'>
Benz
"""

1.4.__dict__(重点)

字段，获取当前类所有有的字段和字段对应的值，以字典的形式返回
对象属性，获取当前对象中所有的对象属性和对应的值

print(Car.__dict__)
print(car1.__dict__)
car2.stop()
print(car2.__dict__)
"""
{'__module__': '__main__', '__doc__': '说明文档：车类', 'num': 100, '__init__': <function Car.__init__ at 0x11016e510>, 'stop': <function Car.stop at 0x11016e620>, '__dict__': <attribute '__dict__' of 'Car' objects>, '__weakref__': <attribute '__weakref__' of 'Car' objects>}
{'make': 'audi', 'model': 'a4', 'year': '2019', 'speed': 100}
{'make': 'Benz', 'model': 'glc260', 'year': '2019', 'speed': 0}
"""

1.5.__module__

字段，获取当前类所在（声明所在模块）的模块的名字

print(Car.__module__)
"""
__main__
"""

1.6.__bases__

字段，获取当前类的父类

print(Car.__bases__)
"""
(<class 'object'>,)
"""