首页 > 其他 > 详细

数据类型及内置方法2

时间:2019-09-16 21:36:56      阅读:63      评论:0      收藏:0      [点我收藏+]

一、元组

  1. 作用:能够存储多个元素,元素与元素之间逗号隔开。元组可以是任意类型,元组不能被修改。

  2. 定义

    t = (1, 2, 3, 'a', [1, 2, 3])
    t = tuple((1, 2, 3))
    t = tuple((1,))    # 内部只有一个元素的时候,也要加逗号。
    print(type(t))
  3. 有序or无序

    有序

  4. 可变or不可变

    不可变

  5. 常用操作和内置方法

    • 按索引取值(只能取不能存)

      t = (1, 2, [3, 4])
      print(t[0]    # 1
      
      t[-1][1] = 5
      print(t)    # (1, 2, [3, 5])    # 包含的可变类型能改
    • 切片(顾头不顾尾,步长)

      t = (1, 2, 3, 4)
      print(t[::2])    # (1, 3)
    • 长度

      t = (1, 2, 3, 4)
      print(len(t))    # 4
    • 成员运算

      t = (1, 2, 3)
      print(1 in t)    # True
    • 循环

      t = (1, 2, 3)
      for i in t:
          print(i)
    • 计数

      t = (1, 1, 3)
      print(t.count(1))    # 2
    • 查询索引

      t = (1, 2, 3)
      print(t.index(2))    # 1

二、字典

  1. 作用:能存储多组键值对,key是不可变类型,value可以是任意类型

  2. 有序or无序

    无序

  3. 可变or不可变

    可变

  4. 定义

    d = {'name': 'byx', 'age': 18}    # 第一种方法
    
    d = dict(name = 'byx', age = 18)    # 第二种方法
    
    l = [
    ['name', 'byx'],
    ['age', 18],
    ['hobby', 'read']
    ]
    d = {}
    for k, l in l:
    d[k] = v
    print(d)    # 第三种方法
    
    l = [
    ['name', 'byx'],
    ['age', 18],
    ['hobby', 'read']
    ]
    d = dict(l)
    print(d)    # 第四种方法
    
    d1 = {'name': 'byx', 'name': 'yxb'}
    print(d1)    # {'name': 'yxb'}    字典的key如果重复,会存入最后一组重复的键值对
  5. 操作以及内置方法

    • 按key存取值(可存可取)

      d = {'name': 'byx', 'age': 18}
      print(d['name'])    # byx
      d['name'] = 'yxb'
      print(d['name'])    # yxb
      
      print(id(d))    # 1934832365856
      d['gender'] = 'male'
      print(d, id(d))    # {'name': 'byx', 'age': 18, 'gender': 'male'} 1934832365856
    • 成员运算

      d = {'name': 'byx', 'age': 18}
      print(i8 in d)    # False     只能判断键
    • 删除

      d = {'name': 'byx', 'age': 18}
      del d['name']    
      print(d)    # {'age': 18}
      
      d = {'name': 'byx', 'age': 18}
      res = d.pop('age')    # 弹出
      print(res)    # 18    返回值是值,键不存在时报错
      print(d)    # {'name': 'byx'}
      
      
      d = {'name': 'byx', 'age': 18}
      res = d.popitem()    # 尾部以元组形式弹出键值对
      print(res)    # ('age', 18)
      print(d)    # {'name': 'byx'}
      
      d = {'name': 'byx', 'age': 18}
      d.clear()    # 清空
      print(d)    # {}
    • 获取所有键、值、键值对

      d = {'name': 'byx', 'age': 18}
      
      print(d.keys())    # dict_keys(['name', 'age'])
      print(d.values())    # dict_values(['byx', 18])
      print(d.items())    # dict_items([('name', 'byx'), ('age', 18)])     ;列表套元组
    • 循环

      d = {'name': 'byx', 'age': 18}
      for i in d:
          print(i,end=" ")    # name age
    • get取值

      d = {'name': 'byx', 'age': 18}
      print(d.get('name'))    # byx
      print(d.get('hobby', '字典里没有hobby'))    # 字典里没有hobby 
      # get可以传第二个参数,key不存在时,返回第二个参数。不传参时返回None
    • dict.fromkeys()创造字典

      l1 = ['name', 'password', 'age']
      print(dict.fromkeys(l1, 123))    # {'name': 123, 'password': 123, 'age': 123}    
    • dict.setdefalt()增加键值对

      d = {'name': 'byx', 'pwd': 123}
      res1 = d.setdefault('name', 'ybx')    # 添加存在的键值对
      print(res1)    # byx    返回存在的值
      print(d)    # {'name': 'byx', 'pwd': 123}    不做修改
      
      res2 = d.setdefault('age', 18)    # 添加不存在的键值对
      print(res2)    # 18    返回添加的值
      print(d)    # {'name': 'byx', 'pwd': 123, 'age': 18}    添加成功
    • dict.update()字典拼接

      d1 = {'name': 'byx', 'pwd': 123}
      d2 = {'age': 18, 'hobby': 'read'}
      d1.update(d2)
      print(d1)    # {'name': 'byx', 'pwd': 123, 'age': 18, 'hobby': 'read'}

三、集合

  1. 作用

    • 关系运算
    • 去重
  2. 定义

    集合的元素遵循三原则:

    • 每个元素必须是不可变类型
    • 没有重复元素(自动去重)
    • 无序
    s = {1, 2, 3, 4, 5}
    s = set({1, 2, 3, 4, 5})
    print(type(s))
    
    x = {}
    print(type(x))    # 空字典
    
    s1 = set()
    print(type(s1))    # 空集合
  3. 操作与内置方法

    • 长度
    s = {1, 2, 3, 4}
    print(len(s))
    • 成员运算

    • 集合运算

      group1 = {'a', 'b', 'c'}
      group2 = {'b', 'c', 'd'}
      print(group1 & group2)    # {'b', 'c'}    交集
      print(group1 - group2)    # {'a'}    差集
      print(group1 ^ group2)    # {'d', 'a'}    对称差
      print(group1 | group2)    # {'d', 'a', 'b', 'c'} 
    • 添加

      s = {1, 2, 3, 4}
      print(s.add(5))    # {1, 2, 3, 4, 5}
    • 删除

      s = {1, 2, 3}
      print((s.remove(4))    # 报错
      
      s = {1, 2, 3}
      print(s.discard(4))    # None    不报错

数据类型及内置方法2

原文:https://www.cnblogs.com/binyuanxiang/p/11529738.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!