美文网首页
Day-8 - 字典和集合（2018-10-09）

Day-8 - 字典和集合（2018-10-09）

作者: 雨雨雨90 | 来源:发表于2018-10-09 16:45 被阅读0次

    一、元组

    1.什么是元组

    格式：tuple = (元素1， 元素2， ……, 元素n)
    tuple = 元素1, 元素2, ……, 元素n
    注意：只有一个元素时， 元素后加逗号
    singel_tuple = (元素1,)
    singel_tuple = 元素1,

    空元组，
    empty_tuple = ()

    使用（）将多个元素括起来，多个元素之间用逗号隔开

    • a.容器，可以同时存储多个数据，不可变的，有序的
      不可变 ---> 不能增删改
      有序 ---> 可以通过下标获取元素

    • b.元素,可以是任何类型的数据

    tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)
tuple2 = 1, 2, 3
tuple3 = 1,
print(tuple1, tuple2, tuple3, sep = "\n")

    注意：1.如果元组的元素只有一个的时候，必须在元素的后面加逗号

    tuple2 = (100)
print(type(tuple2))  # <class 'int'>

tuple2 = (100,)
print(type(tuple2))  # <class 'tuple'>

    注意： 2.多个数据直接用逗号隔开，表示的也是一个元组

    tuple2 = 10, 20, 'abc'
print(tuple2, type(tuple2))  # (10, 20, 'abc') <class 'tuple'>

    2.元素的查

    元组的元素不支持增删改
    列表获取元素的方式，元组都支持：元组[下标]，元组[:],元组[::]
    index[]

    tuple2 = ('星期一', '星期二', '星期三', '星期四', '星期五')
print(tuple2[1])
print(tuple2[2:])
print(tuple2[::-1])

    for item in tuple2:
    print(item)

    index = 0
while index < len(tuple2):
    print(tuple2[index])
    index += 1

    补充：获取部分元素
    可以通过相同的变量个数，来一一获取元组中的元素

    x, y = (10, 20)
print(x, y)

    应用：交换两个数的值

    a = 100
b = 200
tuple6 = (a, b)  # 过程简写 a, b = b, a 或 a, b =(b, a)
b, a = tuple6
print(a, b)

    方法二：
    可以通过在变量前加*来获取部分元素

    tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score)  # 小明 [90, 89, 67, 100]

tuple2 = (90, 89, 67, 100, '小明')
*score, name = tuple2
print(score, name)  # [90, 89, 67, 100] 小明

list1 = ['boy', 15300022673, 90, 89, 67, 100, '小明']
sex, tel, *score, name = list1
print(sex, score, name)  # boy [90, 89, 67, 100] 小明

    可以通过在列表或者元组前加*，来展开列表中的元素

    tuple3 = (1, 2, 3, 4)
print(*tuple3)  # 1 2 3 4

list1 = ['abc', 100, 200]
print(*list1)  # abc 100 200

    3.元组的运算

    +，*，==，is, in, not in ---> 和列表一样

    print((1, 2, 3) + ('a', 'b', 'c'))  # (1, 2, 3, 'a', 'b', 'c')
print((1,2) * 3)  # (1, 2, 1, 2, 1, 2)

    4.len(), max(), min()

    tuple3 = 10, 230, 100, 78, 34
print(len(tuple3))  # 5
print(max(tuple3))  # 230
print(min(tuple3))  # 10

    5.tuple()

    所有的序列都可以转换成元组，注意，字典只能将key值作为元组元素

    print(tuple('abcd'))  # ('a', 'b', 'c', 'd')
print(tuple([1, 223, 90]))  # (1, 223, 90)
print(tuple(range(5)))  # (0, 1, 2, 3, 4)
print(tuple({'a': 100, 'b': 200}))  # ('a', 'b')

    6.sorted()

    可以通过sorted()方法，对元组进行排序，产生一个新的列表

    tuple3 = 10, 230, 100, 78, 34
new = sorted(tuple3)
print(new, tuple3)  # [10, 34, 78, 100, 230] (10, 230, 100, 78, 34)

    二、认识字典

    什么时候用容器类型的数据？ ---> 需要同时保持多个数据的时候
    什么时候用列表？ ---> 保存的多个数据是同一类的数据（不需要区分）
    什么时候用字典? ---> 保存的多个数据是不同类的数据（需要区分）

    1.什么是字典(dict)

    字典是一个容器类的数据类型，可以用来存储多个数据（以键值对的形式存储）
    {key1: value1, key2: value2, ……}
    可变 ---> 可以增删改
    无序 ---> 不能通过下标获取值

    键（key）: 用来定位值的，要求只能是不可变的数据类型（数字，字符串，元组……）,是唯一的
    值（value):存储的数据，可以是任何类型的数据

    person = {'name': 'yuxiaoyu', 'age': 28, 'tel':'173****0924'}
