Python基础-数据类型

阅读量：5096 次

发布时间：2019-06-13

本文共 17916 字，大约阅读时间需要 59 分钟。

author：JevonWei

blog:http://119.23.52.191/

基本数据类型

可变数据	列表,字典
不可变数据	字符串,数字,元组

数字

int()

将字符串转换为数字

a = '123'
b = int(a)
print(type(b),b)
<class 'int'> 123

将十六进制数转换为十进制输出

num = "0011"
v = int(num,base=16)
print(v)
17

bit_lenght()

当前数字的二进制，至少用N位表示

age = 5
r = age.bit_length()
print(r)
3

字符串

字符串一旦创建，不可修改

一旦修改或者拼接，都会造成重新生成字符串

常用的内置方法
join(),split(),find(),strip(),replace(),upper(),lower()

capitalize()

首字母大写

test = 'danran'
v = test.capitalize()
print(v)
Danran

casefold()

lower()

字符串变小写,casefold比lower效果更好

test = 'DanRan'
v1 = test.casefold()
print(v1)
v2 = test.lower()
print(v2)
danran
danran

swapcase()

字符串中的字母大小写转换

test = "DanRan"
v = test.swapcase()
print(v)
dANrAN

center()

设置字符串宽度，并将内容居中，20代表总长度，* 空白未知填充

test = "Danran"
v = test.center(10)
print(v)
v1 = test.center(15,"")
print(v1)
Danran
****Danran****

ljust()

设置字符串的长度,不足的位数以指定字符填充，字符串放在左边

test = "Danran"
v = test.ljust(20,'')
print(v)
Danran*************

rjust()

设置字符串的长度,不足的位数以指定字符填充，字符串放在右边

test = "Danran"
v = test.rjust(20,'')
print(v)
*************Danran

count()

在字符串中寻找子序列出现的次数

test = "DanranJevonDan"
v = test.count('e')
print(v)
v1 = test.count('a') # 在test字符串中查找‘a’子字符串出现的次数
print(v1)
v1 = test.count('a',5) # 在test字符串中从第五个字符开始查找‘a’子字符串出现的次数
print(v1)
v1 = test.count('a',5,7) # 在test字符串中从第五个字符到第七个字符直间查找‘a’子字符串出现的次数
print(v1)
1
3
1
0

endswith()

判断字符串是否是以指定字符结尾

test = "danran"
v = test.endswith("a")
print(v)
v = test.endswith("n")
print(v)
False
True

startswith()

判断字符串是否以指定字符开始

test = "danran"
v = test.startswith("d")
print(v)
True

find()

从开始往后找，找到第一个之后，获取其位置

test = "danran"
v = test.find("an")
print(v)
1
v = test.find("an",3,5)
print(v)
v = test.find("an",3,6)
print(v)
-1
4

format()

格式化字符串，将字符串中的占位符替换为指定的值

test = 'I am {name},age {age}'
print(test)
v = test.format(name='danran',age=18)
print(v)
I am {name},age {age}
I am danran,age 18

test = 'I am {0},age {1}' # 按参数的位置传递相应的值
print(test)
v = test.format('danran',18)
print(v)
I am {name},age {age}
I am danran,age 18

format_map()

格式化，传入的值为字典格式

test = 'I am {name},age {age}'
v1 = test.format(name='df',age=10)
v2 = test.format_map({"name":'danran','age':10})
print(v1)
print(v2)

index()

在字符串中寻找子字符串出现的位置，若在字符串中找不到子序列，则报错

test = "danran"
v = test.index('n')
print(v)
v = test.index('q') # 找不到此字符‘q’，则输出报错
print(v)
Traceback (most recent call last):
File "D:/Project/test.py", line 55, in
v = test.index('q')
ValueError: substring not found
2

isalnum()

判断字符串中是否仅包含字符和数字

test = "danra123_"
v = test.isalnum()
print(v)
test = "danra123"
v = test.isalnum()
print(v)
False
True

