字符串

  1. title()—首字母大写 ；upper()—–全大写 ；lower()—–全小写 。用法：变量名.title() ;变量名.upper() ; 变量名.lower().这些都是临时操作，无法改变变量的值，只有：变量=变量名.··()才行。
  2. f""可以将变量插入字符串中，则直接是双引号里的内容(空格要算)；若在””里加{}，再在{}里加变量名，则可以将字符串变量的内容插入“”内的字符串里。f””可以直接在print里面使用。
1
2
3
4
5
6
7
m=f"jdka jsk"
//输出：jdka jsk 

m="jsakdf" 
n=f"jksa {m} ajdkf"
输出n：jksa jsakdf ajdkf。

  1. \t(制表符)在开头添加空白，如 print(“\tksfj”)。\n换行，\t,\n可以添加在字符串中的任意位置
  2. 删除空白 rstrip()—删除右空白, lstrip()—删除左空白, strip()—删除空白（左右的，中间的不能删）。用法 变量名.rstrip()；变量名.lstrip()；变量名.strip()
  3. 字符串可以直接相加。python中单引号和双引号没有区别。包括换行的字串用”””……”””
1
2
3
4
5
6
eg:
s = """
dsfsfdsf
fsfsfsd
dffd
"""
  1. 可以在已有的字符串中引用其中单个字符，但不能给超出字符串长度的位置进行单个赋值。引用方法：字符串a[位置s]
  2. 换行时：print()
  3. chr()函数可以将一个整数转换成其对应的字符（ASCII值）
  4. ord()函数它可以对应一个长度为1的字符返回相对应的Unicode值或者8进制的ASCII值。严密意思上说，它是与chr函数完全相反计算的函数。（只能是长度为一的字符）
  5. str()函数可以将数字直接转化为字符串：1->’1’。
  6. byte字符串是uint8的别称，rune字符串是int32的别称。byte类型和rune类型使用编码方式不同，其中byte是ASCII编码字符，rune是utf-8字符。
  7. ascii有效数值33-126
  8. replace函数，替换字符串中的字符：replace(要替换内容，被替换的内容)，还可以是replace(要替换内容，被替换的内容,替换个数(从第一个开始))
  9. a = string.printable[:62] 生成只含且包含所有并且不重复的数字和大小写字母的字符串，string.printable[:-6] 打印所有可见字符无法打印ascii表的所有字符，有些可以用字节串表示的字符不在其中
  10. for i in itertools.product(a,repeat=4): 遍历由a字符串中所含的字符构成所有可能的长度为4的字符串,此时i是元组的形式，每个元素是一个字符。(需要这个函数itertools)。itertools.permutations和product类似，用法也类似。
1
2
3
4
5
6
7
8
a = 'abc'
for i in itertools.product(a,repeat=3):
    print(i,end=' ')
//('a', 'a', 'a') ('a', 'a', 'b') ('a', 'a', 'c') ('a', 'b', 'a') ('a', 'b', 'b') ('a', 'b', 'c') ('a', 'c', 'a') ('a', 'c', 'b') ('a', 'c', 'c') ('b', 'a', 'a') ('b', 'a', 'b') ('b', 'a', 'c') ('b', 'b', 'a') ('b', 'b', 'b') ('b', 'b', 'c') ('b', 'c', 'a') ('b', 'c', 'b') ('b', 'c', 'c') ('c', 'a', 'a') ('c', 'a', 'b') ('c', 'a', 'c') ('c', 'b', 'a') ('c', 'b', 'b') ('c', 'b', 'c') ('c', 'c', 'a') ('c', 'c', 'b') ('c', 'c', 'c') 

for i in itertools.permutations('abc'): 
  	print(i,end=' ')
//('a', 'b', 'c') ('a', 'c', 'b') ('b', 'a', 'c') ('b', 'c', 'a') ('c', 'a', 'b') ('c', 'b', 'a')
  1. i =””.join(i)，将列表i中的所有元素合并为一个字符串。
  2. set():set函数用于创建一个无序不重复元素集(可以去掉重复的字母)，它的输出结果是一个set类型。set函数可以接收任何可迭代对象作为参数，包括列表、元组、字符串、字典等。当你使用set函数从字典创建集合时，它只会保留字典中的键，而不会保留值。

字节串

  1. 提取字节串的任意一个不可打印字符：
    1. 直接通过该字符的索引提取时，提取得到的是该字符的ASCII值
1
2
3
4
a = b'\x01helloww'
print(a[0])

输出：1
  2. for循环提取字节时，同样是提取该字节对应的ASCII码

1
2
3
4
5
6
7
s = b"01"
for i in s:
    print(i)

输出：
48
49
  3. 通过切片提取（及切片长度为1），提取的是该字符的字节串

1
2
3
4
a = b'\x01helloww'
print(a[0:1])

