如果你只求很简单的应用、如果你学过其他语言，那么看这一篇就已经可以做到使用Python 编程了。

第02章变量和简单数据类型

1. 变量

变量：我们添加了一个名为message 的变量。每个变量都存储了一个值：与变量相关联的信息。
在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

message = "Hello Python world!"
print(message)
message = "Hello Python Crash Course world!"
print(message)

变量的命名和使用：

①变量名只能包含字母（最好用小写字母）、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。

②变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。

③不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。

④变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。

⑤慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

2. 字符串

字符串：就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。这种灵活性让你能够在字符串中包含引号和撇号：

'I told my friend, "Python is my favorite language!"'
"The language 'Python' is named after Monty Python, not the snake."
"One of Python's strengths is its diverse and supportive community."

使用方法修改字符串的大小写：

name = "ada lovelace"
print(name.title())

#输出：Ada Lovelace

方法title() 出现在这个变量的后面。方法是Python可对数据执行的操作。
在name.title() 中，name 后面的句点（. ）让Python对变量name 执行方法title() 指定的操作。每个方法后面都跟着一对括号，这是因为方法通常需要额外的信息来完成其工作。这种信息是在括号内提供的。函数title() 不需要额外的信息，因此它后面的括号是空的。

name = "Ada Lovelace"
print(name.upper())
print(name.lower())

#输出：ADA LOVELACE
#     ada lovelace

合并（拼接）字符串：
Python使用加号（+ ）来合并字符串。在这个示例中，我们使用+ 来合并first_name 、空格和last_name ，以得到完整的姓名，其结果如下：

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name)


#输出：ada lovelace

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print("Hello, " + full_name.title() + "!")

#输出：Hello, Ada Lovelace!

python字符串中，同样可以用\t 和 \n等制表符。
删除字符串末尾多余的空白：
```
① >>> favorite_language = 'python '
② >>> favorite_language
'python '
③ >>> favorite_language.rstrip()
'python'
④ >>> favorite_language
'python '
```
存储在变量favorite_language 中的字符串末尾包含多余的空白（见①）。你在终端会话中向Python询问这个变量的值时，可看到末尾的空格（见②）。对变
量favorite_language 调用方法rstrip() 后（见③），这个多余的空格被删除了。然而，这种删除只是暂时的，接下来再次询问favorite_language 的值时，你会发
现这个字符串与输入时一样，依然包含多余的空白（见④）。
要永久删除这个字符串中的空白，必须将删除操作的结果存回到变量中：
```
favorite_language = 'python '
favorite_language = favorite_language.rstrip()
```
你还可以剔除字符串开头的空白：可使用方法 lstrip()

3. 数字

①整数

在Python中，可对整数执行加（+ ）减（- ）乘（* ）除（/ ）运算：

>>> 2 + 3
5 >>> 3
-
2
1 >>> 2
*
3
6 >>> 3
/
2
1.5

Python使用两个乘号表示乘方运算：

>>> 3 ** 2
9 
>>> 3 ** 3
27
>>> 10 ** 6
1000000

Python还支持运算次序，因此你可在同一个表达式中使用多种运算。你还可以使用括号来修改运算次序，让Python按你指定的次序执行运算，如下所示：

>>> 2 + 3*4
14
>>> (2 + 3) * 4
20

空格不影响Python计算表达式的方式，它们的存在旨在让你阅读代码时，能迅速确定先执行哪些运算。

②浮点数

从很大程度上说，使用浮点数时都无需考虑其行为。你只需输入要使用的数字，Python通常都会按你期望的方式处理它们。但需要注意的是，结果包含的小数位数可能是不确定的：

>>> 0.2 + 0.1
0.30000000000000004
>>> 3 * 0.1
0.30000000000000004

