本节内容:

1:概述

2:类、对象和方法的创建

3:面向对象三大特性,封装、继承和多态。

4:面向对象中高级篇:类成员:字段、方法、属性

5:类成员的修饰符

6:类的特殊成员

1.概述

  • 面向过程:根据业务逻辑从上到下写垒代码
  • 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
  • 面向对象:对函数进行分类和封装,让开发“更快更好更强...”

2.类、对象和方法

在Python中,定义类是通过class关键字,class后面紧接着是类名,类名通常是大写开头的单词,紧接着是('要继承的类名'),表示该类是从哪个类继承下来的,通常如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类,也可以不写。

class MyClass():             # 创建类
def func(self): # 定义方法
pass obj1=MyClass() # 根据MyClass创建对象

类中定义方法的时候,和以前定义函数一样,都是用来实现某种功能的,不过定义方法的时候必须传至少一个参数(self),代表创建的对象,而函数则不需要,下面来看一下self具体指的什么。

class MyClass():
def func(self,str):
print(self,str) def func1(self,str):
pass
obj1=MyClass() # self 哪个对象调用的,self就是那个对象 obi <====> self
print(obj1) # <__main__.MyClass object at 0x000002C2119AD4A8>
obj1.func('jason') # <__main__.MyClass object at 0x000002C2119AD4A8>

3.面向对象三大特性,封装、继承和多态。

一、封装

面向对象有3大特性,首先我们来说第一个特性,封装,封装一般是通过在类中封装数据,通过对象或者self获取。和其他面向对象的语言类似,也是通过构造函数来进行数据封装。下面来看一下代码。

class A:
def __init__(self,name): # 构造函数,初始化数据,
self.name=name # 封装数据 def f1(self):
print(self.name) # 通过self获取封装的数据 a=A('json')
a.f1() #通过对象获取封装数据

还有一种封装的方式,使用私用的属性来封装数据,看一下具体的用法,

class A:
name='Jason'
__age=18 # 私有静态字段,
def __init__(self):
self.__like='soccer' # 私有普通字段
self.hobby='kkkk' def f1(self):
print(self.__age) # 私有静态字段,私有普通字段只能被类中的方法调用
print(self.__like)
# A.__age # 外部获取不到私有静态字段,数据被封装起来
a=A() # soccer
a.f1() # 18
print(a.hobby)

二、继承  

面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。

注:除了子类和父类的称谓,你可能看到过 派生类 和 基类 ,他们与子类和父类只是叫法不同而已。

那么问题又来了,多继承呢?

  • 是否可以继承多个类
  • 如果继承的多个类每个类中都定了相同的函数,那么那一个会被使用呢?

1、Python的类可以继承多个类,Java和C#中则只能继承一个类

2、Python的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先广度优先

  • 当类是经典类时,多继承情况下,会按照深度优先方式查找
  • 当类是新式类时,多继承情况下,会按照广度优先方式查找

经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了跟多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。

class C():
def bar(self):
print("C_bar") class D():
def bar(self):
print("C_bar") class B():
pass class A(B,C):
def f1(self):
print("A") a = A()
a.bar() ##C_bar 按深度优先

经典类继承

class D(object):

    def bar(self):
print ('D.bar') class C(D): def bar(self):
print ('C.bar') class B(D):
pass # def bar(self):
# print ('B.bar') class A(B, C):
pass # def bar(self):
# print('A.bar') a = A()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
# 所以,查找顺序:A --> B --> C --> D
# 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了
a.bar()

新式类继承

注意:在上述查找过程中,一旦找到,则寻找过程立即中断,便不会再继续找了

子类中执行父类的方法:两种

class B():
def foo(self):
print('foo') class A(B):
def bar(self):
super(A,self).foo() ##子类执行父类的方法 第一种 super(子类,self).父类中的方法(...)
B.foo(self) ##子类执行父类的方法 第二种  父类名.父类中的方法(self,....)
print('bar') a = A()
a.bar()
#输出
# foo
# foo
# bar

这个时候你可以想不到说,我调用父类应用的场景是什么,这时候我就给你制造一个场景,比如说别人已经有一个web框架了,都是按流程下来的,你要是想对他做个扩展要怎么搞?

