笔记

无名的鱼

变量名包括字母、数字和下划线，并且必须以字母开头。
== 运算符用于判断两个变量的值是否相等，而 is 运算符用于判断两个变量是否为同一对象。
Alt + p 复制上一行代码。利用ctrl+f可以对网页浏览页面进行关键字查找。
Tab键不只是缩进，还可以进行代码提示，输入pr按下Tab就会出现以pr开头的函数。

print(x = 1，end = " ")
print(y = 2)
意思是结尾以空格的形式隔开，而不是换行，前面要加上逗号,这样x = 1 和 y = 2中间用空格隔开，敲几个空格就会用几个空格隔开，而不是换行。

转义字符\用在'前（\'    \"  \\n,转义换行符）。
print("Hello", "World", "Python", sep="\n")，如果没有sep="\n"，那么默认用空格分开，如果有sep="\n"，意思是用换行符分隔开。
\n为换行符，用在需要换行的行前面；三引号也可以换行，并且三引号在输入时中间没有空格。\放在末尾表示输入未结束，不执行代码，不如ctrl+j好用。
记住转义序列\n \t 等（用两个\\表示一个\）。
strip() 方法的作用：去除字符串开头和结尾的空白字符（包括空格、换行符、制表符等）；这样就能确保输入的内容是干净的，没有意外的换行。示例：age = input("你多大了？").strip()
print(r"D:\three\two\one")前面加r，里面的\n失去作用，不再换行；对于打印的文本中包含反斜杠，要在引号前加r是反斜杠失效。
字符串可以相加，意思是拼接，”520“+”1314“，结果是”5201314“；字符串不可以相减，会报错。
<=和>=号中间不能加空格，会报错。
ctrl+c强制停止程序运行。
将小数转化为十进制，import decimal  ,    a= decimal.Decimal(‘0.3’)，则转化为十进制。
复数x=1+2j,提取实部与虚部，x.real提取实部，x.imag提取虚部。abs(x)求取的为复数的模。
int()取整函数，int(9.99)结果为9，不会四舍五入。float()转换为浮点数，complex()转换为复数。
random():若random(1,10),返回1到10中随机整数。
while....break循环，需要break在循环体内，注意缩进位置；想让程序持续执行需要用continue。
continue 循环可以让程序继续执行不打印，跳出本次循环，回到循环的开头。
无论多少层循环嵌套，break 语句和 continue 语句都只能作用于离它最近的那一层。
地板除（//）：计算结果取比商小的最大整型。
幂运算：符号是**。
print("循环内，i的值是", i )其中逗号分隔要打印的内容，没有逗号会报错，在前面代码就是print(i , "是一个素数")。
无论for或while循环，当内层循环遇到 break 时，则跳过与它配对的 else。若没有遇到break，则执行配对的else。
if一行条件表达式：print("未满18岁。") if age < 18 else print("任君选购！") if isMale else print("不适合")；if后条件如果成立，输出if前结果，else后亦同理。
or方法：返回第一个为 真(True) 的值，如果都为假，则返回最后一个值。
and方法：返回第一个为 假(False) 的值，如果都为真，则返回最后一个值。
not方法：返回布尔值的否定，只接受一个操作数。not 1 输出false。
在Python中，当or、and、not一起使用时，运算顺序为：先not，后and，最后or。
链式比较化为普通比较：1 < 2 > 3 < 4 < 5化为1 < 2 and 2 > 3 and 3 < 4 and 4 < 5。
len() 函数的参数需要是一个序列或者集合，len(100)会报错。
range()方法：其中range(10,1,-1),打印10到2，不会打印1；range(10)会打印0到9.
列表x = [1,2,3,4,5]中，x[-1]选择的是5这个元素，x[4]选择的是5这个元素。
二维列表创建：a = [[i for i in range(10)]for j in range(10)]。
增加列表：一，append()只能添加一个元素，这个元素可以是列表。二，extend（[]）可以添加多个元素，但extend要加[]，若不加[]，s.extend("FishC")，那么结果就会变成 [1, 2, 3, 4, 5, 'F', 'i', 's', 'h', 'C']
                三，s[len(s):]=[6,7,8],在结尾加上这三个元素，四，s.insert(位置（插入列表所在位置），要插入元素)。五、s[len(s):] = ["上山打老虎"]，s[len(s):] = "上山打老虎"，一个加入列表，一个加入5个元素。
