python数据类型的内置方法

目录

• int整型
• float浮点型
• str字符串
  • 基本方法
  • 移除首尾指定字符
  • 字母大小写相关操作
  • 判断字符串的开头或结尾是否是指定字符
  • 字符串特殊的输出方法
  • 拼接字符串
  • 替换指定字符
  • 判断是否是纯数字
  • 查找指定字符对应的索引值
  • 文本位置改变
  • 特殊符号
  • 首字母大写与大小写翻转
• 列表的内置方法
  • 类型转换
  • 索引与切片
  • 统计列表长度
  • 成员运算
  • 列表添加元素
  • 删除元素
  • 修改元素
  • 排序
  • 列表翻转
  • 比较运算
  • 统计某个元素出现的次数
  • 清空列表
• 字典的内置方法
  • 类型转换
  • 字典取值
  • 修改值
  • 计算字典长度
  • 成员运算
  • 删除元素
  • 获取元素
  • 更新字典
  • 快速生成字典
  • setdefault()方法
• 元组的内置方法
  • 类型转换
  • 索引与切片操作
  • 统计长度
  • 成员运算
  • 统计某个元素出现的次数
  • 元组特性
• 集合内置方法
  • 类型转换
  • 集合去重
  • 关系运算

int整型

1. 类型转换

# int()可以将字符串类型转换成整型
# 但是字符串不能是带有小数点的数字或文本
res = int('123')
print(res, type(res))
'''
   输出结果
   123 <class 'int'>
   '''

2. 进制数转换

# 将其他进制转换成十进制
# 二进制为0b开头
print(bin(100))  # 输出结果:0b1100100
# 八进制为0o开头
print(oct(100))  # 输出结果:0o144
# 十六进制为0x开头
print(hex(100))  # 输出结果:0x64 

# 将十进制转换成其他进制
# 使用int(a, b) 
# a为字符串类型，填写内容；b为整型，填写需要转成的进制
print(int('1100100', 2))  # 输出结果:100
print(int('144', 8))  # 输出结果:100
print(int('64', 16))  # 输出结果:100

float浮点型

1. 类型转换

# float()可以将整型或者数字字符串转换成浮点型
res = float('11.11')
print(res, type(res))  # 输出结果：11.11 <class 'float'>
res = float('11')  
print(res, type(res))  # 输出结果：11.0 <class 'float'>
res = float(11)  
print(res, type(res))  # 输出结果：11.0 <class 'float'>

str字符串

基本方法

1. 类型转换

# str()可以转换所有的基本数据类型
print(str(11), type(str(11)))
print(str(11.11), type(str(11.11)))
print(str([1, 2, 3, 4]), type(str([1, 2, 3, 4])))
print(str({'name': 'jason'}), type(str({'name': 'jason'})))
print(str((1, 2, 3, 4)), type(str((1, 2, 3, 4))))
print(str({1, 2, 3, 4}), type(str({1, 2, 3, 4})))
print(str(True), type(str(True)))

输出结果：

2. 索引取值

s = 'hello,world'
# 字符串的索引取值与列表一样，相当于是把字符串中的内容一个个字符拆分开存入列表中
print(s[0])  # 输出结果：h
print(s[1])  # 输出结果：e

3. 切片操作

# 在索引取值的基础上，我们可以用切片实现取出部分字符
s = 'hello,world'
print(s[1:4])  # 输出结果：ell
# 这里的1代表从s[1]:'e'开始，4代表到s[3]:'l'结束，取不到s[4]

4. 步长

# 在切片操作的基础上，我们可以用切片中的步长来跳过一些字符
s = 'hello,world'
print(s[1:8:2])  # 输出结果：el,o
# 这里的1代表从s[1]:'e'开始，8代表到s[7]:'o'结束，2代表索引加2
# 也就是取出了s[1]:'e',s[3]:'l',s[5]:',',s[7]:'o'

5. 切片拓展

# 如果切片里面的数值是负数，代表从右开始数
s = 'hello,world'
print(s[-1])  # 输出结果：d

# 如果步长为负数，代表从右开始取值
print(s[-1:-8:-1])  # 输出结果：drwo

6. 统计字符串长度

# len()用来计算字符串的长度
print(len('ab cd'))  # 输出结果：5

7. 成员运算

# in可以来判断某个字符串是否被另一个字符串所包含
print('ll' in 'hello,world')  # 输出结果：True

8. 按照指定字符切割字符串

# split()用于按照指定字符切割字符串,并以列表形式存储
data = 'tom|1111|eat'
print(data.split('|'))  # 输出结果：['tom', '1111', 'eat']

