1、面向对象术语

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类属性(类变量):类属性在整个实例化的对象中是公用的。类属性定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 实例变量:定义在方法中的变量,只作用于当前实例的类。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系。
  • 实例化:创建一个类的实例,类的具体对象。
  • 方法:类中定义的函数。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

2、类定义

Python中的类提供了面向对象编程的所有基本功能:类的继承机制允许多个基类,派生类可以覆盖基类中的任何方法,方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

class test(object):   #定义一个类,在3.5中必须指定基类object
i = 123 #类变量
def func(self): #类方法
print('第一个类')
return 'hell python' s = test() #通过类实例化对象
str = s.func() #对象调用类方法
print(test.i) #通过类名调用类变量
print(str) #类返回值 #output
第一个类
123
hell python

类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性和方法;实例化类后可以使用其属性,也可以动态的为实例对象添加属性而不影响类对象。

可以使用点(.)来访问对象的属性,也可以使用函数的方式来访问属性:

class A(object):
def __init__(self,x):
self.x = x
def static_func(y=5):
print(y) d = A(10) #类实例化对象
print(getattr(d,'x')) #getattr访问对象的属性
print(hasattr(d,'x')) #hasattr检查对象属性是否存在
print(setattr(d,'y','zhang')) #设置对象的属性,如果属性不存在则创建新属性
print(d.y) #打印实例对象属性值
delattr(d,'y') #defattr删除对象属性
print(hasattr(d,'x')) #output
10
True
None
zhang
True

python3内置类属性:

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

__doc__:类的文档字符串

__name__:类名

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

__bases__:类的所有父类构成元素(包含了以上所有父类组成的元组)

class myclass(object):
class_n = 'foo'
def __init__(self,x,y,z):
self.x = x
self.y = y
self.z = z
def func_class(self):
print('out:',self.x,self.y,self.z) t = myclass('','','')
t.func_class() #调用实例方法 print('__dict__:',myclass.__dict__) #返回类的属性
print('__dict__:',t.__dict__) #返回实例属性
print('__name__:',myclass.__name__) #返回类名
print('__doc__:',myclass.__doc__)
print('__module__:',myclass.__module__) #返回类属在的模块
print('__mro__:',myclass.__mro__)
print('__bases__:',myclass.__bases__) #返回类对象 #output
out: 10 20 50
__dict__: {'__init__': <function myclass.__init__ at 0x0000004249F0F378>, '__doc__': None, 'func_class': <function myclass.func_class at 0x0000004249F0F400>, 'class_n': 'foo', '__dict__': <attribute '__dict__' of 'myclass' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'myclass' objects>}
__dict__: {'x': '', 'z': '', 'y': ''}
__name__: myclass
__doc__: None
__module__: __main__
__mro__: (<class '__main__.myclass'>, <class 'object'>)
__bases__: (<class 'object'>,)

类的专有方法:

  • __init__ 构造函数,在生成对象时调用

  • __del__ 析构函数,释放对象时使用

  • __repr__ 打印,转换

  • __setitem__按照索引赋值

  • __getitem__按照索引获取值

  • __len__获得长度

  • __cmp__比较运算

  • __call__函数调用

  • __add__加运算

  • __sub__减运算

  • __mul__乘运算

  • __div__除运算

  • __mod__求余运算

  • __pow__乘方

__init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法,类定义了__init__()方法后,类的实例化操作会自动调用__init__()方法,__init__()可以由参数,会传递到类的实例化操作上。

self代表类的实例,而非类本身,在类的内部,使用def关键字来定义一个方法,与一般函数定义不同,类方法必须包含self,且为第一个参数,self代表的是类的实例。

class test(object):
def __init__(self,name,age,salary): #初始化类属性
self.name = name
self.age = age
self.salary = salary #实例化对象会将类初始化到实例对象上 def buygo(self):
print('%s的工资是%s元' %(self.name,self.salary)) #调用类属性 #通过类实例化对象
zhansan = test('zhansan',20,8888)
lisi = test('lisi',22,6000)
#调用类方法
zhansan.buygo()
lisi.buygo() #output:
#zhansan的工资是8888元
#lisi的工资是6000元
class test1(object):
a = 10
b = 20
def get(self):
print('取幂:',self.a.__pow__(self.b))
print('求余数:',self.b.__mod__(self.a))
print('乘:',self.b.__mul__(self.a))
print('减:',self.b.__sub__(self.a))
print('加:',self.b.__add__(self.a))
print('输出:',self.b.__repr__()) d = test1()
d.get() #output
取幂: 100000000000000000000
求余数: 0
乘: 200
减: 10
加: 30
输出: 20

