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

左手的ㄟ右手 2022-09-17 13:21 157阅读 0赞

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) #

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