# 切割字符串时也可以指定切割数量
print(data.split('|', 1))  # 输出结果：['tom', '1111|eat']

# 也可以用rsplit()选择从右边开切
print(data.rsplit('|', 1))  # 输出结果：['tom|1111', 'eat']

移除首尾指定字符

# 在字符串类型中，我们可以使用strip()来去除首尾指定字符
s1 = '  jason  '
# strip()默认去除空格
print(s1.strip())  # 输出结果：jason

s2 = '|||jason||'
print(s2.strip('|'))  # 输出结果：jason

# 如果想要只去除首部字符或是尾部字符，可以使用lstrip(), rstrip()

# 去除尾部
print(s2.rstrip('|'))  # 输出结果：|||jason
# 去除首部
print(s2.lstrip('|'))  # 输出结果：jason||

字母大小写相关操作

# lower()可以将字母全变成小写，upper()可以将字母全变成大写
s = 'Abc6DeFF'
print(s.lower())  # 输出结果：abc6deff
print(s.upper())  # 输出结果：ABC6DEFF

# islower()可以判断字符串是否全小写，isupper()可以判断字符串是否全大写，返回布尔值
s1 = 'awdjklh123asd'
print(s1.islower())  # 输出结果: True
print(s1.isupper())  # 输出结果: False

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

s = 'my name is tom'

# startswith()用于判断字符串的开头是否是指定字符,返回布尔值
print(s.startswith('my'))  # 输出结果：True
print(s.startswith('tom'))  # 输出结果：False

# endswith()用于判断字符串的结尾是否是指定字符,返回布尔值
print(s.endswith('my'))  # 输出结果：False
print(s.endswith('tom'))  # 输出结果：True

字符串特殊的输出方法

# 字符串中的format有四种输出方法

# 方法一：跟占位符一样，只不过使用的是{}占位
print('jason, {}, knight, jkl, {}'.format('tom', 18))  # 输出结果：jason, tom, knight, jkl, 18

# 方法二：索引取值，可以反复使用
print('jason, {0}, {1}, knight, jkl, {1}'.format('tom', 18))  # 输出结果：jason, tom, 18, knight, jkl, 18

# 方法三：指名道姓的方式取值，可以反复使用
print('jason, {name}, {age}, knight, jkl, {age}'.format(name='tom', age=18))  # 输出结果：jason, tom, 18, knight, jkl, 18

# 方法四：根据已有变量取值(在输出字符串的外边添加个f)，可以反复使用
name = 'tom'
age = 18
print(f'jason, {name}, {age}, knight, jkl, {age}')  # 输出结果：jason, tom, 18, knight, jkl, 18

拼接字符串

s1 = 'abcde'
s2 = 'qwer'

# 最普通的拼接方法，直接相加，或乘个整数，但如果字符串很大的话，效率较低
print(s1 + s2)  # 输出结果：abcdeqwer
print(s2 * 2)  # 输出结果：qwerqwer

# 使用join方法拼接
print('|'.join(s1))  #输出结果：a|b|c|d|e

# 如果括号内是列表等数据类型，那么列表内的元素必须是字符串类型，否则报错
s3 = ['tom', 'jason', 'tony']
s4 = [12, 'jason', 'tony']
print('@'.join(s3))  # 输出结果：tom@jason@tony
print('@'.join(s4))  # 会报错

替换指定字符

# replace()可以替换字符串中的指定字符
s = 'aabbccddddee'
print(s.replace('b', '1'))  # 输出结果：aa11ccddddee

# 第三个变量代表需要替换的个数
print(s.replace('d', '1', 2))  # 输出结果：aabbcc11ddee

判断是否是纯数字

# isdigit()用于判断字符串中是否为纯数字
s1 = '85642'
s2 = '564asa54'
print(s1.isdigit())  # 输出结果：True
print(s2.isdigit())  # 输出结果：False

查找指定字符对应的索引值

# 用find()查找索引值
s1 = 'my name is jackeylove'
print(s1.find('name'))  # 输出结果：3
# 第二个变量代表起始位置，第三个变量代表结束位置，输出-1代表没找到
print(s1.find('my', 2, 5))  # 输出结果：-1

# 用index()查找索引值
print(s1.index('name'))  # 输出结果：3
# 第二个变量代表起始位置，第三个变量代表结束位置，没找到会报错
print(s1.index('my', 2, 5))  # 会报错

文本位置改变

name = 'tom'