错误的代码，因为：Python发现你使用了一个值为整数（int ）的变量，但它不知道该如何解读这个值。Python知道，这个变量表示的可能是数值23，也可能是字符2和3。像上面这样在字符串中使用整数时，需要显式地指出你希望Python将这个整数用作字符串。
```
age = 23
message = "Happy " + age + "rd Birthday!"
print(message)
```
为此，可调用函数str() ，它让Python将非字符串值表示为字符串：
```
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)
```

4.注释

在Python中，注释用井号（# ）标识。井号后面的内容都会被Python解释器忽略。

第03章列表简介

1. 列表

列表让你能够在一个地方存储成组的信息，其中可以只包含几个元素，也可以包含数百万个元素。列表是新手可直接使用的最强大的Python功能之一，它融合了众多重要的编程概念。
列表：由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。

在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

#输出：
#['trek', 'cannondale', 'redline', 'specialized']

访问列表元素，下面的代码从列表bicycles 中提取第一款自行车（你还可以对任何列表元素调用第2章介绍的字符串方法）：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[0])

#输出：trek

Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1 ，可让Python返回最后一个列表元素：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])

#输出：specialized

2. 修改、添加和删除元素

修改元素

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)

给列表附加元素时，它将添加到列表末尾。继续使用前一个示例中的列表，在其末尾添加新元素'ducati' ：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles.append('ducati')
print(motorcycles)

#输出：
#['honda', 'yamaha', 'suzuki']
#['honda', 'yamaha', 'suzuki', 'ducati']

你可以先创建一个空列表，再使用一系列的append() 语句添加元素。

motorcycles = []
motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')
print(motorcycles)

使用方法insert() 可在列表的任何位置添加新元素。这种操作将插入位置及其后面的每个元素都右移一个位置：

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)

如果知道要删除的元素在列表中的位置，可使用del 语句：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[1]
print(motorcycles)

方法pop() 可删除列表末尾的元素，并让你能够接着使用它：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()
print(motorcycles)
print(popped_motorcycle)


#输出：
#['honda', 'yamaha', 'suzuki']
#['honda', 'yamaha']
#suzuki

实际上，你可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可：

motorcycles = ['honda', 'yamaha', 'suzuki']
first_owned = motorcycles.pop(0)
print('The first motorcycle I owned was a ' + first_owned.title() + '.')

有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove() ：

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)

too_expensive = 'ducati'
motorcycles.remove(too_expensive)

print(motorcycles)
print("\nA " + too_expensive.title() + " is too expensive for me.")

3. 组织列表

Python方法sort() 让你能够较为轻松地对列表进行排序：

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)


#输出：
#['audi', 'bmw', 'subaru', 'toyota']

你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True：

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)
print(cars)

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted() 。函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序：

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)

print("\nHere is the sorted list:")
print(sorted(cars))

print("\nHere is the original list again:")
print(cars)

要反转列表元素的排列顺序，可使用方法reverse() ：

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)

使用函数len() 可快速获悉列表的长度：

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(len(cars))

第04章操作列表

1. 遍历整个列表

for循环遍历：

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician)

在for 循环中，想包含多少行代码都可以。在代码行for magician in magicians 后面，每个缩进的代码行都是循环的一部分，且将针对列表中的每个值都执行一次。因此，可对列表中的每个值执行任意次数的操作：

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
    print(magician.title() + ", that was a great trick!")
    print("I can't wait to see your next trick, " + magician.title() + ".\n")

for 语句末尾的冒号告诉Python，下一行是循环的第一行。如果你不小心遗漏了冒号，将导致语法错误，因为Python不知道你意欲何为。

2.创建数值列表

Python函数range() 让你能够轻松地生成一系列的数字。range() 只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）：

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


#输出：
#1
#2
#3
#4

要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。如果将range() 作为list() 的参数，输出将为一个数字列表：

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

使用函数range() 时，还可指定步长。例如，下面的代码打印1~10内的偶数：

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