isalpha()

判断字符串中是否全为字母

test = "danran12"
v = test.isalpha()
print(v)

test = "danran"
v = test.isalpha()
print(v)
False
True

isdigit()

isdecimal()

isnumeric()

判断字符串中是否全为数字，isdigit()比isdecimal()功能强大,isnumeric()还支持中文数字

test = "123456"
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1,v2)
True True

test = "②"
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1,v2)
False True

test = "二"
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1,v2,v3)
False
False
True

isidentifier()

判断字符串是否是合法的标识符，标识符由数字、字母及下划线组成，且不能以数字开头

a = "_123"
v = a.isidentifier()
print(v)
True

a = "123"
v = a.isidentifier()
print(v)
False

isprintable()

判断是否存在不可显示的字符，eg:/t,/n

test = "danran"
v = test.isprintable()
print(v)
True

test = "dan\nZran"
v = test.isprintable()
print(v)
False

isspace()

判断字符串是否全为空格

test = "danran"
v = test.isspace()
print(v)
False

test = " dan ran"
v = test.isspace()
print(v)
False

test = " " # test字符串全为空，即空字符串
v = test.isspace()
print(v)
True

istitle()

将字符串修改为标题格式

test = "Dan ran Jevon Wei is me"
v = test.istitle()
print(v)
False

test = "Dan ran Jevon Wei is me"
v1 = test.title() # 将test字符串的所有字符转换为首字母大写，即标题格式
print(v1)
v2 = v1.istitle() # v1即为标题，输出为True
print(v2)
Dan Ran Jevon Wei Is Me
True

* join()

将字符串中的每个元素按照指定分隔符进行拼接

test = "DanranJevonWei"
print(test)
t = ' '
v1 = t.join(test)
v2 = "_".join(test)
print(v1)
print(v2)
D a n r a n J e v o n W e i
D_a_n_r_a_n_J_e_v_o_n_W_e_i

expandtabs()

断句，即按指定字段分割

test = "username\temail\tpasswd\ndanran\tjevon@163.com\tPass1234\ndanran\tjevon@163.com\tPass1234\ndanran\tjevon@163.com\tPass1234"
v = test.expandtabs(15) # \t制表符，每15位为一段，不足的以制表符填充
print(v)
username email passwd
danran jevon@163.com Pass1234
danran jevon@163.com Pass1234
danran jevon@163.com Pass1234

islower()

判断字符串是否全为小写字符

lower()

将字符串转换为小写

test = "DanRan"
v1 = test.islower()
v2 = test.lower()
print(v1)
print(v2)
False
danran

isupper()

判断字符串是否全为大写

upper()

将字符串转换为大写

test = "DanRan"
v1 = test.isupper()
v2 = test.upper()
print(v1)
print(v2)
False
DANRAN

lstrip()

去除字符串左边指定的字符，默认去除空格，制表符及上边空白行

rstrip()

去除字符串右边指定的字符，默认去除空格，制表符及下边空白行

strip()

去除字符串两边指定的字符，默认去除空格，制表符及两边空白行

test = " Danran "
v1 = test.lstrip()
v2 = test.rstrip()
v3 = test.strip()
print(v1)
print(v2)
print(v3)
Danran
Danran
Danran

test = "Danran\n "
v1 = test.lstrip('Da') # 去除字符串左边的“Da”字符
v2 = test.rstrip() # 去除字符串右边的空格，制表符及空白行
v3 = test.strip()
print(v1)
print(v2)
print(v3)
nran # v1
# v1
Danran # v2
Danran # v3

maketrans()

构建一个字符的对应关系

translate()

根据指定的字符对应关系将字符串进行转换

test = "Wei are you Dan ran on" # 定义一个字符串
v = str.maketrans("Danran","123456") # 构建一个字符对应关系，Danran对应为123345
new_test = test.translate(v) # 将test字符串按照构建的v字符对应关系进行转换
print(new_test)
Wei 54e you 156 456 o6

