Python学习--数据结构

数据结构

 

        数据结构基本上就是:可以处理一些数据的结构 。或者说，是用来存储一组相关数据的。在Python中有三种内建的数据结构:列表、元组和字典。

• 列表

        list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。
        注意：1）在Python中，你在每个项目之间用逗号分割。
                   2）列表中的项目应该包括在方括号中，这样Python就知道你是在指明一个列表。
                   3）一旦你创建了一个列表，你可以添加、删除或是搜索列表中的项目。
                   4）列表是可变的数据类型，即这种类型是可以被改变的。
        下面的例子介绍如何使用列表

shoplist = [ 'apple' , 'mango' , 'carrot' , 'banana' ]
print 'I have' , len (shoplist), 'items to purchase.'
print 'These items are:' , 
for item in shoplist:
    print item
print '\nI 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

        输出

I have 4 items to purchase.
These items are: apple
mango
carrot
banana

I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

        变量shoplist是某人的购物列表。 在shoplist中，我们只存储购买的东西的名字字符串，但是你可以在列表中添加任何种类的对象包括数甚至其他列表。

        接下来，我们使用append方法在列表中添加了一个项目。然后我们通过打印列表的内容来检验这个项目是否确实被添加进列表了。打印列表只需简单地把列表传递给print语句，我们可以得到一个整洁的输出。
        再接下来，我们使用列表的sort方法来对列表排序。需要理解的是，这个方法影响列表本身，而不是返回一个修改后的列表，这与字符串工作的方法不同。这就是我们所说的列表是可变的而字符串是不可变的。
        最后，我们想要把它从列表中删除。我们使用del语句来完成这个工作。这里，我们指出我们想要删除列表中的哪个项目，而del语句为我们从列表中删除它。我们指明我们想要删除列表中的第一个元素，因此我们使用del shoplist[0]（记住，Python从0开始计数）。

        注意：我们在print语句的结尾使用了一个逗号来消除每个print语句自动打印的换行符。这样做有点难看，不过确实简单有效。

 

• 元组

        元组和列表十分类似，只不过元组和字符串一样是不可变的即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
        下面的例子介绍如何使用元组

zoo = ( 'wolf' , 'elephant' , 'penguin' )
print 'Number of animals in the zoo is' , len (zoo) 
new_zoo = ( 'monkey' , 'dolphin' ,zoo)
print 'Number of animals in the new zoo is' , len (new_zoo)
print 'All animals in new zoo are' , new_zoo
print 'Animals brought from old zoo are' , new_zoo[ 2 ]
print 'Last animal brought from old zoo is' , new_zoo[ 2 ][ 2 ]

        输出

Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin

        变量zoo是一个元组，我们看到len函数可以用来获取元组的长度。这也表明元组也是一个序列。
        我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目，就像我们对列表的用法一样。这被称作索引运算符。我们使用new_zoo[2]来访问new_zoo中的第三个项目。我们使用new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目。
        含有0个或1个项目的元组。一个空的元组由一对空的圆括号组成，myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候，你应该指明singleton = (2 , )。
        注意：元组之内的元组不会失去它的身份。

        元组与打印语句
        元组最通常的用法是用在打印语句中，下面是一个例子：

age = 22
name = 'Swaroop'
print '%s is %d years old' % (name,age)
print 'Why is %s playing with that python?' % name

        输出

Swaroop is 22 years old
Why is Swaroop playing with that python?

        print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。元组必须按照相同的顺序来对应这些定制。
        观察我们使用的第一个元组，我们首先使用%s，这对应变量name，它是元组中的第一个项目。而第二个定制是%d，它对应元组的第二个项目age。
        Python在这里所做的是把元组中的每个项目转换成字符串并且用字符串的值替换定制的位置。因此%s被替换为变量name的值，依此类推。print的这个用法使得编写输出变得极其简单，它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。
        在大多数时候，你可以只使用%s定制，而让Python来提你处理剩余的事情。这种方法对数同样奏效。然而，你可能希望使用正确的定制，从而可以避免多一层的检验程序是否正确。
        在第二个print语句中，我们使用了一个定制，后面跟着%符号后的单个项。这只在字符串中只有一个定制的时候有效。
        注意：定制可以是%s表示字符串或%d表示整数。

• 字典

        字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即我们把键（名字）和值（详细情况）联系在一起。
        键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。
        字典是dict类的实例/对象。
        注意：1）键必须是唯一的。
                   2）你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
                   3）字典中的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
                   4）字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。
        下面的例子介绍如何使用字典

