几种数据类型的常用API

• 数字

　　int()

• 字符串　

 #==========join===========在字符串前后插入字符
 li = 'alexericrain'
 new_li = '_'.join(li)
 print(new_li)
 #a_l_e_x_e_r_i_c_r_a_i_n

 #==========split==========将给定的字符作为切割点，第二个参数表示切割的次数，返回一个切割后的字符串的列表
 a = 'heellohe'
 b = a.split('e',3)
 print(b)
 #['h', '', 'lloh', '']

 #==========find==========返回待查找的字符所在的第一个位置的索引，未找到就返回-1
 a = 'heellohe'
 b = a.find('e', 3, 8)
 print(b)
 #

 #==========strip==========①不传参数：去掉字符串两端的空格②传参数，原字符串两端没有空格：去掉原字符串中传入的参数（必须两端字符）
 a = 'heelloheeff'
 b = a.strip('f')
 print(b)
 #heellohee

 #==========upper==========将字符串中全部变成大写字母
 a = 'FjihrDDDkkkk'
 b = a.upper()
 print(b)
 #FJIHRDDDKKKK

 #==========lower==========将字符串中全部变成小写字母
 a = 'FjihrDDDkkkk'
 b = a.lower()
 print(b)
 #fjihrdddkkkk

 #==========replace==========用新字符替代就旧字符（区分大小写）
 a = 'FjihrKKDDDkkkk'
 b = a.replace('k', '哈')
 print(b)
 #FjihrKKDDD哈哈哈哈

 #==========chr==========将ASCII码值转为具体的字符
 test = 48
 print(chr(test))
 #

 #==========ord==========将具体的字符转为ASCII码值
 test = 'a'
 print(ord(test))
 #

 #==========bit_length==========将十进制的数字转为二进制数后的长度
 test = 5
 print(test.bit_length())
 #

 #==========capitalize==========将首个为字母的字符转为大写
 test = 'jabc'
 print(test.capitalize())
 #Jabc

 #==========startswith==========判断是否以什么字符开头
 test = 'jdifj'
 print(test.startswith('j'))
 #True

 #==========endswith==========判断是否以什么字符结尾
 test = 'fifh'
 print(test.endswith('h'))
 #True

 #==========format===========将字符串中的占位符用别的字符替代
 test = '我的名字叫{name}, 我今年{age}岁'
 print(test.format(name = '陈媛媛', age = 18))
 # print(test.format(**{'name':'陈媛媛', 'age': 18}))    #第二种写法
 #我的名字叫陈媛媛, 我今年18岁

 #==========format_map===========将字符串中的占位符用别的字符替代
 test = '我的名字叫{name}, 我今年{age}岁'
 print(test.format_map({'name':'陈媛媛','age':''}))
 #我的名字叫陈媛媛, 我今年18岁

 #==========索引==========
 test = 'hello'
 print(test[2])
 #l

 #==========切片==========
 test = 'hello'
 v = test[0:3]   #索引为-1表示最后一个字符，切片时左闭右开[)
 print(v)
 #hel

 #==========len==========返回字符串的长度
 test = ''
 length = len(test)
 print(length)
 #

 #==========str==========将其他类型的数据转换为字符串类型
 test = 123
 print(type(str(test)))
 #<class 'str'>

 #==========expandtabs==========设置字符串中的制表符\t的格数
 test = '用户名\t陈媛媛\n密码\t123\n'
 print(test.expandtabs(20))
 #用户名                 陈媛媛
 #密码                  123

 #==========encode==========将字符串转为二进制编码，必须设定编码格式
 a = '陈'
 print(a.encode('utf-8'))
 #b'\xc3\xa9\xc2\x99\xc2\x88'

字符串常用API

