几种数据类型的常用API

数字

　　int()

字符串

  1 #==========join===========在字符串前后插入字符
  2 li = 'alexericrain'
  3 new_li = '_'.join(li)
  4 print(new_li)
  5 #a_l_e_x_e_r_i_c_r_a_i_n
  6 
  7 #==========split==========将给定的字符作为切割点，第二个参数表示切割的次数，返回一个切割后的字符串的列表
  8 a = 'heellohe'
  9 b = a.split('e',3)
 10 print(b)
 11 #['h', '', 'lloh', '']
 12 
 13 #==========find==========返回待查找的字符所在的第一个位置的索引，未找到就返回-1
 14 a = 'heellohe'
 15 b = a.find('e', 3, 8)
 16 print(b)
 17 #7
 18 
 19 #==========strip==========①不传参数：去掉字符串两端的空格②传参数，原字符串两端没有空格：去掉原字符串中传入的参数（必须两端字符）
 20 a = 'heelloheeff'
 21 b = a.strip('f')
 22 print(b)
 23 #heellohee
 24 
 25 #==========upper==========将字符串中全部变成大写字母
 26 a = 'FjihrDDDkkkk'
 27 b = a.upper()
 28 print(b)
 29 #FJIHRDDDKKKK
 30 
 31 #==========lower==========将字符串中全部变成小写字母
 32 a = 'FjihrDDDkkkk'
 33 b = a.lower()
 34 print(b)
 35 #fjihrdddkkkk
 36 
 37 #==========replace==========用新字符替代就旧字符（区分大小写）
 38 a = 'FjihrKKDDDkkkk'
 39 b = a.replace('k', '哈')
 40 print(b)
 41 #FjihrKKDDD哈哈哈哈
 42 
 43 #==========chr==========将ASCII码值转为具体的字符
 44 test = 48
 45 print(chr(test))
 46 #0
 47 
 48 #==========ord==========将具体的字符转为ASCII码值
 49 test = 'a'
 50 print(ord(test))
 51 #97
 52 
 53 #==========bit_length==========将十进制的数字转为二进制数后的长度
 54 test = 5
 55 print(test.bit_length())
 56 #3
 57 
 58 #==========capitalize==========将首个为字母的字符转为大写
 59 test = 'jabc'
 60 print(test.capitalize())
 61 #Jabc
 62 
 63 #==========startswith==========判断是否以什么字符开头
 64 test = 'jdifj'
 65 print(test.startswith('j'))
 66 #True
 67 
 68 #==========endswith==========判断是否以什么字符结尾
 69 test = 'fifh'
 70 print(test.endswith('h'))
 71 #True
 72 
 73 #==========format===========将字符串中的占位符用别的字符替代
 74 test = '我的名字叫{name}, 我今年{age}岁'
 75 print(test.format(name = '陈媛媛', age = 18))
 76 # print(test.format(**{'name':'陈媛媛', 'age': 18}))    #第二种写法
 77 #我的名字叫陈媛媛, 我今年18岁
 78 
 79 #==========format_map===========将字符串中的占位符用别的字符替代
 80 test = '我的名字叫{name}, 我今年{age}岁'
 81 print(test.format_map({'name':'陈媛媛','age':'18'}))
 82 #我的名字叫陈媛媛, 我今年18岁
 83 
 84 #==========索引==========
 85 test = 'hello'
 86 print(test[2])
 87 #l
 88 
 89 #==========切片==========
 90 test = 'hello'
 91 v = test[0:3]   #索引为-1表示最后一个字符，切片时左闭右开[)
 92 print(v)
 93 #hel
 94 
 95 #==========len==========返回字符串的长度
 96 test = '1234567'
 97 length = len(test)
 98 print(length)
 99 #7
100 
101 #==========str==========将其他类型的数据转换为字符串类型
102 test = 123
103 print(type(str(test)))
104 #<class 'str'>
105 
106 #==========expandtabs==========设置字符串中的制表符	的格数
107 test = '用户名	陈媛媛
密码	123
'
108 print(test.expandtabs(20))
109 #用户名                 陈媛媛
110 #密码                  123
111 
112 #==========encode==========将字符串转为二进制编码，必须设定编码格式
113 a = '陈'
114 print(a.encode('utf-8'))
115 #b'xc3xa9xc2x99xc2x88'

字符串常用API

