1.编程思想

(1)面向过程编程：算法和逻辑
（3）函数式编程：函数
(2)面向对象编程：类和对象（面向生活编程）

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

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

3.类的声明

（1）语法：
class 类名:
类的内容

（2）说明
class - 关键字
类名 - 程序员自己命名；要求：是标识符但不能是关键字；
采用驼峰式命名，并且首字母大写
见名知意
类的内容 - 包含类的说明文档、类中的函数(相同的功能)、类中的属性(相同的属性)

4.类中的函数

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

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

5.什么是init方法

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

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

(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  # 修改字段

p1 = Person()
p1.name = '小明'
p2 = Person()
p2.name = '小p'
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
    # 重写repr方法，来定制对象的打印格式（默认对象地址）
# 返回值必须是字符串

    def __repr__(self):
        return '<%s>' % str(self.__dict__)[1:-1]


dog1 = Dog('dahuang', 3, 'yellow', '土狗')
dog2 = Dog('傻狗', 5, 'yellow', '土狗')
print(dog1.name, dog2.name)
print('dog', dog1)
# 重写repr方法，来定制对象的打印格式（默认对象地址）
# 返回值必须是字符串


def __repr__(self):
    return str(self.__dict__)


# 练习：声明一个矩形类，有属性:长和宽，方法:计算矩形的面积和周长
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
        # print('面积：', width*height)
        # print('周长：', 2*(width+height))

    def get_area(self):
        return self.width*self.height

    def get_perimeter(self):
        return 2*(self.width+self.height)


rect1 = Rectangle(20, 10)
rect2 = Rectangle(5, 17)
print(rect1.get_area(), rect2.get_area())  # 200 85
print(rect1.get_perimeter(), rect2.get_perimeter())  # 60 44

# 例子
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)
p2 = Person('二狗', 20)
p1.eat('面条')

7.对象属性与增删改查

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

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


p1 = Person('小明', 18)
p2 = Person('小花', 20, '女')
# 2.查 - 获取对象属性的值
'''
(1)对象.属性  -  获取对象指定属性的值，如果属性不存在，报错
(2)getattr(对象，属性名) - 获取对象指定属性的值，如果属性不存在，报错
   getattr(对象，属性名，默认值) - 获取对象指定属性的值，如果属性不存在，不报错，而是返回默认值
'''
# (1)
print(p1.name)
# (2)
print(getattr(p1, 'name'))
print(getattr(p1, 'idcard', 'shit'))

# 3.增和改 - 给对象添加属性/修改对象属性
'''
(1)对象.属性 = 值  - 当属性不存在就给对象添加属性，如果属性存在就修改属性的值
(2)setattr(对象，属性名，值) - 当属性不存在就给对象添加属性，如果属性存在就修改属性的值
'''
p1.name = 'xiaoming'
print(p1.name)
p1.idcard = '111111'
print(p1.idcard)
setattr(p1, 'age', 99)
print(p1.age)
setattr(p1, 'height', 1999)
print(p1.height)

# 4.删除 - 删除对象属性
'''
(1)del 对象.属性
(2)delattr(对象，属性名)
'''
# del p1.gender
# print(p1.gender)
# delattr(p1, 'name')
# print(p1.name)

# 属性的增删改查只针对当前对象有效，不会作用于其他对象


class Dog:
    # slots魔法：可以通过给类的__slots__字段赋值，来约束当前类的对象最多有哪些属性
    __slots__ = ('name', 'age', 'gender', 'color', 'type')

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


dog1 = Dog('小明', 19)
print(dog1.name, dog1.age)
dog1.color = 'white'
print(dog1.color)
# dog1.name1 = 'hu'

8.什么是内置类属性

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

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>' % str(self.__dict__)[1:-1]


p1 = Person('Tom', 18, '男')
# 1.__name__
'''
类的字段，获取类的名字
'''
print(Person.__name__)  # 'Person'
print(Person)  # <class '__main__.Person'>

# 2.__doc__
'''
类的字段，获取类的说明文档
'''
print(Person.__doc__)  # 人类

# 3.__class__
'''
对象属性，获取对象对应的类
'''
c1 = p1.__class__
print(c1)  # <class '__main__.Person'>

# 4.__dict__
'''
(1)类的字段，获取类中的字段（用得少）
(2)对象属性，获取对象的所有属性和属性对应的值，然后以字典的形式返回（用的很多）
注意：如果给类的__slots__属性赋了值，那么这个类的对象就不能使用__dict__去获取所有的属性
'''
print(Person.__dict__)
print(p1.__dict__)  # {'name': 'Tom', 'age': 18, 'gender': '男'}

# 5.__module__
'''
类的字段，获取类所在的模块（获取类是在哪个py文件中声明的），返回模块名
'''
print(Person.__module__)  # __main__(当前模块)
print(int.__module__)  # builtins

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