输出：b'\x01'
  1. 字节转比特流时（即二进制表示），一个字节对应8比特，每个字节的改变只会影响该字节对应的8个比特，不会影响其他位二进制数据（即其他字节对应的二进制位）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from Crypto.Util.number import bytes_to_long

a = b'qas'
print(bin(bytes_to_long(a)))
a = b'sad'
print(bin(bytes_to_long(a)))

输出：
0b1110001 01100001 01110011
0b1110011 01100001 01100100
补齐高位0后：
01110001 01100001 01110011
01110011 01100001 01100100

  1. 移位操作符
    1. 左移操作符（<<）将一个数的二进制表示向左移动指定的位数，相当于对该数进行乘以 2^n的操作。
    2. 右移操作符（>>）将一个数的二进制表示向右移动指定的位数，相当于对该数进行除以 2^n 的操作。
  2. 在Python中，bytes 对象是不可变的，这意味着你不能直接修改它的内容。当你尝试像修改普通列表或数组那样去修改 bytes 对象时，就会遇到 TypeError: ‘bytes’ object does not support item assignment 这样的错误。
    1. 为了解决这个问题，你可以使用 bytearray 类型，它是 bytes 的可变版本。你可以将 bytes 对象转换为 bytearray 对象，对其进行修改，然后如果需要，再将其转换回 bytes 对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 假设 txt 是一个 bytes 对象
txt = b'\x01\x02\x03\x04'

# 将 bytes 对象转换为 bytearray
txt_modifiable = bytearray(txt)

# 现在你可以修改 txt_modifiable
# 将字符 '1' 的 ASCII 值赋给第二个字节
txt_modifiable[1] = ord('\x98')

# 如果需要，可以将修改后的 bytearray 转换回 bytes
txt = bytes(txt_modifiable)
print(txt)

输出：
b'\x01\x98\x03\x04'

数和运算

  1. 表示乘方，如23=222；42=4*4；53=555
  2. python的运算法则和数学中一样
  3. 只要操作数中有浮点数，最终得到的数都是浮点数
  4. 数中加下划线，在python3.6及以上的版本中输出时会没有，如2000_2300_231,输出是20002300231
  5. 取余%和c++一样，break,continue 和c++一样
  6. a^b:a和b是十进制的数据，将10进制数字转换为2进制数字进行异或运算，再转换10进制数字。两个数字大小不同的a，b进行异或时，高位保持不变，相同位进行异或。eg:0b1111110011^0b1111=0b1111111100，0011^1111=1100
  7. //向下取整，eg：5//2=2，-5//2=-3

赋值

  1. 一个代码一行但赋值可以这样多个变量赋值：x,y,z=1,2,3 一个位置对应一个数值

其他

  1. 注释：#用于注释
  2. 注释：还可以:”””注释内容”””，这种注释方法可以多行注释，类似于c++的/* */
  3. 注释：可以将多行代码选中后，同时按 ctrl键+/键，就可以同时注释多行代码
  4. 缩进：选中多行代码，按tab键就可以同时缩进4个字符的位置
  5. 左移：选中多行代码，按tab键+shift键，就可以同时左移4个字符的位置

