python 基础总结

数据类型

Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Dictionart(字典)
Set(集合)

可变数据类型和不可变类型：
不可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，对于这种数据类型，就称不可变数据类型。
可变数据类型：当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，对于这种数据类型，就称可变数据类型。
总结：不可变数据类型更改后地址发生改变，可变数据类型更改地址不发生改变

不可变数据（3个）：Number（数字）、String（字符串）、Tuple(元组)
可变数据（3个）：List(列表)、Dictionary(字典)、Set(集合)

Number(数字)

Python3 支持int、float、bool、complex(复数)

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))

del删除对象引用。

var1 =1 
var2 =2 
del var1[,var2[,var3[....,varN]]]
#删除多个
del var1,var2

String（字符串）

Python中的字符串用单引号’或者双引号“括起来，同时使用反斜杠\转义特殊字符。
字符串的截取语法格式如下：

变量[头下标：尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

image.png

加号 + 是字符串的连接符，星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下

#!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

执行以上程序会输出如下结果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

单引号、双引号、三引号用途：

s1='test'
s2="Let's go"
s3='''
作者：[李白]
床前明月光，疑是地上霜。
举头望明月，低头思故乡。
'''
打印结果：
test
Let's go

作者：[李白]
床前明月光，疑是地上霜。
举头望明月，低头思故乡。

注意：

1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。

2、字符串可以用+运算符连接在一起，用*运算符重复。

3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

4、Python中的字符串不能改变。

字符串格式化

#!/usr/bin/python3 
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!

python字符串格式化符号:

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%):

>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2

>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

List(列表)

序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

列表索引
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。

image.png

eg:

#!/usr/bin/python3

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
red
green
blue

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

image.png

增：

#1.append('ele')：在列表后面追加一个元素
list1 = ['a','b']
list1.append('c')#注意这里不要写成list1 = list1.append('c')
print(list1)

#2.extend(listname):在一个列表后面插入另一个列表的元素
list1 = ['a','b']
list2 = ['c','d']
list1.extend(list2)#注意这里不要写成list1 = list1.extend(list2),否则返回的是none
print(list1)

#3.insert(arg1,"arg2"):第一个参数是索引，代表要插入的位置，第二个是要插入的元素
list1 = ['a','b','c','d']
list1.insert(4,'e')#相当于在表尾插入一个元素
print(list1)

#4.用“+”连接两个列表
list1 = ['a','b','c','d','e']
list2 = ['1','2','3']
list1 = list1 + list2
print(list1)

['a', 'b', 'c']
['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e', '1', '2', '3']

删：

#1.list.remove(x):删除指定元素
list= ["nihao","baidu"]
list.remove("baidu")
print(list)

#2.list.pop([i]):删除指定索引的值，i表示索引
   #如果没有参数，就默认删除最后一个元素
list = ["nihao",'baidu','taobao']
list.pop(1)
list.pop()#其实在这里也暗示了是一个栈结构
print(list)

#3.list.clear():删除列表所有项
list = ["nihao",'baidu','taobao']
list.clear()
print(list)

#4.可以使用 del 语句来删除列表的的元素
list = ['Google', 'Runoob', 1997, 2000]
del list[2]
print(list)

执行结果

['nihao']
['nihao']
[]
['Google', 'Runoob', 2000]

remove，pop和del方法的区别：
这三种方法都是list的删除方法，其中remove是针对可变列表的元素进行搜索删除，而pop和del是针对可变列表的下标进行搜索删除。具体区别如下：

remove
remove(item)方法是直接对可变序中的元素进行检索删除，返回的是删除后的列表,不返回删除值（返回None）

>>>list1=[1,3,6,7,8]
>>>print list1.remove(3) #对列表元素进行搜索删除，而不是下表
>>>print list1
None
[1,6,7,8]

pop
pop(index)方法是对可变序列中元素下标进行检索删除，返回删除值

>>>list1=[1,3,6,7,8]
>>>print list1.pop(3),#对列表下表进行检索删除
>>>print list1

7
[1,3,6,8]

del
del(list[index])方法是对可变序列中元素下边进行检索删除，不返回删除值

>>>list1=[1,3,6,7,8]
>>>del list[3]
>>>print list1

[1.3,6,8]

