Python 数据类型常用的内置方法（三）

目录

• Python 数据类型常用的内置方法（三)
  • 1、列表内置方法
    • 1、sort（）：升序
    • 2、reverse（）：颠倒顺序
    • 3、列表比较运算
  • 2、字典内置方法
    • 1、对Key的操作
    • 2、len（ ）--统计键值对个数
    • 3、成员运算
    • 4、删除元素
    • 5、get（）方法 --获取V值
    • 6、keys（ ）、values（ ）、items（ ）
    • 7、update --更新字典
    • 8、fromkeys --初始化字典
  • 3、元组内置方法
    • 1、类型转换
    • 2、索引
    • 3、切片
    • 4、len（）统计元素个数
    • 5、count（）统计元素出现的次数
    • 6、元组易错题
  • 4、集合内置方法
    • 1、去重
    • 2、关系运算

接上篇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

---

持续更新中，求关注···