开发者社区> shadowcat> 正文

简明Python教程学习笔记_6_面向对象编程

简介: 简介 类和对象是面向对象编程的两个主要方面。类创建一个新类型,而对象这个类的 实例 。这类似于你有一个int类型的变量,这存储整数的变量是int类的实例(对象)。 类(Class)::用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 对象:          通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量
+关注继续查看

简介

类和对象是面向对象编程的两个主要方面。创建一个新类型,而对象这个类的 实例 。这类似于你有一个int类型的变量,这存储整数的变量是int类的实例(对象)。

类(Class)::用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
对象:          通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
实例化:      创建一个类的实例,类的具体对象。
方法:          类中定义的函数。
(方法和函数在python中是不同的概念,方法是类定义的函数,在类中的函数才叫方法。函数是就是一般的函数)
数据成员:  类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重载:  如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),重载。
实例变量:  定义在方法中的变量,只作用于当前实例的类。
类变量:      类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

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

给C/C++/Java/C#程序员的注释

注意,即便是整数也被作为对象(属于int类)。这和C++、Java(1.5版之前)把整数纯粹作为类型是不同的。通过help(int)了解更多这个类的详情。 C#和Java 1.5程序员会熟悉这个概念,因为它类似与封装与解封装 的概念。

对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性

域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量类变量

类使用class关键字创建。类的域和方法被列在一个缩进块中。

在Python类中定义的方法通常有三种:实例方法、类方法、静态方法
这三者之间的区别是:

实例方法:一般都以self作为第一个参数,必须和具体的对象实例进行绑定才能访问,
类方法    :以cls作为第一个参数,cls表示类本身,定义时使用@classmethod,那么通过cls引用的必定是类对象的属性和方法;
静态方法:不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod,静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用。


而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析)

不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。

可以直接在类外通过对象名访问,如果想定义成私有的,则需在前面加2个下划线 ' __'
构造方法__init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法.
构造方法支持重载,如果用户自己没有重新定义构造方法,系统就自动执行默认的构造方法。
析构方法__del__(self)在释放对象时调用,支持重载,可以在里面进行一些释放资源的操作,不需要显示调用。

创建实例对象

要创建一个类的实例,你可以使用类的名称,并通过__init__方法接受参数。
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

访问属性

使用点(.)来访问对象的属性。使用如下类的名称访问类变量:
emp1.displayEmployee()
你可以添加,删除,修改类的属性,如下所示:
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性。
delattr(obj, name) : 删除属性。

Python内置类属性

__dict__ : 类的属性(包含一个字典,由类的数据属性组成)
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块(类的全名是'__main__.className',
如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)
__bases__ : 类的所有父类构成元素(包含了以个由所有父类组成的元组)

python对象销毁(垃圾回收)

在Python内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量,称为一个引用计数器。当对象被创建时, 就创建了一个引用计数, 当这个对象不再需要时, 
也就是说, 这个对象的引用计数变为0 时,它被垃圾回收。但是回收不是"立即"的, 
由解释器在适当的时机,将垃圾对象占用的内存空间回收。

self

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,但是在调用这个方法的时候你为这个参数赋值,Python会提供这个值。这个特别的变量指对象本身,按照惯例它的名称是self

虽然你可以给这个参数任何名称,但是 强烈建议 你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它,如果使用self的话,还有些IDE(集成开发环境)也可以帮助你。

给C++/Java/C#程序员的注释
Python中的self等价于C++中的self指针和Java、C#中的this参考。

你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候,这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。

这也意味着如果你有一个不需要参数的方法,你还是得给这个方法定义一个self参数。

创建一个类

#!/usr/bin/python
# Filename: simplestclass.py

class Person:
    pass # An empty block

p = Person()
print p
输出
$ python simplestclass.py
<__main__.Person instance at 0xf6fcb18c>

它如何工作

我们使用class语句后跟类名,创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中,我们使用了一个空白块,它由pass语句表示。

接下来,我们使用类名后跟一对圆括号来创建一个对象/实例。(我们将在下面的章节中学习更多的如何创建实例的方法)。为了验证,我们简单地打印了这个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。

可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值,因为Python可以在任何空位存储对象。

使用对象的方法

#!/usr/bin/python
# Filename: method.py

class Person:
    def sayHi(self):
        print 'Hello, how are you?'

p = Person()
p.sayHi()
# This short example can also be written as Person().sayHi()

输出
$ python method.py
Hello, how are you?

它如何工作

这里我们看到了self的用法。注意sayHi方法没有任何参数,但仍然在函数定义时有self

__init__方法

在Python的类中有很多方法的名字有特殊的重要意义。现在我们将学习__init__方法的意义。

__init__方法在类的一个对象被建立时,马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。注意,这个名称的开始和结尾都是双下划线__init__方法

#!/usr/bin/python
# Filename: class_init.py

class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name

p = Person('Swaroop')
p.sayHi()

# This short example can also be written as Person('Swaroop').sayHi()

输出
$ python class_init.py
Hello, my name is Swaroop

它如何工作

