Python基础-数据类型

目录

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')
  	<class 'str'>

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] = 1111
print(tu)
	(11, 'danran', (11, 22, 3), [(12, 23, 34), 1111], True)

字典

  • 字典的value可以是任何值

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

  • 字典是无序的

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

获取字典的值

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

del()

  • 字典支持del删除

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

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)

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

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)

集合

  • 集合为无序的，且为不可变数据类型。
  • 定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可作为字典的key，即必须为不可变类型。
  • 特性：
    集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无须纠结于集合中单个值。

创建集合

s = {1,2,3,4,5}
print(type(s))
	<class 'set'>

set()

  • 创建集合

    s = set("danran")
    print(s)

frozenset()

  • 创建不可变集合

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

add()

  • 集合中添加元素

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

clear

  • 清空集合

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

copy()

  • 集合拷贝复制

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

pop()

  • 随机删除集合中的元素

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

remove()

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

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

discard()

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

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

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'}

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'}

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)

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

字符串格式化

  • 百分号格式
  • format格式

百分号格式

%[(name)][flags][width].[precision]typecode

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

format格式

posted @ 2018-06-11 20:42  JevonWei  阅读(213)  评论(0)  编辑  收藏  举报