删除列表：一，s.remove（），存在多个相同元素，只会删除第一个，二，s.pop(输入要删除的元素，只接受位置索引)，三，s.clear（）清空列表。
改变列表：一，s.[3:5]= ["人才"，“相同”，"琢磨"]，则3，4会被改变。
排序列表：一，s.sort（）从小到大排序列表，并且s列表被改变，这个方法只能列表使用；如果用sorted（s）则会生成新的列表，列表s不发生改变，字符串和元组也可以使用这个方法。二，s.reverse（）原地调转元素；；i[ : :-1]
                      [5, 4, 3, 2, 1]也可以实现反转；reversed同上。
查找列表：一，s.counts(3)查找3这个元素出现的次数。二，s.index(3)查找3这个元素的索引值，多个相同元素，返回第一个索引值。三，查找列表中列表内的元素，s.[0][0]，先行后列，第一个[0]是行，第二个[0]是列。
复制列表：这两种方法都属于浅拷贝，修改x中的元素，y不会被改变。一，s.copy()复制列表，也可以切片复制，x = s.copy()。二，y = x[:],也是y对x的拷贝。
列表可以直接加减s = [1],t = [2],s+t=[1,2]，列表*3表示将列表里的元素复制三次。
列表推导式：s = [1,2,3,4] , x = [i for i in s] , 则x输出[1,2,3,4]；嵌套if的推导式：x = [i * 2 for i in s if i % 2 == 0] ， 则x = [2 ,4 ]。
元组用括号围成，也可以不加括号，x = 1,2,3用逗号隔开，也表示一个元组。元组的索引也要用中括号x[1] = 1；元组是不可变的，不支持修改，其他增删改查和列表一样。一个元素的元组s=(520,),要加上逗号。
字符串的各种方法：一，x.capitalize()只有字符串的首字母大写；x.casefold()所有字符串字母都变成小写；x.title()字符串中所有单词的首字母变成大写；x.swapcase()字符串中大小写反转；x.upper()字符串中所有字母变成大写；
                             x.lower（）字符串中所有字母变成小写。这些都不会改变字符串X，只是将X以不同形式输出。
                             二，x = “有内鬼，停止交易”，x.center(5)没有原字符串长，则原样输出；x.center(15)居中对齐且左右加上空格；x.ljust(15)左对齐，右边多的变空格；x.rjust(15)右对齐，左边多的变空格；x.zfill(15)右对齐，左      
                             侧变成0；“-520.zfill(5)”输出为‘-0520’；x.center(15，“干”)则填充变成干而不是空格，x.ljust(15 ，“干”)，x.rjust(15，“干”)同理。
                             三，x.count("海"，0，5)在序列0到5上输出“海”出现的次数；x.find("海")从左往右找第一个海的索引值和x.rfind("海")从右往左找第一个海的索引值，如果找不到则返回-1，x.index()找不到返回错误；
                             x.expandtabs(4)将字符串中的一个tab换成4个空格；x.replace("在吗","想你")，把字符串中的在吗换成想你。
                             四，买他的资料吧。
                             五，"{:0=10}".format(520)，用0填充有没有=结果相同，但是用别的填充必须有=，"{:_=10}".format(520)。
f-字符串："2+2的结果是{}".format(2+2)用这个方法转化f"2+2的结果是{2+2}"，结果是相同的，但是变量所处位置不同。
两者的区别：x = x * 2：总是创建新对象，形成新的标识符，x *= 2：对于可变对象是原地修改，标识符不变化，对于不可变对象创建新对象，则标识符变化。
字典的创建方法：一、s["刘备"]=”刘baby“，加到字典最后面。二、s=dict(吕布=“口口布”，关羽=“关习习”)，键不加引号，只有值加引号。三、s=dict([("吕布"，“口口布”),(“关羽”，“关习习”)])。四、s=dict({"吕布"：“口口布”,
                         “关羽”：“关习习”})。五、s=dict({"吕布"：“口口布”,“关羽”：“关习习”}，刘备=“刘baby”)。六、s=dict（zip（[“吕布”，“关羽”]，[“口口布”，“关习习”]））。
字典的增删改查看速查宝典。
字典的值可以嵌套字典或列表，嵌套字典时s["吕布"]["数学"]，嵌套列表时s[“吕布”][1]，后面为列表的索引值。
字典推导式：s = {x:ord(x) for x in "FishC"},求FishC中每个字母的编码，并组成字典，{’F‘ ：70 。。。。。}。
集合可以利用函数寻找和其他集合的并集，交集，差集，对称差集，超集和子集，但是不改变原集合的元素。
集合通过update的修改会改变原集合的元素。

