Python入门6

#20100813
#列表与字典
#可以在原地修改，也可以按需求增长或缩短，而且可以包含任何种类的对象或者被嵌套。
#列表时Python中最具有灵活性的有序集合对象类型。与字符串不同的是，列表可以包含任何种类的对象。
#与字符串不通，列表时是可改变对象，它们都支持在原处修改的操作，可以通过指定的偏移值和分片、列表方法调用、删除语句等方法来实现

#列表是：任意对象的有序集合，通过偏移量读取，可变长度、异构以及任意嵌套，属于可变序列的分类，对象引用数组

'''
常用列表常量和操作
    操作                      解释
 L1 = []                    一个空的列表
 L2 = [1,2,3,4]             四项：索引为0-3
 L3 = ['abc',['def','ghi']] 嵌套的子列表
 L2 = [i]                   索引
 L3 = [i][j]                索引的索引
 L2 = [i:j]                 分片
 len(L2)                    求长度
 L1 + L2                    合并
 L2 * 3                     重复
 for x in L2                迭代
 3 in L2                    成员关系
 L2.append(5)               方法
 L2.extend([5,6,7])         增长
 L2.sort()                  排序
 L2.index(9)                插入
 L2.insert(I, X)            插入
 L2.reverse()               反转
 del L2[k]                  裁剪
 del L2[i:j]                分片裁剪
 L2.pop()
 L2.remove(2)              
 L2[i:j] = []              
 L2[i] = 1                  索引赋值
 L2[i:j] = [11,12,13]      
 range(4)                   生成整数列表/元组
 xrange(0,4)               
 L4 = [x**2 for x in range(5)] 列表解析

'''
L1 = []
L2 = [1,3,2,4]
print L2
print L2[1]
print L2[:2]
print L1 + L2
L2.append(5)
print L2
#在末端插入一个或多个元素
L2.extend([7,6,8])
print L2
#排序
L2.sort()
print L2
print len(L2)

for x in L2:
    print x

print 5 in L2

L2.index(1)
print L2
L2.index(8)
print L2
#在某个元素后面插入新值
L2.insert(1,9)
print L2
L2.insert(8,10)
print L2
#反转，并不是反向排序。也非降序
L2.reverse()
print L2
del L2[0]
print L2
del L2[:3]
print L2
#删除元素的应用；0位第一个元素，一次类推，默认pop()为最后一个元素
L2.pop(3)
print L2
#L2.pop(1)
#print L2
#删除指定的元素      
L2.remove(5)
print L2

L4 = [x**2 for x in range(5)]
print L4

#"+"操作和字符串中的一样，注意："+"两边必须是相同类型的序列，否则运行时会出现类型错误
print str([1,2,3]) + "34"

#原地修改列表
#由于列表时可变的，它们支持实地改变列表对象的操作。
#当使用列表的时候，可以将它赋值给一个特定项（偏移）或整个片段（分片）来改变它的内容
L = ['sapm','Spam','SPAM']
print L
L[0] = 'jinqiang'
print L
L[0:2] = ['xu','jin']
print L

#索引和分片的赋值都是原地修改，它们对列表进行直接修改，而不是生成一个新的列表作为结果。

#与字符串相同，Python列表对象也支持特定类型方法调用。
L.append('tom')
print L
L.sort()
print L
L.extend(['hen','wei','da'])
print L
L.pop()
print L
L.reverse()
print L
#可以用del语句在原处删除某项或某片段
del L[0]
print L
del L[0:2]
print L


#字典：除了列表外，字典也许是Python之中最灵活的内置数据结构类型。
#1、列表可以看做有序的对象集合。
#字典是无序的集合
#2、区别：字典中的元素是通过键来取的，列表时通过偏移存取。
#3、可变长、异构、任意嵌套：与列表相似，字典可以在原处增长或缩短。它们可以包含任何类型的对象，而其它们支持任意深度的嵌套（可以包含列表和其它字典等）。
#4、属于可变映射类型
#5、对象引用表（哈希表）

