列表

列表简介

一组按特定顺序排列的元素,用方括号[]来标识,逗号分隔其中元素。

访问:

使用索引访问列表元素,请求获取列表元素时只返回该元素不包括方括号和引号,用title()方法可让格式更规整。

1
2
3
4
motorcycles = ['honda','yamaha','suzuki']
print(motorcycles)
print(motorcycles[0])
print(motorcycles[0].title())

['honda','yamaha','suzuki']
honda
Honda


列表与其他语言中的数组类似,索引从0开始,但是为最后一个列表元素提供了一种特殊语法:通过将索引指定为-1,可返回到最后一个列表元素。这种约定适用于其他负数索引,例如索引-2返回倒数第二个列表元素,索引-3返回倒数第三个列表元素。

1
print(motorcycles[-1])

suzuki


修改:

列表一般来说都是动态的,可以进行增删改查。

通过指定列表名和元素索引,赋予新值来对列表元素进行修改。

1
2
motorcycles[0] = 'ducati'
print(motorcycles)

['ducati','yamaha','suzuki']


使用append()方法在指定列表末尾添加新元素。实际中可先创建空列表再使用一系列append()语句添加元素。

1
2
motorcycles.append('honda')
print(motorcycles)

['ducati','yamaha','suzuki','honda']


使用insert()方法指定在列表的任何位置添加新元素。这种操作将列表中既有的索引号即以后的元素都右移一个位置。

1
2
motorcycle.insert(0, 'sanya')
print(motorcycles)

['sanya,''ducati','yamaha','suzuki','honda']


使用del语句对列表中已知位置的元素进行删除。

1
2
del motorcycle[0]
print(motorcycles)

['ducati','yamaha','suzuki','honda']


也可使用pop()方法将元素从列表中删除并接着使用它的值。pop()方法中未指定索引的情况下默认删除列表末尾元素。指定索引的情况下pop()可以删除列表中任何位置的元素。

1
2
3
4
5
6
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycles)
popped_motorcycle = motorcycles.pop(0)
print(motorcycles)
print(popped_motorcycles)

['ducati','yamaha','suzuki']
honda
['yamaha','suzuki']
ducati


使用remove()方法可根据指定值删除列表元素。remove()方法只删除第一个指定的值,如果要删除的值可能在列表中出现多次就需要用循环来判断是否删除了所有值。

1
2
motoecycles.remove('yamaha')
print(motorcycles)

['suzuki']


组织:

使用sort()方法可对列表进行永久性排序。下例让列表元素按字母排序,若要按与字母顺序相反的顺序排序只需向sort()方法传递参数reverse=True

1
2
3
4
5
cars = ['bmw','audi','toyota','subaru']
cars.sort()
print(cars)
cars.sort(reverse=True)
print(cars)

['audi','bmw','subaru','toyota']
['toyota','subaru','bmw','audi']


使用sorted()函数可对列表进行临时排序,保留列表元素原排列顺序,按照特定顺序显示。要按与字母顺序相反的顺序显示列表,也可向该函数传递参数reverse=True。

1
2
3
print(cars)
print(sorted(cars))
print(cars)

['toyota','subaru','bmw','audi']
['audi','bmw','subaru','toyota']
['toyota','subaru','bmw','audi']


在普通情况下,并非所有值都是小写的,按字母顺序排列列表要复杂一些,决定排序顺序时有多种解读大写字母的方式,要指定准确的排列顺序。这里只是简单的举例这两种方法。

使用reverse()方法反转列表元素排列顺序,这个操作是永久性修改但要复原再次reverse就可以了。

1
2
cars.reverse()
print(cars)

['audi','bmw','subaru','toyota']


使用函数len()快速获取列表长度。

1
len(cars)

4


操作列表

遍历:

使用for循环可遍历整个列表,其中按顺序获取列表magicians中的值并存储到变量magican中,然后依次执行循环体中的语句(python根据缩进来判断代码行与前一个代码行的关系),直到列表元素循环读尽,该变量可指定任何名称。

1
2
3
magicians = ['alice','david','carolina']
for magican in magicians:
    print(magican)

alice
david
carolina


创建:

使用range()函数可以轻松生成一系列数字。函数range()从指定的第一个值开始,并在到达指定的第二个值后就停止不进入循环语句,故不包括第二个值。

1
2
for value in range(1, 5):
	print(value)

1
2
3
4


range()函数也可通过作为list()的参数来创建数字列表

1
2
numbers = list(range(1, 6))
print(numbers)

[1,2,3,4,5]


此外还可指定range()函数的步长

1
2
even_numbers = list(range(2,11,2))
print(even_numbers)

[2,4,6,8,10]