原来的程序就是这样的:
class RequestHandler:
def get(self,arg):
print('为所欲为') 你的调用过程:先创建一个RequestHander的对象,然后再执行
obj = RequestHandler()
obj.get()

需求:要对他进行扩展:在他执行打印:为所欲为 之前,我还要打印一句说:注意:您的所以操作都有记录

实现:

class RequestHandler:
def get(self, arg):
print('为所欲为') class BaseHandler(RequestHandler):
def get(self, arg):
print('注意:您的所以操作都有记录')
super(BaseHandler,self).get("sss") obj = BaseHandler()
obj.get("ss")
#输出:
#注意:您的所以操作都有记录
#为所欲为

三、多态

python本身就是支持多态的,所以在Python面向对象里面讨论多态并没有什么意义,这里也就不多讲了

4:面向对象中高级篇:类成员:字段、方法、属性

类成员:

# 字段
- 普通字段,保存在对象中,执行只能通过对象访问
- 静态字段,保存在类中, 执行 可以通过对象访问 也可以通过类访问
# 方法
- 普通方法,保存在类中,由对象来调用,self=》对象
- 静态方法,保存在类中,由类直接调用
- 类方法,保存在类中,由类直接调用,cls=》当前类 ######## 应用场景:
如果对象中需要保存一些值,执行某功能时,需要使用对象中的值 -> 普通方法
不需要任何对象中的值,静态方法 # 属性,特性
- 不伦不类

一、字段

字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,

  • 普通字段属于对象
  • 静态字段属于
class Foo:

class Foo:

    # 静态字段
country = "China" def __init__(self, name): # 普通字段
self.name = name # 直接访问静态字段
a = Foo.country
print(a) # 直接访问普通字段
obj = Foo("山西")
aa = obj.country
print(aa) # 输出:
# China
# China

其在内容的存储方式类似如下图:

由上图可是:

  • 静态字段在内存中只保存一份
  • 普通字段在每个对象中都要保存一份

应用场景: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段

二、方法

方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。

  • 普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self
  • 类方法:由调用; 至少一个cls参数;执行类方法时,自动将调用该方法的复制给cls
  • 静态方法:由调用;无默认参数;
class A:

    def show(self):                 # 普通方法,保存在类中,对象通过类对象使用
print('普通方法') @staticmethod # 静态方法,保存在类中
def f1(): # 没有 self 参数
print('静态方法') @classmethod # 类方法 相当于静态方法加了一个类名参数
def f2(cls): # 将当前类名当作参数传进去
print('类方法') a = A()
a.show()
a.f1()
a.f2() # 普通方法
# 静态方法
# 类方法

相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份。

不同点:方法调用者不同、调用方法时自动传入的参数不同。

三、属性  

如果你已经了解Python类中的方法,那么属性就非常简单了,因为Python中的属性其实是普通方法的变种。

对于属性,有以下三个知识点:

  • 属性的基本使用
  • 属性的两种定义方式

1:属性的基本使用

class A:

    def __init__(self,name):
self.name = name @property # 属性或者叫特性,将普通方法伪装成字段,但是不能传入第二个参数
def f3(self):
print('属性')
return self.name @f3.setter # 设置属性
def f3(self, value):
print(value)
self.name = value a = A("crik")
cc=a.f3
print(cc)
a.f3= # 属性
# crik
#

由属性的定义和调用要注意一下几点:

  • 定义时,在普通方法的基础上添加 @property 装饰器;
  • 定义时,属性仅有一个self参数
  • 调用时,无需括号
               方法:foo_obj.func()
               属性:foo_obj.prop

注意:属性存在意义是:访问属性时可以制造出和访问字段完全相同的假象

属性由方法变种而来,如果Python中没有属性,方法完全可以代替其功能。

2.属性定义的方式:

1:直接在方法上 加装饰器 @property
2:静态字段方式,创建值为property对象的静态字段

class Foo:

    def get_bar(self):