列表

  1. 列表（数组）也是从0开始，初始赋值不用定义元素个数，使用中括号将元素括上，元素可以是字符串，字符，数字等，但是字符和字符串要加单引号。在索引时，数组除了第一个是从零开始，倒数第一个则是索引-1，倒数第二个是-2 以此类推。例如 m[-1],m[-3],m[0]。若使用列表之前，未曾有过赋值或调用，需要申明列表:列表名=[]
  2. 在列表末尾添加元素（数组末尾）用append()。用法 变量名.append(元素或变量名)，括号中是添加的元素，字符串要加单引号
  3. 列表中插入元素用insert函数。用法：变量名.insert(位置a，元素)，若a>0,则元素添加在a处，原先在位置a的元素以及后面的元素自动向后移动一位。若a<0，则添加在位置a前面一个的位置，位置a和后面元素各向后移动一位。
  4. 删除列表中的元素，用del语句。用法 del 变量名[位置a]，删除的就是位置a的元素，然后后面的元素自动向前补齐。
  5. 弹出列表中的元素pop()函数。用法 变量名.pop(位置a)，位置a可要可不要，写了位置a，就弹出位置a的元素，不写位置a，一个空括号，则自动弹出最后一个元素。使用语句时，可以只有弹出语句，如 m.pop()；也可以在弹出时用一个变量将弹出的元素储存进去，如 n=m.pop()。
  6. 根据值删去列表中的元素——remove()。用法 变量名.remove(具体的元素)。但只能删除第一次出现此值的元素。
  7. 永久排序(字母顺序和数字从小到大)——sort()。 用法 变量名.sort(),若要字母或数字反着排序，则变量名.sort(reverse=True)
  8. 临时排序（字母顺序和数字从小到大）——sorted()，只是临时排序，此语句执行完，顺序还原不变。用法sorted(变量名)，在可以输出时使用，例如print(sorted(m))
  9. 永久反转列表元素顺序——reverse()。用法：变量名.reverse()
  10. 确定列表的长度（测的是元素个数）——len()。用法：m=len(变量名)
  11. 列表的结构之一。列表名=[循环主体 for循环 ],初始化。eg：a=[m*m for m in range(6)]
  12. a = [[0 for i in range(5)] for i in range(33)] #创建33行5列（a[33][5]）的二维数组
  13. 切片，将列表中的部分索引出来。
  14. 用法一： 列表名[位置a:位置s]，将位置a（包括位置a）到位置s（不包括位置s）的元素索引出来，相当于索引s-a个元素，和range()有点像如果a=0，则m[0:2]=m[:2]。如果要索引位置a到最后一个的元素，那么索引时，右索引的数字为元素个数，即最后一个元素位置加一，并且还可以表示为：列表名[位置a:]
  15. 用法二：列表名[位置a:位置s:步长d]，位置a到位置s（不包括s）每d个索引一个，例如d=2时，每隔一个元素索引一次。切片也可用于for循环中，替代列表s
  16. range()函数创建一系列的数。用法 range(x)=range(0,x),range(x,y),range(x,y,z)，x，y，z是数字。range（x）是指生成从0到x（不包括x）的数字；range(x,y)是指生成从x到y（不包括y）的数字；range（x，y，z）是指生成从x到y（不包括y），步长为z的数字，即类似于for(int q=x;q<y;q=q+z)中的q
  17. list()函数可以将range()函数生成的一系列数字存入一个新建的列表。用法 ： m=list(range(·····))
  18. max(列表名)求列表最大值，min(列表名)求列表最小值，sum(列表名)求列表总和
  19. 复制列表：列表a=列表s[:]只能这样，不能是列表a=列表s，因为如果是这样，在后面对列表a或s的任意操作都会被视为是对同一个列表的操作并执行，最后的结果是无论怎么对列表a或列表s区别操作，列表a和列表s的列表都是一样的，且都为最近一次对列表a或列表s的操作后产生的新列表。
  20. 元组，初始化时其他都和列表一样，只不过括号是用圆括号（），元组建立后，其列表及其元素不可改变，也不可添加元素，但可以以初始化的格式进行重新赋值 eg：列表a=(·····)。索引元素时，还是用中括号[],eg m[2]。
  21. 列表里可以装字典。
  22. 创建空列表：列表a=[]。
  23. list=[1,2,3,4],list[::-1]=[4,3,2,1]
  24. list(字符串)：可以将字符串中的每一个字符存入列表中。
  25. 在Python中，如果您有一个字符的列表，您可以使用join()方法将列表中的每个字符拼接成一个字符串。
1
2
3
4
5
6
7
8
9
10
# 假设您有一个字符的列表
char_list = ['H', 'e', 'l', 'l', 'o']

# 使用空字符串作为分隔符，将列表中的字符拼接起来
joined_string = ''.join(char_list)

# 打印拼接后的字符串
print(joined_string)

#输出：Hello

split()函数和rsplit()函数：

split函数

  1. 在Python中，split() 函数是字符串对象的一个方法，它用于将字符串分割成多个子字符串，并返回一个列表。split() 函数可以接受一个或两个参数。
  2. 单个参数：当split()函数只接受一个参数时，这个参数指定了用作分隔符的字符串。split()方法会根据这个分隔符将字符串分割成多个部分，并返回一个包含这些部分的列表。
1
2
3
text = "Hello, World!"  
result = text.split(", ")  
print(result)  # 输出：['Hello', 'World!']
  1. 两个参数：当split()函数接受两个参数时，第一个参数仍然是指定分隔符的字符串，而第二个参数是一个可选参数，指定了最大分割次数（从左到右）。这意味着split()函数将最多执行指定的分割次数，然后返回结果列表。
1
2
3
text = "apple,orange,banana,grape"  
result = text.split(",", 2)  
print(result)  # 输出：['apple', 'orange', 'banana,grape']
  1. 注意：
    1. 如果分隔符在字符串中不存在，split()函数将返回包含整个原始字符串的列表。
    2. split()函数不会改变原始字符串，而是返回一个新的列表。

rsplit函数

  1. 在Python中，rsplit() 函数与 split() 函数类似，也是用于将字符串分割成多个子字符串，并返回一个列表。不过，rsplit() 是从字符串的末尾开始向前搜索分隔符来进行分割的。
  2. 单个参数：当rsplit()函数只接受一个参数时，这个参数指定了用作分隔符的字符串。rsplit() 方法会根据这个分隔符从字符串的末尾开始向前搜索，并将字符串分割成多个部分，然后返回一个包含这些部分的列表。（此时和split函数一样）
