Python基础学习3---数据结构

数据结构

数据结构基本上就是---他们是可以处理数据的结构或者说他们是用来存储一组相关数据的。

在python中有三种内建的数据结构-----列表、元组和字典

列表（list）

列表就像是我们要去超市买东西列的清单一样，将需要买的东西列成清单后整个结构是就是列表数据了，一旦创建完成后 我们可以随意进行添加 删除修改操作 所以可以断定

列表数据是一个可变的数据类型

列表是使用对象和类的一个例子。当你使用变量 i 并给它赋值的时候，比如赋整数 5 ，你可以认为你创建了一个类（类型） int 的对象（实例） i 。事实上，你可以看一下 help(int) 以更好地理解这一点。

 shoplist = ["apple","mango","carrot","banana"]

 print "i have ",len(shoplist),"item  to purchase"

 print"these items are:",

 for item in shoplist:
     print item,

 print"\n I also have to buy rice"
 shoplist.append("rice")
 print 'My shopping list is now', shoplist

 print 'I will sort my list now'
 shoplist.sort()
 print'sorted shopping list is ',shoplist

 print 'the first item I will buy is',shoplist[0]
 olditem = shoplist[0]

 del shoplist[0]

 print 'I bought the',olditem
 print ' My shopping list is now ',shoplist

现在创建了一个list数据类型的对象 shoppinglist 进行增加 删减 以及调用类方法的操作。

注意，我们在 print 语句的结尾使用了一个 逗号 来消除每个 print 语句自动打印的换行符。这样做有点
难看，不过确实简单有效。在python3.x版本中使用  ”end"  这样的字符来消除自动换行默认操作。

元组

元组和字符串一样是不可变的 即你不能修改元组。元组是通过圆括号加逗号的方式来进行定义，元组通常在使用语句或者用户定义的函数能够安全的采用一组值得时候

即被使用的元组的值不会改变。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

 zoo = ('wolf','elephant','penguin')  #定义一个zoo的元组数据

 print 'number of animals in the zoo is',len(zoo)   #打印元组数据的长度

 new_zoo = ('monkey','doplhin',zoo)  #定义一个新的new_zoo类型的数据 讲之前的zoo 包含进来
 print 'number od animals in the new zoo is ',len(new_zoo) #取得新的元组的长度

 print 'animals brought fron old zoo are',new_zoo[2]  #取得new_zoo中第三个数据 即zoo的序列数据
 print 'Last animal brought from old zoo is',new_zoo[2][2]#取得new_zoo中第三个数据中的第三个数据 即zoo中的第三个数据为penguin

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)
>>> t
(1, 2)

如果要定义一个空的tuple，可以写成()：

>>> t = ()
>>> t
()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)
>>> t
(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

含有0个或1个项目的元组。一个空的元组由一对空的圆括号组成，如 myempty = () 。然而，含有单个
元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组
和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目 2 的元组的时候，你应该指
明 singleton = (2 , ) 。

元组打印语句

 age = 22
 name = 'Swaroop'

 print '%s is %d years old' %(name , age)

字典

字典类似于手机中的通讯录一样，即我们输入名字键（）和详细的信息（值）联系在一起。注意 键必须是唯一的就像我们如果有两个人恰巧同名的话你就无法找到正确的信息。

注意：只能够使用不可变的对象比如字符串来作为字典的键 但是你可以不可变或者可变的对象作为字典的值基本说来就是你应该只使用简单的对象作为键。

键值对字典中以这样的方式标记： d={key1：values1，key2:values2} 注意他们的键/值对用冒号分割 而各个对用逗号分割 所有这些都需要包括在花括号里面。

记住字典中的键/值对是没有顺序的 如果你想要一个特定的顺序 那么应该在使用前对它们排序。

字典是dict类的实例/对象

 ab  =  {  'Swaroop' :
 'swaroopch@byteofpython.info',
 'Larry' : 'larry@wall.org',
 'Matsumoto' : 'matz@ruby-lang.org',
 'Spammer' : 'spammer@hotmail.com'   # 创建新的字典类型的对象ab
 }
 print "Swaroop's address is %s" % ab['Swaroop'] #检索出Swaroop的对象信息
 # Adding a key/value pair 添加一个新的键值
 ab['Guido'] = 'guido@python.org'
 # Deleting a key/value pair 删除已经存在的键值
 del ab['Spammer']
 print '\nThere are %d contacts in the address-book\n' %len(ab)
 for name, address in ab.items():
     print 'Contact %s at %s' % (name, address)
 if 'Guido' in ab: # OR ab.has_key('Guido')
     print "\nGuido's address is %s" % ab['Guido']

接下来，我们使用字典的 items 方法，来使用字典中的每个键/值对。这会返回一个元组的列表，其中每个

元组都包含一对项目——键与对应的值。我们抓取这个对，然后分别赋给 for..in 循环中的变
量 name 和 address 然后在for－块中打印这些值。
我们可以使用 in 操作符来检验一个键/值对是否存在，或者使用 dict 类的 has_key 方法。你可以使
用 help(dict) 来查看 dict 类的完整方法列表。

序列

列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。

 shoplist = ['apple', 'mango', 'carrot', 'banana']
 # Indexing or 'Subscription' operation
 print 'Item 0 is', shoplist[0]
 print 'Item 1 is', shoplist[1]
 print 'Item 2 is', shoplist[2]
 print 'Item 3 is', shoplist[3]
 print 'Item -1 is', shoplist[-1]
 print 'Item -2 is', shoplist[-2]
 # Slicing on a list
 print 'Item 1 to 3 is', shoplist[1:3]
 print 'Item 2 to end is', shoplist[2:]
 print 'Item 1 to -1 is', shoplist[1:-1]
 print 'Item start to end is', shoplist[:]
 # Slicing on a string
 name = 'swaroop'
 print 'characters 1 to 3 is', name[1:3]
 print 'characters 2 to end is', name[2:]
 print 'characters 1 to -1 is', name[1:-1]
 print 'characters start to end is', name[:]

 索引操作符 和切片操作符

1.索引操作符也叫下标操作符，是用括号中的一个数来指定一个序列的时候 python会自动抓取序列中对应的项目。有一点非常要注意的是 python中的索引下标可以使用负数。

位置是从队列尾部开始计算的比如说shoplist[-1]表示的是最后一个元素。

2.切片操作符是序列号后跟一个方括号，方括号内有一对可选的数字并用冒号隔开。 注意这个跟使用的索引操作符非常相似。 记住 数是可选的 冒号是必须的。

切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结
束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。
注意，返回的序列从开始位置 开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而
结束位置被排斥在切片外。

这样， shoplist[1:3] 返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一
个含有两个项目的切片。类似地， shoplist[:] 返回整个序列的拷贝。
你可以用负数做切片。负数用在从序列尾开始计算的位置。例如， shoplist[:-1] 会返回除了最后一个
项目外包含所有项目的序列切片。
使用Python解释器交互地尝试不同切片指定组合，即在提示符下你能够马上看到结果。序列的神奇之处在
于你可以用相同的方法访问元组、列表和字符串。