return 'nick' # *必须两个参数
def set_bar(self, value):
return 'set value' + value def del_bar(self):
return 'nick' BAR = property(get_bar, set_bar, del_bar, 'description...') obj = Foo() obj.BAR # 自动调用第一个参数中定义的方法:get_bar
obj.BAR = "jenny" # 自动调用第二个参数中定义的方法:set_bar方法,并将“jenny”当作参数传入
del Foo.BAR # 自动调用第三个参数中定义的方法:del_bar方法
obj.BAR.__doc__ # 自动获取第四个参数中设置的值:description...

5.类成员的修饰符

类的所有成员在上一步骤中已经做了详细的介绍,对于每一个类的成员而言都有两种形式:

  • 公有成员,在任何地方都能访问
  • 私有成员,只有在类的内部才能方法

私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)

class C:

    def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"

私有成员和公有成员的访问限制不同

静态字段

  • 公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
  • 私有静态字段:仅类内部可以访问;
class C:

    name = "公有静态字段"

    def func(self):
print C.name class D(C): def show(self):
print C.name C.name # 类访问 obj = C()
obj.func() # 类内部可以访问 obj_son = D()
obj_son.show() # 派生类中可以访问

公有静态字段

class C:

    __name = "公有静态字段"

    def func(self):
print C.__name class D(C): def show(self):
print C.__name C.__name # 类访问 ==> 错误 obj = C()
obj.func() # 类内部可以访问 ==> 正确 obj_son = D()
obj_son.show() # 派生类中可以访问 ==> 错误

私有静态字段

普通字段

  • 公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
  • 私有普通字段:仅类内部可以访问;

ps:如果想要强制访问私有字段,可以通过 【对象._类名__私有字段明 】访问(如:obj._C__foo),不建议强制访问私有成员。

class C:

    def __init__(self):
self.foo = "公有字段" def func(self):
print self.foo  # 类内部访问 class D(C): def show(self):
print self.foo # 派生类中访问 obj = C() obj.foo # 通过对象访问
obj.func() # 类内部访问 obj_son = D();
obj_son.show() # 派生类中访问

公有普通字段

class C:

    def __init__(self):
self.__foo = "私有字段" def func(self):
print self.foo  # 类内部访问 class D(C): def show(self):
print self.foo # 派生类中访问 obj = C() obj.__foo # 通过对象访问 ==> 错误
obj.func() # 类内部访问 ==> 正确 obj_son = D();
obj_son.show() # 派生类中访问 ==> 错误

私有普通字段

方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用

ps:非要访问私有属性的话,可以通过 对象._类__属性名

6.类的特殊成员

1. __doc__

表示类的描述信息

class Foo:
""" 描述类信息 """ def func(self):
pass print Foo.__doc__
#输出:类的描述信息

2. __module__ 和  __class__ 

  __module__ 表示当前操作的对象在那个模块

  __class__     表示当前操作的对象的类是什么

#!/usr/bin/env python
# -*- coding:utf- -*- class C: def __init__(self):
self.name = 'nick'

lib/aa.py

from lib.aa import C

obj = C()
print obj.__module__ # 输出 lib.aa,即:输出模块
print obj.__class__ # 输出 lib.aa.C,即:输出类

index.py

3. __init__

  构造方法,通过类创建对象时,自动触发执行。

class Foo:

    def __init__(self, name):
self.name = name
self.age = obj = Foo('nick') # 自动执行类中的 __init__ 方法

4. __del__

析构方法,当对象在内存中被释放时,自动触发执行。

注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
pass

5. __call__

  对象后面加括号,触发执行。

注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

# __call__
class Foo: def __init__(self):
print("This is init") def __call__(self, *args, **kwargs):
print("This is call")
return "CC" obj = Foo() # 执行 __init__
obj() # 执行 __call__ result = Foo()() # 执行 __call__
print(result)

6. __dict__

  类或对象中的所有成员

上文中我们知道:类的普通字段属于对象;类中的静态字段和方法等属于类,即:

class Province:

    country = 'China'

    def __init__(self, name, count):
