python学习之路-第五天-python的数据结构

Posted 2020-10-15 dreamOnly

数据结构

1. 列表

• 例子：

#!/usr/bin/python
# Filename: using_list.py

# This is my shopping list
shoplist = [‘apple‘, ‘mango‘, ‘carrot‘, ‘banana‘]

print ‘I have‘, len(shoplist),‘items to purchase.‘

print ‘These items are:‘, # Notice the comma at end of the line
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

• 结果

$ python using_list.py
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‘]

• 列表中可以添加任意种类的对象

• for in实现了列表的遍历

• append方法可以添加新的对象

• sort方法可以对列表排序，是对列表本身的修改

• del方法后面接上列表中的任意位置，可以删除该对象

2. 元组

• 元组和列表的形式差不多，不过元组中的对象是不允许修改的

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

• 元组通常用于打印语句：

• 例子：

#!/usr/bin/python
# Filename: print_tuple.py

age = 22
name = ‘Swaroop‘

print ‘%s is %d years old‘ % (name, age)
print ‘Why is %s playing with that python?‘ % name

$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?

• 与c中的打印语句类似，不过在python中不用逗号分隔，直接用%定制

• 在第二个print语句中，我们使用了一个定制，后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。

3. 字典

• 字典其实就是key-value对

• 例子：

#!/usr/bin/python
# Filename: using_dict.py

# ‘ab‘ is short for ‘a‘ddress‘b‘ook

ab = {       ‘Swaroop‘   : ‘[email protected]‘,
             ‘Larry‘     : ‘[email protected]‘,
             ‘Matsumoto‘ : ‘[email protected]‘,
             ‘Spammer‘   : ‘[email protected]‘
     }

print "Swaroop‘s address is %s" % ab[‘Swaroop‘]

# Adding a key/value pair
ab[‘Guido‘] = ‘[email protected]‘

# 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‘]

• 结果：

$ python using_dict.py
Swaroop‘s address is [email protected]

There are 4 contacts in the address-book

Contact Swaroop at [email protected]
Contact Matsumoto at [email protected]
Contact Larry at [email protected]
Contact Guido at [email protected]

Guido‘s address is [email protected]

• items方法用于返回一个元组的列表，每个列表中都有键和值，如上面的for循环遍历

• in方法或者has_key方法可以检验这个键是否存在

序列

上面列表，元组，字典都是序列，都有序列的各种方法，序列就是包括索引操作和切片操作；

例子：

#!/usr/bin/python
# Filename: seq.py

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

$ python seq.py
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

• 索引不必多说，下标从0开始，-1表示从右向左数1个，（其实我记忆的话，序列的长度加上这个值，就是他的真实下标）

• 切片符号‘:‘为标志，包括第一个操作数，不包括第二个，也就是左闭右开

• 左操作数为空，从开始位置开始，右操作数为空，到结束位置结束

参考

下面是个例子：

#!/usr/bin/python
# Filename: reference.py

print ‘Simple Assignment‘
shoplist = [‘apple‘, ‘mango‘, ‘carrot‘, ‘banana‘]
mylist = shoplist # mylist is just another name pointing to the same object!

del shoplist[0]

print ‘shoplist is‘, shoplist
print ‘mylist is‘, mylist
# notice that both shoplist and mylist both print the same list without
# the ‘apple‘ confirming that they point to the same object

print ‘Copy by making a full slice‘
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item

print ‘shoplist is‘, shoplist
print ‘mylist is‘, mylist
# notice that now the two lists are different

$ python reference.py
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‘]

从上面的注释中我们已经能看出来，直接用=连接的赋值相当于直接拷贝的地址，原来序列改变，相应赋值的序列也会改变，但是赋值的时候用序列的切片操作赋值，改变原序列后不会影响到赋值的序列