数据类型的内置方法

数据类型的内置方法

数字类型(int float)

# int()方法将括号内的数据转化为整型，其数据只能是整数的字符串，否则会报错。
num = int('1')  # num = 1
# 整型中还有bin() oct() hex()方法把10进制数转化成2 8 16进制数。
print(bin(7))  # 0b111
print(oct(7))  # 0o7
print(hex(7))  # 0x7
#int()方法的第二个参数可以设置字符串转化为数字的进制。
print(int('0b111',2))  # 7
print(int('0o7',8))  # 7
print(int('0x7',16))  # 7
# float()方法将括号内的数据转化为浮点型，其数据可以是分数和整数。
num = float('1.1')  # num = 1.1

字符串类型str

类型转换方法

print(str(7))  # 7
print(str([1,5,7])) # '[1,5,7]'

字符串支持索引取值，对于取某一段字符可以使用切片。

# 切片取值时顾头不顾尾，如下
name = 'White Wilter'
print(name[0:4])  # Whit
# 切片的最后可以设置步长，表示取一个字符，当前索引+步长，再取字符
print(name[0:8:2])  # WieW
# 切片中索引支持负数
print(name[-1])  # r  取最后索引中的字符
# 切片的区间和数轴中x轴类似，不要设反
print(name[-5:-1])  # ilte
print(name[-1:-5])  #  无任何输出
#步长也可以是负数
print(name[0:-1:-1])  # retliW etih

返回字符串的长度。

name = 'foo'
print(len(name))  # 3

移除字符串首尾指定的字符串

# 默认移除首尾的空格
name = '     xie '
print(name)  # '     xie '
print(name.strip())  # 'xie'
#strip(param)可以给定参数移除首尾指定的字符
name = '#xie###'
print(name.strip('#'))  # xie
print(name.lstrip('#'))  # 'xie###' lstrip移除左边
print(name.rstrip('#'))  # '#xie' rstrip移除右边

以指定的字符分割字符串返回列表。

info = 'xie|12|man'
print(info.split('|'))  # ['xie','12','man']
#split的第二个参数maxsplit设置分割的次数，默认左往右计数。
info = 'xie|12|man'
print(info.split('|',maxsplit=1))  # ['xie', '12|man']
#可以使用lsplit、rsplit设置分割的方向。
info = 'xie|12|man'
print(info.lsplit('|',maxsplit=1))  # ['xie', '12|man']
print(info.rsplit('|',maxsplit=1))  # ['xie|12','man']

改变字符串字母的大小写。

name = 'xie'
print(name.upper())  # 'XIE'
name2 = 'XIE'
print(name.lower())  # 'xie'

判断字符串是否以指定的字符开头或结尾。

word = 'Long may the sunshine'
print(word.startswith('m'))  # False
print(word.startswith('L'))  # True
print(word.endswith('sunshine'))  # True
print(word.endswith('n'))  # False

格式化输出

#1.格式化输出第一种方式,按照传参的顺序
info = 'My name is {},i am {} years old.'
print(info.format('xie',18))  # My name is xie,i am 18 years old.
#2.格式化输出第二种方式，可以多次使用
info = 'My name is {1},i am {0} years old.{0}'
print(info.format(18,'xie'))  # My name is xie,i am 18 years old.18
#3.格式化输出第三种方式,参数名方式
info = 'My name is {name},i am {age} years old.'
print(info.format(name = 'xie', age = 18))  # My name is xie,i am 18 years old.

字符串拼接

name_list = ['xie','xu','jiang']
# join()方法以指定字符拼接列表元素，注意：列表的元素必须一致，即都是字符串。
print(' '.join(name_list))  # 'xie xu jiang'

替换字符串中指定的字符

word = 'Long may the sunshine.'
# replace()方法中第一个参数是被替换的字符，第二个是新的字符，第三个是替换的数量。
print(word.replace(' ','|'))  # 'Long|may|the|sunshine.'  默认全替换
print(word.replace(' ','|',1))  # 'Long|may the sunshine.'

判断字符串是否是纯数字

num = '7'
print(num.isdigit())  # True

查找字符在字符串中的位置及出现次数

word = 'Long may the sunshine.'
# find(sub,start,end) sub:查找的字符、start：开始位置、end：结束位置 。
print(word.find('t'))  # 9
print(word.find('s',5,20))  # 13 's'第一次出现的索引
print(word.find('r'))  # -1 没找到返回-1
# index()方法同find类似，但是没找到不返回-1而是报错
print(word.count('s'))  # 2  count()方法返回次数

其他方法

# title 每个单词首字母大写
print('what are you doing'.title())  # What Are You Doing
# capitalize 字符串头大写
print('what are you doing'.capialize())  # What are you doing
# center 字符居中，长度不够的*号补全
print('xie'.center('*',7))  # '**xie**'
# rjust 字符右对齐，长度不够*号补全
print('xie'.rjust('*',4))  # '*xie'
# ljust 字符左对齐，长度不够*号补全
print('xie'.ljust('*',4))  # 'xie*'
# isalnum()判断既可以包含字母也可以包含数字
# isalpha()判断是否全是字母

