1.编程思想

• 1）.面向过程编程：算法和逻辑
• 3）.函数式编程：函数
• 2）.面向对象编程：类和对象

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

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

2.类的声明

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

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

3.创建对象

• 1)语法
  对象 = 类()
• 创建Person类的对象
  p1 = Person()
• 同一个类可以有多个对象
  p2 = Person()

1.类中的函数

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

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

class Person:
    """类的说明文档：人类"""
    def eat(self):
        print('吃饭')
p1 = Person()
p1.eat()  # p1.eat() == p1.eat(p1)
# 强调：不要用类去调用对象方法
# Person.eat(1)

1.什么是init方法

'''
init 是类中的一个魔法方法，在创建对象的时候会被自动调用
'''
class Person:
def init(self):
print('init方法被调用')
Person()
p1 = Person() # Person() 1.开辟空间创建对象 2.使用创建好的对象调用init方法（做一些初始化操作）3.返回对象

class Person1:
    def __init__(self, x, y):
        print('init方法被调用', x, y)

• 如果init方法中除了self以外还有其他的参数，需要通过构造方法来给init方法传参
• 这儿的Person1()就是在调用构造方法
  p1 = Person1(10, 20)

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

'''
1)字段
怎么声明：在类的里面函数的外面的变量，就是类的字段
怎么使用：通过 '类.字段' 的方式去使用
什么时候使用：属性值不会因为对象的不同而不一样，这样的属性就声明成类的字段
2)对象属性
怎么声明：以 'self.属性名 = 值' 的方式声明在init方法中
怎么使用：通过 '对象.属性名' 的方式去使用
什么时候用：属性值会因为对象的不同而不一样，这样的属性就声明成对象属性

class Person:
    # num就是类的字段
    num = 61
    def __init__(self):
        # 这儿的name、age、gender就是Person类的对象属性
        self.name = ''
        self.age = 0
        self.gender = '男'
* 使用类的字段
print(Person.num)
Person.num = 200
print(Person.num)
p1 = Person()
p1.name = '小明'
p1.name = '小东'
p2 = Person()
p2.name = '小发'
print(p1.name, p2.name)
class Dog:
    def __init__(self, name, age, color, breed):
        self.name = name
        self.age = age
        self.color = color
        self.breed = breed
    # 重写repr方法，来定制对象的打印格式（默认对象地址）
    # 返回值必须是字符串
    def __repr__(self):
        return str(self.__dict__)
dog1 = Dog('猪皮', 3, '黄色', '田园狗')
print(dog1.name)
print(dog1)
print(dog1.__dict__)
# 声明一个矩形类，有属性：长和宽，功能：计算矩形的面积和周长
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    def perimeter(self):
        return (self.length + self.width) * 2
    def area(self):
        return self.length * self.width
r1 = Rectangle(10, 20)
r2 = Rectangle(30, 20)
print(r1.perimeter())
print(r2.perimeter())
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('小东', 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('大狗', 14)
p2 = Person('小狗', 22)

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

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

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

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

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

p1.name = 'dagou'
p1.dd = 'xioagou'
print(p1.dd)

4.删 - 删除对象属性

'''
1）del 对象.属性 - 删除对象属性
2）delattr(对象, 属性名)
'''
del p1.dd
delattr(p1, 'age')

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

class Dog:
    # slots魔法：可以通过给类的__slots__字段赋值，来约束当前类的对象最多有哪些属性
    __slots__ = ('name', 'age')
    def __init__(self, name, age):
        self.name = name
        self.age = age
dog1 = Dog('猪皮', 19)

1.什么是内置类属性

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

class Person:
    """说明文档：人类"""
    num = 42
    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]
        # return '|%s.%s object at %s|' % \
        #        (self.__class__.__module__, self.__class__.__name__, hex(id(self)))
    # def __str__(self):
    #     return '<%s>' % str(self.__dict__)[1:-1]
p1 = Person('猪皮', 20)
# 1.__name__
'''
类的字段，获取类的名字
'''
print(Person.__name__)
# 2.__doc__
'''
类的字段，获取类的说明文档
'''
print(Person.__doc__)
# 3.__class__
'''
对象属性，获取对象对应的类
'''
c1 = p1.__class__
print(c1)
# 4.__dict__

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

print(Person.__dict__)
print(p1.__dict__)
print(p1)
persons = [p1, Person('SS', 20), Person('22', 23)]
print(persons)

5.module

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

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