python小白考前复习
1.编码（密码本）
计算机中所有的数据本质上都是以0和1的组合来存储。
在计算机中会将中文内存转换成 01010101010… ，最终存储到硬盘上。
在计算机中有这么一个编码的概念（密码本）。
奥 -> 01111111 00011010 010110110
特 -> 01001111 10010000 001110100
曼 -> 11111111 00000000 010101010
在计算机中有很多种编码。
每种编码都有自己的一套密码本，都维护这自己的一套规则，如：
utf-8编码：
奥 -> 01111111 00011010 010110110
特 -> 01001111 10010000 001110100
曼 -> 11111111 00000000 010101010
gbk编码：
奥 -> 11111111 00000010
特 -> 01001111 01111111
曼 -> 00110011 10101010
所以，使用的不同的编码保存文件时，硬盘的文件中存储的0/1也是不同的。
注意事项：以某个编码的形式进行保存文件，以后就要以这种编码去打开这个文件。否则就会出现乱码。
UTF-8编码去保存奥特曼：01111111 00011010 010110110 01001111 10010000 001110100 11111111 00000000 010101010
GBK编码形式去打开：乱码
编码必须要保持：保存和打开一致，否则会乱码。
默认Python解释器是以UTF-8编码的形式打开文件。如果想要修改Python的默认解释器编码，可以这样干：
# -*- coding:gbk -*- print("我是你二大爷")建议：所有Python代码文件的都要以UTF-8编码保存和读取。
2.数字类型
2.1整数
你可以单独使用数字0，但不要前置它
print(07) #这是错误的
幂的优先级高于乘除
print(2**3*3)# 结果是24
2.2浮点数
科学计数法
- 把10用e代替
- e的前面不能为空(解释器会误以为这是一个变量名的）
print(e10)#NameError: name 'e10' is not defined
- e的后面不能为空，必须是整数
print(1e10.0)#SyntaxError: invalid syntax不合句法
divmod函数：同时计算商和余数
print(divmod(9,2))#输出（4，1）
print(divmod(9.0,2))#输出（4.0，1.0）
慎用round(x,n)函数
Python 中的 round() 函数用于对浮点数进行四舍五入。其基本语法如下：
round(number[, ndigits])
number 是要四舍五入的数字。
ndigits 是一个可选参数，表示要保留的小数位数。如果省略，round() 将返回最接近的整数。
round() 函数的四舍五入规则如下：
如果要舍去的数字小于5，则直接舍去。
如果要舍去的数字大于5，则进位。
如果要舍去的数字正好是5，且它后面没有更多的数字（或者是一个无穷小量）,如果是偶数，则舍去；如果是奇数，则进位。这是所谓的“银行家舍入法”或“圆法”。
例如：
print(round(2.3)) # 输出: 2
print(round(2.5)) # 输出: 3
print(round(2.7)) # 输出: 3
print(round(5.5)) # 输出: 6
print(round(4.5)) # 输出: 4
abs函数求模
因为所有实数都可以看作是复数，而该函数又有如下功能
print(abs(3+4j))#输出5.0
故当括号内为实数时也可以求模，等效于求绝对值
注意：abs返回值为浮点数
关于复数
real和imag方法可以取出实部和虚部
a=3+4j
print(a.real)#3.0
print(a.imag)#4.0
complex可以组合复数
print(complex(3,4))#输出(3+4j)
在Python中，complex() 函数用于创建一个值为 (real, imag) 的复数对象，其中 real 是复数的实部，imag 是复数的虚部。复数在Python中由类 complex 表示。
基本语法如下：
complex([real[, imag]])
real是复数的实部，默认为0。imag是复数的虚部，默认为0。
如果只提供一个参数，它将被视为复数的实部，虚部默认为 0。如果提供两个参数，第一个参数是实部，第二个参数是虚部。
以下是 complex() 函数的一些使用示例：
# 创建一个实部为2，虚部为3的复数
c1 = complex(2, 3)
print(c1) # 输出: (2+3j)
# 创建一个实部为0，虚部为3的复数
c2 = complex(imag=3)
print(c2) # 输出: 3j
# 创建一个实部为2的复数，虚部默认为0
c3 = complex(2)
print(c3) # 输出: (2+0j)
# 不指定参数时，创建一个实部和虚部都为0的复数
c4 = complex()
print(c4) # 输出: (0+0j)
复数在Python中可以进行加法、减法、乘法和除法等运算，就像实数一样。例如：
c5 = complex(1, 2)
c6 = complex(3, 4)
# 加法
print(c5 + c6) # 输出: (4+6j)
# 减法
print(c5 - c6) # 输出: (-2-2j)
# 乘法
print(c5 * c6) # 输出: (-5+10j)
# 除法
print(c5 / c6) # 输出: (0.6-0.8j)
复数的表示形式 (实部+虚部j) 中的 j 表示虚数单位，类似于数学中的 i。在Python中，复数的虚部部分会附带一个 j 来表示。
3.字符串类型
R方法
在Python中，字符串对象有一个称为 r 或 R 的特殊方法，称为 “raw string”（原始字符串）。当你在一个字符串前面加上 r 或 R 时，它告诉Python解释器不要对字符串中的转义字符进行处理，而是将它们视为普通字符。
原始字符串的特点：
- 特殊字符，如
\n（换行符）、\t（制表符）、\"（双引号）和\'（单引号）等，在原始字符串中不会被转义。 - 这在处理文件路径或正则表达式时特别有用，因为在这些情况下，反斜杠
\是路径分隔符或正则表达式的一部分，而不是转义字符。
示例
普通字符串与原始字符串的对比
# 普通字符串
path = "C:\\Program Files\\MyApp"
print(path) # 输出: C:\Program Files\MyApp
# 原始字符串
raw_path = r"C:\Program Files\MyApp"
print(raw_path) # 输出: C:\Program Files\MyApp
在这个例子中，普通字符串 path 中的 \n 被转义为换行符，导致输出时出现了换行。而在原始字符串 raw_path 中，\ 被保留为普通字符，因此输出时没有换行。
原始字符串在正则表达式中的应用
import re
# 普通字符串
pattern = "\\d+"
result = re.findall(pattern, "123 leading digits")
print(result) # 输出: ['123']
# 原始字符串
raw_pattern = r"\d+"
result = re.findall(raw_pattern, "123 leading digits")
print(result) # 输出: ['123']
注意事项
- 原始字符串
r""只影响\字符的处理，其他特殊字符（如"和'）仍然需要使用反斜杠进行转义。
type函数
Python 中的 type() 函数用于获取对象的类型。当你想要确定一个变量的类型时，可以使用这个函数。它返回一个表示对象类型的类型对象。
基本语法如下：
type(object)
object是你想要获取类型的对象。
以下是 type() 函数的一些使用示例：
# 获取一个整数的类型
num = 42
print(type(num)) # 输出: <class 'int'>
# 获取一个浮点数的类型
float_num = 3.14
print(type(float_num)) # 输出: <class 'float'>
# 获取一个字符串的类型
str_val = "Hello, World!"
print(type(str_val)) # 输出: <class 'str'>
# 获取一个列表的类型
my_list = [1, 2, 3]
print(type(my_list)) # 输出: <class 'list'>
# 获取一个元组的类型
my_tuple = (1, 2, 3)
print(type(my_tuple)) # 输出: <class 'tuple'>
# 获取一个字典的类型
my_dict = {'name': 'Alice', 'age': 25}
print(type(my_dict)) # 输出: <class 'dict'>
# 获取一个布尔值的类型
is_true = True
print(type(is_true)) # 输出: <class 'bool'>
# 获取一个复数的类型
complex_num = complex(1, 2)
print(type(complex_num)) # 输出: <class 'complex'>
type() 函数不仅可以用来获取内置类型的类型，还可以用来获取由用户定义的类的实例的类型：
class MyClass:
pass
# 创建 MyClass 的一个实例
my_instance = MyClass()
# 获取实例的类型
print(type(my_instance)) # 输出: <class '__main__.MyClass'>
3.那些冷门的函数们
字符串处理函数
Python提供了丰富的内置函数和方法来处理字符串。以下是一些常用的字符串处理函数和方法：
str.upper(): 将字符串中的所有字符转换为大写。
s = "Hello World" print(s.upper()) # 输出: "HELLO WORLD"str.lower(): 将字符串中的所有字符转换为小写。
print(s.lower()) # 输出: "hello world"str.capitalize(): 将字符串的第一个字母转换为大写，其余字母转换为小写。
print(s.capitalize()) # 输出: "Hello world"str.title(): 将字符串中每个单词的首字母转换为大写。
print(s.title()) # 输出: "Hello World"str.strip(): 移除字符串开头和结尾的空白字符。
ss = " Hello World " print(ss.strip()) # 输出: "Hello World"str.lstrip(): 移除字符串开头的空白字符。
print(ss.lstrip()) # 输出: "Hello World "str.rstrip(): 移除字符串结尾的空白字符。
print(ss.rstrip()) # 输出: " Hello World"str.replace(old, new): 替换字符串中的指定子串。注意它会替换字符串中所有的制定子串
print(s.replace("World", "Python")) # 输出: "Hello Python"str.split(sep=None): 按照指定分隔符
sep分割字符串，并返回一个列表。print(s.split()) # 默认按空白字符分割，输出: ["Hello", "World"]
扩展
data = "奥特曼|root|wupeiqi@qq.com"
v1 = data.split("|") # ['奥特曼', 'root', 'wupeiqi@qq.com']
print(v1)
v2 = data.split("|", 2) # ['奥特曼', 'root|wupeiqi@qq.com']
print(v2)
再扩展
data = "奥特曼,root,wupeiqi@qq.com"
v1 = data.rsplit(',')
print(v1) # ['奥特曼', 'root', 'wupeiqi@qq.com']
v2 = data.rsplit(',',1)
print(v2) # ['奥特曼,root', 'wupeiqi@qq.com']
应用场景：
file_path = "xxx/xxxx/xx.xx/xxx.mp4"
data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]
str.join(iterable): 将可迭代对象中的元素以指定的字符串作为分隔符连接成一个新的字符串。
words = ["Hello", "World"] print(" ".join(words)) # 输出: "Hello World"str.find(sub): 查找子串
sub在字符串中的位置，如果找不到则返回-1。print(s.find("World")) # 输出: 6str.index(sub): 查找子串
sub在字符串中的位置，如果找不到则抛出ValueError。print(s.index("World")) # 输出: 6str.count(sub): 返回子串
sub在字符串中出现的次数。print(s.count("l")) # 输出: 3str.startswith(prefix): 检查字符串是否以指定前缀
prefix开始。print(s.startswith("Hello")) # 输出: Truestr.endswith(suffix): 检查字符串是否以指定后缀
suffix结束。print(s.endswith("World")) # 输出: Truestr.isalpha(): 检查字符串是否只由字母组成。
str.isalpha()函数检查字符串是否只包含字母，并且至少有一个字符。如果字符串中包含空格或其他非字母字符，isalpha()将返回False。
例如：
s = "Hello World"
print(s.isalpha()) # 输出: False
在这个例子中，"Hello World" 包含一个空格，所以 isalpha() 返回 False。如果字符串只包含字母，没有空格或其他字符，那么 isalpha() 将返回 True。
s = "HelloWorld"
print(s.isalpha()) # 输出: True
str.isdigit(): 检查字符串是否只由数字组成。
print("123".isdigit()) # 输出: Truestr.isspace(): 检查字符串是否只由空白字符组成。
print(" ".isspace()) # 输出: Truestr.islower(): 检查字符串是否全部为小写。
print(s.islower()) # 输出: Falsestr.isupper(): 检查字符串是否全部为大写。
print(s.upper().isupper()) # 输出: Truestr.encode(encoding=‘utf-8’): 将字符串编码为指定编码的字节串。
print(s.encode()) # 默认使用 'utf-8' 编码，输出: b'Hello World'str.decode(encoding=‘utf-8’): 将字节串解码为字符串。
byte_str = s.encode() print(byte_str.decode()) # 输出: "Hello World"
还有一下这些
Python 字符串提供了多种方法来进行格式化和操作，以下是您提到的一些字符串方法的介绍：
center(width[, fillchar]):
center()方法将字符串居中，并使用fillchar（默认为空格）填充至指定的width宽度。s = "Hello" print(s.center(10, '-')) # 输出: '----Hello---'ljust(width[, fillchar]):
ljust()方法将字符串左对齐，并使用fillchar填充至width宽度。print(s.ljust(10, '-')) # 输出: 'Hello--------'rjust(width[, fillchar]):
rjust()方法将字符串右对齐，并使用fillchar填充至width宽度。print(s.rjust(10, '-')) # 输出: '--------Hello'zfill(width):
zfill()方法将字符串用'0'填充至width宽度，原字符串右对齐，通常用于数字字符串。print("42".zfill(5)) # 输出: '00042'
# 应用场景：处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"
casefold():
casefold()方法将字符串中的所有字符转换为小写，对 Unicode 字符集进行了扩展，比lower()更彻底。print("Hello World".casefold()) # 输出: 'hello world'swapcase():
swapcase()方法将字符串中的所有大写字母转换为小写，小写字母转换为大写。print("Hello World".swapcase()) # 输出: 'hELLO wORLD'isalnum():
isalnum()方法检查字符串中的所有字符是否都是字母或数字，如果是，则返回True。
跟isalpha一样都会检查空格print("Hello123".isalnum()) # 输出: Trueisnumeric():
isnumeric()方法检查字符串中的所有字符是否都是数字，如果是，则返回True。在这里，汉字的数字也算数字。
跟isalpha一样都会检查空格print("123".isnumeric()) # 输出: Trueexpandtabs(tabsize=8):
expandtabs()方法将字符串中的制表符（\t）展开为空格，tabsize参数指定制表符的宽度。print("\tHello".expandtabs(4)) # 输出: ' Hello'rfind(sub[, start[, end]]):
rfind()方法返回子串sub在字符串中最后一次出现的位置，如果未找到则返回-1。可以指定搜索的起始和结束位置。print("Hello World".rfind("o")) # 输出: 7
以及非重点isinstance
在Python中，isinstance() 是一个内建函数，用于检查一个对象是否是一个已知类的实例，或者是否派生自那个类。这对于在使用面向对象编程技术时确定对象的类型非常有用。
函数的基本语法如下：
isinstance(object, classinfo)
object：要检查的对象。classinfo：一个类或类元组，指定要检查的类型。
如果 object 是 classinfo 中指定的类或其子类的实例，则 isinstance() 函数返回 True，否则返回 False。
示例
# 检查字符串是否为str类的实例
s = "Hello, World!"
print(isinstance(s, str)) # 输出: True
# 检查数字是否为int类的实例
n = 42
print(isinstance(n, int)) # 输出: True
# 检查对象是否为元组或列表的实例
t = (1, 2, 3)
l = [1, 2, 3]
print(isinstance(t, (list, tuple))) # 输出: True
print(isinstance(l, (list, tuple))) # 输出: True
# 检查自定义类的实例
class MyClass:
pass
my_instance = MyClass()
print(isinstance(my_instance, MyClass)) # 输出: True
print(isinstance(my_instance, object)) # 所有类都继承自object，输出: True
isinstance() 函数常用于以下情况：
- 确保对象是期望的类型，然后执行特定操作。
- 在多态编程中检查对象的实际类型，以调用相应的方法。
- 在处理来自不同类但具有相似接口的对象时，确保类型安全。
与 type() 函数不同，isinstance() 还考虑到了继承，即如果对象是某个类的子类实例，isinstance() 也会返回 True。这使得 isinstance() 成为处理复杂类型层次结构时的首选函数。
4.布尔类型、空值和列表类型
关系运算符
python中的关系运算符可以连用，比如
a=b=c=1
print(a==b==c)#True
b+=1
c*=3
print(a<b<c)#True
基本比较法则
- 关系运算符的优先级相同
- 两个数字的比较，关系运算符按照大小比较
比如print(3<5>2)#True,这等价于3<5 and 5>2 - 两个字符串的比较，关系运算符从左到右，一一比较字符串中字符的Unicode码值：
首先，比较两个字符串中的第一个字符，哪个码值大哪个字符串就大
若第一个相等，再依此继续往下比较，直到分出大小
比如
注意字符串不能和数字比较大小print("Hello">"world")#False,因为ascii('H')=72<119=ascii('w')
除了比较是否相等的情况
比如，1和”haha"不可以比较谁打谁小，但可以得出1="haha"的结果是False
逻辑运算符
and和or具有惰性求值（逻辑短路）的特点
- 在表达式 A and B 中，如果 A 为 False，则不会计算 B 的值，因为整个表达式的结果已经确定为 False。只有当 A 为 True 时，才会计算 B。
- 在表达式 A or B 中，如果 A 为 True，则不会计算 B 的值，因为整个表达式的结果已经确定为 True。只有当 A 为 False 时，才会计算 B。
比如
print(3>5 and a>3)#输出为False,注意，此时并没有定义a
逻辑表达式的结果等于最后被计算的子表达式的结果
比如
print(3 and 5)#输出为5，因为3是非0数，结果为True,所以还要计算下一个表达式的值，即为5
print(3 and 5>2)#输出为True，因为3是非0数，结果为True,所以还要计算下一个表达式的值，即为True
print(3 or 5)#输出为3，因为3是非0数，结果为True,所以由惰性求值规则，不需要计算下一个表达式的值，即最后一个表达式的值为3
运算符的优先级有很多，常见的没几个，推荐你记住3个即可：
算数优先级优先级 大于 比较运算符
if 2 + 10 > 11: print("真") else: print("假")比较运算符优先级 大于 逻辑运算符
if 1>2 and 2<10: print("成立") else: print("不成立")逻辑运算符内部三个优先级 not > and > or
if not 1 and 1>2 or 3 == 8: print("真") else: print("假")
上述这3个优先级从高到低总结：加减乘除 > 比较 > not and or 。绝招：加括号。
逻辑运算中：and or
v1 = name == "alex" and pwd == "123"
# v1 = True and False
if name == "alex" and pwd == "123":
pass
v2 = "wupeiqi" and "alex"
# 第一步：将and前后的只转换为布尔值 True and True
# 第二步：判断本次操作取悦于谁？由于前面的是True，所以本次逻辑判断取决于后面的值。
# 所以，后面的只等于多少最终结果就是多少。 v2 = "alex"
v3 = "" and "alex"
# 第一步：将and前后的只转换为布尔值 False and True
# 第二步：判断本次操作取悦于谁？由于前面的是False，所以本次逻辑判断取决于前面的值。
# 所以，前面的只等于多少最终结果就是多少。 v2 = ""
v4 = 1 or 8
# 第一步：将and前后的只转换为布尔值 True or True
# 第二步：判断本次操作取悦于谁？由于前面的是True，所以本次逻辑判断取决于前面的值。
# v4 = 1
v5 = 0 or 8
# 第一步：将and前后的只转换为布尔值 False or True
# 第二步：判断本次操作取悦于谁？由于前面的是False，所以本次逻辑判断取决于后面的值。
# v5 = 8
空值
空值是python的一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
print(bool(None))#False
print(None==0)#False
在一定程度上可以帮助我们去节省内存。例如：
v1 = None
v2 = None
..
v1 = [11,22,33,44]
v2 = [111,22,43]
在上面这个例子中，v1和v2指向的只有None一块空间，之后重新给v1、v1赋值，于是就浪费了None一块空间。
而在下面这个例子中，v1和v2指向两块空间，之后重新给v1、v1赋值，于是就浪费了两块空间。
v3 = []
v4 = []
...
v3 = [11,22,33,44]
v4 = [111,22,43]
注意：暂不要考虑Python内部的缓存和驻留机制。
运算符的优先级和结合性
只有x**y是从右向左结合的
比如
print(-2**3)#**运算优先级高于负号
print(2**3**2)#从右向左
布尔量与数字做运算时，True为1，False为0
print(2+True-False)#3
列表类型
列表运算规则和比较大小同字符串
列表的元素也可以是表达式
a=3
b=45
lst=[a+4.5,b*3]
print(lst)#[7.5,135]
5.内置和转换函数
类型转换函数
Python提供了多种内置函数来执行类型转换，这些函数可以将一个对象从一种类型转换为另一种类型。以下是一些常用的类型转换函数：
int(x): 将对象
x转换为整数类型。如果x是一个浮点数，小数部分将被丢弃。int_value = int(10.6) # 结果为 10 print(int())#不传参时是0还有，int可以把字符串转化成数字
print(int("02"))#输出2 print(int(" 35 "))#输出35有时需要转两次的会转化不了
print(int(" 3 5 "))#输出ValueError: invalid literal for int() with base 10: ' 3 5 ' print(int("2.4"))#输出ValueError: invalid literal for int() with base 10: '2.4'int还可以带一个参数表示进制，如"8"表示字符串的进制是八
print(int("35"，8))#输出29float(x): 将对象
x转换为浮点数类型。#不传参时返回0.0 float_value = float("3.14") # 结果为 3.14str(x): 将对象
x转换为字符串类型。str_value = str(100) # 结果为 "100"bool(x): 将对象
x转换为布尔类型。注意，并不是所有的对象都能转换为布尔类型，有些对象需要先转换为整型或浮点型。bool_value = bool(0) # 结果为 False只要bool里的值有空的意思，都输出False
list(x): 将可迭代对象
x转换为列表类型。list_value = list("hello") # 结果为 ['h', 'e', 'l', 'l', 'o']tuple(x): 将可迭代对象
x转换为元组类型。tuple_value = tuple([1, 2, 3]) # 结果为 (1, 2, 3)dict(x): 将可迭代对象
x转换为字典类型。通常需要提供两个参数：一个键的列表和一个值的列表。dict_value = dict(zip(['a', 'b'], [1, 2])) # 结果为 {'a': 1, 'b': 2}set(x): 将可迭代对象
x转换为集合类型。set_value = set([1, 2, 2, 3, 3]) # 结果为 {1, 2, 3}chr(x): 将整数
x转换为对应的Unicode字符。char = chr(65) # 结果为 'A'ord(x): 将单个字符
x转换为其对应的整数值。number = ord('A') # 结果为 65complex(real[, imag]): 创建一个值为
(real, imag)的复数对象。如果只提供一个参数，它将被视为复数的实部，虚部默认为0。complex_number = complex(2, 3) # 结果为 (2+3j) #不传参时默认为0jeval() 函数:
eval()函数用于计算字符串中的有效Python表达式，并返回表达式的值。使用eval()时需要非常小心，因为它会执行字符串中的代码，可能会引起安全问题。
expression = "1 + 2"
result = eval(expression) # 结果为 3
print(result) # 结果为 3
- repr() 函数:
repr()函数返回对象的字符串表示，通常可以用来获得一个对象的可执行代码形式。对于字符串，它返回带有引号的字符串。
s = "Hello, World!"
print(repr(s)) # 输出: 'Hello, World!'
ss="50+5*10"
print(repr(ss))#输出"100",注意这里是字符串形式的，与eval函数不同
- hex() 函数:
hex()函数将整数转换为十六进制字符串。如果输入的是一个负数，它将返回一个前缀为'-0x'的字符串。
num = 255
print(hex(num)) # 输出: '0xff'
- oct() 函数:
oct()函数将整数转换为八进制字符串。和hex()类似，负数会返回一个前缀为'-0o'的字符串。
print(oct(255)) # 输出: '0o377'
- bin() 函数:
bin()函数将整数转换为二进制字符串。对于负数，它返回一个以'-0b'为前缀的字符串。
print(bin(255)) # 输出: '0b11111111'
![[数据集][目标检测]中国象棋检测数据集VOC+YOLO格式300张12类别](https://img-blog.csdnimg.cn/direct/47d27f3b5ca84c6e9a3bc761e6c99e98.png)
![[数据集][目标检测]变电站火灾检测电力场景烟雾明火检测数据集VOC+YOLO格式140张2类别真实场景非PS合成](https://img-blog.csdnimg.cn/direct/d7cb87bec86644359a014885d391ec3e.png)
