Python新手学习（十）

031

永久存储 引入pickle库（泡菜技术。。。）
存放：pickling
读取：unpickling
‘wb’是什么格式，二进制？

import pickle
mylist=[123,3.14,'小甲鱼',['another list']]
picklefile=open('D:\\mylist.pkl','wb')
pickle.dump(mylist,picklefile)#倒进去dump
picklefile.close()
picklefile=open('D:\\mylist.pkl','rb')
mylist2=pickle.load(picklefile)#load,加载
print(mylist2)

所涉及到的命令，引入泡菜库import pickle
pickle.dump(mylist,picklefile)倒进去，输入，好像在那本书上也看到了dump
dump命令，左边是列表（字典），右面是缸
mylist2=pickle.load(picklefile),加载文件中的信息，放进列表
这种操作相当于做了一个二进制的转化吧，存进去二进制再读出来

032

异常处理，永远不要相信客户，输入什么都可能存在不合法
小甲鱼总结的各种出现异常的链接
想不起来什么错误查找一下
try ：
except ：出现异常后处理的代码
except OSerror as reason：

try:
    sum=1+'1'
    int('abc')#这个是会出错的
    f=open('我为什么是一个文件.txt')
    print(f.read())
    f.close()
except OSError as reason :
    print('文件出错了，原因是:'+str(reason))
except TypeError as reason :
    print('类型出错了，错误原因是:'+str(reason))

034

try:
    print(int('123'))
except ValueError as reason :
    print('出错啦'+str(reason))
else:
    print('没有任何异常')

123
没有任何异常

try:
    print(int('abc'))
except ValueError as reason :
    print('出错啦'+str(reason))
else:
    print('没有任何异常')

出错啦invalid literal for int() with base 10: 'abc'

035

安装eazygui导入

036

类和对象

class turtle:
    color ='green'
    weight=10
    legs=4
    shell=True
    mouth='大嘴'
    def climb(self):
        print('我很努力的往前爬')
    def run(self):
        print('我在飞快的往前爬')
    def bite(self):
        print('咬死你')
    def eat(self):
        print('有得吃')
    def sleep(self):
        print('睡觉')
tt=turtle()#类的实例化
tt.climb()
tt.bite()
tt.eat()

我很努力的往前爬
咬死你
有得吃

list1=[2,1,7,3,5]
list1.sort()
class mylist(list):#list2是类的实例化，mylist是list的字辈
    pass
list2=mylist()
list2.append(5)
print(list2)

[5]

视频里的多态好像不太对

037

self 类似this

class ball:
    def setname(self,name):
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
a=ball()
a.setname('球A')
b=ball()
b.setname('球B')
a.kick()
b.kick()

我叫球A,谁踢我
我叫球B,谁踢我

在这里我将a赋给b
发现修改b的同时也会修改a

class ball:
    def setname(self,name):
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
a=ball()
a.setname('球A')
b=a
b.setname('球B')
a.kick()
b.kick()

我叫球B,谁踢我
我叫球B,谁踢我

上面我发现，类里面并没有先定义name这个属性，但是可以直接赋值，因为类是共有属性，对象可以有自己的私有属性例如

class ball:
    def setname(self,name):
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
a=ball()
a.setname('球A')
a.age=5
print(a.age)

竟然也没有报错，因为后面的age属于类a自己的私有属性，类是共有属性，如果再定义一个b出来，b就不会拥有age的属性
init()是特殊函数 吗？

class ball:
    def __init__(self,name):#这个函数有点特殊，这是构造函数吗
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
b=ball('土豆')
b.kick()

我叫土豆,谁踢我

可以上上面的对比来看，下面那个必须要参数，上面那个不能有参数

class ball:
    def __init__(self,name):#这个函数有点特殊，这是构造函数吗
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
b=ball()#不输形参会报错
b.kick()
class bal:
    def setname(self,name):
        self.name=name
    def kick(self):
        print('我叫%s,谁踢我'% self.name)
a=bal('tudou')#输入形参会报错

第一种报错

Traceback (most recent call last):
  File "D:/pycharm222/001.py", line 7, in <module>
    b=ball()
TypeError: __init__() missing 1 required positional argument: 'name'

