编程思想

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

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

类和对象

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

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

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

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

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

3. 对象的声明
   语法:
   类名() - 创建指定的类的对象并且返回

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

    def eat(self):
        print('人在吃饭')


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

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


if __name__ == '__main__':
    main()

类的方法

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

1. 类中的方法

• 声明在类中的函数就是方法
• 类中的方法包括: 对象方法(实例方法)，类方法，静态方法

2. 对象方法:

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

• b.参数self
  当我们通过对象调用对象方法的时候，self不需要传参；因为系统会自动将当前对象传递给self
  当前对象: 调用当前方法的对象(谁调用对象方法self就是谁)
  注意: 当前类的对象能做的事情self都能做

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

    def eat(self, food):
        print('吃'+food)


def main():
    # 创建对象
    p1 = Person()
    # 通过对象p1调用方法
    print('p1:', p1)
    p1.run()
    # 调用对象方法只需要给除了self以外的其他参数传参
    p1.eat('包子')


if __name__ == '__main__':
    main()

构造方法

1. init方法:init

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

2. 什么是构造方法

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

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

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

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

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


class Dog:
    def __init__(self, x=4, y=3):
        print(x, y)
        print('dog的init方法')


def main():
    p1 = Person()
    d = Dog(1, 2)
    d.__init__()


if __name__ == '__main__':
    main()

对象属性

1. 什么是对象属性

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

• a.对象属性 - 属性的值会因为对象不同而不一样，这种属性就应该声明为对象属性
  声明在init方法中
  以'self.属性 = 值'的方式来声明(这儿的属性就是对象属性) - 方式
  通过'对象.属性'的方式来使用 - 使用

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

在init方法中声明对象属性:

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

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

class Dog():
    def __init__(self, name, type1='as'):
        self.name = name
        self.age = 18
        self.type1 = type1

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

练习2：声明矩形类，拥有属性和宽，拥有方法求面积和周长

class Square:
    def __init__(self, length, width):
        self.length = length
        self.width = width

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

    def perimeter(self):
        return (self.length+self.width) *2

对象属性的增删改查

python中对象的属性支持增删改查
1.查(获取对象属性)
1.查
- 对象.属性 - 获取指定对象指定属性值;当属性不存在的时候会报错

• getattr(对象, 属性名:str, 默认值) - 获取指定对象指定属性值
• 当属性不存在的时候如果默认值赋了值，程序不会报错
• 属性不确定的时候可以使用getattr

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

def main():
    p1 = Person('小花')
    p2 = Person('小红')
    
    print(p1.name)
    print(getattr(p1, 'name', None))
    print(getattr(p1, 'name1', None))

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

    p1.weight = 60
    print(p1.weight)
    p1.age = 33
    print(p1.age)
    setattr(p1, 'age', 23)
    print(p1.age)

3. 删

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

    del p1.sex

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

内置属性

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

class Person:
    """说明文档：人类"""
    # 类的子段
    num = 61

    # 对象属性
    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))

1. 定制对象的打印格式(当我们通过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():
    # 1.类.__name__ - 获取的名字
    print(Person)
    p1 = Person()
    print(p1)
    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是谁调用就指向谁)
   • c.怎么调用：通过类来调用，类.方法()

3. 静态方法

   • a.怎么声明：声明函数前加@staticmethod
   • b.特点：没有默认参数
   • c.怎么调用：通过类来调用，类.方法()

4. 在类中怎么选择使用哪种方法：

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

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

    @classmethod
    def func2(cls):
        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()