这里,我们把__init__方法定义为取一个参数name(以及普通的参数self)。在这个__init__里,我们只是创建一个新的域,也称为name。注意它们是两个不同的变量,尽管它们有相同的名字。点号使我们能够区分它们。

最重要的是,我们没有专门调用__init__方法,只是在创建一个类的新实例的时候,把参数包括在圆括号内跟在类名后面,从而传递给__init__方法。

现在,我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。

给C++/Java/C#程序员的注释
__init__方法类似于C++、C#和Java中的 constructor 。 

类与对象的方法

已经讨论了类与对象的功能部分,现在来看一下它的数据部分。事实上,它们只是与类和对象的名称空间 绑定 的普通变量,即这些名称只在这些类与对象的前提下有效。

有两种类型的 域 ——类的变量和对象的变量,它们根据是类还是对象 拥有 这个变量而区分。

类的变量 由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。通过一个例子会使这个易于理解。

使用类与对象的变量

#!/usr/bin/python
# Filename: objvar.py

class Person:
    '''Represents a person.'''
    population = 0

    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name

        # When this person is created, he/she
        # adds to the population
        Person.population += 1

    def __del__(self):
        '''I am dying.'''
        print '%s says bye.' % self.name

        Person.population -= 1

        if Person.population == 0:
            print 'I am the last one.'
        else:
            print 'There are still %d people left.'% Person.population

    def sayHi(self):
        '''Greeting by the person.

        Really, that's all it does.'''
        print 'Hi, my name is %s.' % self.name

    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.'% Person.population

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()

swaroop.sayHi()
swaroop.howMany()
输出

$ python objvar.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

它如何工作

这里,population属于Person类,因此是一个类的变量。name变量属于对象(它使用self赋值)因此是对象的变量。

观察可以发现__init__方法用一个名字来初始化Person实例。在这个方法中,我们让population增加1,这是因为我们增加了一个人。同样可以发现,self.name的值根据每个对象指定,这表明了它作为对象的变量的本质。

记住,你能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。

在这个程序中,我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__Person.sayHi.__doc__来分别访问类与方法的文档字符串。

就如同__init__方法一样,还有一个特殊的方法__del__,它在对象消逝的时候被调用。对象消逝即对象不再被使用,它所占用的内存将返回给系统作它用。在这个方法里面,我们只是简单地把Person.population1

当对象不再被使用时,__del__方法运行,但很难保证这个方法究竟在 什么时候 运行。如果你想要指明它的运行,你就得使用del语句,就如同以前的例子中使用的那样。

给C++/Java/C#程序员的注释
Python中所有的类成员(包括数据成员)都是 公共的 ,所有的方法都是 有效的 。
只有一个例外:如果你使用的数据成员名称以 双下划线前缀 比如__privatevar,Python的名称管理体系会有效地把它作为私有变量。
这样就有一个惯例,如果某个变量只想在类或对象中使用,就应该以单下划线前缀。而其他的名称都将作为公共的,可以被其他类/对象使用。记住这只是一个惯例,并不是Python所要求的(与双下划线前缀不同)。
同样,注意__del__方法与 destructor 的概念类似。 

继承

面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的类型和子类型 关系。

假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性,比如姓名、年龄和地址。他们也有专有的属性,比如教师的薪水、课程和假期,学生的成绩和学费。

你可以为教师和学生建立两个独立的类来处理它们,但是这样做的话,如果要增加一个新的共有属性,就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。

一个比较好的方法是创建一个共同的类称为SchoolMember然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型(类)的子类型,然后我们再为这些子类型添加专有的属性。

使用这种方法有很多优点。如果我们增加/改变了SchoolMember中的任何功能,它会自动地反映到子类型之中。例如,你要为教师和学生都增加一个新的身份证域,那么你只需简单地把它加到SchoolMember类中。然而,在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember对象来使用,这在某些场合特别有用,比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型,即对象可以被视作是父类的实例,这种现象被称为多态现象

另外,我们会发现在 重用 父类的代码的时候,我们无需在不同的类中重复它。而如果我们使用独立的类的话,我们就不得不这么做了。

在上述的场合中,SchoolMember类被称为 基本类 或 超类 。而TeacherStudent类被称为导出类 或子类 。

现在,我们将学习一个例子程序。

使用继承

#!/usr/bin/python
# Filename: inherit.py

class SchoolMember:
  '''Represents any school member.'''
  def __init__(self, name, age):
    self.name = name
    self.age = age
    print '(Initialized SchoolMember: %s)'% self.name

  def tell(self):
    '''Tell my details.'''
    print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):
  '''Represents a teacher.'''
  def __init__(self, name, age, salary):
    SchoolMember.__init__(self, name, age)
    self.salary = salary
    print '(Initialized Teacher: %s)'% self.name

  def tell(self):
    SchoolMember.tell(self)
    print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
  '''Represents a student.'''
  def __init__(self, name, age, marks):
    SchoolMember.__init__(self, name, age)
    self.marks = marks
    print '(Initialized Student: %s)'% self.name

  def tell(self):
    SchoolMember.tell(self)
    print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40,30000)
