day13-类和对象

1 编程思想：

1.1 面向过程编程 - 工具：逻辑、算法

遇到问题考虑直接用代码；把逻辑思维转换成代码，解决问题。

1.2 函数式编程 - 工具：函数

遇到问题，就考虑是否有一个这种功能的函数。

1.3 面向对象编程 - 工具：类和对象

遇到问题，就考虑是否有一个对象能够帮我解决问题。

2 类的声明

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

2.1 类的声明

语法：
class 类名（父类列表）：
类的内容
说明：
class - 声明类的关键字
类名 - 标识符，不能是关键字；
类名采用驼峰式命名，并且首字母大写
见名知义
（父类列表）- 继承语法；可以省略，省略的时候相当于（object）
类的内容 - 主要包含属性和方法。
驼峰式命名：名字由多个单词组成的时候，通过单词首字母大写来区分不同的单词。studnetName;userName;userId。
方法：声明在类中的函数就是方法。

2.2 属性和方法

类中的属性 - 指的是在类中声明的变量；分为类的字段和对象属性。
类中的方法 - 指的是在类中声明的函数；分为对象方法，类方法和静态方法。

   class Person:  # 声明了一个Person类
    """人类"""
    # 属性
    num=61  # 字段
    # 方法
    def eat(self):
        print('吃饭')

2.3 创建对象

类名（）-->创建类对应的对象。

3 对象方法

3.1 什么是对象方法

直接声明在类中，并且自带一个叫self的参数的函数。

3.2 对象方法的调用

对象方法的调用 - 通过对象调用对象方法
对象.对象方法（）
通过对象调用对象方法的时候，对象方法中的第一个参数self不用传参，系统会自动将当前对象传给self，哪个对象调用的，self就指向谁。
注意：当前类的对象能做的事情，self都能做。

# 声明Person类
class Person:
    """人类"""
    # 声明了一个对象方法sleep
    def sleep(self,a):
        # self=p1，a=10
        print('睡觉',a)
# 创建Perosn的对象p1
p1=Person()

4 init方法和构造方法

4.1 魔法方法

python类中，用__开头并且由__结尾的方法，就是魔法方法。魔法方法不需要主动调用，都会自动调用。

4.2__init__方法

1.是对象方法；
2.不需要自己调用，会被自动调用；
3.专门用来对对象进行初始化的。

4.3 构造方法

概念：函数名和类名一样的函数，就是构造方法。
1.当我们创建类的时候，系统会自动创建这个类的构造方法，用来创建对象。
2.当我们通过构造方法创建对象的时候，系统会自动调用init方法来对创建好的对象进行初始化。
注意：当init方法中，除了self以外如果需要别的参数，那么这些参数是通过构造方法来传的参
只要调用了构造方法就会产生新的对象，即使传入的参数一样（想要对象，调用构造方法）。

5 对象属性

5.1.什么是对象属性

1.声明在init方法中
2.self.属性名=值
3.通过对象使用：对象.属性
语法：
self.变量名=值
说明：变量名就是属性名，这个变量就是对象属性

5.2什么样的属性应该声明为对象属性

如果属性的值会因为对象不同而不一样，那这样的属性就应该声明成对象属性。反之就声明为类的字段。

5.2.1对象属性创建使用默认值

class Person:
    def __init__(self):
        # 这儿的name和age就是Person类的对象属性
        self.name='李四'
        self.age=0
p1=Person() # 创建对象
p1.name='张三'  # 对对象的name属性进行修改

5.2.2创建对象的时候就决定对象属性的值

class Person:
    # name1是参数名，self.name中的name是属性名
    def __init__(self,name1,age=1):
        self.name=name1
        self.age=age
p11=Person('小红')
p12=Person('小花')

练习：声明一个point类，拥有属性x坐标和y坐标。功能：求两个点之间的距离

class Point:
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def distance(self,other):
        return ((self.x-other.x)**2+(self.y-other.y)**2)**0.5

pp1=Point(2,3)
pp2=Point(5,7)  # pp1调用distance函数，故self就是pp1对象，other是pp2对象
print(pp1.distance(pp2))# 5.0

6 对象属性的增删改查

注意：对象属性的增删改查，都是针对指定的那一个对象，不会影响其他对象。

