最新消息:博主的视频课程:Django高级实战教程 开发企业级问答网站开发

Python面向对象编程

Python liaogx 来源:西部世界 893浏览 0评论

一、面向对象基础知识:面向对象初级篇  面向对象进阶篇

C#/Java:只能使用面向对象编程

Ruby/Python:函数编程 + 面向对象

1.面向过程编程

2.函数式编程,def 函数

3.面向对象编程,类封装 def 函数(函数在类里面称之为方法)

calss example:

def func1(self, arg1):

print(self, arg1)

def func2(self, arg1, arg2):

print(self, arg1, arg2)

obj = example()  #根据类创建对象/实例 (不同对象内存中地址空间不一样)

obj.func1(arg01)

obj.func2(arg01,arg02)

self参数:形式参数,Python内部传递。类中方法被对象调用时,对象被传递到self,故self和对象在内存中地址相同

class example:

def func1(self,arg1):

print(self,arg1)

def func2(self,arg1,arg2):

print(self,arg1,arg2)

obj1=example()

obj2=example()

obj1.func1(‘liaogaoxiang’)

print(obj1)

obj2.func2(‘liao’,’gaoxiang’)

print(obj2)

===============================================

<__main__.example object at 0x011DDB30> liaogaoxiang

<__main__.example object at 0x011DDB30>

<__main__.example object at 0x01226590> liao gaoxiang

<__main__.example object at 0x01226590>

二、类的封装

1.类后加”()”表示执行其构造方法 __init__(self):

class example:

def __init__(self,user):

self.passowd=’123456′

self.username=user

def func1(self):

print(self.passowd)

print(self.username)

obj1=example(‘liaogx01’)

obj1.func1()

===============================================

123456

liaogx01

2.__del__(self):析构方法,解释器销毁对象时候自动调用

3.封装的使用场景:

①.当同一类型的方法有相同参数时,直接封装到对象即可。

②.把类当做模板,创建多个对象(对象内封装的数据不一样)

三、类的继承

1.子类可以继承父类中所有功能

2.当子类和父类同事存在时,优先查找执行子类功能

3.Python是多继承语言, C#/Java是单继承语言

4.Python 有两个判断继承的函数:isinstance() 用于检查实例类型;issubclass() 用于检查类继承。

5.继承的搜索顺序就是所谓的「方法解析顺序」(Method Resolution Order,或MRO)Python 至少有三种不同的 MRO:

①.经典类(classic class)的深度遍历

②.Python 2.2 的新式类(new-style class)预计算

③.Python 2.3 的新式类的 C3 算法。它也是 Python 3 唯一支持的方式

6.如何执行父类的构造方法:

class School:

def __init__(self,name):

self.name=name

class Major(School):

def __init__(self,name,id):

School.__init__(self,name)  #执行基类构造方法①

self.id=id

print(name,id)

class Teacher(School):

def __init__(self,name,number):

super(Teacher,self).__init__(name)  #执行基类构造方法②

self.number=number

print(name,number)

Major(‘SSPU’,201209)

Teacher(‘SSPU’,700)  #为什么此处写成’007’时会报错??

==========================================================================

SSPU 201209

SSPU 700

四、多态

1.Python原生支持多态

2.扩展

①.重载:函数名相同,参数个数不同(Python不支持)

②.重写:派生类中重新实现基类中的方法

五、类成员

1.利用反射查看面向对象成员归属

class School:

def __init__(self,name):

self.name=name

class Major(School):

def __init__(self,name,id):

School.__init__(self,name)  #执行基类构造方法①

self.id=id

print(name,id)

class Teacher(School):

def __init__(self,name,number):

super(Teacher,self).__init__(name)  #执行基类构造方法②

self.number=number

print(name,number)

def show(self):

print(‘show’)

Major(‘SSPU’,201209)

obj=Teacher(‘SSPU’,700)  #为什么此处写成’007’时会报错??

”’

反射:以字符串的形式去对象(模块)中操作成员

反射——通过‘类’只能查找到类中的成员

反射——通过‘对象’可以找到对象和类中的成员

”’

print(hasattr(Teacher,’name’),hasattr(obj,’name’))

print(hasattr(Teacher,’show’),hasattr(obj,’name’))

=====================================================================

SSPU 201209

SSPU 700

False True

True True

2.(类成员)静态字段/普通字段/静态方法/普通方法/类方法,通过对象或类均能访问,但按规范是通过类访问静态字段、静态方法和类方法,通过对象访问普通字段和普通方法

class Foo:

country=”China”  #静态字段:将诸多对象中相同的内容只在类里保存一份

def __init__(self,name):

self.name=name  #普通字段

#普通方法↓

def show(self):

print(self.name,self.country)

@staticmethod  #’@statcimethod’用于装饰类的方法,使其变成静态方法(没有self参数,与对象无关)

def example():

print(‘This is a staticmethod.’)

@classmethod  #类方法,规范通过类访问

def example2(cls):  #定义类方法时,必须含有cls参数(类作为参数)

print(‘This is a calssmethod.’)

Hubei=Foo(‘Hubei’)

Henan=Foo(‘Henan’)

Hubei.show()

Henan.show()  #通过对象访问普通字段和普通方法

print(Foo.country)  #通过类直接访问静态字段

print(Foo.example())  #通过类直接访问静态方法

print(Foo.example2())  #通过类直接访问类方法

======================================================================

Hubei China

Henan China

China