partition()

将字符串按指定字符进行分割，仅分割为三份，从左边开始分割

rpartition()

将字符串按指定字符进行分割，仅分割为三份，从右边开始分割

split()

将字符串按指定字符串进行分割，可指定查找到的分割符的次数，不输出分隔符

rsplit()

将字符串按指定字符串进行分割，可指定查找到的分割符的次数，不输出分隔符

test = "Danrandanrandanran" # 定义一个字符串
v1 = test.partition("a") # 将字符串以‘a’字符分割为三份，从左边开始分割
v2 = test.rpartition("a") # 将字符串以‘a’字符分割为三份，从右边开始分割
print(v1)
print(v2)
('D', 'a', 'nrandanrandanran')
('Danrandanrandanr', 'a', 'n')

test = "Danrandanrandanran" # 定义一个字符串
v1 = test.split("a",2) # 将字符串以‘a’字符分割，从左边开始查找两个‘a’分割字符，拿不到'a'分隔符
v2 = test.rsplit("a",2) # 将字符串以‘a’字符分割，从右边开始查找两个‘a’分割字符，拿不到'a'分隔符
print(v1)
print(v2)
['D', 'nr', 'ndanrandanran']
['Danrandanrand', 'nr', 'n']

splitlines()

根据换行符分割字符串，参数为True时保留换行符，参数为False是移除换行符

test = "Dan\nran\n Jevo\nnan"
v = test.splitlines(True) # 参数为True，保留换行符
print(v)
['Dan\n', 'ran\n', ' Jevo\n', 'nan']

test = "Dan\nran\n Jevo\nnan"
v = test.splitlines(False) # 参数为False，移除换行符
print(v)
['Dan', 'ran', ' Jevo', 'nan']

startswith()

判断字符串是否以指定的字符开头

endswith()

判断字符串是否以指定的字符结尾

test = "backend 1.1.2.3"
v = test.startswith('a')
print(v)
False

test = "backend 1.1.2.3"
v = test.endswith('3')
print(v)
True

swapcase()

指定字符串大小写转换

test = 'DanRan'
v = test.swapcase()
print(v)
dANrAN

len()

获取当前字符串的长度

test = "Danran"
v=len(test)
print(v)
6

replace()

查找字符串中的特定字符并替换

test = "Danran"
v=test.replace('a','AAA')
print(v)
DAAAnrAAAn

test = "Danranaev"
v=test.replace('a','AAA',2) # 只替换前两个匹配的字符
print(v)
DAAAnrAAAnaev

range()

帮忙创建连续的数字。

v = range(100)
for item in v:
print(item)

v = range(0,100,5) # 间隔为5，输出0-100的数字
for item in v:
print(item)

索引

通过下标获取字符串中的某一个字符

test = "alex"
v=test[2]
print(v)
e

切片

将字符串进行切片

test="alex"
v=test[0:2]
print(v)
al

test="alex"
v=test[0:-1]
print(v)
ale

练习

将文件对应的索引打印出来

test = input(">>>")
print(test)
l = len(test)
print(l)

r = range(0,l)
for item in r:
print(item,test[item])
danran # print(test)
6 # print(l),打印test字符串的长度
0 d
1 a
2 n
3 r
4 a
5 n

列表 (有序，元素可以被修改)

中括号括起来

使用“,”分割每个元素

列表中的元素可以是数字，字符串，列表，布尔值...

“集合”内部可嵌套任何类型

索引

索引取值
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
print(li[4]) # 通过索引取列表中索引位置为4的值
print(li[3:6]) # 通过索引取列表中索引位置为3到6的值
['Jevon', 'danran', 44]
['age', ['Jevon', 'danran', 44], 1]

