数据类型的内置方法
整型的内置方法
1.类型转换
res = '123'
print(type(res)) # <class 'str'>
res = int(res)
print(type(res)) # <class 'int'>
2.进制转换
# 十进制转成其他进制
print(bin(100)) # 0b1100100
print(oct(100)) # 0o144
print(hex(100)) # 0x64
print(type(bin(100))) # <class 'str'>
# 其他进制转成十进制
print(int('0b1100100', 2)) # 100
print(int('0o144', 8)) # 100
print(int('0x64', 16)) # 100
浮点型的内置方法
&.类型转换
res = '123.12'
print(type(res)) # <class 'str'>
res = float(res)
print(type(res)) # <class 'float'>
字符串的内置方法
1.类型转换
任意数据类型都能转换成字符串类型：
res = str(123)
print(res, type(res)) # 123 <class 'str'>
res = str('alearn')
print(res, type(res)) # alearn <class 'str'>
res = str([1, 2, 3])
print(res, type(res)) # [1, 2, 3] <class 'str'>
res = str({"name":"alearn", 'age':18})
print(res, type(res)) # {'name': 'alearn', 'age': 18} <class 'str'>
res = str((1, 2, 'aa'))
print(res, type(res)) # (1, 2, 'aa') <class 'str'>
res = str({1, 2, 'aa'})
print(res, type(res)) # {1, 2, 'aa'} <class 'str'>
2.索引取值
res = 'hello world!'
print(res[0]) # h
print(res[-1]) # ! 反向取值，索引值超过实际的就会报错
3.切片操作(步长)
res = 'hello world!'
print(res[0:7]) # hello w
print(res[0::2]) # hlowrd 第三位参数是决定步长的，取负值就是反向的意思
print(res[::-1]) # !dlrow olleh
4.长度计算
关键词：len()
res = 'hello world!'
print(len(res)) # 12 空格也算字符
5.移除首尾指定字符
关键词：strip # 默认消除前后空格
res = ' hello world! '
print(res.rstrip()) # hello world! right/left
res_1 = '$$hello world!$$$$'
print(res_1.strip("$")) # hello world!
6.按照指定字符切割字符串
res = 'alearn|123456|123' # 已知该词条中保存着用户昵称、账号、密码
res_list = res.split("|")
print(res) # alearn|123456|123
print(res_list) # ['alearn', '123456', '123']
res_list = res.split("|", 1)
print(res_list) # ['alearn', '123456|123'] 第二个参数控制切割的次数，默认从左往右，没有-1为从右向左一说
7.大小写转化
res = 'Alearn Go go go'
print(res.upper()) # ALEARN GO GO GO 全大写
print(res.lower()) # alearn go go go 全小写
print(res.isupper()) # False 判断是否全大写
print(res.islower()) # False 判断是否全小写
print(res.title()) # Alearn Go Go Go 每个单词首字母大写
print(res.capitalize()) # Alearn go go go 句子开头大写
print(res.swapcase()) # aLEARN gO GO GO 大小写颠倒
实例：验证码的优化
9.判断是否以指定字符开头或结尾
s1 = "alearn 123 new old"
print(s1.startswith('al')) # True
print(s1.endswith("old")) # True
10.格式化输出
# 方式一：占位符%s/%d
# 方式二：字符串内置函数
# 关键字：format
s2 = 'My name is {}, my age is {}'
print(s2.format('alearn', 18)) # {}相当于一个占位符
s2 = 'My {0} name {1} is {0}, my age is {1}'
print(s2.format('alearn', 18)) # 根据索引占位
s2 = 'My {name} name {age} is {name}, my age is {name}'
print(s2.format(name='alearn', age=18)) # 类似key值
11.字符串拼接
# 方式一：通过运算“+”直接拼接
print('hello'+' '+'world') # hello world
# 方拾二：字符串内置方法join
l = ['alearn', 'tom', 'jack']
print('|'.join(l) # alearn|tom|jack
12.替换字符串指定的字符
# 关键字：replace
s4 = 'my name is alan alan'
print(s4.replace('alan', 'alearn',1)) # my name is alearn alan
13.判断是否时纯数字
# 判断字符串里面是否是纯数字
s1, s2, s3 = 'asd123', '10086', 'abc'
print(s1.isdigit(), s2.isdigit(), s3.isdigit()) # False True False
15.查找索引值
# 关键字：find()
s7 = 'my name is alan old old'
print(s7.find('o')) # 16 (自左往右，第一被查找到的索引返回)
print(s7.find('x')) # -1 (没有查找到指定的字符，返回值为-1)
# 关键字：index()
s8 = 'my name is alan old old'
print(s8.index('o')) # 16
print(s8.index('x')) # 报错
16.统计某字符出现的次数
关键字：count()
s7 = 'my name ooo is ob alan old'
print(s7.count("o")) # 5
print(s7.count("x")) # 0
17.填充
关键字:center、ljust、rjust
s8 = 'alan'
print(s8.center(15,'$')) # $$$$$$alan$$$$$
print(s8.ljust(15,"$")) # alan$$$$$$$$$$$
print(s8.rjust(15,"$")) # $$$$$$$$$$$alan
列表的内置方法
1.数据转换
list(容器类型数据) # 否则会报错
list功能相当于for+append()
2.增加元素
append() # 末尾追加
insert() # 依照索引插入元素，参数1:索引值，参数2:需要插入的对象
extend() # 将两个列表合并，括号里是另一个列表
3.删除元素
del # 通用方法，直接移除列表中的某个元素 eg：del l[0]
remove() # 定向移除，参数为需要移除的元素值
pop() # 默认弹出列表末尾的值，参数也可以加索引，移除索引对应的元素
4.排序
关键字:sort()
# 升序操作
lst.sort() # 默认升序
# 降序操作
lst.sort(reverse=True)
# 颠倒顺序
lst = lst[::-1]
5.列表的比较运算
列表的比较运算采用的是索引元素比较，只要前一个比较出结果了，程序结束
其中字符串也是能比较的，参照ASCII码
堆栈与队列
# 堆栈:先进后出
num = []
for i in range(1,5):
num.append(i)
print(num)
for i in range(len(num)):
num.pop()
print(num)
# 队列:先进先出
for i in range(1,5):
num.append(i)
print(num)
for i in range(len(num)):
num.pop(0)
print(num)
字典的内置方法
1.对K操作
dic = {"name": "alearn", "age": 18, "hobby": "rap"}
按K取值：kay不存在会报错
dic['name'] # alearn
dic['xxx'] # KeyError: 'xxx'
按K修改值：K存在修改值，不存在就新增键值对 # 增加元素
dic['name'] = 'alan'
dic['xxx'] = 'study'
2.统计键值对个数
关键字:len()
3.成员运算
- 字典在做成员运算的时候，暴露在外面的是key
关键字:in/not in
dic = {"name": "alearn", "age": 18, "hobby": "rap"}
print('age' in dic) # True
4.删除元素
dic = {"name": "alearn", "age": 18, "hobby": "rap"}
1.通用法del()
del dic['name']
2.pop()弹出法,弹出的是Value
dic.pop('age')
3.popitem()法，弹出内容为元组，前面是key，后面是value
5.获取V值升级版
关键字:get()
get() # 括号内参数为key值，如若key不存在，则不会报错，返回None值
get(key,value) # 当存在第二个参数时，key存在则修改，不存在则创建
6.keys()、values()、items()
- ps:在python2.X解释器中，这三个是列表，在python3.X中，优化成迭代器
keys() # 讲字典中的key全放进一个列表中
values() # 同理，将字典中的Value放进一个列表中
items() # 结果是一个列表，元素是一个一个元组，其中元组是由k:V键值对组成的
7.更新字典
key存在则修改，不存在则新添键值对---第三种方法(索引、get，update)
8.初始化字典
关键字:dic.formkeys(seq,[,value])
seq - keys()列表
[,value] - values()，第二个参数可以不写，默认为None
dic1 = dict.fromkeys(range(5))
print(dic1) # {0: None, 1: None, 2: None, 3: None, 4: None}
元组的内置方法
0.补充
容器类型是指能够存放多个值的数据类型，在定义单个元素时，建议在元素末尾添加有一个逗号
tup = (1,)
set = {1,}
dic = {'name':'',}
1.类型转换
# 转换对象必须是可迭代对象
关键字:tuple()
2.取值
与字符串、列表大体相同，可以索引取值，切片
3.统计元素个数
关键字:len()
4.统计某元素出现的次数
关键字count()，内部参数为元素值
5.关于元组的说明
- 元组可以通俗理解为只读列表，即数据可以被查询，但不能修改，但如果元组内存放一个列表，这样就可以改变存储的值了，但元组仍旧是不可变类型
集合的内置方法
1.去重
2.关系运算
实质就是交并补运算
| 符号 | 字符 | 功能 |
|---|---|---|
| | | union | 并集 |
| & | intersection | 交集 |
| - | difference | 差集 |
| ^ | symmetric_difference | 对称差集 |
| >/>= | issubset | 子集 |
# 定义一个无序列表
s1 = {1, 2, 3, 5, 6}
s2 = {1, 2, 3, 4, 7, 8}
# 并集
print(s1.union(s2))
print(s1 | s2)
# 交集
print(s1.intersection(s2))
print(s1 & s2)
# 差集
print(s1.difference(s2))
print(s1 - s2)
# 对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)
#子集
print(s1.issubset(s2))
print(s1<s2)
浙公网安备 33010602011771号