定义函数时最后用return返回可以继续调用函数的值，如果用print返回则无法调用，调用会显示none。
函数的赋值：定义函数时annimal（x），则赋值时s = annimal(一个数)。
位置参数：位置固定的参数，必须按照顺序定义，（s ， vt ，o）则（”我“，”打“， ”小甲鱼“）
关键字参数：（s ， vt ，o）可以不按照顺序定义，o = “小甲鱼”，s = ”我“ ，vt = ”打“。
位置参数和关键字参数同时使用时，位置参数必须在关键字参数之前。
默认参数：不给默认参数赋值，则它将使用默认值，使用默认参数时，要把它放到最后。def myfunc(vt ,s = "小甲鱼", o = "我")
实际参数：可以是常数（5）；已赋值的变量（x=10）；合法表达式（a+b*2）。
形式参数：定义函数时使用的虚拟变量，接收调用函数时传入的实际参数。
定义函数时，斜杠“/”限制位置参数，即斜杠左侧的参数必须传递位置参数，而不能传递关键字参数（斜杠右侧的参数随意）；def abc(a, / , b, c)
星号“*”限制关键字参数，即星号右侧的参数必须传递关键字参数，而不能传递位置参数（星号左侧的参数随意）。def abc(a, * , b, c)
*args （其中*是必须的）是 Python 中的收集参数，它允许函数接受任意数量的位置参数。一必须放在所有位置参数之后。二可以接收0个或多个参数。
*args将元素打包为元组（*args，a，b），def myfunc（*args,a,b)调用时必须myfunc（1，2，3，a= 4，b = 5）这里的a和b必须使用关键字参数,结果是（1，2，3），4，5，其中（1，2，3）是元组。
**args将元素打包成字典，def myfunc(**args),调用时myfunc（a=10，b=11），因为是字典必须是键值，所以里面必须是关键字参数，结果是{'a' :10, 'b' : 11}
汇总样式：def myfunc（a,*b,**c）,调用myfunc(1 , 2 , 3, 4,x = 5,y = 6),结果为1（2，3，4）{’x‘：5，’y‘：6}
解包参数：myfunc(*args) , myfunc(**kwargs)。
局部作用域（局部变量）：定义在函数内部，只能通过调用函数来调用它，在函数外调用会报错。
全局作用域（全局变量）：定义在函数外部，具有全局作用域的变量在函数内部也可以访问到。
在函数中局部变量会覆盖同名的全局变量。
嵌套函数中的内部函数无法被直接调用。
global通过局部变量修改全局变量的值。（外部x = 880，内部x = 520，通过global外部也变成520.）
nonlocal修改闭包变量，从内部函数修改外部函数作用域中的变量，实现了一个带记忆功能的函数。（外部函数x = 880，内部函数x = 520，通过nonlocal外部函数也打印520.）
LEGB规则：L是local是局部作用域，E是enclose是嵌套函数的外层函数作用域，G是global是全局作用域，B是build-in内置作用域。（发生冲突时，前面的覆盖后面的）
闭包是嵌套函数的一种特殊形式，就是一种带有记忆功能的函数，funny= funa（）将内层函数作为返回值给返回，利用funny（）去做任何事。nonlocal属于对闭包的辅助，没有nonlocal也可以实现闭包。
引用外部变量实例：
def outer():
    x = 0
    y = 0
    def inner(x1,y1):
        nonlocal x,y
        x = x + x1
        y = y + y1
        print(f"现在，x = {x},y = {y}")
    return inner
运行move（1，2），得到：现在，x = 1,y = 2，然后运行move（-2，2），得到：现在，x = -1,y = 4。
将函数作为返回值，只需要写出函数，不需要加小括号，return  funB，函数只有在定义和调用的时候会加小括号。
对于嵌套函数，外层函数的作用域是会通过某种形式给保存下来的，尽管这个函数已经调用完了，但是外层作用域里的变量，他是会保存下来的，并不会像局部作用域那样，调用完就消失了。
return  funB，返回的是 funB 函数对象，而不是执行结果，需要再次调用返回的函数才能看到输出。fun B在 funA 内部直接调用了 funB，调用 funA() 时会立即打印结果，不返回任何值（默认返回 None）。
函数可以作为另一个函数的参数，作为参数时不用加括号，定义time_master（func），再定义myfunc（），通过time_master（myfunc）来调用函数。
import time

def time_master(func):
    def call_func():
        print("开始运行程序....")
        start = time.time()
        func()
        stop = time.time()
        print("结束程序运行...")
        print(f"一共耗费了{(stop - start):.2f}秒。")
    return call_func

@time_master        #就是装饰器（闭包+拿函数当参数）的语法糖
def myfunc():
    time.sleep(2)
    print("Hello,FishC.")