通过索引修改列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
li[1] = 100
print(li)
[1, 100, 3, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
li[1] = [100,99,98]
print(li[1])
[100, 99, 98]

切片

通过切片修改列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
li[1:3] = [100,90] # 通过切片修改列表的第1到3位元素
print(li)
[1, 100, 90, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

for,while循环

for 循环取列表中的每个值
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
for item in li:
print(item)
1
2
3
age
['Jevon', 'danran', 44]
1
5
7

in

判断指定元素是否包含在列表中

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'age' in li
print(v)
True

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'danran' in li
print(v)
False

li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
v = 'danran' in li[4]
print(v)
True

del

删除列表元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
del li[0] # 删除列表的第“0”位元素
print(li)
[2, 3, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

删除列表多个元素
li = [1,2,3,"age",["Jevon","danran",44],1,5,7]
del li[1:3] # 通过切片删除列表的第1到3个元素
print(li)
[1, 'age', ['Jevon', 'danran', 44], 1, 5, 7]

查找元素

查找子列表中的元素li = [1,2,3,"age",["Jevon","danran",[44,22]],1,5,7]print(li[4][2][1])              # 查找列表中的22元素    22

数据类型转换

将字符串转换为列表

内部通过调用for循环实现

s = "asdfqwertaffzxcvvbgfssaa"
new_li = list(s) # 将字符串s转换为列表
print(new_li)
['a', 's', 'd', 'f', 'q', 'w', 'e', 'r', 't', 'a', 'f', 'f', 'z', 'x', 'c', 'v', 'v', 'b', 'g', 'f', 's', 's', 'a', 'a']

列表转换为字符串

若字符串为纯字符组成    li = ["12","age","danran"]    v = "".join(li)             # 将每个字符间以“”分割    print(v)        12agedanran        若字符串由字符和数字组成，则需要通过for循环逐个处理    li = [11,22,33,"abc",'danran']    s = ""    for i in li:        s += str(i)    print(s)        112233abcdanran

append()

在列表的最后追加元素

li = [11,22,33,"abc",'danran']
li.append("Jevon")
print(li)
[11, 22, 33, 'abc', 'danran', 'Jevon']

clear()

清空列表

li = [11,22,33,"abc",'danran']
li.clear()
print(li)
[]

copy()

拷贝复制列表，浅拷贝

li = [11,22,33,"abc",'danran']
v = li.copy()
print(v)
[11, 22, 33, 'abc', 'danran']

count()

统计指定元素在列表中出现的次数

li = [11,2,33,"abc",'danran',2]  v = li.count(2)  print(v)      2

extend()

将指定的元素或子列表扩展到原列表中，参数为可迭代对象

li = [11,2,33,"abc",'danran',2]
li.extend("Jevon")
print(li)
[11, 2, 33, 'abc', 'danran', 2, 'J', 'e', 'v', 'o', 'n']

li = [11,2,33,"abc",'danran',2]
li.extend([999,"Jevon"])
print(li)
[11, 2, 33, 'abc', 'danran', 2, 999, 'Jevon']

比较append()
li = [11,2,33,"abc",'danran',2]
li.append([999,"Jevon"])
print(li)
[11, 2, 33, 'abc', 'danran', 2, [999, 'Jevon']]

index()

根据指定的值获取当前值的索引位置，默认从左向右查找，可指定查找的起始及终止位置

li = [11,2,33,"abc",'danran',2]
v = li.index(2) # 默认从前向后查找
print(v)
1

li = [11,2,33,"abc",'danran',2]
v = li.index(2,2) # 指定查找的起始位置为2
print(v)
5

insert()

在列表的指定索引位置插入元素

li = [11,2,33,"abc",'danran',2]
li.insert(1,"Jevon") # 在列表的第1索引位置插入元素“Jevon”
print(li)
[11, 'Jevon', 2, 33, 'abc', 'danran', 2]

pop()

删除列表指定索引位置的元素，并可获取删除的值，默认删除删除最后的元素
li = [11,2,33,"abc",'danran',2]
v = li.pop() # 删除列表最后以为元素
print(v) # 返回删除的元素
print(li)
2
[11, 2, 33, 'abc', 'danran']

删除列表索引位置为3的元素
li = [11,2,33,"abc",'danran',2]
v = li.pop(3)
print(v)
print(li)
abc
[11, 2, 33, 'danran', 2]

remove()

删除列表指定元素，左边优先

li = [11,2,33,"abc",'danran',2]
li.remove(33) # 删除列表中的元素“33”
print(li)
[11, 2, 'abc', 'danran', 2]

reverse()

将当前列表进行反转

li = [11,2,33,"abc",'danran',2]
li.reverse()
print(li)
[2, 'danran', 'abc', 33, 2, 11]

sort()

将列表中的元素排序

从小到大排序
li = [11,22,44,11,2,77]
li.sort()
print(li)
[2, 11, 11, 22, 44, 77]

从大到小排序
li = [11,22,44,11,2,77]
li.sort(reverse=True)
print(li)
[77, 44, 22, 11, 11, 2]

元组 (有序的)

习惯写元组的时候，随后在最后加入“,”

元素不可被修改，不能被删除或增加

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
print(tu)
(11, 'danran', (1, 2, 3), [(33, 44)], True, 123)

取值

通过切片取值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
v = tu[2:5]
print(v)
((1, 2, 3), [(33, 44)], True)

通过索引取值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
v = tu[2]
print(v)
(1, 2, 3)

通过for循环取元组中的值

tu = (11,"danran",(1,2,3),[(33,44)],True,123,)
for item in tu:
print(item)
11
danran
(1, 2, 3)
[(33, 44)]
True
123

数据类型转换

将字符串，列表，元组互相转换

s = "asdfghj124"  li = ["danran",123,[11,23]]  tu = (123,123,"danran")  将字符串s转换Wie元组  v = tuple(s)  print(v)      ('a', 's', 'd', 'f', 'g', 'h', 'j', '1', '2', '4')  将列表转换为元组  v = tuple(li)  print(v)          ('danran', 123, [11, 23])  将元组转换为列表  v = list(tu)  print(v)      [123, 123, 'danran']  将元组转换Wie字符串  v = str(tu)  print(v)  print(type(v))      (123, 123, 'danran')

count()

统计指定元素在元组中出现的次数

tu = (11,"danran",(11,22,3),11,True,)
v = tu.count(11)
print(v)
2

index()

返回指定元素在元组中的索引位置，左边优先

tu = (11,"danran",(11,22,3),11,True,)
v = tu.index(11)
print(v)
0

元组中列表一级元素不可修改，但列表中的元素可被修改

tu = (11,"danran",(11,22,3),[(12,23,34),12],True,)tu[3][1] = 1111print(tu)    (11, 'danran', (11, 22, 3), [(12, 23, 34), 1111], True)

字典

字典的value可以是任何值

列表、字典不能作为字典的key

字典是无序的

info = {"k1":"12","k2":"23"}
print(info)
{'k1': '12', 'k2': '23'}

获取字典的值

info = {"k1":"12","k2":"23"}v = info["k2"]print(v)    23

del()

字典支持del删除

info = {"k1":"12","k2":"23"}
del info["k1"]
print(info)
{'k2': '23'}

for循环字典

默认for循环只返回key键
info = {"k1":"12","k2":"23"}
for item in info:
print(item)
k1
k2

for循环返回字典的key键
info = {"k1":"12","k2":"23"}
for item in info.keys():
print(item)
k1
k2

for循环获取字典的value值
info = {"k1":"12","k2":"23"}
for item in info.values():
print(item)
12
23

for同时返回字典的key键和value值
info = {"k1":"12","k2":"23"}
for k,v in info.items():
print(k,v)
k1 12
k2 23

clear()

清空元组

copy（）

复制拷贝元组

fromkeys()

根据序列创建字典，并指定统一的值

v = dict.fromkeys(["k1",12,"danran"])
print(v)
{'k1': None, 12: None, 'danran': None}

v = dict.fromkeys(["k1",12,"danran"],"Jevon")
print(v)
{'k1': 'Jevon', 12: 'Jevon', 'danran': 'Jevon'}

get()

根据字典的键取值

info = {"k1":"12","k2":"23"}
v = info.get("k1")
print(v)
12

若指定的键不存在，则返回None,并将默认值赋给此不存在的键
info = {"k1":"12","k2":"23"}
v = info.get("k1111"，"danran")
print(v)
None

info = {"k1":"12","k2":"23"}
v = info.get("k1111","danran")
print(v)
danran

pop()

删除字典中的键值对，当删除的键值对不存在时，可返还默认值

info = {"k1":"12","k2":"23"}
v = info.pop("k1") # 删除k1键值对
print(info)
print(v) # 将删除的k1键值对打印出来
{'k2': '23'}
12

删除的键值对k1111不存在，则返回“danran”
info = {"k1":"12","k2":"23"}
v = info.pop("k1111","danran")
print(info)
print(v)
{'k1': '12', 'k2': '23'}
danran

popitem()

随机删除键值对，并返回删除的键值对
info = {"k1":"12","k2":"23"}
v = info.popitem()
print(info)
print(v)
{'k1': '12'}
('k2', '23')

setdefault()

设置键的默认值，若键值对已存在，则获取当前key对应的值，若key不存在，则设置此key对应的值为指定的值

info = {"k1":"12","k2":"23"}
v = info.setdefault("k111","12334")
print(info)
print(v)
{'k1': '12', 'k2': '23', 'k111': '12334'}
12334

update()

更新字典，如key存在，则更新相应的键值，若key不存在，则增加相应的键值对

info = {"k1":"12","k2":"23"}
info.update({"k1":"1234","k3":"11"})
print(info)
{'k1': '1234', 'k2': '23', 'k3': '11'}

集合

集合为无序的，且为不可变数据类型。

定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可作为字典的key，即必须为不可变类型。

特性：
集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无须纠结于集合中单个值。

创建集合

s = {1,2,3,4,5}print(type(s))

set()

创建集合

s = set("danran")
print(s)
{'a', 'r', 'd', 'n'}

frozenset()

创建不可变集合

s = frozenset("danrna")
print(s)
frozenset({'n', 'd', 'a', 'r'})

add()

集合中添加元素

s = {1,2,3,4,5}
s.add("danran")
print(s)
{1, 2, 3, 4, 5, 'danran'}

clear

清空集合

s = {1,2,3,4,5}
s.clear()
print(s)
set()

copy()

集合拷贝复制

s = {1,2,3,4,5}
a = s.copy()
print(a)
{1, 2, 3, 4, 5}

pop()

随机删除集合中的元素

s = {1,2,3,4,5}
s.pop()
print(s)
{2, 3, 4, 5}

remove()

删除集合中的指定元素，若指定元素不存在，则报错

s = {1,2,3,4,5,"danran"}
s.remove("danran") # 删除集合中的元素“danran”
print(s)
{1, 2, 3, 4, 5}

discard()

删除集合中的指定元素，若指定元素不存在，则不返回报错信息

s = {1,2,3,4,5,"danran"}
s.discard("danran")
print(s)
{1, 2, 3, 4, 5}

intersection()

两个集合的交集，等同于"&".

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.intersection(l)) # intersection()等用于"&".
print(p&l)
{'Jevon', 'danran', 'Wei'} {'dan', 'Wei'}
{'Wei'}
{'Wei'}

union()

两个集合的并集，等同于"|"。

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.union(l)) # 输出两个集合的并集，等同于"|"符合。
print(p|l)
{'Jevon', 'danran', 'Wei'} {'dan', 'Wei'}
{'dan', 'Jevon', 'danran', 'Wei'}
{'dan', 'Jevon', 'danran', 'Wei'}

difference()

两个集合的差集，等同于"-"符号。

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l) # 打印两个集合
print(p.difference(l)) # 集合p于集合l的差集
print(p-l) # 集合p于集合l的差集
print(l.difference(p)) # 集合l于集合p的差集
print(l-p) # 集合l于集合p的差集
{'danran', 'Jevon', 'Wei'} {'Wei', 'dan'} # 打印两个集合
{'danran', 'Jevon'} # 集合p于集合l的差集
{'danran', 'Jevon'} # 集合p于集合l的差集
{'dan'} # 集合l于集合p的差集
{'dan'} # 集合l于集合p的差集

