导航
导航
文章目录
  1. 9.1 简介
  2. 9.2 列表
    1. 对象与类的快速入门
    2. 使用列表
    3. 输出
    4. 如何工作
  3. 9.3 元组
    1. 使用元组
    2. 输出
    3. 如何工作
    4. 元组与打印语句
    5. 输出
    6. 如何工作
  4. 9.4 字典
    1. 使用字典
    2. 输出
    3. 如何工作
  5. 9.5 序列
    1. 使用序列
    2. 输出
    3. 如何工作
  6. 9.6 引用
    1. 对象与引用
    2. 输出
    3. 如何工作
  7. 9.7 更多字符串的内容
    1. 字符串的方法
    2. 输出
    3. 如何工作

简明Python教程-9.数据结构

9.1 简介

数据结构基本上就是——它们可以处理一些 数据 结构
它们是用来存储一组相关数据的
Python中有三种內建的数据结构——列表、元组合字典

9.2 列表

list是处理一组有序项目的数据结构,即可以在一个列表中存储一个 序列 的项目
在列表中,在每个项目之间用逗号分割,并且将项目包括在方括号中,这样Python就知道你在指明一个列表
创建列表之后,可以添加、删除或是搜索列表中的项目
由于可以增加或删除项目,所以说列表是可变的数据类型,即这种类型是可以被改变的

对象与类的快速入门

当使用变量i并给它赋值的时候,可以认为创建了一个(类型)int的 对象 (实例)I
可通过help(int)查看详细信息
类有 方法 ,即仅仅为类而定义的函数
只有在有一个该类的对象的时候,才可以使用这些功能
使用点号来使用对象的方法,如mylist.append(‘an item’)
类有,即仅仅为类而定义的变量
只有在有一个类的对象的时候,才可以使用这些变量/名称
使用点号来使用域,如mylist.fields

使用列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/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

输出

1
2
3
4
5
6
7
8
9
10
$ 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']

如何工作

变量shoplist保存物品名字的字符串(实际上,可以在列表中添加 任何种类的对象 ,包括数字甚至其他列表)
使用for..in循环列表中各项目,列表也是一个序列,序列在后面讨论
print语句的结尾使用了一个逗号来消除每个print语句自动打印的换行符,虽然难看,但简单有效
使用append方法,在列表中添加项目
通过打印列表的内容,来检验项目的添加,只需简单地把列表传递给print语句,就可以得到一个整洁的输出
使用列表的sort方法对列表排序
列表的排序方法影响列表本身,而不是返回一个新列表,这与字符串不同,所以说列表是 可变的 ,字符串是 不可变
del语句从列表中删除我们指定的项目,del shoplist[0]删除第一个元素(Python从0开始计数)
可以通过help(list)获得列表对象定义的所有方法等信息

9.3 元组

元组和列表十分类似,但元组是 不可变的 (字符串也是),即不可修改元组
元组通过 圆括号,和其中用逗号分割的项目 定义
通常用在需要安全地使用一组值的时候,即被使用的元组的值不会改变

使用元组

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python
# Filename: using_tuple.py

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]

输出

1
2
3
4
5
6
$ python using_tuple.py
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函数来获取元组的长度,表明元组也是一个序列(见9.5)
可以通过 方括号 来指明位置,来访问元组中的项目,就像列表一样,这称为索引运算符
使用new_zoo[2]来访问new_zoo中的第三个项目,new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目
含有0个元素的元组,有一对空的圆括号组成,如myempty=()
含有1个元素的元组,在第一个/唯一一个项目后跟一个逗号,如singleton=(2, ),以区分于表达式中一个带圆括号的对象

元组与打印语句

元组最通常的用法是在打印语句中:

1
2
3
4
5
6
7
8
#!/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

输出

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

如何工作

print语句可以使用%符号定制的字符串,%s表示字符串,%d表示整数,元组必须按照相同顺序来对应这些定制
第一个print中,%s对应变量name,元组的第一个项目;%d对应元组的第二个项目age
Python会把元组中的每个项目,转换成字符串,并替换定制位置。%s被替换为变量name的值,以此类推
大多数时候,可以只使用%s定制,Python同样可以处理数。但对应的定制可以多一层检验
第二个print中,定制的%后跟着单个项目,没有圆括号,这只在定制项只有一个的时候有效

