Python

变量

在程序中可随时修改变量的值，而Python将始终记录变量的最新值。

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

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

以上代码将输出：

Hello Python world!
Hello Python Crash Course world!

变量的命令

1. 变量名只能包含字母、数字和下划线。变量名能以字母或下划线打头，但不能以数字打头。
2. 变量名不能包含空格，但能使用下划线来分隔其中的单词。
3. 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
4. 变量名应既简短又具有描述性。
5. 变量名应既简短又具有描述性。
6. 要创建良好的变量名，需要经过一定的实践，在程序复杂而有趣时尤其如此。

字符串

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

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

方法title()以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。

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

可以用下面的放假将字符串全部转大写或小写：

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

# 输出内容如下
# ADA LOVELACE
# ada lovelace

在字符串中使用变量。

first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(full_name)

format() 方法

f字符串是Python 3.6引入的。如果你使用的是Python 3.5或更早的版本，需要使用format()方法，而非这种f语法。要使用方法format()，可在圆括号内列出要在字符串中使用的变量。对于每个变量，都通过一对花括号来引用。这样将按顺序将这些花括号替换为圆括号内列出的变量的值，如下所示：

要在字符串中添加制表符，可使用字符组合 \t。

>>>print("Python")
Python
>>>print("\tPython")
  Python

要在字符串中添加换行符，可使用字符组合\n：

>>>print("Languages:\nPython\nC\nJavaScript")
Languages:
Python
C
JavaScript

删除字符串右边的空白可以用 rstrip，删除左边的空白可以用 lstrip()，同时删除两边的空白可以用 strip()：

favorite_language = 'python '
favorite_language.rstrip()

数

整数

可对整数执行加（+）、减（-）、乘（*）、除（/）运算。

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

# 3^2 => 9
3 ** 2

# 10^6 = 1000000
10 ** 6

浮点数

Python 将所有带小数点的数称为浮点数。但需要注意的是，结果包含的小数位数可能是不确定的：

# 得到 0.30000000000000004
0.2 + 0.1

所有语言都存在这种问题，没有什么可担心的。

整数和浮点数

将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除：

# 得到 2.0
4 / 2

在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数。

无论是哪种运算，只要有操作数是浮点数，Python默认得到的总是浮点数，即便结果原本为整数也是如此。

数中的下划线

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读（Python 3.6开始支持）：

universe_age = 14_000_000_000

当你打印这种使用下划线定义的数时，Python不会打印其中的下划线：

print(universe_age)
# 得到 14000000000

同时给多个变量赋值

可在一行代码中给多个变量赋值，这有助于缩短程序并提高其可读性。这种做法最常用于将一系列数赋给一组变量。

常量

常量类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变。

注释

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

列表

在Python中，用方括号([])表示列表，并用逗号分隔其中的元素。如果让Python将列表打印出来，Python将打印列表的内部表示，包括方括号：[插图]

bicycles = ['trek','cannondale','redline','specialized']
# 输出：['trek','cannondale','redline','specialized']
print(bicycles)

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

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

这种约定也适用于其他负数索引。例如，索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素，依此类推。

bicycles = ['trek','cannondale','redline','specialized']
message = f"My first bicycle was a {bicycles[0].title()}."

# 输出内容为：My first bicycle was a Trek.
print(message)

要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

motorcycles = ['honda','yamaha','suzuki']

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

在列表中添加新元素时，最简单的方式是将元素附加(append)到列表。给列表附加元素时，它将添加到列表末尾。

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

motorcycles.append('ducati')

使用方法 insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。

motorcycles = ['honda','yamaha','suzuki']

motorcycles.insert(0,'ducati')

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

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

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

del motorcycles[0]
print(motorcycles)

方法pop()删除列表末尾的元素，并让你能够接着使用它。术语弹出(pop)源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

motorcycles = ['honda','yamaha','suzuki']

popped_motorcycle = motorcycles.pop()

# ['honda','yamaha']
print(motorcycles)

# suzuki
print(popped_motorcycle)

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

motorcycles = ['honda','yamaha','suzuki']

first_owned = motorcycles.pop(0)

# The first motorcycle I owned was a Honda.
print(f"The first motorcycle I owned was a {first_owned.title()}.")

如果你不确定该使用del语句还是pop()方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

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

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

motorcycles.remove('ducati')

Python方法sort()让你能够较为轻松地对列表进行排序（按字母顺序升序排列）。方法sort()永久性地修改列表元素的排列顺序。

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

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

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

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

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

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

注意，调用函数sorted()后，原始列表元素的排列顺序并没有变。如果要按与字母顺序相反的顺序显示列表，也可向函数sorted()传递参数reverse=True。

