python语法随记

学习python中的小记录…和YH约定的两周学习计划
工具：idle

1.字符串

字符串 字符串 就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，如下所示：

"This is a string."
'This is also a string.'

1.1 修改字符串的大小写

name.py

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

输出为
Ada Lovelace
示例中，小写的字符串"ada lovelace" 存储到了变量name 中。在print() 语句中，方法title() 出现在这个变量的后面。

---

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

---

要将字符串改为全部大写或全部小写

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

输出为
ADA LOVELACE
ada lovelace
存储数据时，方法lower() 很有用。很多时候，你无法依靠用户来提供正确的大小写，因此需要将字符串先转换为小写，再存储它们。以后需要显示这些信息时，再将其转换为最合适的大小写方式。

1.2 合并（拼接）字符串

示例

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

Python使用加号（+ ）来合并字符串。
本例输出为
ada lovelace
这种合并字符串的方法称为拼接。通过拼接，可使用存储在变量中的信息来创建完整的消息.

示例2

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

本例使用了方法title() 来将姓名设置为合适的格式。输出为
Hello, Ada Lovelace!

1.3 使用制表符或换行符来添加空白

要在字符串中添加制表符，可使用字符组合\t，要在字符串中添加换行符，可使用字符组合\n。
代码示例（输出看看效果）：

  print("Languages:\n\tPython\n\tC\n\tJavaScript")

1.4 删除空白

在程序中，额外的空白可能令人迷惑。对程序员来说，‘python’ 和’python ’ 看起来几乎没什么两样，但对程序来说，它们却是两个不同的字符串。
删除用户输入的数据中的多余的空白，可使用方法rstrip()。

❶ >>> 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()
  >>> favorite_language
  'python'

剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法lstrip() 和strip() ：

>>> favorite_language = ' python '
>>> favorite_language.rstrip()
' python'
>>> favorite_language.lstrip()
'python '
>>> favorite_language.strip()
'python'

在这个示例中，首先创建了一个开头和末尾都有空白的字符串，然后分别删除末尾、开头和两端的空格。

1.5 使用函数str() 避免类型错误

有时需要在消息中使用变量的值。例如，假设你要祝人生日快乐，可能会编写类似于下面的代码：
birthday.py

age = 23
message = "Happy " + age + "rd Birthday!"
print(message)

你可能认为，上述代码会打印一条简单的生日祝福语：Happy 23rd bi rthday!。但如果你运行这些代码，将发现它们会引发错误：
Traceback (most recent call last):
File “birthday.py”, line 2, in
message = "Happy " + age + “rd Birthday!”
❶ TypeError: Can’t convert ‘int’ object to str implicitly
Python发现你使用了一个值为整数（int ）的变量，但它不知道该如何解读这个值。调用函数str() ，它让Python将非字符串值表示为字符串：

age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

此时输出为
Happy 23rd Birthday!

2. 列表

2.1 列表简介

列表中可以存储各种元素，他们之间可以是不同的类别。在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。
列表的索引从0开始

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

输出为
cannondale（第二个元素）
specialized（第四个元素）
访问最后一个列表元素可以将索引指定为-1.

列表中的元素可以像变量那样被使用

>>> bicycles = ['trek', 'cannondale', 'redline', 'specialized']
>>> message = "My first bicycle was a " + bicycles[0].title() + "."
>>> print(message)
My first bicycle was a Trek.

这里使用bicycles[0] 的值生成了一个句子，并将其存储在变量message 中。

2.2 修改列表元素

修改列表中的某一个元素：

 bicycles[0] = 'demo1'
 print (bicycles)

在列表末尾添加元素

bicycless.append('ducati')
print(motorcycles)

用方法append() 让动态地创建列表，可以先创建一个空列表，再使用一系列的append() 语句添加元素

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

在列表中插入元素，使用方法insert()

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

输出
[‘ducati’, ‘honda’, ‘yamaha’, ‘suzuki’]