•  列表list

 #==========for-in==========遍历列表,若想将列表转换为字符串，但是里面的元素并不全是字符串时，用for-in遍历
 li = ['a', 'b', 'hello', 123, ['he', 'ko']]
 string = ''
 for i in li:
     string += str(i)
 print(string)
 #abhello123['he', 'ko']

 #==========join==========用自定义的字符串拼接列表元素，也可用来将元素全为字符串的列表转换为字符串
 li = ['a', 'b', 'c', 'd']
 string = ''.join(li)
 print(string)
 #abcd

 #==========索引==========
 li = ['a', 'b', 'c', 'd']
 print(li[2])
 #c

 #==========切片==========
 li = ['a', 'b', 'c', 'd']
 print(li[0: -1])
 #['a', 'b', 'c']

 #==========append==========在列表最后追加元素
 li = ['a', 'b', 'c', 'd']
 li.append('e')
 print(li)
 #['a', 'b', 'c', 'd', 'e']

 #==========clear==========清空列表中的所有元素
 li = ['a', 'b', 'c', 'd']
 li.clear()
 print(li)
 #[]

 #==========copy==========复制列表并返回新列表(浅拷贝)
 li = ['a', 'b', 'c', 'd']
 new_li = li.copy()
 print(new_li)
 #['a', 'b', 'c', 'd']

 #==========count==========返回列表中某个元素出现的次数
 li = ['a', 'b', 'c', 'a']
 print(li.count('a'))
 #

 #==========extend==========将传入的可迭代对象合并到列表中
 li = ['a', 'b', 'c']
 li.extend('')
 li.extend(['d', 'e'])
 print(li)
 #['a', 'b', 'c', '1', '2', '3', 'd', 'e']

 #==========index==========返回指定元素的第一个出现的索引值,可选开始和结束索引
 li = ['a', 'b', 'c']
 print(li.index('a'))
 #

 #==========insert==========在列表的指定位置插入元素
 li = ['a', 'b', 'c']
 li.insert(1, 'd')
 print(li)
 #['a', 'd', 'b', 'c']

 #==========pop==========删除指定索引的元素，若未指定索引，则默认删除最后一个，并返回被删除的元素
 li = ['a', 'b', 'c']
 v = li.pop(1)
 print(li)
 print(v)
 #['a', 'c']
 #b

 #==========remove==========移出列表中的指定元素的第一个
 li = ['a', 'b', 'c', 'a']
 li.remove('a')
 print(li)
 #['b', 'c', 'a']

 #==========reverse==========反转
 li = ['a', 'b', 'c', 'a']
 li.reverse()
 print(li)
 #['a', 'c', 'b', 'a']

 #==========sort==========排序
 li = [1, 2, 45, 12, 3]
 li.sort(reverse=True)   #reverse参数确定排序规则：True-->从大到小，False-->从小到大
 print(li)
 li.sort(reverse=False)
 print(li)
 #[45, 12, 3, 2, 1]
 #[1, 2, 3, 12, 45]

 #==========del==========删除指定元素
 li = [1, 2, 45, 12, 3]
 del li[0]
 print(li)
 #[2, 45, 12, 3]

 #==========list==========将其他数据类型转换为列表
 s = 'hello'
 new = list(s)
 print(new)
 #['h', 'e', 'l', 'l', 'o']

 #删除的方法总结：pop remove del clear

列表常用API

• 元组tuple

 #==========元组的一级元素不可被修改和增删,其他级别的非元组元素可修改和增删==========
 tu = ('', 5, ['h', 52, ('l', 'o', 'v', 'e')])
 tu[2][0] = 'H'
 # tu[2][2][0] = 'L'    #报错
 print(tu)
 #('123', 5, ['H', 52, ('l', 'o', 'v', 'e')])

 #==========tuple==========将其他数据类型转换为元组
 s = 'hello'
 print(tuple(s))
 #('h', 'e', 'l', 'l', 'o')

 #==========join==========拼接元组中的元素，返回一个拼接后的字符串,前提是元素必须都为字符串类型
 tu = ('f', 'd', 'h',)
 new = '_'.join(tu)
 print(new)
 #f_d_h

 #==========for-in==========遍历元组,且可将元组转换为字符串
 tu = ('f', 'd', 'h', 12, 45,)
 new = ''
 for i in tu:
     new += str(i)
 print(new)
 #fdh1245

 #==========count==========返回指定元素在元组中出现的次数
 tu = ('f', 'd', 'h', 12, 45, 'h', ['h', 12])
 print(tu.count('h'))
 #

 #==========index==========返回指定元素在元组中第一次出现的索引,起始和终止索引参数可选
 tu = ('f', 'd', 'h', 12, 45, 'h', ['h', 12])
 print(tu.index('h'))
 #

元组常用API