第二种报错

Traceback (most recent call last):
  File "D:/pycharm222/001.py", line 14, in <module>
    a=bal('tudou')#输入形参会报错
TypeError: object() takes no parameters

Process finished with exit code 1

下一条是关于私有和公有的问题
python中没有private关键字，想要创建一个类私有的变量需要通过命名规则来实现

在变量名之前加两个下划线__name，则在类外部就不能直接通过实例.__name访问,具体原理python编译器将其命名修改为了_类名__name，通过 实例 ._类名__name还是可以访问

class person:
    name='bubble'
    def getname(self):
        return self.name
p=person()
print(p.name)
print(p.getname())

bubble
bubble

上面这样是公有的，外部可以访问

class person:
    __name='bubble'#千万记得是双下划线。。。。
    def getname(self):
        return self.__name
p=person()
print(p.getname())
print(p.name)

Traceback (most recent call last):
  File "D:/pycharm222/001.py", line 8, in <module>
    print(p.name)
AttributeError: 'person' object has no attribute '__name'

Process finished with exit code 1

上面这样会提示私有
可能是因为__name前面这个__就是表示私有
但是可以通过 实例._类名___变量名访问

class person:
    __name='bubble'
    def getname(self):
        return self.__name
p=person()
print(p._person__name)
#print(p.__name)

p._person__name跟个友元函数似的
不能修改的属性一般设置为静态常量的，只设置为私有不太行

038

继承
子类会继承父类的私有函数？？

class parent:
    def hello(self):
        print('正在调用父类的方法')
class child(parent):
    #def hello(self):
        #print('正在调用子类的方法')
    pass
p=parent()
p.hello()
c=child()
c.hello()#多态了

正在调用父类的方法
正在调用父类的方法

然后修改一下（自己编译时出现的意外IndentationError缩进错误。。。 ）

class parent:
    def hello(self):
        print('正在调用父类的方法')
class child(parent):
    def hello(self):
        print('正在调用子类的方法')
p=parent()
p.hello()
c=child()
c.hello()#多态了

正在调用父类的方法
正在调用子类的方法

两个继承方法 1.未绑定的父类方法 2.super
super在书中有提到
1.未绑定的父类方法

#网课看到
import random as r
class fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)
    def move(self):
        self.x -=1
        print('我的位置是',self.x,self.y)
class goldfish(fish):
    pass
class carp(fish):
    pass
class salmon(fish):
    pass
class shark(fish):#子类重写了父类的方法，self.x不存在了
    def __init__(self):
        fish.__init__(self)#self是子类的实例对象，未绑定的父类方法
        self.hungery=True
    def eat(self):
        if self.hungery:
            print("天天吃")
            self.hungery=False
        else:
            print('你吃不下了')
fi=fish()
fi.move()
fi.move()
gold=goldfish()
gold.move()
gold.move()
gold.move()
shar=shark()
shar.move()
shar.eat()

因为子类重写了父类的方法 def init(self) 后，self.x不存在了，如果没有fish.init(self)就会报错，所以要加上才能找到父类的self才能继续进行shar.move()
2.super（）不用给定任何基类的名字，自动能够找出对应的方法
class shark(fish):#super（）使用时，就和这括号里面的fish有关，或者说，能够直接识别出你继承括号里继承的类

#网课看到
import random as r
class fish:
    def __init__(self):
        self.x=r.randint(0,10)
        self.y=r.randint(0,10)
    def move(self):
        self.x -=1
        print('我的位置是',self.x,self.y)
class goldfish(fish):
    pass
class carp(fish):
    pass
class salmon(fish):
    pass
class shark(fish):#super（）使用时，就和这括号里面的fish有关
    def __init__(self):
        super().__init__()#这直接调用？？不用给定任何基类的名字，自动能够找出对应的方法
        self.hungery=True
    def eat(self):
        if self.hungery:
            print("天天吃")
            self.hungery=False
        else:
            print('你吃不下了')

多重继承，了解即可

class base1:
    def foo1(self):
        print('我是1')
class base2:
    def fool2(self):
        print('我是2')
class C(base1,base2):
    pass
c=C()
c.foo1()
c.fool2()

我是1
我是2