1. 技术文章
  2. 第二十四天

第二十四天

由 烂漫一生 提交于 2020-03-12 15:42:53

组合内容回顾

一个类的对象是另一个类对象的属性

两个类之间 有什么什么的关系 :班级有学生 学生有班级 班级有课程 图书有作者 学生有成绩)

学生 课程

班级 课程

圆形 圆环

圆形 圆锥 圆柱

当你改的多的时候, 运用分组比较方便

命名空间

​ 在类的命名空间里 :静态变量, 绑定方法

​ 在对象命名空间里:类指针,对象的属性(实例属性)

调用习惯

类名:静态变量

对象: 静态变量(对象调用静态变量时候,不能对变量赋值操作, 只能查看 不能 向后面的一样 对象.静态变量'=')

绑定方法

对象.绑定方法() 类名.绑定方法(对象)

三大特性

继承

封装

多态

进阶

# 猫
#     吃
#     喝
#     睡
#     爬树
# 狗
#
#     吃
#     喝
#     睡
#     看家
#
# 继承 --需要解决代码重复的
# 继承语法
#
# class A:
#     pass
# class B:
#     pass
#
# B继承A  A是父类 B是子类
# A是父类 基类  超类
# B是 子类   派生类

继承

B继承A  A是父类 B是子类
A是父类 基类  超类
B是 子类   派生类

子类可以用

父类和子类的方法选择:

​ 子类的对象 如果去调用方法

​ 永远优先调用自己的

​ 如果自己有 用自己的

​ 自己没有 用父类的

​ 如果自己有 还想用父类的 直接在子类方法中 调父类 的方法 ,

​ 父类名.方法名

class Animal:
    def __init__(self,name,food):
    # def __init__(self,name):
        self.name=name
        self.food=food
        self.blood=100
        self.waise=100

    def eat(self):
        # print(f'{self.name} is eating')
        print(f'{self.name} is eating {self.food}')



    def drink(self):
        print(f'{self.name} is drinking')

    def sleep(self):
        print(f'{self.name} is sleep')

class Cat(Animal):
    def clime_tree(self):
        print(f'{self.name} is climbing')
    def eat(self):
        self.blood+=100
        Animal.eat(self)
class Dog(Animal):
    def eat(self):
        self.waise+=100
        Animal.eat(self)

    def house_keep(self):
        print(f'{self.name} is keeping')

小白=Cat('小白','猫粮')
小黑=Dog("小黑",'狗粮')

小白.eat()
小黑.eat()
print(小白.__dict__)
print(小黑.__dict__)

# 
# 小白 is eating 猫粮
# 小黑 is eating 狗粮
# {'name': '小白', 'food': '猫粮', 'blood': 200, 'waise': 100}
# {'name': '小黑', 'food': '狗粮', 'blood': 100, 'waise': 200}

特殊属性

# 小猫 小狗有特殊的属性

class Animal:
    def __init__(self,name,food):
    # def __init__(self,name):
        self.name=name
        self.food=food
        self.blood=100
        self.waise=100

    def eat(self):
        # print(f'{self.name} is eating')
        print(f'{self.name} is eating {self.food}')



    def drink(self):
        print(f'{self.name} is drinking')

    def sleep(self):
        print(f'{self.name} is sleep')

class Cat(Animal):
    def __init__(self,name,food,eyes):
        Animal.__init__(self,name,food) #调用弗雷德方法三 ,去完成一些通用属性的初始化  

        self.eyes=eyes  #派生属性


    def clime_tree(self):
        print(f'{self.name} is climbing')
    def eat(self):
        self.blood+=100
        Animal.eat(self)
class Dog(Animal):
    def eat(self):
        self.waise+=100
        Animal.eat(self)

    def house_keep(self):
        print(f'{self.name} is keeping')

小白=Cat('小白','猫粮','蓝色')
小黑=Cat('小白','猫粮','三只眼睛')

print(小黑.__dict__)
print(小白.__dict__)

# {'name': '小白', 'food': '猫粮', 'blood': 100, 'waise': 100, 'eyes': '三只眼睛'}
# {'name': '小白',

单继承

# 单继承  不管有几个儿子  都是单继承
class D:
    def func(self):
        print("in D")
class A(D):pass
class B(A):
    def func(self):
        print('in B')
class C(B):pass
C().func()

# in B

class D:
    def func(self):
        print("in D")
class A(D):pass
class B(A):pass
class C(B):pass

C().func()

# in D

多继承

# # 多继承 有好几个爹
#
# 有些语言不支持多继承 java
# python语言特点 可以在面向对象中支持多继承\



class B:
    def funv(self):print('IN B ')
class A:
    def funv(self):print('IN A ')

class C(A,B):  #  谁在前 就执行谁   A 在前
    pass

C().funv()
# IN A

class C(B,A):   #  谁在前 就执行谁  B在前
    pass

C().funv()
# IN B
#

base

# bases 只显示第一个父类

class A :pass
print(A.__bases__)

# (<class 'object'>,)

class C :pass
class B(A,C) :pass

