为了代码的编写方便简洁，引入了类的定义；
一般，使用 class 语句来创建一个新类，class之后为类的名称(通常首字母大写)并以冒号结尾，例如:

class Ticket():
    def __init__(self,checi,fstation,tstation,fdate,ftime,ttime):
        self.checi=checi
        self.fstation=fstation
        self.tstation=tstation
        self.fdate=fdate
        self.ftime=ftime
        self.ttime=ttime
    def printinfo(self):
        print("车次：",self.checi)
        print("出发站：", self.fstation)
        print("到达站：", self.tstation)
        print("出发时间：", self.fdate)

#类中可以定义所使用的方法，类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self；
#init()方法是一种特殊的方法，被称为类的初始化方法，当创建这个类的实例时就会调用该方法；
#self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数；
接下来是类的对象的创建：

#创建a1对象
a1=Ticket("G11","xian","beijing",'2019-01-20','13:00','18:00')
#创建a2对象
a2=Ticket("T11","xian","beijing",'2019-01-21','13:00','19:00')
``

最后是对象属性的访问：

a1.printinfo()
a2.printinfo()

输出结果如下：

现在，用类的方式爬虫12306的车站信息：

import requests
class Station():
    #__init__()方法是一种特殊的方法，被称为类的初始化方法，当创建这个类的实例时就会调用该方法
    # self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
    def __init__(self,code,cn,qp,jp):
        self.code=code
        self.cn=cn
        self.qp=qp
        self.jp=jp
    #类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
    def printinfo(self):
        print(self.code,self.cn,self.jp,self.qp)
    #self代表类的实例,表示当前对象的地址  self.__class__ 则指向类
    def test(self):
        print(self)
        print(self.__class__)
url="https://kyfw.12306.cn/otn/resources/js/framework/station_name.js?station_version=1.9077"
#url='https://kyfw.lesson10_1.cn/otn/resources/js/framework/station_name.js?station_version=1.9090'
html_text=requests.get(url).text
infos=html_text[:-2].split("@")[1:]
stations=[]

for info in infos:
    station_list=info.split("|")
    #直接将类的对象添加到列表中，通过__init__()方法接受参数
    stations.append(Station(station_list[2],station_list[1],station_list[3],station_list[4]))
#遍历列表，每个元素为类的一个对象
for i in stations[:10]:
    i.printinfo()
    i.test()

结果如下：

嗯嗯~~就这样啦！

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

 面向对象编程语言
   - 类: 一个模板, (人类)---是一个抽象的， 没有实体的
   - 对象: (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()