ab = { 'Swaroop' : '[e-mail]' ,'Larry' : '[e-mail]' ,'Matsumoto' : '[e-mail]' ,'Spammer' : '[e-mail]'}
print "Swaroop's address is %s" %ab[ 'Swaroop' ]
ab[ 'Guido' ] = '[e-mail]'
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:
    ab.has_key('Guido')
    print "\nGuido's address is %s" % ab[ 'Guido' ]

         输出

Swaroop's address is [e-mail]

There are 4 contacts in the address-book

Contact Swaroop at [e-mail]
Contact Matsumoto at [e-mail]
Contact Larry at [e-mail]
Contact Guido at [e-mail]

Guido's address is [e-mail]

         我们使用标记创建了字典ab，然后使用在列表和元组章节中已经讨论过的索引操作符来指定键，从而使用键/值对。
        我们可以使用索引操作符来寻址一个键并为它赋值，这样就增加了一个新的键/值对，就像在上面的例子中我们对Guido所做的一样。
        我们可以使用del语句来删除键/值对。我们只需要指明字典和用索引操作符指明要删除的键，然后把它们传递给del语句就可以了。执行这个操作的时候，我们无需知道那个键所对应的值。
        接下来，我们使用字典的items方法，来使用字典中的每个键/值对。这会返回一个元组的列表，其中每个元组都包含一对项目，键与对应的值。我们抓取这个对，然后分别赋给for..in循环中的变量name和address然后在for－块中打印这些值。
        我们可以使用in操作符来检验一个键/值对是否存在，或者使用dict类的has_key方法。你可以使用help(dict)来查看dict类的完整方法列表。

• 序列

        列表、元组和字符串都是序列。序列的两个主要特点：索引操作符和切片操作符。
        索引操作符让我们可以从序列中抓取一个特定项目。
        切片操作符让我们能够获取序列的一个切片，即一部分序列。
        下面的例子介绍如何使用序列

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

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 ]
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[:]

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[:]

        输出

Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

         首先，我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用方括号中的一个数来指定一个序列的时候，Python会为你抓取序列中对应位置的项目。记住，Python从0开始计数。因此，shoplist[0]抓取第一个项目，shoplist[3]抓取shoplist序列中的第四个元素。索引同样可以是负数，在那样的情况下，位置是从序列尾开始计算的。因此，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。
        切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。shoplist[:]返回整个序列的拷贝。你可以用负数做切片。负数用在从序列尾开始计算的位置。shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。
        使用Python解释器交互地尝试不同切片指定组合，即在提示符下你能够马上看到结果。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。
        注意：1）这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
              2）返回的序列从开始位置开始 ，刚好在结束位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。

• 引用

        当你创建一个对象并给它赋一个变量的时候，这个变量仅仅引用那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。
        一般说来，你不需要担心这个，只是在引用上有些细微的效果需要你注意。这会通过下面这个例子加以说明。

print 'Simple Assignment'
shoplist =[ 'apple' , 'mango' , 'carrot' , 'banana' ]
mylist = shoplist
del shoplist[ 0 ]
print 'shoplist is' , shoplist
print 'mylist is' , mylist

print 'Copy by making a full slice'
mylist = shoplist[:]
del mylist[ 0 ]
print 'shoplist is' , shoplist
print 'mylist is' , mylist

        输出

Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

        如果你想要复制一个列表或者类似的列或者其他复杂的对象（不是如整数那样的简单对象），那么你必须使用切片操作符来取得拷贝。
        如果你只是想要使用另一个变量名，两个名称都引用同一个对象，那么如果你不小心的话，可能会引来各种麻烦。

• 更多字符串的内容

        字符串也是对象，同样具有方法。这些方法可以完成包括检验一部分字符串和去除空格在内的各种工作。我们在程序中使用的字符串都是str类的对象。这个类的一些有用的方法会在下面这个例子中说明。如果要了解这些方法的完整列表，请参见help(str)。

name = 'Swaroop'
if name.startswith( 'Swa' ):
    print 'Yes, the string starts with "Swa"'
if 'a' in name:
    print 'Yes, it contains the string "a"'
if name.find( 'war' ) != -1 :
    print 'Yes, it contains the string "war"'
delimiter = '_*_'
mylist =[ 'Brazil' , 'Russia' , 'India' , 'China' ]
print delimiter.join(mylist)

        输出

Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

         这里，我们看到使用了许多字符串方法：
        startwith方法是用来测试字符串是否以给定字符串开始。
        in操作符用来检验一个给定字符串是否为另一个字符串的一部分。
        find方法用来找出给定字符串在另一个字符串中的位置，或者返回-1以表示找不到子字符串。
        str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字串。