dict1 = {1: 2, 22: 33}
# dict2 = {[1, 2]: 2}  # TypeError: unhashable type: 'list'
dict2 = {(1, 2): 22}
dict3 = {'name': 'yuyu', 'name': 'haha'}
print(dict3)  # {'name': 'haha'}如果键不唯一，只取一个

    三、字典的增删改查

    1.查（获取键值对的value)

    获取字典的值，必须通过key来获取

    • a.字典[key] ---> 获取key对应的值
      注意：key值必须是存在的，否则会报KeyError
    student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
print(student['name'])
print(student['gender'])
# print((student['score']))  # KeyError: 'score'
    • b.字典.get(key) ---> 通过key获取值
      注意：key值不存在的时候不会报错，结果是None
    print(student.get('age'))  # 30
print(student.get('score'))  # None

    确定key一定存在就是使用[]语法，key可能不存在的时候使用get语法

    • c.直接遍历字典（推荐使用）
      通过for-in遍历字典拿到的是key值
    student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}

for x in student:
    print(x)  # 打印student的key
    • d.其他遍历方式（了解）
      直接遍历拿到值
      （将字典先遍历一遍，将字典里面的值取出，放到一个容器里面，浪费CPU资源）
    for value in student.values():
    print(value)  # 打印student的值

    遍历拿到key和value

    for key, value in student.items():
    print(key, value)  # 打印student的键和值

print(student.items())  # dict_items([('name', '小明'), ('age', 30), ('study_id', 'py001'), ('gender', 'male')])

    (在上面的基础上，items还要进行类型的转换，消耗CPU资源）

    2.增（添加键值对）

    字典[key] = 值 （key不存在）

    car = {}
car['color'] = 'yellow'
print(car)  # {'color': 'yellow'}

car['price'] = 300000
print(car)  # {'color': 'yellow', 'price': 300000}

    3.修改（修改值）

    字典[key] = 新值（key存在）

    car['color'] = 'red'
print(car)  # {'color': 'red', 'price': 300000}

    4.删（删除键值对）

    • a. del 字典[key] ---> 通过key删除键值对
    student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
del student['age']
print(student)  # {'name': '小明', 'study_id': 'py001', 'gender': 'male'}
    • b. pop(key) ---> 取出key对应的值（实质还是删除key对应的键值对）
    name = student.pop('name')
print(student, name)  # {'study_id': 'py001', 'gender': 'male'} 小明

    四、字典的相关操作

    1. 字典相关运算

    == : 判断两个字典的值是否相等
    is : 判断两个字典的地址是否相等

    in 和 not in : key in 字典 / key not in 字典 （看键是否在字典）

    print({'a': 100, 'b': 200} == {'b': 200, 'a': 100})  # True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100})  # False
print('a' in {'a': 100, 'b': 200})  # True
print(100 in {'a': 100, 'b': 200})  # False

    2.字典相关的函数和方法

    • 1.len(字典) ---> 获取键值对的个数
    dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(dict1))
    • 2.字典.clear() ---> 清空字典
    dict1.clear()
print(dict1)
    • 3.字典.copy() ---> 将字典中的键值对复制一份，产生一个新的字典
    dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = dict1.copy()
print(dict2)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1 is dict2)  # False
    • 4.dict.fromkeys(序列,值) (静态方法）
      ---> 创建一个字典，将序列中的每个元素作为key,值作为value
    dict3 = dict.fromkeys('abcd', 100)
print(dict3)  # {'a': 100, 'b': 100, 'c': 100, 'd': 100}
    • 5.字典.get(key) --> key不存在取None
      字典.get(key,默认值) --> key不存在取默认值
    student = {}
print(student.get('name'))  # None
print(student.get('name', '无名'))  # 无名
    • 6.字典.values() ---> 返回所有值对应的序列
      字典.keys() ---> 返回所有键对应的序列
      字典.items() ---> 将键值对转换成元组，作为一个序列的元素
      注意：返回的都不是列表，是其他类型的序列
    dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1.items(),type(dict1.items()))  # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'dict_items'>

items = list(dict1.items())
print(items,type(items))  # [('a', 1), ('b', 2), ('c', 3), ('d', 4)] <class 'list'>
    • 7.字典.setdefault(key) ---> 添加键值对，键是key,值是None
      字典.setdefault(key,值) ---> 添加键值对，键是key，值是value
      注意：key存在的时候，对字典不会有任何操作（不会修改key对应的值）
    dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict1.setdefault('aa')
print(dict1)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None}
dict1.setdefault('bb', 100)
print(dict1)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None, 'bb': 100}
    • 8.字典1.update(字典2) ---> 使用字典2中的键值对取更新字典1(已经存在的key就更新，不存在的就添加)
    dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 200, 'c': 100}
dict1.update(dict2)
print(dict1)  # {'a': 1, 'b': 200, 'c': 100}

    五、集合

    1.什么是集合（set)

    容器，可以同时存储多个数据，可变的，无序的，元素是唯一的
    {元素1, 元素2, ……}
    可变 --> 增删改
    无序 --> 不能通过下标获取元素
    唯一 --> 自带去重的功能

    元素只能是不可变的数据

    set1 = {10, 'abc', (10, 200)}
