Python 数据类型常用的内置方法（三）
Python 数据类型常用的内置方法（三）
目录
接上篇👉Python 数据类型常用的内置方法（二）
Python 数据类型常用的内置方法（三)
1、列表内置方法
1、sort（）：升序
- 搭配参数：reverse=True # 参数为True，升序变降序
实例如下：
lst = [2, 111, 3, 222, 11, 1, 22, 33, 333]
#升序操作
lst.sort()
print(lst)
#降序操作
lst.sort(reverse=True)
print(lst)
#结果
[1, 2, 3, 11, 22, 33, 111, 222, 333]
[333, 222, 111, 33, 22, 11, 3, 2, 1]
2、reverse（）：颠倒顺序
- 功能相当于列表索引步长为-1
实例如下：
lst1 = [1, 2, 3, 4, 5, 6, 7]
# 颠倒顺序
lst1.reverse()
print(lst1)
lst1 = [1, 2, 3, 4, 5, 6, 7]
# 步长取-1功能相当于reverse()
print(lst1[::-1])
#结果
[7, 6, 5, 4, 3, 2, 1]
[7, 6, 5, 4, 3, 2, 1]
3、列表比较运算
- 列表比较运算采用相同索引元素比较，只要有一个比出了结果，程序结束
实例如下：
lst2 = [333, 444, 555]
lst3 = [111, 999, 999999, 1, 2, 3]
# 只比较了第一个元素，333>111,程序结束
print(lst2 < lst3)
#结果
False
2、字典内置方法
python字典你值得拥有！
1、对Key的操作
- 按K取值：K不存在会直接报错
- 按K修改值：K存在就修改值，K不存在就新增键值对。
实例如下：
#1、按K取值
dic = {"name": "HammerZe", "age": 18, "hobby": "study python"}
print(dic['name'],dic['age'],dic['hobby'])
#结果
HammerZe 18 study python
#K不存在，报错的情况
print(dic['nixx'])
#结果
KeyError: 'nixx'
#2、按K修改值
# 1、按K取值
dic = {"name": "HammerZe", "age": 18, "hobby": "study python"}
# k存在的情况，为修改值
dic['hobby'] = 'play game'
print(dic)
# k不存在的情况，为添加值
dic['sex'] = 'man'
print(dic)
#结果
{'name': 'HammerZe', 'age': 18, 'hobby': 'play game'}
{'name': 'HammerZe', 'age': 18, 'hobby': 'play game', 'sex': 'man'}
2、len（ ）--统计键值对个数
- 统计字典内部键值对的个数
实例如下：
# len()统计键值对个数
dic = {"name": "HammerZe", "age": 18, "hobby": "study python"}
print(len(dic))
#结果
3
3、成员运算
- 成员运算对Key操作，默认暴露Key
实例如下：
dic = {"name": "HammerZe", "age": 18, "hobby": "study python"}
#in运算
print('age' in dic)
#not in 运算
print('name' not in dic)
#name 和 age键都在字典里
#结果
True
False
4、删除元素
- 根据key名用del删除
- pop方法弹出
- popitem方法弹出
实例如下：
dic = {'name': 'HammerZe', 'age': 18,
'hobby': 'study python', 'sex': 'man'}
# 根据Key删除,'sex'
del dic['sex']
print(dic)
# pop方法弹出'age',打印可以输出value
# dic.pop('age')
print(dic.pop('age'))
print(dic)
# popitem方法
dic = {'name': 'HammerZe', 'age': 18,
'hobby': 'study python', 'sex': 'man'}
# dic.popitem()
print(dic.popitem()) # 输出弹出的内容为元组，前面是key后面为value
print(dic)
5、get（）方法 --获取V值
- get（）括号内写key
- get（）获取值，如果key不存在，不会报错，返回None，对比字典内置方法1中的对Key操作，如果键不存在会报错。
- get（）搭配参数有：get（‘key’,’value’），第二个参数，可以在k不存在的时候自定义信息
实例如下
dic = {'name': 'HammerZe', 'age': 18,
'hobby': 'study python', 'sex': 'man'}
# 按key取值
print(dic.get('name'))
# 按key取值，key不存在的情况,返回None
print(dic.get('height'))
# 搭配两个参数使用，k存在的情况,不会根据后面的值变动，返回原来的值
print(dic.get('age', 11)) # 这里赋值11不会改变原来的值
# 搭配两个参数使用，k不存在的情况，自定义信息
print(dic.get('weight', 140)) # 输出信息
print(dic)
6、keys（ ）、values（ ）、items（ ）
- 在python2中是列表，在python3中是迭代器
- keys获取字典的所有键，看成列表
- values获取字典的所有值，看成列表
- items获取字典的所有键值对，结果为列表套元组的形式，元组内第一个为key，第二个为value
实例如下：
dic = {'name': 'HammerZe', 'age': 18,
'hobby': 'study python', 'sex': 'man'}
# 获取所有键
print(dic.keys())
# 获取所有值
print(dic.values())
# 获取所有键值对
print(dic.items())
#结果
dict_keys(['name', 'age', 'hobby', 'sex'])
dict_values(['HammerZe', 18, 'study python', 'man'])
dict_items([('name', 'HammerZe'), ('age', 18), ('hobby', 'study python'), ('sex', 'man')])
7、update --更新字典
-
键存在则修改，不存在则创建
-
对比方法1中对key操作
实例如下：
# k不存在的情况，为添加值
dic['sex'] = 'man'
print(dic)
#区分上面
#update更新字典
dic = {'name': 'HammerZe', 'age': 18,
'hobby': 'study python', 'sex': 'man'}
# key 存在的情况，修改值
dic.update({'name':'Ze'})
print(dic)
# key 不在的情况，添加键值对
dic.update({'height':'189'})
print(dic)
#结果
{'name': 'Ze', 'age': 18, 'hobby': 'study python', 'sex': 'man'}
{'name': 'Ze', 'age': 18, 'hobby': 'study python', 'sex': 'man', 'height': '189'}
8、fromkeys --初始化字典
- formkeys()方法格式：dict.fromkeys(seq[,value])
- seq - 字典键值列表
- value - 可选参数，设置键序列（seq）对应的值，默认为None
实例如下：！！面试笔试题
#没有设置第二个参数的情况
dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic)
dic1 = dict.fromkeys(range(5))
print(dic1)
#结果
{'k1': [], 'k2': [], 'k3': []}
{0: None, 1: None, 2: None, 3: None, 4: None}
# 设置第二个参数的情况
dic2 = dict.fromkeys(range(5),'python')
print(dic2)
#结果
{0: 'python', 1: 'python', 2: 'python', 3: 'python', 4: 'python'}
3、元组内置方法
1、类型转换
- 能够支持for循环的数据都可以转换成元组
- for循环可迭代的对象：字符串，列表，字典，元组，集合
实例如下：
# print(tuple(1)) #整型不能转换
# print(tuple(1.234)) # 整型不能转换
print(tuple('python')) # 字符串可以转换
# 结果
# ('p', 'y', 't', 'h', 'o', 'n')
print(tuple([1, 2, 3, 4, 5])) # 列表可以转换
# 结果
# (1, 2, 3, 4, 5)
print(tuple({"name":"HammerZe"})) # 字典可以转换，输出key
# 结果
# ('name',)
print(tuple({1,2,3,4})) # 集合可以转换
# 结果
# (1, 2, 3, 4)
注意！！，容器类型存储数据的时候建议在元素末尾添加逗号
- 容器类型定义：内部可以存放多个值的数据类型
实例如下：
tup = (1,)
set = {1,}
dic = {'name':'',}
print(type(tup),type(set),type(dic))
#结果
<class 'tuple'> <class 'set'> <class 'dict'>
2、索引
- 和字符串、列表一样按下标取值
实例如下：
tup = (1, 2, 3, 4, 5, 6, 7)
#正向索引
print(tup[0])
#负向索引
print(tup[-1])
#结果
1
7
3、切片
实例如下：
(1, 2, 3, 4, 5, 6, 7)
(1, 3, 5)
(7, 6, 5, 4, 3, 2, 1)tup = (1, 2, 3, 4, 5, 6, 7)
print(tup[0:7])
print(tup[0:-1:2])
print(tup[::-1])
#结果
(1, 2, 3, 4, 5, 6, 7)
(1, 3, 5)
(7, 6, 5, 4, 3, 2, 1)
4、len（）统计元素个数
实例如下：
tup = (1, 2, 3, 4, 5, 6, 7)
print(len(tup))
#结果
7
5、count（）统计元素出现的次数
实例如下：
tup = (1, 1, 2, 2, 22, 333, 44, 4, 4, 4,)
print(tup.count(4))
#结果
3
6、元组易错题
元组为只读列表，即数据可以被查询，但不能被修改,但是我们可以在元组的元素中存放一个列表，这样就可以改变元组内部存储的值，但元组还是不可变类型，改变的只是元组内的列表。
实例如下：
tup = (1, 2, 3, [4, 5, 6])
print(id(tup), type(tup))
# 追加元素到元组内部的列表
tup[3].append(7)
# 结果
print(tup,id(tup),type(tup))
'''查看id发现并没有改变，
和不可变类型的定义相反，
但是改变的是列表的值，
列表的地址没有改变，
列表在元组中的地址的值没有改变，
所以也就意味着元组没有发生变化'''
4、集合内置方法
- 去重操作
- 关系运算
1、去重
实例如下：
# 定义一个无序列表
s1 = {1, 4, 7, 8, 5, 2, 3, 9, 96, 2}
# 输出的结果也是无序的
print(s1)
#结果
{96, 1, 2, 3, 4, 5, 7, 8, 9}
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)
#结果
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3}
{1, 2, 3}
{5, 6}
{5, 6}
{4, 5, 6, 7, 8}
{4, 5, 6, 7, 8}
False
False
持续更新中，求关注···
