语法 - class xx: - 类

作用：定义类别，减少代码量

大概理解类的作用

Python类是面向对象编程的核心，它允许创建自定义数据类型。通过类，可以封装数据和功能，实现代码复用和模块化。类支持继承，使得代码结构更清晰，功能扩展更灵活。它还支持多态，允许以统一接口处理不同类型的对象。简而言之，类是构建复杂程序的基石。

就是分文件的，分类，分方法，可以实现更多逻辑，更少代码，更容易迁移

一、最简单的类

class Dog():
    """创建一个Dog类"""
    def __init__(self, name, age, color="yellow"):  # 构造函数
        """初始化属性name和age"""
        self.name = name
        self.age = age
        self.color = color     # 给属性指定默认值
        self.dbname = ''  # 数据表类可以写库名字，建议写到配置文件里
        self.tablename = ''  # 数据表类可以写表名字，建议写到配置文件里
    def sit(self):  # 定义蹲下方法
        """蹲下"""
        print (self.name + " is now sitting.")
    def roll_over(self):  # 定义打滚方法
        """打滚"""
        print (self.name + " rolled over!")
    def two_action(self):  # 组合：先打滚后蹲下
        self.roll_over()
        self.sit()

使用类

实例化，name, age一定要给、按顺序给，color不一定，但是默认黄色，写一些固定信息

my_dog = Dog('willie', 6)
"""访问属性"""
print(my_dog.name )  # willie
print(str(my_dog.age))  # 6
my_dog.sit()                 # 调用方法：
## willie is now sitting.
my_dog.two_action()                 # 调用方法：
## willie rolled over!
## willie is now sitting.
my_dog.age = 12           # 修改age属性值
print(my_dog.age)         # 12
print(my_dog.color)       # yellow
my_dog_2 = Dog('willie', 6, 'black')
print(my_dog_2)  # 使用不一样的内存空间
print(my_dog_2.color)  # black
my_dog_3 = Dog('willie', 7, color='red')
print(my_dog_3)  # 使用不一样的内存空间
print(my_dog_3.color)  # red

模块化类

from car import Car    # 从car.py文件中导入Car类
from car import Car, ElectricCar    # 从car.py文件中导入Car类和ElectricCar类,用逗号
from car import *    # 导入car.py文件中的所有类

issubclass() 判断参数 class 是否是类型参数 classinfo 的子类

class A:
    pass
class B(A):
    pass
print (issubclass(B,A))    # 返回 True

callable() 对象是否是可调用

callable(0)
False
callable("runoob")
False

def add(a, b):
    return a + b
callable(add)             # 函数返回 True
True

class A:                  # 类
    def method(self):
            return 0
callable(A)               # 类返回 True
True
a = A()
callable(a)               # 没有实现 __call__, 返回 False
False

class B:
    def __call__(self):
            return 0
callable(B)
True
b = B()
callable(b)               # 实现 __call__, 返回 True
True

hasattr()判断对象是否包含对应的属性

class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print (hasattr(point1, 'x'))
print (hasattr(point1, 'y'))
print (hasattr(point1, 'z'))
print (hasattr(point1, 'no'))  # 没有该属性
输出结果：
True
True
True
False

delattr()删除属性

class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print ('x = ',point1.x)
print ('y = ',point1.y)
print ('z = ',point1.z)
delattr(Coordinate, 'z')
print ('--删除 z 属性后--')
print ('x = ',point1.x)
print ('y = ',point1.y)
## 触发错误
print ('z = ',point1.z)

setattr()设置/更新属性值

class A(object):
    bar = 1
a = A()
getattr(a, 'bar')          # 获取属性 bar 值
1
setattr(a, 'bar', 5)       # 设置属性 bar 值
a.bar
5

vars()返回对象object的属性和属性值的字典对象

class EE():
    '''文档描述'''
    bar = 1
    def aa(self):
        print ("aafun")
print(vars(EE))
mappingproxy({
'__module__': '__main__',
'__doc__': '文档描述',
'bar': 1,
'aa': <function EE.aa at 0x7fd738017a70>,
'__dict__': <attribute '__dict__' of 'EE' objects>,
'__weakref__': <attribute '__weakref__' of 'EE' objects>
})