myfunc()              #myfunc为装饰后的函数
此程序相当于在调用myfunc时并不是直接调用，而是把myfunc这个函数作为参数，塞到上面装饰器里，然后去调用装饰器。（最后的myfunc（）等价于myfunc=time_master（myfunc），返回call_func函数，然后调用myfunc（），实现内部函数，相当于闭包）
@time_master
@add                                         当多个装饰器时，从下往上调用。
@time_master （msg = "A"）      这就是带参数的装饰器。
lambda（匿名函数），简称一行流。示例一：y = [lambda y : y * y ,2,3]，输入：y[0](y[1])  输出：4（y[0]是lambda y : y * y）示例二： squareY = lambda y : y * y 输入：squareY(3)  输出：9  
生成器（generator object）产生的两种方式：一，直接使用yield替换return来实现。
                                                                 二，生成器表达式：s =（i ** 2 for i in range(10)）直接运行则产生生成器数码（与列表推导式不同），它像一只下蛋的老母鸡，一点一点的吐，next（s）则会一个结果一个结果的生               
                                                                                              成。for i in range（s）,print（s）则完全打印。
递归是自己调用自己，但一定要设置终止条件，不然会一直调用无法停止。递归数大概相当于数列，递归效率非常低，不如用while迭代速度快。
无法停止示例：
def super():
    print("你太卑鄙了")
    super()
停止示例：
def cess(i):
    if i >= 0:
        print("你掏卑鄙了")
        i = i - 1
        cess(i)

汉诺塔中嵌套函数的执行方式，当层数为3时，先else中第一个函数调用完成（其中也包括print(x, '-->', z)和hanoi(n-1, y, x, z)），然后再 print(x, '-->', z)，最后调用最后的函数（其中也包括print(x, '-->', z)和hanoi(n-1, y, x, z)）。
def hanoi(n, x, y, z):
    if n == 1:
        print(x, '-->', z)
    else:
        hanoi(n - 1, x, z, y)
        print(x, '-->', z)
        hanoi(n-1, y, x, z)

n = int(input("请输入汉诺塔的层数："))
hanoi(n, 'A', 'B', 'C')
函数：函数文档（help(print)）就是函数的说明书，类型注释（time（s:str , n:int））就是预设好的类型，内省（time.__name__就是找出名字），偏函数（functools.partial()，具体见functools模块），高阶函数（函数接收另一个函数作为参数），wrap装饰器
永久存储open（）函数里面有许多小函数示例和文档对象大合集。
不执行f.close（）或者f.flush（）文档中将不会显示刚输入的内容，内容在文档缓冲区，不在文档内。
文件对象可以直接读取：for each in f：print（each），其中f为f=open（“fishc.txt”，w）
路径处理：具体见pathlib模块
文件操作三板斧：打开文件，文件写入，关闭文件
with上下文管理器：不需要关闭文件，只需要执行打开文件和写入文件。
示例：with open ("FishC.txt","w") as f:
                f.write("I love FishC")                                   直接执行就可以运行结果并关闭文件。
pickle模块：pickle.dump()：对象 → 字节流 → 文件（序列化/写）；pickle.load()：文件 → 字节流 → 对象（反序列化/读）。
python异常写法：
try-else(可以内部嵌套tey-else)
raise自爆异常语句
assert程序调试语句
利用异常来实现goto语句
一、
try:
    1/0
except  （zerodivisionerror(可以指定具体异常，只有属于指定异常，才可以输出“出错了”；若没有这句话，无论任何异常，就直接打印“出错了”)）:
    print("出错了")
输出"出错了"。
打印异常原因：在zerodivisionerror后面加上as e，并且下面print（e）就会打印异常原因（division by zero）。
二、
不知道什么异常：
try：
     1/0
     520+“FishC”
except (zerodivisionerror , valueerror , typeerror)
     pass
只要包含这三种异常中任何一个就pass没有输出，
三，try-except-else-（finally）：
try:
    1/1
except:
    print("逮到你了")
else:
    print("搞笑")
(finally:
    print("带没带到说一声"))
输出"搞笑"和（"带没带到说一声"）。
四，遇到异常不会往下执行：
try:
    1/0
    520+"FishC"
except ZeroDivisionError:
    print("逮到你了")
except TypeError:
    print("执行不了吗")
输出”逮到你了“，不会执行下面的，因为执行完1/0，会立即跳转到“逮到你了”，不会接着执行520+"FishC"。