#字典描述：”键：值（key,value）"的形式写出的，用逗号隔开，用大括号括起来，一个空字典就是一个大的空括号，而字典可以作为另一个字典中的某一个值被嵌套
#常见字典常量和操作
'''
    操作                              解释
  D1 = {}                           空字典
  D2 = {'sapm':2,'eggs':3}         两项目字典
  D3 = {'food':{'ham':1,'egg':2}}   嵌套
  D2['eggs']                       以键进行索引运算
  D3['food']['ham']
  D2.has_key('eggs')                方法
  'eggs' in D2                      成员关系
  D2.keys()                         键列表
  D2.values()                       值列表
  D2.copy                           复制
  D2.get(key,default)               默认
  D2.update(D1)                     合并
  D2.pop(key)                       删除
  len(D1)                           长度（存储元素的数目）
  D2[key] = 42                      新增/修改键
  del D2[key]                       删除键

'''

d2 = {'spam':2,'ham':3,'eggs':1}
print d2
#通过建来进行索引操作
print d2['spam']
print d2
print len(d2)
#字典的has_key()方法以及in成员关系操作符提供了键存在与否的测试方法：
print d2.has_key('ham')
#keys方法能返回字典中所有的键，将他们收集在一个列表中。
print d2.keys()
#字典方法提供了多种工具，values和items方法分别返回字典的值列表和(key,values)对元组
print d2.values()
print d2.items()

#原地修改字典
#通过"键"，修改"值"
d2['ham'] = ['grill','bake','fry']
print d2
#del语句，它删除作为索引的键相关联的元素
del d2['eggs']
print d2
#往字典里新增元素
d2['username'] = 'alice'
print d2

#get使用方法；
print d2.get('username')
print d2.get('uhah')

#update  合并，它把一个字典的键和值合并到另一个，盲目地覆盖相同键的值
print d2
d3 = {'job':'tech','eage':25}
d2.update(d3)
print d2
#pop方法能够从字典中删除一个键并返回它的值，类似于列表的pop方法
print d2.pop('eage')
print d2

#语言表：生成一张表格，把程序语言名称（键）映射到它们的创造者（值）。你可以通过语言名称索引来读取语言创造者的名字。

table = {'python':  'alice',
         'bash':    'bob',
         'tcsh':    'david'}
print table

language = 'python'
creator = table[language]
print creator

print table.keys()
print table['python']

for lang in table.keys():
    print lang,'/t',table[lang]

#字典用法的注意事项：
#1、序列运算无效，字典是映射机制，不是序列。因为字典元素没有顺序的概念，类似有序合并和分片这样的运算是不能用的。
#2、对新索引赋值会添加麻烦。当你编写字典常量时（此时的键是嵌套于常量本身的），或者向现有字典对象的新键赋值时，都会生成键。最终结果是一样的
#3、键不一定总是字符串，可以是整数、类实例对象也可以用作键。

#字典用于实现稀疏数据结构：
matrix = {}
matrix[(2,3,4)] = 88
matrix[(7,8,9)] = 99
x = 2;y = 3;z = 4
print matrix[(x,y,z)]
print matrix

#避免missing-key错误，读取不存在的键的错误在稀疏矩阵中很常见，不希望程序因为这一错误而被关闭。
#1、在if语句中预先对键进行测试
#2、可以使用try语句明确地捕获并修复这一异常
#3、用get方法为不存在的键提供一个默认值

if matrix.has_key((2,3,6)):
    print matrix[2,3,6]
else:
    print 0

print matrix.get((2,3,4),0)
print matrix.get((2,3,6),0)      

#get方法时最简洁的。

rec = {}
rec['name'] = 'alice'
rec['age'] = 25
rec['job'] = 'trainer/writer'

print rec
print rec['name']

#嵌套字典
alice = {'xingqu':'baskball',
         'shanchang':'changpao',
         'home':{'state':'CCCC0','shengfen':'beijing'}
         }
print alice