zoukankan      html  css  js  c++  java
  • 讨论python的数据类型的区别

    python很重要的的那几个数据类型:字符串,列表,字典,元组,他们之间重要的区别的是什么?能否举几个例子来说明下!

    共同点:
    1、它们都是py的核心类型,是py语言自身的一部分。

    核心类型与非核心类型
    多数核心类型可通过特定语法来生成其对象,比如"spam"就是创建字符串类型的对象的表达式;
    非核心类型需要内置函数来创建,比如文件类型需要调用内置函数open()来创建。
    类也可以理解成自定义的非核心类型。

    2、边界检查都不允许越界索引

    3、索引方法都使用[]

       1. s = 'spam'
       2. print s[0]
       3.

       4. s = ['s', 'p', 'a', 'm']
       5. print s[0]
       6.

       7. s = {'name':'bob', 'age':'12'}
       8. print s['name']
       9.

      10. s = ('s', 'p', 'a', 'm')
      11. print s[0]

    复制代码
    不同点:
    1、有序性
    字符串、列表、元祖是序列,元祖可以理解成不可变的列表
    字典是映射
    序列才有有序性,字典没有可靠的左右顺序

    2、可变性
    字符串、元祖(还有数字)具有不可变性,即赋值后对应存储空间的内容不可变,除非这个对象被销毁。
    列表、字典具有可变性

       1. s = 'spam'
       2. s = 'z' + s[1:]

    复制代码
    第一行的s的指向的内存空间(比如地址 0x000123)存储了字符串'spam'
    第二行的s“变”成了'zpam',但它只是重新指向了一个存储着'zpam'字符串的内存地址,原来0x000123出开始的内存空间可能还是一个 'spam'

    ,直到系统来清理它

    3、序列操作
    序列(字符串、列表、元祖)支持,映射(字典)不支持
    注意:序列操作生成的类型不变。

       1. col = 'spam'
       2. print col[1:]
       3. #结果是pam
       4.

       5. col = ['s', 'p', 'a', 'm']
       6. print col[1:]
       7. #结果是['p', 'a', 'm']
       8.

       9. col = ('s', 'p', 'a', 'm')
      10. print col[1:]
      11. #结果是('p', 'a', 'm')

    复制代码
    4、列表解析表达式
    表达式中支持序列(字符串、列表、元祖),貌似也支持映射(字典)。
    注意:和序列操作不同的是,
    列表解析表达式生成的只能是一个列表;

       1. double = [c * 2 for c in 'spam']
       2. print double
       3. 结果为['ss', 'pp', 'aa', 'mm']
       4.

       5. L1 = [1, 2, 3]
       6. L2 = [4, 5, 6]
       7. L3 = [(a + b) for (a,b) in zip(L1, L2)]
       8. print L3
       9. #结果为[5, 7, 9]
      10.

      11. tup = (1, 2, 3)
      12. double = [c * 2 for c in tup]
      13. print double
      14. #结果为[2, 4, 6]

    复制代码
    可以把字典转化成列表,谢谢lx的提醒,呵呵

       1. a = {'a':'zw','b':'ww'}
       2. b = [i * 2 for i in a.items()]
       3. print b
       4. #结果为[('a','zw','a','zw'),('b','ww','b','ww')]
       5. #a.items()实际上是一个列表

    复制代码
    下面一段代码似乎是列表解析表达式对字典的支持,经过un兄和Nell兄的理解,对字典进行的迭代应该是对其keys的迭代,字典的items()、keys()、 values()方法都是返回的列表,所以,这里的for i in a最好写成for i in a.keys(),效果等同。总之,可以不追究列表解析表达式到底支不支持字典,本质上,列表解析表达式就是个对列表使用了循环结构,并生成新的列表的方法。先这样理解

       1. a = {'a':'zw','b':'ww'}
       2. b = [i * 2 for i in a]
       3. print b
       4. #结果为['aa', 'bb']

    复制代码
    5、嵌套
    除了字符串,列表、元祖、字典可以相互多层次嵌套

       1. #第一段
       2. b = [1, 2, 3]
       3. tup = (4, 5, b)
       4. print tup[2]
       5. #结果是[1, 2, 3]
       6. b[0] = 'x'
       7. print tup[2]
       8. #结果是['x', 2, 3]
       9.

      10. #第二段
      11. b = '123'
      12. tup = (4, 5, b)
      13. print tup[2]
      14. #结果是'123'
      15. b = 'xxx'
      16. print tup[2]
      17. #结果仍然是'123'

    复制代码
    有上面两段可以看出,嵌套与可变性是不冲突的。
    tup = (4, 5, b)中所记忆、录入的b是个变量指针,或者叫内存地址,是个数字。
    第一段,b指向一个列表,列表具有可变性,所以b[0] = 'x'的操作后,所以对元祖的索引能体现出变化;
    第二段,b指向一个字符串,字符串具有不可变性,所以b = 'xxx'的操作后,b这个指针本身就改变了,重指向另一段内存空间,而tup元祖中记忆的内存地址(那个曾经的b)所指空间并没有变,还是字符串 '123'。
    所以,不管是第一段还是第二段,元祖tup始终保持不可变性,要变化也是其元素作为指针所指向内存的变化。

    4、列表解析表达式
    表达式中支持序列(字符串、列表、元祖),不支持映射(字典)。

    似乎字典也可以使用在列表解析中

    a = {'a':'zw','b':'ww'}

    [i * 2 for i in a.items()]


    输出:
    [('a','zw','a','zw'),('b','ww','b','ww')]

  • 相关阅读:
    DC中为什么要用Uniquify?
    hdu 1596 find the safest road
    hdu2112 HDU Today
    hdu 2066 一个人的旅行
    poj 3026 Borg Maze
    poj 1979 Red and Black
    poj 1321 棋盘问题
    hdu 1010 Tempter of the Bone
    hdu 4861 Couple doubi
    codeforces584B Kolya and Tanya
  • 原文地址:https://www.cnblogs.com/wanpython/p/1787327.html
Copyright © 2011-2022 走看看