s = Student('Swaroop', 22,75)

print # prints a blank line

members = [t, s]
for member in members:
  member.tell() # works for both Teachers and Students

输出
$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"

它如何工作

为了使用继承,我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后,我们注意到基本类的__init__方法专门使用self变量调用,这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基本类的constructor,你得亲自专门调用它。

我们还观察到我们在方法调用之前加上类名称前缀,然后把self变量及其他参数传递给它。

注意,在我们使用SchoolMember类的tell方法的时候,我们把TeacherStudent的实例仅仅作为SchoolMember的实例。

另外,在这个例子中,我们调用了子类型的tell方法,而不是SchoolMember类的tell方法。可以这样来理解,Python总是首先查找对应类型的方法,在这个例子中就是如此。如果它不能在导出类中找到对应的方法,它才开始到基本类中逐个查找。基本类是在类定义的时候,在元组之中指明的。

一个术语的注释——如果在继承元组中列了一个以上的类,那么它就被称作 多重继承 。

继承语法 :
class 派生类名(基类名)://... 基类名写作括号里,基本类是在类定义的时候,在元组之中指明的。
在python中继承中的一些特点:
1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。
2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。
   (先在本类中查找调用的方法,找不到才去基类中找)。 如果在继承元组中列了一个以上的类,那么它就被称作"多重继承" 。
语法:
派生类的声明,与他们的父类类似,继承的基类列表跟在类名之后,如下所示:
class SubClassName (ParentClass1[, ParentClass2, ...]):
    'Optional class documentation string'
    class_suite
#coding=utf-8
#!/usr/bin/python
class Parent: # 定义父类
    parentAttr = 100
    def __init__(self):
        print "调用父类构造函数"
    def parentMethod(self):
        print '调用父类方法'
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print "父类属性 :", Parent.parentAttr
        
class Child(Parent): # 定义子类
    def __init__(self):
        print "调用子类构造方法"
    def childMethod(self):
        print '调用子类方法 child method'
        
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法
以上代码执行结果如下:
调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200
你可以继承多个类
class A: # 定义类 A
    .....
class B: # 定义类 B
    .....
class C(A, B): # 继承类 A 和 B
    .....
你可以使用issubclass()或者isinstance()方法来检测。
issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类,语法:issubclass(sub,sup)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
方法重写
如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法:
实例:
#coding=utf-8
#!/usr/bin/python
class Parent: # 定义父类
    def myMethod(self):
        print '调用父类方法'
        
class Child(Parent): # 定义子类
def myMethod(self):
    print '调用子类方法'
    
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
执行以上代码输出结果如下:
调用子类方法
基础重载方法
下表列出了一些通用的功能,你可以在自己的类重写:
序号  方法,                          描述 & 简单的调用
1     __init__ ( self [,args...] )   构造函数  简单的调用方法: obj = className(args)
2     __del__( self )                析构方法, 删除一个对象  简单的调用方法 : dell obj
3     __repr__( self )               转化为供解释器读取的形式  简单的调用方法 : repr(obj)
4     __str__( self )                用于将值转化为适于人阅读的形式  简单的调用方法 : str(obj)
5     __cmp__ ( self, x )            对象比较   简单的调用方法 : cmp(obj, x)   运算符重载
Python同样支持运算符重载,实例如下:
#!/usr/bin/python
class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)
    def __add__(self,other):
        return Vector(self.a + other.a, self.b + other.b)


v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
以上代码执行结果如下所示:
Vector(7,8)
类属性与方法
  类的私有属性

    __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。
    在类内部的方法中使用时 self.__private_attrs。
  类的方法
    在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数
  类的私有方法
    __private_method: 两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 slef.__private_methods
#coding=utf-8
#!/usr/bin/python
class JustCounter:
    __secretCount = 0 # 私有变量
    publicCount = 0 # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print self.__secretCount
        
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错,实例不能访问私有变量
Python 通过改变名称来包含类名:
1 2 2
Traceback (most recent call last):
File "test.py", line 17, in <module>
print counter.__secretCount # 报错,实例不能访问私有变量
AttributeError: JustCounter instance has no attribute '__secretCount'
Python不允许实例化的类访问私有数据,但你可以使用 object._className__attrName 访问属性,将如下代码替
换以上代码的最后一行代码:
.........................
print counter._JustCounter__secretCount
执行以上代码,执行结果如下:
1 2 2 2



 抽象是隐藏多余细节的艺术。在面向对象的概念中,抽象的直接表现形式通常为类。虽然Python是解释性语言,但是它是面向对象的,从设计之初就已经是一门面向对象的语言。Python基本上提供了面向对象编程语言的所有元素,如果你已经至少掌握了一门面向对象语言,那么利用Python进行面向对象程序设计将会相当容易。下面就来了解一下如何在Python中进行对象编程。


