类与对象的理解与封装特性

 面向对象编程语言
   - 类: 一个模板, (人类)---是一个抽象的， 没有实体的
   - 对象: (eg: 张三， 李四)
   - 属性: (表示这类东西的特征, 眼睛， 嘴巴， 鼻子)
   - 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习)

1). 定义类:class: 类

from collections import  Counter

例子: str, list, dict, Counter

object代表是， 人类继承于哪一个类， 如果不知道继承哪个类， 就写object；

class 人类(object):
    # print('hello')

    # 构造方法(魔术方法)， 当创建对象的时候， 自动执行的函数
    def __init__(self, name, age, gender):
        # python解释器自动将对象传给self这个形参.
        # 看self到底是什么东西?

        # 将对象与该对象的属性绑定在一起.
        #  调用对象的属性两种方式:
        #       - 张三.name
        #       - self.name
        self.name = name     # 属性
        self.age = age       # 属性
        self.gender = gender # 属性
        print(self)  # 实质上是一个对象， <__main__.人类 object at 0x7f4fdc4864a8>

    # 方法(在类里面定义的函数， 叫做方法)
    def eat(self):
        print("%s 正在吃饭..." %(self.name))

创建对象====根据模板(类)创建对象(真实存在)

张三 = 人类("张三",  10, 'male')
print("张三:", 张三)

看对象的属性

print(张三.name)
print(张三.age)
print(张三.gender)

让对象执行方法

张三.eat()

对象与类掌握练习

应用练习1
创建一个类People,拥有的方法为砍柴,娶媳妇,回家;实例化对象,执行相应的方法
显示如下:
    老李,18岁,男,开车去娶媳妇
    校思浩,22岁,男,上山去砍柴
    唐浩,10岁,女,辍学回家
提示:
    属性:name,age,gender
    方法:goHome(), kanChai(),quXiFu()

class People(object):
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def huiJia(self):
        print("%s,%d,%s,辍学回家" %(self.name,self.age,self.gender))
    def quXiFu(self):
        print("%s,%d,%s,开车去娶媳妇" %(self.name,self.age,self.gender))
    def kanChai(self):
        print("%s,%d,%s,上山砍柴" %(self.name,self.age,self.gender))
Laoli = People('老李',18,'男')
zhangsan = People('校思浩',22,'男')
lisi = People('唐浩',10, '女')

Laoli.quXiFu()
zhangsan.kanChai()
lisi.huiJia()

类的私有属性与私有方法

类的私有属性:
    __private_attrs：两个下划线开头，声明该属性为私有，
    不能在类地外部被使用或直接访问。
    在类内部的方法中使用时 self.__private_attrs。
类的方法:
    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，
    类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
    self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。
类的私有方法
    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，
    不能在类地外部调用。self.__private_methods。

class People(object):
    def __init__(self,name,age,gender, money):
        self.name = name
        self.age = age
        self.gender = gender
        self.__money = money

    def __play(self):
        print("王者荣耀正在进行时")

p1 = People('user1', 10, 'male', 1000000)
print(p1.gender)
p1.__play

栈数据结构的封装

应用练习2:栈的数据结构
class Stack:
    栈的方法:
    入栈(push), 出栈(pop), 栈顶元素(top),
    栈的长度(lenght), 判断栈是否为空(isempty)
    显示栈元素(view)
    操作结果:
    栈类的实例化
    入栈2次
    出栈1次
    显示最终栈元素

class Stack(object):
    # 构造函数
    def __init__(self):
        self.stack = []
    def push(self, value):
        """
        :param value: 入栈元素
        :return:
        """
        self.stack.append(value)
        return True

    def pop(self):
        # 判断栈是否为空
        if self.stack:
            # 获取出栈元素, 并返回
            item = self.stack.pop()
            return  item
        else:
            return  False

    def top(self):
        if self.stack:
            return  self.stack[-1]
        else:
            return  False
    def length(self):
        return  len(self.stack)

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

    def view(self):
        return  ",".join(self.stack)

s = Stack()
s.push('1')
s.push('2')
s.push('3')
s.push('4')
print(s.top())
print(s.length())
print(s.isempty())
s.pop()
print(s.view())

