Python数据类型的内置方法（二）数据类型之列表内置方法 列表关键字：list# 列表的类型描述：用中括号括起来，内部存放多个元素或者数据值，数据值与数据值之间用逗号隔开，数据值
列表关键字：list
# 列表的类型描述：用中括号括起来，内部存放多个元素或者数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型 表达关键字为list
# 1.先定义一个列表，便于理解
# l1 = ['刘备', '曹操', '孙权', '关羽', '张飞']
# l2 = [11, 22, 33, 44, 55, 66]
# 1.统计列表中数据值的个数len
# print(len(l1))
# 2.列表的增
# 2.1 尾部追加元素append() 括号内无论写什么数据类型，都是当成单个数据值追加
# l1.append('黄忠')
# print(l1) # 需要注意的是，列表在调用内置方法之后不会产生新的数据值，而是修改它自身 ['刘备', '曹操', '孙权', '关羽', '张飞', '黄忠']
# l1.append([1, 2, 3, 4, 5])
# print(l1) # ['刘备', '曹操', '孙权', '关羽', '张飞', '黄忠', [1, 2, 3, 4, 5]]
# 2.2 任意位置插入数据值insert() 括号内无论写什么数据类型，都是当成单个数据值插入
# l1.insert(2, '马超') # ['刘备', '曹操', '马超', '孙权', '关羽', '张飞']
# print(l1)
# 2.3 扩展列表
# new_l1 = [77, 88, 99, 100]
# new_l2 = [1, 2, 3]
# 方式一
# for i in new_l1:
# new_l2.append(i)
# print(new_l2) # [1, 2, 3, 77, 88, 99, 100]
# 方式二
# print(new_l1 + new_l2) # [77, 88, 99, 100, 1, 2, 3]
# 方式三(推荐使用)
# new_l1.extend(new_l2)
# print(new_l1) # [77, 88, 99, 100, 1, 2, 3]
# 3.查询数据与修改数据
# 查询数据
# print(l1) # ['刘备', '曹操', '孙权', '关羽', '张飞']
# print(l1[3]) # 关羽
# print(l1[1:5]) # ['曹操', '孙权', '关羽', '张飞']
# 修改数据
# l1[2] = '赵云'
# print(l1) # ['刘备', '曹操', '赵云', '关羽', '张飞']
# 4，删除数据
# 4.1 通用删除策略
# del l1[1] # 把索引1所指定的数据进行删除
# print(l1) # ['刘备', '孙权', '关羽', '张飞']
# 4.2 指定数据值进行删除 括号内必须填写明确的数据值
# l1.remove('张飞')
# print(l1) # ['刘备', '曹操', '孙权', '关羽']
# 4.3 先取出数据值，之后进行删除
# res = l1.pop() # 将列表里的最后一个数据值先取出来，然后进行删除
# print(l1, res) # ['刘备', '曹操', '孙权', '关羽'] 张飞
# res = l1.pop(1)
# print(res, l1) # 曹操 ['刘备', '孙权', '关羽', '张飞']
# 5.查看数据值对应的索引值
# print(l1.index('张飞')) # 4
# 6.统计某个数据值出现的次数
# l1.append('刘备')
# print(l1.count('刘备'))
# 7.排序
# l2.sort()
# print(l2) # [11, 22, 33, 44, 55, 66] 升序
# l2.sort(reverse=True)
# print(l2) # [66, 55, 44, 33, 22, 11] 降序
# 8.反转
# l1.reverse()
# print(l1) # ['张飞', '关羽', '孙权', '曹操', '刘备'] 前后顺序颠倒
# 9.比较运算
# new_1 = [88, 66]
# new_2 = [33, 44, 55, 66]
# print(new_1 > new_2) # True 列表在比较大小的时候是按照位置顺序一一比较的
# new_1 = ['a', 66]
# new_2 = [33, 44, 55, 66]
# print(new_1 > new_2) # 不同数据类型之间默认无法直接做操作
# new_1 = ['a', 66]
# new_2 = ['A', 44, 55, 66]
# print(new_1 > new_2) # True
字典关键字dict
# 字典的类型描述：用大括号括起来，内部可以存放多个数据值，数据值与数据值之间用逗号隔开，组织形式为K:V键值对
# 类型转换
# print(dict([('name', 'zh'), ('pwd', 123)])) # {'name': 'zh', 'pwd': 123}
# print(dict(name='huawei', pwd=666)) # {'name': 'huawei', 'pwd': 666}
"""字典很少涉及到的类型转换 都是直接定义使用"""
info = {
'username': 'lisa',
'password': 666,
'hobby': ['read', 'run']
}
"""
k是对v的描述性性质的信息，一般是字符串，也可以是不可变类型，如整型、浮点型、字符串、元组
"""
# 1.字典内K:V键值对是无序的，无法用索引取值
# 2.取值操作
# print(info['username']) # 不推荐使用，如果键不存在，则会打印报错
# print(info.get('username')) # lisa
# print(info.get('name')) # None
# print(info.get('username', '键不存在返回的值，默认是None')) # lisa
# print(info.get('xxx', '键不存在返回的值，默认是None')) # 键不存在返回的值，默认是None
# 3.统计字典中键值对的个数
# print(len(info)) # 3
# 4.修改数据
# info['username'] = 'name' 键存在则是修改
# print(info) # {'username': 'name', 'password': 666, 'hobby': ['read', 'run']}
# 5.新增数据
# info['salary'] = 600 键不存在就是新增
# print(info) # {'username': 'lisa', 'password': 666, 'hobby': ['read', 'run'], 'salary': 600}
# 6.删除数据
# 方式一
# del info['username']
# print(info) # {'password': 666, 'hobby': ['read', 'run']}
# 方式二
# res = info.pop('username')
# print(info, res) # {'password': 666, 'hobby': ['read', 'run']} lisa
# 方式三
# info.popitem() # 随机删除
# print(info)
# 7.快速获取键、值、键值对数据
# print(info.keys()) # dict_keys(['username', 'password', 'hobby']) 获取字典所有的K值，结果当成列表即可
# print(info.values()) # dict_values(['lisa', 666, ['read', 'run']]) 获取字典所有的V值，结果当成列表即可
# print(info.items()) # dict_items([('username', 'lisa'), ('password', 666), ('hobby', ['read', 'run'])]) 取字典KV键值对数据，组织成列表套元组
# 8.快速构造字典 给的值默认情况下，所有的键都用一个
# res = dict.fromkeys([1, 2, 3, 4, 5], {})
# print(res) # {1: {}, 2: {}, 3: {}, 4: {}, 5: {}}
元组关键字tuple
# 元组的类型描述：小括号括起来，内部存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型，也称为不可变的列表
# 类型转换 支持for循环的数据类型都可以进行转换
# print(tuple(123))
# print(tuple(1.2))
# print(tuple('huawei')) # ('h', 'u', 'a', 'w', 'e', 'i')
# print(tuple([1, 2, 3, 4, 5])) # (1, 2, 3, 4, 5)
# print(tuple({'name': 'lib', 'age': 18})) # ('name', 'age')
# 先定义一个元组
# t1 = ()
# print(type(t1)) # <class 'tuple'>
# t2 = (1)
# print(type(t2)) # <class 'int'>
# t3 = (22.22)
# print(type(t3)) # <class 'float'>
# t4 = 'name'
# print(type(t4)) # <class 'str'>
# 当元组内只有一个数据值的时候，逗号不能省略，如果省略了，括号里边是什么数据类型就是什么数据类型
# 编写元组的时候，把逗号加上，哪怕只有一个数据
# t1 = ()
# print(type(t1)) # <class 'tuple'>
# t2 = (1,)
# print(type(t2)) # <class 'tuple'>
# t3 = (22.22,)
# print(type(t3)) # <class 'tuple'>
# t4 = ('name',)
# print(type(t4)) # <class 'tuple'>
# 以后遇到可以存储多个数据值的数据类型，如果里面只有一个数据值，那么趁机把逗号也加上，可以更加规范
# t1 = (11, 22, 33, 44, 55, 66, 77, 88)
# 1.索引相关操作
# 2.统计元组内数据值的个数
# print(len(t1)) # 8
# 3.查与改
# print(t1[0]) # 可以查找
# t1[0] = 333 # 不可以修改
# 注意：元组的索引不能改变绑定地址
# t2 = (11, 22, 33, 44, [1, 2])
# t2[-1].append(3)
# print(t2) # (11, 22, 33, 44, [1, 2, 3])
表达关键字set
# 定义空集合需要使用关键字才可以
# 类型转换：能够被for循环的数据类型都可以转换为集合，但转换完的数据值只能是不可变的数据类型
# 集合内数据类型必须是不可变的数据类型(整型、浮点型、字符串、元组、布尔值)
# 集合自带去重特性
# l1 = ['red', 'blue', 'black', 'green', 'red', 'red', 'red'] # 自动去除列表里重复的元素
# s1 = set(l1)
# print(s1) # {'red', 'black', 'blue', 'green'}
# l1 =list(s1)
# print(l1) # ['red', 'black', 'blue', 'green']
# 关系运算
# 模拟两个人的好友集合
# a1 = {'宋江', '吴用', '卢俊义', '晁盖', '武松', '李逵'}
# a2 = {'刘备', '关羽', '李逵', '曹操', '周瑜', '马超'}
# 1.求a1和a2的共同好友
# print(a1 & a2) # {'李逵'}
# 2.求a1和a2独有的好友
# print(a1 - a2) # {'卢俊义', '晁盖', '宋江', '吴用', '武松'}
# print(a2 - a1) # {'刘备', '马超', '关羽', '周瑜', '曹操'}
# 3.求a1和a2所有的好友
# print(a1 | a2) # {'吴用', '宋江', '马超', '李逵', '曹操', '卢俊义', '刘备', '晁盖', '武松', '关羽', '周瑜'}
# 4.求a1和a2各自独有的好友，排除共同好友
# print(a1 ^ a2) # {'武松', '宋江', '卢俊义', '吴用', '关羽', '周瑜', '晁盖', '刘备', '曹操', '马超'}
# 5.父集、子集
# s1 = {1, 2, 3, 4, 5, 6, 7}
# s2 = {3, 2, 1}
# print(s1 > s2) # True 判断s1是不是s2的父集，s2是不是s1的子集
"""
为什么字符串调用内置方法是产生新的值 列表调用内置方法是改变自身
"""
1.可变类型 list
值改变(通过内置方法) 内存地址可以不变
l1 = [11, 22, 33]
print(id(l1)) # 1931283911552
l1.append(44) # [11, 22, 33, 44]
print(id(l1)) # 1931283911552
2.不可变类型 str int float
值改变(通过内置方法) 内存地址肯定变
s1 = '$hello$'
print(id(s1))
s1 = s1.strip('$')
print(id(s1))
# 1.利用列表编写一个员工姓名管理系统
# 输入1执行添加用户名功能
# 输入2执行查看所有用户名功能
# 输入3执行删除指定用户名功能
# ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
# 提示: 循环结构 + 分支结构
# 拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写
# 不会没有关系)
"""
主体功能：[添加用户、查看用户、删除用户]
"""
# 1.先定义一个存储用户名数据的列表
user_data_list = []
# 2.循环打印管理系统功能，并提供功能编号
while True:
print("""
1.添加用户名
2.查看所有用户名
3.删除指定用户名
""")
# 3.获取用户需要执行的功能编号
select = input('请您输入需要执行的功能编号>>>:').strip()
# 4.判断用户想要执行的功能
if select == '1':
# 5.获取用户的用户名
username = input('请输入您要添加的用户名>>>:').strip()
# 6.判断用户名是否已经存在，如果存在则提示用户已存在并结束判断
if username in user_data_list:
print('对不起，此用户名已存在，无法添加')
break
# 7.创建一个临时列表用于存放用户名
user_list = f'{username}'
# 8.添加到数据列表中
user_data_list.append(user_list)
# 9.提示用户添加成功
print(f'{username}添加成功')
elif select == '2':
print(user_data_list)
elif select == '3':
# 10.获取想要删除的用户名
delete_user = input('请输入您想要删除的用户名>>>:')
# 11.判断当前用户名是否还存在
if delete_user not in user_data_list:
print('此用户名不存在，无法删除')
continue # 如果存在，则结束本次循环
# 12.使用列表内置方法进行数据删除
res = user_data_list.pop(1).strip()
print('此用户名已删除完毕')
else:
print('请输入正确的功能编号')
# 2.去重下列列表并保留数据值原来的顺序
# eg: [1, 2, 3, 2, 1]去重之后[1, 2, 3]
# l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
# l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
# l2 = set(l1)
# l1 = list(l2)
# print(l1) # [1, 2, 3, 4, 5, 6]
# 3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
# pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
# linuxs = {'kermit', 'tony', 'gangdan'}
# 1.求出即报名python又报名linux课程的学员名字集合
# 2.求出所有报名的学生名字集合
# 3.求出只报名python课程的学员名字
# 4.求出没有同时这两门课程的学员名字集合
# pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
# linuxs = {'kermit', 'tony', 'gangdan'}
#
# print(pythons & linuxs) # {'gangdan'}
# print(pythons | linuxs) # {'tony', 'biubiu', 'gangdan', 'oscar', 'kevin', 'kermit', 'ricky', 'jason'}
# print(pythons - linuxs) # {'jason', 'ricky', 'biubiu', 'oscar', 'kevin'}
# print(pythons ^ linuxs) # {'jason', 'kermit', 'oscar', 'kevin', 'ricky', 'biubiu', 'tony'}