一. 如何定义一个类


  在进行python面向对象编程之前,先来了解几个术语:类,类对象,实例对象,属性,函数和方法。

  类是对现实世界中一些事物的封装,定义一个类可以采用下面的方式来定义:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class className:  
  2.     block  
  注意类名后面有个冒号,在block块里面就可以定义属性和方法了。当一个类定义完之后,就产生了一个类对象。类对象支持两种操作:引用和实例化。引用操作是通过类对象去调用类中的属性或者方法,而实例化是产生出一个类对象的实例,称作实例对象。比如定义了一个people类:
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     name = 'jack'       #定义了一个属性  
  3.     #定义了一个方法  
  4.     def printName(self):  
  5.         print self.name  

  people类定义完成之后就产生了一个全局的类对象,可以通过类对象来访问类中的属性和方法了。当通过people.name(至于为什么可以直接这样访问属性后面再解释,这里只要理解类对象这个概念就行了)来访问时,people.name中的people称为类对象,这点和C++中的有所不同。当然还可以进行实例化操作,p=people( ),这样就产生了一个people的实例对象,此时也可以通过实例对象p来访问属性或者方法了(p.name).

  理解了类、类对象和实例对象的区别之后,我们来了解一下Python中属性、方法和函数的区别。

  在上面代码中注释的很清楚了,name是一个属性,printName( )是一个方法,与某个对象进行绑定的函数称作为方法。一般在类里面定义的函数与类对象或者实例对象绑定了,所以称作为方法;而在类外定义的函数一般没有同对象进行绑定,就称为函数。


二. 属性


  在类中我们可以定义一些属性,比如:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     name = 'jack'  
  3.     age = 12  
  4.   
  5. p = people()  
  6. print p.name,p.age  
  定义了一个people类,里面定义了name和age属性,默认值分别为'jack'和12。在定义了类之后,就可以用来产生实例化对象了,这句p = people( )实例化了一个对象p,然后就可以通过p来读取属性了。这里的name和age都是公有的,可以直接在类外通过对象名访问,如果想定义成私有的,则需在前面加2个下划线 ' __'。
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     __name = 'jack'  
  3.     __age = 12  
  4.   
  5. p = people()  
  6. print p.__name,p.__age  
  这段程序运行会报错:
