数据类型的内置方法(2)

本文详细介绍了Python中四种主要的数据类型:列表、元组、字典和集合的操作方法。包括它们的类型转换、取值、内置方法以及常见用途。例如,列表的append、insert、extend方法,元组的不可变特性,字典的get、update、fromkeys方法,以及集合的交集、并集、差集等关系运算。此外,还提供了几个编程练习,如员工管理系统和列表去重等实际应用场景。

数据类型的内置方法

  • 列表

    • 列表的类型转换
      """只有能够被for循环的数据类型才能被转换成列表"""
      print(list(123))  # 报错
      print(list('abc'))  # ['a', 'b', 'c']
      print(list({'name': 'xiaoming', 'age': 18})  # ['name', 'age'] 字典转换取得是键(k)
      
    • 列表的取值
      l1 = [1, 2, 3, 4, 5]
      """索引取值"""
      print(l1[0])  # 1
      print(l1[-1])  # 5
      """切片取值"""
      print(l1[0:3])  # [1, 2, 3]
      print(l1[-1:-4:-1])  # [5, 4, 3]
      
    • 列表的内置方法
      l1 = ['a', 'b', 'c', 'd', 'e', 'f']
      """添加数据值的方法"""
      # 1.在列表的最后追加一个数据值:append
      l1.append('g')
      print(l1)  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
      l1.append([1, 2, 3])
      print(l1)  # ['a', 'b', 'c', 'd', 'e', 'f', 'g', [1, 2, 3]]  可以追加任意数据类型
      
      # 2. 在指定位置插入数据值:insert
      l2 = ['a', 'b', 'c', 'd', 'e', 'f']
      l2.insert(2, 'g')
      print(l2)  # ['a', 'b', 'g', 'c', 'd', 'e', 'f']  也可以是任意数据类型
      
      # 3. 合并列表
      l1 = [1, 2, 3, 4]
      l2 = [5, 6]
      print(l1 + l2)  # [1, 2, 3, 4, 5, 6] ,可以达到效果,但是不推荐使用
      l1.extend(l2)  # [1, 2, 3, 4, 5, 6],本质上就是用for循环一个个把l2的数据追加到l1里,所以不支持不能被for循环的数据类型
      
      
      """查询数据的方法"""
      l1 = [1, 2, 3, 4, 5, 3]
      # 1. 查询数据值直接使用print即可
      print(l1[2])  # 3
      
      # 2. 查询对应数据值的索引:index
      print(l1.index(4))  # 3
      
      # 3. 统计某个数据值出现的次数:count
      print(l1.count(3))  # 2
      
      
      """修改数据的方法"""
      l1 = [1, 4, 3, 2, 5]
      # 1. 对列表的数据修改直接使用赋值符号即可
      l1[-1] = 6
      print(l1)  # [1, 4, 3, 2, 6]
      
      # 2. 对列表进行排序:sort
      l1.sort()
      print(l1)  # [1, 2, 3, 4, 5]
      l1.sort(reverse=True)  # 设置参数反向排序,参数默认为False
      print(l1)  # [5, 4, 3, 2, 1]
      
      # 3. 对列表进行翻转:reverse
      l1.reverse()
      print(l1)  # [5, 2, 3, 4, 1]
      
      
      """删除数据的方法"""
      l1 = [1, 2, 3, 4, 5]
      # 1. 关键字删除:del
      del l1[0]  # 通过索引取值删除
      print(l1)  # [2, 3, 4, 5]
      
      # 2. 指定数据值删除:remove
      l1.remove(3)  # 填写数据值直接删除
      print(l1)  # [1, 2, 4, 5]
      
      # 3. 取出一个数据值:pop
      res = l1.pop()
      print(l1, res)  # [1, 2, 3, 4] 5  默认取出末尾的数据值
      res = l1.pop(2)
      print(l1, res)  # [1, 2, 4] 3 可以自行选择取出的数据值
      
      
      """比较运算"""
      l1 = [21, 44, 55]
      l2 = [4, 67, 33]
      print(l2 > l1)  # False 列表是从第一个开始比较,比出大小就停止比较
      l1 = [21, 44, 55]
      l2 = ['abc', 67, 33]
      print(l1 > l2)  # 报错,不同数据类型不能比较
      l1 = ['qwe', 44, 55]
      l2 = ['abc', 67, 33]
      print(l1 > l2)  # True 字符之间比较,是看编码的顺序
      
      作用关键字用法
      统计列表中数据值个数lenlen(list)
      在列表的最后追加一个数据值appendlist.append()
      在指定位置插入数据值insertlist.insert()
      合并列表extendlist.extend()
      查询对应数据值的索引indexlist.index()
      统计某个数据值出现的次数countlist.count()
      对列表进行排序sortlist.sort()
      对列表进行翻转reverselist.reverse()
      指定数据值删除removelist.remove()
      取出一个数据值poplist.pop()
  • 元组

    • 元组的类型转换
      """元组也只支持能够被for循环的数据类型转元组"""
      print(tuple(123))  # 报错
      print(tuple('abc'))  # ('a', 'b', 'c')
      
      
      """当元组内只有一个数据值时,逗号不能省略,否则类型会变成该数据值的数据类型"""
      print(type((1)))  # <class 'int'>
      print(type((1,)))  # <class 'tuple'>
      print(type(('a')))  # <class 'str'>
      print(type(('a',)))  # <class 'tuple'>
      
    • 元组的索引操作
      # 1. 索引取值操作和列表一样
      # 2. 元组可以使用索引查看对应的数据值是多少,但不能更改
      t1 = (1, 2, 3, 4, 5)
      print(t1[1[)  # 2
      t1[0] = 11  # 报错
      """元组是不可变数据类型,但元组中有数据值是可变类型,那该数据值可以改变"""
      t1 = (11, 22, 33, [44, 55])
      t1[3].remove(55)
      print(t1)  # (11, 22, 33, [44])
      
  • 字典

    • 字典的类型转换
      # 第一种方法:
      ret = dict([('name', 'xiaoming'), ('age', 18)])
      print(ret, type(ret))  # {'name': 'xiaoming', 'age': 18} <class 'dict'>
      
      # 第二种方法:
      ret = dict(name = 'xiaoming', age = 18)
      print(ret, type(ret))  # {'name': 'xiaoming', 'age': 18} <class 'dict'>
      
    • 字典的取值
      info = {
      'name': 'xiaoming',
      'age': 20,
      'gender': True
      }
      # 1. 字典中是无序的,所以不能使用索引取值
      print(info['name'])  # xiaoming  如果找不到键则会报错,所以不推荐使用
      print(info['user'])  # 报错
      print(info.get('name'))  # xiaoming
      print(info.get('user'))  # None  找不到则会返回None
      print(info.get('user', False))  # False  可以使用第二个参数自定义找不到键的返回值
      
    • 字典的内置方法
      info = {
      'name': 'xiaoming',
      'age': 20,
      'gender': True
      }
      """统计字典里键值对个数"""
      print(len(info))  # 3
      
      """修改/新增字典的值"""
      # 1. 使用赋值的方法
      info['name'] = 'xiaohong'  # 键存在则修改值
      info['hobby'] = 'run'  # 键不存在则新增一个键值对
      # 2. 使用字典内置方法:update
      info.update({'name': 'xiaohong'})
      print(info)  # 键存在则修改值
      info.update({'hobby': 'run'})
      print(info)  # 键不存在则新增一个键值对
      # 3.快速构建一个字典:fromkeys
      res = dict.fromkeys([1, 2, 3], 0)
      print(res, id(res[0]), id(res[1]), id(res[2]))  # {1: [], 2: [], 3: []} 2812102858624 2812102858624 2812102858624  默认使用的是同一个地址的值,一改全改
      
      """删除字典里的值"""
      # 使用关键字del
      del info['name']
      print(info)  # {'age': 20, 'gender': True}
      # 使用内置方法:pop
      age = info.pop('age')  # 不能不填参数,否则会报错
      print(info, age)  # {'name': 'xiaoming', 'gender': True} 20  取出键对应的值
      # 使用内置方法:popitem
      info.popitem()  # 随机删除
      print(info)  # {'name': 'xiaoming', 'age': 20} ,pycharm会自动优化成删除最后一个
      
      """获取键/值/键值对的数据"""
      # 快速获取键
      print(info.keys())  # dict_keys(['name', 'age', 'gender'])  获取字典所有键的数据值
      # 快速获取值
      print(info.values())  # dict_values(['xiaoming', 20, True])  获取字典所有值的数据值
      # 快速获取键值对
      print(info.items())  # dict_items([('name', 'xiaoming'), ('age', 20), ('gender', True)])  快速获取字典所有键值对
      # 获取键对应的值,若值不存在,则新建一个键值对
      res = info.setdefault('name', 'xiaohong')
      print(res, info)  # xiaoming {'name': 'xiaoming', 'age': 20, 'gender': True}
      res = info.setdefault('user', 'xiaohua')
      print(res, info)  # xiaohua {'name': 'xiaoming', 'age': 20, 'gender': True, 'user': 'xiaohua'}
      
      作用关键字用法
      获取字典的值getdict.get()
      统计字典里键值对个数lenlen(dict)
      新增键值对或修改值updatedict.update()
      快速构建一个字典fromkeysdict.fromkeys()
      取出一个键值对,返回值是取出的值popdict.pop()
      随机删除一个键值对popitme() dict.popitme()
      快速获取键keysdict.keys()
      快速获取值valuesdict.values()
      快速获取键值对itemsdict.items()
      获取键对应的值,若值不存在,则新建一个键值对.setdefaultdict…setdefault()
  • 集合

    • 集合的类型转换
      能够被for循环的可变数据类型都可以转换
    • 集合的内置方法
      """去重"""
      s1 = {1, 2, 3, 4, 5, 5, 4, 2}
      print(s1)  # {1, 2, 3, 4, 5}
      
      """关系运算"""
      s1 = {1, 2, 3, 4, 5}
      s2 = {4, 5, 6, 7}
      
      """交集"""
      print(s1 & s2)  # {4, 5} 两个集合共有的数据值
      
      """差集"""
      print(s1 - s2)  # {1, 2, 3} 一个集合有而另一个集合没有的数据值
      
      """并集"""
      print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7} 两个集合所有的数据值
      
      """对称差集"""
      print(s1 ^ s2)  # {1, 2, 3, 6, 7} 两个集合除了共有数据以外的数据值
      
      """父集"""
      s1 = {1, 2, 3, 4, 5, 6, 7, 8}
      s2 = {4, 5, 6, 7}
      print(s1 > s2)  # True s1是否是s2的父集,如s1完全包含了s2,则为True
      
      作用关键字用法
      获得两个集合共有的数据值&set1 & set2
      获得一个集合有而另一个集合没有的数据值-set1 - set2
      获得两个集合所有的数据值|set1 | set2
      两个集合除了共有数据以外的数据值^set1 ^ set2
      判断一个集合不是不是另一个集合的子集>/<set1 > set2
  • 可变与不可变

    """可变类型
    如list"""
    l1 = [1, 2, 3]
    print(id(l1))  # 1487492460992
    l1.append(4)
    print(id(l1))  # 1487492460992
    # 数据值发生了变动但内存地址没有改变
    
    """不可变类型
    如str"""
    s1 = 'hello word'
    print(id(s1))  # 2486728472176
    s1 = s1.upper
    print(id(s1))  # 2486728744288
    # 数据值发生了改变内存地址也会跟着改变
    
  • 练习
    	"""1.
    利用列表编写一个员工姓名管理系统
    输入1执行添加用户名功能
    输入2执行查看所有用户名功能
    输入3执行删除指定用户名功能
    ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
    提示: 循环结构 + 分支结构
    拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写
    不会没有关系)
    """
    user_dict = {}  # 创建空字典用来存储用户信息
    while True:
        print("""
        1.添加用户
        2.查看用户
        3.删除用户
        4.关闭系统
        """)
        option = input('请输入您要使用的功能(1-4):')
        if not option.isdigit():  # 判断是否为数字
            print('请输入数字')
        elif int(option) == 1:
            print('添加新用户\n')
            user = input('请输入您的用户名:')
            pwd = input('请输入您的密码:')
            user_list = [user, pwd]  # 将用户的用户名和密码保存在列表中
            user_dict[f'{len(user_dict)+1}'] = user_list  # 使用一个序号作为键,信息为值保存
        elif int(option) == 2:
            print('查看用户\n')
            for k, v in user_dict.items():  # 循环用户字典的键值对
                print(k, v[0])  # 打印序号和用户名
        elif int(option) == 3:
            print('删除用户\n')
            del_user = input('请输入想要删除的序号:')
            for i in user_dict.keys():  # 循环查找是否有需要删除的用户
                if i == del_user:  # 如果有就删除并退出循环
                    user_dict.pop(del_user)
                    break
            else:
                print('没有查询到此人')  # 循环完字典都没有找到则执行这条代码
        elif int(option) == 4:
            break  # 退出关键字
        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 = []
    for i in l1:  # 循环原列表
        if i in l2:  # 如果在新列表中有的数则跳过这个循环
            continue
        else:  # 没有出现过则追加进新列表
            l2.append(i)
    print(l2)
    
    """3.
    有如下两个集合,pythons是报名python课程的学员名字集合,linuxs是报名linux课程的学员名字集合
      pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
      linuxs = {'kermit', 'tony', 'gangdan'}
    """
    pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
    linuxs = {'kermit', 'tony', 'gangdan'}
    # 1.求出即报名python又报名linux课程的学员名字集合
    print(pythons & linuxs)
    # 2.求出所有报名的学生名字集合
    print(pythons | linuxs)
    # 3.求出只报名python课程的学员名字
    print(pythons - linuxs)
    # 4.求出没有同时这两门课程的学员名字集合
    print(pythons ^ linuxs)
    
    
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值