专栏首页python3python面向对象,类

python面向对象,类

1:类和对象

    是面向对象中的俩个重要概念,类是对事物的抽象,比如人类,球类。对象是事物的实例,比如足球,篮球。球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球体出来。

2:类的定义

    类把需要的变量和函数组合成一起,这种包含称为“封装”。。classA(object):

3:类的结构

    class类名:

    成员变量-属性              ## 类的属性是对数据的封装

    成员函数-方法              ## 类的方法是对类的行为进行封装

类的创建:

    class MyClass1(object):        ## 类名

            color = 'Black'          ## 类的属性-变量

       def fun(self):           ## 类的方法中必须有参数self,这是成员函数类的方法

                print "I am function"

#!/usr/bin/python
class People():
    color = 'yellow'             ## 成员变量
    def think(self):             ## 成员函数
        self.color = 'Black'     ## self表示类本身
        print 'I am a %s' % self.color
        print 'I am a thinker'
ren = People()                   ## 把类赋予一个变量,即实例化
print ren.color
ren.think()

4:类的属性

    公有属性:在类中类外都可以使用。

    私有属性:只能在类中使用,定义方式为__name(双下划线)

    内置属性:由系统定义类的时候默认添加的,由前后双下划线构成。__dict__,__module__。

#!/usr/bin/python
class People():
    color = 'yellow'
    __age = 20
    def think(self):
        self.color = 'Black'
        print 'I am a %s' % self.color
        print 'I am a thinker'
        print self.__age   ## 私有函数,只能在类中使用
ren = People()
print ren.color
ren.think()
print ren._People__age     ## 仅测试使用,类外使用私有函数

5:类的方法相当于函数,类的属性相当于变量。

    方法的定义跟函数一样,但是需要self作为第一个参数。

    公有方法:跟公有属性一样,类内类外都可以使用

    私有方法:跟私有属性一样,只能类内使用。__self

    self:用来区分类跟方法,self本身表示类

    类方法:被classmethod编译过的函数,能被类所调用,也能被对象调用(继承的关系)

    静态方法:被staticmethod编译过的函数,可以被类直接调用,静态方法不需要设置self参数。

    装饰器:

        @classmethod:类方法

        @staticmethod:静态方法

6:对象的创建

    创建对象的过程称之为实例化:当一个对象被创建后,包含三个方面的特性:对象句柄,属性,方法。句柄用来区分对象。

    对象的属性和方法与类中的成员变量和成员函数相对应

    object=MyClass() ## 创建类的一个实例(对象),通过对象来调用方法和属性

#!/usr/bin/python
# coding:utf-8
class MyClass1(object):                   ## 类
    color = 'Yellow'                      ## 类的属性--变量
    __age = 20                            ## 类的私有属性,只能在类中使用
    @classmethod
    def __hide(self):                     ## 类的隐藏方法,只能在类中使用
        print "I am hidemethods!"
    @classmethod                          ## 装饰,对象和类都可以调用
    def fun(self):                        ## 类的方法--函数
        print self.__age                  ## self等同类,表示调用类的私有属性
        print 'This is function!'
    @staticmethod                         ## 装饰,对象和类都能调用,不需要self
    def fun1():                           ## 不需要self
        print MyClass1.color              ## 直接使用类调用类的属性或方法
        MyClass1.__hide()                 ## 调用类的隐藏方法
    class InsideClass(object):            ## 类中类,内部类
        Inside = 'Red'                    ## 内部类的属性
        @classmethod
        def InsideFun(self):              ## 内部类的方法
            print self.Inside
object = MyClass1()                       ## 对象,实例化类
object.fun()                              ## 对象调用类的方法
MyClass1.fun()                            ## 类调用类的方法
MyClass1.fun1()
object_inside = object.InsideClass()      ## 先调用外部类,再调用内部类
MyClass1.InsideClass.InsideFun()          ## 调用内部类的方法
print object_inside.Inside                ## 调用内部类的属性

7:内部方法(魔术方法)

    def __str__(self):               ## 如果直接实例化类,会返回__str__的值,而不是提示这样<对象>

       return "This is class object!"

 构造函数

    def __init__(self,c='Black'):       ## 初始化对象的属性,但不会改变类的属性

       self.color = c        

    析构函数

    def __del__(self):                         ## 主要用于释放资源,一般执行与脚本的最后

#!/usr/bin/python
class PeoPle(object):
    color = 'Black'
    def __init__(self,c):                         ## 初始化属性,c需要在实例化类的时候,跟在后面
        self.color = c
        print "Init runinng ......"               ## 只要把类实例化成对象,就会打印这行,
    def fun1(self):
        print "Color is: %s" % self.color
pe = PeoPle('Red')
print "Object print is: %s" %pe.color             ## __init__会影响对象的属性
print "Class print is: %s" %PeoPle.color          ## 类不会受__init__的影响

类的继承:

单类继承

#!/usr/bin/python
class PeoPle(object):
    color = 'Black'
    def __init__(self,c):                   ## 初始化参数
        self.color = c
        print "Init runinng ......"
    @classmethod                            ## 装饰方法,使其对象和类都可以调用
    def fun1(self):
        print "Color is: %s" % self.color
