Python面向对象

1.概述

• 面向过程：根据业务逻辑从上到下写垒代码

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

2.相关概念

　　类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

　　类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

　　数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

　　方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

　　实例变量：定义在方法中的变量，只作用于当前实例的类。

　　继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

　　实例化：创建一个类的实例，类的具体对象。

　　方法：类中定义的函数。

　　对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

3.定义类

定义类使用class关键字，类名一般我们开发的时候首字母要大写。python中有经典类和新式类，他俩在python3中没有区别，在python2中经典类在多继承的时候是深度优先，新式类是广度优先。python3中统一是广度优先。

　　1、创建类

　　　　面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　　　使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

 1 class Person:  #经典类
 2       def __init__(self,name):#构造函数
 3           self.name = name
 4           self.nose = 2 #鼻子  #属性
 5           self.face = 2 #脸
 6           self.head = 10 #脑子
 7           self.wing = 4#翅膀
 8           print('女蜗开始造人。。。')
 9      def driver(self): #这个人会开车，也就是有开车这个方法
10          print('老司机，开车非常稳')

• class是关键字，表示类；person 是类名，首字母必须大写。

• 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。

• self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

• def dirver(self),是定义类里面的函数，也就是类的方法。

　　　2、实例化

　　　　　类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征。

　　　　　实例化的过程就是类——>对象的过程

　　　　　原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。

　　　　　语法：对象名 = 类名(参数)，例如：

class Person:  #经典类
    def __init__(self,name):#构造函数
        self.name = name
        self.nose = 2 #鼻子  #属性
        self.face = 2 #脸
        self.head = 10 #脑子
        self.wing = 4#翅膀
        print('开始造人。。。')
    def driver(self):
        print('老司机，开车非常稳')

zll = Person('千千')#实例化对象

　　　3、查看属性&调用方法

zll = Person('千千')
print(zll.name)#查看属性直接 对象名.属性名
print(zll.driver())#调用方法，对象名.方法名()

　　　4、类的属性与方法

　　　类的私有属性

　　　　　　__nose：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__nose。

　　　类的方法

　　　　　　在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

　　　　　　self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

　　　类的私有方法

　　　　　　__driver：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__driver。

类的私有属性实例如下：

 
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

执行以上结果为：

1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

类的私有方法实例如下：

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('千千阙歌', 'www.nnzhp.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

以上实例执行结果：

name  :  千千阙歌
url :  www.nnzhp.com
这是公共方法
Traceback (most recent call last):
这是私有方法
  File "D:/test/Pythonlianxi/day9/sss.py", line 21, in <module>
    x.__foo()  # 报错
AttributeError: 'Site' object has no attribute '__foo'  
#外部不能调用私有方法

4、与对象有关

　　　对象是关于类而实际存在的一个例子，即实例

　　　对象/实例只有一种作用：属性引用，例如：

zll = Person('千千')
print(zll.name)
print(zll.face)
print(zll.nose)
print(zll.head)

　　　当然了，你也可以引用一个方法，因为方法也是一个属性，只不过是一个类似函数的属性，我们也管它叫动态属性。

　　　引用动态属性并不是执行这个方法，要想调用方法和调用函数是一样的，都需要在后面加上括号：

print(zll.driver)

 5、继承

　　什么是继承

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

　　　python中类的继承分为：单继承和多继承。

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

　　单继承：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('谦谦',17,60,八)
s.speak()

执行以上程序输出结果为：

ken 说: 我 17 岁了，我在读 八 年级

　　多继承

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("谦谦",25,80,4,"段子手的养成")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

我叫 谦谦，我是一个演说家，我演讲的主题是 段子手的养成

 

转载于:https://www.cnblogs.com/xiehong/p/9078172.html