class Dog:
    def __init__(self,name,color,type):
        self.name=name
        self.color=color
        self.type=type

dog1=Dog('旺财','黄色','二哈')

6.1 查（获取对象属性的值）

1.对象.属性 - 当属性不存在的时候会报错
2.getattr(对象，属性名，默认值) - 当属性不存在的时候，如果设置了默认值，程序不崩溃，而是返回默认值。

print(dog1.name) # 旺财
# print(dog1.sex) # AttributeError
print(getattr(dog1,'color')) # 黄色
print(getattr(dog1,'sex','才才')) # 才才

6.2增、改

1对象.属性 = 值
2.setattr（对象，属性名，值）
注意：属性存在的时候，对应的功能是修改属性的值。当属性不存在的时候是添加属性。

dog1.name='大黄'          # 修改
print(dog1.name) # 大黄
dog1.sex='雄'             # 添加
print(dog1.sex) # 雄

setattr(dog1,'name','热狗') # 修改
print(dog1.name) # 热狗
setattr(dog1,'name2','肉狗') # # 添加
print(dog1.name2)  # 肉狗

6.3 删除

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

del dog1.name # 删除
print(dog1.name) # AttributeError

delattr(dog1,'color') # 删除
print(dog1.color) # AttributeError

6.4 设置魔法 slots魔法

slots是用来约束当前这个类有哪些属性。

class Student:
    # Student类的对象只能有name，study_id，age和sex属性
    __slots__ = ('name','study_id','age','sex')
    def __init__(self,name,age):
        self.name=name
        self.study_id='001'
        self.age=age

7 类的字段和内置类属性

7.1 类的字段

1.直接声明在类里面，函数的外面的变量就是类的字段
2.类的字段需要通过类来使用 ： 类.字段 - （不管是在类的里面还是类的外面都一样通过类来使用）
（在类中声明一个函数就是相当于声明一个字段）
3.不会因为对象不同而不一样的数据就声明成类的字段。

class Person:
    # 声明了一个字段number
    number=61

print(Person.number) # 61

7.2 内置类属性

内置属性就是声明类的时候，类中已经声明好的属性（包含类的字段和对象的属性）。

class Dog:
    """说明文档：狗类"""
    # 类的字段
    type='犬科'
    # 对象属性
    def __init__(self,name='狗',age=5,color='白'):
        self.name=name
        self.age=age
        self.color=color

    # 对象方法
    def eat(self,food):
        print('%s在吃%s'%(self.name,food))

    # 类方法
    @classmethod
    def shout(cls):
        print('wangwnag...')

    # 静态方法
    @staticmethod
    def bite():
        print('狗咬人')

dog1=Dog('小黑',3,'黑色')

7.2.1 __name__

类.__name__ - 获取类的名字（字符串）

class_name=Person.__name__
print( class_name,type( class_name)) # Person ,

7.2.2__class__

对象.__class__ - 获取对象对应的类（结果是一个类，原来类能做的事情它都能可以做）

aa=dog1.__class__
d1=Dog()
d2=aa()
print(d1,d2)
print(Dog.type) # 犬科
print(aa.type) # 犬科
print(dog1.__class__.__name__)  # Dog

7.2.3 __dict__

类.__dict__ - 获取当前类的所有的类的字段及其对应的值.
（重点）对象.__dict__ - 将当前对象所有的对象属性及其值转换成字典，key是属性名，value是属性的值
如果给类的slots赋了值，那么这个类的对象的dict属性就不能用了

# 用类调用，获取所有类的字段
print(Dog.__dict__) # {'__module__': '__main__', 'type': '犬科', '__init__':.....}

# 用对象调用，将对象的属性及其值转换成字典，重点
print(dog1.__dict__) # {'name': '小黑', 'age': 3, 'color': '黑色'} # 数据本地化及传输时经常用到

7.2.4 __base__

类.__base__ - 获取当前类的父类（以元祖的形式返回，元祖中的元素就是类的父类）

print(Dog.__bases__) # (,)

7.2.5 __module__

类.__module__ - 获取当前类所在的模块的模块名

print(Dog.__module__) # __main__ 当就在目前正在执行的模块时，返回main，否则返回文件名

7.3 __doc__

类.__doc__ -获取类的说明文档

print(Dog.__doc__) # 说明文档：狗类