zoukankan      html  css  js  c++  java

  • Python的数据类型3元组，集合和字典

    首先要讲到的就是元组

    元组其实拥有列表的一些特性，可以存储不同类型的值，但在某些方面元组又比不上列表

    定义一个元组，你可以不用加‘ [ ] ’，你只需用逗号隔开即可

    例如

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    In [1]: my_tuple = "susmote", 28, 123456789
     
    In [2]: my_tuple[0]
    Out[2]: 'susmote'
     
    In [3]: my_tuple[1]
    Out[3]: 28
     
    In [4]: my_tuple
    Out[4]: ('susmote', 28, 123456789)

    　　

    元组也能被嵌套

    1
    2
    3
    4
    5
    6
    7
    In [5]: nested_t = my_tuple, (4, 3, 2, 1)
     
    In [6]: nested_t
    Out[6]: (('susmote', 28, 123456789), (4, 3, 2, 1))
     
    In [7]: nested_t[0][0]
    Out[7]: 'susmote'

    　　

    在这里，元组和列表最大的不同就是元组是不可变的，不能通过直接赋值改变元组中的值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    In [8]: my_tuple = "susmote", 28, 123456789
     
    In [9]: my_tuple[0] = "ayesup"
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-9-d99875c0ce61> in <module>()
    ----> 1 my_tuple[0] = "ayesup"
     
    TypeError: 'tuple' object does not support item assignment

    　　下面报了一个类型错误

    但是，在元组里面可以包含列表，而列表有是可变的，所以说元组是包含可变对象

    1
    2
    3
    4
    5
    6
    In [11]: my_tuple = ([1, 2, 3],[4, 5, 6])
     
    In [12]: my_tuple[0][0]  = 7
     
    In [13]: my_tuple
    Out[13]: ([7, 2, 3], [4, 5, 6])

    　　在这里，要注意，括号是可以不用加上的，但为什么规范起见，还是尽量要把括号加上

    元组是可以为空的，你只需要在赋值的时候加一个括号即可

    1
    2
    3
    4
    In [16]: my_tuple = ()
     
    In [17]: len(my_tuple)
    Out[17]: 0

    　　

    如果你想创建一个只有一个元素的元组，那么你只需要在最后加上一个逗号就可以了

    1
    2
    3
    4
    5
    6
    7
    In [18]: my_tuple = "susmote",
     
    In [19]: my_tuple
    Out[19]: ('susmote',)
     
    In [20]: len(my_tuple)
    Out[20]: 1

    　　

    元组是一个包含多个值的列表集合，所以我们可以直接获取其中的值，并赋给一个变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    In [27]: my_tuple = "susmote",123456, 18
     
    In [28]: my_tuple = "susmote", 18, 13488888888
     
    In [29]: name, age, phone = my_tuple
     
    In [30]: name
    Out[30]: 'susmote'
     
    In [31]: phone
    Out[31]: 13488888888

    　　

    接下来我们讲一下集合

    集合相信大家应该不陌生，初中的时候应该是学过的，当然你如果说你没上个初中，那就另当别论了

    由一个或多个确定的元素所构成的整体叫做集合。这是数学中的概念，在python中也可以这样简单的认为

    声明一个要用到花括号" { } "，你要把值全部加到括号里面

    首先集合的一个重要概念就是无序

    例如，我们声明一个集合

    1
    2
    3
    4
    In [32]: my_set = {'a', 'b', 'c', 'd'}
     
    In [33]: print(my_set)
    {'b', 'd', 'c', 'a'}

    　　很清晰的看出他是无序的

    同时你也可以通过判断语句" in "来获取某个元素是否存在与集合中,他返回一个布尔类型

    1
    2
    3
    4
    5
    6
    7
    In [36]: my_set = {'a', 'b', 'c', 'd'}
     
    In [37]: 'a' in my_set
    Out[37]: True
     
    In [38]: 'e' in my_set
    Out[38]: False

    　　tips：Ture代表真，false代表假（相信大家都知道）

    然后集合还有一个概念就是里面的元素只能是唯一的，如果有重复的，会自动移除

    1
    2
    3
    4
    In [1]: my_set = {'a', 'b', 'b', 'c', 'c', 'd'}
     
    In [2]: my_set
    Out[2]: {'a', 'b', 'c', 'd'}

    　　

    除了通过花括号赋值，我们还可以直接调用 set() 方法，生成一个集合

    1
    2
    3
    4
    In [3]: my_set = set('abcdefgabcdefg')
     
    In [4]: my_set
    Out[4]: {'a', 'b', 'c', 'd', 'e', 'f', 'g'}

    　　

    下面我们要讲到集合的一个重要的概念

    集合的运算

    “ - ”   差运算

    1
    2
    3
    4
    5
    6
    In [5]: a = set('abcde')
     
    In [6]: b = set('bdfgh')
     
    In [7]: a - b
    Out[7]: {'a', 'c', 'e'}

    　　只保留a独有的元素，其他的如有与b相同的则移除

    “ | ” 并运算

    1
    2
    3
    4
    5
    6
    In [8]: a = set('abcde')
     
    In [9]: b = set('bdfgh')
     
    In [10]: a | b
    Out[10]: {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}

    　　包含a和b所有的元素，如果有重复的则只留一个

    “ & ” 交运算，求交集

    1
    2
    3
    4
    5
    6
    In [11]: a = set('abcde')
     
    In [12]: b = set('bdfgh')
     
    In [13]: a & b
    Out[13]: {'b', 'd'}

    　　只保留a集合和b集合中相同的元素

    “ ^ ” 求交集的补集

    1
    2
    3
    4
    5
    6
    In [16]: a = set('abcde')
     
    In [17]: b = set('bdfgh')
     
    In [18]: a ^ b
    Out[18]: {'a', 'c', 'e', 'f', 'g', 'h'}

    　　保留a和b都单独存在的元素，去除a与b相同的元素

    关于集合我们主要需要了解的只有这些，至于运用，后续讲

    在这我们再讲最后一种数据类型

    字典（ Dictionaries）

    在python中，字典是一个很常用的数据类型。在其他语言中，也有叫做关联数组的

    字典不像列表，元组，存在自动有顺序的索引（index）

    字典中的索引也就是必须手动建立的Key（键），每个键对应一个value（值）

    而且键除了普通的数值类型之外，还可以用“String”类型

    定义一个字典要用到“ { } ”,每个key后面加“ : ”（冒号）接value（值），再加一个值的话，用逗号隔开

    例如，我们下面定义一个字典

    1
    2
    3
    4
    In [23]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [24]: my_dict
    Out[24]: {'age': 18, 'name': 'susmote', 'tel': 1348888888}

    　　

    下面我们通过key来获取值

    1
    2
    3
    4
    5
    6
    7
    In [20]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [21]: my_dict["name"]
    Out[21]: 'susmote'
     
    In [22]: my_dict["tel"]
    Out[22]: 1348888888

    　　

    如果你觉得里面有个元素没用了，你可以通过  “del()”方法来删除

    1
    2
    3
    4
    5
    6
    7
    8
    9
    In [23]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [24]: my_dict
    Out[24]: {'age': 18, 'name': 'susmote', 'tel': 1348888888}
     
    In [25]: del my_dict["tel"]
     
    In [26]: my_dict
    Out[26]: {'age': 18, 'name': 'susmote'}

    　　

    你可以通过list()方法列出字典里所有的key，或者是所有的value

    1
    2
    3
    4
    5
    6
    7
    In [32]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [33]: list(my_dict.keys())
    Out[33]: ['name', 'age', 'tel']
     
    In [34]: list(my_dict.values())
    Out[34]: ['susmote', 18, 1348888888]

    　　

    排序，通过sorted()方法按照key的首字母顺序进行排序

    1
    2
    3
    4
    In [5]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [6]: sorted(my_dict.keys())
    Out[6]: ['age', 'name', 'tel']

    　　

    前面讲到集合可以通过 “in”   "not in"判断一个keys是否存在与集合中，当然字典也是可以的，同样也是返回一个布尔类型

    1
    2
    3
    4
    5
    6
    7
    In [41]: my_dict = {'name': "susmote", 'age': 18, 'tel': 1348888888}
     
    In [42]: 'name' in my_dict
    Out[42]: True
     
    In [43]: 'name'not in my_dict
    Out[43]: False

    　　

    使用dict() 生成字典

    1
    2
    In [44]: dict([('name', 'susmote'), ('age', 18), ('Tel', 13488888888)])
    Out[44]: {'Tel': 13488888888, 'age': 18, 'name': 'susmote'}

    　　也可以直接这样（字符串类型简单的时候）

    1
    2
    In [45]: dict(name = "susmote", age = 18, tel = 13488888888)
    Out[45]: {'age': 18, 'name': 'susmote', 'tel': 13488888888}

    　　

    python的数据类型大概就是这些，有一些知识点，我会在后面学了控制循环语句之后在讲
  • 相关阅读:
    sabaki and leelazero
    apply current folder view to all folders
    string operation in powershell
    wirte function in powershell
    add environment path to powershell
    Module in powershell
    sql prompt
    vmware中鼠标在部分区域不能使用
    调整多个控件的dock的顺序
    行为型模型 策略模式
  • 原文地址：https://www.cnblogs.com/MaxElephant/p/10082974.html
Copyright © 2011-2022 走看看