9.4 字典

字典类似于地址簿,把(名字)和(详细情况)联系在一起
注意:
键必须是唯一的
键必须是不可变对象(如字符串),值可以是不可变的或可变的。一般应该只使用简单的对象作为键
键值对在字典中标记为:d = {key1 : value1, key2 : value2},键值对用冒号分割,各个对用逗号分割,包含在花括号中
字典中的键值对是没有顺序的。如果想要特定的顺序,应在使用前对它们排序
字典是dict类的实例/对象

使用字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/python
# Filename: using_dict.py

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

ab = { 'Swaroop' : 'swaroopch@byteofpython.info',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
}

print "Swaroop's address is %s" % ab['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']

输出

1
2
3
4
5
6
7
8
9
10
11
$ python using_dict.py
Swaroop's address is swaroopch@byteofpython.info

There are 4 contacts in the address-book

Contact Swaroop at swaroopch@byteofpython.info
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org
Contact Guido at guido@python.org

Guido's address is guido@python.org

如何工作

使用字典的标记创建了字典ab,使用索引操作符指定键来使用键值对
使用索引操作符指定一个键并赋值,增加一个新的键值对,如Guido
使用del语句来删除键值对,使用索引操作符指明要删除的键,无需知道值
字典的items方法返回一个元组的列表,每个元组都包含一对项目——键与对应的值。抓取对,并分别赋给for..in循环中的变量name和address,然后在for块中打印
使用in操作符来检验一个键值对是否存在,或使用dict类的has_key方法(使用help(dict)来查看)

9.5 序列

列表、元组和字符串都是序列
序列的两个主要特点是 索引 操作符和 切片 操作符
索引操作符让我们可以从序列中抓取一个特定项目
切片操作符让我们可以获取序列的一个切片

使用序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/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[:]

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$ 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

如何工作

通过索引来获取序列中的单个项目,也被称作下标操作,使用方括号中的数来制定序列对应位置的项目
Python从0开始计数,shoplist[0]抓取第一个元素,shoplist[3]抓取第四个元素
索引可以是负数,位置从序列尾开始计算。如shoplist[-1]表示序列最后一个元素,shoplist[-2]抓取序列倒数第二个元素
切片操作符:
1、是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割。这与索引操作符十分相似,需要注意的是,数是可选的,冒号是必须的
2、第一个数(冒号前)表示切片开始位置,第二个数(冒号后)表示切片结束位置。如果不指定第一个数,则从序列首开始,如果不指定第二个数,则停止在序列尾。注意,返回的序列从 开始位置 开始,在 结束位置之前 结束,即,开始位置包含在序列切片中,而结束位置被排斥在切片外
例如,shoplist[1:3]返回位置1开始,包括位置2,停止在位置3的一个序列切片。因此返回一个含有两个项目的切片
shoplist[:]返回整个序列的拷贝
可以用负数做切片,负数从负数尾开始计算位置。如,shoplist[:-1]返回除了最后一个项目外的序列切片
序列的神奇之处在于,可以用相同的方法访问元组、列表和字符串

9.6 引用

当创建一个对象,并给它赋一个变量的时候,这个变量仅仅 引用 那个对象,而不是对象本身。即,变量名指向计算机中存储的那个对象的内存。
这被称作名称到对象的 绑定
一般不需担心,但有些细微的效果需要注意。

对象与引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/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

输出

1
2
3
4
5
6
7
$ 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']

如何工作

大多数解释已经在程序注释中了
需要记住的是,如果想复制一个列表,或者类似的序列或者其他复杂的对象(不是整数那样的 简单对象 ),则需要使用切片操作符来取得拷贝
如果只使用变量赋值,则两个变量都 引用 另一个对象

9.7 更多字符串的内容

字符串也是对象,同样具有方法,可以完成包括检验一部分字符串和去除空格在内的各种工作
在程序中使用的字符串,都是str类的对象,下面例子说明其中一些方法,具体列表参见help(str)

字符串的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/python
# Filename: str_methods.py

name = 'Swaroop' # This is a string object

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)

输出

1
2
3
4
5
$ python str_methods.py
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方法,用一个作为分隔符的字符串连接序列的项目,返回生成的大字符串