精华内容
下载资源
问答
  • 类属性和实例属性 实例属性定义: 通过类创建对象过程称为实例化,所以实例就是对象 当我们通过对象或者在类里通过self绑定属性称为实例属性 例如: # 定义一个people类 class People(object): def __init__(self)...

    类属性和实例属性

    实例属性定义:

    通过类创建对象的过程称为实例化,所以实例就是对象
    当我们通过对象或者在类里通过self绑定的属性称为实例属性

    例如:
    # 定义一个people类
    class People(object):
        def __init__(self):
            # 通过self绑定实例属性
            self.name = "张飞"
    
    
    peo = People()
    # 通过对象绑定实例属性
    peo.age = 18
    print(dir(peo))
    
    
    输出结果:
    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
    

    通过dir()方法,我们能看到在People类中包含有self绑定的name属性和通过对象绑定的实例属性

    类属性定义

    在类(class)上绑定的属性称之为类属性,类属性归类所有.
    语法:
    class 类名():
    属性名 = 值
    类属性访问:
    类名.属性名
    对象.属性名 对象没有相同属性名时,才能使用
    修改:
    类名.属性名 = 值
    注意:
    类属性,类的实例也可以使用
    使用 对象.属性 时,优先去寻找对象属性,如果找不到,会去寻找类属性
    修改时,对象属性是不能去修改类属性的

    例如
    class Man(object):
        sex = '男'
    
    
    Man.sex = '女'
    man = Man()
    print(man.sex)
    man.sex = '中'  # 修改时,对象属性不能修改类属性
    print(man.sex)
    
    man2 = Man()
    print(man2.sex)
    print(Man.sex)
    
    输出结果:
    # 类属性被类修改
    中
    女
    女
    
    

    类方法

    定义

    在python语法中,万物皆对象.所有python的类也是一个对象,称之为类对象.既然类也是一个对象,就可以给类对象上添加方法,这个方法称为类方法

    使用

    被所有对象共享,所有实例都可以调用类方法
    类方法,可以不通过创建实例,直接调用,多用来操作类属性
    类方法,只需要在定义之前,加上一行 @classmethod
    类方法,默认保留的参数是 cls, 传入的是 类 这个对象
    
    例如:
    class Women(object):
        @classmethod
        def age(cls):
            print("我是类方法")
    
    
    # 直接通过类调用方法
    Women.age()
    
    # 通过创建实例调用方法
    women = Women()
    women.age()
    
    输出结果:
    我是类方法
    我是类方法
    

    类方法的使用好处:

    类方法不用创建对象直接可以通过类名调用,简单方便
    为了起到对类属性的保护作用,通常将类属性设置为私有的,再通过类方法来获取和设置类属性
    

    如有需要代码,请点击git地址–>类属性类方法代码地址

    展开全文
  • 一、类属性和类方法方法 在类内部,使用 def 关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数 代码块: class Student(object): count = 0 def __init__...

    一、类属性和类方法

    • 类的方法
      在类的内部,使用 def 关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数 self,且为第一个参数

    代码块:

    class Student(object):
        count = 0
    
        def __init__(self,name):
            self.name = name
            Student.count += 1
    
        @classmethod
        def Show_Student_count(awda):
            print('学生数量为 %d' %(awda.count))
    
    student1 = Student('小明')
    Student.Show_Student_count()
    

    程序及运行结果:
    在这里插入图片描述

    二、静态方法

    代码块:

    class Cat(object):
    
        @staticmethod
        def call():
            print('喵')
    
    Cat.call()
    

    程序及运行结果:
    在这里插入图片描述

    三、私有属性、私有方法

    • 类的私有属性
      __private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
    • 类的私有方法
      __private_method:两个下划线开头,声明该方法为私有方法,不能在类的外部调用。在类的内部调用 self.__private_methods

    代码块:

    class Women():
    
       def __init__(self,name):
           self.name = name
           self.__age = 18
    
        def __secret(self):
           print('%s的年龄是%d' %(self.name,self.__age))
    
    lily = Women('lily')
    print(lily.name)
    print(lily.__age)
    # lily.__secret()
    

    程序及运行结果:
    在这里插入图片描述
    注意: Python不允许实例化的类访问私有数据,但你可以使用 object._className__attrName( 对象名._类名__私有属性名 )

    单下划线、双下划线、头尾双下划线说明:

    • __ foo__: 定义的是特殊方法,一般是系统定义名字 ,类似 __ init __() 之类的。

    • _foo: 以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身与子类进行访问,不能用于 from module import *

    • __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

    展开全文
  • 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)

    展开全文
  • 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中的类属性类属性和实例属性名字冲突怎么办Python中方法也是属性Python中定义类方法 类是模板,而实例则是根据类创建的对象。 绑定在一个实例上的属性不会影响其他实例,但是,类本身也是一个对象,...
  • 类属性 类方法 属于类对象 而不是这个类某一个实例对象 该类所有实例对象共享一份 直接可以通过类名.形式进行访问 类方法第一个参数为cls cls引用类对象 @classmethod 注意不要通过 对象来对类属性进行修改...
  • 可以在Python的类定义中直接添加静态变量,如下例中的foo。此属性属于类C,可以直接通过C.foo访问,而无需实例化它。而实例属性则只存在于对象的实例中,这也就意味着,每一个不同的实例都有只属于自己的实例属性。...
  • 可以在Python的类定义中直接添加静态变量,如下例中的foo。此属性属于类C,可以直接通过C.foo访问,而无需实例化它。而实例属性则只存在于对象的实例中,这也就意味着,每一个不同的实例都有只属于自己的实例属性。 ...
  • 1. Python中类中特性分成属性和方法 属性和方法都分为私有和公有,私有只可以在本中使用外部是无法访问 2. 定义属性(成员变量)语法格式(公有属性/私有属性) class 类名: def __init__(self): self....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,437
精华内容 2,574
关键字:

python中的类属性和类方法

python 订阅