class MyClass(PeoPle):                      ## 继承父类PeoPle  
    color = 'MyClass'
    def __init__(self):
        PeoPle.__init__(self.'Red')         ## 表示继承父类的__init__构造函数。                      
    @classmethod
    def fun1(self):
       print "This is MyClass the function"
    pass
my=MyClass()                      ## 由于MyClass类中继承过PeoPle里的__init__参数。
print MyClass.color               ## 优先返回MyClass里的属性
my.fun1()                         ## 优先返回MyClass里的方法
PeoPle.fun1()                     ## 返回PeoPle里的fun1方法
MyClass.fun1()                    ## 返回MyClass里的fun1方法
pe = PeoPle('Green')              ## 由于PeoPle初始化__init__那里需要俩个参数,所以这里要加一个参数
print "Object print is: %s" % pe.color  ## 打印初始化后对象的属性即Green
print "Class print is: %s" % PeoPle.color  ## 打印类属性即Black 

多类继承:

#!/usr/bin/python
class PeoPle(object):
    def __init__(self):
        self.dwell = 'Earth'
        self.color = 'Yellow'
    def think(self):
        print "I dwell am %s!" % self.dwell
class Chinese(object):
    color = 'Black'
    def __init__(self):
        self.dwell = 'China'
    def think(self):
        print "I am chinese %s " % self.color
class MyClass(Chinese,PeoPle):       ## 默认首先继续第一个类的属性跟方法                    
    def __init__(self): 
        PeoPle.__init__(self)        ## 表示使用指定类的属性
    pass
my = MyClass()
my.think()                           ## 返回I am Chinese Yellow

类的属性---总结

  • 类属性(公有属性): 可以在类中使用,相当于变量。    
  • 类私有属性(私有属性): 只能函数中使用,无法被对象调用
  • 对象的公有属性: 对象可以调用
  • 对象的私有属性: 只能类中调用
  • 内置属性:
  • 函数的局部变量: 只能在本函数中使用
  • 函数的全局变量: 可以在类中所有的函数里使用
#!/usr/bin/python
# coding:utf8
val6 = "全局变量"
print '*' * 50
class My(object):
    val1 = "类的公有属性 val1"
    __val2 = "类的私有属性 __val2"
    def fun(self):
        self.val3 = "对象的公有属性 val3"
        self.__val4 = "对象的私有属性 __val4"
        val5 = "函数的局部变量,只能在本函数使用"
        global val6
        val6 = "函数的全局变量,可以在类中所有的函数中使用"
    def fun1(self):
        print val6
my = My()
print my.val1
print my._My__val2
my.fun()
print '*' * 50
my.fun1()

类的方法总结:

  • 公有方法:
  • 私有方法:
  • 类方法:
  • 静态方法:
  • 内置方法:
#!/usr/bin/python
#-*- coding:utf8 -*_
class MyClass(object):
    name = 'Warning'
    def __init__(self):
        self.fun1()
        self.__fun2()
        self.fun3()
        self.fun4()
    def fun1(self):
        print "%s %s" % (self.name,'我是公有方法')
    def __fun2(self):
        print "%s %s" % (self.name,'我是私有方法')
    @classmethod
    def fun3(self):
        print "%s %s" % (self.name,'我是类方法')
    @staticmethod
    def fun4():
        print "%s %s" % (MyClass.name,'我是静态方法')
my = MyClass()
my.fun1()                           ## 调用公有方法
MyClass.fun3()                      ## 调用类方法
MyClass.fun4()                      ## 调用静态方法,注意静态方法不需要self,与类方法的区别

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Python笔记

    import functools import operator mul2 = lambda x: 2 * x print(mul2(3)) pr...

    py3study
  • 比较全的python cmd模块的用法

       百度搜了下python cmd的用法,发现都比较片,自己看了官方文档,写个稍微完整的例子,没有onecmd,另外undoc_header misc_hea...

    py3study
  • 第27天面向对象之反射,绑定方法,特定的

      类中的方法为什么要这么麻烦分这么多的类型呢?当然是有运用场景了,在写类中方法的时候具体的应用设置成绑定方法还是非绑定方法主要取决于我们方法代码中是否要用到对...

    py3study
  • 面向对象 "一"

    Wyc
  • python面向对象-封装-property-接口-抽象-鸭子类型-03

    # 将复杂的丑陋的隐私的细节隐藏到内部,对外提供简单的使用接口 或 # 对外隐藏内部实现细节,并提供访问的接口

    suwanbin
  • 比较全的python cmd模块的用法

       百度搜了下python cmd的用法,发现都比较片,自己看了官方文档,写个稍微完整的例子,没有onecmd,另外undoc_header misc_hea...

    py3study
  • Python笔记

    import functools import operator mul2 = lambda x: 2 * x print(mul2(3)) pr...

    py3study
  • 面向对象进阶

    Wisdom is knowing what to do next , virtue is doing it .

    GH
  • python高级之描述器

    py3study
  • Python入门学习(二)

    1 字典 1.1 字典的创建和访问 字典不同于前述的序列类型,它是一种映射类型。它的引入是为了简化定义索引值和元素值存在特定关系的定义和访问问题。 字典的定义形...

    闪电gogogo

扫码关注云+社区

领取腾讯云代金券