码迷,mamicode.com
首页 > 编程语言 > 详细

python3 速查参考- python基础 8 -> 面向对象基础:类的创建与基础使用,类属性,property、类方法、静态方法、常用知识点概念(封装、继承等等见下一章)

时间:2018-05-15 01:45:43      阅读:205      评论:0      收藏:0      [点我收藏+]

标签:string   span   __name__   user   pre   面向过程   特征   manager   utf-8   

基础概念


 

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方法  
      

 

python3 速查参考- python基础 8 -> 面向对象基础:类的创建与基础使用,类属性,property、类方法、静态方法、常用知识点概念(封装、继承等等见下一章)

标签:string   span   __name__   user   pre   面向过程   特征   manager   utf-8   

原文地址:https://www.cnblogs.com/wuzhiming/p/9038661.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!