range()函数几乎能够创建任何需要的数字集,例如:创建一个列表其中包含前10个整数的平方(python中**表示乘方运算)

1
2
3
4
squares = []
for value in range(1, 11):
    squares.append(value ** 2)
print(squares)

[1,4,9,16,25,36,49,64,81,100]


此外,还有几个专门用于处理数字列表的python函数:

1
2
3
4
digits = [1,2,3,4,5,6,7,8,9,0]
print(min(digits))
print(max(digits))
print(sum(digits))

0
9
45


Python中列表解析将for循环和创建新元素的代码合并成一行并自动附加新元素,下面使用列表解析创建列表squares。列表解析中先要指定一个描述性的列表名,然后指定一个左方括号并定义一个表达式用于生成要存储到列表中的值,接下来,写一个for循环用于给表达式提供值(这里for语句末尾不要冒号),补全右括号。

1
2
squares = [value ** 2 for value in range(1, 11)]
print(squares)

[1,4,9,16,25,36,49,64,81,100]


切片:

创建:

Python中列表的部分元素称为切片,要创建切片可指定要使用的第一个元素和最后一个元素索引,与range()函数类似。

1
2
players = ['ame','maybe','charles','fy','xnova']
print(players[0:3])

['ame','maybe','charles']


若没有指定起始索引或终止索引,将自动从列表开头开始提取到终止索引,或从指定起始索引提取到列表末尾。也可通过负数索引输出列表末尾的任何切片。

1
2
3
print(players[:4])
print(players[2:])
print(players[-3:])

['ame','maybe','charles','fy']
['charles','fy','xnova']
['charles','fy','xnova']


遍历:

可在for循环中使用切片对列表部分元素进行遍历

1
2
for player in players[:3]:
    print(player.title())

['ame','maybe','charles']


复制列表:

通过既有列表创建全新列表,可创建一个包含整个列表的切片(省略起始索引和终止索引即可)

1
2
3
4
5
new = players[:]
new[1] = x
new[3] = 'xx'
print(players)
print(new)

['ame','maybe','charles','fy','xnova']
['ame','x','charles','xx','xnova']


不可以直接简单地将旧列表赋给新列表(new = players ✖ ),这样做实际上是让新变量new关联到包含在players中的列表,因此这两个变量都指向同一个列表,而不是复制出另一个全新的列表。

元组

列表适合用于存储在程序运行期间可能发生变化的数据集,可以进行修改。而存储一系列不可修改的元素时,这种不可变的列表被称为元组。

定义:

与列表不同,元组使用圆括号来标识,访问元素一样通过索引。

1
2
dimensions = (200,50)
print(dimensions[0])

200


上面将一个大小不变的矩形长和宽存储在定义的元组中,当代码出现试图修改元组的操作时,会返回类型错误消息。

遍历:

与列表类似,使用for循环遍历

1
2
3
dimensions = (200,50)
for dimension in dimensions:
	print(dimension)

200
50


修改元组变量:

虽然不能修改元组元素,但可以给存储元组的变 量赋值。即重新定义整个元组。

1
2
3
4
5
6
 dimensions = (200,50)
for dimension in dimensions:
	print(dimension)
dimensions = (400,100)
for dimension in dimensions:
	print(dimension)

200
50
400
100


代码格式:

PEP 8 建议每级缩进都使用四个空格,在程序中混合使用制表符和空格可能导致意外的问题,大多数编辑器中都提供了将制表符转换为空格的功能。

建议行长不超过80字符,这样可以在屏幕上打开多个文件时能同时看到哥哥文件的完整行。此外,PEP 8 还建议注释的行长都不超过72字符,因为有些工具为大型项目自动生成文档时会在每行注释开头添加格式化字符。

要将程序的不通过部分分开,可使用空行来组织程序文件,但也不能滥用。空行不会影响代码运行,但会影响代码的可读性。Python解释器根据水平缩进情况来解读代码,但不关心垂直间距。

条件判定

条件测试

每条if语句的核心都是一个值为True或False的表达式,这种表达式被称为条件测试。Python根据条件测试的值为True还是False来决定是否执行条件语句中的代码。

检查相等

大多数条件测试都将一个变量的当前值同特定值进行比较。


>>> car = 'bmw'
>>> car == 'bmw'
True


和其他语言类似,检查相等时用 == ,检查不等时用 != ,Python中检查是否相等时区分大小写,若要不区分大小写的测试可以采用下例方法,这样比较不会影响原来的变量。


>>> car = 'Audi'
>>> car.lower() == 'audi'
True
>>> car
'Audi'


若要同时检查多个条件,可使用关键字 and 和 or 。


>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 or age_1 >= 21
True
>>> age_0 >= 21 and age_1 >= 21
False