使用函数range() 几乎能够创建任何需要的数字集，例如，如何创建一个列表，其中包含前10个整数（即1~10）的平方呢？在Python中，两个星号（** ）表示乘方运算。下面的代码演示了如何将前10个整数的平方加入到一个列表中：

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

有几个专门用于处理数字列表的Python函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

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

列表解析：将for 循环和创建新元素的代码合并成一行，并自动附加新元素。
要使用这种语法，首先指定一个描述性的列表名，如squares ；然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。
在这个示例中，表达式为value**2 ，它计算平方值。接下来，编写一个for 循环，用于给表达式提供值，再加上右方括号。在这个示例中，for 循环为for value in range(1,11) ，它将值1~10提供给表达式value**2 。请注意，这里的for 语句末尾没有冒号。

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

3. 使用列表的一部分

你可以处理列表的部分元素——Python称之为切片。
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0 、1 和2 的元素：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])

#输出：['charles', 'martina', 'michael']

如果你没有指定第一个索引，Python将自动从列表开头开始。要让切片终止于列表末尾，也可使用类似的语法。

#自动从头开始
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[:4])

#自动到尾部结束
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[2:])

负数索引返回离列表末尾相应距离的元素，因此你可以输出列表末尾的任何切片。
例如，如果你要输出名单上的最后三名队员，可使用切片players[-3:] ：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[-3:])

如果要遍历列表的部分元素，可在for 循环中使用切片：

players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

通过切片复制一个列表（会有两个列表）：

my_foods = ['pizza', 'falafel', 'carrot cake']

#会有两个不同的列表存在
friend_foods = my_foods[:]
my_foods.append('cannoli')
friend_foods.append('ice cream')

而下面这个例子将my_foods 赋给friend_foods ，而不是将my_foods 的副本存储到friend_foods 。这种语法实际上是让Python将新变量friend_foods 关联到包含在my_foods 中的列表，因此这两个变量都指向同一个列表。

my_foods = ['pizza', 'falafel', 'carrot cake']

#这行不通
friend_foods = my_foods
my_foods.append('cannoli')
friend_foods.append('ice cream')

4.元组

有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

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

像列表一样，也可以使用for 循环来遍历元组中的所有值。
虽然不能修改元组的元素，但可以给存储元组的变量赋值。因此，如果要修改前述矩形的尺寸，可重新定义整个元组：

dimensions = (200, 50)
print("Original dimensions:")
for dimension in dimensions:
    print(dimension)

dimensions = (400, 100)
print("\nModified dimensions:")
for dimension in dimensions:
    print(dimension)

5. 代码格式

Python改进提案（Python Enhancement Proposal，PEP）：PEP 8是最古老的PEP之一，它向Python程序员提供了代码格式设置指南。PEP 8的篇幅很长，但大都与复杂的编码结构相关。

PEP 8建议每级缩进都使用四个空格，这既可提高可读性，又留下了足够的多级缩进空间。
你在编写代码时应该使用制表符键，但一定要对编辑器进行设置，使其在文档中插入空格而不是制表符。在程序中混合使用制表符和空格可能导致极难解决的问题。

很多Python程序员都建议每行不超过80字符。
PEP 8还建议注释的行长都不超过72字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符。

第05章 if语句

1. 条件测试

这个示例中的循环首先检查当前的汽车名是否是'bmw' 。如果是，就以全大写的方式打印它；否则就以首字母大写的方式打印：

cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

在Python中检查是否相等时区分大小写，例如，两个大小写不同的值会被视为不相等：

car = 'Audi'
car == 'audi' #False

如果大小写无关紧要，而只想检查变量的值，可将变量的值转换为小写，再进行比较：

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

要判断两个值是否不等，可结合使用惊叹号和等号（!= ），其中的惊叹号表示不，在很多编程语言中都如此。
python中可以使用==、<、>、<=、>=来进行数值比较。
PEP 8提供的建议是，在诸如== 、>= 和<= 等比较运算符两边各添加一个空格。

