课堂笔记-从3开始

BigSmall

26
字典：当索引不好用时
写法：dict1={key：值，key：值，，}，查找的时候用dict1[key]

BigSmall

27
在一些情况下，映射比序列更加实用，python中唯一的映射就是字典

赋值是在原来的东西上添加了一个标签，而拷贝则是产生一个新的东西

BigSmall

28
集合
在python3里面，用一堆花括号括起来一堆数字，如果没有体现映射关系，那么它就是集合
唯一性
无序

BigSmall

29
文件
输入-处理-输出，处理之前我们也学了处理，当 input和print不满足输入输出时，就用文件
随时保存，以免丢失
文件就是各种格式的文件，比如：.exe,.ppt......
要养成文件用完记着关闭文件的习惯

扩展阅读：（文件的打开模式和文件对象方法）
https://fishc.com.cn/forum.php?mod=viewthread&tid=45279&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

文件的打开：f=open('D:\\1.txt')，默认时以可读的方式打开，如果要写的话，后面加上，‘w’；前面一个反斜杠时文件路径的，后面那个时转义字符，用来读取前面路径的那个反斜杠
文件的读取： f.read()，括号里面加数字就是读多少个字符
文件的书签：f.tell()，读取到那个位置，就会书签到该位置
list（文件），可以将文件以列表读取
把文件一行一行的读取：for each_line in f:  print(each_line)
文件的写入：f.write('')，这样就会把原来的东西删了，写入现在的东西；写入后关闭文件才能看到写入的东西，否则只是写在了缓存区


for a in f:print(a)在文件中，该语句可以遍历文件的每行，同列表的一样print也会隔行打印

BigSmall

30
文件的分割
字符串的分割：str.split('分隔符',分割次数)

拆包：对于可迭代对象，如元组、列表、字符串、集合、字典这些可迭代对象都可以被拆包，拆包是指将一个结构中的数据拆分为多个单独变量中。
例子:(a,b)=[1,2]，将列表里面的两个元素拆分成两个变量；括号不必须

b='对话2'+str(a)+'.txt'    file2=open(b,'w')     
打开文件时，参数b应该时一个字符串，所以我们在个参数b赋值的时候应该也赋值一个字符串，文字字母什么的直接加上‘’就可以了，而a在写的代码中是一个数字，所以在这里我们要把它变成一个字符，文件的后缀也直接加上‘’就可以了

def save(list2,list3,a):
    b='对话2'+str(a)+'.txt'
    c='对话3'+str(a)+'.txt'
    file2=open(b,'w')
    file2.writelines(list2)
    file3=open(c,'w')
    file3.writelines(list3)
    file2.close()
    file3.close()
在定义该函数的时候，我本以为不用设置形参，但事实却不行。仔细看该函数，里面的list2、list3、a这三个参数并没有定义，所以需要把他们设置为形参，在调用该函数的时候，通过实参进行运算
定义函数就是把自己要定义的那部分函数直接封装起来，不要去考虑什么该放在主函数，什么该放在函数中，在这里，我们就是把实现保存的那部分代码直接放到了save函数中。同样还有split函数，直接把自己写的所有代码直接放了进去，不需要再考虑什么。

file2.writelines(list2)
这个语句就是将列表（序列都可以）的内容写入文件
文件的写入在循环里面，对于文件的写入，如果是'w'，就会在原来的文件中修改，会把原来的文件删除，所以在这里才能循环写文件。

将一个列表变成空列表或者定义一个空列表：listb=[]


if i[:4]!='====':这主意这个写法，对于第i行，也许有很多个等号，但是我们就分片前4个====

文件打开一定要关闭，否则在程序运行中就会出错，文件的关闭一般放在该段函数的后面

def split(name):
    file1=open(name)
split('D:\\1.txt')   涉及到文件时，注意函数的定义和调用时的形参与实参的写法