实例方法,类方法,静态方法,类属性,实例属性:

#实例方法,就是类的实例能够使用的方法
class myclass(object):
def __init__(self,name):
self.name = name
def instancefunc(self):
print('调用实例方法%s'%self.name) if __name__ == "__main__":
inst = myclass('zhangsan') #通过类创建实例
inst.instancefunc() #实例使用实例方法
myclass.instancefunc(inst) #类使用实例方法,需要传递实例参数
#类方法是将类本身作为对象进行操作的方法,类方法使用@classmethod装
#饰器定义,其第一个参数是类,约定为cls,也可以自己定义,类对象和实例
#都可以调用类方法,类方法只能调用类属性,不能调用实例属性。 class A(object):
number = 10 #定义类属性
def __init__(self,name): #初始化类属性
self.name = name
def car(self): #定义实例方法
print('实例方法:%s'%self.name)
@classmethod #定义类方法
def cat(cls):
print('类方法:%s'%cls.number) #此处不能调用类属性name,只能调用类属性number d = A('sb')
d.car() #实例调用实例方法
d.cat() #实例调用类方法
A.cat() #类调用类方法 #output
实例方法:sb
类方法:10
类方法:10
#静态方法是一种普通函数,就位于类定义的命名空间中,它不会对任何实例类
#型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可
#以调用静态方法,静态方法不能调用类属性和实例属性,但可以调用传参。 class A(object):
number = 10
def __init__(self,name):
self.name = name
def car(self):
print('实例方法:%s'%self.name)
@staticmethod #定义静态方法
def cat(x,y): #定义调用传参
print('静态方法:%s'%(x*y)) d = A('sb') #实例化类
d.car() #实例方法
d.cat(5,4) #实例调用静态方法
A.cat(6,3) #类调用静态方法 #output
实例方法:sb
静态方法:20
静态方法:18
#类属性与实例属性在实例方法,类方法,静态方法中的调用关系
class A(object):
number = 10 #定义类属性
def __init__(self,name):
self.name = name #实例属性
def car(self): #实例方法可以调用类属性和实例属性
print('实例方法:%s[%s]'%(self.name,self.number))
@classmethod
def cae(cls): #类方法只能调用类属性
print('类方法:%s'%cls.number) @staticmethod
def cat(x,y): #静态方法不能调用类属性和实例属性
print('静态方法:%s'%(x*y)) d = A('sb')
d.car()
A.car(d)
d.cae() #实例调用方法
A.cae() #类调用方法
d.cat(5,4)
A.cat(6,3) #output
实例方法:sb[10]
实例方法:sb[10]
类方法:10
类方法:10
静态方法:20
静态方法:18

3、类的封装

封装是面向对象的特征之一,是对象和类概念的主要特性。

封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

python通过变量名命名来区分属性和方法的访问权限,默认权限相当于c++和java中的public

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

类的私有方法:__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 self.__private_methods

class myclass(object):
def __init__(self,name,age): #构造方法,根据类创建对象时自动执行
self.name = name
self.age = age
def func(self):
print('%s今年%s'%(self.name,self.age)) #根据类创建对象,会自动执行类的__init__方法
obj1 = myclass('zs',18) #会将zs和18分别封装到类的self的name和age属性中
obj2 = myclass('ls',20) print(obj1.name,obj1.age) #直接调用obj1对象的属性
print(obj2.name,obj2.age) obj1.func() #默认会将obj1传递给self参数,即:obj1.func(obj1),所以此方法的内部self=obj1,self.name是zs
obj2.func() #output
zs 18
ls 20
zs今年18
ls今年20
class fater(object):
__name = '私有属性'
age = "公有属性"
def func(self):
print(self.age)
print(self.__name)
def __foo(self): #定义私有方法
print(self.__name)
class son(fater):
def show(self):
print(fater.age)
#print(fater.__name) print(fater.age)
print('----------------') obj1 = fater()
obj1.func()
print('----------------')
#obj1.__foo() #直接调用会报错,只有通过"_类名__方法"的形式调用
obj1._fater__foo() #调用私有方法
print(obj1.age)
#print(obj1.__name) #直接调用会报错,通过“_类名__属性”方法调用
print(obj1._fater__name) #调用私有属性 print('-------son----')
obj2 = son()
obj2.show() #调用父类属性
obj2.func()
obj2.__foo() #调用父类方法错误
obj2._fater__foo() #正确调用父类方法 #output
公有属性
----------------
func: 公有属性
func: 私有属性
----------------
__foo: 私有属性
公有属性
私有属性
-------son----
show: 公有属性
func: 公有属性
func: 私有属性
__foo: 私有属性

