一、常量与变量
常量:程序中使用的具体的数、字符。在运行过程中,值无法更改
变量:表示一一个存储单元,其中存储的值可以修改 如: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,可以换成其他字符串。
python
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()可以转换成整数
python
a = input("请进行输入:")
print(a,type(a))
a = int(input("请进行输入:"))
print(a,type(a))
六、选择结构
if语句
python
if condition:
# 在条件满足时执行的代码块
# 可以是一条语句或多条语句,必须相同缩进级别
elif another_condition:
# 如果上一个条件不满足,但是这个条件满足时执行的代码块
# elif子句是可选的,可以有一个或多个
else:
# 如果上面的条件都不满足时执行的代码块
# else子句也是可选的
Python使用缩进来表示代码块的层次结构,因此在if
语句中,每个代码块都必须有相同的缩进级别。
在Python中可以在一个if
语句块内部嵌套另一个if
语句:
python
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 循环中,以便迭代一系列数字。
python
range(start, stop, step)
start
:可选参数。序列的起始值,默认为0。stop
:必需参数。序列的结束值。该值不包括在序列中。step
:可选参数。序列的步长或增量值,默认为1。
range()
函数返回一个数字序列,从 start
开始,以 step
递增,直到但不包括 stop
。
python
for num in range(10, 0, -1):
print(num)
for num in range(2, 10, 2):
print(num)
python
for 变量 in 序列:
执行代码块
变量
:在每次迭代中,将序列中的元素赋值给变量。序列
:可以是列表、元组、字符串等序列类型,或者是可迭代对象。执行代码块
:在每次迭代中,执行缩进的代码块,这是循环体。
python
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
sum()
函数是 Python 内置函数之一
python
sum(iterable, start=0)
iterable
:必需,一个可迭代的对象,如列表、元组等。start
:可选,默认为0,指定初始值。
sum实现奇数求和
python
n = int(input("请输入整数 n(实现n以内奇数求和):"))
result = sum( range(1,n+1,2))
print(result)
while语句
python
while 条件:
执行代码块
条件
是一个表达式,如果该表达式的值为True
,则继续执行循环体中的代码块;如果为False
,则退出循环,继续执行循环之后的代码。执行代码块
是循环体,包含在while
循环中要重复执行的代码。
python
total = 0
num = 1
while num <= 5:
total += num
num += 1
print("1 到 5 的和为:", total)
辗转相除法
辗转相除法,也称为欧几里德算法,是一种用于计算两个整数的最大公约数(Greatest Common Divisor,GCD)的算法。其基本原理是利用整数除法的性质以及两个数的除余操作。
辗转相除法的步骤如下:
- 将两个整数中较大的数除以较小的数,并计算余数。
- 将较小的数与余数进行同样的操作,直到余数为 0。
- 当余数为 0 时,最后一次的除数就是两个整数的最大公约数。
python
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
通常用于在满足某些条件时强制退出循环,提前结束循环的执行。
python
for i in range(5):
if i == 3:
break
print(i)
continue
关键字:
continue
关键字用于跳过当前循环中的剩余代码,并直接进入下一次循环的迭代。- 当
continue
被执行时,循环中continue
之后的代码不会被执行,而是直接开始下一次循环迭代。 continue
通常用于在某些条件下跳过当前循环迭代,继续下一次迭代。
python
for i in range(5):
if i == 2:
continue
print(i)
七、基础数据结构
7.1 列表
列表的创建
列表使用方括号 []
来表示,其中的元素用逗号 ,
分隔。
python
# 创建一个空列表
my_list = []
# 创建一个包含整数元素的列表
my_list = [1, 2, 3, 4, 5]
# 创建一个包含字符串元素的列表
my_list = ['apple', 'banana', 'cherry']
# 列表中的元素可以是不同类型的
mixed_list = [1, 'apple', True, 3.14]
访问列表元素
python
my_list = ['apple', 'banana', 'cherry']
print(my_list[0]) # 输出:'apple'
print(my_list[1]) # 输出:'banana'
print(my_list[2]) # 输出:'cherry'
列表的切片
python
my_list = [1, 2, 3, 4, 5]
# 获取索引 1 到 3 的子列表(不包括索引 3)
sub_list = my_list[1:3]
print(sub_list) # 输出:[2, 3]
修改列表元素
列表是可变的,可以通过索引来修改其中的元素。
python
my_list = ['apple', 'banana', 'cherry']
my_list[1] = 'orange'
print(my_list) # 输出:['apple', 'orange', 'cherry']
添加元素到列表
可以使用 append()
方法向列表末尾添加新元素,也可以使用 insert()
方法在指定位置插入新元素。
python
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()
方法删除列表中的元素。
python
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)是一种有序、不可变的数据结构,用于存储一组元素。元组使用圆括号 ()
来表示,其中的元素用逗号 ,
分隔。元组与列表相似,但元组是不可变的,即创建后不能修改、添加或删除其中的元素。
元组的创建
元组使用圆括号 ()
来表示,其中的元素用逗号 ,
分隔。
python
# 创建一个空元组
my_tuple = ()
# 创建一个包含整数元素的元组
my_tuple = (1, 2, 3, 4, 5)
# 创建一个包含字符串元素的元组
my_tuple = ('apple', 'banana', 'cherry')
# 元组中的元素可以是不同类型的
mixed_tuple = (1, 'apple', True, 3.14)
访问元组元素
元组中的元素可以通过索引来访问,索引从 0 开始。
python
my_tuple = ('apple', 'banana', 'cherry')
print(my_tuple[0]) # 输出:'apple'
print(my_tuple[1]) # 输出:'banana'
print(my_tuple[2]) # 输出:'cherry'
元组的切片
可以使用切片操作从元组中获取子元组。
python
my_tuple = (1, 2, 3, 4, 5)
# 获取索引 1 到 3 的子元组(不包括索引 3)
sub_tuple = my_tuple[1:3]
print(sub_tuple) # 输出:(2, 3)
元组的不可变性
元组是不可变的,一旦创建后,就不能修改其中的元素。
python
my_tuple = ('apple', 'banana', 'cherry')
# 尝试修改元组中的元素会引发错误
my_tuple[1] = 'orange' # TypeError: 'tuple' object does not support item assignment
7.3 字符串(字符串对象不支持修改)
在Python中,字符串是一种表示文本数据的数据类型,它是一系列Unicode字符的有序序列。字符串可以由单引号('
)、双引号("
)或三引号('''
或 """
)来表示。
字符串的创建
可以使用单引号、双引号或三引号来创建字符串。
python
# 使用单引号创建字符串
single_quoted_string = 'Hello, world!'
# 使用双引号创建字符串
double_quoted_string = "Hello, world!"
# 使用三引号创建多行字符串
multi_line_string = '''This is a
multi-line
string.'''
字符串的访问
字符串中的每个字符都有一个索引,索引从0开始。
python
my_string = "Hello, world!"
print(my_string[0]) # 输出:H
print(my_string[7]) # 输出:w
字符串的切片
可以使用切片操作从字符串中获取子字符串。
python
my_string = "Hello, world!"
print(my_string[1:5]) # 输出:ello
字符串的拼接
可以使用 +
运算符来拼接字符串。
python
string1 = "Hello, "
string2 = "world!"
combined_string = string1 + string2
print(combined_string) # 输出:Hello, world!
字符串的常用方法
Python自带方法:
字符串长度: 使用 len()
方法可以获取字符串的长度。
字符串内部函数:
字符串大小写转换:
upper()
: 将字符串中的所有字符转换为大写。lower()
: 将字符串中的所有字符转换为小写。capitalize()
: 将字符串的第一个字符转换为大写,其他字符转换为小写。
python
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)
: 将字符串中的指定子字符串替换为新的子字符串。
python
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)
: 将可迭代对象中的字符串元素连接成一个字符串,以原字符串为连接符。
python
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()
: 去除字符串右端的空白字符。
python
my_string = " Hello, world! "
print(my_string.strip()) # 输出:Hello, world!
print(my_string.lstrip()) # 输出:Hello, world!
print(my_string.rstrip()) # 输出: Hello, world!
字符串的格式化
可以使用字符串的格式化方法来创建具有动态内容的字符串。
python
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
。
python
my_string = "Hello, world!"
print('H' in my_string) # 输出:True
print('X' in my_string) # 输出:False
使用 not in
检查非成员关系
not in
运算符用于检查某个值是否不存在于序列中,如果不存在,则返回True
,否则返回False
。
python
my_string = "Hello, world!"
print('H' not in my_string) # 输出:False
print('X' not in my_string) # 输出:True
字符串转义字符
\n
:换行符,将光标移动到下一行开头。\t
:制表符,用于在文本中插入水平制表符。- \ : 续行符
\\
:反斜杠,用于插入一个反斜杠字符。\'
:单引号,用于插入一个单引号字符。\"
:双引号,用于插入一个双引号字符。
python
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
python
s = "hello world"
print(list(s)) #['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
一行输入两个整数
python
s = input().split()
a , b = list( map(int , s) )
print( a, b ) #1 2
一行输入多个整数
python
s = input().split()
a = list(map(int , s))
print(a)
修改字符串的常用方法
使用切片替换部分内容:
python
s = "hello, world"
s = s[:5] + "Python" # 将 "hello" 替换为 "Python"
print(s) # 输出: "Python, world"
使用字符串的 replace()
方法:
python
s = "hello, world"
s = s.replace("hello", "Python")
print(s) # 输出: "Python, world"
使用列表操作,然后使用字符串的 join()
方法
python
s = "hello, world"
s_list = list(s)
s_list[0] = 'P' # 替换第一个字符
s = ''.join(s_list)
print(s) # 输出: "Pello, world"
使用字符串的格式化方法:
python
s = "hello, world"
s = "{} {}".format("Python", s.split(" ")[1])
print(s) # 输出: "Python, world"
format 格式化
python
formatted_string = "Some text with {} and {}".format(value1, value2)
python
formatted_string = "Some text with {1} and {0}".format(value1, value2)
python
pi = 3.141592653589793
formatted_pi = "Value of pi: {:.2f}".format(pi) # 控制小数点后保留两位
print(formatted_pi) # Output: Value of pi: 3.14
python
'''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的类型没有限制
python
#创建了一个空字典
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}
'''
扩展: 不定长参数(位置参数和关键字参数)
python
def func(*args):
print(args)
func(1,2,3,4)
python
def func( a, *args ):
print( args )
func( 1, 2, 3, 4 )
python
def func( *args, a ):
print( args )
func( 1, 2, 3, a = 4 )
python
def func( a, **args ): #参数以字典形式传输,双星号不定长放到关键字参数后
print( args )
func( a = 1, b = 2, c = 3, d = 4 )
创建字典的六种方式
① 直接在空字典 {} 里面写键值对
python
a = {'name': 'Tom', 'age': 28}
print(a)
② 定义一个空字典,再往里面添加键值对
python
a = {} # a = dict()
a['name'] = 'Tom'
a['age'] = 28
print(a)
③ 把键作为关键字传入
python
a = dict(name="Tom", age=28)
print(a)
④ 可迭代对象方式来构造字典
python
a = dict([("name", "Tom"), ("age", 28)]) # 这里用元组/列表/集合都是可以的
print(a)
⑤ 通过 zip() 把对应元素打包成元组,类似于上一种方法
python
a = dict(zip(["name", "age"], ["Tom", 28]))
print(a)
⑥ 利用类方法 fromkeys() 创建
python
d = my_dict( name = 'Tony', age = 28, height = 188 )
print( d )
dict(**kwarg) / dict(mapping) / dict(iterable)
用于创建一个字典并返回
python
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)])) # 可迭代对象方式来构造字典
python
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 个元素
- 当所输入可迭代对象中最短的一个被耗尽时,迭代器将停止迭代
- 不带参数时,它将返回一个空迭代器
- 当只有一个可迭代对象参数时,它将返回一个单元组的迭代器
python
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元素的
利用集合特性进行 去重 和 关系测试
python
#把一个列表变成集合,就会自动去掉重复的元素
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(注意变量类型)
python
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要求参数为集合
python
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要求参数为集合
python
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|...要求参数为集合
python
s1 = {'a', 'c', 'f', 1, 2, 3}
print(s1.union('acf123', {4:5, 6:7}))
intersection(*others)
●others: Iterable
●返回一个新集合,其中包含原集合以及others指定的所有集合中共有的元素(即交集)
●对应的运算符版本set & other & ...要求参数为集合
python
s1 = {'a', 'c', 'f', 1, 2, 3}
print(s1.intersection('acf123'))
difference(*others)
●others: Iterable
●返回一个新集合,其中包含原集合中在others指定的其他集合中不存在的元素(即差集)
●对应的运算符版本set - other- ... 要求参数为集合
python
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):集合元素个数
python
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()
●从集合中移除所有元素
python
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) )
输入若干数字,将所有元素去重后输出数字:
python
s = list (map(int, input().split()))
a = set (s)
print (a)
python
'''
维护-一个数据结构管理表格,初始-个n行m列的表格,元素均为
空,需要完成若干次操作:
set x y value:将表格第x行第y列设置为value
findxy:查询第x行第y列对应的值
del x y:删除第x行第y列的值
Many value:查找value 是否在表格中,如果在表格中则出现次
数为多少
'''