类和对象的属性是通过字典存放的。
对象由属性（类中的对象）和方法（指类中的函数；函数放到类里面，函数括号里需要加上self，加上self是为了让类知道，那个对象在调用，myfunc(self)）相加而成，通过类来创造实际的对象。
类名必须由大写字母开头，定义class Turtle，把类赋值给不同对象，t2=Turtle（），t1=Turtle（），改变t2中类的属性（t2.legs=5），对t1中类的属性没有影响。
面向对象编程：封装；继承和多态

继承:
class A:
    x = 520
    def hello(self):
        print("你好，我是A")
#类B继承类A
class B(A):
    pass
令b = B(),则b.x输出520；b.hello()（函数调用的方法，实例.函数名（））输出“你好，我是A”
若类B存在和类A一样的属性和方法名，并且B继承于A：
class B(A):
    x = 880
    def hello(self):
        print("你好，我是B")
令b = B(),则b.x输出880；b.hello输出“你好，我是B”

继承的内置函数：一、判断是否属于同一个继承。isinstance（b，B)，输出是true 和 isinstance（b，A），输出是true。
                         二、判断一个类是否为某个类的子类。issubclass（B，A），输出是true。

多重继承（一个子类可以同时继承多个父类）：
class B:
    x = 880
    y = 250
    def hello(self):
        print("你好，我是B")
class C(A,B):
     pass
令c= C（），则c.x为520，c.hello（）为“你好，我是A”               说明：从左到右去继承；只有A中没有才会去B中找，比如c.y输出为250.

绑定：第一个参数是 self，指向实例本身；第二个参数是开发者自定义参数，使用时只需要只需要传递自定义参数，Python 自动传递第一个参数；可以访问和修改实例属性。
class C：
        def set_x(self,v):
                self.x = v
输入：c.set_x(250)     输入c.x           输出：250

类的内省：C.__dict__,可以内省出类C中有哪些属性。
重写（子类对父类的重写）：class D(C)对C在继承的情况下进行改写。
在类中定义__init__（）方法，就可以在实例化对象的同时实现个性化定制，自己手动添加就是p.age = 30，def __init__(self, age):     self.age = age   用着两个语句就可以达成手动添加效果。
super()函数：当在子类里写代码时，想使用父类里已经写好的某个功能，就可以用 super() 自动向上搜索父类，然后调用它的方法，自动避免重复问题，搜索基于当前实例的类在 MRO 中的位置，不是当前函数所在的类向上找。super().__init__()多个父类只需要这一个语句，它会遍历。
mro(方法解析顺序):深度优先，从左到右，孙子——爸爸——爷爷，一级一级从下往上找。调用方法C.mro().
多态：同一个运算符、函数或对象在不同的场景下具有不同的作用效果的技能。
self.__x=x前边两个下划线，表示这是私有变量。
私有变量的访问：_类名__属性名（getattr(c,"_C__age")）用于访问双下划线开头的“私有”属性。
__slots__不允许动态添加属性，里面有self.x = x和self.y = y，不允许添加z属性到这个里面；并且继承与父类中的__slots__属性是不会生效的。
魔法方法大合集(__函数名__())。
按位与运算3&2结果2，3&4结果是0.解释：3的二进制011，2的二进制是010，取相同则为010为数字2；4的二进制100，取相同则为000.
按位或运算3|2结果3，3|4结果是7.  解释：3的二进制011，2的二进制是010，取相交则为011为数字3；4的二进制100，取相交则为111.
按位异或运算，3^2为1，3^4为7.解释：异或运算，相同取0，不同取1，3的二进制011，4的二进制100，取异或则为111.
右移位数，8的二进制为1000，8>>2则二进制变为10，则为数字2.（最后的1会丢失，9的二进制为1001，9>>2二进制变成数字2，并不是二进制011）
左移位数，8的二进制为1000，8<<2则二进制变为100000，则为数字32.
模块：文件A中定义的函数，想去文件B中引用，则A就是B的模块，调用时就是：一、import A    二、from 模块名称 import 对象名称（如果对象特别多，可以只输入一个*，表示引入模块中所有对象），不推荐第二种
模块导入过程中，是会从头到尾执行一遍所导入的模块。
破解方法：当其他模块导入当前模块时，if __name__ == "__main__": 下面的代码不会执行，只有直接运行当前模块时才会执行。当直接运行脚本时：__name__ == "__main__"，当被导入时：__name__ == "模块名"。
包：通过文件夹的形式，对源代码文件进行整理和分类。调用方法：import 包的文件夹名称.模块文件名称。             下面调用对象时，包的文件夹名称.模块文件名称.模块中函数名（）
包文件夹中的模块文件，无法直接调用自己所在的包。