[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. Traceback (most recent call last):  
  2.   File "C:/PycharmProjects/FirstProject/oop.py", line 6, in <module>  
  3.     print p.__name,p.__age  
  4. AttributeError: people instance has no attribute '__name  

  提示找不到该属性,因为私有属性是不能够在类外通过对象名来进行访问的。在Python中没有像C++中public和private这些关键字来区别公有属性和私有属性,它是以属性命名方式来区分,如果在属性名前面加了2个下划线'__',则表明该属性是私有属性,否则为公有属性(方法也是一样,方法名前面加了2个下划线的话表示该方法是私有的,否则为公有的)。


三. 方法


  在类中可以根据需要定义一些方法,定义方法采用def关键字,在类中定义的方法至少会有一个参数,,一般以名为'self'的变量作为该参数(用其他名称也可以),而且需要作为第一个参数。下面看个例子:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     __name = 'jack'  
  3.     __age = 12  
  4.   
  5.     def getName(self):  
  6.         return self.__name  
  7.     def getAge(self):  
  8.         return self.__age  
  9.   
  10. p = people()  
  11. print p.getName(),p.getAge()  

  如果对self不好理解的话,可以把它当做C++中类里面的this指针一样理解,就是对象自身的意思,在用某个对象调用该方法时,就将该对象作为第一个参数传递给self。


四. 类中内置的方法


  在Python中有一些内置的方法,这些方法命名都有比较特殊的地方(其方法名以2个下划线开始然后以2个下划线结束)。类中最常用的就是构造方法和析构方法。

  构造方法__init__(self,....):在生成对象时调用,可以用来进行一些初始化操作,不需要显示去调用,系统会默认去执行。构造方法支持重载,如果用户自己没有重新定义构造方法,系统就自动执行默认的构造方法。

  析构方法__del__(self):在释放对象时调用,支持重载,可以在里面进行一些释放资源的操作,不需要显示调用。

  还有其他的一些内置方法,比如 __cmp__( ), __len( )__等。下面是常用的内置方法:

 内置方法  说明
 __init__(self,...)  初始化对象,在创建新对象时调用
 __del__(self)  释放对象,在对象被删除之前调用
 __new__(cls,*args,**kwd)  实例的生成操作
 __str__(self)  在使用print语句时被调用
 __getitem__(self,key)  获取序列的索引key对应的值,等价于seq[key]
 __len__(self)  在调用内联函数len()时被调用
 __cmp__(stc,dst)  比较两个对象src和dst
 __getattr__(s,name)  获取属性的值
 __setattr__(s,name,value)  设置属性的值
 __delattr__(s,name)  删除name属性
 __getattribute__()  __getattribute__()功能与__getattr__()类似
 __gt__(self,other)  判断self对象是否大于other对象
 __lt__(slef,other)  判断self对象是否小于other对象
 __ge__(slef,other)  判断self对象是否大于或者等于other对象
 __le__(slef,other)  判断self对象是否小于或者等于other对象
 __eq__(slef,other)  判断self对象是否等于other对象
 __call__(self,*args)  把实例对象作为函数调用
  __init__():__init__方法在类的一个对象被建立时,马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意,这个名称的开始和结尾都是双下划线。代码例子:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # Filename: class_init.py  
  2. class Person:  
  3.     def __init__(self, name):  
  4.         self.name = name  
  5.     def sayHi(self):  
  6.         print 'Hello, my name is'self.name  
  7.   
  8. p = Person('Swaroop')  
  9. p.sayHi()  
  10.   
  11. 输出:  
  12. Hello, my name is Swaroop  
  __new__():__new__()在__init__()之前被调用,用于生成实例对象。利用这个方法和类属性的特性可以实现设计模式中的单例模式。单例模式是指创建唯一对象吗,单例模式设计的类只能实例化一个对象。
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class Singleton(object):  
  4.     __instance = None                       # 定义实例  
  5.   
  6.     def __init__(self):  
  7.         pass  
  8.   
  9.     def __new__(cls, *args, **kwd):         # 在__init__之前调用  
  10.         if Singleton.__instance is None:    # 生成唯一实例  
  11.             Singleton.__instance = object.__new__(cls, *args, **kwd)  
  12.         return Singleton.__instance  
  __getattr__()、__setattr__()和__getattribute__():当读取对象的某个属性时,python会自动调用__getattr__()方法。例如,fruit.color将转换为fruit.__getattr__(color)。当使用赋值语句对属性进行设置时,python会自动调用__setattr__()方法。__getattribute__()的功能与__getattr__()类似,用于获取属性的值。但是__getattribute__()能提供更好的控制,代码更健壮。注意,python中并不存在__setattribute__()方法。代码例子:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class Fruit(object):  
  4.     def __init__(self, color="red", price=0):  
  5.         self.__color = color  
  6.         self.__price = price  
  7.   
  8.     def __getattribute__(self, item):              # <span style="font-family:宋体;font-size:12px;">获取属性的方法</span>  
  9.         return object.__getattribute__(self, item)  
  10.   
  11.     def __setattr__(self, key, value):  
  12.         self.__dict__[key] = value  
  13.   
  14. if __name__ == "__main__":  
  15.     fruit = Fruit("blue"10)  
  16.     print fruit.__dict__.get("_Fruit__color")    # <span style="font-family:宋体;font-size:12px;">获取color属性</span>  
  17.     fruit.__dict__["_Fruit__price"] = 5  
  18.     print fruit.__dict__.get("_Fruit__price")    # <span style="font-family:宋体;font-size:12px;">获取price属性</span>  

  Python不允许实例化的类访问私有数据,但你可以使用object._className__attrName访问这些私有属性。

  __getitem__():如果类把某个属性定义为序列,可以使用__getitem__()输出序列属性中的某个元素.假设水果店中销售多钟水果,可以通过__getitem__()方法获取水果店中的没种水果。代码例子:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class FruitShop:  
  4.      def __getitem__(self, i):      # 获取水果店的水果  
  5.          return self.fruits[i]        
  6.   
  7. if __name__ == "__main__":  
  8.     shop = FruitShop()  
  9.     shop.fruits = ["apple""banana"]  
  10.     print shop[1]  
  11.     for item in shop:               # 输出水果店的水果  
  12.         print item,  
  输出:

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. banana  
  2. apple banana  
  __str__():__str__()用于表示对象代表的含义,返回一个字符串.实现了__str__()方法后,可以直接使用print语句输出对象,也可以通过函数str()触发__str__()的执行。这样就把对象和字符串关联起来,便于某些程序的实现,可以用这个字符串来表示某个类。代码例子:
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class Fruit:       
  4.     '''''Fruit类'''               #为Fruit类定义了文档字符串  
  5.     def __str__(self):          # 定义对象的字符串表示  
  6.         return self.__doc__  
  7.   
  8. if __name__ == "__main__":  
  9.     fruit = Fruit()  
  10.     print str(fruit)            # 调用内置函数str()触发__str__()方法,输出结果为:Fruit类  
  11.     print fruit                 #直接输出对象fruit,返回__str__()方法的值,输出结果为:Fruit类  
  __call__():在类中实现__call__()方法,可以在对象创建时直接返回__call__()的内容。使用该方法可以模拟静态方法。代码例子:
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class Fruit:  
  4.     class Growth:        # 内部类  
  5.         def __call__(self):  
  6.             print "grow ..."  
  7.   
  8.     grow = Growth()      # 调用Growth(),此时将类Growth作为函数返回,即为外部类Fruit定义方法grow(),grow()将执行__call__()内的代码  
  9. if __name__ == '__main__':  
  10.     fruit = Fruit()  
  11.     fruit.grow()         # 输出结果:grow ...  
  12.     Fruit.grow()         # 输出结果:grow ...  


五. 类属性、实例属性、类方法、实例方法以及静态方法


  在了解了类基本的东西之后,下面看一下python中这几个概念的区别。

  先来谈一下类属性和实例属性

  在前面的例子中我们接触到的就是类属性,顾名思义,类属性就是类对象所拥有的属性,它被所有类对象的实例对象所共有,在内存中只存在一个副本,这个和C++中类的静态成员变量有点类似。对于公有的类属性,在类外可以通过类对象和实例对象访问。

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     name = 'jack'  #公有的类属性  
  3.     __age = 12     #私有的类属性  
  4.   
  5. p = people()  
  6.   
  7. print p.name             #正确  
  8. print people.name        #正确  
  9. print p.__age            #错误,不能在类外通过实例对象访问私有的类属性  
  10. print people.__age       #错误,不能在类外通过类对象访问私有的类属性  
  实例属性是不需要在类中显示定义的,比如:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     name = 'jack'  
  3.   
  4. p = people()  
  5. p.age =12  
  6. print p.name    #正确  
  7. print p.age     #正确  
  8.   
  9. print people.name    #正确  
  10. print people.age     #错误  
  在类外对类对象people进行实例化之后,产生了一个实例对象p,然后p.age = 12这句给p添加了一个实例属性age,赋值为12。这个实例属性是实例对象p所特有的,注意,类对象people并不拥有它(所以不能通过类对象来访问这个age属性)。当然还可以在实例化对象的时候给age赋值。

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     name = 'jack'  
  3.       
  4.     #__init__()是内置的构造方法,在实例化对象时自动调用  
  5.     def __init__(self,age):  
  6.         self.age = age  
  7.   
  8. p = people(12)  
  9. print p.name    #正确  
  10. print p.age     #正确  
  11.   
  12. print people.name    #正确  
  13. print people.age     #错误  
  如果需要在类外修改类属性,必须通过类对象去引用然后进行修改。如果通过实例对象去引用,会产生一个同名的实例属性,这种方式修改的是实例属性,不会影响到类属性,并且之后如果通过实例对象去引用该名称的属性,实例属性会强制屏蔽掉类属性,即引用的是实例属性,除非删除了该实例属性。
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     country = 'china'  
  3.       
  4.   
  5. print people.country  
  6. p = people()  
  7. print p.country  
  8. p.country = 'japan'   
  9. print p.country      #实例属性会屏蔽掉同名的类属性  
  10. print people.country  
  11. del p.country    #删除实例属性  
  12. print p.country  

  下面来看一下类方法、实例方法和静态方法的区别。

  类方法:是类对象所拥有的方法,需要用修饰器"@classmethod"来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以"cls"作为第一个参数(当然可以用其他名称的变量作为其第一个参数,但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),能够通过实例对象和类对象去访问。

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     country = 'china'  
  3.       
  4.     #类方法,用classmethod来进行修饰  
  5.     @classmethod  
  6.     def getCountry(cls):  
  7.         return cls.country  
  8.   
  9. p = people()  
  10. print p.getCountry()    #可以用过实例对象引用  
  11. print people.getCountry()    #可以通过类对象引用  

  类方法还有一个用途就是可以对类属性进行修改:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     country = 'china'  
  3.       
  4.     #类方法,用classmethod来进行修饰  
  5.     @classmethod  
  6.     def getCountry(cls):  
  7.         return cls.country  
  8.          
  9.     @classmethod  
  10.     def setCountry(cls,country):  
  11.         cls.country = country  
  12.           
  13.   
  14. p = people()  
  15. print p.getCountry()    #可以用过实例对象引用  
  16. print people.getCountry()    #可以通过类对象引用  
  17.   
  18. p.setCountry('japan')     
  19.   
  20. print p.getCountry()     
  21. print people.getCountry()  

  运行结果:

[plain] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. china  
  2. china  
  3. japan  
  4. japan  

  结果显示在用类方法对类属性修改之后,通过类对象和实例对象访问都发生了改变。

  实例方法:在类中最常定义的成员方法,它至少有一个参数并且必须以实例对象作为其第一个参数,一般以名为'self'的变量作为第一个参数(当然可以以其他名称的变量作为第一个参数)。在类外实例方法只能通过实例对象去调用,不能通过其他方式去调用。

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     country = 'china'  
  3.       
  4.     #实例方法  
  5.     def getCountry(self):  
  6.         return self.country  
  7.           
  8.   
  9. p = people()  
  10. print p.getCountry()         #正确,可以用过实例对象引用  
  11. print people.getCountry()    #错误,不能通过类对象引用实例方法  
  静态方法:需要通过修饰器"@staticmethod"来进行修饰,静态方法不需要多定义参数。
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class people:  
  2.     country = 'china'  
  3.      
  4.     @staticmethod  
  5.     #静态方法  
  6.     def getCountry():  
  7.         return people.country  
  8.           
  9.   
  10. print people.getCountry()  

  对于类属性和实例属性,如果在类方法中引用某个属性,该属性必定是类属性,而如果在实例方法中引用某个属性(不作更改),并且存在同名的类属性,此时若实例对象有该名称的实例属性,则实例属性会屏蔽类属性,即引用的是实例属性,若实例对象没有该名称的实例属性,则引用的是类属性;如果在实例方法更改某个属性,并且存在同名的类属性,此时若实例对象有该名称的实例属性,则修改的是实例属性,若实例对象没有该名称的实例属性,则会创建一个同名称的实例属性。想要修改类属性,如果在类外,可以通过类对象修改,如果在类里面,只有在类方法中进行修改。

  从类方法和实例方法以及静态方法的定义形式就可以看出来,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用。


六. 继承和多重继承


  上面谈到了类的基本定义和使用方法,这只体现了面向对象编程的三大特点之一:封装。下面就来了解一下另外两大特征:继承和多态。

  在Python中,如果需要的话,可以让一个类去继承一个类,被继承的类称为父类或者超类、也可以称作基类,继承的类称为子类。并且Python支持多继承,能够让一个子类有多个父类。

  Python中类的继承定义基本形式如下:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. #父类  
  2. class superClassName:  
  3.     block  
  4.   
  5. #子类  
  6. class subClassName(superClassName):  
  7.     block  
  在定义一个类的时候,可以在类名后面紧跟一对括号,在括号中指定所继承的父类,如果有多个父类,多个父类名之间用逗号隔开。以大学里的学生和老师举例,可以定义一个父类UniversityMember,然后类Student和类Teacher分别继承类UniversityMember:
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. class UniversityMember:  
  4.   
  5.     def __init__(self,name,age):  
  6.         self.name = name  
  7.         self.age = age  
  8.   
  9.     def getName(self):  
  10.         return self.name  
  11.   
  12.     def getAge(self):  
  13.         return self.age  
  14.   
  15. class Student(UniversityMember):  
  16.   
  17.     def __init__(self,name,age,sno,mark):  
  18.         UniversityMember.__init__(self,name,age)     #注意要显示调用父类构造方法,并传递参数self  
  19.         self.sno = sno  
  20.         self.mark = mark  
  21.   
  22.     def getSno(self):  
  23.         return self.sno  
  24.   
  25.     def getMark(self):  
  26.         return self.mark  
  27.   
  28.   
  29.   
  30. class Teacher(UniversityMember):  
  31.   
  32.     def __init__(self,name,age,tno,salary):  
  33.         UniversityMember.__init__(self,name,age)  
  34.         self.tno = tno  
  35.         self.salary = salary  
  36.   
  37.     def getTno(self):  
  38.         return self.tno  
  39.   
  40.     def getSalary(self):  
  41.         return self.salary  

  在大学中的每个成员都有姓名和年龄,而学生有学号和分数这2个属性,老师有教工号和工资这2个属性,从上面的代码中可以看到:

  1)在Python中,如果父类和子类都重新定义了构造方法__init( )__,在进行子类实例化的时候,子类的构造方法不会自动调用父类的构造方法,必须在子类中显示调用。

  2)如果需要在子类中调用父类的方法,需要以”父类名.方法“这种方式调用,以这种方式调用的时候,注意要传递self参数过去。

  对于继承关系,子类继承了父类所有的公有属性和方法,可以在子类中通过父类名来调用,而对于私有的属性和方法,子类是不进行继承的,因此在子类中是无法通过父类名来访问的。

  Python支持多重继承。对于多重继承,比如

  class SubClass(SuperClass1,SuperClass2)

  此时有一个问题就是如果SubClass没有重新定义构造方法,它会自动调用哪个父类的构造方法?这里记住一点:以第一个父类为中心。如果SubClass重新定义了构造方法,需要显示去调用父类的构造方法,此时调用哪个父类的构造方法由你自己决定;若SubClass没有重新定义构造方法,则只会执行第一个父类的构造方法。并且若SuperClass1和SuperClass2中有同名的方法,通过子类的实例化对象去调用该方法时调用的是第一个父类中的方法。


