面向对象

1.面向对象

定义一个类：

类的格式：

class  类名（父类）  如果不继承任何父类，则用object

例如：

class Player（object）：

pass

print  Player

类名后面有括号的类，成为新式类

括号里面的内容是父类；程序中，所有类的父类都是object

2.类的数据属性

可以对类添加属性，然后显示类的属性

3.类的 方法

类的方法其实就是函数，在类中定义的函数叫做方法

类的方法中，python解释器要求第一个形参必须是self，self实质上是类实例化后的对象本身

在类中定义方法，必须对类进行实例化，然后才能调用类中的方法

4.面向对象的三大特性：封装，继承，多态

封装：封装实际上就是把数据封装到某个地方，以后再去调用封装在某处的内容或者数据

封装数据

调用封装数据

通过对象直接调用

通过self间接调用

练习1：

题目要求：
创建一个People类
方法有：砍柴，娶媳妇，回家
属性有：name，age，gender
显示：
老李，18，男，开车娶媳妇
校思浩，22，男，上山砍柴
唐浩，10，男，辍学回家
#/usr/bin/env python
# coding:utf-8


class People(object):
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def Cut(self):
        print "%s,%s,%s,上山去砍柴" %(self.name,self.age,self.gender)
    def Marry(self):
        print "%s,%s,%s,开车去娶媳妇" %(self.name,self.age,self.gender)
    def GoHome(self):
        print "%s,%s,%s,辍学回家" %(self.name,self.age,self.gender)


laoli = People("老李","18","男")
xiaosihao = People("校思浩","22","男")
tanghao = People("唐浩","10","男")


laoli.Marry()
xiaosihao.Cut()
tanghao.GoHome()


运行结果：
老李,18,男,开车去娶媳妇
校思浩,22,男,上山去砍柴
唐浩,10,男,辍学回家

练习2：

栈的数据结构：（先进后出，后进先出）
#!/usr/bin/env python
# coding:utf-8


class Stack(object): ##定义一个栈的类
    def __init__(self):
        self.stack = []


    def push(self,value): ##入栈
        self.stack.append(value)


    def pop(self): ##出栈
        if not self.isempty():
            return self.stack.pop()
        else:
            return None


    def top(self): ##显示栈顶元素
        if not self.isempty:
            return self.stack[-1]
        else:
            return None


    def length(self): ##显示栈的长度
        return len(self.stack)


    def isempty(self): ##判断栈是否为空
        return self.stack == []


    def view(self): ##显示栈的全部元素
        for i in self.stack:
            print i,


if __name__ == "__main__":
    stack1 = Stack()


    stack1.push(1)
    stack1.push(2)
    stack1.push(3)
    stack1.push(4)
    stack1.push(5)


    stack1.pop()
    stack1.top()


    stack1.view()
运行结果：
1 2 3 4

练习3：

队列的数据结构：（先进先出，后进后出）
#!/usr/bin/env python
# coding:utf-8


class Queue(object):
    def __init__(self):
        self.queue = []

    def push(self,value):
        self.queue.insert(0,value)

    def pop(self):
        if not self.isempty():
            return self.queue.pop()
        else:
            return None

    def top(self):
        if not self.isempty:
            return self.queue[-1]
        else:
            return None

    def length(self):
        return len(self.queue)

    def isempty(self):
        return self.queue == []

    def view(self):
        for i in self.queue:
            print i,

if __name__ == "__main__":
    queue1 = Queue()
    queue1.push(1)
    queue1.push(2)
    queue1.push(3)
    queue1.push(4)
    queue1.push(5)

    queue1.pop()
    queue1.top()

    queue1.view()

继承：

继承中与偶父类和子类

多态

当父类和子类有相同的方法时，优先调用执行子类的方法