# 方法内变量可以有2个值，第一个代表长度，第二个代表长度不够时用于补充的字符(只能是单字符)
print(name.center(10, '@'))  # 输出结果：@@@tom@@@@
print(name.rjust(10, '-'))  # 输出结果：-------tom
print(name.ljust(10, '*'))  # 输出结果：tom*******

# 方法内变量只有一个值，表示长度，不够长度用0补充
print(name.zfill(10))  # 输出结果：0000000tom

特殊符号

# 特殊符号就是反斜杠与英文字母的组合
print('这里换行\n被换行了')
'''
输出结果：
这里换行
被换行了
'''
# 如果要输出特殊符号，可以在字符串前边加一个r
print(r'这里换行\n被换行了')  # 输出结果：这里换行\n被换行了

首字母大写与大小写翻转

s = 'my name is tom'

# 字符串第一个字母大写，capitalize()
print(s.capitalize())  # 输出结果：My name is tom

# 每个单词首字母大写，title()
print(s.title())  # 输出结果：My Name Is Tom

# 大小写翻转，swapcase()
print(s.swapcase())  # 输出结果：MY NAME IS TOM
print('AbCd'.swapcase())  # 输出结果：aBcD

列表的内置方法

类型转换

# list()可以将除整型、浮点型、布尔值以外的类型转换成列表
print(list('jason'))  # 输出结果：['j', 'a', 's', 'o', 'n']
print(list({'name': 'jason', 'pwd': 123}))  # 输出结果：['name', 'pwd']
print(list((11, 22, 33, 44, 55)))  # 输出结果：[11, 22, 33, 44, 55]
print(list({1, 2, 3, 4, 5}))  # 输出结果：[1, 2, 3, 4, 5]

# ps:所有支持for循环的数据类型均可转换成列表

索引与切片

name_list = ['jason', 'tom', 123, 'abc']

# 索引取值
print(name_list[2])  # 输出结果：123
print(name_list[-1])  # 输出结果：abc

# 切片操作
print(name_list[1:3])  # 输出结果：['tom', 123]
print(name_list[-4:-2])  # 输出结果：['jason', 'tom']

# 切片操作之步长
print(name_list[::2])  # 输出结果：['jason', 123]
print(name_list[3:1:-1])  # 输出结果：['abc', 123]

统计列表长度

# len()用来统计长度
name_list = ['jason', 'tom', 123, 'abc']
print(len(name_list))  # 输出结果：4

成员运算

# 成员运算
name_list = ['jason', 'tom', 123, 'abc']
print('j' in name_list)  # 输出结果：False
print('jason' in name_list)  # 输出结果：True

列表添加元素

# 尾部添加'单个'元素，append()
name_list = ['jason', 'tom']
name_list.append('tony')
print(name_list)  # 输出结果：['jason', 'tom', 'tony']
name_list.append([1, 2, 3])
print(name_list)  # 输出结果：['jason', 'tom', 'tony', [1, 2, 3]]

# 指定位置添加'单个'元素，insert()
name_list = ['jason', 'tom']
name_list.insert(1, 'tony')  
print(name_list)  # 输出结果：['jason', 'tony', 'tom']
name_list.insert(1, [1, 2, 3])  
print(name_list)  # 输出结果：['jason', [1, 2, 3], 'tony', 'tom']

# 合并列表，extend()
name_list = ['jason', 'tom']
name_list.extend([1, 2, 3])
print(name_list)  # 输出结果：['jason', 'tom', 1, 2, 3]

删除元素

# del + 列表索引删除指定索引的值
l = ['jason', 'tom', 'tony', 12]
del l[1]
print(l)  # 输出结果：['jason', 'tony', 12]

# remove()指名道姓删除元素
l = ['jason', 'tom', 'tony', 12]
l.remove('tom')
print(l)  # 输出结果：['jason', 'tony', 12]

# pop()默认弹出尾部元素
l = ['jason', 'tom', 'tony', 12]
print(l.pop())  # 输出结果：12
print(l)  # 输出结果：['jason', 'tom', 'tony']

# 或按索引弹出元素
l = ['jason', 'tom', 'tony', 12]
print(l.pop(2))  # 输出结果：tony
print(l)  # 输出结果：['jason', 'tom', 12]

修改元素

# 直接按索引修改值
l = ['jason', 'tom', 'tony', 12]
l[1] = 'abc'
print(l)  # 输出结果：['jason', 'abc', 'tony', 12]

PS：修改列表内部元素时，列表的内存地址不会变，但是内部元素的内存地址会改变。

排序

# sort()可以用于列表排序，默认升序
l = [5, 4, 8, 3, 2, 9, 7]
l.sort()
print(l)  # 输出结果：[2, 3, 4, 5, 7, 8, 9]

