面向对象及正则表达式

Python核心风格:避免用下划线作为变量名的开始。

因为下划线对解释器有特殊的意义,而且是内建标识符所使用的符号,我们建议程序员避免用下划线作为变量名的开始。一般来讲,变量名_xxx被看作是私有的,在模块或类外不可以使用。当变量是私有的时候,用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对Python 来说有特殊含义,对于普通的变量应当避免这种命名风格。

 "单下划线"

 "单下划线开始的成员变量叫做保护变量,意思是只有类对象和自类对象自己能访问到这些变量。

例子:以单下划线开头(_foo)的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用“from xxx import *”而导入。

 "双下划线"

"双下划线开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。

 例子:以双下划线开头的(__foo)代表类的私有成员;以双下划线开头和结尾的(__foo__)代表python里特殊方法专用的标识,如 __init__()代表类的构造函数。

面向对象的三大特性

继承

什么是继承

继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类

python中类的继承分为:单继承和多继承

class ParentClass1: #定义父类
    pass
class ParentClass2: #定义父类
    pass
class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
    pass

继承小结

继承的作用

减少代码的重用
提高代码可读性
规范编程模式

几个名词

抽象:抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
继承:子类继承了父类的方法和属性
派生:子类在父类方法和属性的基础上产生了新的方法和属性

抽象类与接口类

复制代码
1.多继承问题
在继承抽象类的过程中,我们应该尽量避免多继承;
而在继承接口的时候,我们反而鼓励你来多继承接口


2.方法的实现
在抽象类中,我们可以对一些抽象方法做出基础实现;
而在接口类中,任何方法都只是一种规范,具体的功能需要子类实现
复制代码

钻石继承

新式类:广度优先
经典类:深度优先

 

多态

多态

多态指的是一类事物有多种形态

动物有多种形态:人,狗,猪

复制代码
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')
复制代码

文件有多种形态:文本文件,可执行文件

复制代码
import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')
复制代码

 

多态性

一 什么是多态动态绑定(在继承的背景下使用时,有时也称为多态性)

多态性是指在不考虑实例类型的情况下使用实例

复制代码
在面向对象方法中一般是这样表述多态性:
向不同的对象发送同一条消息(!!!obj.func():是调用了obj的方法func,又称为向obj发送了一条消息func),不同的对象在接收时会产生不同的行为(即方法)。
也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同
复制代码

 

封装

【封装】

         隐藏对象的属性和实现细节,仅对外提供公共访问方式。

【好处】 

1. 将变化隔离; 

2. 便于使用;

3. 提高复用性; 

4. 提高安全性;

【封装原则】

      1. 将不需要对外提供的内容都隐藏起来;

      2. 把属性都隐藏,提供公共方法对其访问。

私有变量和私有方法

在python中用双下划线开头的方式将属性隐藏起来(设置成私有的)

私有变量

复制代码
#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的,即这种操作并不是严格意义上的限制外部访问,仅仅只是一种语法意义上的变形
复制代码

这种自动变形的特点:

1.类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果

2.这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。

 

这种变形需要注意的问题是:

1.这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作,不会变形

 

 

来自:http://www.cnblogs.com/Eva-J/articles/7293890.html#_label9

设计一个三维向量类

 1 class Vecter3:
 2     def __init__(self, x=0, y=0, z=0):
 3         self.X = x
 4         self.Y = y
 5         self.Z = z
 6     def __add__(self, n):
 7         r = Vecter3()
 8         r.X = self.X + n.X
 9         r.Y = self.Y + n.Y
10         r.Z = self.Z + n.Z
11         return r
12     def __sub__(self, n):
13         r = Vecter3()
14         r.X = self.X - n.X
15         r.Y = self.Y - n.Y
16         r.Z = self.Z - n.Z
17         return r
18     def __mul__(self, n):
19         r = Vecter3()
20         r.X = self.X * n
21         r.Y = self.Y * n
22         r.Z = self.Z * n
23         return r
24     def __truediv__(self, n):
25         r = Vecter3()
26         r.X = self.X / n
27         r.Y = self.Y / n
28         r.Z = self.Z / n
29         return r
30     def __floordiv__(self, n):
31         r = Vecter3()
32         r.X = self.X // n
33         r.Y = self.Y // n
34         r.Z = self.Z // n
35         return r
36     def show(self):
37         print((self.X,self.Y,self.Z))
38         v1 = Vecter3(1,2,3)
39         v2 = Vecter3(4,5,6)
40         v3 = v1+v2v3.show()
41         v4 = v1-v2v4.show()
42         v5 = v1*3
43         v5.show()
44         v6 = v1/2
45         v6.show() 

 

 

猜你喜欢

转载自www.cnblogs.com/SGzhang/p/10712598.html
0条评论
添加一条新回复