美文网首页
总结Day8_元祖、字典、集合

总结Day8_元祖、字典、集合

作者: RiskHY | 来源:发表于2019-01-03 19:36 被阅读0次

    ===元祖===

    1.什么是元祖(tuple)

      python提供的容器型数据类型,不可变并且有序。(元祖就是不可变的列表)
      不可变 - 不支持增删改,只支持查
      有序 - 每个元素对应一个确定的下标

    2.字面量和元素

      (元素1, 元素2, 元素3...)
      其中的元素可以是任何类型的数据,并且类型可以不一样,同样的元素可以有多个

    point = (100, 30)
    print(point, type(point))
    

      注意:
      1.空的元祖: ()

    tuple1 = ()
    print(type(tuple1))
    

      2.只有一个元素的元祖

    tuple2 = (100,)
    print(tuple2, type(tuple2))
    

      3.直接将多个元素用逗号隔开,不加小括号表示也是一个元祖

    tuple3 = 1, 2, 3
    print(tuple3, type(tuple3))
    
    3.元祖获取元素和列表一样
    tuple4 = ('成都', '达州', '绵阳', '南充', '广元')
    # 获取单个元素
    print(tuple4[1], tuple4[-1])
    
    # 获取部分
    print(tuple4[0:3])
    print(tuple4[::-1])
    
    # 遍历
    for city in tuple4:
        print(city)
    
    for index in range(len(tuple4)):
        print(tuple4[index])
    

      补充:特殊的获取方式
      1. 变量1,变量2... = 元祖 -- 用前面的变量依次获取元祖元素的值。(要求前面变量的个数和元祖元素的个数一致)

    point = (100, 200, 10)
    x, y, z = point    # x,y = (100, 200)  <==> x, y = 100, 200
    print(x, y, z)
    

      2. 变量1, 变量2 = 元祖 -- 通过带的变量获取元祖中剩余的部分;
      注意:这个结构中带的变量只能有一个,不带的变量可以有多个

    name, *scores = ('小明', 100, 89, 67, 99)
    print(name, scores)
    
    name, num, *scores = ('小明', 100, 89, 67, 99)
    print(name, num, scores)
    
    *info, num1, num2 = ('小明', 100, 89, 67, 99)
    print(info, num1, num2)
    
    info1, *nums, num1 = ('小明', 100, 89, 67, 99)
    print(nums)
    

      补充:*的用法

    # 1.取元祖和列表中的数据
    nums = (1, 2, 3)
    nums2 = [11, 22, 33]
    print(*nums, *nums2)
    
    4.相关运算(和列表一样)

      +,*
      in / not in
      len(), max(), min(), sum(), tuple()

    tuple1 = (1, 2, 3)
    tuple2 = ('aa', 'bb')
    print(tuple1 + tuple2)
    print(tuple1*3)
    
    print('aaa' in tuple2)
    

    """

    5.排序

      sorted(序列) - 对序列中的元素排序,产生一个新的列表(不管是什么序列,排完后最后都是列表)

      注意:列表.sort() -- 修改原列表中元素的顺序; sorted(列表) -- 产生一个新的列表

    nums = (1, 34, 89, 9)
    new_nums = sorted(nums, reverse=True)
    print(new_nums, tuple(new_nums),nums)
    

      join的使用
      字符串.join(序列) - 将序列中的元素取出,用指定的字符串连接在一起。要求序列中的元素必须是字符串

    new_str = ''.join(['aks', 'bos', 'cous'])
    print(new_str, type(new_str))
    
    list1 = [1, 345, 90, 9]
    new_list = list1.sort()    # None; sort不会产生新的列表
    print(list1, new_list)
    

    ===字典===

    1.什么是字典(dict)

      python提供的容器型数据类型,可变并且无序
      可变 - 支持元素的增删改
      无序 - 不支持下标操作

    2.字面量和元素

      用大括号括起来,里面多个键值对,每个键值对用逗号隔开。键值对就是字典的元素。
      {key1:value1, key2:value2, key3:value3...}
      键值对 -- 键/key:值/value(键值对); 键值对必须成对出现,而且脱离字典单独出现没有意义
      键/key -- 必须是不可变的, 而且是唯一的。实际一般将字符串作为键
      值/value -- 可以是任意类型的数据
      注意: 字典存储数据,实质是通过值来存储的。key是值对应的标签和获取值的方式

    dict1 = {}    # 空字典
    print(type(dict1))
    
    dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 111, 'a': [1, 11, 111]}
    print(dict1)   # {'a': [1, 11, 111], 10: 200, (1, 2): 'abc'}, key唯一
    
    # dict2 = {[1, 2]: 120}   # TypeError: unhashable type: 'list'
    
    3.什么时候使用字典

      多个没有相同意义的数据(需要区分),就使用字典。例如:保存一个人的不同信息,一辆车的不同信心
      什么时候使用列表: 存储的多个数据是有相同意义的数据(不需要区分),就使用列表.例如:保存一个班的学生信息,保存所有的价格

    person = ['xiaohua', 18, 'girl', 160, 90, 89]
    print(person[1])
    person[-2]
    
    person = {'name': 'xiaohua', 'age': 18, 'sex': 'girl', 'height': 160, 'weight': 90, 'score': 89}
    print(person['age'])
    
    # 练习: 声明一个变量保存一个班的学生信息(4个学生),每个学生需要保存姓名,电话和年龄
    all_students = [
        {'name': '小明', 'tel': '23897823', 'age': 20},
        {'name': '张三', 'tel': '238722111', 'age': 28},
        {'name': '李四', 'tel': '2111111222', 'age': 18},
        {'name': 'xiaohua', 'tel': '111228233', 'age': 30}
    ]
    print(all_students[0])
    

    ===字典元素操作===

      字典元素的增删改查

    1.查(获取值)

      注意:字典中的键值对单独拎出来没有任何意义
      a.字典[key] - 获取字典中key对应值
      注意: 当key不存在的时候,会报KeyError

    car = {'color': '黄色', 'type': '跑车', 'price': 500000}
    print(car['color'])
    print(car['price'])
    # print(car['speed'])  # KeyError: 'speed'
    

      b.字典.get(key) - 获取字典中key对应值; 当key不存在的时候不会报错,并且取到一个默认值None
      字典.get(key,值1) - 获取字典中key对应值;当key不存在的时候不会报错,并且取到指定的值1

    print(car.get('type'))
    print(car.get('speed'))
    
    print(car.get('color', '红色'))   # 黄色
    print(car.get('speed', 0))       # 0
    

      c.遍历字典
      注意: 直接通过for-in遍历字典取到的是key

    dict1 = {'a': 100, 'b': 200, 'c': 300}
    # 遍历字典取到的是key(推荐使用)
    for key in dict1:
        # key
        print(key, end=' ')
        # value
        print(dict1[key])
    
    
    print(dict1.values(), dict1.items())
    # 遍历字典的values(),获取所有的值
    for value in dict1.values():
        print(value)
    
    # values = []
    # for key in dict1:
    #     values.append(dict1[key])
    # for value in values:
    #     print(value)
    
    
    # 遍历字典的items(),直接获取key和value(不建议使用)
    for key, value in dict1.items():
        print(key, value)
    
    # items = []
    # for key in dict1:
    #     items.append((key, dict1[key]))
    # for key,value in items:
    #     print(key, value)
    
    2.增、改

      字典[key] = 值 - 当key不存在就是添加键值对; 当key存在的时候就是修改key对应的值

    movie = {'name': '喜羊羊与灰太狼', 'type': '卡通', 'time': 120}
    
    # 添加
    movie['score'] = 7.9
    print(movie)
    
    # 修改
    movie['type'] = '搞笑'
    print(movie)
    
    3.删(删除键值对)

      a.del 字典[key] - 删除字典中指定的key对应的键值对

      b.字典.pop(key) - 取出字典中key对应的值

    del movie['time']
    print(movie)
    
    name = movie.pop('name')
    print(movie, name)
    
    # 练习: 用一个字典保存一个学生的信息: {'name': '张三', 'age': 30, 'score': 80}
    # 输入需要修改的信息,例如输入:name ->修改名字, age -> 修改年龄... abc -> 提示'没有该信息'
    """
    请输入要修改的信息: name
    请输入新的名字: 李四
    {'name': '李四', 'age': 30, 'score': 80}
    
    请输入要修改的信息: age
    请输入新的年龄: 18
    {'name': '张三', 'age': 18, 'score': 80}
    
    请输入要修改的信息: abc
    没有该信息!
    """
    student = {'name': '张三', 'age': 30, 'score': 80}
    message = input('请输入要修改的信息:')
    
    if student.get(message):
        if message == 'name':
            new_name= input('请输入新的名字:')
            student['name'] = new_name
        elif message == 'age':
            new_age = int(input('请输入新的年龄:'))
            student['age'] = new_age
        else:
            new_score = input('请输入新的分数:')
            student['score'] = new_score
    
        print(student)
    
    else:
        print('没有该信息!')
    

    ===字典相关===

    1.比较运算

      ==, !=
      注意:判断两个字典是否相等,只看键值对是否一样,不管键值对的顺序;
      字典不支持>和<符号

    print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})   # True
    
    2. in / not in

      key in 字典 --- 判断字典中指定的key是否存在
      key not in 字典 --- 判断字典中指定的key是否不存在

    dict1 = {'a': 1, 'z': 2, 'c': 3}
    print('a' in dict1)  # True
    print(1 in dict1)    # False
    
    3. len(), max(), min()

      dict(数据) - 数据要求是序列,并且序列中的元素都是有两个元素的子序列

    # 获取字典中键值对的个数
    print(len(dict1))
    # 获取字典中key的最大值/最小值
    print(max(dict1), min(dict1))
    
    # 将列表转换成字典
    print(dict([(1, 2), ('a', 'b'), [10, 'abc']]))
    
    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    # 字典转列表/元祖/集合都是将字典中的key取出来作为列表/元祖/集合的元素
    print(list(dict2))      # ['name', 'color', 'height']
    
    4.相关方法

      1.字典.clear() - 清空字典
      注意:清空容器推荐使用clear操作,而不是重新赋一个空的容器

    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    print(id(dict2))
    dict2.clear()
    print(dict2, id(dict2))
    
    # 只有容器本身不存在的时候,可以使用
    dict2 = {}
    print(id(dict2))
    

      2.字典.copy() - 复制字典的中的元素,产生一个新的字典

    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    # 直接赋值,修改其中一个的元素,会影响另外一个
    dict3 = dict2
    print(dict3)
    dict3['name'] = '小明'
    print(dict3)
    print(dict2)
    
    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    # 拷贝赋值,会产生新的地址,赋值后相互不影响
    dict4 = dict2.copy()
    print(dict4)
    del dict4['color']
    print(dict4)
    print(dict2)
    

      3. dict.fromkeys(序列, 值) -- 以序列中所有的元素作为key,指定的值作为value创建一个新的字典

    new_dict = dict.fromkeys('abc', (10, 20, 30))
    print(new_dict)
    
    new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
    print(new_dict)
    

      字典.keys() - 将字典所有的key取出产生一个新的序列
      字典.values() - 将字典所有的value取出产生一个新的序列
      字典.items() - 将字典所有的key和value做为一个元祖取出产生一个新的序列

    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    print(dict2.keys(), dict2.values(), dict2.items())
    

      4.字典.setdefault(key, value=None)

      字典.setdefault(key) - 当key不存在的时候,添加键值对key:None
      字典.setdefault(key, value) - 当key不存在的时候,添加键值对key:value
      注意:这个操作当key存在的时候,不会修改

    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    
    dict2.setdefault('name2', '小胡')
    dict2.setdefault('sex')
    print(dict2)
    

      5. 字典1.update(字典2) - 使用字典2中的键值对去更新字典1;
      如果字典2中的key,字典1中本身存在就是修改,不存在就添加

    dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
    dict2.update({'height': 180, 'age': 18})
    print(dict2)
    
    dict2.update([('a', 100), ('age', 30)])
    print(dict2)
    

    ===集合===

    1.什么是集合(set)

      可变的,无序的; 元素是唯一并且不可变

    2.字面量

      {元素1, 元素2, 元素3...}

    set1 = {1, 23, 'abc'}
    print(set1)
    # set1 = {1, 23, 'abc', [1, 2]}  # TypeError: unhashable type: 'list'
    
    # 表示空集合
    set2 = set()
    print(type(set2))
    
    set3 = {1, 2, 1, 2, 2}
    print(set3)
    
    # 集合自带去重功能
    list1 = [1, 2, 1, 2, 2]
    list1 = list(set(list1))
    print(list1)
    
    3.增删改查

      set1 = {1, 38, 90, 8}
      1.查
      集合不能单独的获取单个元素,只能一个一个的遍历

    for item in set1:
        print(item)
    

      2.增
      a.集合.add(元素) - 在集合中添加指定的元素
      b.集合.update(序列) - 将序列中的元素添加到集合中

    set1 = {1, 38, 90, 8}
    set1.add('abc')
    print(set1)
    
    set1.update('abc')
    print(set1)
    
    set1.update({'aa': 10, 'bb': 20})
    print(set1)
    

      3.删
      集合.remove(元素) --- 删除集合中指定的元素

    set1 = {1, 38, 90, 8}
    set1.remove(90)
    print(set1)
    
    4.数学集合运算

      交集(&): 获取两个集合公共的元素产生一个新的集合
      并集(|): 将两个集合中的元素合并在一起产生一个新的集合
      差集(-): 集合1 - 集合2:去掉集合1中包含集合2的部分,剩下的产生一个新的集合
      补集(^): 将两个集合合并在一起,去掉公共部分,剩下的部分产生一个新的集合
      子集的判断: 集合1>集合2 -> 判断集合1中是否包含集合2, 集合1<集合2 - 判断集合1中是否包含集合2

    set1 = {1, 2, 3, 4, 5, 6}
    set2 = {4, 5, 6, 7, 8}
    # 交集
    print(set1 & set2)  # {4, 5, 6}
    # 并集
    print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}
    # 差集
    print(set1 - set2)  # {1, 2, 3}
    # 补集
    print(set1 ^ set2)  # {1, 2, 3, 7, 8}
    
    print({1, 2, 3, 9, 18} > {1, 2, 3, 0})   # False
    print({1, 2, 3, 9, 18} > {1, 2, 3})     # True、
    
    print({1, 2, 3} > {1, 2, 3})     # False
    print({1, 2, 3} >= {1, 2, 3})    # True
    

    相关文章

      网友评论

          本文标题:总结Day8_元祖、字典、集合

          本文链接:https://www.haomeiwen.com/subject/qaeqrqtx.html