要反转列表元素的排列顺序，可使用方法reverse()。注意，reverse()不是按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序。方法reverse()永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，只需对列表再次调用reverse()即可。

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

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

# 4
len(cars)

索引错误的话会导致报错，比如下面这段代码：

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

会导致报错：

Traceback (most recent call last):
  File "motorcycles.py",line 2,in <module>
    print(motorcycles[3])
IndexError:list index out of range

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

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

Python函数range()让你能够轻松地生成一系列数。例如，可以像下面这样使用函数range()来打印一系列数：

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

上述代码会输出1~4，不会输出5：

1
2
3
4

调用函数range()时，也可只指定一个参数，这样它将从0开始。例如，range(6)返回数0～5。

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

numbers = list(range(1,6))

# [1,2,3,4,5]
print(numbers)

使用函数range()时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成数。

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

# [2,4,6,8,10]
print(even_numbers)

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

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

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

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

digits = [1,2,3,4,5,6,7,8,9,0]

# 0
min(digits)

# 9
max(digits)

# 45
sum(digits)

前面介绍的生成列表squares的方式包含三四行代码，而列表解析让你只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。

# 请注意，这里的for语句末尾没有冒号。
squares = [value**2 for value in range(1,11)]

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

除了处理整个列表，你还可以处理列表的部分元素，Python称之为切片。

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range()一样，Python在到达第二个索引之前的元素后停止。

players = ['charles','martina','michael','florence','eli']

# ['charles','martina','michael']
print(players[0:3])

如果没有指定第一个索引，Python将自动从列表开头开始：

players = ['charles','martina','michael','florence','eli']

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

要让切片终止于列表末尾，也可使用类似的语法。例如，如果要提取从第三个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引：

players = ['charles','martina','michael','florence','eli']

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

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

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

注意

注意：可在表示切片的方括号内指定第三个值。这个值告诉Python在指定范围内每隔多少元素提取一个。

遍历切片：

players = ['charles','martina','michael','florence','eli']

print("Here are the first three players on my team:")
for player in players[:3]:
    print(player.title())

打印内容如下：

Here are the first three players on my team:
Charles
Martina
Michael

要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引([:])。

元组

Python将不能修改的值称为不可变的，而不可变的列表被称为元组。元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样。

注意：严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号：

my_t = (3,)

遍历元组中的所有值：

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

相比于列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，就可以使用元组。

if

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

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

要检查是否两个条件都为True，可使用关键字and将两个条件测试合而为一。

关键字or也能够让你检查多个条件，但只要至少一个条件满足，就能通过整个测试。仅当两个测试都没有通过时，使用or的表达式才为False。

要判断特定的值是否已包含在列表中，可使用关键字in。

requested_toppings = ['mushrooms','onions','pineapple']

# True
'mushrooms'in requested_toppings

# False
'pepperoni'in requested_toppings

还有些时候，确定特定的值未包含在列表中很重要。在这种情况下，可使用关键字not in。

banned_users = ['andrew','carolina','david']
user = 'marie'

if user not in banned_users:
    print(f"{user.title()},you can post a response if you wish.")

布尔表达式：

game_active = True
can_edit = False

最简单的if语句只有一个测试和一个操作：

if conditional_test:
    do something

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

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(f"Adding {requested_topping}.")

print("\nFinished making your pizza!")

if-elif-else结构：

age = 12

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

age = 12

if age <4:
    price = 0
elif age <18:
    price = 25
elif age <65:
    price = 40
else:
    price = 20

print(f"Your admission cost is ${price}.")

else 代码块是可以省略的：

age = 12

if age <4:
    price = 0
elif age <18:
    price = 25
elif age <65:
    price = 40
elif age >= 65:
    price = 20

print(f"Your admission cost is ${price}.")

在if语句中将列表名用作条件表达式时，Python将在列表至少包含一个元素时返回True，并在列表为空时返回False（这点和JavaScript中的空数组的布尔值判断逻辑不一样）。

遍历键值对：

user = {
    'username': 'efermi',
}
for key,value in user.items():
    print(f"\nkey: {key}")
    print(f"Value: {value}")

遍历键：

# .keys() 是可以省略的，默认就是遍历所有键
for name in fvorite_languages.keys():
    print(name.title())

遍历值：

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

# 对值进行去重后再遍历
for language in set(favorate_languages.values):
    print(language.title())

字典

在Python中，字典是一系列键值对。每个键都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。

在Python 3.7中，字典中元素的排列顺序与定义时相同。如果将字典打印出来或遍历其元素，将发现元素的排列顺序与添加顺序相同。

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

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

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

del alien_0['points']
print(alien_0)