1
2
3
text = "apple,orange,banana,grape"
result = text.rsplit(",")
print(result)  # 输出：['apple', 'orange', 'banana', 'grape']
  1. 两个参数：当rsplit()函数接受两个参数时，第一个参数仍然是指定分隔符的字符串，而第二个参数是一个可选参数（整数），指定了最大分割次数。这意味着 rsplit() 函数将从字符串的末尾开始，最多执行指定的分割次数，然后返回结果列表。（和split函数的区别）
1
2
3
text = "apple,orange,banana,grape"  
result = text.rsplit(",", 1)  
print(result)  # 输出：['apple,orange,banana', 'grape']
  1. 注意：
    1. 如果分隔符在字符串中不存在，rsplit() 函数将返回包含整个原始字符串的列表。
    2. 如果分隔符是空字符串，rsplit() 函数将把字符串中每个字符都当作分隔符，并返回一个包含所有单个字符的列表，但是是从字符串末尾开始向前构建的。
    3. 同样，rsplit() 函数不会改变原始字符串，而是返回一个新的列表。

for循环

  1. for循环。用法 :
1
2
for 变量a in 列表s（或range（））:
  	 循环内容（必须缩进，才代表是循环主体，且要缩进相同格数）

意义：循环从列表s中的第一个元素到最后一个元素，依次赋值给变量a，每赋一次值进入一次循环主体当下一行语句不缩进时，此语句就不再在for循环当中，列表s可以替换成range()函数，例如 for 变量a in range(6)。

  1. for循环还可以用在字典中，遍历字典中的键和值，格式和列表的相比有略微变化 用法：
1
2
3
4
5
for 变量1，变量2 in 字典a.items():   其中变量1存键名，变量2存值。

for循环还可以只遍历字典的键：
for 变量a in 字典s.keys():
for 变量1 in 字典a:     默认的是只遍历字典的键

if语句

  1. if语句和c++基本一样，只是不需要圆括号将条件括起来，然后条件后面需要加冒号，再换行；else也要接冒号。条件中的并且’&&‘被替代为’and‘、或者’||’被替代为’or’，同样两个并列的条件也可以分别用括号括起来，使之更加清楚明了。
  2. in 语句，检查某个元素是否在列表中(字符串同样适用)，可以用在if中，也可以用在print中，其他判断语句也是。用法：元素a(或变量a) in 列表s。判断是否是不在列表中，就用not in语句，使用时就和in语句一样：元素a not in 列表s。
  3. if语句还多了一个if-elif-else语句，相当于if-else的else里面还有一个if-else，elif后面也可以接条件，然后加冒号。一个if语句中可以增加很多个elif，就相当于if的判断条件，不符合就执行下一条判断语句。elif后面不是最后一定要有else。
  4. if语句可以用来判断列表是否为空，用法： if 列表a：。如果列表不为空，则为true，进行下一条语句；如果列表为空，则为false，不进行if里的语句，或进行else的语句。
  5. 判断此程序是否是作为主程序运行：if name==’main‘:，如果是调用的其他py文件，则是false

字典

  1. 字典。类似于列表，只不过创建时使用{}。字典内储存有键值对，通过键来索引匹配的值。用法：字典名a={‘键名1’：元素1，‘键名2’：元素2·····} 元素如果是字符串，则加单引号；如果是数字，则直接写，什么都不加。索引时：字典名[‘键名‘]，同样因为键名是字符串，所以要加单引号。注意：因为键名是字符串，所以无论何时要记得加单引号。
  2. 添加键值对。语句：字典a[‘键名1’]=元素1。即可添加键值对。
  3. 可以创建空字典：字典a={}。在后续根据需要再添加键值对。
  4. 修改字典中的值，和添加键值对类似，直接赋值即可。
  5. 删除字典中的键值对。同样用del语句，和删除列表中的元素的方法类似，方法：del 字典a[‘键名’]。同样，删除后，后面的自动向前补齐。
  6. 字典中同样可以装列表，可以直接以列表的形式装进去，也可以以变量的形式装进去。eg：字典a={‘键名1’：[····]，‘键名2’：列表名s，····}。也可以字典中套字典。使用和c++的二维数组类似
  7. get()语句。用法：变量s=字典a.get(‘键名1’，返回的内容d)。若没有键名1，则返回d。d可以为字符串，也可以为数字，若为字符串则要加单引号。若字典中有键1，则变量s=键1的值；若字典中没有键1，则变量s=内容d。内容d也可以选择不要，则语句是：变量s=字典a.get(‘键名1’)，此时如果不存在键1，则返回None给变量s。
  8. 字典a.keys()代表的是键；字典a.values()代表的是值；字典a.items()代表的是键值对。
  9. sorted还可以用在字典上，用法和列表类似，用法：sorted(字典a.keys())，排序是仅对键排序，如果是print(sorted(字典a.keys()))，则只输出键排序后的结果，不包含值。同样也可以对字典a.items()排序，只不过排序结果和.keys()差不多，都是对键排序，但是.items()比.keys()多了值，输出时排序结果有值。同样也可以对字典a.values()排序，结果是对值的排序结果，只输出值的排序。
  10. 去重可以用set。用法：set(变量a)。不管是set(字典a)还是set(字典a.values())，.keys()和.items()都是根据键去重。变量a既可以是字典，也可以是列表，作用都是去重。字典的去重是多个重复的键，出去前面重复的键，保留最后一个。
  11. 对字典键值对按值排序，输出结果为键值对（格式：每一个键值对存放在元组中，元组存放在列表中）：