队列数据结构的封装

class Queue(object):
    # 构造函数
    def __init__(self):
        self.queue = []
    def push(self, value):
        self.queue.append(value)
        return True
    def pop(self):
        if self.queue:
            del self.queue[-1]
        else:
            return  False

    def front(self):
        if self.queue:
            return  self.queue[0]
        else:
            return  False
    def rear(self):
        if self.queue:
            return  self.queue[-1]
        else:
            return  False
    def length(self):
        return  len(self.queue)

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

    def view(self):
        return  ",".join(self.queue)
s = Queue()
s.push('1')
s.push('2')
s.push('3')
s.push('4')
print(s.front())
print(s.rear())
print(s.length())
print(s.isempty())
s.pop()
print(s.view())

第二个特性之继承

概念:

- 父类与子类/基类和派生类

from io import TextIOWrapper

class Animals(object):
    def __init__(self, name, age):
        self.name = name
        self.age= age
    def eat(self):
        print('eating......')


class Dog(Animals):  # 当Dog没有构造方法时，执行Animals里面的构造方法
    def __init__(self, name, age, power):
        # self.name = name
        # self.age = age
        # 执行Dog的父类的构造方法;
        super(Dog, self).__init__(name, age)
        self.power = power
    def eat(self):
        print(self.power)
        super(Dog, self).eat()


#  1. 如果子类没有的属性和方法， 则去父类找， 如果父类也没有， 就报错。
d1 = Dog("大黄",3,100)
print(d1.name)
print(d1.age)
print(d1.power)
d1.eat()

多继承原理

#coding:utf-8

# # 经典类
# class Person1:
#     pass
# p1 = Person1()
# print(p1)
#
# # 新式类
# class Person2(object):
#     pass
# p2 = Person2()
# print(p2)

# 在python2中既有新式类也有经典类;
#
#
#       经典类的继承算法: 深度优先算法
#       新式类的继承算法: 广度优先算法
# python3全部都是新式类;

class D:
    def test(self):
        print("D test")
class C(D):
    pass
    def test(self):
        print("C test")
class B(D):
    pass
    # def test(self):
    #     print("B test")
class A(B,C):
    pass
    # def test(self):
    #     print("A test")
a = A()
a.test()

三，多态性

#子类和父类存在相同方法时，子类会覆盖父类方法
#运形时总会调用子类方法--> 多态


class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

图书管理系统

# 假设每本书只有一本

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0：'已借出' 1:'未借出'
        self.state = state
        self.bookIndex = bookIndex


    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.state)

class   BookManage(object):
    # 存放所有书籍信息, 列表里面存放的是Book对象
    books = []

    def start(self):
        """图书管理系统初始化数据"""
        self.books.append(Book('python', 'Guido', 1, 'IN23445'))
        self.books.append(Book('java', 'Guido1', 1, 'IN23445'))
        self.books.append(Book('C++', 'Guido2', 1, 'IN23445'))
        print("初始化数据成功!")

    def Menu(self):
        """图书管理菜单栏"""
        while True:
            print("""
                        图书管理操作
                        
            1). 添加书籍
            2). 删除数据
            3). 查询书籍
            4). 退出
            """)
            choice = input("请输入你的选择:")
            if choice == '1':
                self.addBook()
            elif choice == '2':
                self.delBook()
            elif choice == '3':
                self.borrowBook()
            elif choice == '4':
                exit()
            else:
                print("请输入正确的选择!")

    def addBook(self):
        print("添加书籍".center(0, '*'))
        name = input("书籍名称:")
        bObj = self.isBookExist(name)
        if bObj:
            print("书籍%s已经存在" %(bObj.name))
        else:
            self.books.append(Book(name,input("作者:"), 1, input("存放位置:")))
            print("书籍%s添加成功" %(name))

    def delBook(self):
        print("删除书籍".center(50,'*'))
        for i in self.books:
            print(i)
        name = input("删除书籍名称：")
        a = self.isBookExist(name)
        if a:
            self.books.remove(a)
            print("删除%s成功" %(a))
        else:
            print("书籍不存在")

    def borrowBook(self):
        print("查询书籍".center(50,'*'))
        for i in self.books:
            print(i)
        name = input("查询书籍名称：")
        b = self.isBookExist(name)
        for book in self.books:
            if book == b:
                print(book)
                break
            else:
                print("%s不存在" %(b))
                break
    def isBookExist(self, name):
        """检测书籍是否存在"""
        # 1. 依次遍历列表books里面的每个元素
        # 2. 如果有一个对象的书名和name相等， 那么存在；
        # 3. 如果遍历所有内容， 都没有发现书名与name相同， 书籍不存在;
        for book in self.books:
            if book.name == name:
                # 因为后面需要
                return book
        else:
            return  False