2.3 花样删除列表中的元素

1.利用索引从列表中删除元素
del motorcycles[1]
print(motorcycles)

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

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

列表末尾的值’suzuki’ 已删除，它现在存储在变量popped_motorcycle 中：
[‘honda’, ‘yamaha’, ‘suzuki’]
[‘honda’, ‘yamaha’]
suzuki
也可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。每当你使用pop() 时，被弹出的元素就不再在列表中了。
如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元素后还能继续使用它，就使用方法pop() 。

3.根据值删除元素
有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove().
假设我们要从列表motorcycles 中删除值’ducati’ 。

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

输出结果
[‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
[‘honda’, ‘yamaha’, ‘suzuki’]

4.使用remove() 从列表中删除元素时，也可接着使用它的值：

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

输出结果
[‘honda’, ‘yamaha’, ‘suzuki’, ‘ducati’]
[‘honda’, ‘yamaha’, ‘suzuki’]
注意 　方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

2.4列表排序

使用方法sort() 对列表进行永久性排序

cars.py

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

run 后得到输出（此时汽车是按字母顺序排列的，再也无法恢复到原来的排列顺序：）
[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]

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

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

[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
[‘toyota’, ‘subaru’, ‘bmw’, ‘audi’]

使用函数sorted() 对列表进行临时排序

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()

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

输出结果为
[‘audi’, ‘bmw’, ‘subaru’, ‘toyota’]
[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
我们同样可以向函数sorted() 传递参数reverse=True .

反转列表元素的排列顺序

要反转列表元素的排列顺序，可使用方法reverse() 。注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：

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

[‘bmw’, ‘audi’, ‘toyota’, ‘subaru’]
[‘subaru’, ‘toyota’, ‘audi’, ‘bmw’]
方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，为此只需对列表再次调用reverse() 即可。

确定列表的长度

使用函数len() 可快速获悉列表的长度。列表包含4个元素，因此其长度为4.
len(cars)

避免列表索引错误和小结

索引-1 总是返回最后一个列表元素，当列表为空时，这种访问最后一个元素的方式才会导致错误。
小结
列表是什么以及如何使用其中的元素；
如何定义列表以及如何增删元素；
如何对列表进行永久性排序，以及如何为展示列表而进行临时排序；
如何确定列表的长度，以及在使用列表时如何避免索引错误。

3 操作列表

3.1 遍历整个列表

用for循环打印列表

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

码让Python从列表magicians 中取出一个名字，并将其存储在变
量mags中。然后让Python打印前面存储到变量mags中的名字.
输出为
alice
david
carolina
编写for 循环时，对于用于存储列表中每个值的临时变量，可指定任何名称。然而，选择描述单个列表元素的有意义的名称大有帮助。所以，其实，在本例中将mags换成magician会让程序更易读。使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表。

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

顺带在每个循环多执行一个操作。
另外，别忘了for后面的冒号。

3.2 创建数值列表

3.2.1 range()

使用函数range() 来打印一系列的数字：

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

输出
1
2
3
4
函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）

3.2.2 使用range() 创建数字列表

要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表

>>> numbers = list(range(1,6))
>>> print(numbers)
[1, 2, 3, 4, 5]

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

>>> even_numbers = list(range(2,11,2))
>>> print(even_numbers)
[2, 4, 6, 8, 10]

何将前10个整数的平方加入到一个列表中（两个星号（**）表示乘方运算）：

>>> squares = []  ##先创建空表
>>> for value in range(1,11):  ##遍历1-10
	square = value**2
	squares.append(square) ##将新计算得到的平方值附加到列表squares 末尾

	
>>> print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

简洁写法(在循环中，计算每个值的平方，并立即将结果附加到列表squares 的末尾。)

 squares.append(value**2)

3.2.3 对数字列表进行简单统计（max，min，sum）

>>> min(squares)
1
>>> max(squares)
100
>>> sum(squares)
385

3.3.4　列表解析

将for 循环和创建新元素的代码合并成一行，并自动附加新元素。

>>> squares = [value**2 for value in range(1,11)]
>>> print(squares)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

方括号里定义了一个表达式，表达式为value2 ，它计算平方值。接下来，编写一个for 循环，用于给表达式提供值。
示例中，for 循环为for value in range(1,11) ，它将值1~10提供给表达式value2 。请注意，这里的for 语句末尾没有冒号。

3.4 处理列表的部分元素——切片

3.4.1 切片

用切片可以生成列表的任何子集，如，提取列表的第2～4个元素，可以将起始索引指定为1 ，并将终止索引指定为4 ：

>>> players = ['charles', 'martina', 'michael', 'florence', 'eli']
>>> print(players[1:4])
['martina', 'michael', 'florence']

这里切片始于’marita’ ，终于’florence’
如果你没有指定第一个索引，Python将自动从列表开头开始：

>>> print(players[:4])
['charles', 'martina', 'michael', 'florence']

让切片终止于列表末尾，也可使用类似的语法。

>>> print(players[2:])
['michael', 'florence', 'eli']

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

>>> players[-3:]
['michael', 'florence', 'eli']

3.4.2 遍历切片

遍历前三名队员，并打印他们的名字：

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

	
Charles
Martina
Michael

典型应用：获取玩家游戏的最高分，将列表降序后，创建一个只包含前三个得分的切片即可。

3.4.3 复制列表

复制列表用法：

>>> new_players = players[:]
>>> print(new_players)
['charles', 'martina', 'michael', 'florence', 'eli']
>>> new_players.append('lzz')
>>> players.append('old_p')
>>> print(players)
['charles', 'martina', 'michael', 'florence', 'eli', 'old_p']
>>> print(new_players)
['charles', 'martina', 'michael', 'florence', 'eli', 'lzz']

不用的列表加上不同元素，说明确实复制上了。这里，我们在不指定任何索引的情况下从列表players中提取一个切片，从而创建了这个列表的副本，再将该副本存储到变量new_players中。

如果写成这样，两个变量会指向同一个列表。并不是创建副本
new_players = players
可以看看效果

>>> my_foods = ['pizza', 'falafel', 'carrot cake']
>>> friend_foods = my_foods
>>> my_foods.append('cannoli')
>>> friend_foods.append('ice cream')
>>> print(my_foods)
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
>>> print(friend_foods)
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
>>> friend_foods.append('yyy')
>>> print(my_foods)
['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream', 'yyy']

不管在my_foods还是在friend_foods做改变，最终都会影响到两个变量～

3.5 元组

列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。
而不可变的列表被称为元组 。
元组使用了圆括号而不是方括号。

>>> dimensions = (200, 50)
>>> print(dimensions[1])
50
>>> dimensions[0] = 250
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    dimensions[0] = 250
TypeError: 'tuple' object does not support item assignment

示例告诉我们，对元组的元素进行修改的操作是被禁止的。

虽然不能修改元组的元素，但可以给存储元组的变量赋值。

dimensions = (200, 50)
dimensions = (400, 100)
for dimension in dimensions:
      print(dimension)

输出
400
100

4 if语句

这一章内容好像比较少，这里只摘录部分。
例1，检查当前汽车名是否为’bmw’，若是，以全大写打印。

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

Audi
BMW
Subaru
Toyota

检查是否相等，不相等会返回False

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

检查是否不相等用 !=

用and检查多个条件，检查是否两个条件是否都满足

age_0 >= 21 and age_1 >= 21

用or检查多个条件，只要有一个条件满足就可以

检查特定值是否包含在列表中（比如结束用户的注册过程前，可能需要检查他提供的用户名是否已包含在用户名列表中。在地图程序中，可能需要检查用户提交的位置是否包含在已知位置列表中。）

>>> stdlist=['a','b','c']
>>> 'c' in stdlist
True

检查特定值是否不包含在列表中可使用关键字not in

if-else语句
if age >= 18:
	...
else:
	...

if-elif-else结构

5. 字典

5.1 简单的例子
存储了有关特定外星人的信息的字典（字典alien_0 存储了外星人的颜色和点数）：

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

输出
green
5

在Python中，字典 是一系列 键 —值对 （花括号中）。每个键 键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
键和值之间用冒号分隔，而键—值对之间用逗号分隔。
键 —值对是两个相关联的值。指定键时，Python将返回与之相关联的值。

5.2 使用字典（创建访问修改添加删除）

添加键 —值对

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

输出
green
5
{‘color’: ‘green’, ‘points’: 5, ‘x_position’: 0, ‘y_position’: 25}

创建空字典

先使用一对空的花括号定义一个字典，再分行添加各个键—值对。

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

输出
{‘color’: ‘green’, ‘points’: 5}

修改

alien_0 = {'color': 'green'}  
alien_0['color'] = 'yellow'   #直接进行修改即可，亦可在实现中随时更新，如位置+increase增量

删除键 —值对 del

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

输出
{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘green’}

由类似对象组成的字典

可以使用字典来存储众多对象的同一种信息。例如，假设你要调查很多人，询问他们最喜欢的编程语言，可使用一个字典来存储这种简单调查的结果，如下所示：

每个键都是一个被调查者的名字，而每个值都是被调查者喜欢的语言。给定被调查者的名字，可使用这个字典轻松地获悉他喜欢的语言：
favorite.py

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.

>>> favorite_languages['sarah']
'c'

5.3 遍历字典

遍历所有 键-值对 items()

示例：获悉该用户字典中的所有信息

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

输出
Key: username
Value: efermi

Key: first
Value: enrico

Key: last
Value: fermi
要编写用于遍历字典的for 循环，可声明两个变量，用于存储键—值对中的键和值。对于这两个变量，可使用任何名称。字典名和方法items()返回一个键—值对列表。
【注意】即便遍历字典时，键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

遍历所有 键 keys()

不需要使用字典中的值时，使用方法keys()

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

输出
Jen
Sarah
Edward
Phil
for那行代码提取字典favorite_languages 中的所有键，并依次将它们存储到变量name 中。
亦可替换为
for name in favorite_languages:
输出不变。

---

示例：检查当前的名字是否在列表friends 中，如果在就打印一条问候语。

favorite_languages = {
‘jen’: ‘python’,
‘sarah’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}
friends = [‘phil’, ‘sarah’]
for name in favorite_languages.keys():
if name in friends:
print(" Hi " + name.title() +
", I see your favorite language is " +
favorite_languages[name].title() + “!”)

---

还可以使用keys() 确定某个人是否接受了调查。下面的代码确定Erin是否接受了调查：

favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }
if 'erin' not in favorite_languages.keys(): ##(1)
    print("Erin, please take our poll!")

方法keys() 并非只能用于遍历；实际上，它返回一个列表，其中包含字典中的所有键，因此(1)处的代码行只是核实’erin’ 是否包含在这个列表中。由于她并不包含在这个列
表中，因此打印一条消息，邀请她参加调查：输出
Erin, please take our poll!

按顺序遍历字典中的所有键sorted()

获取字典的元素时，获取顺序是不可预测的。要以特定的顺序返回元素，一种办法是在for 循环中对返回的键进行排序。可使用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()

返回一个值列表，而不包含任何键。

for language in favorite_languages.values():
    print(language.title())

这条for 语句提取字典中的每个值，并将它们依次存储到变量language 中。通过打印这些值，就获得了一个列表，其中包含被调查者选择的各种语言。

这种做法提取字典中所有的值，而没有考虑是否重复。
为剔除重复项，可使用集合（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())

这样结果会是一个不重复的列表，输出如下
The following languages have been mentioned:
Ruby
Python
C

5.4 嵌套

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

字典列表（列表中都是字典）

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 的列表中。
最后，遍历这个列表.
'''

{‘color’: ‘green’, ‘points’: 5}
{‘color’: ‘yellow’, ‘points’: 10}
{‘color’: ‘red’, ‘points’: 15}

示例：外星人不止3个，且都是使用代码自动生成（range）

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

# 创建30个绿色的外星人
#range() 返回一系列数字，其唯一的用途是告诉Python我们要重复这个循环多少次。
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("...")
# 显示创建了多少个外星人,打印列表的长度，以证明确实创建了30个外星人：
print("Total number of aliens: " + str(len(aliens)))

输出
{‘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, ‘speed’: ‘slow’}
…
Total number of aliens: 30

修改某些外星人的部分信息，可以这么做

for alien in aliens[0:3]:
    if alien['color'] == 'green':
        alien['color'] = 'yellow'
        alien['speed'] = 'medium'
        alien['points'] = 10

可以用之前学过的if-elif等结构自由按自己的设定进行修改。

在字典中存储列表

举个栗子，我们要描述顾客点的比萨，如果使用列表，只能存储要添加的比萨配料；但如果使用字典，就不仅可在其中包含配料列表，还可包含其他有关比萨的描述。

 # 存储所点比萨的信息
 # 在这个字典中，一个键是'crust' ，与之相关联的值是字符串'thick' ；
 #下一个键是'toppings'，与之相关联的值是一个列表，其中存储了顾客要求添加的所有配料。
pizza = {
      'crust': 'thick',
      'toppings': ['mushrooms', 'extra cheese'],
      }

# 准备描述所点的比萨
print("You ordered a " + pizza['crust'] + "-crust pizza " +
      "with the following toppings:")
# 为打印配料，我们编写了一个for 循环
for topping in pizza['toppings']:
    print("\t" + topping)

输出
You ordered a thick-crust pizza with the following toppings:
mushrooms
extra cheese

---

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

favorite_languages = {
    'jen': ['python', 'ruby'],
    'sarah': ['c'],
    'edward': ['ruby', 'go'],
    'phil': ['python', 'haskell'],
    }

在遍历字典的主循环中，使用一个for 循环来遍历每个人喜欢的语言列表

for key, values in favorite_languages.items():
   print( key.title() )
   for language in values:
       print("\t" + language.title())

为进一步改进这个程序，可在遍历字典的for 循环开头添加一条if 语句，通过查看len(values) 的值来确定当前的被调查者喜欢的语言是否有多种。

字典中嵌套字典

先上代码

users = {
    'aeinstein': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
        },
    'mcurie': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
        },
    }
#变量user_info 包含用户信息字典，而该字典包含三个键：'first' 、'last' 和'location' 
for username, user_info in users.items():  #遍历字典users 
    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())

这里定义了一个名为users 的字典，其中包含两个键：用户名’aeinstein’ 和’mcurie’ ；与每个键相关联的值都是一个字典，其中包含用户的名、姓和居住地。

遍历字典users 时，n依次将每个键存储在变量username 中，并依次将与当前键相关联的字典存储在变量user_info 中。
变量user_info 包含用户信息字典，而该字典包含三个键：‘first’ 、‘last’ 和’location’
【注意】每位用户的字典的结构可以不相同！！倘若表示每位用户的字典都包含不同的键，for 循环内部的代码将更复杂。

6. 用户输入input与while循环

用户输入input()

函数input() 让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便你使用。

如何处理文本和数字输入，
使用函数input() 时，Python将用户输入解读为字符串。
要想变成数值，应先转换。

>>> age = input("How old are you? ")
How old are you? 23
>>> age = int(age)
>>> age > 18
True

while 循环

多种控制while循环流程的方式：设置活动标志、使用break 语句以及使用continue 语句；
continue示例

current_number = 0
while current_number < 10:
    current_number += 1
    if current_number % 2 == 0:        
        continue
    
    print(current_number)

'''
if 语句检查current_number 与2的求模运算结果。如果结果为0（意味着current_number 可被2整除），就执行continue 语句，让Python忽略余下的代码，并返回
到循环的开头。
'''

输出
1
3
5
7
9
如何使用while 循环在列表之间移动元素，以及如何从列表中删除所有包含特定值的元素；

结合使用while 循环和字典。

创建一个调查程序，其中的循环每次执行时都提示输入被调查者的名字和回答。我们将收集的数据存储在一个字典中，以
便将回答同被调查者关联起来：
一段示例

responses = {}
 # 设置一个标志，指出调查是否继续
polling_active = True
while polling_active:
     # 提示输入被调查者的名字和回答
    name = input("\nWhat is your name? ")
    response = input("Which mountain would you like to climb someday? ")
    # 将答卷存储在字典中
    responses[name] = response
      # 看看是否还有人要参与调查
    repeat = input("Would you like to let another person respond? (yes/ no) ")
    if repeat == 'no':
          polling_active = False
  # 调查结束，显示结果
print("\n--- Poll Results ---")
for name, response in responses.items():
     print(name + " would like to climb " + response + ".")

输出
What is your name? lzj
Which mountain would you like to climb someday? huangshan
Would you like to let another person respond? (yes/ no) y

What is your name? linjie
Which mountain would you like to climb someday? huashan
Would you like to let another person respond? (yes/ no) n

What is your name? lzy
Which mountain would you like to climb someday? songshan
Would you like to let another person respond? (yes/ no) no

— Poll Results —
lzj would like to climb huangshan.
linjie would like to climb huashan.
lzy would like to climb songshan.
先定义了一个空字典（responses ），并设置了一个标志（polling_active ），用于指出调查是否继续。只要polling_active 为True ，Python就运行while 循环中的代码。

7.函数

传递参数

参数传递时除了一般的传递方法还有一个关键字实参的传递办法
关键字实参 是传递给函数的“名称—值”对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆。
此时无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。
举个栗子吧

def describe_pet(animal_type, pet_name):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster', pet_name='harry')

---

默认值
编写函数时，可给每个形参指定默认值，如果调用时没有给形参提供实参，Python将会使用默认值。

def describe_pet(pet_name, animal_type='dog'):
    """显示宠物的信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
    
describe_pet(pet_name='willie')
describe_pet('AMMY',animal_type='cat')

输出

I have a dog.
My dog’s name is Willie.

I have a cat.
My cat’s name is Ammy.

---

8. 类

继承

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()
    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
    def increment_odometer(self, miles):
        self.odometer_reading += miles
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

输出
2016 Tesla Model S

导入类

car.py

"""一个可用于表示汽车的类"""
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
    --snip---

my_car.py

from car import Car
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

import 语句让Python打开模块car ，并导入其中的Car 类。这样我们就可以使用Car 类了

要导入模块中的每个类，可使用下面的语法：
from module_name import *

参考资料

---

参考资料：
Python编程：从入门到实践
[美] Eric Matthes
译者：袁国忠

补充：一些函数

利用loc、iloc提取行数据
loc函数：通过行索引 “Index” 中的具体值来取行数据（如取"Index"为"A"的行）

iloc函数：通过行号来取行数据（如取第二行的数据）

import numpy as np
import pandas as pd
#创建一个Dataframe
data=pd.DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list('ABCD'))

```python
In[1]: data
Out[1]: 
    A   B   C   D
a   0   1   2   3
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15
 
#取索引为'a'的行
In[2]: data.loc['a']
Out[2]:
A    0
B    1
C    2
D    3
 
#取第一行数据，索引为'a'的行就是第一行，所以结果相同
In[3]: data.iloc[0]
Out[3]:
A    0
B    1
C    2
D    3