4、类继承

继承是面向对象的重要特征之一,继承是两个类或者多个类之间的父子关系,子类继承了父类的所有公有实例变量和方法。
继承实现了代码的重用。重用已经存在的数据和行为,减少代码的重新编写。
python在类名后用一对圆括号表示继承关系,括号中的类表示父类或基类
#经典类和新式类的区别:当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。
class old: #经典类写法
pass class new(object): #新式类写法
pass

在python中类继承的特点:

1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()

2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。

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

class test(object):   #定义父类
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary def buygo(self):
print('%s[%s]岁就有%s元的工资了' %(self.name,self.age,self.salary)) class test_student(test): #调用父类
def __init__(self,name,age,salary,nb):
test.__init__(self,name,age,salary) #重写父类构造方法
self.nb = nb
def buygo(self): #覆写类方法
print('%s[%s]岁就有%s元的工资了,很%s' %(self.name,self.age,self.salary,self.nb)) #通过类实例化对象
zhansan = test_student('zhansan',20,8888,'牛逼哦')
lisi = test_student('lisi',22,6000,'得瑟吧') zhansan.buygo()
lisi.buygo() #output:
zhansan[20]岁就有8888元的工资了,很牛逼哦
lisi[22]岁就有6000元的工资了,很得瑟吧

如果父类中的方法名相同于子类中的方法名,子类方法将覆盖父类方法。

多继承的优先级顺序是:在新式类中是从左往右查找,找到即停止;而经典类是深度查找的从左到右如:A(B,C),B(D),那么顺序是A->B->D->C

5、多态

多态依赖于继承,多态的作用,就是为了类在继承和派生的时候,保证继承类中实例的某个属性或方法的调用,实现了接口的重用。class A(object):    def __init__(self):

        self.name = 'ZHANGSAN'
def show(self):
print('A.show:',self.name)
class B(A):
def show(self):
print('show_b:',self.name)
class C(A):
def show(self):
print('show_c:',self.name) def func(obj): #定义函数,传递对象
obj.show() #通过类实例对象调用类下的方法 A_obj = A()
B_obj = B()
C_obj = C() func(A_obj)
func(B_obj)
func(C_obj) #output

A.show: ZHANGSAN
show_b: ZHANGSAN
show_c: ZHANGSAN

 

6、总结

  • 面向对象的知识总计如下:
  • 面向对象时一个编程方式,此编程方式的实现是基于对类和对象的使用
  • 类是一个模版,模版中包装了多个‘函数’供使用
  • 对象根据模块创建实例,实例可以调用被包装在类中的函数
  • 继承实现了多个类直接的方法属性调用,减少代码的重用性
  • 多态在继承的基础上解决了方法调用的重用,而不被子类给覆盖。
  • 面向对象的三大特性:封装、继承和多态