• 字典dict

 #==========key==========
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 print(dic['name'])
 #chen

 #==========del==========删除字典对应键值对
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 del dic['name']
 print(dic)
 #{'age': 12, 'hobby': ['sing', 'dance']}

 #===========for-in==========默认遍历key
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 for item in dic:
     print(item)
 #name
 #age
 #hobby

 #===========keys==========遍历key
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 for item in dic.keys():
     print(item)
 #name
 #age
 #hobby

 #===========values==========遍历value
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 for item in dic.values():
     print(item)
 #chen
 #
 #['sing', 'dance']

 #===========items==========遍历键值对
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 for k, v in dic.items():
     print(k, '===', v)
 #name === chen
 # age === 12
 # hobby === ['sing', 'dance']

 #==========clear==========清空字典所有的键值对
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 dic.clear()
 print(dic)
 #{}

 #==========copy==========复制字典并返回给一个新的字典，浅拷贝
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 new_dic = dic.copy()
 print(new_dic)
 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance']}

 #==========fromkeys==========第一个参数为可迭代对象--->键，第二个参数为任意值--->所有键的共用值   注：方法
 v = dict.fromkeys(['name', 'age', 'gender'], 'ha')
 print(v)
 #{'name': 'ha', 'age': 'ha', 'gender': 'ha'}

 #==========get==========通过键获取字典的值，若键名不存在，可以通过设置第二个参数来返回错误信息，而不是报错
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 print(dic.get('nam', '该键不存在'))
 #该键不存在

 #==========pop==========删除对应键的键值对，并返回被删除的值,若键不存在，则返回第二个参数
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 v = dic.pop('nam', '键不存在')
 print(dic)
 print(v)
 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance']}
 #键不存在

 #==========popitem==========没有参数，随机删,返回两个参数，一个是键，一个是值
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 k, v = dic.popitem()
 print(k,v)
 #hobby ['sing', 'dance']

 #==========setdefault==========设置新的键值对，若与原来的键重复，则设置无效，并返回键名原本的值，否则返回新添加的值
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 v = dic.setdefault('gender', '男')
 print(dic, v)
 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance'], 'gender': '男'} 男
 w = dic.setdefault('name', 'yuan')
 print(dic, w)
 #{'name': 'chen', 'age': 12, 'hobby': ['sing', 'dance'], 'gender': '男'} chen

 #==========update==========参数为字典，将原始字典的键值对进行跟新，有则跟新，无则添加，返回值为None
 dic = {
     'name': 'chen',
     'age': 12,
     'hobby': ['sing', 'dance']
 }
 v = dic.update({'name':'yuan'})
 # v = dic.update(name = 'yuan')  #两种写法，这一种会自动转换为字典类型
 print(dic, v)
 #{'name': 'yuan', 'age': 12, 'hobby': ['sing', 'dance']} None

 #==========in==========默认判断的是键
 dic = {
     'k1': 'v1'
 }
 v = 'k1' in dic   #True
 w = 'v1' in dic.values()  #True
 print(v, w)
 #True True

字典常用API

• 布尔bool

　　bool()

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

• 集合set

 #==========add==========
 s = {1, 2, 3, 4}
 s.add('hello')
 print(s)
 #{1, 2, 3, 4, 'hello'}

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

 #==========copy==========
 s = {1, 2, 3, 4}
 new_s = s.copy()
 print(new_s)
 #{1, 2, 3, 4}

 #==========pop==========随机删除元素，无法指定所删除的对象
 s = {1, 2, 3, 4}
 s.pop()
 print(s)
 #{2, 3, 4}

 #==========remove==========删除指定的元素，若不存在会报错
 s = {1, 2, 3, 4}
 s.remove(2)
 print(s)
 #{1, 3, 4}

 #==========discard==========删除指定的元素，若不存在不会报错
 s = {1, 2, 3, 4}
 s.discard(5)
 print(s)
 #{1, 2, 3, 4}

 #==========intersection==========求两个集合的交集
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s = s1.intersection(s2)
 print(s)
 print(s1 & s2)   #功能与intersection相同
 #{1, 2}

 #==========union==========求两个集合的并集
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s = s1.union(s2)
 print(s)
 print(s1 | s2)   #功能与union相同
 #{1, 2, 3, 4, 5, 10, 15}

 #==========difference==========求两个集合的差集（自己的 - 交集）
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s = s1.difference(s2)
 print(s)
 print(s1 - s2)   #功能与difference相同
 #{3, 4, 15}

 #==========difference_update==========求两个集合的差集（自己的 - 交集）,并更新到原集合中
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s1.difference_update(s2)
 print(s1)
 #{3, 4, 15}

 #==========symmetric_difference==========求两个集合的交叉补集（并集 - 交集）
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s = s1.symmetric_difference(s2)
 print(s)
 print(s1 ^ s2)   #功能与symmetric_difference相同
 #{3, 4, 5, 10, 15}

 #==========isdisjoint==========返回两个集合是否没有交集：有交集为False，没有交集为True
 s1 = {1, 2, 3, 4, 15}
 s2 = {1, 2, 5, 10}
 s = s1.isdisjoint(s2)
 print(s)
 #False

 #==========issubset==========判断一个集合是否为另一个集合的子集
 s1 = {1, 2, 3}
 s2 = {1, 2}
 s = s2.issubset(s1)
 print(s)
 print(s2 <= s1)
 #True

 #==========issuperset==========判断一个集合是否为另一个集合的父集
 s1 = {1, 2, 3}
 s2 = {1, 2}
 s = s1.issuperset(s2)
 print(s)
 print(s1 >= s2)
 #True

 #==========update==========将两个集合的并集更新到集合中
 s1 = {1, 2, 4}
 s2 = {1, 2, 3}
 s1.update(s2)
 print(s1)
 #{1, 2, 3, 4}

 #==========frozenset==========用来定义不可变类型的集合
 s = frozenset('hello')
 print(s)
 #frozenset({'o', 'h', 'l', 'e'})

集合常用API