七. 多态


  多态即多种形态,在运行时确定其状态,在编译阶段无法确定其类型,这就是多态。Python中的多态和Java以及C++中的多态有点不同,Python中的变量是弱类型的,在定义时不用指明其类型,它会根据需要在运行时确定变量的类型(个人觉得这也是多态的一种体现),并且Python本身是一种解释性语言,不进行预编译,因此它就只在运行时确定其状态,故也有人说Python是一种多态语言。在Python中很多地方都可以体现多态的特性,比如内置函数len(object),len函数不仅可以计算字符串的长度,还可以计算列表、元组等对象中的数据个数,这里在运行时通过参数类型确定其具体的计算过程,正是多态的一种体现。这有点类似于函数重载(一个编译单元中有多个同名函数,但参数不同),相当于为每种类型都定义了一个len函数。这是典型的多态表现。有些朋友提出Python不支持多态,我是完全不赞同的。

  本质上,多态意味着可以对不同的对象使用同样的操作,但它们可能会以多种形态呈现出结果。len(object)函数就体现了这一点。在C++、Java、C#这种编译型语言中,由于有编译过程,因此就鲜明地分成了运行时多态和编译时多态。运行时多态是指允许父类指针或名称来引用子类对象,或对象方法,而实际调用的方法为对象的类类型方法,这就是所谓的动态绑定。编译时多态有模板或范型、方法重载(overload)、方法重写(override)等。而Python是动态语言,动态地确定类型信息恰恰体现了多态的特征。在Python中,任何不知道对象到底是什么类型,但又需要对象做点什么的时候,都会用到多态。

  能够直接说明多态的两段示例代码如下:
  1、方法多态