self.name = name
self.count = count def func(self, *args, **kwargs):
print 'func' # 获取类的成员,即:静态字段、方法、
print Province.__dict__
# 输出:{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None} obj1 = Province('shangxi',)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出:{'count': , 'name': 'shangxi'} obj2 = Province('shangdong', )
print obj2.__dict__
# 获取 对象obj1 的成员
# 输出:{'count': , 'name': 'shangdong'}

 7. __str__

  如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。

class Foo:

    def __str__(self):
return 'nick' obj = Foo()
print obj
# 输出:nick

8、__getitem__、__setitem__、__delitem__

用于索引操作,如字典。以上分别表示获取、设置、删除数据

class Foo:

    def __getitem__(self, item):
print(item) def __setitem__(self, key, value):
print(key, value) def __delitem__(self, key):
print(key) obj = Foo() obj["nick"] # 自动触发执行 __getitem__
obj["nick"] = "jenny" # 自动触发执行 __setitem__
del obj["nick"] # 自动触发执行 __delitem__

9、__getslice__、__setslice__、__delslice__

该三个方法用于分片操作,如:列表

class Foo(object):

    def __getslice__(self, i, j):
print '__getslice__',i,j def __setslice__(self, i, j, sequence):
print '__setslice__',i,j def __delslice__(self, i, j):
print '__delslice__',i,j obj = Foo() obj[-:] # 自动触发执行 __getslice__
obj[:] = [,,,] # 自动触发执行 __setslice__
del obj[:] # 自动触发执行 __delslice__

10. __iter__ 

用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__

#!/usr/bin/env python
# -*- coding:utf- -*- class Foo(object): def __init__(self, sq):
self.sq = sq def __iter__(self):
return iter(self.sq) obj = Foo([,,,]) for i in obj:
print i

__iter__

11. __new__ 和 __metaclass__

阅读以下代码:

class Foo(object):

    def __init__(self):
pass obj = Foo() # obj是通过Foo类实例化的对象

上述代码中,obj 是通过 Foo 类实例化的对象,其实,不仅 obj 是一个对象,Foo类本身也是一个对象,因为在Python中一切事物都是对象

如果按照一切事物都是对象的理论:obj对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的 构造方法 创建。

print type(obj) # 输出:<class '__main__.Foo'>     表示,obj 对象由Foo类创建
print type(Foo) # 输出:<type 'type'> 表示,Foo类对象由 type 类创建

所以,obj对象是Foo类的一个实例Foo类对象是 type 类的一个实例,即:Foo类对象 是通过type类的构造方法创建。

那么,创建类就可以有两种方式:

a). 普通方式

class Foo(object):

    def func(self):
print 'hello wupeiqi'

b).特殊方式(type类的构造函数)

def func(self):
print 'hello wupeiqi' Foo = type('Foo',(object,), {'func': func})
#type第一个参数:类名
#type第二个参数:当前类的基类
#type第三个参数:类的成员 

==》 类 是由 type 类实例化产生

那么问题来了,类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?

答:类中有一个属性 __metaclass__,其用来表示该类由 谁 来实例化创建,所以,我们可以为 __metaclass__ 设置一个type类的派生类,从而查看 类 创建的过程。

class MyType(type):

    def __init__(self, what, bases=None, dict=None):
super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs):
obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name):
self.name = name def __new__(cls, *args, **kwargs):
return object.__new__(cls, *args, **kwargs) # 第一阶段:解释器从上到下执行代码创建Foo类
# 第二阶段:通过Foo类创建obj对象
obj = Foo()

