Python数据类型的内置方法
在日常生活中不同类型的数据具有不同的功能
eg : 表格数据文件具有处理表格的各项功能(透视表 图形化 公式计算)
视频数据文件具有快进 加速等各项功能...
1.整型int
方法在代码中展示出来的效果就是：名字()
1.1类型转换
res = '123' # res为字符串
res = int(res) #强制类型转换为int
'''int在做类型转换的时候 只能转换纯数字'''
1.2 进制数转换
print(bin(100)) # 将十进制的100转换成二进制 0b1100100
print(oct(100)) # 将十进制的100转换成八进制 0o144
print(hex(100)) # 将十进制的100转换成十六进制 0x64
# 0b开头为二进制数 0o开头为八进制数 0x开头为十六进制数
print(int('0b1100100', 2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100
2.浮点型float
类型转换
res = '111.222'
res = float(res)
3.字符串str
3.1类型转换
字符串可以转换任何类型的数据
print(str(111))
print(str(111.222))
print(str([1, 2, 3, 4]))
print(str({'name': 'tony', 'pwd': 199}))
print(str((1, 2, 3, 4)))
print(str(True))
print(str({1, 2, 3, 4}))
3.2基本用法
res = 'hello world!'
3.2.1索引取值
print(res[1]) # e
3.2.2切片操作 顾头不顾尾
print(res[1:4]) # ell
3.2.3步长操作
print(res[1:10:2]) # el ol (隔一位取值)
3.2.4索引支持负数
print(res[-1]) # ! 最后一位
print(res[-5:-1]) # orld 顾头不顾尾
print(res[-5：-1:-1]) # 方向冲突不执行 （坐标系原理）
3.2.5统计字符串内部字符个数
print(len(res)) # 12
3.2.6移除字符串首尾指定的字符
strip()
name = ' tony '
print(name.strip()) # 输出为tony，默认移除首尾的空格
name = '@@@tony@@@@'
print(name.strip('@')) # tony
print(name.lstrip('@')) # tony@@@@
print(name.rstrip('@')) # @@@tony
name = '@@@tony@@@$@'
print(name.strip('@')) # tony@@@$
print(name.strip('$''@')) # tony
3.2.7按照指定的字符切割字符串
split() 该方法的结果是一个列表
res = 'tony|1234|567'
print(res.split('|')) # ['tony', '1234', '567']
print(res.split('|', maxsplit=1)) # ['tony', '1234|567']
# maxsplit：用于限制切割的次数
print(res.rsplit('|', maxsplit=1)) # ['tony|1234', '567'] 改变切割方向
3.3.大小写
res = 'aBCdEfg123'
# 转全大写
print(res.upper()) # ABCDEFG123
# 转全小写
print(res.lower()) # abcdefg123
"""实际案例:图片验证码忽略大小写
思路:全部转大写或者小写再比对
"""
old_code = 'ASDFasdf'
print('这是返回给用户的图片验证码:%s' % old_code)
new_code = input('用户输入的验证码：').strip()
if new_code.upper() == old_code.upper():
print('succeed')
else:
print('error')
# 判断是否是纯大写 输出的是布尔值
print(res.isupper())
# 判断是否是纯小写 输出的是布尔值
print(res.islower())
3.4.判断字符串是否以指定的字符开头和结尾
s = 'hello world'
# 判断字符串是否以指定的字符开头
print(s.startswith('h')) # True
print(s.startswith('s')) #False
print(s.startswith('hello')) # True
# 判断字符串是否以指定的字符结尾
print(s.endswith('d')) # True
print(s.endswith('asd')) # False
print(s.endswith('world')) # True
3.5 格式化输出
3.5.1.占位符 %s %d
3.5.2.字符串内置方法 format()
3.5.2.1 相当于%s占位符
s = 'my name is {} my age is {}'
print(s2.format('tony',18)) # my name is tony my age is 18
3.5.2.2 大括号内写索引取值刻意打破顺序，并且可以反复使用相同位置的数据
s = 'my name is {0} {1} {0} my age is {1} {0} {0}'
print(s.format('tony', 19)) # my name is tony 19 tony my age is 19 tony tony
3.5.2.3 大括号内写变量名
s = 'my name is {name1} {age1} {age1} my age is {age1} {name1} {age1}'
print(s.format(name1='tony', age1=19))
# my name is tony 19 19 my age is 19 tony 19
3.6.字符串的拼接
3.6.1 字符串的相加
print('hello'+'world')
3.6.2 join方法
l = ['tony', '123', 'tom', 'jake']
print('$'.join(l)) # tony$123$tom$jake
l1 = ['jason', 123, 'tony']
print('$'.join(l1)) # 报错
"""必须是字符串类型，在python中不同数据类型之间无法直接操作"""
3.7.替换字符串中指定的字符
s = 'tony tony is my name i am a boy boy boy'
# 替换字符串中所有的boy>>>girl
print(s.replace('boy', 'girl')) # tony tony is my name i am a girl girl girl
# 替换指定个数的文本
print(s.replace('boy', 'girl', 1)) # tony tony is my name i am a girl boy boy
3.8.判断字符中是否是纯数字
s1 = 'tony1111'
print(s1.isdigit()) # False
s2 = '1111'
print(s2.isdigit()) # True
'''实际案例'''
guess_age = input('请输入猜测的年龄>>>:').strip()
if guess_age.isdigit():
guess_age = int(guess_age)
else:
print('请输入纯数字')
3.9.字体格式相关
s1 = 'my name is jason my age is 18'
# 所有单词首字母大写
print(s1.title()) # My Name Is Jason My Age Is 18
# 所有单词首字母大写
print(s1.capitalize()) # My name is jason my age is 18
s2 = 'AAABBBcccddd'
print(s2.swapcase()) # aaabbbCCCDDD 大小写互换
# 查看指定字符对应的起始索引值 从左往右找到一个就结束
s3 = 'my name is jason sb sb sb somebody sb sb sb sb sone sb sone'
print(s3.find('s')) # 查看指定字符对应的起始索引值 从左往右找到一个就结束得到的值是索引
print(s3.find('sb')) # 查看指定字符对应的起始索引值 从左往右找到一个就结束
print(s3.find('w')) # 找不到返回-1
print(s3.index('w')) # 找不到直接报错
# 统计某个字符出现的次数(记忆)
print(s3.count('sb')) # 8
s4 = 'jason'
print(s4.center(15, '$')) # 居中展示 $$$$$jason$$$$$
print(s8.ljust(15, '&')) # 左对齐 jason&&&&&&&&&&
print(s8.rjust(15, '*')) # 右对齐 **********jason
name = 'tony123'
# 字符串中既可以包含数字也可以包含字母
name.isalnum()
# 字符串中只包含字母
name.isalpha()
4.列表list
4.1.列表的基本方法
列表内一般都会存储相同数据类型的数据
类型转换 数据类型关键字(需要转换的数据)
print(list(123)) # 报错
print(list(123.21)) # 报错
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list({'username': 'jason', 'pwd': 123})) # ['username', 'pwd']
print(list((11, 22, 33))) # [11, 22, 33]
print(list({11, 22, 33})) # [33, 11, 22]
'''list关键字可以将支持for循环的数据类型转换成列表'''
4.2列表修改，添加数据
4.2.1修改值
name_list[0] = 666
print(name_list) # [666, 'kevin', 'tony', 'jack']
4.2.2添加值
4.2.2.1 方式1 尾部追加(将括号内的数据当成一个整体追加到列表末尾)
name_list.append(666)
print(name_list) # ['jason', 'kevin', 'tony', 'jack', 666]
name_list.append([666, 777, 888, 999])
print(name_list) # ['jason', 'kevin', 'tony', 'jack', [666, 777, 888, 999]]
4.2.2.2 方式2 插入元素(将括号内的数据当成一个整体插入到索引指定位置)
name_list.insert(0, 'heiheihei')
print(name_list) # ['heiheihei', 'jason', 'kevin', 'tony', 'jack']
name_list.insert(2, 'hahaha')
print(name_list) # ['jason', 'kevin', 'hahaha', 'tony', 'jack']
name_list.insert(0, [11, 22, 33])
print(name_list)
4.2.2.3 方式3 扩展元素(相当于for循环+append操作)
name_list.extend([111, 222, 333, 444, 555])
print(name_list) # ['jason', 'kevin', 'tony', 'jack', 111, 222, 333, 444, 555]
l1 = [111, 222, 333, 444, 555]
l2 = [1, 2, 3, 4, 5]
for i in l2:
l1.append(i) # 将l2中元素追加到l1末尾
print(l1)
4.3 列表删除数据
4.3.1 方式1 通用删除方式
del name_list[1] # 根据索引直接删除 del是关键字delete缩写
print(name_list) # ['jason', 'tony', 'jack']
4.3.2 方式2 remove() 括号内指定需要移除的元素值
name_list.remove('jason')
print(name_list)
print(name_list.remove('jason')) # None
4.3.3 方式3 pop() 括号内指定需要弹出的元素索引值 括号内如果不写参数则默认弹出列表尾部元素
name_list.pop(1)
print(name_list)
name_list.pop()
print(name_list)
print(name_list.pop()) # jack
5.可变类型与不可变类型
可变类型 >>> 列表
值改变 内存地址不变 修改的是原值
不可变类型 >>> 整型 浮点型 字符串
值改变 内存地址肯定变 其实是产生了新值
s1 = 'my name is jason my age is 18'
print(s1.title()) # 打印出来的是操作之后的结果 # My Name Is Jason My Age Is 18
print(s1) # my name is jason my age is 18
name_list = ['jason', 'kevin', 'tony', 'jack']
print(id(name_list))
print(name_list.remove('jason')) # 打印出来的是None
print(name_list) # ['kevin', 'tony', 'jack']
print(id(name_list))
练习
# 队列 先进先出
msg = []
while True:
msg.append(input('请输入（输入q停止：）'))
if 'q' in msg:
break
for i in msg:
if i == 'q':
break
print(i)
# 堆栈 先进后出
msg = []
while True:
msg.append(input('请输入(输入q停止）：'))
if 'q' in msg:
break
for i in msg[-2:-len(msg)-1:-1]:
print(i)
4.3 列表的其他方法
l1 = [21,35,8,69,1,14,90]
l1.sort() # 排序（默认是升序）
l1.sort(reverse=True) # 参数指定 降序
l1.reverse() # 顺序颠倒
l1[1:5] # 切片
print(l1[::-1]) # 冒号左右两边不写数字默认全都要
print(l1[:5]) # 左边不写默认从头开始 [21,35,8,69,1]
print(l1[1:]) # [35,8,69,1,14,90] 右边不写默认到最后一个数字（不是顾头不顾尾）
# 比大小
l2 = [999,111]
l3 = [111, 222, 333, 444, 555, 666, 777, 888]
print(l2>l3) # True 列表比较运算采用相同索引元素比较 只要有一个比出了结果就直接得出结论
s1 = 'hello world'
s2 = 'abc'
print(s1 > s2) # 字符串比较大小也是按照索引位置内部转成ASCII对应的数字比较
5.字典的内置方法
获取V的值
1.按K取值 K不存在会直接报错
dic = {
'name': 'jason',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print(dic['name'])
print(dic['pwd'])
2. get() 键不存在 不会报错，会返回None
print(dic.get('name')) # jason
print(dic.get('xxx')) # None 键不存在 不会报错返回None
print(dic.get('name', '哈哈哈')) # 第二个参数 可以在k不存在的时候自定义返回信息
print(dic.get('xxx', '哈哈哈')) # 第二个参数 可以在k不存在的时候自定义返回信息
3.按k修改值 新增键值对(使用频率最高)
dic['name'] = 'jasonNB' # 键存在为修改值
print(dic)
dic['hobbies'].append('read')
print(dic)
dic['pwd'] = 123 # 键不存在为新增键值对
print(dic)
4.统计字典内部键值对的个数
print(len(dic)) # 3
5.成员运算 默认只暴露k
print('jason' in dic) # False
print('name' in dic) # True
6.删除元素
6.1 方式一
del dic['name']
print(dic)
6.2 方式二 指定k弹出键值对 给出v
print(dic.pop('age'))
print(dic)
6.3 方式3 弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
print(dic.popitem())
print(dic)
7.keys() values() items() 在python2中是列表 在python3中是迭代器
print(dic.keys()) # dict_keys(['name', 'age', 'hobbies']) 获取字典所有的键 看成列表即可
print(dic.values()) # dict_values(['jason', 18, ['play game', 'basketball']]) 获取字典所有的值 看成列表即可
print(dic.items()) # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
8. 更新字典 键存在则修改 不存在则创建 值的类型必须与原来的数据类型相同
dic.update({'name': 'jasonNB', 'pwd': 123})
print(dic)
9.初始化字典
print(dict.fromkeys(['k1', 'k2', 'k3'], []))
'''笔试题'''
res = dict.fromkeys(['k1', 'k2', 'k3'], [])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)
print(res) # 输出后的k1，k2，k3值都一样
res['k1'] = [111,222,333]
res['k1'].append(444)
print(res)
- setdefault()
# 当键存在的情况下,获取该键对应的值
print(dic.setdefault('name', 'jasonNB'))
print(dic)
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))
print(dic)
6.元组的内置方法
1.类型转换 能够支持for循环的数据都可以转换成元组
print(tuple(111)) # 不可以
print(tuple(11.11)) # 不可以
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple([11,22,33])) # (11, 22, 33)
print(tuple({'name':'jason','pwd':123})) # ('name', 'pwd')
# 元组第一道笔试题
t1 = (111) # 整型
t2 = (11.11) # 浮点型
t3 = ('hello') # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))
'''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
建议:所有的容器类型在存储数据的时候 如果内部只有一个元素
那么也推荐你加上逗号
'''
2.基本方法
t = (111, 222, 333, 444, 555)
# 1.索引取值
print(t[2])
print(t[-1])
# 2.切片操作
print(t[1:5])
print(t[1:])
print(t[:])
# 3.步长
print(t[1:5:2])
# 4.统计元组内元素的个数
print(len(t)) # 5
# 5.for循环
for i in t:
print(i)
# 6.count计数
print(t.count(111)) # 1
'''笔试题'''
t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)
7.集合去重操作
1.定义空集合需要使用关键字set
s1 = set()
2.类型转换 能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
l = [1,2,3]
s = set(l)
3.去重
s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
print(s1) # {1, 2, 3, 4}
name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 1.先将列表转换成集合
s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)
集合关系运算
friends1 = {"zero", "kevin", "jason", "eg"} # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"} # 用户2的好友们
1.求两个用户的共同好友
print(friends1 & friends2) # {'jason', 'eg'}
2.求两个用户所有的好友
print(friends1 | friends2) # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
3.求用户1独有的好友
print(friends1 - friends2) # {'zero', 'kevin'}
4.求用户2独有的好友
print(friends2 - friends1) # {'ricky', 'Jy'}
5.求用户1和用户2各自的好友
print(friends1 ^ friends2) # {'Jy', 'zero', 'kevin', 'ricky'}
6.父集与子集
s1 = {11, 22, 33, 44}
s2 = {11, 33}
print(s1 > s2) # 判断s1是否是s2的父集 True
print(s2 < s1) # 判断s2是否是s1的子集 True
浙公网安备 33010602011771号