列表类型list

类型转化方法

str = 'xie'
print(list(str))  # ['x','i','e']

列表添加元素

# append()在列表末尾添加元素
list = [1, 2, 3]
print(list.append(4))  # [1, 2, 3, 4]
# insert()指定列表索引位置插入元素,第一个参数是插入的元素，第二个参数是索引位置
print(list.insert(0, 0))  # [0, 1, 2, 3]
# extend()在列表末尾追加多个元素，传参是列表
print(list.extends([4, 5]))  # [1, 2, 3, 4, 5]

列表删除元素

list = [1, 2, 3]
# remove()删除列表中指定值的元素，如果值在列表中有多个只删除第一个
list.remove(1)  # [2, 3]
# del 删除指定索引位置的元素
del list[0]  # [2, 3]
# pop()删除列表末尾元素并返回删除的值
print(list.pop())  # 3  此时list [1, 2]

列表长度

list = [1, 2, 3]
# len()方法返回列表长度，即为元素的个数
print(len(list))  # 3

列表排序

#sort()方法排序列表元素，默认升序。可以传参reverse=True降序。
list = [1,7,26,4,81,21,3,18]
# list.sort()
# print(list)  # [1, 3, 4, 7, 18, 21, 26, 81]
list.sort(reverse=True)
print(list)  # [81, 26, 21, 18, 7, 4, 3, 1]

列表其他操作

list = [11, 22, 33, 44]
# 列表切片操作，同字符类似
print(list[2:])  # [33, 44]
print(list[::-1])  # [44, 33, 22, 11]
# 列表反转元素顺序
list = ['xie', 'b', 'c']
list.reverse()
print(list)  # ['c', 'b', 'xie']

字典类型dict

字典类型转化

dict1 = dict(name='xie',age=18)  # {'name':'xie','age':18}
dict2 = dict(['name','xie'],['age',18])  # {'name':'xie','age':18}

字典取值

# 字典通过索引或者get方法取值
info = {'name':'xie','age':18,'gender':'male'}
print(info['name'])  # xie 索引取值，如果字典中没有name键会报错
print(info.get('name'))  # xie get方法取值，如未找到name键返回None
print(info.get('name','san'))  # san 第二个参数在未有name字段时返回

字典添修元素

info = {'name':'xie'}
# 通过key添加元素，如果key字段存在修改对应的值
info['age'] = 18  # {'name':'xie','age':18}
# update更新键值对，如果字段不存在新增
info.update({'name':'san'})   # {'name':'san','age':18}

字典删除元素

info = {'name':'xie','age':18}
del info['age']  # {'name':'xie'}
print(info.pop('age'))  # 18 返回弹出的值，key不存在会报错
print(info.popitem())  # ('age',18) 键值对以元组形式返回

字典成员运算

info = {'name':'xie','age':18}
# 字典只暴露key
print('name' in info)  # True
print('xie' in info)  # False

字典键值对个数

info = {'name':'xie','age':18}
# len方法返回字典键值对个数
print(len(info))  # 2

字典其他方法

info = {'name':'xie','age':18,'gender':'male'}
# info.keys()、info.values()、info.items()
# keys values 返回迭代对象可通过for循环取得所有key或value
# items 返回迭代对象可通过for循环取得以元组形式的键值对

# 快速生成字典方法 fromkeys
new_dict = {}.fromkeys(['k1','k2','k3'],'v')
print(new_dict)  # {'k1': 'v', 'k2': 'v', 'k3': 'v'}

# setdefault方法新增值，如果字段存在返回对应的值
dict1 = {'name':'xie'}
dict1.setdefault('age',18)  # {'name':'xie','age':18}

元组类型tuple

元组类型转化

# 能够for循环遍历的都能转化为元组
t1 = tuple(1,'xie')  # (1,'xie')
t2 = tuple([2,3])  # (2,3)
t3 = tuple('hello')  # ('h','e','l','l','o')
t3 = tuple({'name':'xie','age':18})  # ('name',18)

元组取值

t1 = (1,2,3)
# 元组支持索引取值，切片
print(t1[0])  # 1
print(t1[1:])  # (2,3)

元组元素个数

t1 = (1,2,3)
print(len(t1))  # 3

集合类型set

集合去重

list = [1,4,2,2,1]
print(set(list))  # {1, 2, 4}  集合无序

集合关系运算

friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
# & 表示两个集合的并集
print(friends1 & friends2)  # {'eg', 'jason'}
# | 表示两个集合的交集
print(friends1 | friends2)  # {'zero', 'eg', 'Jy', 'kevin', 'ricky', 'jason'}
# - 表示两个集合的差集
# friends1独有的朋友
print(friends1 - friends2) # {'kevin', 'zero'}
# friends2独有的朋友
print(friends2 - friends1)  # {'ricky', 'Jy'}
# ^ 表示两个集合的对称差集
print(friends1 ^ friends2)  # {'Jy', 'zero', 'ricky', 'kevin'}