l = [5, 4, 8, 3, 2, 9, 7]
l.sort(reverse=True)
print(l)  # 输出结果：[9, 8, 7, 5, 4, 3, 2]

列表翻转

# reverse()可以用于列表的翻转
l = [1, 2, 3, 4, 5]
l.reverse()
print(l)  # 输出结果：[5, 4, 3, 2, 1]

比较运算

# 两个列表进行比较时，只会比较对应索引位置的元素

# 当列表长度和值都相等时，才会相等
l1 = [3, 2, 33]
l2 = [3, 2, 33]
print(l1 == l2)  # 输出结果：True

# 当列表第一个值不相等时，直接比较第一个值并输出结果
l1 = [11, 2, 33, 4, 55]
l2 = [3, 2, 33]
print(l1 > l2)  # 输出结果：True

# 当列表第一个值相等时，比较下一个值，如果还相等，继续下一个值，直到不同并输出结果
l1 = [11, 2, 4, 4, 55]
l2 = [11, 2, 11, 6]
print(l1 > l2)  # 输出结果：False

# 当有两个不同长度列表，短列表的值都与长列表相等，则长列表大
l1 = [11, 2, 4, 1]
l2 = [11, 2, 4]
print(l1 > l2)  # 输出结果：True

统计某个元素出现的次数

# 统计出现次数使用count()
l = [1, 2, 1, 5, 1, 4, 6, 7, 1]
print(l.count(1))  # 输出结果：4

清空列表

# clear()
l = [1, 5, 'asd']
l.clear()
print(l)  # 输出结果：[]

字典的内置方法

类型转换

# dict()用于转换成字典
print(dict(name='tom', age=18))  # 输出结果：{'name': 'tom', 'age': 18}

字典取值

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}

# 按key取值，这种方式最简单，但是如果找不到key所对应的值会报错，所以不推荐
print(d1['name'])  # 输出结果：jason
print(d1['xxx'])  # 报错

# 用get()方法，推荐使用
print(d1.get('name'))  # 输出结果：jason
print(d1.get('xxx'))  # 输出结果：None
# get()方法可以填两个变量，第一个填key，第二个填写如果key不存在则会返回的值
print(d1.get('xxx', '不存在'))  # 输出结果：不存在

修改值

ps:字典是可变类型

# 直接用key索引直接赋值修改
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
d1['age'] = 20
print(d1['age'])  # 输出结果：20

# 如果赋值时key不存在于字典内，则会新增值
d1['sex'] = 'boy'
print(d1)  # 输出结果：{'name': 'jason', 'age': 20, 'hobbies': ['play game', 'basketball'], 'sex': 'boy'}

计算字典长度

# len()计算长度，有按照key的数量计算
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print(len(d1))  # 输出结果：3

成员运算

# in 和 not in，只能判断key是否存在，不能判断value
d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
print('name' in d1)  # 输出结果：True

删除元素

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
# del通用方式
del d1['hobbies']
print(d1)  # 输出结果：{'name': 'jason', 'age': 18}

# pop()，括号内要有key值
print(d1.pop('age'))  # 输出结果：18

获取元素

d1 = {
    'name': 'jason',
    'age': 18,
    'hobbies': ['play game', 'basketball']
}
# 以下方法获取到的值都可以看作列表
# 获取所有的key
for key in d1.keys():
    print(key)

# 获取所有的value
for value in d1.values():
    print(value)

# 获取所有的key:value
for item in d1.items():
    print(item)

更新字典

# update() 可以同时更新字典中多个数据
d = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
# key存在则修改 key不存在则新增
d.update({'k1':'tom', 'k4':'aaa'})
print(d)  # 输出结果：{'k1': 'tom', 'k2': 'Tony', 'k3': 'JY', 'k4': 'aaa'}

快速生成字典

# fromkeys()可以快速生成字典,但key都会对应同一个value
d = dict.fromkeys(['k1', 'k2', 'k3'], [11])
print(d)  # 输出结果：{'k1': [11], 'k2': [11], 'k3': [11]}

d['k1'].append(22)
print(d)  # 输出结果：{'k1': [11, 22], 'k2': [11, 22], 'k3': [11, 22]}

setdefault()方法

# key不存在则新增key:value，并且返回是新增的value
d = {'k1': 111, 'k2': 222}
print(d.setdefault('k3', 333))  # 输出结果：333
print(d)  # 输出结果：{'k1': 111, 'k2': 222, 'k3': 333}

