2019-01-11 class

一.类和对象

1.什么是类，什么是对象
类就是拥有相同属性和相同功能的对象的集合；类是抽象的
对象就是累的实例；对象是具体的
人是类，xxx就是对象
车是类，楼下停在...的那辆车就是对象

2.类的声明
类中的内容包含功能（函数）和属性（变量/属性）
a.语法
class 类名（父类）：
类的内容

class Person:
    """类的说明文档：人类"""
    num = 61  # 类的属性
    # 类中的方法
    def eat(self):
        print('人在吃饭')

b.说明
class - python声明类的关键字
类名 - 要求：标识符，不能是关键字
规范：驼峰式命名(通过首字母大写来区分不同单词)，第一个字母要大写
userName - 驼峰式
UserName - 类名
user_name - pep8
：- 固定写法
类的内容 - 包含类的方法和属性、说明文档
方法：就是声明在类中的函数
属性就是声明在类中的变量
3.对象的声明
语法：
类名（） - 创建指定的类的对象
class 类名：
类中的属性
类中的方法

二.方法

1.类中的方法
声明在类中的函数就是方法
类中的方法包括：对象方法（实例方法），实例，静态方法

2.对象方法：
直接声明在类中的方法就是对象方法
有默认参数self
通过'对象.方法（）'的方式来调用（对象方法就要通过对象来调用）
当我们通过对象调用对象方法的时候，self不需要传参；因为系统会自动将对象传递给self
当前对象：调用当前方法的对象（谁调用对象方法self就是谁）
注意：当前类和对象能做的事情self都能做

class Person:
    def run(self):
        print('人在跑步')

def main():
    # 创建对象
    p1=Person()
    p1.run()
    # 通过对象p1调用对象方法只需要给除了self以外的对象传参
    p2 = Person()
    p2.run()

三.init方法

1.init方法: init
init方法是类中的一个特殊的对象方法,专门用来对象创建的对象进行初始化。
当通过类创建对象的时候，系统就会自动调用init方法

2.构造方法
a.什么是构造方法
函数名和类名一样的函数就是构造方法， 专门用来创建对象。
python中声明类的时候系统会自动创建这个类对应的构造方法。

b.构造方法的执行过程
当我们构造方法的时候内部会先在内存中开辟空间保存对象;然后用创建的这个对象去调用inin方法,用来对对象进行初始化;
init方法调用结束后，返回对象.

def Person(*args, *kwargs):
对象 = 创建对象
对象.init(args, **kwargs)
return 对象

注意: 如果类的init方法除了self以外还有其他参数，那么我们在创建对象的时候需要通过给构造方法来给init方法传参。

class Dog:
    def __init__(self, x=0, y=9):
        print(x, y)
        print('dog的init')

四.对象属性

1.什么是对象属性
类中的属性分为类的字段和对象属性
a.对象属性 - 属性的值会因为对象不同而不一样，这种属性就应该声明为对象属性
声明在init方法中 - 位置
以'self.属性名 = 值'的方式来声明(这儿的属性就是对象属性) - 方式
通过'对象.属性'的方式来使用 - 使用

b.类的字段 - 属性的值不会因为对象不同而不同，这种属性就声明成类的字段
直接声明类的里面，函数的外面的变量就是类的字段
以'字段名 = 值'
通过'类.字段'的方式来使用

class Person:
    # num就是类的字段
    num = 61

    # 在init方法中声明对象属性
    def __init__(self, name='', age=0):
        self.name = name
        self.age = age

练习：创建Dog类，有属性名字、类型、年龄
要求创建Dog的对象的时候：不能给年龄赋值，可以给类型赋值也可以不用给类型赋值，必须给名字赋值
对象方法eat：打印XXX在吃什么

class Dog:
    def __init__(self, name, type='土狗'):
        self.name = name
        self.age = 0
        self.type = type

    def eat(self, food):
        # self = dog1, food = '骨头'
        # self = dog2, food = '屎'
        print('%s在吃%s' % (self.name, food))

五.增删改查

1.属性的增删改查

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

slots魔法：约束当前类的对象最多能拥有那个属性

class Dog:
    # __slots__魔法
    # 约束当前类的对象最多能拥有那个属性
    __slots__ = ('name', 'color', 'age', 'sex')

    def __init__(self, name='', color='黑色'):
        self.name = name
        self.color = color
        self.age = 10

1.查(获取对象属性)
对象.属性 - 获取指定对象指定属性值;当属性不存在的时候会报错
getattr(对象, 属性名:str, 默认值) - 获取指定对象指定属性值;
当属性不存在的时候如果给默认值赋了值，程序不会报错，并且将默认值作为结果

    print('==============查===================')
    print(p1.name)
    # print(p1.name1)   # AttributeError:'Person' object has no attribute 'name1'
    # 属性不确定的时候可以使用getattr
    # attr = input('属性:')
    # print(getattr(p1, attr))
    print(getattr(p1, 'name', None))
    print(getattr(p1, 'name1', None))

