Python开发技术详解-笔记_第04章-内置数据结构

4. 内置数据结构

 Python提供的几种内置数据结构--元组,列表,字典,序列
 
 - 元组 列表 字典 的 创建和使用
 - 元组的遍历
 - 元组和列表的"解包"操作
 - 列表的 排序 查找 和 反转
 - 字典的特性
 - 序列的含义

 4.1 元组(tuple)

    -元组是"写保护"的, 即元组创建后不能再做任何修改操作
    -元组通常代表一行数据, 而元组中的元素代表不同的数据项

  4.1.1 元组的创建 -> ()

    -由一系列元素组成, 所有元素被包含在一对圆括号中
    -格式: tuple_name = (元素1, 元素2, ...)
    -空元素元组: tuple_name = ()
    -单个元素的元组: tuple_name = (元素,)
    -二元元组: 
        tuple_1 = ("1", "a")
        tuple_2 = ("2", "b")
        tuple = (tuple_1, tuple_2)

    -打包与解包
     -打包: 元组的创建过程,即多个元素组合成一个元组
        - tuple = (1, 2, 3)
     -解包: 将元组中的各个元素分别赋值给多个变量
        - a, b, c = tuple
     -解包通过 map(func, sequence[,sequence,...]) -> list
        >>> map(None, (1,2,3))
        [1, 2, 3]     

  4.1.2 元组的访问

    -通过索引访问, tuple_name[index]
    -非负数索引: 从头到尾, 即 tuple_name[0]代表元组中第一个元素
    -负数索引: 从尾到头, 即 tuple_name[-1] 代表元组中倒第一个元素
    -分片(slice)是元组的一个子集,即截取索引为 [start,stop) 的连续元素
    -分片格式 tuple_name[start:stop:step]

  4.1.3 元组的遍历

    -通过循环语句依次访问元组中各元素的值
    -需要用到: range()/xrange() 和 len() 等内建函数
    -内建函数由Python自动导入, 相当于java中的lang包
    -range([start,]stop[,step]) -> list of integer
    -举例: 二元元组的遍历 traverse_tuple.py

 4.2 列表

    -列表可实现 添加 删除 查找 元素修改等操作

  4.2.1 列表的创建 -> [ ]

    -列表由一系列元素组成, 所有元组包含在一对中括号中
    -列表的作用类似于java中的ArrayList
    -创建: list_name = [元素1, 元素2, ...]
    -追加: list_name.append(元素)
    -插入: list_name.insert(index, 元素)
    -删除: list_name.remove(元素), 删第一个,当元素不存在时抛异常
    -删除并返回: list_name.pop([index])
    - 举例