列表list

  1 #==========for-in==========遍历列表,若想将列表转换为字符串，但是里面的元素并不全是字符串时，用for-in遍历
  2 li = ['a', 'b', 'hello', 123, ['he', 'ko']]
  3 string = ''
  4 for i in li:
  5     string += str(i)
  6 print(string)
  7 #abhello123['he', 'ko']
  8 
  9 #==========join==========用自定义的字符串拼接列表元素，也可用来将元素全为字符串的列表转换为字符串
 10 li = ['a', 'b', 'c', 'd']
 11 string = ''.join(li)
 12 print(string)
 13 #abcd
 14 
 15 #==========索引==========
 16 li = ['a', 'b', 'c', 'd']
 17 print(li[2])
 18 #c
 19 
 20 #==========切片==========
 21 li = ['a', 'b', 'c', 'd']
 22 print(li[0: -1])
 23 #['a', 'b', 'c']
 24 
 25 #==========append==========在列表最后追加元素
 26 li = ['a', 'b', 'c', 'd']
 27 li.append('e')
 28 print(li)
 29 #['a', 'b', 'c', 'd', 'e']
 30 
 31 #==========clear==========清空列表中的所有元素
 32 li = ['a', 'b', 'c', 'd']
 33 li.clear()
 34 print(li)
 35 #[]
 36 
 37 #==========copy==========复制列表并返回新列表(浅拷贝)
 38 li = ['a', 'b', 'c', 'd']
 39 new_li = li.copy()
 40 print(new_li)
 41 #['a', 'b', 'c', 'd']
 42 
 43 #==========count==========返回列表中某个元素出现的次数
 44 li = ['a', 'b', 'c', 'a']
 45 print(li.count('a'))
 46 #2
 47 
 48 #==========extend==========将传入的可迭代对象合并到列表中
 49 li = ['a', 'b', 'c']
 50 li.extend('123')
 51 li.extend(['d', 'e'])
 52 print(li)
 53 #['a', 'b', 'c', '1', '2', '3', 'd', 'e']
 54 
 55 #==========index==========返回指定元素的第一个出现的索引值,可选开始和结束索引
 56 li = ['a', 'b', 'c']
 57 print(li.index('a'))
 58 #0
 59 
 60 #==========insert==========在列表的指定位置插入元素
 61 li = ['a', 'b', 'c']
 62 li.insert(1, 'd')
 63 print(li)
 64 #['a', 'd', 'b', 'c']
 65 
 66 #==========pop==========删除指定索引的元素，若未指定索引，则默认删除最后一个，并返回被删除的元素
 67 li = ['a', 'b', 'c']
 68 v = li.pop(1)
 69 print(li)
 70 print(v)
 71 #['a', 'c']
 72 #b
 73 
 74 #==========remove==========移出列表中的指定元素的第一个
 75 li = ['a', 'b', 'c', 'a']
 76 li.remove('a')
 77 print(li)
 78 #['b', 'c', 'a']
 79 
 80 #==========reverse==========反转
 81 li = ['a', 'b', 'c', 'a']
 82 li.reverse()
 83 print(li)
 84 #['a', 'c', 'b', 'a']
 85 
 86 #==========sort==========排序
 87 li = [1, 2, 45, 12, 3]
 88 li.sort(reverse=True)   #reverse参数确定排序规则：True-->从大到小，False-->从小到大
 89 print(li)
 90 li.sort(reverse=False)
 91 print(li)
 92 #[45, 12, 3, 2, 1]
 93 #[1, 2, 3, 12, 45]
 94 
 95 #==========del==========删除指定元素
 96 li = [1, 2, 45, 12, 3]
 97 del li[0]
 98 print(li)
 99 #[2, 45, 12, 3]
100 
101 #==========list==========将其他数据类型转换为列表
102 s = 'hello'
103 new = list(s)
104 print(new)
105 #['h', 'e', 'l', 'l', 'o']
106 
107 #删除的方法总结：pop remove del clear

列表常用API

元组tuple

 1 #==========元组的一级元素不可被修改和增删,其他级别的非元组元素可修改和增删==========
 2 tu = ('123', 5, ['h', 52, ('l', 'o', 'v', 'e')])
 3 tu[2][0] = 'H'
 4 # tu[2][2][0] = 'L'    #报错
 5 print(tu)
 6 #('123', 5, ['H', 52, ('l', 'o', 'v', 'e')])
 7 
 8 #==========tuple==========将其他数据类型转换为元组
 9 s = 'hello'
10 print(tuple(s))
11 #('h', 'e', 'l', 'l', 'o')
12 
13 #==========join==========拼接元组中的元素，返回一个拼接后的字符串,前提是元素必须都为字符串类型
14 tu = ('f', 'd', 'h',)
15 new = '_'.join(tu)
16 print(new)
17 #f_d_h
18 
19 #==========for-in==========遍历元组,且可将元组转换为字符串
20 tu = ('f', 'd', 'h', 12, 45,)
21 new = ''
22 for i in tu:
23     new += str(i)
24 print(new)
25 #fdh1245
26 
27 #==========count==========返回指定元素在元组中出现的次数
28 tu = ('f', 'd', 'h', 12, 45, 'h', ['h', 12])
29 print(tu.count('h'))
30 #2
31 
32 #==========index==========返回指定元素在元组中第一次出现的索引,起始和终止索引参数可选
33 tu = ('f', 'd', 'h', 12, 45, 'h', ['h', 12])
34 print(tu.index('h'))
35 #2