后面写一点想法：这应该是第一次尝试着自己去写这么长的代码（虽然是看了一遍教学），当遇到一些问题时，去查百度，发帖子，然后一个个小问题的解决，自己就跟一个小孩子一样，会很开心的yea一下（手上动作加嘴里轻轻喊一下）。虽然过程确实很艰难，不过结果挺开心。“Yes！”

BigSmall

31
模块：就是一堆类似的函数组合而成的文件，当你需要该模块里面的函数的时候，要把该模块的函数导入
比如：from random import randint

os、os.path 模块中关于文件、目录常用的函数使用方法（就是关于系统里面文件以及路径的一些操作）：
https://fishc.com.cn/forum.php?mod=viewthread&tid=45512&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

BigSmall

32
从文件和中读取的一般都是字符串，这就意味着从文件中恢复列表、元组就比较困难了
pickle：将列表、元组或者字典保存成二进制文件，读取该二进制文件后依然是原来的形式

保存：
import pickle
list1=[,,,,]
file1=open('list1.pkl','wb')
pickle.dump(list1,file1)
file1.close()
读取：
file1=open('list1.pkl','rb')
list2=pickle.load(file1)

BigSmall

33
异常总结：
https://fishc.com.cn/forum.php?mod=viewthread&tid=45814&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403
当我们遇到异常可以到这个网站去匹配

BigSmall

34
异常检测
try:
    1+'1'
except TypeError as reason:
    print(reason)
typeerror是出错类型，是什么出错类型就写什么
reason是一个变量，自己想怎么命名就怎么命名
except检查出错误，错误之后的代码就不会被执行了，所以为了使错误之后的代码也被执行，就将错误之后的代码放在finally：下面
   

BigSmall

35
//是除法，不会四舍五入，只保留一位整数

python中，else语句不仅可以和if语句搭配，还可以和其他语句搭配
else语句
可以和循环语句搭配，当循环语句成功循环完毕，那么就会执行循环下面的else语句，但是如果循环中止（循环语句里面写入break），那么else语句就不会被执行
还可以和try语句搭配，如果出错，执行try语句，如果没错就执行下面的else语句

with语句，可以避免文件没有关闭造成的问题，该语句可以自动关闭
with open（） as f：

BigSmall

36
pip安装
都不需要自己下载软甲包，直接运行cmd，输入pip install easygui
震惊，都不知道发生了什么，who can tell me？what the hell？

easygui帮助文档
https://fishc.com.cn/forum.php?mod=viewthread&tid=46069&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403

为了避免和python的代码冲突，建议使用import easygu as g，g.msgbox；而不是使用from easygui import*,msgbox

不要在idie点run，直接双击打开

设置框的大小和字体：

BigSmall

37
对象：
对象=属性+方法
属性就是变量赋值
方法就是函数定义

类和对象
类是对客观世界中事物得抽象，而对象是类实例化后的实体
例如：汽车模型就是一个类，制造出来的每辆汽车就是一个对象

类
创建：class 类名（大写字母开头，与函数的小写字母开头区分开）：
                属性
                方法
类的调用：
a=类名（）
a.方法

oo（object oriented 面向对象）的特征

封装：列表就是一个对象 ，列表的内部封装了许多方法，比如list.append()，我们只知道这个是往列表里面加元素的，但是并不清楚它是怎么实现的
继承：子类自动共享父类之间数据和方法的机制，比如class 类名（list）：pass，就是让类名继承list的属性和方法
多态：不同的类，如果有相同名字的函数，在之后的调用并不会冲突，各自是各自的，比如a.fun()和b.fun()，虽然函数名字相同，但是a的fun和b的fun函数实现的功能却不一样

BigSmall

38
类是图纸，对象是按着图纸做好的东西
一个类可以形成许多不同的对象，不同对象的使用同一类的同一函数，可以加进去该对象的不同的东西。这就需要在定义函数的时候将第一个参数写成self
class Ball:
        def this(self,name):
                print('这是球%s'%name)

a=Ball()
b=Ball()
a.this('a')
b.this('b')

