面向对象的编程

编程思想

1.面向过程编程 - 遇到问题直接将逻辑转换成代码;逻辑思维，算法
2.函数式编程 - 遇到问题就想找一个、写一个拥有相应功能的函数
3.面向对象编程 - 遇到问题就考虑可不可以有这样一个类来给我提供相应功能(function)和数据;以类和对象为工具

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

import  datetime
print(datetime.datetime.today())
# today()方法就是封装在datetime里的函数

1.什么是类，什么是对象
类就是拥有相同功能和相同的属性的对象的集合;类是抽象的
对象就是类的实例，对象是具体的

人是类， sxc就是人类的对象
电脑是类， 桌上这台电脑就是对象
属性是都有屏幕键盘可以上网...

2.类的声明
类的内容包含功能(函数)和属性(变量/属性)

a.语法
class 类名:
类的内容

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

3.对象的声明
语法:
类名() - 创建指定类的对象
"""

声明一个人类

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

创建Person类的对象:p1就是对象

def main():
    p1 = Person()
    print(p1)

    # 同一个类可以创建多个对象
    p2 = Person()
    print(p2)

class 类名:
类中的属性
类中的内容

1.类中的函数就是方法:
直接声明在类中的方法就是对象方法
有默认参数self
通过'对象.方法()'的方式来调用（对象方法要通过对象来调用）

b.参数self
当我们通过对象调用对象方法的时候，self是不用传参的;因为系统会自动将当前对象传递给self
当前对象:调用当前方法的对象(self),调用对象会不断地改变

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

def main():
    p1 = Person()
    p1.run()
    p1.eat('apple')

    p2 = Person()
    p2.run()

if __name__ == '__main__':
    main()

1.init方法： init

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

注意:如果类的init方法除了self以外还有其他参数，那么我们在创建对象的时候需要给构造方法传参
class Person:
# 类中开头并且结尾的方法叫做魔法方法。不需要酌定调用，系统会自动调用
def init(self):
print('init被调用了')

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

# 构造方法的伪代码
def my_init(a, b):
    print('a', a, b)
    print('my_init')

def my_Dogs(*args, **kwargs):
    my_init(*args, **kwargs)
    print(args,kwargs)

my_Dogs(a=10, b=20)
my_Dogs(10,34)

def main():
    # 创建对象的时候会自动调用,每次调用对象都会调用
    p1 = Person()

    dog1 = Dog(10,20)
    dog2 = Dog()

if __name__ == '__main__':
    main()

1.对象属性

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

a.对象属性 - 属性值会因为对象不一样而不一样，这种属性就应该声明为对象属性

声明在init方法中
以'self.属性 = 值'的方式来声明 - 方式
通过'对象.属性'的方式来使用 - 使用

b.类的字段

直接声明类的里面，函数的外面的变量就是类字段
以'字段名 = 值'
通过'类.字段'的方式来使用

 __slots__ = ('name', 'color')
用来约束当前class中最多能有多少个属性

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

# 练习创建Dog类，有属性名、类型、年龄
# 要求创建Dog对象：不能给年龄赋值，类型可以赋值可以不赋值，必须给名字赋值

class Dog:
    def __init__(self, name, type = '拉布拉多' ):
        self.age = 18
        self.type = type
        self.name = name

    def eat(self, food):
        print('%s在吃%s' %(self.name, food))
# 声明一个矩形类，拥有属性长和宽，拥有方法求面积和求周长

class Rect:
    def __init__(self.lenth, self.width):
        self.lenth = lenth
        self.width = width

    def area(self):
       return self.lenth*self.width

    def long(self):
       return (self.lenth+self.width)*2

def main():
    p1 = Person('zqm', 18)
    print(p1.age, p1.name)
    # 修改
    p1.name = '李四'
    print(p1.age, p1.name)
    dog1 = Dog('大黄')
    dog1.eat('骨头')

    rect1 = Rect(10,20)
    print(rect1.area())

if __name__ == '__main__':
    main()

结果如下：
18 zqm
18 李四
大黄在吃骨头
面积为: 200
长度是: 60

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

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


def main():
    p1 = Person('小花')
    p2 = Person('小红')

    # 1.查（获取对象属性）；当属性不存在的时候会报错
    # getattr(对象, 属性名:str)  -  获取指定对象指定属性值
    print(p1.name)
    print(getattr(p1, 'name', None))
    # 指定属性不存在的时候返回默认值
    print(getattr(p1, 'name1', None))

    # 增/改
    p1.name = 'xiaohua'
    print('修改后:',p1.name)

    p1.height = 180
    print(p1.height)

    setattr(p1, 'age', 18)
    print(p1.age)

    setattr(p1, 'weight', 200)
    print(p1.weight)

    # del 对象
    del p1.sex

结果如下:
小花
小花
None

内置属性

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

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


def main():

    # 1. 类.__name__
    class_name = Person.__name__
    # 值是一个字符串，可以当字符串来用
    print(Person, class_name)

    # 2.对象.__class__
    p1 = Person('小明')
    my_class = p1.__class__
    print(my_class)
    # 可以将my_class当成类来使用
    p2 = Person('小花')
    print(my_class.num)

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

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

    print(p1.__dict__)

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

    # 6.类.__bases__ - 获取当前父类（元组）
    print(Person.__bases__)
    
if __name__ == '__main__':
    main()

结果如下：
<class '__main__.Person'> Person
<class '__main__.Person'>
61
说明文档
{'name': '小明', 'age': 0, 'sex': '男'}
__main__
(<class 'object'>,)

    def __repr__(self):
        return '<%s.%s object at %s>' % (self.__class__.__module__, self.__class__.__name__)

# 定制打印格式

1.对象方法：直接声明在类型
自带self参数，调用的时候不用传参，谁调用指向谁
对象.方法()
2.类方法:
@classmethod
自带cls参数
通过类来调用 类.方法()
3.静态方法:用过类来调用 类.方法()

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

class Person:
    @staticmethod
    def func3():
        print('我是静态方法！')

    @classmethod
    def func2(cls):
        print('我是类方法2')
    @classmethod
    def func1(cls):
        p1 = cls()
        print('这是一个类方法')
        print(p1)
        cls.num = 100

        cls.func2()
        print(cls.num)
        print('class', cls)
def main():
    Person.func1()
    Person.func3()

if __name__ == '__main__':
    main()

结果如下：
这是一个类方法
<__main__.Person object at 0x00000000028DF828>
我是类方法2
100
class <class '__main__.Person'>
我是静态方法！