Class

类的定义以及实例的建立

Python中,类通过 class 关键字定义。

例如最简单的一个类定义可以为:

class Person(object):
pass

Python 的编程习惯,类名以大写字母开头,紧接着是(object),表示该类是从哪个类继承下来的。

例如上面的person类,我们可以创建很多实例:

zhangsan=Person()
lisi=Person()

实例的属性及方法

Python是动态语言,对每一个实例,都可以直接给他们的属性赋值,即使类中并无定义,例如,给xiaoming这个实例加上name、gender和birth属性:

xiaoming = Person()
xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'

__init__()

如上所说,我们可以自由地给一个实例绑定各种属性,但是,现实世界中,一种类型的实例应该拥

有相同名字的属性。例如,Person类应该在创建的时候就拥有 name、gender 和 birth 属性。

所以在创建类时,我们可以使用__init__()方法,当创建实例时,__init__()方法被自动调用,我们就

能在此为每个实例都统一加上以下属性:

class Person(object):
def __init__(self, name, gender, birth):
self.name = name
self.gender = gender
self.birth = birth

__init__() 方法的第一个参数必须是 self(也可以用别的名字,但建议使用习惯用法),后续参数则

可以自由指定,和定义函数没有任何区别。

同时,创建实例时,就必须要提供除 self 以外的参数:

xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')

属性的访问限制(私有属性)

我们可以给一个实例绑定很多属性,如果有些属性不希望被外部访问到怎么办?

Python对属性权限的控制是通过属性名来实现的,如果一个属性由双下划线开头(__),该属性就无

法被外部访问。例如:

class Person(object):
def __init__(self, name):
self.name = name
self._title = 'Mr'
self.__job = 'Student' p1=Person("zhangsan") print(p1.name,'\n')
print(p1._title,'\n')
try:
print(p1.__job)
except:
print("Error")

结果:

zhangsan 

Mr 

Error

可以看出只有__job无法被访问

实例的方法

虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外,还可以定义实例的方法。

例如我们可以定义一个__name私有属性,同时创建一个get_name方法去访问__name:

class Person(object):

    def __init__(self, name):
self.__name = name def get_name(self):
return self.__name p2=Person("Bob")
print(p2.get_name())

结果

Bob

get_name(self) 就是一个实例方法,它的第一个参数是self。__init__(self, name)其实也可看做是一个特殊的实例方法。

在实例方法内部,可以访问所有实例属性,这样,如果外部需要访问私有属性,可以通过方法调用获得,这种数据封装的形式除了能保护内部数据一致性外,还可以简化外部调用的难度。

python中实例方法也是属性

我们在 class 中定义的实例方法其实也是属性,它实际上是一个函数对象,因为方法也是一个属性,所以,它也可以动态地添加到实例上,只是需要用 types.MethodType() 把一个函数变为一个方法:

import types
def Pn_get_name(self):
return str("This person's name is :"+self.name) class Person(object):
def __init__(self, name):
self.name = name p1=Person("Alice")
p2=Person("Bob") p1.get_name=types.MethodType(Pn_get_name,p1) print(p1.get_name(),'\n')
print(p2.get_name())

结果:

This person's name is :Alice 

Traceback (most recent call last):
File "D:/pythonwork/practise/test.py", line 15, in <module>
print(p2.get_name())
AttributeError: 'Person' object has no attribute 'get_name'

给一个实例动态添加方法并不常见,直接在class中定义要更直观

类的属性及方法

类是模板,而实例则是根据类创建的对象。绑定在一个实例上的属性不会影响其他实例,但是,类本身也是一个对象,如果在类上绑定一个属性,则所有实例都可以访问类的属性,并且,所有实例访问的类属性都是同一个,也就是说,实例属性每个实例各自拥有,互相独立,而类属性有且只有一份。

定义类属性可以直接在 class 中定义:

class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name

因为类属性是直接绑定在类上的,所以,访问类属性可以直接用类名访问,也可以使用实例访问,例如:

class Person(object):
address = 'Earth'
def __init__(self, name):
self.name = name p1=Person("zhangsan") print(Person.address)
print(p1.address)

结果:

Earth
Earth

由于Python是动态语言,类属性也是可以动态添加和修改的:

Person.address = 'China'

print(Person.address)
print(p1.address)

结果:

China
China

因为类属性只有一份,所以,当Person类的address改变时,所有实例访问到的类属性都改变了。