公有私有
类通过‘.函数名‘就可以访问里函数内容，如果不想让访问，可以在定义函数名的时候加上两个下划线变成私有

BigSmall

37课后习题
关于类和self的详解
https://www.bilibili.com/video/av24145796?from=search&seid=114635733586211685


import random as r #导入函数模块写在最前面即可，这样在类里面也可以引用

class Turtle:
    def __init__(self): #这样的类一般放属性，不用调用就运行，有关属性的数据都加上self.，这样调用才不会出问题
        # 初始体力
        self.energy=100
        # 初始位置随机
        self.a1=r.randint(0,10) #随机位置，可以用随机函数产生x、y；游戏场景范围可以通过控制x、y实现
        self.b1=r.randint(0,10)
    def move(self): #定义类里面的函数也加self
        # 随机计算方向并移动到新的位置（a2, b2）
        self.a2=self.a1+r.choice([1,2,-1,-2]) #随机移动可以在原来的x、y加随机数，在这里随机数用一个r.choice函数实现
        self.b2=self.b1+r.choice([1,2,-1,-2])
        # 检查移动后是否超出场景x轴边界
        if self.a2 < 0:
            self.a1 = 0 - (self.a2 - 0) #超出边界后按照原路返回，这个地方不太好理解
        elif self.a2 > 10:
            self.a1 = 10 - (self.a2 - 10)
        else:
            self.a1 = self.a2
        # 检查移动后是否超出场景y轴边界
        if self.b2 < 0:
            self.b1 = 0 - (self.b2 - 0)
        elif self.b2 > 10:
            self.b1 = 10 - (self.b2 - 10)
        else:
            self.b1 = self.b2   
        # 体力消耗
        self.energy-=1
        # 返回移动后的新位置
        return (self.a1,self.b1)  #第一做没返回值，想用这x，y直接比，但不行，因为这个函数不是__init__函数，需要.来调用，不能直接用来参数比较
    def eat(self):
        self.energy+=20
        if self.energy>100:
            self.energy=100 #注意这个地方，一般想不到，就是虽然会加血，但是血有上限

class Fish:
    def __init__(self):
        self.c1=r.randint(0,10)
        self.d1=r.randint(0,10)
        number=1
    def move(self):
        # 随机计算方向并移动到新的位置（x, y）
        self.c2=self.c1+r.choice([1,-1])
        self.d2=self.d1+r.choice([1,-1])
        # 检查移动后是否超出场景x轴边界
        if self.c2 < 0:
            self.c1 = 0 - (self.c2 - 0)
        elif self.c2 > 10:
            self.c1 = 10 - (self.c2 - 10)
        else:
            self.d1 = self.d2
        # 检查移动后是否超出场景y轴边界
        if self.d2 < 0:
            self.d1 = 0 - (self.d2 - 0)
        elif self.d2 > 10:
            self.d1 = 10 - (self.d2 - 10)
        else:
            self.d1 = self.d2
        # 返回移动后的新位置
        return (self.c1,self.d1)
        

turtle=Turtle()
fish=[] #10条鱼，用列表来保存
for i in range(10):
    new_fish=Fish()
    fish.append(new_fish)
   
while True: #这段函数不好想
    if not len(fish):
        print("鱼儿都吃完了，游戏结束！")
        break
    if not turtle.energy:
        print("乌龟体力耗尽，挂掉了！")
        break
    pos = turtle.move() #就是这里，不能直接用move里面参数进行比较，需要调用函数，直接用函数来返回
    for each_fish in fish[:]:
        if each_fish.move() == pos:
            # 鱼儿被吃掉了
            turtle.eat()
            fish.remove(each_fish) #死一条鱼，列表remove一条，直到鱼全死了
            print("有一条鱼儿被吃掉了...")
        

BigSmall

做了37的习题的一些感想
自己在语言这方面的天赋基本为0，看着小甲鱼的答案做都觉得磕磕巴巴。别人都是自己写，只能硬着头皮继续往下看了，希望自己以后也会有突破吧。
这次这个游戏消化了一天，做出来也没有上次那么开心了。
可是我能怎么办呢？
明天继续
水会贴，会宿舍

