精华内容
下载资源
问答
  • 下划线说明头尾双下划线例如__init__(),定义是特殊方法,一般是系统定义名字双下划线以双下划线开头的变量类的私有变量(private),只允许这个本身访问,例如__var单下划线以单下划线开头的变量为保护类型...

    下划线说明

    头尾双下划线

    例如__init__(),定义的是特殊方法,一般是系统定义名字

    双下划线

    以双下划线开头的变量为类的私有变量(private),只允许这个类本身访问,例如__var

    单下划线

    以单下划线开头的变量为保护类型的变量(protected),只允许这个类和其子类访问

    Python不允许实例化对象访问类的私有数据,但是可以利用object._className__attr来访问属性,例如:

    >>> class MyClass():

    __var=10

    >>> c=MyClass()

    >>> c.__var

    Traceback (most recent call last):

    File "", line 1, in

    c.__var

    AttributeError: 'MyClass' object has no attribute '__var'

    >>> c._MyClass__var

    10

    >>>

    内置类属性

    __dict__ : 类的属性(包含一个字典,由类的数据属性组成)

    __doc__ :类的文档字符串

    __name__: 类名

    __module__: 类定义所在的模块(类的全名是'__main__.className',如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)

    __bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)

    >>> class MyClass():

    '这是类的文档'

    publicVar=10

    def __init__(self,varA,varB):

    self.varA='aa'

    self.varB='bb'

    def displayVar(self):

    print('varA =',self.varA)

    print('varB =',self.varB)

    print('publicVar=',MyClass.publicVar)

    >>> MyClass.__doc__ # 类的文档字符串

    '这是类的文档'

    >>> MyClass.__name__ # 类名

    'MyClass'

    >>> MyClass.__module__ # 类定义所在的模块

    '__main__'

    >>> MyClass.__bases__ # 类的父类,默认所有类继承自object类

    (,)

    >>> MyClass.__dict__ # 类的属性,返回一个字典

    mappingproxy({'__module__': '__main__', '__doc__': '这是类的文档', 'publicVar': 10, '__init__': , 'displayVar': , '__dict__': , '__weakref__': })

    >>>

    基本重载方法

    可以在自己的类中重写方法

    方法名

    描述

    __init__(self[,args..])

    构造函数

    __del__(self)

    析构函数

    __repr__(self)

    转化为供解释器读取的形式

    __str__(self)

    将值转化为适于人阅读的形式

    __cmp__ (self,x)

    对象比较

    对象销毁机制

    Python 使用了引用计数这一简单技术来跟踪和回收垃圾,当一个对象没有被引用时就会被自动释放,但是释放并不是立即的,而是解释器在合适的时机将垃圾对象的内存回收。

    >>> class MyClass():

    def __del__(self):

    print('delete this object')

    def __init__(self):

    print('init this object')

    >>> c= MyClass() # 引用为1

    init this object

    >>> b=c # 引用为2

    >>> d=b # 引用为3

    >>> del c # 引用为2

    >>> del b # 引用为1

    >>> del d # 引用为0 准备释放内存

    delete this object

    >>>

    利用内置函数访问属性

    可以使用以下函数的方式来访问属性:

    getattr(obj, name[, default]) : 访问对象的属性。

    hasattr(obj,name) : 检查是否存在一个属性。

    setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一-个新属性。

    delattr(obj, name) : 删除属性。

    hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。

    getattr(emp1, 'age') # 返回 'age' 属性的值

    setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8

    delattr(emp1, 'age') # 删除属性 'age'

    # 属性名记得加单引号,否则会认为是一个与属性名同名的变量

    展开全文
  • 成员的访问方式#!/usr/bin/env python# _*_coding:utf-8 _*_class pepole(object):'''This is __doc__ information!!!'''country = "CHINA" #静态字段 存在里__city = "BeiJing" #私有静态字段def siyou(self): ...

    类成员的访问方式

    #!/usr/bin/env python

    # _*_coding:utf-8 _*_

    class pepole(object):

    '''This is __doc__ information!!!'''

    country = "CHINA" #静态字段 存在类里

    __city = "BeiJing" #私有静态字段

    def siyou(self): #私有字段在内部设置方法可以访问

    return pepole.__city

    def __init__(self,name,age,weight):

    self.name = name

    self.age = age #普通字段,动态字段,对象字段 存在对象里

    self.weight = weight

    self.__name2 = "FUCK" #私有普通字段,通过内部间接访问,也可通过特殊方法访问

    def __call__(self, *args, **kwargs):

    print 'This is __call__!!!'

    def func(self): #括号里至少一个参数,可以多个

    print self.__name2 #内部简介访问私有字段

    return "123"

    def __infunc(self): #私有方法,通过内部简介访问

    print "This is __infunc!"

    def run_infunc(self): #通过内部间接的访问私有方法

    self.__infunc()

    @classmethod #类方法

    def class_func(cls): #括号里只能有一个参数 cls

    return "class_method"

    @staticmethod #静态方法括号里不需要参数(),可以有个多参数

    def sts():

    print "This is staticmethod"

    @staticmethod #静态的私有方法,属于类,内部间接访问

    def __static_func(): #静态方法括号里不需要参数(),可以有个多参数

    print "This is __static_func"

    def run_static(self): #简介访问静态私有方法

    pepole.__static_func()

    @property #属性把一个方法伪造成一个字段、一个属性,像字段那样的属性而不是一个功能

    def att(self): #只能有一个self参数

    return "property"

    def __str__(self):

    return "This is __str__"

    #class Son(pepole): #继承people的派生类,不能拿到父类中的私有方法或字段

    # def show(self):

    #print pepole.__city

    # pass

    obj = pepole("chenchao",18,70)

    print obj.__doc__#查看类里的注释信息

    obj() #执行__call__ 方法 在对象的后面加()

    printobj.country #执行静态字段

    print obj.name #执行字段self.name = "chenchao"

    print obj.siyou() #内部访问间接的调用私有字段 __city = "Beijing"

    print obj.func() #执行普通方法 def func(self):

    print pepole.class_func() #类方法 调用类方法 @classmethod

    pepole.sts() #调用静态方法 @staticmethod

    print obj.att #执行属性的方法,不带括号 @property

    obj.run_infunc() #执行私有方法 (间接访问) def __func_method()

    obj.run_static() #执行静态的私有方法(间接访问)

    print pepole.__dict__ #获取类的成员,即:静态字段,方法

    print obj.__dict__ #获取obj对象的成员 普通字段,私有普通字段

    print obj #类中定义了__str__方法,打印对象默认输出方法的返回值

    print str(obj) #自动去类中找__str__方法并得到返回值

    from test import pepole

    obj2 = pepole("zhangsan",22,66)

    print obj2.__module__ #表示当前操作的对象在那个模块

    print obj2.__class__ #表示当前操作的对象的类是什么

    print obj._pepole__name2 #特殊方法访问对象中的私有普通字段

    print pepole._pepole__city #特殊方法访问类中的私有静态字段

    obj._pepole__infunc() #特殊方法访问类中的私有方法

    #obj2 = Son()

    #obj2.show() #如果是继承的关系,那么派生类不能访问父类中的私有方法或私有字段

    isinstance()  issubclass()

    #!/usr/bin/env python

    # _*_coding:utf-8 _*_

    a = 10

    class A():

    print "This is class A"

    class B(A):

    print "This is class B"

    w = B()

    print isinstance(w,B) #True 判断对象w 是否是类B的对象

    print isinstance(w,A) #True 类的基类也可行

    print isinstance(a,int) #True

    print issubclass(B,A) #True 判断B是A的派生类或 A是B的基类

    print isinstance(B,int) #False

    isinstance(obj=对象, cls=类)

    检查obj是否是类 cls 的对象is instance :实例

    issubclass(sub=子类, super=父类)

    检查sub类是否是 super 类的派生类is subclass:子类

    展开全文
  • 面向过程程序设计把计算机程序视为一系列命令集合,即一组函数顺序执行。为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统复杂度。而面向对象程序设计把...

    面向对象编程

    Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。

    面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度。

    而面向对象的程序设计把计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。

    类Class:

    类是对象的模板。即类是对一组有相同数据和相同操作的对象的定义,一个类所包含的方法和数据描述一组对象的共同属性和行为。

    类是在对象之上的抽象,对象则是类的具体化,是类的实例。类可有其子类,也可有其它类,形成类层次结构。

    任何类最终都可以追溯到根类object

    对象的方法(Method)

    给对象发消息实际上就是调用对象对应的关联函数,称之为对象的方法(Method).

    综上,面向对象的设计思想是抽象出Class,根据Class创建Instance。

    面向对象的抽象程度又比函数要高,因为一个Class既包含数据,又包含操作数据的方法。

    面向对象的三大特点:数据封装、继承、多态

    类和实例

    类是抽象的模板,而实例是根据类创建出来的一个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。

    定义类,Class关键字

    (1) 关键字class

    (2) 类名:通常是大写开头的单词,如Student

    (3)(继承类):表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就是用object类,这是所有类最终都会继承的类。

    注:当我们定义一个class的时候,实际上就定义了一种数据类型。定义的class数据类型和Python自带的数据类型没什么区别,比如str, dict, list。

    创建实例:类名+()

    1 #这是最简单的定义类

    2 classStudent(object):3 pass

    4

    5 #创建一个实例

    6 bart=Student()7 print(bart)

    运行结果:

    <__main__.student object at>,变量bart指向Student的一个实例,后面的0x00000000010CC2E8是内存地址,每个object的地址都不一样。

    __init__方法

    作用:绑定属性

    注意:特殊方法“__init__”前后分别有两个下划线!!!

    1,__init__方法的第一个参数永远是self,表示创建的实例本身,在__init__方法内部,把各种属性绑定到self

    2,有了__init__方法,在创建实例的时候,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去。

    和普通函数相比,在类中定义的函数(不仅仅是__init__函数,包括后面类的方法函数,是指类中所有的定义函数),第一个参数永远是实例变量self,并且调用时,不用传递self参数

    数据封装

    类的方法

    在类的内部定义访问数据的函数,这样,就把“数据”给封装起来了,这些封装数据的函数是和类本身关联起来的,称为类的方法。

    实战

    1 classStudent(object):2

    3 def __init__(self, name, score):4 self.name =name5 self.score =score6

    7 defprint_score(self):8 print('%s: %s' %(self.name, self.score))9

    10 defget_grade(self):11 if self.score >= 90:12 return 'A'

    13 elif self.score >= 60:14 return 'B'

    15 else:16 return 'C'

    17

    18 bart = Student('Bart Simpson', 59)19 lisa = Student('Lisa Simpson', 87)20

    21 print('bart.name =', bart.name)22 print('bart.score =', bart.score)23 bart.print_score()24

    25 print('grade of Bart:', bart.get_grade())26 print('grade of Lisa:', lisa.get_grade())

    运行结果:

    变量名

    特殊变量:以双下划线开头,并且以双下划线结尾的,是特殊变量,类似__xxx__,特殊变量是可以直接访问的,不是Private变量,所以,在需要特殊变量的地方不能用__name__、__score__这样的变量名。

    私有变量(Private):有2种形式,一个下划线开头,两个下划线开头

    (1) 一个下划线开头:如_name

    这样的实例变量,外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思是:“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问。”

    (2)两个下划线开头:如__name

    双下划线开头的实例变量是不是一定不能从外部访问呢?

    答:也不是,不能直接访问__name,是因为python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量。

    但是强烈建议不要这么做,因为不同版本的Python解释器可能会把__name改成不同的变量名。

    总的来说,Python本身没有任何机制阻止你干坏事,一切全靠自觉。

    访问私有变量(Private)的方式:

    举例:

    bart=Student('bart simpon',98)

    备注:空白处相当于新增变量,不会改变score的值

    1个下划线

    2个下划线

    bart.score

    bart._score

    可以访问

    bart.__score

    bart._Student_score

    bart._Student__score

    可以访问

    备注:1,空白处相当于新增变量,不会改变score的值

    2,可以访问,说明我们可以修改私有变量的值

    3,既然已经设置成私有变量了,应尽量不要随意访问

    访问私有变量方式代码实践:

    1个下划线的代码:

    1 classStudent(object):2

    3 def __init__(self, name, score):4 self._name =name5 self._score =score6

    7 defprint_score(self):8 print('Print语句返回值:%s: %s' %(self._name, self._score))9

    10

    11 bart=Student('bart simpon',98)12

    13 print("这是1个下划线的私有变量:")14 bart.score=45

    15 print("bart.score:",bart.score)16 print("bart.print_score():",bart.print_score())17 print("")18

    19

    20 bart.__score=45

    21 print("bart.__score:",bart.__score)22 print("bart.print_score():",bart.print_score())23 print("")24

    25

    26 bart._Student_score=45

    27 print("bart._Student_score:",bart._Student_score)28 print("bart.print_score():",bart.print_score())29 print("")30

    31

    32 bart._Student__score=45

    33 print("bart._Student__score:",bart._Student__score)34 print("bart.print_score():",bart.print_score())35 print("")36

    37 bart._score=45

    38 print("bart._score:",bart._score)39 print("bart.print_score():",bart.print_score())

    一个下划线:   只有bart._score能修改_score的值

    2个下划线的代码:

    1 classStudent(object):2

    3 def __init__(self, name, score):4 self.__name =name5 self.__score =score6

    7 defprint_score(self):8 print('Print语句返回值:%s: %s' % (self.__name, self.__score))9

    10

    11

    12

    13 bart=Student('bart simpon',98)14 #print("gds",bart.print_score())

    15 print("这是2个下划线的私有变量:")16 bart.score=45

    17 print("bart.score:",bart.score)18 print("bart.print_score():",bart.print_score())19 print("")20

    21

    22 bart._score=45

    23 print("bart._score:",bart._score)24 print("bart.print_score():",bart.print_score())25 print("")26

    27

    28 bart.__score=45

    29 print("bart.__score:",bart.__score)30 print("bart.print_score():",bart.print_score())31 print("")32

    33

    34 bart._Student_score=45

    35 print("bart._Student_score:",bart._Student_score)36 print("bart.print_score():",bart.print_score())37 print("")38

    39

    40 bart._Student__score=45

    41 print("bart._Student__score:",bart._Student__score)42 print("bart.print_score():",bart.print_score())

    2个下划线:  只有bart._Student__score能修改__score的值

    如果要使内部属性不被外部访问,可以在属性名前加两个下划线__,变成私有变量,只有内部可以访问,外部不能访问。

    这样确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。

    如果外部代码要获取name和score怎么办?可以给Student类增加get_name和get_score这样的方法。

    如果外部代码要修改score怎么办?可以给Student类增加get_score方法。

    代码如下:

    1 classStudent(object):2

    3 def __init__(self, name, score):4 self.__name =name5 self.__score =score6

    7 defprint_score(self):8 print('%s: %s' % (self.__name, self.__score))9

    10 defget_name(self):11 return self.__name

    12

    13 defget_score(self):14 return self.__score

    15

    16 def set_score(self, score): #使用这种方法修改属性值,可以检查传入的参数值是否有问题

    17 if 0 <= score <= 100:18 self.__score =score19 else:20 raise ValueError('bad score')21

    22 bart = Student('Bart Simpson', 59)23 print("bart._Student__score:",bart._Student__score) #这种就运行正确了

    24

    25 print("bart.get_score():",bart.get_score())26

    27 print(bart.score) #运行结果出错,提示'Student' object has no attribute 'score'

    28

    29 #print(bart.__score) #运行结果出错,提示'Student' object has no attribute '__score'

    运行结果:

    问题:为什么一个、两个下划线的地方,print( bart.score )能运行出结果,而这最近的一段代码中print( bart.score )却报错?

    答:前者是相当于新增加了一个变量,所以能运行出结果,而后者的print( bart.score )这种访问形式是不能直接访问私有变量,所以报错,而print( bart._Student__score )却访问成功了

    参考网址:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

    展开全文
  • Python 面向对象搞懂Python、方法、变量、实例化和对象概念面向对象技术简介Python从设计之初就已经是一门面向对象语言,正因为如此,在Python中创建一个和对象是很容易。面向对象编程是在面向过程编程...

    Python 面向对象搞懂Python类、方法、变量、实例化和对象的概念

    面向对象技术简介

    Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。面向对象编程是在面向过程编程的基础上发展来的,它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭,很多初学者会因无法理解面向对象而放弃学习编程。本章节我们将详细介绍Python的面向对象编程。

    面向对象编程(Object-oriented Programming,简称 OOP),如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基本特征。

    类:用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

    对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

    属性:类中的所有变量称为属性。

    方法:类中定义的函数。不过,和函数所有不同的是,类方法至少要包含一个 self 参数。

    类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

    实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量。

    局部变量:定义在方法中的变量,只作用于当前实例的类。

    方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

    方法重载:类中支持多个同名函数,但参数的个数或类型要不同,在调用的时候,解释器会根据参数的个数或者类型,调用相应的函数.

    封装:将类的某些部分(属性、方法)隐藏起来,具有一定的保护作用,隐藏对象的属性和方法实现细节,仅对外提供公共的访问方式。

    继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

    多态:多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承).

    实例化:创建一个类的实例,类的具体对象。

    定义类

    语法格式如下:

    class 类名:

    执行语句

    类变量

    类方法

    类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性。

    类最重要的两部分就是类变量和类方法,类成员之间的可以相互调用。

    在Python中可以使用class关键字定义类,然后在类中通过之前学习过的函数来定义方法,这样就可以将对象的动态特征描述出来,代码如下所示。

    class Animal():

    # __init__用于在创建对象时进行初始化操作,通过这个方法可以绑定name和color两个属性

    def __init__(self, name, color):

    self.name = name

    self.color = color

    def play(self, action):

    print('%s正在玩%s.' % (self.name, action))

    animal = Animal("dog","black")

    animal.play("篮球")

    执行结果:

    dog正在玩篮球.

    写在类中的函数,我们通常称之为(对象的)方法,这些方法就是对象可以接收的消息。当我们定义好一个类之后,可以通过上面的方式来创建对象并调用。

    类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用,像下面这样:

    def __init__(self):

    self.data = []

    类定义了 __init__() 方法,类的实例化操作会自动调用 __init__() 方法。如下实例化类 Animal,对应的 __init__() 方法就会被调用:

    animal = Animal("dog","black")

    当然, __init__() 方法可以没有参数。

    self代表类的实例,而非类,类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

    class Animal:

    def show(self):

    print(self)

    print(self.__class__)

    animal = Animal()

    animal.show()

    执行结果:

    __main__.Animal

    从执行结果可以很明显的看出,self 代表的是类的实例,代表当前对象的地址,而 self.class 则指向类。

    self 不是 python 关键字,我们把他换成 lidihuo 也是可以正常执行的:

    class Animal():

    def show(lidihuo):

    print(lidihuo)

    print(lidihuo.__class__)

    animal = Animal()

    animal.show()

    执行结果:

    __main__.Animal

    访问权限

    对于C++、Java、C#等编程语言的属性有4种访问权限,而在在Python中,属性和方法的访问权限只有两种,也就是公开的和私有的,如果希望属性是私有的,在给属性命名时可以用两个下划线作为开头,下面看个列子。

    class Animal:

    # __init__用于在创建对象时进行初始化操作,通过这个方法可以绑定name和color两个属性

    def __init__(self, name, color):

    self.name = name

    self.color = color

    def __play(self, action):

    print('%s正在玩%s.' % (self.name, action))

    def main():

    animal = Animal("dog","black")

    animal.__play("篮球")

    if __name__ == "__main__":

    main()

    执行结果:

    Traceback (most recent call last):

    File "script.py", line 14, in

    main()

    File "script.py", line 12, in main

    animal.__play("篮球")

    AttributeError: 'Animal' object has no attribute '__play'

    在实际开发中,我们并不建议将属性设置为私有的,因为这会导致子类无法访问。但让属性名以单下划线开头来表示属性是受保护的,本类之外的代码在访问这样的属性时应该要保持慎重。

    @property装饰器

    上面我们讲到python中属性和方法访问权限,我们不建议将属性设置为私有的,但是有时直接将属性暴露给外界也是有问题的,前面我们建议将属性命名以单下划线开头,通过这种方式来暗示属性是受保护的,不建议外界直接访问,可以通过属性的getter(访问器)和setter(修改器)方法进行对应的操作。通过@property包装器来包装getter和setter方法,使得对属性的访问既安全又方便,代码如下所示。

    class Animal:

    def __init__(self, name, color):

    self.name = name

    self.color = color

    # 访问器 - getter方法

    @property

    def name(self):

    return self._name

    # 访问器 - getter方法

    @property

    def color(self):

    return self._color

    # 修改器 - setter方法

    @name.setter

    def name(self, name):

    self._name = name

    # 修改器 - setter方法

    @color.setter

    def color(self, color):

    self._color = color

    def play(self, action):

    print('%s正在玩%s.' % (self.name, action))

    def main():

    animal = Animal("dog","black")

    animal.play("篮球")

    if __name__ == "__main__":

    main()

    执行结果:

    dog正在玩篮球.

    __slots__魔法

    Python是一门动态语言,允许我们在程序运行时给对象绑定新的属性或方法,当然也可以对已经绑定的属性和方法进行解绑定。限定对象只能绑定某些属性,可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效,对子类并不起任何作用。

    class Animal:

    # 限定Person对象只能绑定_name, _color和_age属性

    __slots__ = ('_name', '_color', '_age')

    def __init__(self, name, color):

    self.name = name

    self.color = color

    # 访问器 - getter方法

    @property

    def name(self):

    return self._name

    # 访问器 - getter方法

    @property

    def color(self):

    return self._color

    # 修改器 - setter方法

    @name.setter

    def name(self, name):

    self._name = name

    # 修改器 - setter方法

    @color.setter

    def color(self, color):

    self._color = color

    def play(self, action):

    print('%s正在玩%s.' % (self.name, action))

    def main():

    animal = Animal("dog","black")

    animal.play("篮球")

    animal._age = (5)

    animal._weight = (50)

    if __name__ == "__main__":

    main()

    执行结果:

    animal._weight = (50)

    AttributeError: 'Animal' object has no attribute '_weight'

    静态方法和类方法

    @staticmethod,静态方法,通过类直接调用,不需要创建对象,不会隐式传递self

    @classmethod,类方法,方法中的self是类本身,调用方法时传的值也必须是类的公有属性,就是说类方法只能操作类本身的公有字段。

    class Animal:

    name = "Dog"

    color = "Black"

    @classmethod

    def play(self, action):

    print('%s正在玩%s.' % (self.name, action))

    @staticmethod

    def show():

    print('%s是%s的.' % (Animal.name,Animal.color))

    def main():

    animal = Animal()

    animal.play("篮球")

    Animal.show()

    if __name__ == "__main__":

    main()

    执行结果:

    Dog正在玩篮球.

    Dog是Black的.

    面向对象的支柱

    面向对象有三大支柱:封装、继承和多态。封装就是把数据和对数据的操作封装起来了,在我们创建了对象之后,只需要调用对象方法)就可以执行方法中的代码,也就是说我们只需要知道方法的名字和传入的参数,而不需要知道方法内部的实现细节。继承和多态的内容请点击下面查看

    展开全文
  • 类变量的形式访问。但是在类的内部,也可以使用self.类变量来访问,但是这个是用含义就不同了(后面使用代码验证)。 实例变量 在类的内部,实例变量self.实例变量的形式访问;在类的外部使用对象名。实例变量的形式...
  • 1、类变量、实例变量概念类变量:类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量...类变量的形式访问。但是在类的内部,也可以使用sel...
  • 关于get和set方法是干什么用的我就不多说了,这里只说一下我...如果直接将成员变量设置为public权限,那么对于该成员变量的访问和修改的控制就不再是由封装它的对象来控制的,而是由调用它的来控制,这样首先破坏了j
  • 1、类变量、实例变量概念类变量:类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量...类变量的形式访问。但是在类的内部,也可以使用sel...
  • 1、类变量、实例变量概念类变量:类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量...类变量的形式访问。但是在类的内部,也可以使用sel...
  • 1、类变量、实例变量概念类变量:类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量...类变量的形式访问。但是在类的内部,也可以使用sel...
  • 1、类变量、实例变量概念类变量:类变量就是定义在类中,但是在函数体之外的变量。通常不使用self.变量名赋值的变量。类变量通常不作为类的实例变量的,类变量...类变量的形式访问。但是在类的内部,也可以使用sel...
  • 变量

    2017-10-10 21:14:17
    关于变量的作用域: 成员变量: 的属性 局部属性: 方法中定义的变量或者是方法的形式参数. 对于java语言来说,作用域控制是通过块来控制的. 块的概念:一对{}包裹,该代码片段就成为一块. 对于某个快内定义的...
  • 从语法形式上,看成员变量是属于类的,而局部变量是在方法中定义 变量或是方法参数;成员变量可以被 public,private,static 等修饰符所 修饰,而局部变量不能被访问控制修饰符及 static 所修饰;但是,成员 变量...
  • 类的成员实例变量实例变量就是对象个体特有“数据”。#定义class Dog:def __init__(self, name, age):self.name = name #创建和初始化实例变量...实例变量形式访问print('这是我家狗,名字是%s, 现在...
  • 类的成员实例变量实例变量就是对象个体特有“数据”。#定义class Dog:def __init__(self, name, age):self.name = name #创建和初始化实例变量...实例变量形式访问print('这是我家狗,名字是%s, 现在...
  • C++编程中经常出现两个不同的类对象之间相互访问数据需要,但是成员变量不是public形式,无法直接访问相应的变量,抛开全局变量不谈,常用方法有:1封装留下接口函数、2友元机制、3静态成员变量。...
  • 私有成员变量在本中可以随意访问,但超出了类的范围就不能访问了。 要想访问私有成员变量,必须定义一对Getter/Setter方法 且方法必须以getXxx/setXxx规则命名 对于getXxx来说,不能有参数,返回值类型要与成员...
  • 成员变量

    2013-08-27 15:11:43
    方法操作所定义的数据,以及提供数据的访问的代码。大多数情况下,程序的其他部分都是通过的方法和其他的实例进行交互的。 在中,除了变量外的都是成员方法。 方法中有一种是成员变量进行初始化的,称为...
  • 因此,函数自变量可以用作临时访问令牌或功能,使被调用方可以执行某些操作,但只能在调用过程中执行。 在现代语言中,此类编程模式不再可用。 这项工作主要目的是在现代语言中与一流实体一起重新引入二等功能...
  • 还有一点就是,非成员函数不可以访问类里面私有成员,包括变量和函数,友员函数出外。一个里面成员函数 也不可以访问的类里面私有成员,因为他们对于别的类而言就是非成员函数。公有成员是可以访问的。...
  • <br />protected 这个就是可以在本包中被其它类访问,如果不在本包中,则只能在其子类中被子 <br /> 类的对访问 <br />private 只能在本中使用,不能在其它或其它包中使用 <br />...
  • 实例变量和属性

    千次阅读 2014-12-17 11:46:30
    概要  在开发IOS中,发现自己属性和实例变量存在一定困惑,所以今天花了时间查资料以及做实验,...实例变量如果可以访问,需要使用指针访问形式(当然因为访问实例是一个指针)。正常情况下,属性和实例变量
  • 类的再剖析

    2021-03-24 13:50:41
    类的再剖析explicit关键字应用和实现static成员变量特点访问形式友元函数分析与实现友元声明友元写法与分析 explicit关键字 构造函数不仅可以构造与初始化对象,对于单个参数构造函数,还具有类型转换...
  • book.i只能通过这种形式访问但是把i弄成静态就可以直接Book.i内部也一样 上面肯定不能直接访问Book.Book1那又怎么能访问Book.Book1.i呢?他定义了这个i为静态,那肯定应该是支持直接通过类名来访问的,但是...
  • java类的设计技巧

    2010-09-27 09:31:20
    1)一定将数据设计为私有。...当数据保持私有时,他们表示形式的变化不会对类的使用者产生影响,即使出现bug也易于检测。 2)一定要对数据初始化。 java不对局部变量进行初始化,但是会对对象实例域...
  • 一个java可以产生n个属于此类型对象(实例),java是创建java对象模板,java对象是java类的具体表现形式,java是一个抽象表现。 运行对象访问对象里内容称为封装。 创建 创建对象 允许perObject引用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 776
精华内容 310
关键字:

对类变量的访问形式