上海缔客网站建设公司,网站策划书内容不包括什么,青浦网站制作su35,那个网站专做地质基础信息一、什么是对象 在 Pyth 中#xff0c;对象就是经过实例化的#xff0c;具体可以操作的一组代码的组合#xff1b; 对象一般包含数据#xff08;变量#xff0c;更习惯称之为属性 attribute#xff09;#xff0c;也包含代码#xff08;函数#xff0c;也称之为方法对象就是经过实例化的具体可以操作的一组代码的组合 对象一般包含数据变量更习惯称之为属性 attribute也包含代码函数也称之为方法 当你想要创建一个别人从来都没有创建过的新对象时首先必须定义一个类用以指明该类型的对象所包含的内容属性和方法 可以把对象想象成 名词 那么方法就是动词。对象代表着一个独立的实物它的方法则定义了它是如何和其他事物互相作用的。 和模块不同你可以同时创建许多属于同一个类的对象但每个对象又可以有各自的独特的属性。 编程的集中方式 面向过程根据业务逻辑从上到下写代码函数式将某功能代码封装到函数中日后便无需重复编写仅调用函数即可面向对象对函数进行分类和封装让开发“更快更好更强...”面向对象编程 面向对象是一种编程方式此编程方式的实现是基于对 类 和 对象 的使用类 是一个模板模板中包装了多个“函数”供使用可以讲多函数中公用的变量封装到对象中对象根据模板创建的实例即对象实例用于调用被包装在类中的函数面向对象三大特性封装、继承和多态 二、使用 class 定义类 创建实例化一个对象 面向对象编程是一种编程方式此编程方式的落地需要使用 “类” 和 “对象” 来实现所以面向对象编程其实就是对 “类” 和 “对象” 的使用。 类是对现实世界的某些对象的共性的抽象化。比如球就是对蓝球足球乒乓球的抽象化大部分都有圆形的特征都是体育用具。 类就是一个模板模板里可以包含多个函数和变量属性函数里实现一些功能方法 对象则是根据模板创建的实例通过实例化过的对象可以执行类中的函数即对象的方法 图中没有指明的地方下面一一阐述 __init__ 是Python中一个特殊的函数名是一个类的初始化实例的一个方法用于根据类的定义去创建实例对象 self 参数也是python的一个特殊参数的名称固定格式self 实际上指的就是正在被创建的对象本身它是在定义方法的时候的第一个参数这是必须的。详解见下图 上图中: doctorPerson(shark) 就是实例化一个对象这个对象就是 doctor 当创建这个对象时候Python做了以下几件事 查看 Person 类的定义在内存中实例化创建一个新的对象 doctor调用对象的 __init__ 方法将这个新创建的对象 doctor 作为形参 self 的实参传进去并将 shark 作为形参 name 的实参传入;将 name 的值 shark 赋值给 这个对象 doctor的 Name 变量即属性;将以上的操作结果返回给这个新对象;给这个新对象赋值给 dockor ;这个新对象和其他的对象一样可以把它当做列表、元组、字典的一个元素也可以当做参数传给函数或者当做函数的返回值 当创建了一个实例的对象后可以用下面的方式访问到它的属性或者方法 doctor.Name
shark 特性property 什么是 property property是一种特殊的属性访问它时会执行一段功能函数然后返回值 下面的例子中首先定义一个Duck类它仅包含一个 hidden_name 属性我们不希望比人直接访问到这个属性因此需要定义两个方法 在每个方法中添加一个 print() 函数。最后把这些方法设置为 name 属性 class Duck():
... def __init__(self,input_name):
... self.hidden_name input_name
... def get_name(self):
... print(inside the getter)
... return self.hidden_name
... def set_name(self,input_name):
... print(inside the setter)
... self.hidden_name input_name
... name property(get_name,set_name)
... fowl Duck(Howard)fowl.name # 当调用 name 属性时get_name() 方法会自动被调用
inside the getter
Howardfowl.get_name() # 当然这里可以显示调用
inside the getter
Howardfowl.name Daffy # 当对 name 进行设置时set_name() 方法会自动被调用
inside the setterfowl.set_name(Daffy) # 当然也这里可以显示调用
inside the setterfowl.name
inside the getter
Daffy# 下面来使用Python应有的风格来实现就是用装饰器的方式
#property 用于指示getter方法
#name.setter 用于指示setter方法 class Duck():
... def __init__(self,input_name):
... self.hidden_name input_name
... property
... def name(self):
... print(inside the getter)
... return self.hidden_name
... name.setter
... def name(self,input_name):
... print(inside the setter)
... self.hidden_name input_name
... fowl Duck(Howard)fowl.name
inside the getter
Howardfowl.name Donald
inside the setterfowl.name
inside the getter
Donald# 这里显然就没有显示的调用了 使用 property 的一个巨大优势如果你改变某个属性的定义只需要在类的定义里修改即可不需要再每一个调用处修改 下面还是接着上面的例子来操作一下 fowl.hidden_name
Donald发生了什么你本来是知道有这个属性的还是可以直接访问到的。假如被人也知道这个属性也同样能访问到是不是就没有起到最初隐藏某些属性的目的了。其实在Python中有专门的方法来定义一个需要隐藏的属性就是在变量名前加两个下划线__,看下面我们改下过的 Duck 类 class Duck():
... def __init__(self,input_name):
... self.__name input_name
... property
... def name(self):
... print(inside the getter)
... return self.__name
... name.setter
... def name(self,input_name):
... print(inside the setter)
... self.__name input_name
... fowl Duck(Howard)fowl.name # 代码同样有效
inside the getter
Howardfowl.name Donald
inside the setterfowl.name
inside the getter
Donaldfowl.__name # 这时访问不到 __name 属性了
Traceback (most recent call last):File stdin, line 1, in module
AttributeError: Duck object has no attribute __name其实这种命名规范并没有把属性变成真正的私有但Python确实将它重整了让外部的代码无法使用。其实还是可以访问到的 fowl._Duck__name
Donald上面的情况有时候也叫数据的封装 封装不但有上面提到的数据封装也有关于方法的封装 为啥要用封装呢 封装数据的主要原因是保护隐私 封装方法的主要原因是隔离复杂度就是把复杂的代码逻辑实现过程封装起来对于使用者是透明的给用户用到的只是一个简单的接口。 封装其实分为两个层面但无论哪种层面的封装都要对外界提供好访问你内部隐藏内容的接口接口可以理解为入口有了这个入口使用者无需且不能够直接访问到内部隐藏的细节只能走接口并且我们可以在接口的实现上附加更多的处理逻辑从而严格控制使用者的访问 第一个层面的封装什么都不用做创建类和对象会分别创建二者的名称空间我们只能用类名.或者obj.的方式去访问里面的名字这本身就是一种封装 fowl.name inside the getter Donald 注意对于这一层面的封装隐藏类名.和实例名.就是访问隐藏属性的接口 第二个层面的封装类中把某些属性和方法隐藏起来(或者说定义成私有的)只在类的内部使用、外部无法访问或者留下少量接口函数供外部访问。 同上面提到的 隐藏属性的方法一样在python中用双下划线的方式实现隐藏属性设置成私有的 在继承中父类如果不想让子类覆盖自己的方法可以将方法定义为私有的 #把fa定义成私有的即__faclass A:
... def __fa(self): #在定义时就变形为_A__fa
... print(from A)
... def test(self):
... self.__fa() #只会与自己所在的类为准,即调用_A__fa
... class B(A):
... def __fa(self):
... print(from B)
... bB()b.test()
from A python并不会真的阻止你访问私有的属性模块也遵循这种约定如果模块名以单下划线开头那么from module import *时不能被导入,但是你from module import _private_module依然是可以导入的 其实很多时候你去调用一个模块的功能时会遇到单下划线开头的(socket._socket,sys._home,sys._clear_type_cache),这些都是私有的原则上是供内部调用的作为外部的你一意孤行也是可以用的只不过显得稍微傻逼一点点 接口与归一化设计 继承有两种用途 一继承基类的方法并且做出自己的改变或者扩展代码重用 二声明某个子类兼容于某基类定义一个接口类Interface接口类中定义了一些接口名就是函数名且并未实现接口的功能子类继承接口类并且实现接口中的功能 class Interface:#定义接口Interface类来模仿接口的概念python中压根就没有interface关键字来定义一个接口。def read(self): #定接口函数readpassdef write(self): #定义接口函数writepassclass Txt(Interface): #文本具体实现read和writedef read(self):print(文本数据的读取方法)def write(self):print(文本数据的读取方法)class Sata(Interface): #磁盘具体实现read和writedef read(self):print(硬盘数据的读取方法)def write(self):print(硬盘数据的读取方法)class Process(All_file):def read(self):print(进程数据的读取方法)def write(self):print(进程数据的读取方法) 实践中继承的第一种含义意义并不很大甚至常常是有害的。因为它使得子类与基类出现强耦合。 继承的第二种含义非常重要。它又叫“接口继承”。接口继承实质上是要求“做出一个良好的抽象这个抽象规定了一个兼容接口使得外部调用者无需关心具体细节可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上叫做归一化。 归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样所有东西都可以当文件处理不必关心它是内存、磁盘、网络还是屏幕当然对底层设计者当然也可以区分出“字符设备”和“块设备”然后做出针对性的设计细致到什么程度视需求而定。 在python中根本就没有一个叫做interface的关键字上面的代码只是看起来像接口其实并没有起到接口的作用子类完全可以不用去实现接口 如果非要去模仿接口的概念可以借助第三方模块 http://pypi.python.org/pypi/zope.interface twisted的twisted\internet\interface.py里使用zope.interface 文档https://zopeinterface.readthedocs.io/en/latest/ 为何要用接口 接口提取了一群类共同的函数可以把接口当做一个函数的集合。 然后让子类去实现接口中的函数。 这么做的意义在于归一化什么叫归一化就是只要是基于同一个接口实现的类那么所有的这些类产生的对象在使用时从用法上来说都一样。 归一化让使用者无需关心对象的类是什么只需要的知道这些对象都具备某些功能就可以了这极大地降低了使用者的使用难度。 比如我们定义一个动物接口接口里定义了有跑、吃、呼吸等接口函数这样老鼠的类去实现了该接口松鼠的类也去实现了该接口由二者分别产生一只老鼠和一只松鼠送到你面前即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑都会吃都能呼吸。 再比如我们有一个汽车接口里面定义了汽车所有的功能然后由本田汽车的类奥迪汽车的类大众汽车的类他们都实现了汽车接口这样就好办了大家只需要学会了怎么开汽车那么无论是本田还是奥迪还是大众我们都会开了开的时候根本无需关心我开的是哪一类车操作手法函数调用都一样 抽象类 1 什么是抽象类 与java一样python也有抽象类的概念但是同样需要借助模块实现抽象类是一个特殊的类它的特殊之处在于只能被继承不能被实例化 2 为什么要有抽象类 如果说类是从一堆对象中抽取相同的内容而来的那么抽象类就是从一堆类中抽取相同的内容而来的内容包括数据属性和函数属性。 比如我们有香蕉的类有苹果的类有桃子的类从这些类抽取相同的内容就是水果这个抽象的类你吃水果时要么是吃一个具体的香蕉要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。 从设计角度去看如果类是从现实对象抽象而来的那么抽象类就是基于类抽象而来的。 从实现角度来看抽象类与普通类的不同之处在于抽象类中只能有抽象方法没有实现功能该类不能被实例化只能被继承且子类必须实现抽象方法。这一点与接口有点类似但其实是不同的即将揭晓答案 3. 在python中实现抽象类 import abc #利用abc模块实现抽象类class All_file(metaclassabc.ABCMeta):all_typefileabc.abstractmethod #定义抽象方法无需实现功能def read(self):子类必须定义读功能passabc.abstractmethod #定义抽象方法无需实现功能def write(self):子类必须定义写功能pass# class Txt(All_file):
# pass
#
# t1Txt() #报错,子类没有定义抽象方法class Txt(All_file): #子类继承抽象类但是必须定义read和write方法def read(self):print(文本数据的读取方法)def write(self):print(文本数据的读取方法)class Sata(All_file): #子类继承抽象类但是必须定义read和write方法def read(self):print(硬盘数据的读取方法)def write(self):print(硬盘数据的读取方法)class Process(All_file): #子类继承抽象类但是必须定义read和write方法def read(self):print(进程数据的读取方法)def write(self):print(进程数据的读取方法)wenbenwenjianTxt()yingpanwenjianSata()jinchengwenjianProcess()#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type) 4. 抽象类与接口 抽象类的本质还是类指的是一组类的相似性包括数据属性如all_type和函数属性如read、write而接口只强调函数属性的相似性。 抽象类是一个介于类和接口直接的一个概念同时具备类和接口的部分特性可以用来实现归一化设计 三、继承 在你编写代码解决实际问题的时候经常能找到一些已有的类这些类可以帮你实现大部分功能但不是全部。这时该怎么办 对这个已有的类进行修改但这么做会使代码变的更加复杂一不小心就可能破坏原来类的可用的功能。 这时就可以用到类的一个特性 继承 类的继承就是可以从一个已有的类中衍生出以个新的类这个新的类可以不需要再做任何代码的复制重写就可以拥有原有类的所有属性和方法。 并且你也可以对这个新的类进行添加新属性和你需要的新方法甚至把原来类的方法进行重写即重写实现并不改变原来方法的名称这种重写方法我们习惯称为覆盖方法下面会一一介绍。 我们习惯把新类称为子类把原来的类称为基类、父类或者超类。 具体实现的方法就是在定义新类时在类的名称后面的小括号中写入要继承的父类的名称即可 比如说汽车Car自行车Bicycle的共性大部分都是有品牌、出厂日期等属性变量的都可以行驶方法。 这些都是属于车Vehicle这个类的属性和方法。下面我们就来演示一下如何实现继承的。 # 先定义一个父类 车
class Vehicle():def __init__(self,name,brand,date):self.name nameself.brand brandself.date datedef run(self):print(The {} is running.format(self.name) )# 再定义两个子类对父类车进行继承
class Car(Vehicle): # 汽车类passclass Bicycle(Vehicle): # 自行车类pass# 现在都继承了父类但是在子类中什么代码也没写
# 但是会有服了的所以属性和方法my_car Car(x6,bmw,20170106) # 实例化一个汽车对象
my_bicycle Bicycle(roam_xr2,giant,20170305) # 实例化一个自行车对象# 直接通过实例化的对象对其属性和方法进行调用
print(my_car.name)
my_car.run()print(my_bicycle.name)
my_bicycle.run()# 输出结果
x6
The x6 is running
roam_xr2
The roam_xr2 is running 四、多态和多态性 有很多人可能会把二者混为一谈然后就会容易乱甚至懵逼。其实只要分开看就会很明朗 多态 多态就是一类事物有多种形态的表现形式。一个抽象类有多个子类因而多态的概念依赖于继承就像上面的例子一样 车是有多重形态存在于这个世界上的如自行车、汽车、火车等 在 Python 中序列就有多重形态字符串、列表、元组 这就不写代码了参考上面的即可 多态性 那么什么优势多态性哪 多态性就是在现实生活中具有不同功能的多个事物对象也就是每个对象去实现的方法不一样而对这些功能的叫法即名称是一样的比如自行和汽车都能行驶但是自行车是通过人力为驱动力2个轮子去行驶而汽车是使用发动机为驱动力至少4个轮去行驶不要给我提摩托车。 再比如人都会说话但是中国人说的是普通话而美国人和英国人说的英语但这并不能妨碍他们同一种语言之间的正常交流都叫说话。 多态性在面向对象编程OOP中指的是不同的对象可以使用相同的函数名但这些函数体却不一样去实现的方法也自然不一样了这样就可以用一个函数名调用不同内容的函数从而去实现不同的方法。 在面向对象方法中一般是这样表述多态性向不同的对象发送同一条消息不同的对象在接收时会产生不同的行为即方法。也就是说每个对象可以用自己的方式去响应共同的消息。所谓消息就是调用函数不同的行为就是指不同的实现即执行不同的函数。 多态性分为静态多态性和动态多态性 静态多态性如任何类型都可以用运算符进行运算 如下图总所实现的一样字符串、列表、和元组都有一样的方法名称 __len__() 但是内部是实现一定不同。 我们可以对之前车的例子进行稍微的改动一下 class Vehicle():def __init__(self,name,brand,date):self.name nameself.brand brandself.date datedef run(self):print(The {} is running.format(self.name) )
class Car(Vehicle): # 汽车类def run(self):print({}正在用四个轮子行驶平均速度是 80km/h.format(self.name))
class Bicycle(Vehicle): # 自行车类def run(self):print({}正在用两个轮子行驶平均速度是 20km/h.format(self.name))my_car Car(x6,bmw,20170106) # 实例化一个汽车对象
my_bicycle Bicycle(roam_xr2,giant,20170305) # 实例化一个自行车对象# 为了很好的展示多态性还有再借助一个函数
def func(obj):obj.run() #这里明确的调用了一个函数函数名就是run
#将不同的对象传进这个函数
func(my_car)
func(my_bicycle)
# 输出了不同的结果
x6正在用四个轮子行驶平均速度是 80km/h
roam_xr2正在用两个轮子行驶平均速度是 20km/h 为什么要用多态性多态性的好处 其实大家从上面多态性的例子可以看出我们并没有增加什么新的知识也就是说python本身就是支持多态性的这么做的好处是什么呢 1.增加了程序的灵活性和使用者的透明性或者易用性 以不变应万变不论对象千变万化使用者都是同一种形式去调用如func(obj) 2.增加了程序额可扩展性 通过继承Vehicle类创建了一个新的类使用者无需更改自己的代码还是用func(animal)去调用 # 开发者修改代码衍生的新子类火车
class Train(Vehicle):def run(self):print({}正在用多个轮子行驶平均速度是 150km/h.format(self.name))
# 实例化一个新的火车对象 t1
t1 Train(hexiehao,China CSR,20000706)
# 给使用者的函数代码不变
def func(obj):obj.run()
# 使用者使用同样的方式去调用
func(t1)# 输出结果
hexiehao正在用多个轮子行驶平均速度是 150km/h 组合 如果你想创建的子类在大多数情况下的行为都和父类相似的话使用基础是非常不错的选择。 它们之间的关系是属于的关系。但有些时候是有组合 composition更加符合现实的逻辑。比如 x 含有 y 他们之间是 has-a 的关系。 汽车是属于车的一种is-a它有含有四个轮子has-a轮子是汽车的组成部分但不是汽车的一种。 class Vehicle():def __init__(self,brand):self.brand brand
class Wheel():def __init__(self,num):self.num num
class Car():def __init__(self,car_brand,num_wheel):self.car_brand car_brandself.num_wheel num_wheeldef run(self):print(The %s car is running on %s wheels %(v1.brand,w1.num))
v1 Vehicle(BMW)
w1 Wheel(4)
car1 Car(v1,w1)
car1.run()
# 输出结果
The BMW car is running on 4 wheels 五、对象相关知识补充 对象/实例只有一种作用属性引用变量引用 class Person():
... def __init__(self,name,age):
... self.name name
... self.age age
... def run(self):
... print({} is running.format(self.name))
... person Person(Fudd,23) #实例化一个人的对象
# 对象调用了自己的数据属性print(name:,person.name)
name: Fuddprint(age ,person.age)
age 23对象本身只有数据属性但是python的class机制会将类的函数绑定到对象上称为对象的方法或者叫绑定方法 person.run #对象的绑定方法
bound method Person.run of __main__.Person object at 0x7f80cc575c50 Person.run # 对象的绑定方法 run 本质就是调用类的函数 run 的功能二者是一种绑定关系
function Person.run at 0x7f80cc571620对象的绑定方法的特别之处在于 obj.func()会把obj传给func的第一个参数。 也就是通常见到的在类里定义的任何函数self 都是第一个参数这是 Python的机制所必需的。 类的初始化实例流程图 根据上图我们得知再次指明了其实self,就是实例本身你实例化时python会自动把这个实例本身通过self参数传进去 六、覆盖方法 类的覆盖方法就上上面的例子中的 run() 方法一样子类可以父类里的这个方法继续完全覆盖。 其实子类可以覆盖父类的所以方法包括__init__()本身下面就开展示一个覆盖父类__init__()的例子 class Person():def __init__(self,name,age):self.name nameself.age ageclass MDPerson(Person):def __init__(self,name,age):self.name Doctor nameself.age age
person Person(Fudd,23)
doctor MDPerson(Fudd,23)print(name:,person.name ,age ,person.age)
print(name:,doctor.name ,age:,doctor.age)
# 输出内容
name: Fudd age 23
name: DoctorFudd age: 23 七、添加新方法 添加新方法很简单 比如还拿上面的 人 这个类来说现在衍生一个老师类并且在这个新的类里添加一个新的属性 老师的认证级别和一个新的方法讲课 class Person():def __init__(self,name,age):self.name nameself.age agedef run(self):print({} is running.format(self.name))
class Teacher(Person):def __init__(self,name,age,level): #添加了新的属性Person.__init__(self,name,age) # 上面重构了__init__(),再要使用父类的属性就需要这样写self.level leveldef lecture(self): # 添加的新方法print(%s teacher %s teacher is lecturing %(self.level,self.name))
t1 Teacher(shark,23,Senior )
print(t1.level)
t1.lecture()
# 输出结果
Senior
Senior teacher shark teacher is lecturing 八、子类里使用 super 调用父类的属性 其实对于上面的例子中已经用到了父类属性只是方法看着有点 low,下面就演示一下稍微高逼格的方法 class Person():def __init__(self,name,age):self.name nameself.age agedef run(self):print({} is running.format(self.name))
class Teacher(Person):def __init__(self,name,age,level):super().__init__(name,age) # 注意这里使用super() 替代了父类名并且参数中没有 self # 上面是 Pyhon3 的方式Python2 中的方式是super(Teacher,self).__init__(name,age)self.level leveldef lecture(self):print(%s teacher %s teacher is lecturing %(self.level,self.name))
t1 Teacher(shark,23,Senior )
print(t1.level)
t1.lecture()
# 输出结果
Senior
Senior teacher shark teacher is lecturing 九、静态方法 类的方法 通常情况下在类中定义的所有函数都是对象的绑定方法。注意了这里说的就是所有跟self啥的没关系self也只是一个再普通不过的参数而已在类的定义中以self作为第一个参数的方法都是实例方法instance method。这种在创建自定义类是最常用实例方法的首个参数是 self 当这种方法被调用时Python 会把调用此方法的对象作为 self 参数传入。除此之外还有两种常见的方法静态方法和类方法二者是为类量身定制的但是实例非要使用也不会报错后续将介绍。 静态方法 静态方法是一种普通函数位于类定义的命名空间中不会对任何实例类型进行操作 python为我们内置了函数staticmethod来把类中的函数定义成静态方法 class Foo:def spam(x,y,z): #类中的一个函数千万不要懵逼self和x啥的没有不同都是参数名print(x,y,z)spamstaticmethod(spam) #把spam函数做成静态方法基于之前所学装饰器的知识staticmethod 等同于spamstaticmethod(spam),于是class Foo:staticmethod #装饰器def spam(x,y,z):print(x,y,z)使用演示print(type(Foo.spam)) #类型本质就是函数
Foo.spam(1,2,3) #调用函数应该有几个参数就传几个参数f1Foo()
f1.spam(3,3,3) #实例也可以使用,但通常静态方法都是给类用的,实例在使用时丧失了自动传值的机制
class function
1 2 3
3 3 3应用场景:编写类时需要采用很多不同的方式来创建实例而我们只有一个__init__函数此时静态方法就派上用场了 class Date:def __init__(self,year,month,day):self.yearyearself.monthmonthself.daydaystaticmethoddef now(): #用Date.now()的形式去产生实例,该实例用的是当前时间ttime.localtime() #获取结构化的时间格式return Date(t.tm_year,t.tm_mon,t.tm_mday) #上面的意思是 新建一个实例实例名没有起但是返回了也就是当调用 now() 时就会得到一个新的实例 staticmethoddef tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间ttime.localtime(time.time()86400)return Date(t.tm_year,t.tm_mon,t.tm_mday)aDate(1987,11,27) #自己定义时间
bDate.now() #采用当前时间
cDate.tomorrow() #采用明天的时间print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day) 类方法 与之实例方法相对类方法class method会作用于整个类在类定义的内部用装饰器 classmethod 修饰的方法都是类方法。与实例方法类似类方法第一个参数是类本身。在Python中这个参数常被写作 clsimport time class Date:def __init__(self,year,month,day):self.yearyearself.monthmonthself.daydayclassmethoddef now(cls): #用Date.now()的形式去产生实例,该实例用的是当前时间ttime.localtime() #获取结构化的时间格式return cls(t.tm_year,t.tm_mon,t.tm_mday) #上面的意思是 新建一个实例实例名没有起但是返回了也就是当调用 now() 时就会得到一个新的实例 staticmethodaDate(1983,07,28) #自己定义时间
bDate.now() #采用当前时间print(a.year,a.month,a.day) # 输出自定义的实例化时间
print(b.year,b.month,b.day) # 输出调用类方法 now()即当前的时间的实例化时间
# 输出结果
1983 07 28
2017 3 5 静态方法和类方法的区别1. staticmethod 与类只是名义上的归属关系2. classmethod 只能访问类变量不能访问实例变量 应用场景import time
class Date:def __init__(self,year,mon,day):self.yearyearself.monmonself.daydayclassmethoddef now(cls):ttime.localtime()return cls(t.tm_year,t.tm_mon,t.tm_mday)# 下面是使用静态方法去实现的情况请注意看后面的图片说明# staticmethod # def now():# ttime.localtime()# return Date(t.tm_year,t.tm_mon,t.tm_mday)class EuroDate(Date):def __str__(self):return year:%s mon:%s day:%s %(self.year,self.mon,self.day)e EuroDate.now()
print(e) # 打印这个对象当打印这个对象是会自动调用对象的类的 __str__()方法 类的继承顺序和原理 首先来说一下什么是经典类和新式类 pyth2.x中默认都是经典类Python3.x不是默认是都是新式类 # Python3.6 定义类class A:
... pass
... class B():
... pass
... class C(object):
... pass
...
# 打印类以及其类型print(A,type(A))
class __main__.A class typeprint(B,type(B))
class __main__.B class typeprint(C,type(C))
class __main__.C class type# Python2.7 定义类class A:
... pass
... class B():
... pass
... class C(object): # 在Python2.x 中定义新式类必须显式的定义
... pass
...
# 打印类以及其类型print(A,type(A))
(class __main__.A at 0x7f5e2344c258, type classobj) # 经典类print(B,type(B))
(class __main__.B at 0x7f5e2344c2c0, type classobj)print(C,type(C))
(class __main__.C, type type) # 新式类1 继承顺序 class A(object):def test(self):print(from A)class B(A):def test(self):print(from B)class C(A):def test(self):print(from C)class D(B):def test(self):print(from D)class E(C):def test(self):print(from E)class F(D,E):# def test(self):# print(from F)pass
f1F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表经典类没有这个属性#新式类继承顺序:F-D-B-E-C-A
#经典类继承顺序:F-D-B-A-E-C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类继承原理python如何实现的继承 python到底是如何实现继承的对于你定义的每一个类python会计算出一个方法解析顺序(MRO)列表这个MRO列表就是一个简单的所有基类的线性顺序列表例如 F.mro() #等同于 F.__mro__
[class __main__.F, class __main__.D, class __main__.B,class __main__.E, class __main__.C, class __main__.A, class object]为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理, 它实际上就是合并所有父类的MRO列表并遵循如下三条准则:1.子类会先于父类被检查2.多个父类会根据它们在列表中的顺序被检查3.如果对下一个类存在两个合法的选择,选择第一个父类转载于:https://www.cnblogs.com/xiguatian/p/6392141.html