print(B.__bases__)

#
# (<class '__main__.A'>, <class '__main__.C'>)

类的补充

二：特殊的类属性
类名.__name__# 类的名字(字符串)    
类名.__doc__# 类的文档字符串   查看当前 函数的注释  也可以查看 类的注释
主要用来 卖萌

def a():
    '''sahjkodaskljdhkasjdhjkas'''
    pass
print(a.__doc__)

sahjkodaskljdhkasjdhjkas


#
class A:
    '''这个类是猫咪哦'''
    pass
print(A.__doc__)

#这个类是猫咪哦

类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)

类名.__dict__# 类的字典属性    变量名字  函数名字 全在里面
类名.__module__# 类定义所在的模块   脚本中 __main__   文件中   打印文件的名字


类名.__class__# 实例对应的类(仅新式类中)  查看类的类型   type   都是方法

补充

# 所有在python3中的类都是继承  object类
#
# object 中有 init
# 所有类都默认继承object

class A :
    pass    #即便什么都不写  也不会报错

# 等于

# class A (object):  #  规范写法
#     pass

a=A()
a=A()
# 开空间,调用init



# bases 只显示父类  不显示更上一级的类

class A :pass
print(A.__bases__)

# (<class 'object'>,)

class C :pass
class B(A,C) :pass

print(B.__bases__)

#
# (<class '__main__.A'>, <class '__main__.C'>)

绑定方法和普通的函数

from types import Functiontype,Methodtype

#Functiontype  函数
#Methodtype  方法

#isinstance type

a=1
b='asd'
print(isinstance(a,int))

print(type(a) is int)



class Cat:
    pass
小白=Cat()
print(type(小白))

print(isinstance(小白,int))

print(type(小白) is Cat)  #判断小白是不是Cat类

#isinstance 和   type  的比较

class Animal:
    pasa
class Cat(Animal):
    pass
小白=class(Cat)

print(type(小白) is Cat)
print(type(小白) is Animal)
True
False

print(isinstance(小白,Cat))
print(isinstance(小白,Animal))
True
True


结论:
isinstance可以判断 继承类的关系
type 只能判断父类  不能判断父类的父类  



#Functiontype  函数
#Methodtype  方法

class A :
    def (self):
        print('in func')
print(A.func)   #函数     类名调用 始终是一个函数
a=A()
print(a.func)  #方法      对象去调用   它是一个方法

print(isinstance(a.func,Functiontype))  
print(isinstance(a.func,Methodtype))  #对
print(isinstance(A.func,Functiontype))  #对
print(isinstance(A.func,Methodtype))

pickle

pickle 是一个 python 中, 压缩/保存/提取 文件的模块，字典和列表都是能被保存的.

但必须注意的是python2以ASCII形式保存，而在python3中pickle是使用转换二进制的数据压缩方法保存数据

所以，在保存或者读取数据的时候，打开文件应该使用‘wb' 'rb'的方式

import pickle
a = 'owoof'
with open('111.pkl', 'wb') as file:
    pickle.dump(a, file)

在Pickle模块中还有dumps()和loads()函数,他们是直接实现一个二进制和pickle表示对象的转换,不用打开文件(这点与dump不同)

dumps()是将可读对象转换成二进制文件,并返回二进制文件,loads()是把二进制文件转换成可读对象,并返回对象

在使用dump()和load()时,需要注意用with open 打开一次文件每调用一次dump()就会在文件中生成一次数据, 当再次with open 打开文件时, 之前写数据调用了几次dump()就最多只能调用load()几次,而且每次dump()是和load()对应的.

dump()次数和load()次数 是对应的

with open('poins_normal.pkl', 'rb') as file:with open('poins_normal.pkl', 'rb') as file:
  class_1 = pickle.load(file)
  # print(np.shape(class_1))
  class_2 = pickle.load(file)
  labels = pickle.load(file)
  class_1 = pickle.load(file)
  # print(np.shape(class_1))
  class_2 = pickle.load(file)
  labels = pickle.load(file)

如上,我事先写了三次dump(),那么之后的三次load()是一一对应的,如果我进行第四次load()调用,编译器会提示data ran out of .

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
python=Course('python','6month','21800')
linux = Course('linux','5 moneth',19800)
go = Course('go','4 moneth',12800)
#
# #
# import pickle
# with open('pickle_f','wb') as f:
#     pickle.dump(python,f)
#     pickle.dump(linux,f)
#     pickle.dump(go,f)


# with open('pickle_file','rb') as f:
#     ret=pickle.load(f)
    # print(ret)
    # < __main__.Course
    # object
    # at
    # 0x02AEAA50 >

    # print(ret.__dict__)
    # # {'name': 'python', 'period': '6month', 'price': '21800'}


# from core import login

import time
import pickle
#
with open('pickle_f','rb') as f:
    while 1:
        try:
            obj=pickle.load(f)
            print(obj.name,obj.price)
            time.sleep(1)
        except EOFError:
            break

封装

多态

进阶

2020年3月12日15:22:25 修改

标签
animal
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!