day15面向对象

day15面向对象

一、编程思维

根据面对问题不同人呈现出的思维模式，可以将编程思维分为三种：

1. 面向过程编程
2. 函数式编程
3. 面向对象编程

from functools import reduce
result = reduce(lambda x,y:x*y,range(1,11))
print(result)

二、类和对象

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

   类就是拥有相同功能或者相同属性的对象的集合。(类是抽象的概念)
   对象就是类的实例

2. 定义类 - 创建类

   1. 定义类：用代码来描述你的这个类是拥有哪些相同的功能(用函数)和哪些相同的属性(用变量)的对象的集合。
   2. 语法:
      class 类名(父类):
      类的说明文档
      类的内容(包含方法和属性)
   3. 说明：
      a. class - 关键字；固定写法
      b. 类名 - 程序员自己命名；
      两个要求–是标识符，不是关键字；
      规范：见名知义，不使用系统的函数名、类名和模块名；采用驼峰式命名-大驼峰
      c.类的说明文档 - 本质就是一个多行注释
      d.类的内容 -包含定义在类中的函数(方法)和定义在类中的变量(属性)
      方法包括：对象方法、类方法、静态方法
      属性包括：类属性、对象属性

   # PEP8 - user_name
   # 小驼峰 - userName
   # 大驼峰 - UserName
   
   class Dog:
       pass
   

3. 创建对象

"""
对象是通过类来创建的
语法：
类名()
"""
dog1 = Dog()

三、方法

1. 什么是方法 - 定义在类中的函数就是方法

2. 不同的方法的使用

   1)对象方法
   a.怎么定义：直接定义在类中的函数就是对象方法
   b.怎么调用：以’对象.xxx()'的形式来调用
   c.特点:自带参数self，调用函数时，self不需要传参，系统会自动将当前对象传给self(谁调用self，self就指向谁)

   2)类方法
   a.怎么定义:定义函数前，添加装饰器 @classmethod
   b.怎么调用:以’类名.xxx()'的形式来调用
   c.特点:自带参数cls，调用函数时，cls不需要传参，系统会自动将当前类传给cls

   3)静态方法
   a.怎么定义:定义函数前添加装饰器 @staticmethod
   b.怎么调用:以’类名.xxx()'的形式来调用
   c.特点：没有特点

class A:
    # func1是对象方法
    def func1(self):
        print(f'self:{self}')
        print('对象方法')

    def func2(self,a,b=2):
        print(f'对象方法2, a:{a}, b:{b}')

    # func3是类方法
    @classmethod
    def func3(cls):
        print(f'cls:{cls}')
        print('类方法')


    #func4是静态方法
    @staticmethod
    def func4():
        print('静态方法')

a1 = A()
print(a1)
# 通过对象调用对象方法
a1.func1()
a1.func2(100)

# 通过类来调用类方法
print(f'A:{A}')
A.func3()

# 通过类来调用静态方法
A.func4()

四、init方法

魔法方法

1)魔法方法的特点：

a.函数名以__开头，以__结尾
b.魔法方法不需要程序员自己调用，系统会在特定的情况下自动调用

2)两个常见的魔法方法：

a.__init__
如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它
创建对象时需不需要实参，需要几个实参，由类中的__init__决定

b.__repr__    - [定制打印格式]
如果类中添加了__repr__方法，打印类的对象的时候会自动添加调用这个方法，并且将这个方法对应的返回值作为打印的结果进行打印
在类中添加__repr__方法时，这个方法的返回值必须是字符串

class A:
    def __init__(self):
        print('init方法被调用')

a1 = A()
a2 = A()

class B:
    def __init__(self,m,n):
        print(f'm:{m},n:{n}')
    def __repr__(self):
        return f'<B的对象{id(self)}>'
b1 = B(10, 20)
b2 = B(m=100,n=200)
print(b1)

class Student:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def __repr__(self):
        return f'<name:{self.name},age:{self.age},gender:{self.gender}>'
stu1 = Student('xiao',12,'女')
print(stu1)

五、属性

属性 - 定义在类中的变量

1. 类中的属性分为：类属性、对象属性

   1)类属性
   a.怎么定义：直接在类中定义的变量就是类属性
   b.怎么使用：以'类名.xxx'的方式使用
   c.什么时候用:如果属性值不会因为对象不同而不一样，就定义成类属性
   
   2)对象属性
   a.怎么定义：以'self.属性名 = 属性值'的形式定义在__init__方法中
   b.怎么使用:以'对象.xxx'的方式使用
   c.什么时候用:如果属性值会因为对象不同而不一样，就定义成对象属性
   

class A:
    #m、name是类属性
    m=10
    name='小爷'

    #x 和 n是对象属性
    def __init__(self):
        self.x = 10
        self.n = 'hello'


# 通过类使用类属性
print(A.name)
print(A.m)

# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)


class Dog:
    def __init__(self, name, age, gender, breed):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed
dog1 = Dog('黑子',2,'男','茶杯犬')
print(dog1.name)
print(dog1)


class Circle:
    pi = 3.1415926
    def __init__(self, r=0):
        self.r = r

    # 如果对象方法中需要用到对象属性，有self来提供
    def area(self):
        return  Circle.pi * self.r ** 2

    def perimeter(self):
        return Circle.pi * self.r * 2


c1 = Circle(10)
print(c1.area())
print(c1.perimeter())

六、继承

1. 继承

   继承：让子类直接拥有父类的属性和方法

   子类 - 继承者
   父类 - 被继承的类

2. 继承语法

   语法：
   class 类名(父类1，父类2，父类3，…)
   类的说明文档
   类的内容

   注意:定义类的时候没有写父类，那么这个类会默认继承 object(基类)

class A:
    m = 100
    def __init__(self):
        self.n = 200
    def func1(self):
        print('对象方法')
    @classmethod
    def func2(cls):
        print('类方法')
    @staticmethod
    def func3():
        print('静态方法')


class B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新的对象属性
    def __init__(self):
        #如果子类自己有__init__方法，那么会调用子类自己的__init__方法，没有时才会调用父类的__init__方法
        super().__init__() #调用当前类的父类的__init__方法    添加父类的对象属性方法
        # super(B, self).__init__()
        self.p = 1000

    # 添加新的方法
    def func11(self):
        print('对象方法2')

    @classmethod
    def func22(cls):
        print('类方法')

    @staticmethod
    def func33():
        print('静态方法')



b1 = B()

# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()
B.func3()

# 使用B中的内容
print(B.x)
b1.func11()