2. 增/改
   对象.属性 = 值 - 当属性存在的是修改属性的值；属性不存在的时候添加属性
   setattr(对象, 属性名, 值) - 当属性存在的是修改属性的值；属性不存在的时候添加属性

    print('==============增/改===================')
    # 修改属性
    p1.name = 'xiaohua'
    print(p1.name)
    # 添加属性
    p1.height = 180
    print(p1.height)

3.删

    del 对象.属性
    delattr(对象, 属性名)

    print('==============删=================')
    del p1.sex
    # print(p1.sex)  # AttributeError: 'Person' object has no attribute 'sex'
    delattr(p1, 'age')
    # print(p1.age)  # AttributeError: 'Person' object has no attribute 'age'

注意：对象属性的操作，只针对操作的那一个对象，不会影响其他对象

六.内置属性

内置属性指的是我们创建类的时候系统自动给我们添加的属性(其实是通过继承获取到的)

class Person:
    """说明文档：人类"""
    # 类的字段
    num = 61
    # __slots__ = ('name', 'age', 'sex')

    # 对象属性
    def __init__(self, name='', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex

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

定制对象的打印格式(当我们通过print打印一个对象的时候，实质就是打印对象调用repr函数的返回值)
# 这个函数的返回值必须是字符串

def __repr__(self):
    # return '<%s.%s object at %s>' % (self.__class__.__module__, self.__class__.__name__, hex(id(self)))
  return '<' + str(self.__dict__)[1:-1] + ' at ' + hex(id(self)) + '>'

def main():
    p1 = Person('小明', 18)
    print(p1)    # print(p1.__repr__())

    persons = [Person('p1', 12), Person('p2', 18, '女')]
    print(persons)

    # 1. 类.__name__  - 获取的名字(字符串)
    print(Person)
    class_name = Person.__name__
    print(Person, class_name)
    # 值是一个字符串，可以当成字符串来用
    print(class_name.upper())

    # 2. 对象.__class__  - 获取对象对应的类(结果是类)
    # 获取对象p1的类
    my_class = p1.__class__
    print(my_class)
    # 可以将my_class当成类来使用
    p2 = my_class('小花')
    print(my_class.num)

    # 3. 类.__doc__  - 获取类的说明文档(字符串)
    print(Person.__doc__)
    print(int.__doc__)

    # 获取对象p1对应的类的说明文档
    print(p1.__class__.__doc__)

    # 4.对象.__dict__  - 将对象转换成字典，将属性和值作为字典的键值对(字典)
    # 注意：当给__slots__属性赋值后，对象的__dict__属性就不能使用
    print(p1.__dict__)

    # 5.类.__module__ - 获取当前类所在的模块的模块名
    print(Person.__module__)

    # 6.类.__bases__ - 获取当前类的父类(元祖)
    print(Person.__bases__)

七.类方法和对象方法

1.对象方法：
a.怎么声明: 直接声明在类型
b.特点: 自带self参数,调用的时候不用传参,谁调用指向谁
c.怎么调用: 对象.方法()

2.类方法:
a.怎么声明: 声明函数前加@classmethod
b.特点: 自带默认参数cls; 调用的不用传参，系统会自动将调用当前函数的类传给它
（cls是谁调用就指向谁, 类方法只能通过类来调用，所以cls就是当前类）
类能做的事情，cls都能做

c.怎么调用: 通过类来调用, 类.方法()

3.静态方法
a.怎么声明:声明函数前加@staticmethod
b.特点: 没有默认参数
c.怎么调用:通过类来调用, 类.方法()

4.在类中怎么选择使用哪种方法:
如果实现类中的函数的功能需要使用对象的属性， 那么这个函数就要声明对象方法。
实现函数的功能不需要对象属性的前提下，如果需要类的字段， 就声明称类方法。
实现函数的功能既不需要对象属性也不需要类的字段就声明成静态方法。

class Person:
    num = 61

    def __init__(self):
        self.name = '张三'

    def func4(self):
        print('%s对应的对象' % self.name)
        # print('人类的数量:%d亿' % Person.num)

    @staticmethod
    def func3():
        print(Person.num)
        print('我是静态方法!')

    @classmethod
    def func2(cls):
        print(cls.num)
        print('我是类方法2')

    @classmethod
    def func1(cls):
        # 类能做的,cls都能做
        p1 = cls()    # 用cls来创建对象
        print(p1)

        cls.num = 100  # 用cls来使用类的字段

        cls.func2()   # 用cls调用类方法

        print('cls:', cls)
        print('这是一个类方法')

def main():
    print(Person)
    Person.func1()
    Person.func3()
    p1 = Person()
    p1.func4()