1
2
# 按值(value)从大到小排序，my_dict：字典名，reverse=True：从大到小排序
sorted_items_desc = sorted(my_dict.items(), key=lambda item: item[1], reverse=True)
  1. 判断字典中是否有这个健
1
2
3
4
#用于检查变量 i 是否是字典 private_fre 中的一个键（key）。
#如果 i 是字典中的一个键，那么 if 语句后面的代码块将会执行。

if i in private_fre:

复杂语句

  1. 缩进相同列数，相当于c++中在同一个花括号内，属于同一条复杂语句。

输入输出

  1. input函数。用法：m=input(“提示语句”),提示语句可以不要。读入整行
  2. 用input输入，python自动将它归类为字符串。
  3. print()，可以同时输出多个元素，中间用空格隔开：print(元素1,元素2,元素3,元素4,····)
  4. end语句用于print中：print(···，end = ···)表示该语句的结尾是什么，如果不加end语句，print默认的是end = ‘\n’,所以每次print语句输出完后会换行

pycharm下载库

  1. pycharm添加外部库方法：通过cmd命令提示符，输入pip install 库名,再按回车即可。还可以在pycharm的settings里的project的interpreter里package右边的加号点击搜索即可。
  2. 提高库的下载速度：pip install 库名 -i 网址（镜像源）
  3. 下载库时，如果报错：
1
ERROR: Cannot uninstall 'llvmlite'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.

直接在anacoda里面的Lib文件夹的site-packages的文件夹内，将无法删除的库手动删除即可(除了库名对应的文件夹以外，还有该库的info文件，或含有该库名的其他文件)。

int()

  1. int()函数.用法int(字符型变量)将可以将字符型变量变为整型，和c++不同的是，它是将字符型的数字直接变成整型，数字不变，而不是将其转换为ASCII值。例如：字符型‘12’用int()可以变成12。int()函数可以用在input函数后，因为input()函数输入的内容自动识别为字符型。(input函数是读取整行)
  2. int()函数值能对由数字组成的字符串使用，eg：’12345’等。不能对其他字符组成的字符串使用，eg：’asdf’等。
  3. int()函数还可以对十进制数字使用，无论数字a是多少，都只会保留数字a的整数部分。

while

  1. while语句。用法：while 条件 ：
  2. while True ： 会一直循环
  3. while 元素a in 列表s ：意思元素a在列表s中有n个，while重复循环n次

创建函数

  1. 定义函数：def 函数名（）：
1
2
3
def 函数名（）：
    """····（解释说明函数的作用）"""(这行可要可不要)
    函数内的语句
  1. 向函数传递信息：函数a（元素s）元素s就是向函数a传递的信息，可以在函数内使用，和c++类似，元素s是形参。括号内可以有多个形参，用逗号隔开：函数a（元素1，元素2，···）
  2. 在给函数传递值时，可以将名称和值联系起来：函数a（形参1=元素1，形参3=元素3，····）
  3. 函数默认值：在定义函数时，就可以在函数的（）中给形参赋值：def 函数a（形参1=元素1，····）。在后续调用函数时，就可以不用再给该形参赋值。如果在后续调用函数时，又给该形参赋值，那么该形参的值是后续赋值所给的值。
  4. 返回值用return语句，和c++类似，返回的值在调用函数的代码行。
  5. return可以返回多个值，但是用小括号将之括在一起，eg:return (元素a，元素s)。调用函数，并储存韩式返回值时，应当：(元素1，元素2)=函数a(····)
  6. 调用函数时，直接传递列表，函数可以直接修改列表。若调用了列表，则在整个代码中的原列表的值也会随之改变。
  7. 若想要禁止函数修改列表，则可以采取将列表副本传递给函数的方法，调用函数时：函数a(列表s[:])
  8. 传递任意数量的实参，储存在形参列表中。在定义函数时：def 函数a(元素1)。此时形参元素1是空元组，且在调用函数a时，可以传递无数实参，eg：函数a(元素1，元素2，元素3，···)在调用元素1时，就是写元素1，不加星号（）。若还有其他形参，必须将*元素1放在最后。
  9. 传递任意数量的实参，储存在形参字典中。定义函数时：def 函数a(**元素1).此时元素1是空字典。在调用函数时，输入任意多个键和值的方法是：函数a(···,键名a=元素1，键名s=元素2)，此时键名不用加单引号，同样，还有多个其他形参时，此形参放在最后的位置。但在此时键名不能只是数字（键名a，键名s····）
  10. 将函数储存在模块中：创建一个函数d，将之保存在文件a中，在文件s中如果要调用函数a，则：
