Python面向对象

发表于 | 分类于
字数统计: 1,118 | 阅读时长 ≈ 5

本文主要介绍python面向对象相关知识。

1.类和对象

(1)类的定义

  • 经典类：

    1
    2
    class class_name:
    	statements

  • 新型类：

    1
    2
    class class_name(object):
    	statements

  • 对象的创建
    object = class_name()

(2)属性和方法

  • 类的属性
    类的属性分为公有属性和私有属性：

    1
    2
    3
    class demo:
    	pub = 0			//公有属性
    	__pri = 0		//私有属性

  • 类的方法
    类的方法也分为公有方法和私有方法：

    1
    2
    3
    4
    5
    class demo:
    	def pub(self):						//公有方法
    		print 'pubilic function'
    	def __pri(self):					//私有方法
    		print 'private function'

  • 内部类

    1
    2
    3
    4
    5
    class demo:
    	class inner:
    		pub = 0
    		def fun(self):
    			print 'inner class'

(3)类的内置方法

内置方法 说明
init(self,…) 初始化对象，在创建新对象时调用
del(self) 释放对象，在对象被删除之前调用
new(cls,*args,**kwd) 实例的生成操作
str(self) 在使用print语句时调用
getitem(self,key) 获取序列的索引key对应的值，等价于seq[key]
len(self) 在调用内联函数len()时被调用
cmp(src,dst) 比较两个对象src和dst
getattr(s,name) 获取属性的值
setattr(s,name,val) 设置属性的值
delattr(s,name) 删除name属性
getattribute() 与getattr(s,name)类似
gt(self,other) 判断self对象是否大于other对象
lt(self,other) 判断self对象是否小于other对象
ge(self,other) 判断self对象是否大于或等于other对象
le(self,other) 判断self对象是否小于或等于other对象
eq(self,other) 判断self对象是否等于other对象
call(self,* args) 把实例对象作为函数调用

2.继承与派生

(1)关于继承
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可以称为基类或超类，新建的类称为派生类或子类。
python中类的继承分为：
单继承：子类只继承一个父类
多继承：子类继承多个父类

1
2
3
4
5
6
7
8
class ParentClass1:
	pass
class ParentClass2:
	pass
class SubClass1(ParentClass1):
	pass 
class SubClass2(ParentClass1,ParentClass2):
	pass

查看子类继承了哪些父类

1
2
3
4
>>> SubClass1.__bases__
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

如果没有指定基类（或叫父类），python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如str）的实现。

1
2
3
4
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

(2)继承顺序
当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找
只有Python2中才有新式类和经典类之分，Python3中统一都是新式类

(3)继承原理
对于你定义的每一个类，python都会计算出一个方法解析顺序（MRO）列表，这个MRO列表就是一个简单的所有蕨类的线性顺序列表，例如：

1
2
>>> F.mro() #等同于F.__mro__ 
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

(4)子类中调用父类的方法
方法一： 父类名.父类方法()

1
2
3
4
5
6
7
8
9
10
class Parentclass:
        def __init__(self,name,age)
                self.name = name
                self.age = age


class Subclass(Parentclass):
        def __init__(self,name,age,sex)
                Parentclass.__init__(self,name,age)
                self.sex = sex

方法二：利用super()函数

1
2
3
4
5
6
7
8
9
10
class Parentclass:
        def __init__(self,name,age)
                self.name = name
                self.age = age


class Subclass(Parentclass):
        def __init__(self,name,age,sex)
                super().__init__(name,age)
                self.sex = sex

3.多态与多态性

多态指的是一类事物有多种形态。一个抽象类有多个子类，因而多态的概念依赖于继承。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class animal:
    def talk(self):
        print("正在叫")

class people(animal):
    def talk(self):
        print("say hello")

class pig(animal):
    def talk(self):
        print("哼哼哼")

class dog(animal):
    def talk(self):
        print("汪汪汪")

peo = people()
pig1 = pig()
dog1 = dog()

def func(obj):
    obj.talk()
	
func(peo)
func(pig1)
func(dog1)

4.封装

封装数据的主要原因是：保护隐私
封装方法的主要原因是：隔离复杂度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Teacher:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

	def get_info(self):
        print('姓名:%s,年龄:%s' %(self.__name,self.__age))
		
	def set_info(self,name,age):
	    if not isinstance(name,str):
            raise TypeError('姓名必须是字符串类型')
	    if not isinstance(age,int):
            raise TypeError('年龄必须是整型')
	    self.__name=name
        self.__age=age

t=Teacher('egon',18)
t.get_info()

t.set_info('egon',19)
t.get_info()

---------------- The End ----------------