python 第十二周 元组、列表、字典、序列

• 4.2 列表

  列表与元组相似，也是由一组元素组成，列表可以实现添加、删除和查找操作，元素的值可以被修改。

• 4.2.1 列表的创建

  List_name = [元素1，元素2，…] ,列表用“[ ]”包含元素。
  添加元素调用：函数append(object)，每次添加的新元素将排在列表的尾部。
  删除元素调用：函数remove(value),不在列表中的元素，将抛出ValueError异常。

list = ["apple", "banana", "grape", "orange"]
print list
print list[2]
list.append("watermelon")
list.insert(1, "grapefruit")   #插入到list第二个位置
print list
list.remove("grape")    
print list
##list.remove("a")           #没有该元素将会报错
print list.pop()             #函数pop()取出列表中的最后一个元素
print list

注意：如果list中存在两个相同的元素，此时调用remove()移除同名元素，将只删除列表中位置靠前的元素。

• 4.2.2 列表的使用方法
  1、同时坚持负索引、分片以及多元列表。
  2、列表可以实现连接操作，提供了两种方式：一种是调用extend ( ) ,另一种是使用运算符“+”或”“+=”。

list1 = ["apple", "banana"]
list2 = ["grape", "orange"]
list1.extend(list2)
print list1
list3 = ["watermelon"]
list1 = list1 + list3
print list1
list1 += ["grapefruit"]
print list1
list1 = ["apple", "banana"] * 2
print list1

4.2.3 列表的查找、排序与反转
查找方法：1、使用index()属性。2、使用保留字“in”来判断元素是否在列表中。

list = ['orange','apple']
print list.index ('orange')   #方法一
print 'orange' in list        #方法二

排序和反转的方法：
调用sort()，sort() 提供了参数reverse 用于控制元素排序的顺序，如果不提供参数，默认采用首字母升序排序。如果设置参数reverse=ture,则采用首字母降序排列。

list = ["banana", "apple", "orange", "grape"]
list.sort()      #升序排列
print "Sorted list:", list
list.reverse()    #降序排列
print "Reversed list:", list

4.2.4 用列表实现堆栈和队列
堆栈 : “后进后出“原则。append()添加一个新元素到堆栈的顶部。pop()把堆栈中的最后一个元素弹出。
队列：”先进先出“原则。

   #堆栈的实现
list = ["apple", "banana", "grape"]
list.append("orange")
print list
print "弹出的元素：", list.pop()
print list

#队列的实现
list = ["apple", "banana", "grape"]
list.append("orange")
print list
print "弹出的元素：", list.pop(0)
print list

• 4.3 字典
• 4.3.1 字典的创建
  字典由一系列“键-值（key-value)对组成，”键-值“对之间用”逗号“隔开，并且被包含在一对“花括号”中。

dictonary_name = { key1 : value , key2 : value , . . .}
dict = {1 : "apple" , 2 : "orange"}
print dict
print dict [1]     #字典的访问

• 4.3.2 字典的访问
  字典通过Key值获取相应的value值。要注意用一对“方括号”包含。
  value = dict [ key ]
  1、字典的添加、删除、修改，只需要编写一条赋值语句。
  dict [ “x” ] = “value”
  ①如果索引“x”不在字典dict的key列表中，dict将添加一条新的映射（x:key)；如果已在dict中，则修改对应的value值。
  ②由于字典是无序的，所以字典没有append ( ) ,remove ( ) ，字典的删除调用del ( )实现，del （ ）属于内建函数，可以直接调用。pop()方法与列表有所不同，pop ( k [ , d ] ) -> v 。

#字典的添加、删除、修改操作
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
dict["w"] = "watermelon"     #添加
del(dict["a"])               #删除
dict["g"] = "grapefruit"     #修改
print dict.pop("b"),dict.pop('c','furit')  #前者字典有索引的提取，后者没有索引的提取。 输出结果：banana furit
print dict
dict.clear()          #清空字典
print dict

2、字典的遍历
①第一种方法用for in 循环结构

dict = {1:'apple' , 2:'orange' , 3:'banana'}
for k in dict:        #利用for in 循环语句
    print 'dict[%d]=' % k ,dict[k]   #k值获取是是dict的key值，因此通过dict[k]来获取value值。

