python数据类型内置方法

内容概要

• 列表内置方法
• 字典内置方法
• 字符串转换成字典的方法 eval()
• 元组内置方法
• 元组相关笔试题
• 集合内置方法

列表内置方法

l1 = [2, 4, 5, 7, 3, 9, 0, 6]
# 升序
l1.sort()
# 降序
l1.sort(reverse=True)
# 顺序颠倒
l1.reverse()
# 切片取值
print(l1[1:5])
print(l1[::-1])  # 冒号左右两边不写数字默认全部都要，-1步长表示倒序取值（reverse()）
print(l1[:5])  # 冒号左边不写默认从头开始
print(l1[1:])  # 冒号右边不写默认取值到末尾

# 列表比较, 从列表的第一个值开始比较
list1 = [66, 11]
list2 = [55, 99, 22]
print(list1 > list2)
# 字符串比较是比较代表字符的字符编码数字
str1 = 'hello'
str2 = 'abc'
print(str1 > str2)

字符串如果想类型转换成字典 eval()

str1 = '{"name": "elijah", "age": 18, "hobby": "beauty"}'
print(str1, type(str1))
user_dict = eval(str1)
print(user_dict, type(user_dict))

字典内置方法

dic = {
    'name': 'elijah',
    'age': 23,
    'hobby': ['read', 'sport']
}

# 1.按k取值  k不存在会直接报错
print(dic['name'])
# print(dic['pwd'])  # 报错

# 2.按k值修改值 或者新增键值对（使用频率高）
dic['name'] = 'jason'
dic['hobby'].append('basketball')
dic['pwd'] = 123  # 键不存在就是新增键值对

# 3.统计字典内部键值对个数
print(len(dic))

# 4.成员运算 默认只暴露k
print('elijah' in dic)

dic = {
    'name': 'elijah',
    'age': 23,
    'hobby': ['read', 'sport']
}
# 5.删除元素
# 5.1 del
del dic['name']
print(dic)
# 5.2 .pop() 指定k弹出键值对 给出v
dic.pop('age')
print(dic)
# 5.3 .popitem() 弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v
print(dic.popitem())
print(dic)

# 6.获取v值
print(dic['name'])  # 键不存在直接报错  按k取值不太推荐使用该方式
print(dic['xxx'])  # 键不存在直接报错  按k取值不太推荐使用该方式
print(dic.get('name'))
print(dic.get('xxx'))  # None  键不存在 不会报错返回None
print(dic.get('name', '哈哈哈'))
print(dic.get('xxx', '哈哈哈'))  # 第二个参数 可以在k不存在的时候自定义返回信息
print(dic)

# 7.keys() values() items() 在python2中是列表， 在python3中是迭代器（老母猪）
print(dic.keys())  # dict_keys(['name', 'age', 'hobby'])
print(dic.values())  # dict_values(['elijah', 23, ['read', 'sport']])
print(dic.items())  # dict_items([('name', 'elijah'), ('age', 23), ('hobby', ['read', 'sport'])])
# 获取字典里面所有键值对 组织列表套元组的形式， 元组内有两个元素，一个是k一个是v

字典需要了解方法

# 1.更新字典  键存在则修改 不存在则创建
dic.update({'name': 'jasonNB', 'pwd': 123})
print(dic)
# 2.初始化字典
print(dict.fromkeys(['k1', 'k2', 'k3'], []))

'''笔试题'''
res = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(res)
res['k1'].append(11)
print(res)
res['k2'].append(22)
res['k3'].append(33)
print(res)
# 单独给k1取值，不影响k2k3
res['k1'] = [5, 6, 7]
print(res)

# 3.当键存在的情况下 不修改而是获取该键对应的值
print(dic.setdefault('name', 'jasonNB'))
print(dic)
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))
print(dic)

元组内置方法

'''

小括号括起来，内部存放多个元素，元素之间用逗号隔开

元素可以是任意数据类型，但元组内元素不支持‘修改’（索引指向的元素的内存地址不能改变）（元组内列表的值改变了内存地址也不会变）

可以简单认为元组是不可变的列表

'''

# 类型转换，能支持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')
t4 = (111,)

print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))

# 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, [1, 2, 3])
print(t1)
t1[2].append(5)
print(t1)

集合去重操作

# 定义
s1 = set()

# 类型转换  能够支持for循环的数据类型都可以转成集合(元素是不可变类型）
'''集合内元素是无序的'''

# 去重
s2 = {1,1,1,12,2,2,2,23,3,3,3,3,4,4,4}
print(s2)

"""课堂练习题"""
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 基本要求:去重即可
s1 = set(ll)
ll = list(s1)
print(ll)  # [33, 66, 11, 44, 77, 22, 55]

# 拔高要求:去重并保留原来的顺序
# 定义一个新列表
l1 = []
# 按顺序循环列表的值
for i in ll:
    # 如果值不在新列表内则添加，有则跳过
    if i not in l1:
        l1.append(i)
print(l1)  # [33, 22, 11, 44, 55, 66, 77]

集合关系运算

# 交集 (共同好友)
print(friends1 & friends2)  # {'kevin', 'egon'}
# 并集 （两人所有的好友）
print(friends1 | friends2)  # {'elijah', 'jason', 'kevin', 'amy', 'tony', 'egon'}
# 差集   各自独有的好友
print(friends1 - friends2)  # {'jason', 'elijah'}
print(friends2 - friends1)  # {'tony', 'amy'}
# 对称差集   各自的好友相加去掉共同的好友
print(friends1 ^ friends2)  # {'jason', 'amy', 'elijah', 'tony'}

# .difference() 相当于 friends1 - friends2 和 friends2 - friends1
print(friends1.difference(friends2))
print(friends2.difference(friends1))
# .intersection() 相当于 & 交集
print(friends1.intersection(friends2))
#  .symmetric_difference()  相当于 friends1 ^ friends2
print(friends1.symmetric_difference(friends2))
# .union()  相当于 friends1 | friends2
print(friends1.union(friends2))

# 父集和子集
s1 = {1, 2, 3, 4, 5}
s2 = {1, 2}
print(s1 > s2)  # 判断s1是否是s2的父集  True
print(s2 < s1)  # 判断s2是否是s1的子集  True

# 即报名python 又报名 linux
pythons & linuxs
#  所有报名的学生
pythons | linuxs
# 只报名了python
pythons - linuxs
# 没有同时报名两门课的学员
pythons ^ linuxs