• 全栈测试 一 | py3基础 六 :类的基础


    基础概念


     1.速查笔记:

    #-- 最普通的类  
        class C1(C2, C3):  
            spam = 42                       # 数据属性  
            def __init__(self, name):       # 函数属性:构造函数  
                self.name = name  
            def __del__(self):              # 函数属性:析构函数  
                print("goodbey ", self.name)      
        I1 = C1('bob')  
          
    #-- Python的类没有基于参数的函数重载  
        class FirstClass:  
            def test(self, string):  
                print(string)  
            def test(self):                 # 此时类中只有一个test函数 即后者test(self) 它覆盖掉前者带参数的test函数  
                print("hello world")  
      
    #-- 子类扩展超类: 尽量调用超类的方法  
        class Manager(Person):  
            def giveRaise(self, percent, bonus = .10):  
                self.pay = int(self.pay*(1 + percent + bonus))     # 不好的方式 复制粘贴超类代码  
                Person.giveRaise(self, percent + bonus)            # 好的方式 尽量调用超类方法  
      
    #-- 类内省工具  
        bob = Person('bob')  
        bob.__class__                       # <class 'Person'>  
        bob.__class__.__name__              # 'Person'  
        bob.__dict__                        # {'pay':0, 'name':'bob', 'job':'Manager'}  
          
    #-- 返回1中 数据属性spam是属于类 而不是对象  
        I1 = C1('bob'); I2 = C2('tom')      # 此时I1和I2的spam都为42 但是都是返回的C1的spam属性  
        C1.spam = 24                        # 此时I1和I2的spam都为24  
        I1.spam = 3                         # 此时I1新增自有属性spam 值为2 I2和C1的spam还都为24  
          
    #-- 类方法调用的两种方式  
        instance.method(arg...)  
        class.method(instance, arg...)

    2.学习笔记

    面向对象:狗吃(屎)

    面向过程:吃狗(屎)

    类:具有共同特征和行为的一组对象的抽象定义。类相当于制造飞机的图纸,用它创建的飞机相当于对象。

    类就是创建对象的模板。

    3.类的创建中self的含义

    # -*-  coding:utf-8 -*-
    class Test():
        def __init__(self,name):
            self.name=name
    
    try1 = Test('python') #当前调用class中方法的对象,此语句就是创建一个对象,对应类中定义的self

    4. __init__方法讲解

    # -*-  coding:utf-8 -*-
    class Test():
        def __init__(self,name,age):#__init__在创建一个对象的时候,默认被调用,不需要手动调用
            self.name = name    #__init__(self)中,定义了两个形参,那么创建对象时需要传递两个实参
            self.age = age    #self参数,Python解释器会自动把当前的对象引用传递进去,不需要开发者传递
    
    try1 = Test('python',12) #当前调用class中方法的对象,此语句就是创建一个对象,对应类中定义的self

    5. __str__方法

    # -*-  coding:utf-8 -*-
    """
    __str__定义在类内部,必须返回一个字符串类型
    实例化不会触发__str__方法,但是打印的话就会触发
    """
    class Test():
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def __str__(self):
            return "name %s,age%d"%(self.name,self.age)
    
    try1 = Test('python',12)
    print(try1)

    类的属性


     

    # -*-  coding:utf-8 -*-
    class test2():
        name = wm    #公共的类属性
        __age = 18  #私有的类属性,只能在类的内部调用
        def __init__(self,user,pw):
            self.user = user
            self.pw = pw
    a = test2('python',20)
    print(a.name)
    print(a.__age)    #会报错

    静态方法和类方法


     

     1. 速查笔记

    #-- #实例方法 / 静态方法 / 类方法  
        class Methods:  
            def imeth(self, x): print(self, x)      # 实例方法:传入的是实例和数据,操作的是实例的属性  
            def smeth(x): print(x)                  # 静态方法:只传入数据 不传入实例,操作的是类的属性而不是实例的属性  
            def cmeth(cls, x): print(cls, x)        # 类方法:传入的是类对象和数据  
            smeth = staticmethod(smeth)             # 调用内置函数,也可以使用@staticmethod  
            cmeth = classmethod(cmeth)              # 调用内置函数,也可以使用@classmethod  
        obj = Methods()  
        obj.imeth(1)                                # 实例方法调用 <__main__.Methods object...> 1  
        Methods.imeth(obj, 2)                       # <__main__.Methods object...> 2  
        Methods.smeth(3)                            # 静态方法调用 3  
        obj.smeth(4)                                # 这里可以使用实例进行调用  
        Methods.cmeth(5)                            # 类方法调用 <class '__main__.Methods'> 5  
        obj.cmeth(6)                                # <class '__main__.Methods'> 6  
          
    #-- 函数装饰器:是它后边的函数的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成  
            @staticmethod  
            def smeth(x): print(x)  
        # 等同于:  
            def smeth(x): print(x)  
            smeth = staticmethod(smeth)  
        # 同理  
            @classmethod  
            def cmeth(cls, x): print(x)  
        # 等同于  
            def cmeth(cls, x): print(x)  
            cmeth = classmethod(cmeth)  
          
    #-- 类修饰器:是它后边的类的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成  
            def decorator(aClass):.....  
            @decorator  
            class C:....  
        # 等同于:  
            class C:....  
            C = decorator(C)  #-- #实例方法 / 静态方法 / 类方法  
        class Methods:  
            def imeth(self, x): print(self, x)      # 实例方法:传入的是实例和数据,操作的是实例的属性  
            def smeth(x): print(x)                  # 静态方法:只传入数据 不传入实例,操作的是类的属性而不是实例的属性  
            def cmeth(cls, x): print(cls, x)        # 类方法:传入的是类对象和数据  
            smeth = staticmethod(smeth)             # 调用内置函数,也可以使用@staticmethod  
            cmeth = classmethod(cmeth)              # 调用内置函数,也可以使用@classmethod  
        obj = Methods()  
        obj.imeth(1)                                # 实例方法调用 <__main__.Methods object...> 1  
        Methods.imeth(obj, 2)                       # <__main__.Methods object...> 2  
        Methods.smeth(3)                            # 静态方法调用 3  
        obj.smeth(4)                                # 这里可以使用实例进行调用  
        Methods.cmeth(5)                            # 类方法调用 <class '__main__.Methods'> 5  
        obj.cmeth(6)                                # <class '__main__.Methods'> 6  
          
    #-- 函数装饰器:是它后边的函数的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成  
            @staticmethod  
            def smeth(x): print(x)  
        # 等同于:  
            def smeth(x): print(x)  
            smeth = staticmethod(smeth)  
        # 同理  
            @classmethod  
            def cmeth(cls, x): print(x)  
        # 等同于  
            def cmeth(cls, x): print(x)  
            cmeth = classmethod(cmeth)  
          
    #-- 类修饰器:是它后边的类的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成  
            def decorator(aClass):.....  
            @decorator  
            class C:....  
        # 等同于:  
            class C:....  
            C = decorator(C)

     2. 类方法

    • 定义:类方法是给类用的,类在使用时会将类本身当做参数传给类方法的第一个参数,python为我们内置了函数classmethod来把类中的函数定义成类方法,一般以cls作为第一个参数
    • 实例代码:
    # -*-  coding:utf-8 -*-
    class People(object):
        country = 'china'
    
        @classmethod
        def getCountry(cls):
            return cls.country
    p = People
    print(p.getCountry())

     3.  静态方法

    实例释义:

    # -*-  coding:utf-8 -*-
    class A(object):
        name = 'python'
        def test1(self):
            print('--test1--')
        @classmethod
        def test2(cls):#cls代表当前类A
            cls.name = 'java'
            print('--test2--')
        @staticmethod
        def test3():#静态方法属于类,没有类方法中那样的默认参数cls,但是可以通过类对象来调用,也可以用类名来调用
            A.name = 'C#'
            print('--test3--')
    a = A()
    a.test1()
    a.test2()
    a.test3()
    print(A.name)

    property的使用


    1. 速查笔记

    #-- 类属性高级话题: @property  
        # 假设定义了一个类:C,该类必须继承自object类,有一私有变量_x  
        class C(object):  
            def __init__(self):  
                self.__x = None  
        # 第一种使用属性的方法  
            def getx(self):  
                return self.__x  
            def setx(self, value):  
                self.__x = value  
            def delx(self):  
                del self.__x  
            x = property(getx, setx, delx, '')  
        # property函数原型为property(fget=None,fset=None,fdel=None,doc=None)  
        # 使用  
        c = C()  
        c.x = 100                         # 自动调用setx方法  
        y = c.x                           # 自动调用getx方法  
        del c.x                           # 自动调用delx方法  
        # 第二种方法使用属性的方法  
            @property  
            def x(self):  
                return self.__x  
            @x.setter  
            def x(self, value):  
               self.__x = value  
            @x.deleter  
            def x(self):  
               del self.__x  
        # 使用  
        c = C()  
        c.x = 100                         # 自动调用setter方法  
        y = c.x                           # 自动调用x方法  
        del c.x                           # 自动调用deleter方法
  • 相关阅读:
    vs2015编译各种库
    回测分析软件
    交易平台
    策略框架
    期货homes平台以及仿ctp接口
    k线中转器
    期货数据服务器以及取数据接口
    c++ 二叉树的遍历(迭代,递归)
    c++实现单向链表的一些操作
    numpy操作
  • 原文地址:https://www.cnblogs.com/wuzhiming/p/13348012.html
Copyright © 2020-2023  润新知