开发者社区> 余二五> 正文

Python面向对象编程

简介:
+关注继续查看

什么是类和对象?

python中,一切皆为对象,比如人就是一个对象,汽车、房子都是对象。

每一个对象都有自己的属性,比如人这个对象的属性有性别、身高、年龄等等

房子的属性有房价、面积、户型等等

python中,一个对象的特征也称为属性(attribute)。它所具有的行为也称为方法(method

所以:对象=属性+方法


在python中,我们把具有相同属性和方法的对象归为一个类(class)

比如:人、动物、植物、建筑等等


类是对象的模板和蓝图,对象是类的实例化。类不代表具体的事物,而对象表示具体的事物。

注意:属性为对象所有,类不具有对象的属性!!!

初始化对象:

创建类时,可以定义一个特定的方法为__init__()。只要创建类的实例,就会运行该方法。可以向

__init__()方法传递参数,这样可以在实例化对象时,把属性设置为你希望的值


例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python
#-*-coding:utf-8-*-
 
class person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #self.__private = flag
 
    def action(self):
        return self.name +' 在上班'
 
p1 = person('laowang',50)
print p1.name
print p1.age
 
输出结果:
1
2
laowang
50





什么是静态字段和动态字段?


上面的self是什么?Name、Age是什么?name、age又是什么?

self是创建对象的值,也就是说它表示对象本身,在上面的例子中self就是p1,而Name、Age是对象的属性,这种属于对象的字段叫做动态字段。name、age是创建对象时需要传递的参数。


上面的例子中memo是什么?它属于类还是某一个对象?

memo属于类,这种属于类的字段通常被称为静态字段。self.xx才是属于对象的

属于类的字段,静态字段使用类名.字段名来访问,例如上例中 person.memo

动态字段使用对象名.字段名,例如上例中p1.Name、p1.Age


类能否访问动态字段?对象能否访问静态字段?

类不能访问动态字段,因为动态字段是对象的一个属性,只属于对象。对象可以访问静态字段。访问方法:对象名.静态字段名,在前面的例子中为 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python
#-*-coding:utf-8-*-
 
class person:
    memo = '我是静态字段'
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #self.__private = flag
 
    def action(self):
        return self.name +' 在上班'
 
p1 = person('laowang',50)
print person.memo

输出结果:

1
我是静态字段



注意:为了避免歧义,尽量避免对象访问静态字段



什么是静态方法和动态方法?

在最开始,我们说过

对象=属性+方法

那么什么是方法?

方法就是对象的一个行为,在python中方法就是一个函数,它可以被对象所调用,对象调用方法的可以这样写:对象名.方法名,

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python
#-*-coding:utf-8-*-
 
class person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        #self.__private = flag
 
    def action(self):
        return self.name +' 在上班'
 
p1 = person('laowang',50)
print p1.action()

输出结果:

1
laowang 在上班


上例中action(self)这种带有参数的方法叫动态方法,动态方法只能被对象访问,而不能被类访问。

有了动态方法则也有静态方法,那么如果定义一个静态方法?


定义一个静态方法,有两个要求:

1、需要在动态方法上加一个装饰器“@staticmethod”

2、去掉self,因为静态方法属于类,而self属于对象

创建静态方法:

1
2
3
@staticmethod
def foo():
    print '这是一个静态方法'


1
2
3
4
5
6
7
8
9
10
11
12
13
class person:
    # #静态字段
    # memo = '众多物种之一'
    # #__init__函数用来对类进行实例化
    def __init__(self,name,age,male):
        pass
 
    #静态方法
    @staticmethod
    def static():
        return "这是一个静态方法"
 
print person.static()

输出结果:

1
这是一个静态方法


总结:静态方法和动态方法的区别

静态方法能被类和对象访问,而动态方法只能被对象访问。静态方法需要@staticmethod装饰器修饰,并且不带有self



什么是特性(property)?

特性是字段和方法之外的一个定义,他不同于字段和方法,通常用来返回值,特性能被对象调用,

调用方法:对象名.方法名  注意方法名后面没有括号

如果定义一个特性?

在动态方法上加一个装饰器@property

例如:

1
2
3
@property
def bar(self):
    return self.Name


class person:
    # #静态字段
    # memo = '众多物种之一'
    # #__init__函数用来对类进行实例化
    def __init__(self,name,age,male):
        #动态字段
        self.Name=name
        self.Age=age
        self.__male = male
    #动态方法
    # def action(self):
    #     return self.Name + '正在上班'

    #静态方法
    @staticmethod
    def static():
        return "这是一个静态方法"

    #特性
    @property
    def Bar(self):
        return self.Name



静态方法什么情况下使用?

场景:假设我们需要操作数据库,会执行增删改查动作,每一个动作就是一个方法,如果使用动态方法,那么每一次查询需要创建一个对象,每一次修改需要创建一个对象,如果使用静态方法,则不需要创建多个对象了。因为静态方法可以使用类.静态方法来访问。

其实静态方法和一个普通的函数没有什么区别。用的也并不多。Python是一个模块化的语言,为了面向对象编程,才弄出一个和其他语言一样的静态方法出来。这是历史遗留问题。



私有字段和私有方法

如何定义私有字段?

定义私有字段时,使用self.__name = name的方式,即在字段名前面加两个下划线。

私有字段能够被对象访问?

默认情况下,私有字段不能直接被对象访问。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python
#-*-coding:utf-8-*-
 
class person:
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__heigtht = flag
 
    def action(self):
        return self.name +' 在上班'
 
p1 = person('laowang',50,True)
#print p1.name
print p1.__height

输出结果:

1
2
3
4
Traceback (most recent call last):
  File "C:/Users/zenge/PycharmProjects/2/day4/.py", line 17, in <module>
    print p1.__height
AttributeError: person instance has no attribute '__height'


如何使私有字段被对象访问?

私有字段只有被定义到方法中,并return出来然后使用对象.方法的方式才能访问

还是上面的例子,我们修改下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__heigtht = flag
    def action(self):
        return self.name +' 在上班'
    def show(self):
        return self.__heigtht
p1 = person('laowang',50,True)
#print p1.name
print p1.show()

输出结果:

1
True

所以,要访问私有字段,必须将私有字段定义成一个访问,并return这个字段。


我们还可以使用@property来获取私有字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__heigtht = flag
    def action(self):
        return self.name +' 在上班'
    def show(self):
        return self.__heigtht
    @property
    def foo(self):
        return self.__heigtht
 
p1 = person('laowang',50,True)
#print p1.name
print p1.foo

输出结果:

1
True


私有方法

如何定义一个私有方法?

在方法名前面加加两个下划线即可。

私有方法能否直接被对象访问呢?

看下面的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__heigtht = flag
    def action(self):
        return self.name +' 在上班'
    def show(self):
        return self.__heigtht
    #私有方法
    def __sha(self):
        return '我是私有方法'
p1 = person('laowang',50,True)
#print p1.name
print p1.__sha()

输出结果:

1
2
3
4
Traceback (most recent call last):
  File "C:/Users/zenge/PycharmProjects/2/day4/.py", line 25, in <module>
    print p1.sha()
AttributeError: person instance has no attribute '__sha'


如何使私有方法被对象访问?

我们可以通过定义一个公有方法,在这个公有方法中return私有方法,这样对象就可以使用对象.方法的方式访问私有方法啦

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person:
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__heigtht = flag
    def action(self):
        return self.name +' 在上班'
    def show(self):
        return self.__heigtht
    #私有方法
    def __sha(self):
        return '我是私有方法'
    def public(self):
        return self.__heigtht
p1 = person('laowang',50,True)
#print p1.name
print p1.public()

输出结果

1
True


私有字段和私有方法什么情况下使用?

私有字段和私有方法是不能被外部调用的,只有在你定义的类里面被调用,所以如果你不想某个方法或者字段被外部调用时,就可以使用私有方法和私有方法,例如你写的接口的中的账号密码等字段。

前面有介绍如何调用私有字段和私有方法,但是不建议这个做,


如何修改私有字段?

前面介绍了私有字段默认不能被访问,但是可以通过@property特性来使私有字段被访问,那么私有字段如何能被修改呢?

要修改私有字段,需要对返回私有字段的函数添加装饰器。并且在类名后面加(object)

例如

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
#!/usr/bin/env python
#-*-coding:utf-8-*-
class person(object):
    memo = '我是静态字段'
    def __init__(self,name,age,flag):
        self.name = name
        self.age = age
        #私有字段
        self.__height = flag
    def action(self):
        return self.name +' 在上班'
    def show(self):
        return self.__height
    #只读私有字段
    @property
    def foo(self):
        return self.__height
    #修改私有字段,需要加参数
    @foo.setter
    def foo(self,value):
         self.__height = value
 
p1 = person('laowang',50,True)
print p1.foo
p1.foo = False
print p1.foo

输出结果

1
2
True
False











本文转自 曾哥最爱 51CTO博客,原文链接:http://blog.51cto.com/zengestudy/1857953,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Python面向对象的开发之封装,多继承,多态
Python面向对象的开发之封装,多继承,多态
13 0
Python面向对象的开发
Python面向对象的开发
12 0
Python面向对象实战--飞机大战
Python面向对象实战--飞机大战
26 0
面向对象的三大特性-python
面向对象的三大特性-python
15 0
Python------面向对象
Python------面向对象
12 0
Python基础—面向对象(超详版)(三)
Python基础—面向对象(超详版)
45 0
Python基础学习 -- 面向对象
Python基础学习 -- 面向对象
34 0
+关注
余二五
文章
问答
视频
文章排行榜
最热
最新
相关电子书
更多
双剑合璧-Python和大数据计算平台的结合
立即下载
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
相关实验场景
更多