注意:如果在实例变量上修改类属性,则实际上是给实例绑定了一个与类属性同名的实例属性,而

访问时会优先访问实例属性:

p1.address="China"

print(Person.address)
print(p1.address)

结果:

Earth
China

类的方法

和属性类似,方法也分实例方法和类方法。

在class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。

要在class中定义类方法,我们通过标记一个 @classmethod,该方法将绑定到 Person 类上,而非

类的实例。类方法的第一个参数将传入类本身,通常将参数名命名为 cls,下面例子中

的 cls.count 实际上相当于 Person.count。

class Person(object):
count = 0
@classmethod
def how_many(cls):
return cls.count def __init__(self, name):
self.name = name
Person.count = Person.count + 1 print (Person.how_many())
p1 = Person('Bob')
print (Person.how_many())

结果:

0
1

类的继承

如果已经定义了Person类,需要定义新的Student和Teacher类时,可以直接从Person类继承,定义Student类时,只需要把额外的属性加上,例如score:

class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score

注意:

一定要用 super(Student, self).__init__(name, gender) 去初始化父类,否则,继承自 Person 的 Student 将没有 name 和 gender。

函数super(Student, self)将返回当前类继承的父类,即 Person ,然后调用__init__()方法,注意self参数已在super()中传入,在__init__()中将隐式传递,不需要写出(也不能写)。

python中的多态

类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 Person 派生出 Student和

Teacher ,并都写了一个 同名的whoAmI() 方法,当我们调用实例的whoAmI() 方法时,总是先查找

它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。

例如:

class Person(object):
pass
def Pstr(self):
print("This is Person class method") class Student(Person):
def __init__(self, name):
self.name = name
def Pstr(self):
print("This is Student class method") class Teacher(Person):
def __init__(self, name):
self.name = name p1=Student("Alice")
p2=Teacher("Tom") p1.Pstr()
p2.Pstr()

结果:

This is Student class method
This is Person class method

python中的多重继承

除了从一个父类继承外,Python允许从多个父类继承,称为多重继承。

例如:

class A(object):
def __init__(self, a):
print 'init A...'
self.a = a class B(A):
def __init__(self, a):
super(B, self).__init__(a)
print 'init B...' class C(A):
def __init__(self, a):
super(C, self).__init__(a)
print 'init C...' class D(B, C):
def __init__(self, a):
super(D, self).__init__(a)
print 'init D...'

像这样,D 同时继承自 B 和 C,也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用

__init__()方法时,A 虽然被继承了两次,但__init__()只调用一次:

运行测试代码:

d=D('d')

结果:

init A...
init C...
init B...
init D...

类的定制

我们可以使用一些特殊的方法来定制我们自己定义的类

python中 __slots__

由于Python是动态语言,任何实例在运行期都可以动态地添加属性。

如果要限制添加的属性,例如,Student类只允许添加 name、gender和score 这3个属性,就可以利用Python的一个特殊的__slots__来实现。

例如:

class Student(object):
__slots__ = ('name', 'gender', 'score')
def __init__(self, name, gender, score):
self.name = name
self.gender = gender
self.score = score

进行操作:

>>> s = Student('Bob', 'male', 59)
>>> s.name = 'Tim' # OK
>>> s.score = 99 # OK
>>> s.grade = 'A'
Traceback (most recent call last):
...
AttributeError: 'Student' object has no attribute 'grade'

__slots__的目的是限制当前类所能拥有的属性,如果不需要添加任意动态的属性,使用__slots__也能节省内存。

python中 __str__和__repr__对于print的改变

例如原本对于类中的实例直接打印:

class Student(object):
def __init__(self, name):
self.name = name p1=Student("Alice") print(p1)

结果:

<__main__.Student object at 0x000002672671EF98>

但是我们想让print实例的时候直接打印类名与实例名我们就可以使用__str__:

class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student: %s' % self.name p1=Student("Alice") print(p1)

结果:

Student: Alice

但是我们在命令交互行中直接输入变量p1却不是这样:

>>>p1
<Student object at 0x0000023C8F331A58>

这是因为 Python 定义了__str__()和__repr__()两种方法,__str__()用于显示给用户,而__repr__()

用于显示给开发人员。

同理我们可以定义类的__repr__()例如直接:

__repr__ = __str__

这样直接在命令交互中直接输入变量p1也是同样效果了

