Day15

一、 编程思想

1、 面向过程编程

遇到问题直接将逻辑转换成代码；逻辑思维，算法

2、 函数式编程

遇到问题就想找一个或写一个拥有相应功能的函数；以函数作用工具

3、 面向对象编程

遇到问题就考虑可以不可以有一个类来给我提供相应的功能和数据；以类和对象为工具

python既支持函数式编程也支持面向对象编程

二、认识类和对象

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

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

2、 类的声明

类中的内容包含功能（函数）和属性（变量/属性）

a. 语法

class 类名（父类）:
类的内容

b. 说明

class - python声明类的关键字
类名 - 要求：标识符，不能是关键字
规范：驼峰式命名（通过首字母大写来区分不同的单词）
: - 固定写法
类的内容 - 包含类的方法、属性和说明文档
方法就是声明在类中的函数
属性就是声明在类中的变量

3、 对象的声明

语法：
类名() - 创建指定的类的对象并且返回

class Person:
    """类的说明文档：人类"""
    num = 61 # 类中的属性

    # 类中的方法
    def eat(self):
        print('吃饭')

def main():
    # 创建Person类的对象；p1就是对象
    p1 = Person()
    print(p1)
    p2 =Person()
    print(p2)
    p3 = p2
    print(p3)

if __name__ == '__main__':
    main()

三、 对象方法

class 类名:
类中的属性
类中的方法

1、 类中的方法

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

a. 对象方法

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

class Person:
    def run(self):
        print('人在跑步')
    def eat(self,food):
        print(food)
p1 = Person()
print(p1.run())
p1.eat('包子')

2、 init方法：init

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

3、 构造方法

函数名和类名一样的函数就是构造方法，专门用来创建对象
python中声明类的时候系统会自动创建这个类对应的构造方法
当我们构造方法的时候，内部现在内存中开辟空间保存对象，然后用创建的这个对象去调用init方法，用来对对象初始化
init方法调用结束，返回对象。
def Person():
对象 = 创建对象
对象.init():
return 对象

class Person:
    # 类中以“__”开头结尾的方法叫魔法方法。不需要主动调用，系统会自动调用
    def __init__(self):
        print('init被调用了')

p1 = Person()

四、对象属性

1、 什么是对象属性

类中的属性分为累的字段和对象属性

a. 对象属性

属性的值会因为对象不同而不一样，这种属性就应该声明为对象属性
声明在init方法中 - 位置
以'self.属性 = 值'的方式来声明（这儿的属性就是对象属性） - 方式
通过'对象.属性'的方式来使用 - 使用
b. 类的字段 - 属性的值不会因为对象不同而不同，这种属性就声明成类的字段
直接声明在类的里面，函数外面的变量就是类的字段
以'字段名=值'
通过'类.字段'的方式来使用

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


p1 = Person('张三', 18)
# 获取对象属性的值
print(p1.name, p1.age)

 练习：创建Dog类，有属性名字、类型、年龄
要求创建Dog的对象的时候不能给年龄赋值，可以给类型赋值也可以不用给类型赋值，必须给名字赋值
# 对象方法eat：打印xxx在吃什么
class Dog():
    def __init__(self, name, type1='金毛'):
        self.name = name
        self.type = type1
        self.age = 10

    def eat(self):
        print(self.name + '吃')


print(Dog('wg').eat())

练习：声明矩形类，拥有属性长和款，拥有方法求面积和求周长
class retangle:
    def __init__(self, chang=0, kuan=0):
        self.chang = chang
        self.kuan = kuan

    def s(self):
        s = self.chang * self.kuan
        return '长%.3f，宽%.3f的面积是%.3f' % (self.chang, self.kuan, s)

    def c(self):
        c = (self.chang + self.kuan) * 2
        return '长%.3f，宽%.3f的周长是%.3f' % (self.chang, self.kuan, c)


r = retangle(10,20)
print(r.s()+'\n'+r.c())
# 使用类的字段
r.kuan = 100
r.chang = 200

五、 对象属性的增删查改

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

1、 查（获取对象属性）

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

class Dog:
    # 约束当前类的对象最多能拥有的哪些属性
    #__slots__ = ('name', 'color')
    def __init__(self,name='',color='黑色'):
        self.name = name
        self.color = color

def main():
    dog1 = Dog('WG', '黄色‘')

    p1 = Person('小花')
    p2 = Person('wg')

查（获取对象属性）

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

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

增/改
对象.属性 = 值 - 当属性存在的时候是修改属性的值，不存在就增加属性和值

    # 修改属性
    p1.name ='xoiaohua'
    print(p1.name)
    # 添加属性
    p1.height = 180
    print(p1.height)
    setattr(p1,'age',19)
    print(p1.age)
    setattr(p1,'weight',200)
    print(p1.weight)

删

    del 对象.属性
    delattr(对象,属性名)
    """
    print('=================')
    del p1.sex
    delattr(p1,'age')

    # 注意：对象属性的操作，只针对操作的那一个对象
    print(p1.height)




if __name__ == '__main__':
    main()

五、 内置方法

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

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('')

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

    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():
    # 1. __name__
    """
    获取类名:
    """
    p1 = Person()
    persons = []
    print(Person.__name__)
    # 2 类.__class__ - 获取对象对应的类（结果是类）
    print(Person.__class__)
    # 3.类.__doc__ - 获取说明文档
    print(Person.__doc__)
    # 4. 对象.__dict__  -  将对象转换成字典，将属性和值作为字典的键值对
    print(p1.__dict__)
    # 5. 类.__module__             -      获取当前类所在的模块的模块名
    print(Person.__module__)
    # 6. 类.__bases__              -      获取当前类的父类（元组）
    print(Person.__bases__)
    print(p1)


if __name__ == '__main__':
    main()

六、 类方法和内置方法

1、对象方法：

a. 声明：直接声明在类里

b. 特点：自带self参数，调用的时候不用传参，谁调用指向谁

c. 调用：对象.方法（）

2、类方法：

a. 声明：声明函数前加@classmethod

b. 特点：自带默认参数cls；调用的而不用传参，系统自动调用当前函数的类传给它

     （cls是谁调用就指向谁）

c. 调用： 通过类来调用，类.方法()

3、 静态方法

a. 声明：声明函数前加@staticmethod

b. 特点：没有默认参数

c. 调用：通过类来调用，类.方法()

4、 在类中怎么选择的使用哪种方法

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

class Person:
    num = 60

    @classmethod
    def func1(cls):
        # 类能做的，cls都能做
        p1 = cls()  # 用cls来创建对象
        print(p1)
        print('这是一个类方法')
        cls.num = 100  # 用cls来使用类的字段
        cls.func2()  # 用cls来调用方法
        print(cls.num)

    @staticmethod
    def func2():
        print('我是静态方法')


def main():
    Person.func1()


if __name__ == '__main__':
    main()