This is a staticmethod.

None

This is a calssmethod.

None

3.类成员的特性

class Fuck:

def __init__(self,name):

self.name=name

def start(self):

start=”%s, start fucking”%self.name

return start

@property

def stop(self):  #不能传递参数

stop=”%s, stop fucking” % self.name

returnstop

@stop.setter  #用于给stop函数设置值(传递参数),函数stop必须同名

def stop(self,change_value):

print(change_value)

self.name=change_value  #更改内存中实例的值

obj=Fuck(‘Please’)

print(obj.start())  #当没有property特性时,通过函数的方式访问

print(obj.stop)  #加上property特性之后,通过字段的方式访问

obj.stop=’Emellia’

print(obj.stop)

==========================================================================

Please, start fucking

Please, stop fucking

Emellia

Emellia, stop fucking

4.类成员修饰符

class Fuck:

a=’aa’  #公共静态字段,类的内外部都能访问

__b=’bb’  #私有静态字段,只能在类内部访问

def __init__(self,name):

self.name=name

@staticmethod

def __sm():  #私有静态方法

print(‘staticmethod.’)

def print(self):  #公有普通方法

print(self.__b)

Fuck.__sm()  #↑间接实现外部访问私有静态方法

obj=Fuck(‘x’)

print(Fuck.a)  #print(Fuck.__b)#AttributeError:typeobject’Fuck’hasnoattribute’__b’

print(obj._Fuck__b)  #Pyhton中特殊语法,通过‘_’+‘类名’+‘__(私有字段)’访问私有字段

obj.print()

=============================================================================

aa

bb

bb

staticmethod.

5.类的特殊成员

1.call

class Fuck:

def __init__(self):

print(‘init’)

def __call__(self):

print(‘call’)

return 1

obj=Fuck()  #类后加‘()’表示执行__init__方法

obj()  #对象后面加‘()’表示执行__call__方法

print(‘=====’)

print(Fuck()())  #依次输出__init__、__call__、return返回值的结果

=========================================================================

init

call

=====

init

call

1

2.setitme/geitem/delitem/dict

class Fuck:

def __init__(self):

print(‘init’)

def __call__(self):

print(‘call’)

return1

def __getitem__(self,item):

print(item)

def __setitem__(self,key,value):

print(key,value)

def __delitem__(self,key):

print(key)

obj=Fuck()

obj[‘gettime’]  #对象后面加[‘value’]将执行类中的__getitem__方法,将value值传递给item

obj[‘my_key’]=’my_value’  #对象后加[‘my_key’]=’my_value’将执行类中的__setitem__方法,将my_key,my_value依次传递给key,value

delobj[‘delitem’]  #对象后面加[‘deltiem’]将执行类中的__delitem__方法,将delitem值传递给key

print(Fuck.__dict__)  #表示类中所有的成员

print(obj.__dict__)  #表示对象中所有的成员

===================================================================

init

gettime

my_key my_value

delitem

{‘__init__’: <function Fuck.__init__ at 0x02B7AF18>, ‘__doc__’: None, ‘__setitem__’: <function Fuck.__setitem__ at 0x02B7AF60>, ‘__weakref__’: <attribute ‘__weakref__’ of ‘Fuck’ objects>, ‘__call__’: <function Fuck.__call__ at 0x02B7AE88>, ‘__getitem__’: <function Fuck.__getitem__ at 0x02B7AD68>, ‘__module__’: ‘__main__’, ‘__dict__’: <attribute ‘__dict__’ of ‘Fuck’ objects>, ‘__delitem__’: <function Fuck.__delitem__ at 0x02B7AE40>}

{}

3.iter/str/object

class Fuck(object):  #Python中object类是所有类的基类

def __iter__(self):  #迭代器用于迭代生成器

yield 1

yield 2

yield 3

yield 4

def __str__(self):  #此方法返回什么值,输出对象时就输出什么值

return ‘__str__’

obj=Fuck()  #for循环对象时,会自动执行对象中的__iter__方法

for i in obj:

print(i)

print(obj)  #输出__str__方法的返回值

print(type(Fuck),type(obj))  #Python中一切事物皆对象,obj对象由Fuck类创建;Fuck类对象由type类创建

==========================================================================

1

2

3

4

__str__

<class ‘type’> <class ‘__main__.Fuck’>

六、异常处理

inp=input(“请输入整数:”)

try:

num=int(inp)

print(num)

raise Exception(‘Wrong!’)  #将字符串‘Wrong!’传递给Exception对象,主动触发异常

except Exception as e:  #Exception可以捕捉到任何错误,具体错误类都是Exception的派生类

print(“您输入的不是整数”)

print€  #e表示封装了错误信息的对象

1.Python完整的异常处理结构

try:

#主代码块

pass

except KeyError,e:

#异常时,执行该块

pass

else:

#主代码块执行完,执行该块

pass

finally:

#无论异常与否,最终执行该块

pass

2.Python中常见的异常

AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
IOError 输入/输出异常;基本上是无法打开文件
ImportError 无法引入模块或包;基本上是路径问题或名称错误
IndentationError 语法错误(的子类) ;代码没有正确对齐
IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,导致你以为正在访问它
ValueError 传入一个调用者不期望的值,即使值的类型是正确的

七、断言

#assert条件,一般做测试用

assert1==1#正常

assert1==2#报错AssertionError

转载请注明:西部世界 » Python面向对象编程

发表我的评论
取消评论

表情