if __name__ == "__main__":
    bManger = BookManage()
    bManger.start()
    bManger.Menu()

1、创建Person类，属性有姓名、年龄、性别，创建方法personInfo,打印这个人的信息
2、创建Student类，继承Person类，属性有学院college
，班级class，重写父类personInfo方法，调用父类方法打印个人信息外，将学生的学院、班级信息也打印出来，
创建方法study参数为Teacher对象，调用Teacher类的teachObj方法，接收老师教授的知识点，然后打印‘老师xxx,我终于学会了！’xxx为老师的teach方法返回的信息。
重写__str__方法，返回student的信息。
3、创建Teacher类，继承Person类，属性有学院college，专业professional
，重写父类personInfo方法，调用父类方法打印个人信息外，将老师的学院、专业信息也打印出来。
创建teachObj方法，返回信息为‘今天讲了如何用面向对象设计程序’
4、创建三个学生对象，分别打印其详细信息
5、创建一个老师对象，打印其详细信息
6、学生对象调用learn方法
7、将三个学员添加至列表中，通过循环将列表中的对象打印出来，print(Student对象)。

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

class Baoan13(object): #新式类 定义一个类，并且继承object类，父类、基类、超类 class Baoan13: #经典类，参数列表中没有object head='我是一个类变量' #类变量，可以被类中所有的实例方法调用，不作为实例变量使用 def __init__(self,name,age,hight): #构造方法，又称构造函数。作用：初始化类的属性 #定义：在类里面，双下滑线构成私有方法，只能被自身或子类访问 self.name=name #实例变量（用self修饰的一个变量） self.age=age self.hight=hight def play(self): #实例方法（实例函数） print(self.name+'今

年'+self.age+'岁了，他的身高是'+self.hight+'cm。') def get_play(self): #这个实例方法是调用上面play的实例方法 self.play

点击添加图片描述（最多60个字） 编辑 @classmethod #@classmethod是一个类方法的装饰器 #在类中，@开头的称为装饰器 #装饰器的作用：本身也是一个函数，在不影响原有功能的基础上，添加新的功能 def func1(cls): #类方法，以cls修饰的一个方法，类方法的特性：单例模式 print('我是一个类方法。') def func2(cls): #这也是一个类方法，与上面有@classmethod修饰的不一样 cls.value=20 #类方法变量 print(cls.value) @staticmethod #静态方法的装饰器 # 静态方法：写在类中的普通方法，能被实例方法和类方法调用，但是不能调用实例方法和类方法 def func: print('我是一个任人调用的静态方法。') def putong: print('我只是一个普通函数。')

if __name__=='__main__': #主函数调用 #1调用.类直接调用实例方法(实例函数) Baoan13('小明','18','180').play #2.调用.根据类创建一个对象p,创建对象的过程被称为实例化 # #对象p可以调用类中所有的实例方法(实例函数)和实例变量 p=Baoan13('小明','18','180') #常用。创建对象，传入参数（参数数量要与构造的方法一致） p.play #对象调用实例方法 # p.get_play #对象调用实例方法（实例方法get_play去调用实例方法play） # print(p.name) #对象调用实例变量 # print(p.age) #对象调用实例变量 # print(p.hight) #对象调用实例变量 # print(p.head) #对象调用类变量 # p.func1 #对象调用类方法( @classmethod修饰的) # p.func2 #对象调用类方法 # p.func #对象调用类方法（@staticmethod修饰的） # putong #普通函数的调用 如需了解更多测试技术信息请关注： 深圳市多测师信息技术有限公司