改(更新)：

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
print(list)

结果为：

第三个元素为 :  1997
更新后的第三个元素为 :  2001
['Google', 'Runoob', 2001, 2000]

查

略

Python列表脚本操作符

Python表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

列表函数&方法

函数：

序号	函数	实例	返回值
1	[len(list)]列表元素个数	list1 = ['Google', 'Runoob', 'Taobao'] print (len(list1))	3
2	[max(list)]返回列表元素最大值	list1 = ['Google', 'Runoob', 'Taobao'] print (max(list1))	Taobao
3	[min(list)]返回列表元素最小值	list1 = ['Google', 'Runoob', 'Taobao'] print (min(list1))	Google
4	[list(seq)]将元组转换为列表 seq 为要转换列表的元组或字符串	aTuple = (123, 'Google', 'Runoob', 'Taobao') list1 = list(aTuple) print ("列表元素 : ", list1) str="Hello World" list2=list(str) print ("列表元素 : ", list2)	列表元素 : [123, 'Google', 'Runoob', 'Taobao'] 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

方法：

序号	方法
1	list.append(obj)在列表末尾添加新的对象
2	list.count(obj)统计某个元素在列表中出现的次数
3	list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)将对象插入列表
6	list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)移除列表中某个值的第一个匹配项
8	list.reverse()反向列表中元素
9	list.sort( key=None, reverse=False)对原列表进行排序
10	list.clear()清空列表
11	list.copy()复制列表

Tuple(元组)

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型


>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

Python 表达式	结果	描述
tup[1]	'Runoob'	读取第二个元素
tup[-2]	'Weibo'	反向读取，读取倒数第二个元素
tup[1:]	('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')	截取元素，从第二个开始后的所有元素。
tup[1:4]	('Runoob', 'Taobao', 'Wiki')	截取元素，从第二个开始到第四个元素（索引为 3）。

增/删/改：

元组tuple是不可变类型对象，不支持对直接元组进行增删改操作；
但是当元组内部的元素是可变类型时，可以对里面的元素进行增删改操作

tup = ([1,2],"m")
tup[0].append(3)
tup[0][0] =100
print(tup)   # 返回([100, 2, 3], 'm')

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python3
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

对元组增删操作，只能直接初始化，或者直接从内存中删除；

查

#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>>
2	max(tuple)返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>>
3	min(tuple) 返回元组中元素最小值.	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>>
4	tuple(iterable)将可迭代系列转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

Dictionart(字典)

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
一个简单的字典实例：

dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

增

1、直接增加有则改之，无则增加

dic={'name':'太白','age':18}
dic['sex']='男'
print(dic) #{'name': '太白', 'age': 18, 'sex': '男'}
dic['age']=23  #改
print(dic) #{'name': '太白', 'age': 23}

2、setdefault 有则不变，无则增加

dic.setdefault('hobby')
print(dic) #{'name': '太白', 'age': 18, 'hobby': None}
②
dic.setdefault('hobby','球类运动')
print(dic) #{'name': '太白', 'age': 18, 'hobby': '球类运动'}
③
dic.setdefault('age',45)
print(dic)  #{'name': '太白', 'age': 18}
dic={'name':'太白','age':18}

删

1）pop 按照键去删除键值对，有返回值 ***
设置第二个参数则无论字典中有无此键都不会报错

ret=dic.pop('age')
print(ret)  #18
print(dic) #{'name': '太白'}
1.1)
ret=dic.pop('hobby','没有此键')
print(ret) #没有此键
print(dic)  #{'name': '太白', 'age': 18}

2)clear 清空 **

dic.clear()
print(dic) #{}

3)del ***

del dic['age']
print(dic) #{'name': '太白'}
del dic['age1']
print(dic)  #没有此键，则报错

改

dic={'name':'太白','age':18}
dic['name']='alex'
print(dic)  #{'name': 'alex', 'age': 18}

查

dic={'name':'太白','age':18,'hobby_list':['直男','钢管','开车']}
(1)print(dic['hobby_list']) #['直男', '钢管', '开车']
2)get  ***  推荐使用
l1=dic.get('hobby_list')
print(l1) #['直男', '钢管', '开车']
l1=dic.get('hobby_list1')
print(l1) #None
l1=dic.get('hobby_list2','没此键')
print(l1)  #没此键

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict)计算字典元素个数，即键的总数。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3
2	str(dict)输出字典，可以打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict)