BigSmall

39
如果将上次做的游戏的鱼分成几种类型，能不能不要每次都重头到尾去重新定义一个新的鱼类呢？鱼类的属性方法是相似的，所以引入继承
class 子名（父名）：
修改子类，父类并不会改变
修改子类的方法，子类继承的方法会被覆盖（同一函数名）
修改子类，同一函数__init__(self)，需要在继承的基础上加一些方法，就用super函数，super（）.__init__()

多重继承
class 子类（父类1，父类2，父类3）

BigSmall

39
多种鱼类，相似的属性和方法，怎么样就可以不用从头一个一个定义？就引入了继承
class 子类（父类）：
修改子类，父类不变
修改子类，同一函数名，子类继承的就会被覆盖
修改子类，同一函数__init__，如果需要在继承的基础上再加一些东西，就需要引入super().__init__()

多重继承：
class 子类（父类1，父类2，父类3）

39为什么有两个呢，因为第一次发的39，回复之后就没有了，我以为是丢失了，就重新编写了一次，结果过了一会提醒我审核通过 。以后就知道了，如果没发出去有可能正在审核。

BigSmall

40
组合
对于37游戏，如果想加一个水池类，有乌龟有鱼，如果让水池继承乌龟和鱼，显然时不同物种，所以就引入了组合
简单的说：把旧类的组合放到新类里面去
class Turtle:
    def __init__(self,x): #这里的x在实例化的时候需要写在Turtle（）括号里面
        self.number=x
class Fish:
    def __init__(self,x):
        self.number=x #其实类里面的‘self.’就相当于‘类名的’，这里就是鱼的个数
class Pool:
    def __init__(self,x,y):
        self.turtle=Turtle(x) #组合就是把自己需要组合的类在新的类中实例化
        self.fish=Fish(y) #其实类里面的‘self.’就相当于‘类名的’，这里就是池子里的鱼
        print('有乌龟%d只，有鱼%d只'%(self.turtle.number,self.fish.number))

类、类对象和实例对象
类是一个概念，比如鱼类什么的，类一旦class成功，那就变成了类对象
由类对象实例化而成的叫做实例对象
修改类对象，实例对象也会跟着改变
修改实例对象，类对象不会改变
修改实例对象，如果实例对象的属性和类对象的方法名相同，那么实例对象从类对象来的方法就会被覆盖，此时修改类对象，实例对象就不会改变

绑定（没有理解，以后用到的时候用例子来理解吧 ）
python严格要求方法需要有实例才能被调用，这种限制其实就是绑定
也就是在实例化的时候需要一个参数来绑定

       

BigSmall

41
与类和对象相关的一些BIF（内置函数Built-in function）
issubclass（a类，b类）判断a类是不是b类的子类，python默认自己是自己的子类
isinstance（实例化对象1，类2）判断1是不是2的实例化对象
hasattr（对象1，‘属性2’）判断2是不是1的属性
getattr（对象1，‘属性2’，‘3’）如果2是1的属性，返回2，如果不是，那么返回3；如果不设置3，存在的话默认返回0
setattr（对象1，‘属性2’，‘3’）为对象1再添加一个属性2，并为属性2赋值3
delattr（对象1，属性2）删除对象中属性
property（）通过属性来设置属性，就是把一部分属性封装在一个属性里面

BigSmall

42
魔法方法
魔法方法总是被双下划线包围。
魔法方法是面向对象的python的一切，如果你不知道魔法方法说明你还没能意识到面向对象的python的强大。
魔法方法的‘魔力’体现在他们总能够在适当的时候被自动调用。

__init__（self，）
该函数不能做任何的返回
该函数就是针对类的属性进行定义，当类实例化后，属性自动拥有，不用再去调用

__new__()
对于不可改变的类，比如str，不可改变的话就不能用init方法修改，所以这里用new方法进行替换

__del__(self)