②第二种方法是使用字典的 items( ) 方法实现字典的遍历。items ( )把字典中每对key 和 value 组成了一个元组，并将这些元组放在一个列表中返回。
print dict.items( )
输出结果：[ ( 1 , ‘apple’ ) , ( 2, ‘orange’ ），（3 , ’ banana’ ) ]
③使用 iteritems( ) 、iterkeys ( )、itervalues ( ) 实现字典的遍历。

#调用iteritems()实现字典的遍历
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"} 
print dict.iteritems()       #返回字典的遍历器对象
for k, v in dict.iteritems():
    print "dict[%s] =" % k, v
for (k, v) in zip(dict.iterkeys(), dict.itervalues()):
    print "dict[%s] =" % k, v

④字典的value值可以是元组、列表和字典，这样的字典叫做混合型字典。

#使用列表、字典作为字典的值
dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}
print dict["a"]          #输出：（"apple") 
print dict["a"][0]       #输出：apple
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]

• 4.3.3 字典的方法
  1、 Keys( ) 和 values ( ) 方法
  分别返回字典的key列表和value列表。

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"} 
#输出key的列表
print dict.keys()
#输出value的列表
print dict.values()
#每个元素是一个key和value组成的元组，以列表的方式输出

2、get ( ) 方法
获取字典中某个value值。D.get ( k [ , d ] ) -> D [ k ] 参数K表示字典的键值，参数d可作为get()的返回值，也可以默认，默认值为None.

#字典中元素的获取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"} 
print dict
print dict.get("c", "apple")        #输出：grape  
print dict.get("e", "apple")        #输出：apple

#get()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
    print D["key1"]
else:
    print "None"

3、update ( )方法
update( )把一个字典中的key 和 value 值全部拷贝到另一个字典中，相当于一个合并函数。

#udpate()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
    D[k] = E[k]
print D           
输出结果：{'key2':'value3','key1':'value1','key4':'value4'}
#如果某些key在目标字典中已经存在，则新字典中的值覆盖原有的值，字典原有的内容保持不变。

4、 setdefault ( )方法
setdefault ( ) 方法与get （）使用方法类似
D.setdefault( k [ , d ] ) -> D . get ( k, d) 参数k表示字典的键值，参数d表示D[K] 的默认值，d可以省略，默认值为“None”。

#设置默认值
dict = {}
dict.setdefault("a")     #添加一个key值为"a",且设置默认value值:None
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict  

#由于已经设置了dict["a]的值为"apple",因此再次调用setdefault()也不会影响value值，所以dict["a"]的值仍为“apple”，而不是“None"。 输出结果：{'a' : 'apple'}

• 4.3.4 字典的排序与复制
  1、字典的排序

#调用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"} 
print dict   
#按照key排序  1、items()=遍历字典返回元组。2、d[0]表示items()中的key，按照key值进行排序。3、lambda()可以创建匿名函数，用于返回计算结果。
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序  
print sorted(dict.items(), key=lambda d: d[1])

输出结果：[“a” : “apple”, “b” : “grape”, “c” : “orange”, “d” : “banana”]
2、字典的复制
copy() : 把字典A的内容复制到字典B中，并清除字典B中原有的内容。

#字典的浅拷贝
dict = {"a" : "apple", "b" : "grape"} 
dict2 = {"c" : "orange", "d" : "banana"} 
dict2 = dict.copy()
print dict2
输出结果：{'a': 'apple', 'b': 'grape'}

深、浅拷贝的区别：
深拷贝能够拷贝对象内部所有的数据和引用，浅拷贝只是复制数据，数据的引用没有被复制，因此新的数据使用同一块内存空间。

#字典的深、浅拷贝的区别
import copy
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}} 
dict2 = copy.deepcopy(dict)
dict3 = copy.copy(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict

输出结果：{‘a’: ‘apple’, ‘b’: {‘o’: ‘orange’, ‘g’: ‘grape’}}
{‘a’: ‘apple’, ‘b’: {‘o’: ‘orange’, ‘g’: ‘orange’}}
4.4 序列
序列是具有索引和切片能力的集合。元组、列表和字符串具有通过索引访问某个具体的值，或通过切片一段切片的能力，因此元组、列表和字符串都属于序列。