# set2 = {[1, 2]}  # TypeError: unhashable type: 'list'
# set3 = {{'a': 1}}  # TypeError: unhashable type: 'dict'
set4 = {}  # 这是一个空的字典

    2.集合的增删改查

    a.查（获取元素）

    集合不能单独获取一个元素，也不能切片，只能通过for-in来遍历

    for x in set1:
    print(x)
# abc
# (10, 200)
# 10

    b.增

    • 集合.add(元素) --> 在集合中添加一个元素
    set1 = {1, 2, 3}
set1.add(4)
print(set1)  # {1, 2, 3, 4}
    • 集合.update(序列) --> 将序列中的元素添加到集合中（序列为字典时，只添加键到集合中）
    set1.update({'a', 'b'})
print(set1)  # {1, 2, 3, 4, 'a', 'b'}

set1.update('fsdf1231')
print(set1)  # {1, 2, 3, 4, '2', '3', 's', 'd', '1', 'b', 'f', 'a'}

set2 = {1, 2, 3}
set2.update([4, 5, 6])
print(set2)  # {1, 2, 3, 4, 5, 6}

set2.update({'a': 7, 'b': 8, 'c': 9})
print(set2)  # {1, 2, 3, 4, 5, 6, 'c', 'b', 'a'}

    3.删（删除元素）

    • 集合.remove(元素) ---> 删除指定的元素
    set2 = {1, 2, 3}
set2.remove(1)
print(set2)  # {2, 3}

    4.改（集合不能改）

    六、集合相关的数学运算

    集合相关的运算：是否包含，求交集、并集、差集、补集

    1.包含

    集合1 >= 集合2 --> 判断集合1中是否包含集合2
    集合2 <= 集合2 --> 判断集合2中是否包含集合1

    set1 = {1 ,2, 3, 4, 5}
set2 = {3, 4, 5}
print(set1 >= set2)  # True

set1 = {1 ,2, 3, 4, 5, 10}
set2 = {3, 4, 5, 6}
print(set1 >= set2)  # False

    2.交集 &

    & ：求两个集合公共的部分

    set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 & set2)  # {1, 3, 5}

    3.求并集

    | --> 求两个集合的和

    set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 | set2)  # {1, 2, 3, 4, 5, 7, 9}

    4.求差集

    集合1 - 集合2 --> 求集合1中除了集合2以外的部分

    set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 - set2)  # {2, 4}

    5.求补集

    集合1 ^ 集合2 --> 求两个集合除了公共部分以外的部分

    set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 ^ set2)  # {2, 4, 7, 9}

    七、类型转换

    1.整型

    int()
    浮点数、布尔、部分字符串可以转换成整型

    只有去掉引号后本身就是一个整数的字符串才能转换成整型

    print(int('34'))  # 34
print(int('+34'))  # 34
print(int('-34'))  # -34
# print(int('34.5'))  # ValueError: invalid literal for int() with base 10: '34.5'

    2.浮点数

    float()
    整数，布尔，部分字符串可以转换成浮点数
    去掉引号，本身就是一个数字的字符串才能转换成浮点数

    
print(float(100))  # 100.0
print(float(True))  # 1.0
print(float('34.90'))  # 34.9
print(float('100'))  # 100.0

    3.布尔

    bool()
    所有的数据都可以转换成布尔值，
    为空为0的值转换成False,其他的数据都转换成True

    num = 230
if num % 2:
    print('是奇数')
else:
    print('是偶数')

    4.字符串

    str()
    所有的数据都可以转换成字符串
    数据转换成字符串，就是在数据的最外面加引号

    print(str(100))  # 00
print([str(True)])  # ['True']
print(str([1, 2, 3, 4]))  # [1, 2, 3, 4]
print(str({'a': 1, 'b': 2}))  # {'a': 1, 'b': 2}
print(str(lambda  x:x*2))  # <function <lambda> at 0x0000000002381E18>
print(len(str([1, 2, 3, 4])))  # 12

    5.列表

    list()
    序列才能转换成列表
    将序列中的元素作为列表的元素(字典转换成列表，是将字典的key转换成列表的元素)

    print(list('abcd'))  # ['a', 'b', 'c', 'd']
print(list((23, 45, 'ac')))  # [23, 45, 'ac']
print(list({'a': 100, 'b': 200}))  # ['a', 'b']
print(list({'a': 100, 'b': 200}.items()))  # [('a', 100), ('b', 200)]

    6.元组

    tuple()
    只能将序列转换成元组

    print(tuple('abcd'))  # ('a', 'b', 'c', 'd')
print(tuple({'a': 100, 'b': 200}))  # ('a', 'b')

    7.字典

    dict()
    序列的每个元素有两个元素的数据才能转换成字典

    list1 = [(1, 2)]
print(dict(list1))  # {1: 2}

tuple1 = ((1, 2), ['a', 10])
print(dict(tuple1))  # {1: 2, 'a': 10}

    8.集合

    set()
    序列可以转换成集合，有去重的功能

    print(set([1, 1, 90, 3, 10, 10]))  # {10, 1, 90, 3}

    相关文章

      网友评论

          本文标题：Day-8 - 字典和集合（2018-10-09）

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

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Day-8 - 字典和集合（2018-10-09）|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！