元组常用API

字典dict

  1 #==========key==========
  2 dic = {
  3     'name': 'chen',
  4     'age': 12,
  5     'hobby': ['sing', 'dance']
  6 }
  7 print(dic['name'])
  8 #chen
  9 
 10 #==========del==========删除字典对应键值对
 11 dic = {
 12     'name': 'chen',
 13     'age': 12,
 14     'hobby': ['sing', 'dance']
 15 }
 16 del dic['name']
 17 print(dic)
 18 #{'age': 12, 'hobby': ['sing', 'dance']}
 19 
 20 #===========for-in==========默认遍历key
 21 dic = {
 22     'name': 'chen',
 23     'age': 12,
 24     'hobby': ['sing', 'dance']
 25 }
 26 for item in dic:
 27     print(item)
 28 #name
 29 #age
 30 #hobby
 31 
 32 #===========keys==========遍历key
 33 dic = {
 34     'name': 'chen',
 35     'age': 12,
 36     'hobby': ['sing', 'dance']
 37 }
 38 for item in dic.keys():
 39     print(item)
 40 #name
 41 #age
 42 #hobby
 43 
 44 #===========values==========遍历value
 45 dic = {
 46     'name': 'chen',
 47     'age': 12,
 48     'hobby': ['sing', 'dance']
 49 }
 50 for item in dic.values():
 51     print(item)
 52 #chen
 53 #12
 54 #['sing', 'dance']
 55 
 56 #===========items==========遍历键值对
 57 dic = {
 58     'name': 'chen',
 59     'age': 12,
 60     'hobby': ['sing', 'dance']
 61 }
 62 for k, v in dic.items():
 63     print(k, '===', v)
 64 #name === chen
 65 # age === 12
 66 # hobby === ['sing', 'dance']
 67 
 68 #==========clear==========清空字典所有的键值对
 69 dic = {
 70     'name': 'chen',
 71     'age': 12,
 72     'hobby': ['sing', 'dance']
 73 }
 74 dic.clear()
 75 print(dic)
 76 #{}
 77 
 78 #==========copy==========复制字典并返回给一个新的字典，浅拷贝
 79 dic = {
 80     'name': 'chen',
 81     'age': 12,
 82     'hobby': ['sing', 'dance']
 83 }
 84 new_dic = dic.copy()
 85 print(new_dic)
 86 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance']}
 87 
 88 #==========fromkeys==========第一个参数为可迭代对象--->键，第二个参数为任意值--->所有键的共用值   注：方法
 89 v = dict.fromkeys(['name', 'age', 'gender'], 'ha')
 90 print(v)
 91 #{'name': 'ha', 'age': 'ha', 'gender': 'ha'}
 92 
 93 #==========get==========通过键获取字典的值，若键名不存在，可以通过设置第二个参数来返回错误信息，而不是报错
 94 dic = {
 95     'name': 'chen',
 96     'age': 12,
 97     'hobby': ['sing', 'dance']
 98 }
 99 print(dic.get('nam', '该键不存在'))
100 #该键不存在
101 
102 #==========pop==========删除对应键的键值对，并返回被删除的值,若键不存在，则返回第二个参数
103 dic = {
104     'name': 'chen',
105     'age': 12,
106     'hobby': ['sing', 'dance']
107 }
108 v = dic.pop('nam', '键不存在')
109 print(dic)
110 print(v)
111 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance']}
112 #键不存在
113 
114 #==========popitem==========没有参数，随机删,返回两个参数，一个是键，一个是值
115 dic = {
116     'name': 'chen',
117     'age': 12,
118     'hobby': ['sing', 'dance']
119 }
120 k, v = dic.popitem()
121 print(k,v)
122 #hobby ['sing', 'dance']
123 
124 #==========setdefault==========设置新的键值对，若与原来的键重复，则设置无效，并返回键名原本的值，否则返回新添加的值
125 dic = {
126     'name': 'chen',
127     'age': 12,
128     'hobby': ['sing', 'dance']
129 }
130 v = dic.setdefault('gender', '男')
131 print(dic, v)
132 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance'], 'gender': '男'} 男
133 w = dic.setdefault('name', 'yuan')
134 print(dic, w)
135 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance'], 'gender': '男'} chen
136 
137 #==========update==========参数为字典，将原始字典的键值对进行跟新，有则跟新，无则添加，返回值为None
138 dic = {
139     'name': 'chen',
140     'age': 12,
141     'hobby': ['sing', 'dance']
142 }
143 v = dic.update({'name':'yuan'})
144 # v = dic.update(name = 'yuan')  #两种写法，这一种会自动转换为字典类型
145 print(dic, v)
146 #{'name': 'yuan', 'age': 12, 'hobby': ['sing', 'dance']} None
147 
148 #==========in==========默认判断的是键
149 dic = {
150     'k1': 'v1'
151 }
152 v = 'k1' in dic   #True
153 w = 'v1' in dic.values()  #True
154 print(v, w)
155 #True True