要检查特定值是否包含在列表中时,可使用关键字 in (不在使用 not in )。


>>> requested_toppings = ['mushrooms','onions','pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False


if语句

if 语句与变体

if语句中可包含任何条件测试,而后面的缩进代码块中可执行任何操作,条件测试的结果决定了执行或忽略该代码块。

if-else中else语句能指定条件测试未通过时要执行的操作。

1
2
3
4
5
6
7
age = 22
if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, youare too young to vote.")
    print("Please register to vote as soon as you turn 18!")

>>> You are old enough to vote!
>>> Have you registered to vote yet?


当需要检查超过两个的情况时,可使用 if-elif-else 结构。依次检查每个条件测试,直到遇到通过了的条件测试。测试通过后执行紧跟其后的缩进代码块并跳过余下的测试(这适用于只想执行一个代码块的情况,想要运行多个代码块就要使用一系列独立的 if 语句)。

1
2
3
4
5
6
7
8
age = 12
if age < 4:
    price = 0
elif age < 18:
    price = 5
else:
    price = 10
print("Your admission cost is $" + str(price) + ".")

上述代码中最后的 else 可修改为 elif age >= 18 这样更为清晰,因为 else 是一条包罗万象的语句,只要不满足前面所有的条件测试就会执行自己的缩进代码块,这可能会引入无效甚至恶意的数据。

用 if 语句处理列表

利用 for 循环结合 if 语句可检查列表中的特殊值并作出合适的处理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']
if requested_toppings:       //
    for requested_topping in requested_toppings:
        if requested_topping == 'green peppers':
            print("Sorry, we are out of green peppers right now.")
        else:
            print("Adding " + requested_topping + ".")
    print("Finished making your pizza!")
else:
    print("Sorry, we only have plain pizzas")

>>> Adding mushrooms.
>>> Sorry, we are out of green peppers right now.
Adding extra cheese.
>>> Finished making your pizza!


字典

简单示例

Python中字典可存储不受限制的信息量,能高效地模拟现实世界中的情形,下面是一个字典的简单示例:

1
2
3
alien = {'color':'green','points':5}
print(alien['color'])
print(alien['points'])

green
5


简单使用

Python中字典是一系列的 - 对,每个键都与一个值相关联,可以通过键来访问与之相关联的值,这个值可以是数字、字符串、列表乃至字典,python中可将任何python对象用作字典中的值。

在指定键时,python将返回与之相关联的值。键和值之间用冒号分隔,而 键-值 对之间之间用逗号分隔。一个字典中可以存储任意个 键-值 对。

访问字典

要获取与键相关联的值,可依次指定字典名和放在方括号内的值

1
2
3
alien = {'color':'green','points':5}
new_points = alien['points']
print("You just earned " + str(new_points) + " points!")

You just earned 5 points!


添加键-值对

字典作为一种动态结构,可随时在其中添加键-值对,依次指定字典名、用方括号括起的键和相关联的值。

1
2
3
4
5
alien = {'color':'green','points':5}
print(alien)
alien['x_position'] = 0
alien['y_position'] = 25
print(alien)

{'color':'green','points':5}
{'color':'green','points':5,'y_position':25,'x_potion':0}


Python不关心键-值对的添加顺序,只关心键和值之间的关联关系,所以键-值对的排列顺序不一定与添加顺序相同。

创建空字典、修改与删除键-值对

为了方便,可先使用一对空的花括号定义一个空字典,再分行添加各种键-值对。使用字典来存储用户提供的数据或在编写能自动生成大量键-值对的代码时,通常都需要先定义一个空字典。

要修改字典中的值,可依次指定字典名、用方括号括起的键以及与该键相关联的新值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
alien = {}
alien['x_position'] = 0
alien['y_position'] = 25
alien['speed'] = 'medium'
print("Original x_position: " + str(alien['x_position']))
#向右移动外星人

#根据外星人当前速度决定将其移动多远

if alien['speed'] = 'slow':
    x_increment = 1
elif alien['speed'] == 'medium':
    x_increment = 2
else
#这个外星人的速度很快

    x_increment = 3
#新位置等于老位置加上增量

alien['x_position'] = alien['x_position'] + x_increment
print("New x_position: " + str(alien['x_position']))

Original x_position: 0
New x_position: 2

删除键-值对只需要使用del语句指定字典名和要删除的键就可将字典中相应的键-值对彻底删除。

由类似对象组成的字典

字典除了可以存储一个对象的多种信息之外,还可以用来存储众多对象的同一种信息。在定义字典时可以在输入左花括号后按回车键,再在下一行缩进四个空格,指定第一个键-值对后在它后面加上逗号,回车后文本编辑器将自动缩进以继续指定键-值对,在最后一个键-值对的下一行缩进四个空格并用右花括号结束字典定义(最后一个键—值对后面也加上逗号,为以后在下一行添加键—值对做好准备。)。

1
2
3
4
5
6
7
favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
    }
