Mr.kang之真经求取
                                        ---积跬步,至千里

面向对象编程

 

必知: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() # 如果是需要使用单例模式,就这样进行实例化

 

posted @ 2018-06-21 22:32  Mrs.kang  阅读(168)  评论(0编辑  收藏  举报