1
2
import 文件a(名字)
文件a.函数d(····)
  1. 导入储存在模块（文件a）中的函数：from 文件a import 函数s。此时在后续代码中若要调用函数，则可以直接使用。可以同时导入多个函数：from 文件a import 函数s1，函数s2，函数s3···
  2. 使用as给函数指定别名：from 文件a import 函数s as 函数名s2——在此文件中函数s改名函数s2
  3. 使用as给模块（文件）指定别名：import 文件a as 文件名a1——在此文件中文件a改名文件a1
  4. 导入模块中的所有函数：from 文件a import *
  5. 在 Python 中，全局变量（global variables）是在模块（通常指的是一个文件）级别定义的变量，它们可以在整个模块中访问。然而，函数内部默认情况下不能直接修改全局变量的值。但是有一些特殊情况下，你可以在函数内部修改全局变量的值：
  6. 可变类型的全局变量：如果全局变量是一个可变类型（例如列表、字典、集合等），你可以在函数内部修改它的内容，而不需要使用 global 关键字。（哪怕只是修改函数中形参的值，也会导致传递值的实参的数值改变）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def a(s):
    s[1] = 0
    print(s)

s = [1,2,3]
a(s)
print(s)
输出：
[1, 0, 3]
[1, 0, 3]

def a(d):
    d[1] = 0
    print(d)

s = [1,2,3]
a(s)
print(s)
输出：
[1, 0, 3]
[1, 0, 3]
  1. 要让函数内的d的改变不影响外部的列表a，您可以在函数内部创建d的副本。这样，对副本的任何修改都不会影响原始列表。您可以使用列表的copy()方法或者切片操作[:]来创建副本。

1
2
3
4
5
6
7
8
9
10
11
12
def s(d):
    d = d.copy()
    d.pop()
    print(d)

a = [1,2,3]
s(a)
print(a)

输出：
[1, 2]
[1, 2, 3]
  2. 不可变类型的全局变量：对于不可变类型（例如整数、字符串、元组等），你不能直接在函数内部修改其值。如果你尝试修改，Python 会创建一个新的局部变量，而不是修改全局变量。
     1. 使用 global 关键字：如果你在函数内部想要修改一个全局变量的值，你可以使用 global 关键字来声明该变量是全局变量。这样，你就可以在函数内部修改它了。

类

  1. 创建类：
1
2
3
4
5
6
7
8
9
10
11
12
class 类名：   #类名首字母最好大写以示和函数区别,作用和c++类似
    def __init__(self,元素1，元素2，元素3，···)：#元素1，元素2，元素3和函数的形参类似
        self.元素名a=元素1                     #同样可以给元素1，元素2··设值默认值
        self.元素名s=元素2
        self.元素名d=元素3  #一般元素a、s、d会和元素1、2、3名字相同
        ····               #self.元素名 才是类的变量，叫属性。形参元素1、2、3···只是用
                           #于赋值，所以定义属性的数量和形参的数量无关
		def 函数名(self):       # 类里面创建函数（可以创建也可以不创建）
   			····                #类里面创建的函数和一般的函数类似，也可以以又return语句

变量a=类名(元素1，元素2，元素3，···)  #此处和函数类似，给形参元素1，元素2，元素3赋值
                             #此语句叫创建实例，可以创建多个实例，后续调用此类时：a.元素名a；a.元素名s；a元素名d,·····。
  1. 调用类里面的函数时，如果定义函数时括号内只有self，则是：变量a.函数名（），（）是空括号，实参在创建实例的时候就输入了，若定义函数时括号内除了self还有形参，则调用函数时括号内有实参。类中的函数又称为方法
  2. 在创建类的时候给属性赋默认值：
1
2
3
4
5
def __init__(self,元素1，元素2，元素3，···)：
     self.元素名a=元素1
     self.元素名s=值1  #赋予属性默认值
     self.元素名d=元素2
     ···
  1. 修改属性值：可以在创建实例后，可以直接修改属性的值：变量a.元素名a=某元素或某值；也可以在创建类的代码中修改，比如在定义函数的代码中。
  2. 创建子类，子类将继承所有父类的方法和属性写法：
1
2
3
class 子类名(父类名)：
    def __init__(self,元素名1，元素名2，元素名3···)：
    super().__init__(元素名1，元素名2，元素名3···)

父类必须在子类前面，此时属性和方法都会继承的子类中,此时元素名1，元素名2，元素名3 的 ···不用和父类形参名相同.在继承父类后，同样可以添加属性和方法，属性就在super（）下一行，方法就是正常添加

  1. 在继承父类的子类中，如果出现和父类相同的方法名，则会忽略父类的方法，使用子类的方法。
  2. 实例也可以作为其他类的属性：self.元素名1=类a()，后续使用就将其（变量a.元素名1）当作一个整体，看成类a来使用。