可以用and和or来检查多个条件：

age_0 = 22
age_1 = 18
age_0 >= 21 and age_1 >= 21 #False

age_0 = 22
age_1 = 18
age_0 >= 21 or age_1 >= 21 #True

还有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in 。例如，如果有一个列表，其中包含被禁止在论坛上发表评论的用户，就可在允许用户提交评论前检查他是否被禁言：

banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
if user not in banned_users:
    print(user.title() + ", you can post a response if you wish.")

布尔表达式

game_active = True
can_edit = False

2. if语句

最简单的if 语句只有一个测试和一个操作。在紧跟在if 语句后面的代码块中，可根据需要包含任意数量的代码行。

if conditional_test:
    do something

经常需要在条件测试通过了时执行一个操作，并在没有通过时执行另一个操作；在这种情况下，可使用Python提供的if-else 语句。

age = 17

if age >= 18:
    print("You are old enough to vote!")
    print("Have you registered to vote yet?")
else:
    print("Sorry, you are too young to vote.")
    print("Please register to vote as soon as you turn 18!")

经常需要检查超过两个的情形，为此可使用Python提供的if-elif-else 结构。Python只执行if-elif-else 结构中的一个代码块。

age = 12

if age < 4:
    print("Your admission cost is $0.")
elif age < 18:
    print("Your admission cost is $5.")
else:
    print("Your admission cost is $10.")

可根据需要使用任意数量的elif 代码块。
Python并不要求if-elif 结构后面必须有else 代码块。

3. 使用if语句处理列表

通过结合使用if 语句和列表，可完成一些有趣的任务：对列表中特定的值做特殊处理；高效地管理不断变化的情形，如餐馆是否还有特定的食材；证明代码在各种情形下都将按预期那样运行。

比萨店在制作比萨时，每添加一种配料都打印一条消息。通过创建一个列表，在其中包含顾客点的配料，并使用一个循环来指出添加到比萨中的配料。然而，如果比萨店的青椒用完了，该如何处理呢？为妥善地处理这种情况，可在for 循环中包含一条if 语句：

requested_toppings = ['mushrooms', 'green peppers', 'extra cheese']

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("\nFinished making your pizza!")

预先确定列表不是空的

requested_toppings = []
if requested_toppings:
    for requested_topping in requested_toppings:
        print("Adding " + requested_topping + ".")
    print("\nFinished making your pizza!")
else:
    print("Are you sure you want a plain pizza?")

使用多个列表

available_toppings = ['mushrooms', 'olives', 'green peppers',
                      'pepperoni', 'pineapple', 'extra cheese']
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']

for requested_topping in requested_toppings:
    if requested_topping in available_toppings:
        print("Adding " + requested_topping + ".")
    else:
        print("Sorry, we don't have " + requested_topping + ".")
print("\nFinished making your pizza!")

第06章字典

1. 使用字典

在Python中，字典：是一系列 键 - 值对 。每个键都与一个值相关联，你可以使用键来访问与之相关联的值。
键 - 值对：两个相关联的值。指定键时，Python将返回与之相关联的值。
值：可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
在Python中，字典用放在花括号{} 中的一系列 键 - 值对 表示。键和值之间用冒号分隔，而键 - 值对之间用逗号分隔。
在字典中，你想存储多少个键—值对都可以。最简单的字典只有一个键—值对

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

alien_0 = {'color': 'green', 'points': 5}
print(alien_0['color'])
print(alien_0['points'])

#输出：
#green
#5

要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

alien_0 = {'color': 'green', 'points': 5}

print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)


#输出：
#{'color': 'green', 'points': 5}
#{'color': 'green', 'points': 5, 'y_position': 25, 'x_position': 0}

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

alien_0 = {'color': 'green'}

alien_0['color'] = 'yellow'

对于字典中不再需要的信息，可使用del 语句将相应的键-值对彻底删除。使用del 语句时，必须指定字典名和要删除的键。删除的键-值对永远消失了