[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. # -*- coding: UTF-8 -*-  
  2.   
  3. _metaclass_=type # 确定使用新式类  
  4. class calculator:  
  5.     
  6.     def count(self,args):  
  7.         return 1  
  8.   
  9. calc=calculator() #自定义类型  
  10.   
  11. from random import choice  
  12. obj=choice(['hello,world',[1,2,3],calc]) #obj是随机返回的 类型不确定  
  13. print type(obj)  
  14. print obj.count('a'#方法多态  

  对于一个临时对象obj,它通过Python的随机函数取出来,不知道具体类型(是字符串、元组还是自定义类型),都可以调用count方法进行计算,至于count由谁(哪种类型)去做怎么去实现我们并不关心。

  有一种称为”鸭子类型(duck typing)“的东西,讲的也是多态:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. _metaclass_=type # 确定使用新式类  
  2. class Duck:  
  3.     def quack(self):   
  4.         print "Quaaaaaack!"  
  5.     def feathers(self):   
  6.         print "The duck has white and gray feathers."  
  7.    
  8. class Person:  
  9.     def quack(self):  
  10.         print "The person imitates a duck."  
  11.     def feathers(self):   
  12.         print "The person takes a feather from the ground and shows it."  
  13.    
  14. def in_the_forest(duck):  
  15.     duck.quack()  
  16.     duck.feathers()  
  17.    
  18. def game():  
  19.     donald = Duck()  
  20.     john = Person()  
  21.     in_the_forest(donald)  
  22.     in_the_forest(john)  
  23.    
  24. game()  
  就in_the_forest函数而言,参数对象是一个鸭子类型,它实现了方法多态。但是实际上我们知道,从严格的抽象来讲,Person类型和Duck完全风马牛不相及。
  2、运算符多态

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. def add(x,y):  
  2.     return x+y  
  3.   
  4. print add(1,2#输出3  
  5.   
  6. print add("hello,","world"#输出hello,world  
  7.   
  8. print add(1,"abc"#抛出异常 TypeError: unsupported operand type(s) for +: 'int' and 'str'  
  上例中,显而易见,Python的加法运算符是”多态“的,理论上,我们实现的add方法支持任意支持加法的对象,但是我们不用关心两个参数x和y具体是什么类型。
  Python同样支持运算符重载,实例如下:

[python] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. class Vector:  
  2.    def __init__(self, a, b):  
  3.       self.a = a  
  4.       self.b = b  
  5.   
  6.    def __str__(self):  
  7.       return 'Vector (%d, %d)' % (self.a, self.b)  
  8.      
  9.    def __add__(self,other):  
  10.       return Vector(self.a + other.a, self.b + other.b)  
  11.   
  12. v1 = Vector(2,10)  
  13. v2 = Vector(5,-2)  
  14. print v1 + v2  
  一两个示例代码当然不能从根本上说明多态。普遍认为面向对象最有价值最被低估的特征其实是多态。我们所理解的多态的实现和子类的虚函数地址绑定有关系,多态的效果其实和函数地址运行时动态绑定有关。在C++, Java, C#中实现多态的方式通常有重写和重载两种,从上面两段代码,我们其实可以分析得出Python中实现多态也可以变相理解为重写和重载。在Python中很多内置函数和运算符都是多态的。

参考文献:

http://www.cnblogs.com/dolphin0520/archive/2013/03/29/2986924.html

http://www.cnblogs.com/jeffwongishandsome/archive/2012/10/06/2713258.html




版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
The Road to learn React书籍学习笔记(第一章)
react灵活的生态圈 Small Application Boilerplate: create-react-app Utility: JavaScript ES6 and beyond Styling: plain CSS and inline style Asynchronous Re...
1044 0
面向对象简介|学习笔记
快速学习 面向对象简介
28 0
The Road to learn React书籍学习笔记(第四章)
高级React组件 本章将重点介绍高级 React 组件的实现。我们将了解什么是高阶组件以及如何实现它们。此外,我们还将深入探讨 React 中更高级的主题,并用它实现复杂的交互功能。 引用 DOM 元素 有时候我们需要在 React 与 DOM 节点进行交互。
982 0
The Road to learn React书籍学习笔记(第二章)
The Road to learn React书籍学习笔记(第二章) 组件的内部状态 组件的内部状态也称为局部状态,允许保存、修改和删除在组件内部的属性,使用ES6类组件可以在构造函数中初始化组件的状态。
933 0
Python编程语言学习:如何将excel表格内的科学计数法转为常规数值并全部显示?
Python编程语言学习:如何将excel表格内的科学计数法转为常规数值并全部显示?
138 0
《Python编程从0到1》笔记4——你分得清“索引和切片”吗?
Python为序列类型(sequence types) 提供了独特的索引(indexing)和切片(slicing)机制以访问序列的某个元素或某一部分。
517 0
+关注
shadowcat
酱油程序猿 CSDN 博客:http://blog.csdn.net/freeking101
155
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载