print("Sarah's favorite language is " + favorite_languages['sarah'].title() + ".")

Sarah's favorite language is C.


遍历字典

遍历所有键-值对

使用 for 循环即可遍历字典,for循环中可声明任意变量名的两个变量用于存储键-值对中的键和值。用items()方法可返回一个键-值对列表,for循环会依次将每个键-值对存储到指定的两个变量中(遍历字典时,键-值对的返回顺序不与存储顺序相同)。

1
2
3
4
5
6
7
8
9
#对于存储的是不同人的同一种信息这样的字典,遍历所有的键-值对很合适

user = {
    'username':'efermi',
    'first':'enrico',
    'last':'fermi',
    }
for key, value in user.items():
    print("\nKey: " + key)
    print("Value: " + value)

Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi


遍历所有键

不需要使用字典中的值时,方法keys()可只检索字典中的键。也可以省略方法keys(),因为在遍历字典时会默认遍历所有的键。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
    }
friends = ['phil','sarah']
#打印每个人名字,只对朋友打印特殊消息

for name in favorite_languages.keys():
    print(name.title())
    if name in friends:
        print("  Hi " + name.title() + ", I see your favorite language is " + favorite_languages[name].title() + "!")

Edward
Phil
Hi Phil, I see your favorite language is Python!
Sarah
Hi Sarah, I see your favorite language is C!
Jen


按顺序遍历所有键

字典明确地记录键和值之间的关联关系,但是获取字典元素时的获取顺序是不可预测的。若要以特定顺序返回元素的话,可在 for 循环中对返回的键进行排序。例如,可用函数sorted()来获得按特定顺序排列的键列表的副本。

1
2
3
4
5
6
7
8
favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
    }
for name in sorted(favorite_languages.keys()):
    print(name.title() + ", thank you for taking the poll.")

Edward, thank you for taking the poll.
Jen, thank you for taking the poll.
Phil, thank you for taking the poll.
Sarah, thank you for taking the poll.


遍历字典中所有值

使用方法values()可返回一个值列表,其中不包含任何键。而若要剔除掉最终列表中大量的重复项,可使用集合(set)。

1
2
3
4
5
6
7
8
9
favorite_languages = {
    'jen':'python',
    'sarah':'c',
    'edward':'ruby',
    'phil':'python',
    }
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

The following languages have been mentioned:
Python
C
Ruby


嵌套

有时需要将一系列字典存储在列表中,或将列表作为值存储在字典中,甚至字典中嵌套字典。

字典列表

若一个字典包含了一个个体的各种信息,这是是无法存储第二个个体的信息的。这时可以创建一个列表,其中存储一系列字典分别对应到每个个体以此实现管理。

1
2
3
4
5
6
7
8
aliens = []
for alien_numer in range(30):
    new_alien = {'color':'green','points':5,'speed':'slow'}
    aliens.append(new_alien)
for alien in aliens[:5]:
    print(alien)
print("...")
print("Total number of aliens: " + str(len(aliens)))

'speed':'slow','color':'green','points':5
'speed':'slow','color':'green','points':5
'speed':'slow','color':'green','points':5
'speed':'slow','color':'green','points':5
'speed':'slow','color':'green','points':5
...
Total number of aliens:30


字典中存储列表

列表可以存储在字典中,每当需要在字典中将一个键关联到多个值时,都可以在字典中嵌套一个列表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
favorite_languages = {
    'jen':['python','ruby'],
    'sarah':'c',
    'edward':['ruby','go'],
    'phil':['python','haskell'],
    }
for name, languages in favorite_languages.items():
    print("\n" + name.title() + "'s favorite languages are:")
    for language in languages:
        print(language.title())

Jen's favorite languages are:
Python
Ruby
Sarah's favorite languages are:
C
Phil's favorite languages are:
Python
Haskell
Edward's favorite languages are:
Ruby
Go


在字典中存储字典

字典嵌套于字典中是可行的,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
users = {
    'aeinstein':{
        'first':'albert',
        'last':'einstein',
        'location':'princeton',
        },
    'mcurie':{
        'first':'marie',
        'last':'curie',
        'location':'paris',
        },
    }
for username, user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + " " + user_info['last']
    location = user_info['location']
    print("Full name: " + full_name.title())
    print("Location: " + location.title())

Username: aeinstein
Full name: Albert Einstein
Location: Princetion
Username: mcurie
Full name: Marie Curie
Location: Paris