Day7 - Python基础7 面向对象的更多相关文章

  1. Day7 - Python基础7 面向对象编程进阶

    Python之路,Day7 - 面向对象编程进阶   本节内容: 面向对象高级语法部分 经典类vs新式类 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个 ...

  2. Python之路,Day7 - Python基础7 面向对象

    本节内容:   面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法.     引子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战> ...

  3. Python 基础 四 面向对象杂谈

    Python 基础  四  面向对象杂谈 一.isinstance(obj,cls) 与issubcalss(sub,super) isinstance(obj,cls)检查是否obj是否是类 cls ...

  4. 自学Python之路-Python基础+模块+面向对象+函数

    自学Python之路-Python基础+模块+面向对象+函数 自学Python之路[第一回]:初识Python    1.1 自学Python1.1-简介    1.2 自学Python1.2-环境的 ...

  5. 二十. Python基础(20)--面向对象的基础

    二十. Python基础(20)--面向对象的基础 1 ● 类/对象/实例化 类:具有相同属性.和方法的一类人/事/物 对象(实例): 具体的某一个人/事/物 实例化: 用类创建对象的过程→类名(参数 ...

  6. python基础,函数,面向对象,模块练习

    ---恢复内容开始--- python基础,函数,面向对象,模块练习 1,简述python中基本数据类型中表示False的数据有哪些? #  [] {} () None 0 2,位和字节的关系? # ...

  7. (转)Python成长之路【第九篇】:Python基础之面向对象

    一.三大编程范式 正本清源一:有人说,函数式编程就是用函数编程-->错误1 编程范式即编程的方法论,标识一种编程风格 大家学习了基本的Python语法后,大家就可以写Python代码了,然后每个 ...

  8. Python基础7 面向对象编程进阶

    本节内容: 面向对象高级语法部分 经典类vs新式类 静态方法.类方法.属性方法 类的特殊方法 反射 异常处理 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 面向对象高级语法部分 经典 ...

  9. Python之路【第六篇】python基础 之面向对象(一)

    一.三大编程范式 1.面向过程编程 2.函数式编程 3.面向对象编程 二.编程进化论 1.编程最开始就是无组织无结构,从简单控制流中按步写指令 2.从上述的指令中提取重复的代码块或逻辑,组织到一起(比 ...

随机推荐

  1. Mac Electron App 签名后打开闪退

    背景 昨天在测试 Mac Electron App 打包,发现不签名的应用能够正常打开,签了名的打开反而会崩溃. 寻因 首先我怀疑是不是自己代码导致闪退,但是在一番查找后,发现还根本没到执行我的代码就 ...

  2. Git 在同一台机器上配置多个Git帐号

    在同一台机器上配置多个Git帐号 By:授客 QQ:1033553122 实践环境 win10 Git-2.21.0-64-bit.exe TortoiseGit-2.8.0.0-64bit.msi ...

  3. 一些webpack常见编译报错的解决方案

    重新安装依赖可以解决80%的webpack编译报错问题. rm -rf node_modules rm package-lock.json npm cache clear --force npm in ...

  4. 表空间相关SQL

    --查表空间使用率情况(含临时表空间)SELECT D.TABLESPACE_NAME "Name", D.STATUS "Status", TO_CHAR(N ...

  5. nginx 校验及重启

    #查询nginx所在路径 [centos find 查询文件](https://www.cnblogs.com/codeWorldCodeHeart/p/12049262.html) #校验如下 /u ...

  6. 解读并加工BeautifulReport 报告模板

    使用unittest框架的脚本执行完成后,会生成一个html格式的报告 这个报告是提前制作了一个html的模板,然后将对应的内容写入到模板中,并生成一个最终的报告,这个报告模板在通过 pip inst ...

  7. C#语法基础----变量 符号 数据转换

    变量的作用:为了更好的管理内存数据,不同类型的数据存放在不同的内存块中. 变量的特点:不同数据类型占用的存储空间大小不一样. 变量的意义:内存地址是一串十六进制数,非常不好记忆,通过变量可以快速找到数 ...

  8. 【西北师大-2108Java】第十一次作业成绩汇总

    [西北师大-2108Java]第十一次作业成绩汇总 作业题目 面向对象程序设计(JAVA) 第13周学习指导及要求 实验目的与要求 (1)掌握事件处理的基本原理,理解其用途: (2)掌握AWT事件模型 ...

  9. cisco ssh实验--附带配置脚本-2019.11.19

    cisco ssh实验

  10. 【nodejs原理&源码赏析(5)】net模块与通讯的实现

    目录 一. net模块简介 二. Client-Server的通讯 2.1 server的建立 2.2 Socket的建立 三. IPC通讯 四. 撸一个简易的cluster通讯模型 示例代码托管在: ...