# key存在，则返回对应的value，不做修改
d = {'k1': 111, 'k2': 222}
print(d.setdefault('k1', '嘿嘿嘿'))    # 输出结果：111
print(d)  # 输出结果：{'k1': 111, 'k2': 222}

元组的内置方法

类型转换

# tuple()和list()一样
# tuple()可以将除整型、浮点型、布尔值以外的类型转换成元组
print(tuple('jason'))  # 输出结果：('j', 'a', 's', 'o', 'n')
print(tuple({'name': 'jason', 'pwd': 123}))  # 输出结果：('name', 'pwd')
print(tuple((11, 22, 33, 44, 55)))  # 输出结果：(11, 22, 33, 44, 55)
print(tuple({1, 2, 3, 4, 5}))  # 输出结果：(1, 2, 3, 4, 5)

索引与切片操作

t = ('jason', 'tom', 123, 'abc')

# 索引取值
print(t[2])  # 输出结果：123
print(t[-1])  # 输出结果：abc

# 切片操作
print(t[1:3])  # 输出结果：('tom', 123)
print(t[-4:-2])  # 输出结果：('jason', 'tom')

# 切片操作之步长
print(t[::2])  # 输出结果：('jason', 123)
print(t[3:1:-1])  # 输出结果：('abc', 123)

统计长度

# len()用来统计长度
t = ('jason', 'tom', 123, 'abc')
print(len(t))  # 输出结果：4

成员运算

# 成员运算
t = ('jason', 'tom', 123, 'abc')
print('j' in t)  # 输出结果：False
print('jason' in t)  # 输出结果：True

统计某个元素出现的次数

# 统计出现次数使用count()
l = (1, 2, 1, 5, 1, 4, 6, 7, 1)
print(l.count(1))  # 输出结果：4

元组特性

# 当元组内只有一个值时，数据类型会是括号内的数据类型
t2 = (11)
print(type(t2))  # 输出结果：<class 'int'>
t2 = (11.11)
print(type(t2))  # 输出结果：<class 'float'>
t2 = ('jason')
print(type(t2))  # 输出结果：<class 'str'>

# 所以我们在定义时会在值的后面加一个逗号
t2 = (11,)
print(type(t2))  # 输出结果：<class 'tuple'>
t2 = (11.11,)
print(type(t2))  # 输出结果：<class 'tuple'>
t2 = ('jason',)
print(type(t2))  # 输出结果：<class 'tuple'>

# 无法修改元组内的字符串、整型、浮点型、布尔值
# 但可以修改元素为可变类型的值
tt = (11, 22, 33, [11, 22])
tt[-1][0] = 33
print(tt)  # 输出结果：(11, 22, 33, [33, 22])

集合内置方法

集合的用处比起其他的数据类型较少，主要还是用于去重和关系运算

类型转换

# set()和list()一样
# set()可以将除整型、浮点型、布尔值以外的类型转换成集合
print(set('jason'))  # 输出结果：{'o', 'n', 's', 'j', 'a'}
print(set({'name': 'jason', 'pwd': 123}))  # 输出结果：{'name', 'pwd'}
print(set((11, 22, 33, 44, 55)))  # 输出结果：{33, 11, 44, 22, 55}
print(set({1, 2, 3, 4, 5}))  # 输出结果：{1, 2, 3, 4, 5}

集合去重

因为集合内不能出现重复的元素，自带去重特性，所以集合可以用于去重

# 自带去重
s = {1,1,1,1,1,2,2,2,2,2,1,2,3,2,2,1,2,3,2,3,4,3,2,3}
print(s)  # 输出结果：{1, 2, 3, 4}

# 列表去重
l = ['a', 'b', 1, 'a', 'a']
s = set(l)
l = list(s)
print(l)  # 输出结果：['a', 1, 'b']

"""列表如果用转集合的方式去重，返回的值不会是列表原来的顺序"""

关系运算

# 判断两个群体内的差异，如:共同好友、共同关注、共同点赞

f1 = {'jason', 'kevin', 'tony', 'jerry'}
f2 = {'jason', 'tom', 'jerry', 'jack'}
# 查询共同元素
print(f1 & f2)  # 输出结果：{'jason', 'jerry'}
# 查询f1中f2没有的元素
print(f1 - f2)  # 输出结果：{'tony', 'kevin'}
# 查询f1和f2所有元素
print(f1 | f2)  # 输出结果：{'jerry', 'kevin', 'jack', 'tom', 'tony', 'jason'}
# 查询各自的独立元素
print(f1 ^ f2)  # 输出结果：{'jack', 'kevin', 'tom', 'tony'}