【从Python基础到深度学习】9.Python 语法基础

一、常量与变量

常量:程序中使用的具体的数、字符。在运行过程中，值无法更改

变量:表示一一个存储单元，其中存储的值可以修改 如：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 = 5

if 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 += num
    num += 1
print("1 到 5 的和为:", total)

辗转相除法

辗转相除法，也称为欧几里德算法，是一种用于计算两个整数的最大公约数（Greatest Common Divisor，GCD）的算法。其基本原理是利用整数除法的性质以及两个数的除余操作。

辗转相除法的步骤如下：

1. 将两个整数中较大的数除以较小的数，并计算余数。
2. 将较小的数与余数进行同样的操作，直到余数为 0。
3. 当余数为 0 时，最后一次的除数就是两个整数的最大公约数。

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return 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:
        break
    print(i)

continue 关键字：

• continue 关键字用于跳过当前循环中的剩余代码，并直接进入下一次循环的迭代。
• 当 continue 被执行时，循环中 continue 之后的代码不会被执行，而是直接开始下一次循环迭代。
• continue 通常用于在某些条件下跳过当前循环迭代，继续下一次迭代。

for i in range(5):
    if i == 2:
        continue
    print(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"))         # 输出：-1

new_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 = 30

formatted_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.txt

print('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 = 0
        line = ""
        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) + 1
            else:
                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 kwargs

d = 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列设置为value
    findxy:查询第x行第y列对应的值
    del x y:删除第x行第y列的值
    Many value:查找value 是否在表格中，如果在表格中则出现次
数为多少
'''