python3之面向对象的更多相关文章

  1. [Python3] 024 面向对象 第四弹

    目录 11. 类和对象的三种方法 12. 抽象类 12.1 抽象方法 12.2 抽象类 12.3 抽象类的使用 13. 自定义类 接上一篇 [Python3] 023 面向对象 第三弹 11. 类和对 ...

  2. [Python3] 023 面向对象 第三弹

    目录 7. 类相关函数 8. 类的成员描述符(属性) 9. 类的内置属性 10. 类的常用魔术方法 10.1 操作类 10.2 描述符 10.3 属性操作 10.4 运算分类相关魔术方法 接上一篇 [ ...

  3. [Python3] 022 面向对象 第二弹

    目录 6. 面向对象的三大特性 6.1 封装 6.1.1 私有 private 6.1.2 受保护 protected 6.1.3 公开 public 6.2 继承 6.2.1 继承的概念与作用 6. ...

  4. Python3中面向对象 OOP

    Python3中面向对象 OOP 定义: python中通过关键字 class 实现类的定义: class ClassName(object): pass 获取成员变量:ClassName.变量名 修 ...

  5. 【Python3之面向对象的程序设计】

    一.面向对象的程序设计的由来 1.第一阶段:面向机器,1940年以前 最早的程序设计都是采用机器语言来编写的,直接使用二进制码来表示机器能够识别和执行的指令和数据. 简单来说,就是直接编写 0 和 1 ...

  6. [Python3] 021 面向对象 第一弹

    目录 1. 面向对象概述 1.1 OOP 思想 1.2 几个名词 1.3 类与对象 2. 类的基本实现 2.1 类的命名 2.2 如何声明一个类 2.3 如何实例化一个类 2.4 如何访问对象成员 2 ...

  7. Python3 day6面向对象

    http://www.cnblogs.com/alex3714/articles/5188179.html ====================生活中==================== 世界 ...

  8. 【Python3之面向对象进阶】

    一.isinstance和issubclass 1.isinstance(obj,cls)检查是否obj是否是类 cls 的对象 class Foo(object): pass obj=Foo() p ...

  9. 笔记||Python3之面向对象

    面向对象编程:简称OOP. 是一种程序设计思想.oop把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数. 在python中,所有数据类型都可以视为对象,也可以自定义对象.自定义的对象数据类 ...

随机推荐

  1. Cygwin-Cygwin ssh Connection closed by ::1 出错

    问题描写叙述: Cygwin好不easy安装好了ssh服务,第一连接没有问题,能够显示相关信息 $ ssh localhost Last login: Sat Jul 25 09:00:30 2015 ...

  2. freemarker四种变量

    freemarker四种变量 1.简单介绍说明 (1)数据模型中的变量:root中的变量 (2)模板中的变量:使用<#assign>定义的变量 (3)局部变量:在指令中的变量 (4)循环变 ...

  3. Nginx事件处理中的connection和read、write事件的关联

    /*********************************************************************  * Author  : Samson  * Date   ...

  4. Mybatis 入门之resultMap与resultType解说实例

    resultMap:适合使用返回值是自己定义实体类的情况 resultType:适合使用返回值得数据类型是非自己定义的,即jdk的提供的类型 resultMap : type:映射实体类的数据类型 i ...

  5. char a[] = "ab\0123\098"; 求a的长度

      原因: \0表示后面的字符是八进制(\ddd); 8进制=10进制( 10是'\n' 的ASCII码): 当\0后面有数字,且数字范围在0~7之间时,为8进制转义.如'\012': 当\0后面没有 ...

  6. Microsoft Graph Web应用程序极致开发体验

    作者:陈希章 重写于 2017年5月24日 前言 这篇文章最早写于2017年5月2日,当时的想法是从最简单的方式来写如何在一个ASP.NET MVC应用程序中集成Microsoft Graph,但实际 ...

  7. 配置java项目的intellij idea的运行环境

    才疏学浅,只懂一点点前端的皮毛东西,对于项目运行环境的配置一无所知,今天简单记录一下! 前提:装好了jdk.maven.intellij idea. 1. file菜单->Open...打开从S ...

  8. 2. whoami,常用包,调优selinux,七种启动模式,系统开机服务

    1   whoami  查看当前登录用户      useradd zhang   增加用户      passwd  zhang       su - zhang     切换用户        e ...

  9. ES6之Proxy及Proxy内置方法

    Proxy是ES6提供的代理器可以起到拦截作用,写法形式如 var proxy = new Proxy(target,handler);参数target表示要拦截的目标对象,handler是用来定制拦 ...

  10. ConcurrentDictionary内部函数的使用说明

    AddOrUpdate(...)函数的使用: private static ConcurrentDictionary<long, string> condic = new Concurre ...