精华内容
下载资源
问答
  • Python中的属性和方法

    2020-04-01 20:53:50
    直接在类定义的属性是类属性; 类属性可以通过类或类的实例访问到; 但是类属性只能通过类对象来修改,无法通过实例对象修改; count=0 def __init__(self): 实例属性: 通过实例对像添加的属性属于实例...

    定义一个类:

    class A(object):	
    

    类属性:
    直接在类中定义的属性是类属性;
    类属性可以通过类或类的实例访问到;
    但是类属性只能通过类对象来修改,无法通过实例对象修改;

    	  count=0
    	  
    	  def __init__(self):
    

    实例属性:
    通过实例对像添加的属性属于实例属性;
    实例属性只能通过实例对象来访问和修改,类对象无法访问修改;

    	       self.name = "孙悟空"
    

    实例方法:
    在类中定义,以self为第一个参数的方法都是实例方法;
    实例方法在调用时,python会将调用对象作为self传入;
    实例方法可以能过实例和类去调用;
    当能过实例调用时,会自动将当前调用对象作为self传入;
    当通过类调用用时,不会自动传递self,此时我们必须手支传递self;

    	  def test(self):
    	   	print("这是test方法~~~~,self")
    

    类方法:
    在类内部使用 @classmethod 来修饰的方法属于类方法;
    类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象 ;
    类方法和实例方法的区别,实例方法的第一个参数是self,而类方法的第一个参数是cls;
    类方法可以能过类去调用,也可以通过实例调用,没有区别;

    	@classmethod:   
      	 def test_2(cls):
    		print("这是test_2方法,它是一个类方法~~~", cls)
    		print(cls.count)
    

    静态方法:
    在类中使用@staticmethod 来修饰的方法属于静态方法
    静态方法不需要指定任何的默认参数,静态方法可以能过类和实例去调用
    静态方法,基本上是一个和当前类无关的方法,它只是一个保存到当前类中的函数
    静态方法一般都是一些工具方法,和当前类无关;

    	@staticmethod
    	def test_3():
    		print("test_3执行了~~~")
    

    a = A()
    #实例属性,通过实例对象添加的属性属于实例属性
    a.count =10
    A.count = 100
    print(‘A,’,A.count)
    print(‘a,’,a.count)
    print(‘A,’,A.name)
    print(‘a,’,a.name)

    a.test() 等价于 A.test(a)

    A.test_2() 等价于 a.test_2()

    A.test_3()
    a.test_3()

    展开全文
  • Python-类属性,实例属性,类方法,静态方法,实例方法属性和实例属性#coding:utf-8class Student(object):name = "I am a class variable" #类变量>>> s = Student() # 创建实例s>>> print(s.name) # ...

    Python-类属性,实例属性,类方法,静态方法,实例方法

    类属性和实例属性

    #coding:utf-8

    class Student(object):

    name = "I am a class variable" #类变量

    >>> s = Student() # 创建实例s

    >>> print(s.name) # 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性

    Student

    >>> print(Student.name) # 打印类的name属性

    Student

    >>> s.name = "Michael" # 给实例绑定name属性

    >>> print(s.name) # 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性

    Michael

    >>> print(Student.name) # 但是类属性并未消失,用Student.name仍然可以访问

    Student

    >>> del s.name # 如果删除实例的name属性

    >>> print(s.name) # 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了

    Student

    类方法,实例方法,静态方法

    实例方法,第一个参数必须要默认传实例对象,一般习惯用self。

    静态方法,参数没有要求。

    类方法,第一个参数必须要默认传类,一般习惯用cls。

    # coding:utf-8

    class Foo(object):

    """类三种方法语法形式"""

    def instance_method(self):

    print("是类{}的实例方法,只能被实例对象调用".format(Foo))

    @staticmethod

    def static_method():

    print("是静态方法")

    @classmethod

    def class_method(cls):

    print("是类方法")

    foo = Foo()

    foo.instance_method()

    foo.static_method()

    foo.class_method()

    print("----------------")

    Foo.static_method()

    Foo.class_method()

    运行结果:

    是类的实例方法,只能被实例对象调用

    是静态方法

    是类方法

    ----------------

    是静态方法

    是类方法

    类方法

    由于python类中只能有一个初始化方法,不能按照不同的情况初始化类,类方法主要用于类用在定义多个构造函数的情况。

    特别说明,静态方法也可以实现上面功能,当静态方法每次都要写上类的名字,不方便。

    # coding:utf-8

    class Book(object):

    def __init__(self, title):

    self.title = title

    @classmethod

    def class_method_create(cls, title):

    book = cls(title=title)

    return book

    @staticmethod

    def static_method_create(title):

    book= Book(title)

    return book

    book1 = Book("use instance_method_create book instance")

    book2 = Book.class_method_create("use class_method_create book instance")

    book3 = Book.static_method_create("use static_method_create book instance")

    print(book1.title)

    print(book2.title)

    print(book3.title)

    展开全文
  • python中关于属性和方法

    千次阅读 2018-11-29 20:25:55
    有时候会经常把属性和方法弄混淆,更是在python中,像实例属性,实例方法, 类属性和类方法,以及静态属性和静态方法。   在python中,程序中存储所有数据都是对象,而每一个对象都有一个标识,一个类型和一个...

                  有时候会经常把属性和方法弄混淆,更是在python中,像实例属性,实例方法,

    类属性和类方法,以及静态属性和静态方法。

     

    在python中,程序中存储的所有数据都是对象,而每一个对象都有一个标识,一个类型和一个值,

    for example:

             a=42

    就会创建一个值为42的整数对象,而a就是这个标识,

    类似与is和==的区别(is就是比较对象的id,也就是表示标识是否相等,而==则是比较对象的值)

    is也被叫做同一性运算符,这个运算符比较判断的是对象间的唯一身份标识,也就是id是否相同。通过对下面几个list间的比较,你就会明白is同一性运算符的工作原理:

    (略微扯远了一点)

     

     

    在python的类中,当类被实例化后就会有对象产生,即实例化对象,那么他的id和类型就不可改变了,如果对象的值是可以改变的,那就是可变对象,反之则为不可变对象。

    属性就是与对象相关的值

    方法就是调用时将在对象上执行某些操作的函数,可用点运算符(.)访问

    展开全文
  • 1.类的属性成员变量对象的创建创建对象的过程称之为实例化,当一个对象被创建后,包含三个方面的特性对象聚丙属性和方法,句柄用于区分不同的对象,对象的属性和方法,与类中的成员变量和成员函数对应,obj = ...

    1.类的属性

    成员变量

    对象的创建

    创建对象的过程称之为实例化,当一个对象被创建后,包含三个方面的特性对象聚丙属性和方法,

    句柄用于区分不同的对象,

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

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

    类的属性

    类的属性按使用范围分为公有属性和私有属性类的属性范围,取决于属性的名称,

    **共有属性**---在内中和内外都能够调用的属性

    **私有属性**---不能在内外贝类以外函数调用

    定义方式:以"__"双下划线开始的成员变量就是私有属性

    可以通过instance.__classname__attribute方式访问,

    内置属性--由系统在定义类的时候默认添加的由前后双下划线构成,如__dic__,__module__

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    ren = People()

    ren.color = "白色人"

    print ren.color

    ren.think()

    print "#"*30

    print("People.color")

    print ren.__People__age ##测试时使用。如要调用 时,通过方法内调用 。

    2.类的方法

    成员函数

    类的方法

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

    类方法为:

    公有方法

    私有方法

    类方法

    静态方法

    公有方法:在类中和类外都都测调用的方法.

    私有方法:不测被类的外部调用模块,在方法前加个“__”c双下划线就是私有方法。

    self参数:

    用于区分函数和类的方法(必须有一个self)

    self参数表示执行对象本身

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def test(self):

    self.think() # 内部调用

    jack = People()

    jack.test() #外部调用

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    def test(self):

    self.__talk() # 内部调用talk()

    jack = People()

    jack.test() #外部调用

    类方法

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

    静态方法:相当于“全局函数”,可以被类直接调用,可以被所有实例化对象共享,通过staticmethod()定义静态方法, 静态方法没有self参数

    装饰器:

    @classmethod()

    @staticmethod()

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    def test(self):

    print "Testing...."

    cm = classmethod(test)

    jack = People()

    People.cm()

    通过类方法类内的方法 ,不涉及的属性和方法 不会被加载,节省内存,快。

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    def test(): ##没有self 静态调用 会把所有的属性加载到内存里。

    print People.__age # 通过类访问内部变量

    sm = staticmethod(test)

    jack = People()

    People.sm()

    装饰调用类的方法:

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    jack = People()

    People.test()

    People.test1()

    3.类的内置方法

    Python内部类:

    所谓内部类,就是在类的内部定义的类,主要目的是为了更好的抽象现实世界。

    例子:

    汽车是一个类,汽车的底盘轮胎也可以抽象为类,将其定义到汽车内中,而形成内部类,

    更好的描述汽车类,因为底盘轮胎是汽车的一部分。

    内部类实例化方法:

    方法1:直接使用外部类调用内部类

    方法2:先对外部类进行实例化,然后再实例化内部类

    out_name = outclass_name()

    in_name = out_name.inclass_name()

    in_name.method()

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    print("I am chinese")

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    jack = People.Chinese()

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    jack = People.Chinese() #外部类调用内部类

    print jack.name #外部类调用内部类对象

    另一种方法,外部类调用内部类对象

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    ren = People() #实例化外部类

    jack = ren.Chinese() #实例化内部类

    print jack.name #打印内部类属性

    print People.Chinese.name

    print People.Chinese().name

    魔术方法:

    str(self)

    构造函数与析构函数

    构造函数:

    用于初始化类的内部状态,Python提供的构造函数是__init__():

    __init__():方法是可选的,如果不提供,python会给出一个默认的__init__方法。

    析构函数:

    用于释放对象占用的资源,python提供的析构函数是__del__():

    __del__():也是可选的,如果不提供,则python会在后台提供默认析构函数。

    构造函数__str__

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def __str__(self):

    return "This is People class"

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    ren = People() #实例化外部类

    print ren #默认执行__str__

    __init__(self)初始化类:

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def __str__(self):

    return "This is People class"

    def __init__(self,c="white"): #类实例化时自动执行

    self.color = c

    self.think()

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    jack = People("green")

    ren = People() #实例化外部类

    print ren.color #通过对象访问属性是初始化后的值

    print People.color #通过类访问还是原来的值

    [root@localhost 20180110]# python test1.py

    I am a black

    I am a thinker

    30

    black

    yellow

    析构函数__del__():释放资源

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def __str__(self):

    return "This is People class"

    def __init__(self,c="white"): #类实例化时自动执行

    print ("initing...")

    self.color = c

    self.think()

    f = open("test.py")

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    def __del__(self):

    print ("del....")

    self.f.close()

    jack = People("green")

    ren = People() #实例化外部类

    print ren.color #通过对象访问属性是初始化后的值

    print People.color #通过类访问还是原来的值

    垃圾回收机制:

    Python采用垃圾回收机制来清理不再使用的对象;python提供gc模块释放不再使用的对象。

    Python采用“引用计数”的算法方式来处理回收,即:当然某个对象在其作用域内不再被其

    他对象引用的时候,python就自动化清除对象。

    gc模块collect()可以一次性收集所有待处理的对象(gc.collect)

    #!/usr/bin/env python

    #-*- coding:utf-8 -*-

    class People(object):

    color = "yellow"

    __age = 30 #私有属性

    class Chinese(object):

    name ="I am a Chinese."

    def __str__(self):

    return "This is People class"

    def __init__(self,c="white"): #类实例化时自动执行

    print ("initing...")

    self.color = c

    self.think()

    f = open("test.py")

    def think(self):

    self.color = "black"

    print "I am a %s " % self.color

    print ("I am a thinker")

    print self.__age

    def __talk(self):

    print "I am talking with Tom"

    @classmethod #调用类的方法

    def test(self):

    print ("this is class method")

    @staticmethod #调用类的方法

    def test1():

    print ("this is static method")

    def __del__(self):

    print ("del....")

    self.f.close()

    print gc.collect() 如果是0是没有回收的。

    jack = People("green")

    ren = People() #实例化外部类

    print ren.color #通过对象访问属性是初始化后的值

    print People.color #通过类访问还是原来的值

    展开全文
  • 本文实例讲述了Python编程中属性和方法使用技巧。分享给大家供大家参考。具体分析如下:一、属性在python中,属性分为公有属性和私有属性,公有属性可以在类外部调用,私有属性不能在类外部调用。公有属性可以是...
  • 属性和实例属性 #coding:utf-8 class Student(object): name = 'I am a class variable' #类变量 >>> s = Student() # 创建实例s >>> print(s.name) # 打印name属性,因为实例并没有name属性,所以会继续查找...
  • Python中的私有属性和私有方法

    千次阅读 2019-06-05 14:49:08
    但是Python中的属性和方法在类的外部默认是可以访问的,而有些属性和方法我们只允许在类的内部使用,不允许在类的外部使用。这种情况下,可以使用类的私有属性和私有方法。 一、私有属性 Python中通过一对前缀...
  • Python中的属性和方法大全

    千次阅读 2019-05-28 22:06:44
    Python中的属性和方法大全 文章目录Python中的属性和方法大全1.特殊属性:2.方法2.1特殊内建函数与查看属性2.2实例化2.3可视化2.4可哈希(hash)与等等运算符(==)2.5bool3运算符重载3.1比较运算符重载3.2算术...
  • 魔法属性和方法Python内置一些属性和方法,有着特殊含义。命名时前后加上两个下划线,在执行系统特定操作时,会自动调用。 那么接下来,我们就列举一些常见魔法属性和方法。 1._init_: 初始化方法,在创建类...
  • 主要介绍了Python编程之属性和方法,以实例形式较为详细分析了Python中属性与方法功能、特点与使用技巧,需要朋友可以参考下
  • 1. Python中类中特性分成属性和方法 属性和方法都分为私有和公有,私有只可以在本类中使用外部是无法访问 2. 定义属性(成员变量)语法格式(公有属性/私有属性) class 类名: def __init__(self): self....
  • 私有属性和方法 在实际开发,对象 某些属性或方法 可能只希望 在对象内部被使用,而 不希望在外部被访问到 私有属性 就是 对象 不希望公开 属性 私有方法 就是 对象 不希望公开 方法 代码 class Girl: ...
  • Python中的属性分为:类属性和对象(实例)属性: 1.类属性就是属于类所有,可以直接用类名.属性名直接调用,类的属性在内存中只有一份。 实例属性就是在__init__()方法中初始化的属性; 2.实例属性属于类的对象所有...
  • Python的属性和方法

    2019-08-03 09:55:08
    # 定义一个类 class A(object): ... # 类属性,直接在类定义的属性是类属性 # 类属性可以通过类或类的实例访问到 # 但是类属性只能通过类对象来修改,无法通过实例对象修改 count = 0 def __init__(se...
  • 1.Python中的属性和方法在类的外部默认是可以访问的,而有些属性和方法我们只允许在类的内部使用,不允许在类的外部使用。这种情况下,可以使用类的私有属性和私有方法。 """ class Custom(object): def __init__...
  • Python 私有属性和方法

    千次阅读 2018-08-12 19:47:46
    3、python中可以在对象方法内部直接访问私有属性和方法,在外部不可以访问对象私有属性和方法。如:self.__name。 4、在python中没有真正意义私有属性和私有方法,我们在定义私有属性和方法是解释器对私有...
  • python的属性和方法

    千次阅读 2015-02-28 14:51:58
    函数如何变成方法properties描述符工作机制确定方法解析顺序 新式意味着了Python2.2及以上版本并包括了3.x。在这些版本已经有一些行为上变化但这里介绍所有概念都是有效。 内容索引 在你开始前 1. 新...
  • 本文主要介绍了如何在Python中动态获取对象的属性和方法,并运行使用它们,需要的朋友可以参考一下
  • 中的属性分为: 实例属性 类属性 类中的方法分为: 实例方法方法 静态方法中的属性 实例属性: 定义:在类的方法中定义的变量 使用:创建实例对象的时候被创建,能被实例调用,无法被类调用,可以...
  • python中魔法属性和魔法方法

    千次阅读 2015-10-11 18:13:30
     在python总,有名称会在前面后面都加上两个下划线,例如__future__、__init__、__del__以及__new__等等,这些特殊名称,在python中就称为魔法方法或魔法属性。  例如:  (1)__new__ 是创建类对象...
  • property属性 class Cat(object): ... """@property装饰器函数将变成类一个属性属性名为函数名,属性值为函数返回值""" """@property装饰函数会在读取属性值执行""" money = self.__money return money
  • 关于Python中的私有属性和私有方法 Python对于类的成员没有严格的访问控制限制,这与其他面相对对象语言有区别。关于私有属性和私有方法,有如下要点: 1、通常我们约定,两个下划线开头的属性是私有的(private)。...
  • 就标识这个这个属性是一个私有属性self.__money = 1000000如果一个方法是以两个下划线开始 也代表已经私有子类继承了父类 如果父类的属性私有 将不会被子类继承私有属性和私有方法可以在类的里面使用自定义类 ...
  • 注: python与其他语言不一样,可以动态的加载对象的属性和方法。 2、类属性 & 对象属性 类属性 #定义类和属性 class Student: # 类属性 name = 'Jason' age = 20 object1 = Student() #使用类,创建对象 object1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,290
精华内容 3,316
关键字:

python中的属性和方法

python 订阅