>>>p1
Student: Alice

python3中__cmp__方法已经不再使用

在python2中该方法可实现对于sorted()函数改变,不再赘述

 

python中 __len__对于len()的改变

如果一个类表现得像一个list,要获取有多少个元素,就得用 len() 函数。

要让 len() 函数工作正常,类必须提供一个特殊方法__len__(),它返回元素的个数。

例如,我们写一个 Students 类,把名字传进去:

class Students(object):
def __init__(self, *args):
self.names = args
def __len__(self):
return len(self.names) ss = Students('Bob', 'Alice', 'Tim')
print (len(ss))

结果:

3 

类的实例的数学运算

同以上特殊方法一样,我们可以利用

__add__对符号 + 进行改变

__sub__对符号 -进行改变

__mul__对符号 * 进行改变

__div__对符号 / 进行改变

例如:

我们创建一个分数的类:

class Rational(object):
def __init__(self, p, q):
self.p = p
self.q = q

我们想实现符号+直接运用在我们创建的实例上我们需要这样写代码:

class Rational(object):
def __init__(self, p, q):
self.p = p
self.q = q
def __add__(self, r):
return Rational(self.p * r.q + self.q * r.p, self.q * r.q)
def __str__(self):
return '%s/%s' % (self.p, self.q)
__repr__ = __str__ r1 = Rational(1, 3)
r2 = Rational(1, 2)
print(r1+r2)

结果:

5/6

类的实例的类型转换

如上,Rational类实现了有理数(分数)类的数学运算,但是,如果要把结果转为 int 或 float 怎么办?

我们对于整数和浮点数可以直接使用int()和float()函数直接转换,但是我们肯定无法直接使用在我们所创建的类的实例上,因此我们需要使用__int__()和__float__()

例如__int__:

class Rational(object):
def __init__(self, p, q):
self.p = p
self.q = q
def __int__(self):
return self.p//self.q #python3中//是整数结果

结果:

>>> print int(Rational(7, 2))
3

python中 @property

对于Student类:

class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score

当我们想要修改一个 Student 的 scroe 属性时,可以这么写:

s = Student('Bob', 59)
s.score = 1000

显然,直接给属性赋值无法检查分数的有效性。

如果利用两个方法:

class Student(object):
def __init__(self, name, score):
self.name = name
self.__score = score
def get_score(self):
return self.__score
def set_score(self, score):
if score < 0 or score > 100:
raise ValueError('invalid score')
self.__score = score

这样一来,s.set_score(1000) 就会报错。

这种使用 get/set 方法来封装对一个属性的访问在许多面向对象编程的语言中都很常见。但是写 s.get_score() 和 s.set_score() 没有直接写 s.score 来得直接。

而在Python中,python支持高阶函数,在函数式编程中我们介绍了装饰器函数,可以用装饰器函数@property

把 get/set 方法“装饰”成属性调用:

class Student(object):
def __init__(self, name, score):
self.name = name
self.__score = score
@property
def score(self):
return self.__score
@score.setter
def score(self, score):
if score < 0 or score > 100:
raise ValueError('invalid score')
self.__score = score

现在再设置score会怎么样呢:

s = Student('Bob', 59)
s.score = 60
print (s.score)
try:
s.score = 1000
except:
print("Error")

结果:

60
Error

注意: 第一个score(self)是get方法,用@property装饰,第二个score(self, score)是set方法,用@score.setter装饰,@score.setter是前一个@property装饰后的副产品。说明对 score 赋值实际调用的是 set方

法。如果没有定义set方法即@score.setter,就不能对“属性”赋值,这时,就可以创建一个只读“属性”。

python中 __call__

在Python中,函数其实是一个对象:

>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123

由于 f 可以被调用,所以,f 被称为可调用对象。而所有的函数都是可调用对象。

一个类实例也可以变成一个可调用对象,只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象:

class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender def __call__(self, friend):
print ('My name is %s...' % self.name)
print ('My friend is %s...' % friend)

现在可以对 Person 实例直接调用:

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例,所以,在Python中,函数也是对象,对象和函数的区别并不显著。

