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

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

2.类的声明

1)语法
class 类名：
类的内容

2）说明
class - 关键字
类名 - 自己命名；是标识符，但不能是关键字
采用的是驼峰式命名，而且首字母大写，例如：StudentName
见名知义
类的内容 - 包含类的说明文档、类中的函数（相同的功能）、类中的属性（相同的属性）

class Person:
    """类的说明文档：人类"""
    def eat(self):
        print('吃饭')

3.创建对象

1）语法
对象 = 类（）

p1 = Person()

同一个类有多个对象

p2 = Person()

1.类中的函数

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

1）对象方法
直接声明在类中的函数，自带一个self参数
对象方法需要通过‘对象.函数名（）'的方式来调用
通过对象调用对象方法的时候，self不需要传参；系统会自动将当前对象传给self（谁调用指向谁）

class Person():
    def eat(self):
        # self = p1
        print('吃饭')
        self.run()


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

def study(self, subiect: str):
    print('学习' + subiect)


p1 = Person()
p1.eat()        # p1.eat() == p1.eat(p1)
p1.study('python')

 #强调：不要用类去调用方法
 Person.eat(100)

1.什么是init方法

init是类中的一个魔法方法，在创建对象的时候会被自动调用

class Person:
    def __init__(self):
        print('init被调用')

p1 = Person()   # Person(): 1.开辟空间创建对象 2.使用创建好的对象调用init方法（做一些初始化操作）3.返回对象
p2 = Person()

class Person1:
    def __init__(self, x=2, y=3):
        print(x, y)

如果init方法中除了self以外还有其他的参数，需要通过构造方法来个init方法传参
这儿Person1（）就是在调用构造方法

p1 = Person1(10, 20)
p2 = Person1()
p3 = Person1(100)

1.类中的属性：对象属性、字段

1）字段：
a.怎么声明：声明在类的里面、函数的外面的变量，就是类的字段
b.怎么使用：通过 类.字段 的方式去使用
c.什么时候用：属性值不会因为对象不同而不一样，这样的属性就声明成类的字段

2）对象属性
a.怎么声明：以'self.属性名 = 值'的方式声明init方法中
b.怎么使用：通过'对象.属性名'的方式去使用
c.什么时候使用：属性值会因为对象不同而不一样，这样的属性就声明成对象属性

class Person:
     #num就是类的字段
    num = 61
    def __init__(self):
        # 这儿的name,age和gender就是Person类的对象属性
        self.name = ''
        self.age = 0
        self.gender = '男'


print(Person.num)
Person.num = 100
print(Person.num)

p1 = Person()
p1.name = 'xiaoxiao'

p2 = Person()
p2.name = 'xiao'
print(p1.name, p2.name)

class Dog:
    def __init__(self, name1, age1, color1, breed1):
        self.name = name1
        self.age = age1
        self.color = color1
        self.breed = breed1

dog1 = Dog('大黄', 3, '黄色', '土狗')
dog2 = Dog('大', 4, '红色', '哈士奇')

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


# 重写repr方法，来定制对象的打印格式（默认对象地址）
 #返回值必须是字符串
def __repr__(self):
    return str(self.__dict__)  # '<%s>' % str(self.__dict__)[1:-1]

stu1 = Student('小冯')
print(stu1.tel)
stu1.tel = 111
print(stu1.tel)
print('学生对象', stu1)

练习：声明一个矩形类，有属性：长和宽，方法：计算矩形的面积和轴承

class Rect:
    def __init__(self, length, width):
        self.length = length
        self.width = width


def sum1(self):
    print('周长', self.length * 2 + self.width * 2)

def area(self, n):
    print('面积', self.length * self.width)
    print(n)

su = Rect(2, 4)
su.sum1()
su.area('这是直接传入函数')

例子

class Person:
    def __init__(self, name, age=0):
        self.name = name
        self.age = age

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

p1 = Person('小明', 18)
p1.eat('面条')

1.对象属性

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

注意：属性的增删改查只针对当前对象，不会作用于其他对象

class Person:


def __init__(self, name, age=0, gender='男'):
    self.name = name
    self.age = age
    self.gender = gender


p1 = Person('小明', 19)
p2 = Person('小花', 18, '女')

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

1)对象.属性 - 获取对象指定属性的值，如果属性不存在，报错
2)getattr(对象，属性名） - 获取对象指定属性的值，如果属性不存在，报错
getattr(对象，属性名，默认值） - 获取对象指定属性的值，如果属性不存在，不会报错而是返回默认值

print(p1.name)
print(getattr(p1, 'name'))

3.增、改 - 给对象添加属性或者修改对象属性的值

1)对象.属性 = 值 - 当属性不存在，就给对象添加属性，如果存在就修改属性的值
2)setattr(对象，属性名，值） -

p1.name = 'xiaoming'
print(p1.name)
p1.id_card = '111'
print(p1.id_card)
setattr(p1, 'age', 30)
print(p1.age)

4.删 - 删除对象属性

1)del 对象.属性
2)delattr(对象，属性名)

del p1.gender

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

delattr(p1, 'name')

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

 可以通过给__slots__字段赋值，来约束当前类的对象最多有哪些属性

class Dog:
    __slots__ = ('name', 'age', 'gender')

​```
def __init__(self, name, age):
    self.name = name
    self.age = age
​```

dog = Dog('大黄', 18)
dog.gender = '男'

# dog.color = '白'     # AttributeError: 'Dog' object has no attribute 'color'

print(dog.gender)

1.什么是内置类属性

创建类的时候，系统自动为这个类提供的属性

class Person:
    """说明文档：人类"""
    num = 61

​```
def __init__(self, name, age=0, gender=''):
    self.name = name
    self.age = age
    self.gender = gender

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

def __repr__(self):
    return '|%s.%s object at %s|' % \
           (self.__class__.__module__, self.__class__.__name__, hex(id(self)))
​```

p1 = Person('Tom', 18, '男')

1.name

类的字段，获取类的名字

print(Person.__name__)  # Person  （是字符串）

2.doc

类的字段，获取类的说明文档

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

3.class

对象属性，获取对象对应的类

c1 = p1.__class__
print(c1)
p2 = c1('小花')
print(p1, p2)
print(c1.num)

4.dict

1)类的字段，获取类中的字段（用得少）
2)对象属性，获取对象的所有属性和其对应的值，以字典的形式返回
注意：如果给类的slots属性赋了值，那么这个类的对象就不能使用dict去获取所有的属性

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

5.module

类的字段，获取类所在的模块（类是在哪个py文件中声明的）返回模块名

print(Person.__module__)
print(int.__module__)

6.bases

类的字段，获取当前类的父类

print(Person.__bases__)  # (<class 'object'>,)
print(Person)