一、常量与变量
常量:程序中使用的具体的数、字符。在运行过程中，值无法更改
变量:表示一一个存储单元，其中存储的值可以修改 如：a=5,b=6
变量命名:
1、只能包含字母、数字、下划线
2、只能以字母、下划线开头
3、不要使用关键字作为变量名称
二、基础数据类型
整数: int
浮点数: float （存在误差）
字符串: str
布尔: bool
获取变量类型: type函数
强制类型转换 :
整数: int()
浮点数: float ()
字符串: str()
布尔: bool()
三、 数据类型转换
int转float:直接转换 7 -> 7.0
float转int:舍弃小数
int转bool:非0: True、 0: False
bool转int: False: 0、 True: 1
转str:直接转换
四、常用运算符
算术运算符:+、-、*、/、//(整除)、%(求余)、**(幂)
关系运算符:>、<、==、!=、>=、<=
赋值运算符: =、+=、-=、
*=、/=、%=、//=、**=
逻辑运算符: and、 or、 not
成员运算符: in、 not in
身份运算符: is、 is not
五、输入输出 函数
print()用于打印输出，是最常见的一个函数。
语法: print(*objects, sep=' ', end="\n', file=sys.stdout, flush=False)
参数说明:
1、objects:表示输出一个或者多个对象。输出多个对象需要用sep分隔。
2、sep:输出多个对象时使用sep分隔，默认值是一一个空格。
3、end: 输出结束以end结尾，默认值是换行符\n,可以换成其他字符串。
print(1)
print("Hello World")
a= 1
b= 'runoob '
print(a,b)
print("aa","bbb" )
print("aa" ,"bbb")
print("www",lanqiao, "cn",sep="+") #设置间隔符
input()输入输出函数
语法: input([prompt])
参数说明: prompt: 提示信息
输入的变量均为str字符串类型
int()可以转换成整数
a = input("请进行输入：")
print(a,type(a))a = int(input("请进行输入："))
print(a,type(a))
六、选择结构
if语句
if condition:# 在条件满足时执行的代码块# 可以是一条语句或多条语句，必须相同缩进级别
elif another_condition:# 如果上一个条件不满足，但是这个条件满足时执行的代码块# elif子句是可选的，可以有一个或多个
else:# 如果上面的条件都不满足时执行的代码块# else子句也是可选的
Python使用缩进来表示代码块的层次结构，因此在if语句中，每个代码块都必须有相同的缩进级别。
在Python中可以在一个if语句块内部嵌套另一个if语句：
x = 10
y = 5if x > 5:print("x is greater than 5")if y > 2:print("y is also greater than 2")else:print("y is not greater than 2")
else:print("x is not greater than 5")
for语句
range() 函数用于生成一系列数字，在 Python 中常用于 for 循环中，以便迭代一系列数字。
range(start, stop, step)
start：可选参数。序列的起始值，默认为0。stop：必需参数。序列的结束值。该值不包括在序列中。step：可选参数。序列的步长或增量值，默认为1。
range() 函数返回一个数字序列，从 start 开始，以 step 递增，直到但不包括 stop。
for num in range(10, 0, -1):print(num)
for num in range(2, 10, 2):print(num)
for 变量 in 序列:执行代码块
变量：在每次迭代中，将序列中的元素赋值给变量。序列：可以是列表、元组、字符串等序列类型，或者是可迭代对象。执行代码块：在每次迭代中，执行缩进的代码块，这是循环体。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:print(fruit)sum() 函数是 Python 内置函数之一
sum(iterable, start=0)
iterable：必需，一个可迭代的对象，如列表、元组等。start：可选，默认为0，指定初始值。
sum实现奇数求和
n = int(input("请输入整数 n(实现n以内奇数求和):"))
result = sum( range(1,n+1,2))
print(result)
while语句
while 条件:执行代码块
条件是一个表达式，如果该表达式的值为True，则继续执行循环体中的代码块；如果为False，则退出循环，继续执行循环之后的代码。执行代码块是循环体，包含在while循环中要重复执行的代码。
total = 0
num = 1
while num <= 5:total += numnum += 1
print("1 到 5 的和为:", total)
辗转相除法
辗转相除法，也称为欧几里德算法，是一种用于计算两个整数的最大公约数（Greatest Common Divisor，GCD）的算法。其基本原理是利用整数除法的性质以及两个数的除余操作。
辗转相除法的步骤如下：
- 将两个整数中较大的数除以较小的数，并计算余数。
- 将较小的数与余数进行同样的操作，直到余数为 0。
- 当余数为 0 时，最后一次的除数就是两个整数的最大公约数。
def gcd(a, b):while b != 0:a, b = b, a % breturn a# 例子
num1 = 48
num2 = 18
print("48 和 18 的最大公约数是:", gcd(num1, num2))
初始时，a 为较大的数，b 为较小的数
break 和 continue
break 和 continue 是 Python 中用于控制循环的两个关键字。
break 关键字：
break关键字用于跳出当前所在的最内层循环（for 或 while 循环），并继续执行循环之后的代码。- 当
break被执行时，循环立即终止，不再执行循环体中未执行的代码，也不会继续下一次循环。 break通常用于在满足某些条件时强制退出循环，提前结束循环的执行。-
for i in range(5):if i == 3:breakprint(i)
continue 关键字：
continue关键字用于跳过当前循环中的剩余代码，并直接进入下一次循环的迭代。- 当
continue被执行时，循环中continue之后的代码不会被执行，而是直接开始下一次循环迭代。 continue通常用于在某些条件下跳过当前循环迭代，继续下一次迭代。-
for i in range(5):if i == 2:continueprint(i)
七、基础数据结构
7.1 列表
列表的创建
列表使用方括号 [] 来表示，其中的元素用逗号 , 分隔。
# 创建一个空列表
my_list = []# 创建一个包含整数元素的列表
my_list = [1, 2, 3, 4, 5]# 创建一个包含字符串元素的列表
my_list = ['apple', 'banana', 'cherry']# 列表中的元素可以是不同类型的
mixed_list = [1, 'apple', True, 3.14]
访问列表元素
my_list = ['apple', 'banana', 'cherry']print(my_list[0]) # 输出：'apple'
print(my_list[1]) # 输出：'banana'
print(my_list[2]) # 输出：'cherry'
列表的切片
my_list = [1, 2, 3, 4, 5]# 获取索引 1 到 3 的子列表（不包括索引 3）
sub_list = my_list[1:3]
print(sub_list) # 输出：[2, 3]
修改列表元素
列表是可变的，可以通过索引来修改其中的元素。
my_list = ['apple', 'banana', 'cherry']my_list[1] = 'orange'
print(my_list) # 输出：['apple', 'orange', 'cherry']
添加元素到列表
可以使用 append() 方法向列表末尾添加新元素，也可以使用 insert() 方法在指定位置插入新元素。
my_list = ['apple', 'banana', 'cherry']my_list.append('orange')
print(my_list) # 输出：['apple', 'banana', 'cherry', 'orange']my_list.insert(1, 'grape')
print(my_list) # 输出：['apple', 'grape', 'banana', 'cherry', 'orange']
删除列表元素
可以使用 del 关键字、remove() 方法或 pop() 方法删除列表中的元素。
my_list = ['apple', 'banana', 'cherry']del my_list[1]
print(my_list) # 输出：['apple', 'cherry']my_list.remove('cherry')
print(my_list) # 输出：['apple']deleted_element = my_list.pop(0)
print(deleted_element) # 输出：'apple'
print(my_list) # 输出：[]
7.2 元组
在 Python 中，元组（Tuple）是一种有序、不可变的数据结构，用于存储一组元素。元组使用圆括号 () 来表示，其中的元素用逗号 , 分隔。元组与列表相似，但元组是不可变的，即创建后不能修改、添加或删除其中的元素。
元组的创建
元组使用圆括号 () 来表示，其中的元素用逗号 , 分隔。
# 创建一个空元组
my_tuple = ()# 创建一个包含整数元素的元组
my_tuple = (1, 2, 3, 4, 5)# 创建一个包含字符串元素的元组
my_tuple = ('apple', 'banana', 'cherry')# 元组中的元素可以是不同类型的
mixed_tuple = (1, 'apple', True, 3.14)
访问元组元素
元组中的元素可以通过索引来访问，索引从 0 开始。
my_tuple = ('apple', 'banana', 'cherry')print(my_tuple[0]) # 输出：'apple'
print(my_tuple[1]) # 输出：'banana'
print(my_tuple[2]) # 输出：'cherry'
元组的切片
可以使用切片操作从元组中获取子元组。
my_tuple = (1, 2, 3, 4, 5)# 获取索引 1 到 3 的子元组（不包括索引 3）
sub_tuple = my_tuple[1:3]
print(sub_tuple) # 输出：(2, 3)
元组的不可变性
元组是不可变的，一旦创建后，就不能修改其中的元素。
my_tuple = ('apple', 'banana', 'cherry')# 尝试修改元组中的元素会引发错误
my_tuple[1] = 'orange' # TypeError: 'tuple' object does not support item assignment
7.3 字符串(字符串对象不支持修改)
在Python中，字符串是一种表示文本数据的数据类型，它是一系列Unicode字符的有序序列。字符串可以由单引号（'）、双引号（"）或三引号（''' 或 """）来表示。
字符串的创建
可以使用单引号、双引号或三引号来创建字符串。
# 使用单引号创建字符串
single_quoted_string = 'Hello, world!'# 使用双引号创建字符串
double_quoted_string = "Hello, world!"# 使用三引号创建多行字符串
multi_line_string = '''This is a
multi-line
string.'''
字符串的访问
字符串中的每个字符都有一个索引，索引从0开始。
my_string = "Hello, world!"print(my_string[0]) # 输出：H
print(my_string[7]) # 输出：w
字符串的切片
可以使用切片操作从字符串中获取子字符串。
my_string = "Hello, world!"print(my_string[1:5]) # 输出：ello
字符串的拼接
可以使用 + 运算符来拼接字符串。
string1 = "Hello, "
string2 = "world!"combined_string = string1 + string2
print(combined_string) # 输出：Hello, world!
字符串的常用方法
Python自带方法：
字符串长度： 使用 len() 方法可以获取字符串的长度。
字符串内部函数：
字符串大小写转换：
upper(): 将字符串中的所有字符转换为大写。lower(): 将字符串中的所有字符转换为小写。capitalize(): 将字符串的第一个字符转换为大写，其他字符转换为小写。
my_string = "Hello, World!"print(my_string.upper()) # 输出：HELLO, WORLD!
print(my_string.lower()) # 输出：hello, world!
print(my_string.capitalize()) # 输出：Hello, world!
字符串查找和替换：
find(substring): 查找子字符串在原字符串中的位置，如果找到返回索引值，否则返回 -1。replace(old, new): 将字符串中的指定子字符串替换为新的子字符串。
my_string = "Hello, world!"print(my_string.find("world")) # 输出：7
print(my_string.find("Python")) # 输出：-1new_string = my_string.replace("world", "Python")
print(new_string) # 输出：Hello, Python!
字符串分割和连接：
split(delimiter): 将字符串根据指定的分隔符拆分成多个子字符串，并返回一个列表。join(iterable): 将可迭代对象中的字符串元素连接成一个字符串，以原字符串为连接符。
my_string = "apple,banana,orange"split_string = my_string.split(",")
print(split_string) # 输出：['apple', 'banana', 'orange']my_list = ['apple', 'banana', 'orange']
joined_string = ",".join(my_list)
print(joined_string) # 输出：apple,banana,orange
字符串去除空白：
strip(): 去除字符串两端的空白字符。lstrip(): 去除字符串左端的空白字符。rstrip(): 去除字符串右端的空白字符。
my_string = " Hello, world! "print(my_string.strip()) # 输出：Hello, world!
print(my_string.lstrip()) # 输出：Hello, world!
print(my_string.rstrip()) # 输出： Hello, world!
字符串的格式化
可以使用字符串的格式化方法来创建具有动态内容的字符串。
name = "Alice"
age = 30formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string) # 输出：My name is Alice and I am 30 years old.
使用 in 检查成员关系
in运算符用于检查某个值是否存在于序列中，如果存在，则返回True，否则返回False。
my_string = "Hello, world!"print('H' in my_string) # 输出：True
print('X' in my_string) # 输出：False
使用 not in 检查非成员关系
not in运算符用于检查某个值是否不存在于序列中，如果不存在，则返回True，否则返回False。
my_string = "Hello, world!"print('H' not in my_string) # 输出：False
print('X' not in my_string) # 输出：True
字符串转义字符
\n：换行符，将光标移动到下一行开头。\t：制表符，用于在文本中插入水平制表符。- \ : 续行符
\\：反斜杠，用于插入一个反斜杠字符。\'：单引号，用于插入一个单引号字符。\"：双引号，用于插入一个双引号字符。
print("Hello\nWorld!")
# 输出：
# Hello
# World!print("This is a\ttabbed\ttext.")
# 输出：This is a tabbed text.print("C:\\path\\to\\file.txt")
# 输出：C:\path\to\file.txtprint('He\'s a good boy.')
# 输出：He's a good boy.print("She said, \"Hello!\"")
# 输出：She said, "Hello!"
字符串强制转换为List
s = "hello world"
print(list(s)) #['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']一行输入两个整数
s = input().split()a , b = list( map(int , s) )
print( a, b ) #1 2一行输入多个整数
s = input().split()a = list(map(int , s))
print(a)修改字符串的常用方法
使用切片替换部分内容：
s = "hello, world"
s = s[:5] + "Python" # 将 "hello" 替换为 "Python"
print(s) # 输出： "Python, world"
使用字符串的 replace() 方法：
s = "hello, world"
s = s.replace("hello", "Python")
print(s) # 输出： "Python, world"
使用列表操作，然后使用字符串的 join() 方法
s = "hello, world"
s_list = list(s)
s_list[0] = 'P' # 替换第一个字符
s = ''.join(s_list)
print(s) # 输出： "Pello, world"
使用字符串的格式化方法：
s = "hello, world"
s = "{} {}".format("Python", s.split(" ")[1])
print(s) # 输出： "Python, world"
format 格式化
formatted_string = "Some text with {} and {}".format(value1, value2)
formatted_string = "Some text with {1} and {0}".format(value1, value2)
pi = 3.141592653589793
formatted_pi = "Value of pi: {:.2f}".format(pi) # 控制小数点后保留两位
print(formatted_pi) # Output: Value of pi: 3.14
'''python实现下列需求开放式编程:对于给定的一.大段不规范的英文文本，对其进行排版:单词和单词之间有一个空格句子中的符号和前一个单词之间没有空格句子之间一一个空格分隔句子首字母大写，其他字母小写按照换行符划分段落,输出时每段空两个空格输出时每行80个字符，对于单个单词-行超过80个单词，直接下一-行输出该单词
'''
def format_text(text):formatted_text = ""paragraphs = text.split('\n\n') # 根据换行符划分段落for paragraph in paragraphs:lines = []words = paragraph.split()line_length = 0line = ""for word in words:if line_length + len(word) + 1 <= 80: # 考虑空格的长度if line_length == 0:line += word.capitalize()else:line += " " + word.lower()line_length += len(word) + 1else:lines.append(line)line = word.capitalize()line_length = len(word)lines.append(line)formatted_paragraph = " ".join(lines) # 每段空两个空格formatted_text += formatted_paragraph + "\n\n"return formatted_text# 示例文本
unformatted_text = """
this is a test. i am writing a python program to format text.
it's a simple program, but it should work well.
let's see how it goes.
"""formatted_text = format_text(unformatted_text)
print(formatted_text)
7.4 字典
键: key, 值: value, 通过key来找value, key必须唯一， 因此同一个key只能对应着一个value
- Python中用{}表示字典，可以使用{}创建一个字典
- 字典中的key和value之间用冒号:分隔，元素之间用逗号，分隔。
- 字典的key只能为数字、字符串、元组，大多数情况使用字符串作为key
- 如果键重复，那么重复键对应的值后面会把前面的值覆盖掉，但是位
置还是原来的位置 - value的类型没有限制
#创建了一个空字典
a={}
print("type (a) = ", type (a) )
print("a = ", a)
#创建字典
a = {'a':123, 'b' :456, 0:789}
print("type (a) = ", type (a))
print("a = ", a)'''
type (a) = <class 'dict'>
a = {}
type (a) = <class 'dict'>
a = {'a': 123, 'b': 456, 0: 789}
'''扩展： 不定长参数(位置参数和关键字参数)
def func(*args):print(args)func(1,2,3,4)def func( a, *args ):print( args )func( 1, 2, 3, 4 )def func( *args, a ):print( args )func( 1, 2, 3, a = 4 )def func( a, **args ): #参数以字典形式传输，双星号不定长放到关键字参数后print( args )func( a = 1, b = 2, c = 3, d = 4 )创建字典的六种方式
① 直接在空字典 {} 里面写键值对
a = {'name': 'Tom', 'age': 28}
print(a)
② 定义一个空字典，再往里面添加键值对
a = {} # a = dict()
a['name'] = 'Tom'
a['age'] = 28
print(a)
③ 把键作为关键字传入
a = dict(name="Tom", age=28)
print(a)
④ 可迭代对象方式来构造字典
a = dict([("name", "Tom"), ("age", 28)]) # 这里用元组/列表/集合都是可以的
print(a)
⑤ 通过 zip() 把对应元素打包成元组，类似于上一种方法
a = dict(zip(["name", "age"], ["Tom", 28]))
print(a)⑥ 利用类方法 fromkeys() 创建
d = my_dict( name = 'Tony', age = 28, height = 188 )
print( d )
dict(**kwarg) / dict(mapping) / dict(iterable)
用于创建一个字典并返回
print(dict(one=1, two=2, three=3)) # 传入关键字来构造字典
print(dict(zip(["one", "two", "three"], [1, 2, 3]))) #映射函数方式来构造字典
print(dict([("one", 1), ("two", 2), ("three", 3)])) # 可迭代对象方式来构造字典def my_dict( **kwargs ):return kwargsd = my_dict( name = 'Tony', age = 28, height = 188 )
print( d )d = dict( name = 'Tony', age = 28, height = 188 )
print( d )
zip(*iterables)
- 返回一个元组的迭代器，其中的第 i 个元组包含来自每个可迭代对象
- 的第 i 个元素
- 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代
- 不带参数时，它将返回一个空迭代器
- 当只有一个可迭代对象参数时，它将返回一个单元组的迭代器
result1 = zip( "abcd", "efgh" )
print(list( result1 ))result2 = zip( "abcd", "efg" )
print(list( result2 ))result3 = zip( )
print(list( result3 ))result4 = zip( "abcd" )
print(list( result4 ))字典的对象方法
7.5 集合
Python中的集合和数学中的集合概念一样， 存储不重复的元素。
集合中的元素都是唯一的，互不相同。
集合中只能存储不可变的数据:数字、字符串、元组。
Python用{}表示集合，其中的元素用逗号分隔。
Python集合可以改变，不是序列，是无序的。
创建集合的方式:
- {元素1,元素2,元素3...}:把大括号中的所有元素构造成一个集合，如果有重复元素，只保留1个
- {}: 这是空字典，不是空集合
- set(x): 把x转换成集合，x一般为列表、元组等
- set(): 空集
set([iterable])
●返回一个新的set对象，其元素来自于iterable， 如果未指定
iterable，则将返回空集合
frozenset([iterable])
●返回一个新的frozenset对象，即不可变的集合，其元素来自于
iterable，如果未指定参数，则返回冻结的空集合
●作用: set中的元素必须是不可变类型的，而frozenset是可以作为set元素的
利用集合特性进行 去重 和 关系测试
#把一个列表变成集合，就会自动去掉重复的元素
li=[1, 2, 5, 7, 7, 4, 5]
a = set( li )
print(a)
#测试多组集合数据之间的交集、差集、并集等关系
a =set("abdefga")
b = set("abc")
c = set("aef")
print(c <= a)
#判断c是否是a的子集
print(a - b)
#返回a和b的差集
print(a| b)
#返回a和b的并集
print(a & b)
#返回a和b的交集
print(a ^ b)
#返回a和b中不同时存在的元素(对称差)
print(a | b| c)
集合对象的方法 set frozenset对象都可用
isdisjoint(other)
●other: Iterable
●如果集合中没有与other共有的元素则返回True（注意变量类型）
str1 = "145"
list1 = [1, 4]
dic1 = {1:"1"}
set1 = {"1", 2, 3}
print(set1. isdisjoint(str1) )
#False
print(set1. isdisjoint(list1))
#True
print(set1. isdisjoint(dic1) )
#True
fset = frozenset(["1", 2, 3])
print(fset. isdisjoint(str1))
print(fset. isdisjoint(list1) )
print(fset. isdisjoint(dic1) )
issubset(other)
●other: Iterable
●如果集合中的每个元素都在other之中，则返回True .
●对应的运算符版本set <= other要求参数为集合
str1 = "132"
list1 = [1, 4, "1", "2"]
dic1 = {1:"1", 2:"2"}
set1 = {"1", "2"}
print(set1. issubset(str1) )
#True
print(set1. issubset(list1) )
#True
print(set1. issubset(dic1) )
# False
fset = frozenset(["1", "2"])
print(fset. issubset(str1) )
print(fset. issubset(list1) )
print(fset. issubset(dic1) )
issuperset(other)
●other: Iterable
●如果other中的每个元素都在集合之中，则返回True
●对应的运算符版本set >= other要求参数为集合
str1 = "12"
list1 = [1, "2"]
dic1 = {1:"1", 2:"2"}
set1 = {"1", "2", 1, 3}
print( set1.issuperset(str1) )
#True
print(set1. issuperset(list1) )
#True
print(set1. issuperset(dic1) )
# False
fset = frozenset(["1", "2", 1, 3])
print(fset. issuperset(str1) )
print(fset. issuperset(list1))
print(fset. issuperset(dic1) )
union(*others)
●others: Iterable
●返回一个新集合，其中包含来自原集合以及others指定的所有集合中的元素(即并集)
●对应的运算符版本set|other|...要求参数为集合
s1 = {'a', 'c', 'f', 1, 2, 3}
print(s1.union('acf123', {4:5, 6:7})) intersection(*others)
●others: Iterable
●返回一个新集合，其中包含原集合以及others指定的所有集合中共有的元素(即交集)
●对应的运算符版本set & other & ...要求参数为集合
s1 = {'a', 'c', 'f', 1, 2, 3}
print(s1.intersection('acf123')) difference(*others)
●others: Iterable
●返回一个新集合，其中包含原集合中在others指定的其他集合中不存在的元素(即差集)
●对应的运算符版本set - other- ... 要求参数为集合
str1 = "12"
list1 = [1, "2"]
dic1 = {"1":1, "2":2}
set1 ={"1", "2", 1, 3}
print(set1.difference(str1, list1, dic1) )
fset = frozenset(["1", "2", 1, 3] )
print( fset. difference(str1, list1, dic1))
symmetric_ difference(other)
●other: Iterable
●返回一个新集合，其中的元素或属于原集合或属于other指定的其他集合，但不能同时属于两者(即对称差)
●对应的运算符版本set^ other要求参数为集合
集合遍历操作：
- 与遍历list一样， for x in a，其中a是set, x是循环变量
- s.clear():清空集合
- X in S:
- 判断是否存在
- len(s):集合元素个数
s = {1,2 ,3,4}
for x in s:print (x)
print ( sum(s), max(s) , min(s) )集合对象的方法 仅set 对象都可用
set.update(*others)
●others: Iterable
●更新集合，添加来自others中的所有元素
set.intersection_ _update(*others)
●others: Iterable
●更新集合，只保留其中在所有others中也存在的元素.
set.difference_ update(*others)
●others: Iterable
●更新集合，移除其中也存在于任意一个others中的元素
set.symmetric_ difference_ update(other)
●other: Iterable
●更新集合，只保留存在于一-方而非共同存在的元素
set. add(elem)
●将元素elem添加到集合中。如果元素已经存在，则没有影响
set.remove(elem)
●从集合中移除元素elem。 如果elem不存在于集合中则会引发KeyError
set.discard(elem)
●从集合中移除元素elem。如果elem不存在于集合中则不做任何操作
set.pop()
●从集合中移除并返回任意一个元素。如果集合为空则会引发KeyError
set.clear()
●从集合中移除所有元素
s = {1, 2, 3}
t = {2, 3, 4}print ( "交集：", s.intersection(t) )
print ( "并集：", s.union(t) )
print ("差集：", s.difference(t) )
print ("对称集：", s.symmetric_difference(t) )输入若干数字，将所有元素去重后输出数字：
s = list (map(int, input().split()))
a = set (s)
print (a)'''
维护-一个数据结构管理表格,初始-个n行m列的表格，元素均为
空，需要完成若干次操作:set x y value:将表格第x行第y列设置为valuefindxy:查询第x行第y列对应的值del x y:删除第x行第y列的值Many value:查找value 是否在表格中，如果在表格中则出现次
数为多少
'''