文本

  1. 读文件：
1
2
with open('文件名.txt') as 变量名1：
     变量a=变量名1.read()

此时变量a中储存文件中的所有内容（可以是n行的内容，n>1），文件中内容不能包含中文

  1. 以字节的形式读文件：
1
2
with open("C:/Users/上善若水/Desktop/cipher.txt","rb") as p:
    c = bytes_to_long(p.read())

代码中的open函数以二进制读取模式（“rb”）打开文件，这意味着文件将会按照字节的形式被读取，而不会尝试按照任何特定的编码来解释这些字节。这通常用于读取非文本文件，如图像、音频、视频或任何其他二进制格式的文件。

  1. 读取在文件夹内的文件：with open(‘文件夹名/文件名.txt’) as 变量名1： 即可
  2. 读取文件夹或文件时，不管是文件夹还是文件，都必须和python源代码在同一个文件夹中才行。
  3. 还可以进行绝对路径的引用：open(‘·····’)，单引号中间的内容是绝对路径——文件在电脑中显示的路径+/+文件名。eg:C:\Users\上善若水\Desktop\python\read,但是在引用时，我们一个当把其中的’'变成’/‘才行。
  4. 还可以将路径赋值给变量，再引用变量：变量1=’···’,with open(变量1) as 变量2：
  5. 读取文件时，会将改行的换行符读取，所以想要输出时不换行，则使用函数.rstrip()
  6. 逐行读取文件：
1
2
with open('···') as  变量1:
     for 变量2 in 变量1：

变量2中储存了每一行的内容

  1. readlines()函数：将文件中读取的内容以列表的形式读取出来，每行为一个元素。
1
2
with open('····') as 变量1：
    列表1=变量1.readlines()
  1. 创建新的文本，并输入内容：
1
2
3
4
with open('新文本的路径（包括新文本的名字）'，'w') as 变量a：
    a.write('要输入的内容')

#eg：'/path/to/your/file.txt'（文件路径）

如果再一个已创建的文本中输入，则文本中原先的内容都会清空，又输入的内容代替

  1. 如果直接是两行.write()代码，是无法换行的，和print不同，我们需要加换行符才能使输入的内容换行
  2. 如果想要在原来的文本的基础上加入内容：with open('····',mode='a') as 变量1:
  3. 'rb+'代替'w'，可以用于读取二进制文件。
  4. 'w'模式：表示写入模式，如果文件存在会被覆盖。如果文件不存在，创建新文件。这种模式下，你正在处理文本数据，即你写入的内容会被视为字符串。'wb'模式：表示二进制写入模式。这种模式下，你正在处理二进制数据，比如图片、视频等。这时候，你写入的应该是字节（bytes）类型的数据，而不是字符串。总结来说，'w'与'wb'的主要区别在于，'w'用于写入文本（字符串），而'wb'用于写入二进制数据。
  5. 过大的文件读取后无法完整的打印在控制台上

try语句

  1. try-except语句：先执行try语句下面的代码块，如果不报错，就忽视except下的代码块的语句，如果报错，判断和except语句中的异常名是否一致，如果一致，则执行except下的代码块：
1
2
3
4
try:
    ····（代码块）    #print(5/0) 报错如下：
except  异常名：     # ZeroDivisionError: division by zero,异常名是ZeroDivisionError
    ····（代码块）
 其中的异常不包括语句的基本错误。一个try后面可以跟无数个except。
  1. try-except-else，else在最后一个except后面，和except并列，当try语句执行完，没有异常时，执行else下面的代码模块（我觉得没有什么用，直接把else模块的代码放在try的模块中不就一样了）
  2. try-···-finally,try语句后面还可以和finally并列，不管try中的模块是否又异常，finally中的模块都要执行。try语句后面必须又except或者finally。try语句中即使出现异常，finally中的语句仍然会执行除非有基本的语句错误（我也觉得finally没多大用）

pass语句

  1. pass是空语句，什么都不做。pass不做任何事情，表示一个占位符，一般用作占位语句。能够保证程序的代码结构正确。

json模块

  1. json.dump()将数据储存进json文件中：
1
2
with open('文件名.json'，'w') as 变量1：
     json.dump(变量2，变量1)   #将变量2的内容赋给变量1，再储存进文件中。
  1. json.load()将json文件中的数据读取出来：
1
2
with open('文件名.json') as 变量1：
     变量2=json.load(变量1)    #读取出来的数据储存在变量2中
  1. json支持数组、对象、字符串、数字、布尔型、NULL值
  2. json.load从文件中加载数据，而json.loads从字符串中加载数据。另外，json.load返回一个Python对象，而json.loads返回一个Python字典（如果JSON字符串是一个对象）或一个Python列表（如果JSON字符串是 一个数组）。