使用放在方括号内的键从字典中获取感兴趣的值时，可能会引发问题：如果指定的键不存在就会出错。就字典而言，可使用方法get()在指定的键不存在时返回一个默认值，从而避免这样的错误。方法get()的第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值，是可选的。

alien_0 = {'color':'green','speed':'slow'}

point_value = alien_0.get('points','No point value assigned.')
print(point_value)

遍历所有键值对：

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

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

遍历字典中的所有键：

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

for name in favorite_languages.keys():
    print(name.title())

遍历字典时，会默认遍历所有的键。即 for name in favorite_languages: 等价于 for name in favorite_languages.keys():。显式地使用方法keys()可让代码更容易理解，你可以选择这样做，但是也可以省略它。

要以特定顺序返回元素，一种办法是在for循环中对返回的键进行排序。为此，可使用函数sorted()来获得按特定顺序排列的键列表的副本：

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

for name in sorted(favorite_languages.keys()):
    print(f"{name.title()},thank you for taking the poll.")

遍历字典中的所有值：

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

print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())

通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。

favorite_languages = {
    --snip--
}

print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

可使用一对花括号直接创建集合，并在其中用逗号分隔元素：

languages = {'python','ruby','python','c'}

# {'ruby','python','c'}
languages

用户输入和while循环

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

message = input("Tell me something,and I will repeat it back to you:")
print(message)

函数input()接受一个参数——要向用户显示的提示(prompt)或说明，让用户知道该如何做。在本例中，Python运行第一行代码时，用户将看到提示Tell me something,and I will repeat it back to you:。程序等待用户输入，并在用户按回车键后继续运行。输入被赋给变量message，接下来的print(message)将输入呈现给用户。

函数int()将数的字符串表示转换为数值表示，如下所示：

age = input("How old are you?")
# How old are you?21

age = int(age)

# True
age >= 18

prompt = "\nTell me something,and I will repeat it back to you:"
prompt += "\nEnter 'quit'to end the program."
message = ""
while message != 'quit':
    message = input(prompt)
    print(message)

删除为特定值的所有列表元素：

pets = ['dog','cat','dog','goldfish','cat','rabbit','cat']
print(pets)

while 'cat'in pets:
    pets.remove('cat')

print(pets)

函数

有时候，预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。例如，来看一个制作比萨的函数，它需要接受很多配料，但无法预先确定顾客要多少种配料。下面的函数只有一个形参*toppings，但不管调用语句提供了多少实参，这个形参会将它们统统收入囊中：

def make_pizza(*toppings):
    """打印顾客点的所有配料。"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。函数体内的函数调用print()通过生成输出，证明Python能够处理使用一个值来调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用。注意，Python将实参封装到一个元组中，即便函数只收到一个值：

('pepperoni',)
('mushrooms','green peppers','extra cheese')

如果要遍历其中的具体元素：

def make_pizza(*toppings):
    """概述要制作的比萨。"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

结合使用位置实参和任意数量实参：

def make_pizza(size,*toppings):
    """概述要制作的比萨。"""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')

*args

你经常会看到通用形参名*args，它也收集任意数量的位置实参。

使用任意数量的关键字实参：

def build_profile(first,last,**user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切。"""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile('albert','einstein',
                             location='princeton',
                             field='physics')
print(user_profile)

上例得到内容如下：

{'location':'princeton','field':'physics',
 'first_name':'albert','last_name':'einstein'}

**kwargs

注意　你经常会看到形参名**kwargs，它用于收集任意数量的关键字实参。

import语句允许在当前运行的程序文件中使用模块中的代码。

假定现在有文件 pizza.py：

def make_pizza(size,*toppings):
    """概述要制作的比萨。"""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

导入整个模块（只需编写一条import语句并在其中指定模块名，就可在程序中使用该模块中的所有函数）：

import pizza

pizza.make_pizza(16,'pepperoni')
pizza.make_pizza(12,'mushrooms','green peppers','extra cheese')

还可以导入模块中的特定函数，这种导入方法的语法如下：

from module_name import function_name

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

from module_name import function_0,function_1,function_2

使用 as 给函数指定别名：

from pizza import make_pizza as mp

mp(16,'pepperoni')
mp(12,'mushrooms','green peppers','extra cheese')

使用as给模块指定别名：

import pizza as p

p.make_pizza(16,'pepperoni')
p.make_pizza(12,'mushrooms','green peppers','extra cheese')

使用星号(*)运算符可让Python导入模块中的所有函数：

from pizza import *

make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')

给形参指定默认值时，等号两边不要有空格：

def function_name(parameter_0,parameter_1='default value')

对于函数调用中的关键字实参，也应遵循这种约定：

function_name(value_0,parameter_1='value')