数据类型的内置方法
目录
一.数据类型的内置方法
数据类型的内置方法就是：数据类型自带的操作方法或功能
调用数据类型的内置方法句式为：句点符
数据类型.方法名()
eg:
name = '张三'
1) 变量名.字符串的内置方法()
2) 数据值.字符串的内置方法()
1.整型相关操作方法
1)类型转换
int(待转换的数据)
1) 浮点型可以转整型,'只要小数点前面的,不做四舍五入'
print(int(11.11)) # 11
2) 字符串可以转整型,'但是字符串内部必须是【整数】才可以'
print(int('11')) # 11
3) 布尔值的使用
print(int(True)) # 1
print(int(False)) # 0
4) 其他类型转换会报错
2)进制数转换
【十进制转其他进制】:
# 十 >> 二
print(bin(100)) # 0b1100100
# 十 >> 八
print(oct(100)) # 0o144
# 十 >> 十六
print(hex(100)) # 0x64
'''
0b 二进制数的标识
0o 八进制数的标识
0x 十六进制数的标识
数字开头没有任何标识的就是十进制
'''
【其他进制转十进制】：
#会自动识别转换
print(int(0b1100100)) # 100
print(int(0o144)) # 100
print(int(0x64)) # 100
#人为主动转换进制数
print(int('0b1100100',2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100
2.浮点型相关操作方法
1)类型转换
float(待转换的数据)
1) 整数型可以转浮点型,'在数字后会跟一个小数点'
print(float(11)) # 11.0
2) 字符串可以转浮点型,'但是字符串内部必须是数字(整、浮点)才可以'
print(int('11.11')) # 11.0
3) 布尔值的使用
print(float(True)) # 1.0
print(float(False)) # 0.0
4) 其他类型转换会报错
2)数学运算易出错
a = 23.00
b = 1.2
c = a * b
print(c) # 27.599999999999998
'''
由以上举例得出：python对数字运算精确度很低,容易出错！
如需要精准的计算需借助其他模块！
'''
3.字符串相关操作方法
字符串在调用内置方法后会产生新的值 具体需看【可变类型与不可变类型】
1)类型转换
str(待转换的数据)
#1.所有数据类型都可以转换成字符串
str(123)
str(True)
str({'name':'张三'})
...
#2.给所有数据类型前后加引号也可以转换成字符串
2)常用内置方法
1.索引取值(单个字符)
'''
1.索引值是从0开始(顾头不顾尾)
2.超出索引范围会直接报错
3.索引可跟负数,[-1]为取最后一个
'''
s1 = 'abcde'
print(s1[0]) # a
print(s1[-1]) # e
2.切片取值(多个字符)
s1 = 'abcde'
print(s1[:]) # abcde 取所有值
print(s1[:3]) # abc 取索引0~索引2的值
print(s1[1:3]) # bc 取索引1~索引2的值
print(s1[-2:-1]) # d 取倒数第二(包含)~倒数第一(不包含)的值
3.修改切片间隔
s1 = 'abcde'
print(s1[0:5:1]) # abcde 取索引0~索引4的值且间隔1
print(s1[0:5:2]) # ace 取索引0~索引4的值且间隔2
print(s1[::2]) # ace 取所有值且间隔2
4.统计字符个数
len()统计字符个数
s1 = 'abcde'
print(len(s1)) # 5
5.移除首位指定字符
strip()常用于移除空格
name = '$张三$'
1)移除首尾所有指定字符
print(name.strip('$')) # 张三
2)移除首指定字符
print(name.lstrip('$')) # 张三$
3)移除尾指定字符
print(name.rstrip('$')) # $张三
4)括号内不写默认移除空格
print(name.strip()) # 张三
'常用于获取用户输入移除用户不小心打的空格'
6.切割字符串中指定字符
split('')当字符串中有多个重复字符分割不同数据时，可切割该指定字符以列表形式显示。
a = 'aaa|bbb|ccc'
1)切割所有指定字符
print(a.split('|')) # ['aaa', 'bbb', 'ccc']
#注意：此处可以用【解压赋值】依次赋值给不同变量名！
2)从左往右切指定个数
print(a.split('|',maxsplit=1)) #['aaa', 'bbb|ccc']
3)从右往左切指定个数
print(a.rsplit('|',maxsplit=1)) #['aaa|bbb', 'ccc']
7.字符串大小写相关
upper() lower() isupper() islower()常用于验证码
a = 'aBcDe'
1)将字符串全部转成大小写
print(a.upper()) # ABCDE
print(a.lower()) # abcde
2)判断字符串是否为纯大写或小写(True/False)
print('AAA'.isupper())
print('aaa'.islower())
8.字符串格式化输出
方式1)：等价于%s 没优势
lx = '我的名字是{},我的年龄是{}'
print(lx.format('张三',18))
#结果为：我的名字是张三,我的年龄是18
方式2)：支持索引取值，可以重复使用
lx = '我的名字是{0},我的年龄是{1}{0}{1}'
print(lx.format('张三',18))
#结果为：我的名字是张三,我的年龄是18张三18
方式3)：支持关键字取值(按K取值),可重复使用
lx = '名字是{name}{name}年龄是{age}'
print(lx.format(name='张三',age=18))
#结果为：名字是张三张三年龄是18
方法4)：最常用！！！*****************
name = '张三'
age = 18
print(f'名字是{name}年龄是{age}{age}')
#结果为：名字是张三年龄是1818
9.判断字符串中是否是纯数字
isdigit()判断是否为纯数字。常用于获取用户输入校验等
print('123'.isdigit()) # True
print('123a'.isdigit()) # False
3)其他内置方法
1.替换字符串中指定内容
replace()括号内写被 替换的字符 与 替换的字符
a='a a a b b b'
1)从左往右替换所有指定内容
print(a.replace('a','c'))
#结果为：c c c b b b
2)从左往右替换指定个数的内容
print(a.replace('a','c',1))
#结果为：c a a b b b
2.字符串的拼接
''.join([a,b])引号中可以加中间拼接的字符,不写则不添加，a与b分别是要拼接的数据值
a='张'
b='三'
方式1)：直接用+号,但是易占用较多内存
print(a+b) # 张三
方式2)：直接*该字符串实现拼接多个
print(a*2) # 张张
方式3)：建议使用join方法！切可以在拼接中插入指定字符
print(''.join([a,b])) # 张三
print('|'.join([a,b])) # 张|三
3.统计指定字符出现次数
count()统计个数
a='aabcdef'
print(a.count('a')) #2
4.判断字符串开头或结尾
startswith()判断开头是否为某个值
endswith()判断结尾是否为某个值
a='hello'
#判开头是否是'he'
print(a.startswith('he')) # True
#判断结尾是否是'lo'
print(a.endswith('lo')) # True
5.查找某个字符对应索引值
index()存在则返回索引值,只会返回左边数第一个，不存在则报错
find()存在则返回索引值，不存在则报错
a='helloh'
#获取'h'的索引值 不存在则报错
print(a.index('h')) # 0
#获取'a'的索引值 不存在则返回-1
print(a.find('a')) # -1
6.正文相关转换首字母大写
title()将字符串中所有单词的首字母大写
capitalize()将字符串第一个字母大写
a = 'my name is zhangsan'
1)将所有单词的首字母大写
print(a.title())
#结果为：My Name Is Zhangsan
2)将字符串第一个字母大写
print(a.capitalize())
#结果为：My name is zhangsan
4.列表相关操作方法
列表在调用内置方法后会修改自身具体需看【可变类型与不可变类型】
1)类型转换
list(其他数据类型)
能够被for循环的数据类型都可以转成列表
支持for循环的数据类型有：列表、字符串、字典、元组、集合
字符串、字典、元组、集合：
print(list('123')) # ['1', '2', '3']
print(list({'name':'张三','age':'18'})) # ['name', 'age']
print(list((1,2,3))) # [1, 2, 3]
print(list({1,2,3})) # [1, 2, 3]
2)常用内置方法
1.索引取值(单个数据值)
'''
1.索引值是从0开始(顾头不顾尾)
2.超出索引范围会直接报错
3.索引可跟负数,[-1]为取最后一个
'''
l1 = [1, 2, 3]
print(l1[0]) # 1
print(l1[-1]) # 3
2.切片取值(多个数据值)
l1 = [1,2,3,4,5]
print(l1[:]) # [1,2,3,4,5] 取所有值
print(l1[:3]) # [1,2,3] 取索引0~索引2的值
print(l1[1:3]) # [2,3] 取索引1~索引2的值
print(l1[-2:-1]) # [4] 取倒数第二(包含)~倒数第一(不包含)的值
3.修改切片间隔
l1 = [1,2,3,4,5]
print(l1[0:5:1]) # [1,2,3,4,5] 取索引0~索引4的值且间隔1
print(l1[0:5:2]) # [1,3,5] 取索引0~索引4的值且间隔2
print(l1[::2]) # [1,3,5] 取所有值且间隔2
4.统计列表数据值个数
len()统计数据值个数
l1 = [1,2,3,4,5]
print(len(l1)) # 5
5.修改数据值
l1 = [1,2,3,4,5]
l1[0] = 'z'
print(l1)
#结果为：['z',2,3,4,5]
6.添加数据值
append() 尾部追加
insert()括号内跟索引 与 要插入的数据值
extend()合并两个列表
1)尾部追加数据值
l1 = [1, 2, 3, 4, 5]
l1.append('zzz')
print(l1)
#结果为：[1, 2, 3, 4, 5, 'zzz']
2)任意位置插入数据值(在索引几的位置插入什么数据)
l1 = [1, 2, 3, 4, 5]
l1.insert(1,'zzz')
print(l1)
#结果为：[1, 'zzz', 2, 3, 4, 5]
3)扩展列表、合并列表
l1=[1,2,3]
l2=[4,5,6]
方式一：不建议使用
print(l1+l2)
#结果为：[1,2,3,4,5,6]
方式二：底层是用for+append实现的
l1.extend(l2)
print(l1)
#结果为：[1,2,3,4,5,6]
7.删除数据值
remove()删除指定数据值
pop()取出后可以赋给一个变量名,然后删除
l1 = [1,2,3,4,5]
1)通用删除 del：(删除某个索引对应的值)
del l1[0]
print(l1)
#结果为：[2, 3, 4, 5]
2)指定删除 remove：(彻底删除指定的数据值)
l1.remove(2)
print(l1)
#结果为：[1, 3, 4, 5]
3)取出后删除 pop：(可以把取出的值赋值给一个变量)
'括号内不写默认最后一个,0代表第一个,1代表第二个'
l1.pop()
print(l1)
#结果为：[1, 2, 3, 4]
a = l1.pop()
print(a)
#结果为：5
pop常用于观展人数中，xxx退出观战
8.查看数据值对应索引值
index()查看某个数据值的索引值
l1=[1,2,3,4]
print(l1.index(1))
#结果为：0
9.统计某个数据值出现的次数
count()计数统计数据值出现的次数
l1=[1,1,2,3,4,5]
print(l1.count(1))
#结果为：2
10.数据值排序
sort()升序
sort(reverse=True)降序
l1=[4,2,5,1,2,3]
1)升序：
l1.sort()
print(l1)
#结果为：[1, 2, 2, 3, 4, 5]
2)降序：
l1.sort(reverse=True)
print(l1)
#结果为：[5, 4, 3, 2, 2, 1]
11.反转列表数据值顺序
reverse()将列表反转
不等同于降序排序！
l1=[4,2,5,1,2,3]
l1.reverse()
print(l1)
#结果为：[3, 2, 1, 5, 2, 4]
12.两个列表比较
a = [99,11]
b = [11,22,33]
print(a > b)
#结果为：True
l1 = ['a','b']
l2 = ['A','B']
print(l1 > l2)
#结果为True
'''
1.两个列表在比较大小时,是按照索引0来互相比较。
2.不同数据类型之间无法比较
3.a比A大的原因是因为中间涉及到字符编码。a=97 A=65
'''
5.字典相关操作方法(dict)
1)类型转换
dict(其他数据类型)
字典一般都是直接定义,不类型转换
2)常用内置方法
1.字典取值
.get()常用来取字典中K键的值
【按K取值】 当K键不存在时会报错#不推荐
d = {'name':'张三','age':18}
print(d['name'])
#结果为：张三
print(d['xxx'])
#结果为：会报错
【get取值】 当K键不存在时会返回None#推荐！
d = {'name':'张三','age':18}
print(d.get('name'))
#结果为：张三
print(d.get('xxx'))
#结果为：None
2.修改字典V值
直接按K键=要修改的新数据值
d = {'name':'张三','age':18}
d['name']='李四'
print(d)
#结果为：{'name': '李四', 'age': 18}
3.新增键值对
同修改字典V值：当键存在时修改V值，键不存在新增键值对
d = {'name':'张三','age':18}
d['pwd']=123
print(d)
#结果为：{'name': '张三', 'age': 18, 'pwd': 123}
4.删除数据
del pop都是删除 区别在于pop可以赋值给一个变量名打印出删除掉的数据值
d = {'name':'张三','age':18}
1)del d['name'] #删除name的键值对
2)a = d.pop('name')
print(a)#打印出来的就是删除掉的V值
print(d)#打印出来的就是删除后的列表
5.统计字典中键值对个数
d = {'name':'张三','age':18}
print(len(d))
#结果为：2
6.获取所有 键、值、键值对数据
keys() values() items()组成的结果可支持for循环
d = {'name':'张三','age':18}
d = {'name':'张三','age':18}
获取所有【键】
print(d.keys()) # dict_keys(['name', 'age'])
获取所有【值】
print(d.values()) # dict_values(['jason', 18])
获取所有【键值对】(组成列表套元组形式)
print(d.items()) # dict_items([('name', 'jason'), ('age', 18)])
for k,v in d.items():
print(f'{k}:{v}')
#结果为：
#name：jason
#age：18
7.快速构造字典
dict.fromkeys()
快速生成一个值相同的字典
'第一个列表里的数据值当作键，第二个是公共的数据值(所有键都是该数据值)'
d1=dict.fromkeys(['name','pwd','hobby'],123)
print(d1)
#结果为：{'name': 123, 'pwd': 123, 'hobby': 123} 后期可以再单个修改对应的值数据
笔试题：
res=dict.fromkeys(['name','pwd'],[])
print(res)#{'name': [], 'pwd': []}
res['name'].append('jason')
res['pwd'].append(123)
print(res)#{'name': ['jason', 123], 'pwd': ['jason', 123]}
'当第二个公共数据值是可变类型的 通过任何键调用内置方法去修改值时会影响所有的键'
8.从列表中取出最后的键值对
d={'name':'jason','age':18,'pwd':'123'}
print(d.popitem()) # 也可以赋值给一个变量名,打印变量名
#打印第一次结果为：('pwd', '123')
print(d.popitem())
#打印第二次结果为：('age', 18)
print(d)
#此时打印字典的结果为：{'name': 'jason'}
当没有键值对可打印时会报错
6.元组相关操作方法(tuple)
1)类型转换
支持for循环的数据类型都可以转为元组：列表、字典、元组、集合
print(tuple([1,2,3])) # (1,2,3)
print(tuple({'name':'张'})) # ('name',)
print(tuple((1,2,3))) # (1,2,3)
print(tuple({1,2,3})) # (1,2,3)
2)常用内置方法
注意：
1.元组内如果只有一个数据值,结尾要跟逗号
t1 = () #空元组
t1 = (1,)
2.元组内索引绑定的内存地址不能被修改#除非是可变类型
t1 = (1, 2, 3, [1, 2])
# t1.append(5) #结果会报错！
t1[-1].append(5)
print(t1) # (1, 2, 3, [1, 2, 5])
3.元组不能新增或删除数据#除非是可变类型
1.索引取值
t1=(1,2,3,4,5)
print(t1[0]) # 1
print(t1[-1]) # 5
2.切片操作
t1=(1,2,3,4,5)
print(t1[:]) # (1,2,3,4,5) 取所有值
print(t1[:3]) # (1,2,3) 取索引0~索引2的值
print(t1[1:3]) # (2,3) 取索引1~索引2的值
print(t1[-3:-1]) # (3,4) 取倒数第二(包含)~倒数第一(不包含)的值
3.切片间隔/方向
t1=(1,2,3,4,5,6)
print(t1[0:5:1]) # (1,2,3,4,5) 取索引0~索引4的值且间隔1
print(t1[0:5:2]) # (1,3,5) 取索引0~索引4的值且间隔2
print(t1[::2]) # (1,3,5) 取所有值且间隔2
print(t1[::-1]) # (6,5,4,3,2,1) 取所有值并改变字符串方向(后进先出)
4.统计数据值个数
t1=(1,2,3,4,5,6)
print(len(t1)) # 6
5.统计某个数据值出现的次数
t1=(1,2,3,4,5,6)
print(t1.count(2)) # 1
6.统计元组内对应索引值
t1=(1,2,3,4,5,6)
print(t1.index(1)) # 0
7.集合相关操作方法(set)
1)类型转换
print(set('abc')) # {'a','b','c'} 字符串
print(set([1,2,3])) # {1, 2, 3} 列表
print(set({'name':'jason'})) # {'name'} 字典
print(set((1,2,3))) # {1, 2, 3} 元组
整型、浮点型、布尔值会报错
注意：
1.集合里的'数据值'必须是不可变类型(整型、浮点型、字符串、元组)
2.集合内是无序的 没有索引概念
3.如果想单独取数据值应该转成列表去取。
2)常用内置方法
一般集合不常用,只在去重、关系运算时才会考虑使用集合。
1.去重
eg：把以下列表去重
l1=[1,2,3,2,1,3]
s1=set(l1) #把该列表转成集合
l1=list(s1) #把该集合再转回列表
print(l1)
#结果为：[1, 2, 3]
'集合的去重是无序的,有时候无法保留原先顺序'
2.关系运算
常用做差异校验
eg：模拟两个人的好友
f1 = {'jason','tony','oscar','jerry'}
f2 = {'kevin','jerry','jason','lili'}
1.求f1和f2的共同好友
print(f1 & f2) #{'jason','jerry'}
2.求是f1单独认识的好友
print(f1 - f2)#{'oscar','tony'}
3.求f1和f2所有的好友
print(f1 | f2)#{'oscar','jason','kevin','lili','tony','jerry'}
4.求f1和f2各自单独认识的好友
print(f1 ^ f2)#{'lili','oscar','tony','kevin'}
5.父集、子集
print(f1 < f2)#false
print(f1 > f2)#false
'集合在做父子比较时是依照谁包含谁来判断'
二.可变类型与不可变类型
| 可变类型 | 不可变类型 |
|---|---|
| 字典、列表、集合 | 字符串、整型、浮点型、元组 |
| 值改变，内存地址不变(改自身) | 值改变，内存地址也变(产生新的结果) |
1.【不可变类型】：
#值改变，内存地址也变(产生新的结果)
s1='$$jason$$'
s1.strip('$')
'由于产生的是新的结果，所以打印原字符串没有变化'
print(s1)
#结果为：$$jason$$
'因为产生了新的结果，所以可以打印出来(可直接打印出来,也可以赋值一个变量名接收后打印)''
print(s1.strip('$'))
#结果为：jason
2.【可变类型】：
#值改变,内存地址不变(改自身)
l1=[11,22,33]
l1.append('z')
'由于改的是自身 所以打印原本的列表就是修改后的列表'
print(l1)
#结果为：[11,22,33,'z']
'因为没有产生新的结果,所以打印出来的是None'
print(l1.append('z'))
#结果为：None
