python编程基础----------面向对象的编程

一.python面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

1.对象

          对象有两部分：第一部分是属性，第二部分是方法.类就相当于模板，而对象就是用模板生产出来的产品。

请看下面一个实例：

class People(object):
    # 类属性
    name=''
    sex=False
    age=0
    height=0
    weight=''
    def eat(self):
        print('人类出生就会吃东西')
    def sleep(self):
        print('人类出生就会睡觉')
    def work(self):
        print('每个人都有劳动的权利')
# 创建一个对象叫做p
p=People()
p.name='小王'
p.age=17
p.sex=False
p.height=165
p.weight='60kg'

print(p.name)
p.eat()
p.work()

很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法）当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:，像下面这样：

class People(object):
# __init__：初始化 魔术方法的一种，用来初始化对象
    def __init__(self,name,age,sex):
        # init（）方法会自动调用，在创建对象的时候
        # 将后面的值赋给前面的self.XX属性
        # init里面的属性 叫做对象属性
        self.name=name
        self.age = age
        self.sex=sex
    def study(self):
        print('只有学习才能使我感到快乐')
# 在创建对象的时候直接赋值
p=People('lalala',17,True)
print(p.name)
p=People
p.name='李四'
print(p.name)

2.类的方法

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

class People(object):
    # 类属性
    name='道德经'
    age=0
    def __init__(self,fond=''):
        # 对象属性
        self.fond=fond
    def say(self):
        # self指的是调用方法本身
        # 对象方法
        print('Hello')
p=People()
print(People.name)
print(p.name)
p.fond='学习'
print(p.fond)
# 对象属性不能通过类名加属性的方式来调用，只能通过对象来调用
# 类属性可以通过类名加属性的方式来调用，也可以通过对象来调用
# print(People.fond)

p.say()
# 对象方法可以通过对象加方法名这种形式来调用
# 也可以通过类名加方法名，然后将对象当成参数传入方法这种形式来调用
People.say(p)

3.私有属性

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

# 对象属性中，凡是带下划线的，都是不希望外部使用（道德上）
# 但是并不是说我们完全不能使用
# 如果加的是但下划线，可以通过p.name='lalala'这种方式调用
# 如果假的是双下划线，则可以通过p._People__age这种形式使用
class People(object):
    def __init__(self,name='',sex='',age='16',fond='学习'):
        self.name=name
        self._sex=sex
        self.__age=age
        self.__fond=fond
        # get set 方法
    @property
    def fond(self):
        print('fond被get了')
        return self.__fond
    fond.setter
    def fond(self,fond):
        print('fond被set了')
        self.__fond=fond
p=People()
p.name='张三'
print(p.name)
p._sex='男'
print(p._sex)
# 如果有这个属性，则修改属性值为后面的值，如果没有这个属性，则添加
# p.__age='17'
# print(p.__age)
print(p._People__age)

# p.fond='开车'
print(p.fond('kaiche'))

4.继承：

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

# 子类继承于父类
# 子类会有父类的属性和方法
# 子类也可以重写父类的属性和方法
# 子类也可以拥有自己独有的属性和方法
class People(object):
    def __init__(self,age='77',sex=''):
        self.age=age
        self.sex=sex
    def eat(self):
        print('人类为吃而活')
    def brath(self):
        print('郑州的空气如此香甜')
class Man(People):
    def __init__(self,age='',sex='',huZi=''):
       # 继承父类已有的属性
        super(Man,self).__init__(age,sex)
    def smoke(self):
        print('吸烟有害健康')
    def eat(self):
        # 继承父类的方法
        super(Man,self).eat()
        print('上面这句话是people的，正在说的这句话才是我自己的')
class Boy(Man):
    def __init__(self):
        pass

m=Man()
print(m.age)

m.smoke()
m.eat()

5.多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#类定义
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("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

看完了今天的内容，我们来写一个小例子：

# 1.男女相亲，
# 男方对女方的要求：
# 0.对方必须是女的
# 1.身高不能小于165
# 2.女方年龄不能比自己大
# 3.女方的腰围一定要比自己小
# 4.女方读的数不能少于100
# 女方对男方的要求：
# 0.对方必须是男的
# 1.对方的年龄不能比自己小 不能大于自己10岁
# 2.对方的身高不能比自己小，不能大于自己10岁
# 3.对方的腰围不能超过自己1.5倍
# 4.男方应该有稳定收入，年薪不能少于20w
# 5.男方房子面积不能少120，总价值不能少于200w
class People(object):
    def __init__(self,name='',age='',sex='',yaowei='',height=''):
        self.name=name
        self.age = age
        self.sex = sex
        self.yaowei = yaowei
        self.height = height
    def sexIsFit(self,other):
        if other.sex == True and self.sex==other.sex:
            print('gay')
            # 在此用False代表相亲失败
            return False
        if other.sex==False and self.sex==other.sex:
            print('lala')
            return False
    def ageIsFit(self,other):
        if self.sex == False and self.age >other.age:
            print('小兄弟')
            return False
        if self.sex == True and self.age <other.age:
            print('大姐姐')
            return False
class Man(People):
    def __init__(self,salary='',house_area='',house_value=''):
        super(Man,self).__init__(name='',age='',sex='',yaowei='',height='')
        self.salary=salary
        self.house_area=house_area
        self.house_value=house_value
    def makeFriendwithGirl(self,other):
        result = super(Man,self).sexIsFit(other)
        if result == False:
            return
        result = super(Man, self).ageIsFit(other)
        if result == False:
             return
        if other.height<165:
            print('lalala')
            return
        if other.yaowei>self.yaowei:
            print('我喜欢稍微瘦一点的')
            return
        if other.readCount <100:
            print('你没有有趣的灵魂')
            return
        print('你是一个完美的女生')
class Woman(People):
    def __init__(self,readCount=''):
        super(Woman,self).__init__(name='',age='',sex='',yaowei='',height='')
        self.readCount=readCount
    def makeFriendwithGirl(self,other):
        result = super(Woman,self).sexIsFit(other)
        if result == False:
            return
        result = super(Woman, self).ageIsFit(other)
        if result == False:
             return
        if other.height<165:
            print('lalala')
            return
        if other.yaowei>self.yaowei:
            print('我喜欢稍微瘦一点的')
            return
        if other.readCount <100:
            print('你没有有趣的灵魂')
            return
        print('你是一个完美的女生')
jack  = Man()
jack.sex=True
jack.age=21
jack.height=176
jack.yaowei=45
jack.salary=2000000
jack.house_area=150
jack.house_value=3000000


rouse=Woman()
rouse.sex=False
rouse.age=20
rouse.height=170
rouse.readCount=108
rouse.yaowei=25


jack.makeFriendwithGirl(rouse)