symmetric_difference()

两个集合的交叉补集运算，等同于"^"符号

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
print(p.symmetric_difference(l)) # p集合于l集合的交叉补集
print(p^l) # p集合于l集合的交叉补集
print(l.symmetric_difference(p)) # l集合于p集合的交叉补集
print(l^p) # l集合于p集合的交叉补集
{'Wei', 'Jevon', 'danran'} {'Wei', 'dan'}
{'danran', 'Jevon', 'dan'} # p集合于l集合的交叉补集
{'danran', 'Jevon', 'dan'} # p集合于l集合的交叉补集
{'Jevon', 'danran', 'dan'} # l集合于p集合的交叉补集
{'Jevon', 'danran', 'dan'} # l集合于p集合的交叉补集

difference_update()

更新两个集合的差集

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
s = p.difference(l)
print(s)
p.difference_update(l) # 更新p集合与l集合的差集
print(s)
{'Wei', 'Jevon', 'danran'} {'dan', 'Wei'}
{'Jevon', 'danran'}
{'Jevon', 'danran'} # 更新后的差集

symmetric_difference_update

更新两个集合的交叉补集

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
print(p,l)
s = p.symmetric_difference(l)
print(s)
p.symmetric_difference_update(l) # 更新两个集合的交叉补集
print(s)
{'danran', 'Wei', 'Jevon'} {'Wei', 'dan'}
{'danran', 'Jevon', 'dan'}
{'danran', 'Jevon', 'dan'} # 输出更新后的两个集合的交叉补集

