面向对象编程

必知：Python中有两种编程方式：

　　　　1.函数式编程

　　　　2.面向对象编程: 其实就是对类和对象的应用

1.类的创建：

格式：

　　　　class 类名：
　　　　　　def 方法名（）：

2.类中方法的调用：

1.定义好一个类后

2.将类赋值给一个自定义的对象

3.利用自定义的对象来调用类中的方法

示例：

class bar:  # 定义一个类
    def foo(self): # 定义一个方法
        print('hello world ')
        
# 以上就是完成类的创建了

# 下面是对类中方法的调用

obj = bar()   # 自定义一个对象，将类名加括号赋值给对象

obj.foo()   # 通过'对象.方法名'的方式来调用

3.类中默认的__init__方法（构造方法）：

　　当你执行将类名赋值给对象是，Python内部自动执行的一个函数，所以进行封装时也可以利用这个方法，可以让你的代码看起来更漂亮

方法中的默认self参数：

　　self参数Python内部在你调用方法的时候，自动传值的参数，其实他代指的是调用方法的对象的名字（也就是上面例子中的obj对象）

4.面向对象的三大特性：

1.封装：

　　1.就是当你的函数的参数中有许多的共同且不变的参数时，可以直接将值封装在对象中

　　2.利用类的特性，__init__方法，在方法中封装公用的值

class bar:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.blood = 'o'
    def show_info(self, hobby):
        print(self.name, self.age, self.blood, hobby)


alex = bar('alex', 15)

alex.show_info('jklsjdfljk')

2.继承（可以多代继承）

　　子代可以继承父代类中的方法

　　示例：

class bar:  # 父类（基类）
    def show_name(self):
        print('hello')
    def show_age(self):
        print('world')



class car(bar): # 子类（派生类）
    def show_sex(self):
        print('male')

实现不继承父代中的方法：

代码示例：

class bar:
    def show_name(self):
        print('hello')
    def show_age(self):
        print('world')



class car(bar):
    def show_sex(self):
        print('male')
    def show_name(self):  # 在子代中定义一个和父代中相同名字的方法，就可以实现，方法重写
        print('female')

执行父类中的已经被子类重写的方法：

　　1.super(父类类名，当前对象).方法名

　　2.父类名.方法名（self）

注意：

1.self永远是执行该方法的调用者

2.Python中支持多继承

3.调用顺序

　　1.如果有init方法，最先执行init方法　　

　　2.父类从左到右

　　3.如果父类还有父类的话，就直接找到低，再找下一个父类

　　4.如果，不同的父类，有相同的基类的时候，最后执行基类

3.多态

　　Python原生就是多态的

类中的字段和方法：

字段：

　　普通字段：属于对象，只能通过对象来访问

　　静态字段：属于类，并且在内存中只存在一份，不但能通过对象来访问，还能通过类来调用（可以修改）

class bar:

    name = 'alex'

bar.name = 'alvin' # 可修改
print(bar.name)

方法：

　　普通方法：保存在类中，只能通过对象来调用

class bar:    
    def func(self):  # 普通方法
        print('hello world')

obj = bar()

obj.func()

　　静态方法：就是给普通的方法加上一个装饰器（staticmethod），这个方法就可以通过类直接调用，省去了创建对象的内存，还省略了self参数

class bar:

    @staticmethod
    def func():  # 静态方法
        print('hello world')

bar.func()    # 直接由类调用方法

　　类方法：也是保存在类中，也是需要加上一个装饰器（classmethod），这个方法可以有self参数，但是默认不写成self而是写成cls，cal --->类名（Python自动传入这个参数）

· 各种方法的使用场景：

　　如果对象中需要保存一些值，执行某功能的时候，需要使用对象中的值，那么这时候我们就应该使用普通方法

　　如果时对象中不是必须保存一些值，我们就可以使用静态方法，使用静态方法的好处就是可以节省创建对象的空间

属性：

　　他是一个方法，需要加装饰器（property）他的创建方式和普通的方法的创建方式是一样的，并且调用方法是和字段一样的，

1.创建一个属性

class bar:

    @property
    def fun(self):   # 这种方法叫做属性
        print('hello world')
        return 'sdkfj'


obj = bar()

print(obj.fun)

2.修改属性的返回值

再创建一个方法，加上装饰器（属性名.setter），修改属性的返回值，需要在方法中添加一个接受修改以后的返回值

class bar:
    
    @property           # 属性
    def foo(self):
        return 1
    @foo.setter    # 对属性的返回值进行修改
    def foo(self, value):    # 需要有一个参数来接受，修改后的值
        print(value)

obj = bar() # 创建对象
 
obj.foo = 3  # 修改返回值

3.删除属性的返回值

再创建一个方法，加上装饰器（属性名.deleter）, 删除属性的返回值

class bar:
    @property
    def foo(self):
        print('hello world')
        return 3
    @foo.deleter
    def foo(self): # 创建一个新的方法，加上装饰器，可以删除之前的属性的返回值
        return 1

obj = bar()

del obj.foo    # 删除属性的返回值

反射：

作用：通过字符串的方式，操作对象中的成员

注意：类是一个对象，对象是一个对象，一个模块相对于函数也是一个对象，所以反射中的方法在类，模块中也都可以使用

　　反射提供的方法：

　　1.getattr（对象，字符串类的成员）利用字符串查看成员的值

　　2.hasattr（对象，字符串类的成员）查看对象中是否有这个成员，返回布尔值

　　3.setattr（对象，成员名，成员名的值）在对象中创建新的成员

　　4.delattr（对象，字符串类的成员）删除对象中的成员

示例：

class bar:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # def func(self):
    #     print('hello world')



obj = bar('alex', 34)


while True:
    your_enter = input('your enter:')

    # result = getattr(obj, your_enter)  # getattr 的应用

    # result = hasattr(obj, your_enter)    # hasattr 的应用，判断后面的成员是否在前面的对象中，返回布尔值

    result = delattr(obj, your_enter)      # 利用delattr删除对象中的成员
    res = getattr(obj, your_enter)  # 这一段代码是判断是否正真的删除成员了
    print(res)

View Code

单例模式：

单例模式的目的就是永远使用同一个实例（或者说是对象）

示例：

class bar:
    
    __v = None 
    
    @classmethod
    def only_type(cls): # 使用类方法
        if cls.__v :
            return cls.__v    # 永远都是这一个实例
        else:
            cls.__v = bar()   # 实例化过程，创建了一个对象
            return cls.__v
    def func(self):
        print('ksdfl')
        
        
obj = bar.only_type() # 如果是需要使用单例模式，就这样进行实例化