python中的类与继承的更多相关文章

  1. 关于Python中的类普通继承与super函数继承

    关于Python中的类普通继承与super函数继承 1.super只能用于新式类 2.多重继承super可以保公共父类仅被执行一次 一.首先看下普通继承的写法 二.再看看super继承的写法 参考链接 ...

  2. Python 中的类的继承

    class parent(object): def override1(self): print("Parent") class child(parent): def overri ...

  3. GO-结构体(类似python中的类)

    一.结构体有名属性 package main import "fmt" func main(){ type Sb struct { name string //属性名,数据类型 a ...

  4. Python中的类、对象、继承

    类 Python中,类的命名使用帕斯卡命名方式,即首字母大写. Python中定义类的方式如下: class 类名([父类名[,父类名[,...]]]): pass 省略父类名表示该类直接继承自obj ...

  5. python中的类和实例

    今天花了两个多小时后搜索相关博客看了看python中有关类和实例的介绍,差不多大概明白了. python中的类和c++中的类是一样的,不同之处就是c++的类,如果含有成员变量,并且成员变量发生变化后, ...

  6. 4、Python中的类详解(0601)

    <大话数据结构>的作者程杰在博客园也有博客,网址是:http://cj723.cnblogs.com/ 面向对象编程(OOP) 1.程序 = 指令 + 数据 代码可以选择以指令为核心或以数 ...

  7. python中新式类和经典类

    python中的类分为新式类和经典类,具体有什么区别呢?简单的说, 1.新式类都从object继承,经典类不需要. Python 2.x中默认都是经典类,只有显式继承了object才是新式类 Pyth ...

  8. Python中的类(一)

    Python中的类(一) 一. 应用场景 如果多个函数中有一些相同的参数时,转换成面向对象. 二. 如何创建类 类是用来描述具有相同的属性和方法的对象的集合.它定义了该集合中每个对象所共有的属性和方法 ...

  9. python中元类(metaclass)的理解

    原文地址:http://www.cnblogs.com/tkqasn/p/6524879.html 一:类也是对象 类就是一组用来描述如何生成一个对象的代码. 类也是一个对象,只要你使用关键字clas ...

随机推荐

  1. C语言中的作用域、链接属性与存储属性

    C语言中的作用域.链接属性与存储属性 一.作用域(scope) 代码块作用域 表示{}之间的区域,下例所示,a可以在不同的代码块里面定义. #include<stdio.h> int ma ...

  2. python内置的一些模块

    logging模块: 默认情况下,logging将日志打印到屏幕,日志级别为WARNING:日志级别大小关系为:CRITICAL > ERROR > WARNING > INFO & ...

  3. vector ----- size函数注意事项

    vector 的size函数返回vector大小,返回值类型为size_type,Member type size_type is an unsigned integral type,即无符号整数: ...

  4. python学习笔记第三章

    1.列表是由一系列特定顺序排列得元素组成,在python中用([])组成,列表得索引是从0开始,不是1 xu=['a','b',''c] print(xu) 访问列表的元素第一个元素 xu=['a', ...

  5. [转载]PyCharm创建.py自动添加文件头注释

    转自:https://blog.csdn.net/qq_36482772/article/details/67218214 创建.py文件时 顺便自动添加作者.时间.文件名信息…… mac系统打开编辑 ...

  6. ES6学习笔记(二十一)编程风格

    本章探讨如何将 ES6 的新语法,运用到编码实践之中,与传统的 JavaScript 语法结合在一起,写出合理的.易于阅读和维护的代码. 1.块级作用域 (1)let 取代 var ES6 提出了两个 ...

  7. js获取当前根目录的方法

    function getRootPath_web() { //获取当前网址,如: http://localhost:8083/uimcardprj/share/meun.jsp var curWwwP ...

  8. [SCOI2012]喵星球上的点名(树状数组+后缀数组)

    我们把所有的名,姓,询问都拼起来构成一个新的长串,然后跑一边SA.排完序后对于每一个询问,我们可以二分求出它所对应的区间(即满足这个区间的前缀都是这个询问串).然后问题就转化为很多区间问区间出现过的不 ...

  9. [Vijos P2000]A x B Problem

    题目大意:叫你求A × B. 解题思路:高精度.你可千万别小看这道题,这是2017年7月27日的信息. 不过也不要怕,根据twd2的题解里写的,用普通的高精度加上一些小小的修改是可以过的. 那么直接上 ...

  10. EEPlat PaaS中的多租户数据隔离模式

    EEPlat PaaS支持三种租户的数据隔离技术:Sparce Column.tenantId字段隔离.每一个租户独立数据库. 1)Sparce Column,和Salesforce Appforce ...