intersection_update()

更新两个集合的交集

isdisjoint()

如果两个集合没有交集，即返回"True"

p = set(["danran","Jevon","Wei","Jevon"])
l = set(["dan","Wei"])
q = set(["li","ran"])
print(p.isdisjoint(l)) # 集合p和集合l交集不为空，即返回False
print(l.isdisjoint(q)) # 集合l和集合q交集为空，即返回True
False
True

issubset()

判断集合是否是子集关系，等同于"l<=p"符号。

p = set(["danran","Wei","Jevon"])
l = set(["danran","Wei"])
print(l.issubset(p)) # 集合l是集合p的子集
print(l<=p)
print(p.issubset(l))
True
True
False

issuperset()

判断集合是否是父集关系，等同于"p>=l"符号。

p = set(["danran","Wei","Jevon"])
l = set(["danran","Wei"])
print(p.issuperset(l)) # 集合p是集合l的父集
print(p>=l)
True
True

update()

对集合更新多个值

p = set(["danran","Wei","Jevon"])
l = set(["danran","xin"])
p.update(l)
print(p)
{'Wei', 'danran', 'Jevon', 'xin'}

对可迭代的数据都可更新到集合中
p = set(["danran","Wei","Jevon"])
p.update(["dan"])
print(p)
{'dan', 'Wei', 'danran', 'Jevon'}

字符串格式化

百分号格式

format格式

百分号格式

%[(name)][flags][width].[precision]typecode- (name)        # 可选，用于选择指定的key- flags         # 可选，可供选择的值由    +           右对齐：正数前加正号，负数前加负号    -           左对齐：正数前无符号，负数前加负号    空格  右对齐：正数前加空格，负数前加负号    0           右对齐：正数前无符号，负数前加负号；用0填充空白处    - width     # 可选，占有宽度- .precision    # 可选，小数点后保留的位数- typecode      # 必选