alien_0 = {'color': 'green', 'points': 5}

del alien_0['points']

你也可以使用字典来存储众多对象的同一种信息。我们将一个较大的字典放在了多行中。
确定需要使用多行来定义字典时，在输入左花括号后按回车键，再在下一行缩进四个空格，指定第一个键-值对，并在它后面加上一个逗号。此后你再次按回车键时，文本编辑器将自动缩进后续键-值对，且缩进量与第一个键-值对相同。
定义好字典后，在最后一个键-值对的下一行添加一个右花括号，并缩进四个空格，使其与字典中的键对齐。另外一种不错的做法是在最后一个键-值对后面也加上逗号，为以后在下一行添加键-值对做好准备。

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }

2. 遍历字典

字典可用于以各种方式存储信息，因此有多种遍历字典的方式：可遍历字典的所有键—值对、键或值。
要编写用于遍历字典的for 循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使用任何名称。for 语句的第二部分包含字典名和方法items() ，它返回一个键—值对列表。

user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}

for key, value in user_0.items():
    print("\nKey: " + key)
    print("Value: " + value)

即便遍历字典时，键-值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

遍历字典中的所有键：在不需要使用字典中的值时，方法keys() 很有用。

favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in favorite_languages.keys():
    print(name.title())

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ，输出将不变。
按顺序遍历字典中的所有键，可使用函数sorted() 来获得按特定顺序排列的键列表的副本：

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.")

遍历字典中的所有值：如果你感兴趣的主要是字典包含的值，可使用方法values() ，它返回一个值列表，而不包含任何键。
为剔除重复项，可使用集合（set）。集合：类似于列表，但每个元素都必须是独一无二的：

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())

3.嵌套

有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套。你可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。

列表中嵌套字典：

alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}

aliens = [alien_0, alien_1, alien_2]

for alien in aliens:
    print(alien)

# 创建一个用于存储外星人的空列表
aliens = []

# 创建30个绿色的外星人
for alien_number 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)))

字典中嵌套列表：

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("\t" + language.title())

字典中嵌套字典：下面例子是有多个网站用户，每个都有独特的用户名，可在字典中将用户名作为键，然后将每位用户的信息存储在
一个字典中，并将该字典作为与用户名相关联的值。在下面的程序中，对于每位用户，我们都存储了其三项信息：名、姓和居住地；为访问这些信息，我们遍历所有的用户名，并访问与每个用户名相关联的信息字典

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("\tFull name: " + full_name.title())
    print("\tLocation: " + location.title())

可在字典中嵌套字典，但这样做时，代码可能很快复杂起来。

《Python编程：从入门到实践》笔记

第02章变量和简单数据类型

1. 变量

2. 字符串

3. 数字

4.注释

第03章列表简介

1. 列表

2. 修改、添加和删除元素

3. 组织列表

第04章操作列表

1. 遍历整个列表

2.创建数值列表

3. 使用列表的一部分

4.元组

5. 代码格式

第05章 if语句

1. 条件测试

2. if语句

3. 使用if语句处理列表

第06章字典

1. 使用字典

2. 遍历字典

3.嵌套

猜你喜欢

《Python编程：从入门到实践》 笔记

第02章 变量和简单数据类型

1. 变量

2. 字符串

3. 数字

4.注释

第03章 列表简介

1. 列表

2. 修改、添加和删除元素

3. 组织列表

第04章 操作列表

1. 遍历整个列表

2.创建数值列表

3. 使用列表的一部分

4.元组

5. 代码格式

第05章 if语句

1. 条件测试

2. if语句

3. 使用if语句处理列表

第06章 字典

1. 使用字典

2. 遍历字典

3.嵌套

猜你喜欢

《Python编程：从入门到实践》笔记

第02章变量和简单数据类型

第03章列表简介

第04章操作列表

第06章字典