Python字典包含了以下内置方法：

序号	函数及描述
1	radiansdict.clear()删除字典内所有元素
2	radiansdict.copy()返回一个字典的浅复制
3	radiansdict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	radiansdict.items()以列表返回一个视图对象
7	radiansdict.keys()返回一个视图对象
8	radiansdict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
10	radiansdict.values()返回一个视图对象
11	pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
12	popitem()随机返回并删除字典中的最后一对键和值。

三个特殊的 key() values() items()

1)
dic={'name':'太白','age':18,'hobby_list':['直男','钢管','开车']}
print(dic.keys(),type(dic.keys()))#dict_keys(['name', 'age', 'hobby_list']) 
2)可以转化成列表
print(list(dic.keys())) #['name', 'age', 'hobby_list']
for key in dic.keys():
    print(key)
>>>
name
age
hobby_list
或者
for key in dic:
    print(key)
>>>name
age
hobby_list
3）values()   转化成值
①print(dic.values())  #dict_values(['太白', 18, ['直男', '钢管', '开车']])
②print(list(dic.values())) #['太白', 18, ['直男', '钢管', '开车']]
③for value in dic.values():
    print(value)
>>>
太白
18
['直男', '钢管', '开车']

items() 所有的键值对

dic={'name':'太白','age':18,'hobby_list':['直男','钢管','开车']}
①print(dic.items())  #dict_items([('name', '太白'), ('age', 18), ('hobby_list', ['直男', '钢管', '开车'])])
②for i in dic.items():
    print(i)
>>>
('name', '太白')
('age', 18)
('hobby_list', ['直男', '钢管', '开车'])

利用元组的拆包

for key,value in dic.items():
    print(key,value)
>>>
name 太白
age 18
hobby_list ['直男', '钢管', '开车']

Set(集合)

集合（set）是一个无序的不重复元素序列
集合是可变数据类型
集合属于不可哈希范围
集合自动去重

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：

parame = {value01,value02,...}
或者
set(value)

实例：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

集合的基本操作

增：

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

删

set1 = {'liangxiao','zhouyuqiang','wutao'}
set1.remove('liusidong')    # 只支持一个个的删除
set1.pop()                  # 随机删除
set1.clear()                # 清空集合
del set1                    # 删除集合

语法格式：

s.remove(x)

将元素x从集合s中移除，如果元素不存在，则发生报错。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例：

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

eg:

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

输出结果：

$ python3 test.py 
Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
清空集合：
语法：s.clear()

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

改

update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
语法：

set.update(set)

参数：
set -- 必需，可以是元素或集合
返回值：无
实例：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.update(y) 
 
print(x)

结果：

{'banana', 'apple', 'google', 'runoob', 'cherry'}

查

for i in set1:
       print(i)        # 集合只能通过for循环进行过滤查找

集合冻结：

set1 = {1, 2, 3}
set1 = frozenset(set1)      #冻结集合，即无法执行增删改操作

集合操作：

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

print(set1 & set2)              #求交集
print(set1.intersection(set2))  #求交集

print(set1 | set2)              #求并集
print(set1.union(set2))         #求并集

print(set1 ^ set2)              #反交集
print(set1.symmetric_difference(set2))  #反交集

print(set1 - set2)              #求set1与set2的差集
print(set1.difference(set2))    #求set1与set2的差集

计算集合个数：
语法格式如下：

len(s)

实例：

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

判断元素是否在集合中存在
语法格式如下：

x in s

实例：

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

python 基础总结

数据类型

Number(数字)

String（字符串）

字符串格式化

List(列表)

增：

删：

改(更新)：

查

Python列表脚本操作符

嵌套列表

列表函数&方法

Tuple(元组)

元组索引，截取

增/删/改：

查

元组运算符

元组内置函数

关于元组是不可变的

Dictionart(字典)

增

删

改

查

字典内置函数&方法

三个特殊的 key() values() items()

items() 所有的键值对

Set(集合)

集合的基本操作

增：

删

改

查

集合内置方法完整列表

你可能感兴趣的:(python 基础总结)