报错

  1. 因为中文报错：SyntaxError: Non-UTF-8 code starting with ‘\xba’ in file。在代码首行加: # coding:utf-8 即可（一定在首行加）
  2. 因为Python在Windows中打印文本时默认使用GBK编码，但是网络上的数据大都是UTF-8编码，特殊字符GBK无法解码就会报错:UnicodeEncodeError: ‘gbk’ codec can’t encode character ‘\xee’ in position 20266: illegal multibyte sequence。解决方法（添加下面代码）：
1
2
3
4
5
6
import sys
import io
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
#但要注意，有些时候输出的都为正常的utf-8（没有特殊字符）的时候，不需要加上面
的几行代码，加了反而会输出乱码，这个时候删除sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
即可。所以最好一般不要加这个代码，除非出现报错SyntaxError……才加

对python结果进行搜索

  1. ctrl+f，在搜索框输入搜索内容即可（其他很多软件、浏览器中是ctrl+g用来搜索内容）

左移和右移操作

  1. 左移
    1. 左移操作在二进制层面上相当于乘以2的某个幂。当你将一个数字的二进制表示向左移动时，你实际上是在增加它的位级表示中的位置，这相当于将该数字乘以2的移位数的次方。
    2. 例如，如果有一个数字x，并且你执行x << 1（即左移一位），这相当于x * 2。如果你执行x << 2，这相当于x * 4，依此类推。
    3. 左移操作比乘法运算快得多，因为它可以直接在硬件级别上执行。左移操作也不会遇到乘法可能导致的溢出问题，因为结果总是简单地扩展了数字的二进制表示。（需要注意的是，左移操作可能会导致结果超出原始数据类型能够表示的范围。）
1
2
x = 1  # 二进制表示为 0001  
y = x << 3  # y 的值是 8，二进制表示为 1000
  1. 右移
    1. 右移操作在二进制层面上相当于除以2的某个幂。当你将一个数字的二进制表示向右移动时，你实际上是在减少它的位级表示中的位置，这相当于将该数字除以2的移位数的次方。
    2. 例如，如果有一个数字x，并且你执行x >> 1（即右移一位），这相当于x / 2（忽略余数）。如果你执行x >> 2，这相当于x / 4，依此类推。
    3. 注意：
      1. 舍入：在实际的除法运算中，你可能会得到一个带有小数的结果，而在右移操作中，结果总是向下取整。
      2. 符号：对于负数，右移的行为可能会因编程语言和平台的不同而有所不同。在某些情况下，右移负数可能会导致算术右移（保持符号位不变），而在其他情况下可能会导致逻辑右移（不考虑符号位）。
      3. 溢出：如果右移的位数超过了数字的位数，结果通常是未定义的。例如，在一个8位字节中右移9位是没有意义的。
      4. 性能：在计算机硬件中，移位操作通常比除法运算要快得多，因为它们可以直接在硬件级别上执行。
1
2
x = 8  # 二进制表示为 1000  
y = x >> 1  # y 的值是 4，二进制表示为 0100

异或运算：

  1. a，b不同，异或结果为1；a，b相同，异或结果为0。python的异或运算符：^
  2. 一般是将两个数的值转化为二进制，再进行异或运算，最后得到的值就是异或运算的结果的二进制形式。
  3. 异或运算的性质：a异或b=c，则a异或c=b；b异或c=a
  4. ^异或时不会自动补全，低位异或，高位不变。如：
1
2
3
4
5
6
7
8
9
n1 = b'ab'
n2 = b'a'
c = bytes_to_long(n1) ^ bytes_to_long(n2)
print((long_to_bytes(c))[:1])
# b'a'
print((long_to_bytes(c))[1:])
# b'\x03'
print(long_to_bytes(bytes_to_long(b'a') ^ bytes_to_long(b'b')))
# b'\x03'
  1. 在两个长度不同的字节串进行异或运算的时候，可以通过重复短的字节串自身来填充短的字节串，直到长度与长字节串一致。
1
2
3
#len(a)>len(key)
complete_key = (key * (len(a)//len(key)+1))[:len(a)]
#[:len(a)],将长度限制在len(a)
  1. xor函数能自动补全短字节的字节串，原理同 5 。
1
2
3
4
5
6
from pwn import xor

a = '0e0b213f26041e480b26217f27342e175d0e070a3c5b103e2526217f27342e175d0e077e263451150104'
a = bytes.fromhex(a)
key = b'myXORkey'
print(xor(a,key))

镜像源

  1. 清华大学：https://pypi.tuna.tsinghua.edu.cn/simple/
  2. 阿里云：https://mirrors.aliyun.com/pypi/simple/
  3. 豆瓣：https://pypi.douban.com/simple/
  4. 中国科学技术大学：https://pypi.mirrors.ustc.edu.cn/simple/