字典常用API

布尔bool

　　bool()

　　bool()之后为False:　　0　　""　　[]　　()　　{}　　None

集合set

  1 #==========add==========
  2 s = {1, 2, 3, 4}
  3 s.add('hello')
  4 print(s)
  5 #{1, 2, 3, 4, 'hello'}
  6 
  7 #==========clear==========
  8 s = {1, 2, 3, 4}
  9 s.clear()
 10 print(s)
 11 #set()
 12 
 13 #==========copy==========
 14 s = {1, 2, 3, 4}
 15 new_s = s.copy()
 16 print(new_s)
 17 #{1, 2, 3, 4}
 18 
 19 #==========pop==========随机删除元素，无法指定所删除的对象
 20 s = {1, 2, 3, 4}
 21 s.pop()
 22 print(s)
 23 #{2, 3, 4}
 24 
 25 #==========remove==========删除指定的元素，若不存在会报错
 26 s = {1, 2, 3, 4}
 27 s.remove(2)
 28 print(s)
 29 #{1, 3, 4}
 30 
 31 #==========discard==========删除指定的元素，若不存在不会报错
 32 s = {1, 2, 3, 4}
 33 s.discard(5)
 34 print(s)
 35 #{1, 2, 3, 4}
 36 
 37 #==========intersection==========求两个集合的交集
 38 s1 = {1, 2, 3, 4, 15}
 39 s2 = {1, 2, 5, 10}
 40 s = s1.intersection(s2)
 41 print(s)
 42 print(s1 & s2)   #功能与intersection相同
 43 #{1, 2}
 44 
 45 #==========union==========求两个集合的并集
 46 s1 = {1, 2, 3, 4, 15}
 47 s2 = {1, 2, 5, 10}
 48 s = s1.union(s2)
 49 print(s)
 50 print(s1 | s2)   #功能与union相同
 51 #{1, 2, 3, 4, 5, 10, 15}
 52 
 53 #==========difference==========求两个集合的差集（自己的 - 交集）
 54 s1 = {1, 2, 3, 4, 15}
 55 s2 = {1, 2, 5, 10}
 56 s = s1.difference(s2)
 57 print(s)
 58 print(s1 - s2)   #功能与difference相同
 59 #{3, 4, 15}
 60 
 61 #==========difference_update==========求两个集合的差集（自己的 - 交集）,并更新到原集合中
 62 s1 = {1, 2, 3, 4, 15}
 63 s2 = {1, 2, 5, 10}
 64 s1.difference_update(s2)
 65 print(s1)
 66 #{3, 4, 15}
 67 
 68 #==========symmetric_difference==========求两个集合的交叉补集（并集 - 交集）
 69 s1 = {1, 2, 3, 4, 15}
 70 s2 = {1, 2, 5, 10}
 71 s = s1.symmetric_difference(s2)
 72 print(s)
 73 print(s1 ^ s2)   #功能与symmetric_difference相同
 74 #{3, 4, 5, 10, 15}
 75 
 76 #==========isdisjoint==========返回两个集合是否没有交集：有交集为False，没有交集为True
 77 s1 = {1, 2, 3, 4, 15}
 78 s2 = {1, 2, 5, 10}
 79 s = s1.isdisjoint(s2)
 80 print(s)
 81 #False
 82 
 83 #==========issubset==========判断一个集合是否为另一个集合的子集
 84 s1 = {1, 2, 3}
 85 s2 = {1, 2}
 86 s = s2.issubset(s1)
 87 print(s)
 88 print(s2 <= s1)
 89 #True
 90 
 91 #==========issuperset==========判断一个集合是否为另一个集合的父集
 92 s1 = {1, 2, 3}
 93 s2 = {1, 2}
 94 s = s1.issuperset(s2)
 95 print(s)
 96 print(s1 >= s2)
 97 #True
 98 
 99 #==========update==========将两个集合的并集更新到集合中
100 s1 = {1, 2, 4}
101 s2 = {1, 2, 3}
102 s1.update(s2)
103 print(s1)
104 #{1, 2, 3, 4}
105 
106 #==========frozenset==========用来定义不可变类型的集合
107 s = frozenset('hello')
108 print(s)
109 #frozenset({'o', 'h', 'l', 'e'})

集合常用API