# new list
numList = ["0a", "1b", "2c", "3d"]
print numList
# list_name[index]
print "numList[%d] = %s" % (2, numList[2])
# list_name.append(value)
numList.append("4e")
print numList
# list_name.pop()
print "numList[%d] = %s" % (len(numList)-1, numList.pop())
# list_name.insert(index, value)
numList.insert(2, "value")
print numList
# list_name.remove(value)
numList.remove("value")
print numList

  4.2.2 列表的使用方法

    与元组十分相似, 同样支持负索引、分片多元列表等特性,但列表的元素可以被修改.

   (1) 连接两个列表

    ① list1.extend(list2)
    ② +
    ③ *
    ----------举例-------------
        list1 = [1, 2, 3]
        list2 = [4, 5, 6]
        list1.extend(list2)
        print list1

        list3 = ["a", "b"]
        list4 = ["c", "d"]
        print list3 + list4

        print ["#"] * 10

   (2) 排序 和 反转

     - list_name.sort([reverse=]), 升序(默认)reverse=False
     - list_name.reverse()
    ----------举例-------------
        numList = [5, 9, 3, 7] 
        print "original : ", numList
        numList.reverse()
        print "reverse  : ", numList
        numList.sort(reverse=False)
        print "sort  asc: ", numList
        numList.sort(reverse=True)
        print "sort desc: ", numList

   (3) 常用方法

        append(object)  
        insert(index, object)
        remove(value)
        pop([index])    删除指定index的值并返回其删除
        extend(iterable)
        index(value,[start,[step]]) 返回值所在的索引
        sort(cmp=None,key=None,reverse=False)   
        reverse()

  4.2.3 列表的实现栈和队列

    (1) 栈
        压栈: list.append(value)
        出栈: list.pop() -- value

    (2) 队列
        入队: list.append(value)
        出队: list.pop(0) -- value

 4.3 字典

    字典(Dictionary)由"键-值"对组成的集合,字典的值通过键来引用
    字典与Java中的HashMap类似

  4.3.1 字典的创建

    字典由一系列"键-值"对组成, "键-值"对之间用逗号(",")隔开,并且包含在一对花括号中.

    格式:
        dict_name = {key1:value1, key2:value2, ...}

    访问:
        dict_name[key]

    打印:
        print "%s" % {"1":"a", "2":"b"}
        print "%s, %(1)s" % {"1":"a", "2":"b"}
        print "%s, %(1)s, %(2)s" % {"1":"a", "2":"b"}
        注: key值必须是string

  4.3.2 字典的访问

    元素的访问:

        dict_name[key] ---> value

    元素的添加/修改:

        dict_name[key] = value
     -举例
        #-*- encoding:UTF-8 -*-
        charDict = {1:"A"}
        # 添加
        charDict[2] = "B"
        print charDict
        # 修改
        charDict[2] = "BB "
        print charDict     

    删除:

        dict_name.pop(key[,default]) ---> value
        删除指定key的元素, 
            存在, 返回其value,
            否则, 返回default,如没有default则抛异常
      -举例
        charDict = {"a":"AAA", "b":"BBB"}
        try:
            print charDict.pop("c")
        except KeyError, msg:
            print msg, "not in dict"

        print charDict.pop("c", "None")

        print "remove value: ", charDict.pop("a")
        print charDict

    清空:

        dict_name.clear()

    遍历:

      ① for key in dict_name:
            print key, dict_name[key]
      ② dict_name.items() 
            --> [(key1,value1),(key1,value1),...]
         for (key, value) in dict_name.items():
            print key, value
      ③ 遍历器: 
         - iteritems()      
            for (key, value) in dict_name.iteritems() :
         - iterkeys()
            for key in dict_name.iterkeys() :
         - itervalues()
            for (k,v) in zip(d.iterkeys(), d.itervalues()) :

  4.3.3 字典的方法

    (1) keys() 和 values()

      - dict_name.keys()    ---> key列表
      - dict_name.values()  ---> value列表

    (2) get()

      - dict_name.get(key[,default=None]) 
            ---> dict_name[key]
      - 举例
        charDict = {"a":"AAA"}
        print charDict.get("a")

        result = charDict.get("b")
        if None == result :
            print "a is not existence"

        print charDict.get("b", "wa haha")

    (3) update()

      - dict_A.update(dict_B) ---> None
        将 dict_B合并到dict_A, 无则添加, 有则覆盖

    (4) setdefault()

      - dict_name.setdefault(key[,default=None]) 
            --->dict_name.get(k,default)
            
        charDict = {}
        print charDict.setdefault("a")
        print charDict
        print charDict.setdefault("b", "BBB")
        print charDict

    (5) 字典的常用方法

        items()             (key, value)元组列表
        iteritems()         返回指向字典的遍历器
        setdefault(key[,default])    
        pop(key[,default])  删除key对应的值并返回
        get(key[,default])  
        keys()              返回key列表
        values()            返回value列表
        update(otherDict)   扩充
        copy()

  4.3.4 字典的排序和复制

    (1) 排序

        - 内置函数 
        sorted(iterable, cmp=None, key=None, reverse=False) 
            --> new sorted list

        charDict = {"d":"1DD", "b":"3BB", "a":"4AA", "c":"2CC"}
        print charDict
        # 按 key 排序
        print sorted(charDict.items(), key = lambda item : item[0])
        # 按 value 排序

        print sorted(charDict.items(), key = lambda item : item[1])           

 

    (2) 复制

        copy(x)
            Shallow copy operation on arbitrary Python objects.
        deepcopy(x, memo=None, _nil=[])
            Deep copy operation on arbitrary Python objects.

        浅拷贝: 对引用的拷贝
        神拷贝: 对资源的拷贝

  4.3.5 全局字典 -- sys.modules模块

       -sys.modules是一个全局字典,
        该字典是python启动后就加载在内存中的.
       -每当导入新的模块,sys.modules都将记录这些模块.
       -sys.modules对于加载模块起到了缓存的作用.
       -当某模块第一次导入,sys.modules将自动记录模块.
        当第2次再导入该模块时,python会首先到字典中查找.

       -通过sys.modules了解当前环境加载了哪些模块
        import sys
        for (key,value) in sys.modules.items() :
            print key, "-->", value        

 4.4 序列(sequence)

       -序列是具有索引和切片能力的集合.
       -字符串、列表、元组 都属于序列