《Python编程:从入门到实践》 笔记 (一) – 基础知识

一、变量和简单数据类型

本章学习了:如何使用变量;如何创建描述性变量名以及如何消除名称错误和语法错误;字符串是什么,以及如何使用小写、大写和首字母大写方式显示字符串;使用空白来显示整洁的输出,以及如何剔除字符串中多余的空白;如何使用整数和浮点数;使用数值数据时需要注意的意外行为。还学习了如何编写说明性注释,让代码人来说更容易理解

1.1 变量

每个变量都存储了一个 值 —— 与变量相关联的信息

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

1.1.1 变量的命名和使用

  • 变量名只能包含字母(最好用小写字母)、数字和下划线。变量名可以字母或下划线打头,但不能以数字打头,例如,可将变量命名为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。

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

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

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

>>> name = "ada lovelace"
>>> print(name.title())
Ada Lovelace

1.2.2 合并(拼接)字符串

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

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

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

空白泛指任何非打印字符,如空格、制表符和换行符。你可使用空白来组织输出,以使其更易读。

# 在同一个字符串中同时包含制表符和换行符。字符串 "\n\t" 让 Python 换到下一行,并在下一行开头添加一个制表符
>>> print("Languages:\n\tPython\n\tC\n\tJavaScript")
Languages:
    Python
    C
    JavaScript

1.2.4 删除空白

  • 存储在变量 favorite_language 中的字符串末尾包含多余的空白。你在终端会话中向 Python 询问这个变量的值时,可看到末尾的空格。对变量 favorite_language 调用方法 rstrip() 后,这个多余的空格被删除了。然而,这种删除只是暂时的,接下来再次询问 favorite_language 的值时,你会发现这个字符串与输入时一样,依然包含多余的空白。

  • 要永久删除这个字符串中的空白,必须将删除操作的结果存回到变量中

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

1.2.5 Python 2 中的 print 语句

在 Python 2 中,无需将要打印的内容放在括号内。从技术上说, Python 3 中的 print 是一个函数,因此括号必不可少。有些 Python 2 print 语句也包含括号,但其行为与 Python 3 中稍有不同。简单地说,在 Python 2 代码中,有些 print 语句包含括号,有些不包含。

1.3 数字

在编程中,经常使用数字来记录游戏得分、表示可视化数据、存储 Web 应用信息等。 Python 根据数字的用法以不同的方式处理它们。鉴于整数使用起来最简单,下面就先来看看 Python 是如何管理它们的。

1.3.1 整数

  • 在 Python 中,可对整数执行加( + )减( – )乘( * )除( / )乘方(**)运算
  • 空格不影响 Python 计算表达式的方式,它们的存在旨在让你阅读代码时,能迅速确定先执行哪些运算。
  • 在 Python 2 中,整数除法的结果只包含整数部分,小数部分被删除。请注意,计算整数结果时,采取的方式不是四舍五入,而是将小数部分直接删除。
>>> 2 + 3
5
>>> 3 - 2
1
>>> 3 ** 2
9
>>> 2 + 3*4
14

1.3.2 浮点数

Python 将带小数点的数字都称为浮点数。从很大程度上说,使用浮点数时都无需考虑其行为。你只需输入要使用的数字, Python 通常都会按你期望的方式处理它们

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

需要注意的是,结果包含的小数位数可能是不确定的。所有语言都存在这种问题,没有什么可担心的。 Python 会尽力找到一种方式,以尽可能精确地表示结果,但鉴于计算机内部表示数字的方式,这在有些情况下很难。就现在而言,暂时忽略多余的小数位数即可

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

函数 str() ,将非字符串值表示为字符串

1.3.4 浮点数

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

1.4 注释

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

#  向大家问好
print("Hello Python people!")

二、列表简介

本章学习了:列表是什么以及如何使用其中的元素;如何定义列表以及如何增删元素;如何对列表进行永久性排序,以及如何为展示列表而进行临时排序;如何确定列表的长度,以及在使用列表时如何避免索引错误。

2.1 列表是什么

列表:由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字 0~9 或所有家庭成员姓名的列表;也可以将任何东西加入列表中,其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素,给列表指定一个表示复数的名称(如 letters 、 digits 或 names )是个不错的主意。

在 Python 中,用方括号( [] )来表示列表,并用逗号来分隔其中的元素。下面是一个简单的列表示例,这个列表包含几种自行车:

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

# 访问列表元素
>>> print(bicycles[0])
trek
>>> print(bicycles[0].title())
Trek

# 索引从 0 而不是 1 开始
>>> print(bicycles[1])
cannondale
>>> print(bicycles[3])
specialized

# 将索引指定为 -1 ,可让 Python 返回最后一个列表元素
>>> print(bicycles[-1])
specialized

# 使用列表中的各个值
>>> message = "My first bicycle was a " + bicycles[0].title() + "."
>>> print(message)
My first bicycle was a Trek.

2.2 修改、添加和删除元素

大多数列表都将是动态的,这意味着列表创建后,将随着程序的运行增删元素

# 修改列表元素
>>> motorcycles = ['honda', 'yamaha', 'suzuki']
>>> print(motorcycles)
['honda', 'yamaha', 'suzuki']
>>> motorcycles[0] = 'ducati'
>>> print(motorcycles)
['ducati', 'yamaha', 'suzuki']

# 在列表中添加元素
>>> motorcycles.append('ducati')
>>> print(motorcycles)
['ducati', 'yamaha', 'suzuki', 'ducati']

# 在列表中插入元素

# 使用 del 语句删除元素,使用 del 可删除任何位置处的列表元素,条件是知道其索引
>>> del motorcycles[0]
>>> print (motorcycles)
['yamaha', 'suzuki']

#  使用方法 pop() 删除元素,默认删除列表末尾的元素,并让你能够接着使用它,可指定位置
>>> motorcycles = ['honda', 'yamaha', 'suzuki']
>>> popped_motorcycle=motorcycles.pop()
>>> print(motorcycles)
['honda', 'yamaha']
>>> print (popped_motorcycle)
suzuki
>>> first_owned = motorcycles.pop(0)
>>> print(first_owned)
honda

# 根据值删除元素
>>> motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
>>> motorcycles.remove(honda)
>>> motorcycles.remove('honda')
>>> print(motorcycles)
['yamaha', 'suzuki', 'ducati']

2.3 组织列表

# 方法 sort() 对列表进行永久性排序
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> cars.sort()
>>> print(cars)
['audi', 'bmw', 'subaru', 'toyota']

# 函数 sorted()  对列表进行临时排序
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> print(sorted(cars))
['audi', 'bmw', 'subaru', 'toyota']
>>> print(cars)
['bmw', 'audi', 'toyota', 'subaru']
# 向函数 sorted() 传递参数 reverse=True,与字母顺序相反的顺序显示列表
>>> print(sorted(cars, reverse=True))
['toyota', 'subaru', 'bmw', 'audi']

# 方法 reverse(),倒着打印列表,永久性地修改列表元素的排列顺序
# 注意, reverse() 不是指按与字母顺序相反的顺序排列列表元素,而只是反转列表元素的排列顺序
>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> cars.reverse()
>>> print(cars)
['subaru', 'toyota', 'audi', 'bmw']

# 函数 len(),确定列表的长度
>>> len(cars)
4

三、操作列表

3.1 遍历整个列表

需要对列表中的每个元素都执行相同的操作时,可使用 Python 中的 for 循环

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

I can't wait to see your next trick, David.

I can't wait to see your next trick, Carolina.

3.2 避免缩进错误

  • for 语句末尾的冒号告诉 Python ,下一行是循环的第一行
  • 对于位于 for 语句后面且属于循环组成部分的代码行,一定要缩进。如果你忘记缩进, Python 会提醒你:
>>> for magician in magicians:
... print(magician)
  File "<stdin>", line 2
    print(magician)
        ^
IndentationError: expected an indented block

3.3 创建数值列表

Python 函数 range() 让你能够轻松地生成一系列的数字

>>> for value in range(1,5):
...   print(value)
...
1
2
3
4

# 可使用函数 list() 将 range() 的结果直接转换为列表
>>> numbers = list(range(1,6))
>>> print(numbers)
[1, 2, 3, 4, 5]

# 可指定步长。例如,下面的代码打印 1~10 内的偶数
>>> even_numbers = list(range(2,11,2))
>>> print(even_numbers)
[2, 4, 6, 8, 10]

# 创建一个列表,其中包含前 10 个整数(即 1~10 )的平方
squares = []
for value in range(1,11):
  square = value**2
  squares.append(square)

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

# 有几个专门用于处理数字列表的 Python 函数
>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

3.4 使用列表的一部分

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

# 没有指定索引, Python 将自动从列表开头开始,或结尾结束
>>> print(players[:4])
['charles', 'martina', 'michael', 'florence']
>>> print(players[2:])
['michael', 'florence', 'eli']
# 输出名单上的最后三名队员
>>> print(players[-3:])
['michael', 'florence', 'eli']


# 遍历切片
# cat players.py

#!/usr/bin/env
players = ['charles', 'martina', 'michael', 'florence', 'eli']

print("Here are the first three players on my team:")

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

# python3 players.py
Here are the first three players on my team:
Charles
Martina
Michael

# 复制列表
>>> my_foods = ['pizza', 'falafel', 'carrot cake']
>>> friend_foods = my_foods[:]
>>> print(my_foods)
['pizza', 'falafel', 'carrot cake']
>>> print(friend_foods)
['pizza', 'falafel', 'carrot cake']

3.5 元组

Python 将不能修改的值称为不可变的,而不可变的列表被称为 元组

# 元组看起来犹如列表,但使用圆括号而不是方括号来标识。
>>> dimensions = (200, 50)
>>> print(dimensions[0])
200
>>> print(dimensions[1])
50
# 无法修改
>>> dimensions[0] = 250
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment


# 遍历元组中的所有值
>>> for dimension in dimensions:
...   print(dimension)
...
200
50

3.6 设置代码格式

Python 程序员都遵循一些格式设置约定。学会编写整洁的 Python 后,就能明白他人编写的 Python 代码的整体结构 —— 只要他们和你遵循相同的指南。要成为专业程序员,应从现在开始就遵循这些指南,以养成良好的习惯

  • 格式设置指南
    若要提出 Python 语言修改建议,需要编写 Python 改进提案 ( Python Enhancement Proposal , PEP )。 PEP 8 是最古老的 PEP 之一,它向 Python 程序员提供了代码格式设置指南。 PEP 8 的篇幅很长,但大都与复杂的编码结构相关。
  • 缩进
    PEP 8 建议每级缩进都使用四个空格,这既可提高可读性,又留下了足够的多级缩进空间。
    大家常常使用制表符而不是空格来缩进。对于字处理文档来说,这样做的效果很好,但混合使用制表符和空格会让 Python 解释器感到迷惑。
  • 行长
    很多 Python 程序员都建议每行不超过 80 字符。PEP 8 还建议注释的行长都不超过 72 字符,因为有些工具为大型项目自动生成文档时,会在每行注释开头添加格式化字符
  • 空行
    要将程序的不同部分分开,可使用空行。你应该使用空行来组织程序文件,但也不能滥用;只要按本书的示例展示的那样做,就能掌握其中的平衡。例如,如果你有 5 行创建列表的代码,还有 3 行处理该列表的代码,那么用一个空行将这两部分隔开是合适的。然而,你不应使用三四个空行将它们隔开
  • 其他格式设置指南
    PEP 8:请访问 https://python.org/dev/peps/pep-0008/

四、if 语句

4.1 条件测试

每条 if 语句的核心都是一个值为 True 或 False 的表达式,这种表达式被称为条件测试

# 检查是否相等 ==
>>> car = 'bmw'
>>> car == 'bmw'
True
>>> car == 'audi'
False
# 在 Python 中检查是否相等时区分大小写
>>> car == 'bmW'
False
# 函数 lower() 转换为小写,upper() 大写,不会修改存储在变量 car 中的值
>>> car = 'Audi'
>>> car.lower() == 'audi'
True
>>> car.upper() == 'AUDI'
True


# 检查是否不相等 !=
>>> requested_topping = 'mushrooms'
>>> if requested_topping != 'anchovies':
...   print("Hold the anchovies!")
...
Hold the anchovies!


# 比较数字
>>> age = 19
>>> age == 19
True
>>> age < 21
True
>>> age >= 21
False


# 检查多个条件
# 使用 and 检查多个条件
>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 21 and age_1 >= 21
False
>>> age_0 >= 21 and age_1 <= 21
True

# 使用 or 检查多个条件
>>> age_0 = 22
>>> age_1 = 18
>>> age_0 >= 23 or age_1 >= 21
False


# 检查特定值是否包含在列表中
>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False
# 检查特定值是否不包含在列表中
>>> 'pepperoni' not in requested_toppings
True

4.2 if 语句

# 简单的 if  语句
if conditional_test:
    do something

# if-else  语句
>>> age = 17
>>> if age >= 18:
...   print("You are old enough to vote!")
... else:
...   print("Sorry, you are too young to vote.")
... 
Sorry, you are too young to vote.

# if-elif-else  结构
>>> if condition_1:
...     statement_block_1
... elif condition_2:
...     statement_block_2
... else:
...     statement_block_3

# Python 并不要求 if-elif 结构后面必须有 else 代码块
>>> age = 12
>>> if age < 4:
...     price = 0
... elif age < 18:
...     price = 5
... elif age < 60:
...     price = 10
... elif age >= 65:
...     price = 5
... 
>>> print("Your admission cost is " + str(price) + ".")
Your admission cost is5.

4.3 使用 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?")


# 使用多个列表
# cat toppings.py
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!")

# python3 toppings.py
Adding mushrooms.
Sorry, we don't have french fries.
Adding extra cheese.

Finished making your pizza!


五、字典

本章学习了:如何定义字典,以及如何使用存储在字典中的信息;如何访问和修改字典中的元素,以及如何遍历字典中的所有信息;如何遍历字典中所有的键 – 值对、所有的键和所有的值;如何在列表中嵌套字典、在字典中嵌套列表以及在字典中嵌套字典

5.1 使用字典

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

# 定义字典
>>> alien_0 = {'color': 'green', 'points': 5}

# 访问字典中的值
>>> print(alien_0['color'])
green
>>> print(alien_0['points'])
5

# 添加键 — 值对
>>> alien_0['x_position'] = 0
>>> alien_0['y_position'] = 25
>>> print(alien_0)
{'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'] = 'yellow'
>>> print(alien_0)
{'color': 'yellow', 'points': 5}

# 删除键 — 值对
del alien_0['points']

# 由类似对象组成的字典
favorite_languages = {
    'jen': 'python',
    'sarah': 'c',
    'edward': 'ruby',
    'phil': 'python',
    }

5.2 遍历字典

# 遍历所有的键 — 值对
>>> 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

# 遍历字典中的所有键
>>> favorite_languages = {
... 'jen': 'python',
... 'sarah': 'c',
... 'edward': 'ruby',
... 'phil': 'python',
... }
>>> for name in favorite_languages.keys():
...     print(name.title())
... 
Jen
Sarah
Edward
Phil

# 可使用函数 sorted() 来获得按特定顺序排列的键列表
>>> 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() ,它返回一个值列表,而不包含任何键。
>>> for language in favorite_languages.values():
...     print(language.title())
...
Python
C
Ruby
Python

5.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)
... 
{'color': 'green', 'points': 5}
{'color': 'yellow', 'points': 10}
{'color': 'red', 'points': 15}

# 在字典中存储列表
>>> 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())
... 

Jen's favorite languages are:
    Python
    Ruby

Sarah's favorite languages are:
    C

Edward's favorite languages are:
    Ruby
    Go

Phil's favorite languages are:
    Python
    Haskell

# 在字典中存储字典
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())
...

Username: aeinstein
    Full name: Albert Einstein
    Location: Princeton

Username: mcurie
    Full name: Marie Curie
    Location: Paris

六、用户输入和 while 循环

本章学习了:如何在程序中使用 input() 来让用户提供信息;如何处理文本和数字输入,以及如何使用 while 循环让程序按用户的要求不断地运行;多种控制 while 循环流程的方式:设置活动标志、使用 break 语句以及使用 continue 语句;如何使用 while 循环在列表之间移动元素,以及如何从列表中删除所有包含特定值的元素;如何结合使用 while 循环和字典。

6.1 函数 input()

# 提示用户输入信息
>>> name = input("Please enter your name: ")
Please enter your name: kk
>>> print("Hello, " + name + "!")
Hello, kk!

# 使用函数input() 时,Python将用户输入解读为字符串
# 使用 int() 来获取数值输入
>>> height = input("How tall are you, in inches? ")
How tall are you, in inches? 22
>>> height = int(height)
>>> if height >= 18:
...     print("\nYou're tall enough to ride!")
... else:
...     print("\nYou'll be able to ride when you're a little older.")
...

You're tall enough to ride!

6.2 while 循环简介

# 使用 while  循环
>>> current_number = 1
>>> while current_number <= 5:
...     print(current_number)
...     current_number += 1
... 
1
2
3
4
5

# 让用户选择何时退出
>>> 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)
... 
Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. 2
2

Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. quit
quit
>>>

# 使用标志
>>> while active:
...     message = input(prompt)
...     if message == 'quit':
...         active = False
...     else:
...         print(message)
... 

Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. 1
1

Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. quit
>>>

# 使用 break  退出循环
>>> prompt = "\nPlease enter the name of a city you have visited:"
>>> prompt += "\n(Enter 'quit' when you are finished.) "
>>>  
... while True:
...     city = input(prompt)
...     if city == 'quit':
...         break
...     else:
...         print("I'd love to go to " + city.title() + "!")
... 

Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) Shanghai
I'd love to go to Shanghai!

Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) quit

# 使用 continue
>>> current_number = 0
>>>
... while current_number < 10:
...     current_number += 1
...     if current_number % 2 == 0:
...         continue
...     print(current_number)
... 
1
3
5
7
9

# 每个 while 循环都必须有停止运行的途径,这样才不会没完没了地执行下去

6.3 while 循环来处理列表和字典

for 循环是一种遍历列表的有效方式,但在 for 循环中不应修改列表,否则将导致 Python 难以跟踪其中的元素。要在遍历列表的同时对其进行修改,可使用 while 循环。

# 在列表之间移动元素
# cat confirmed_users.py

# 首先,创建一个待验证用户列表
# 和一个用于存储已验证用户的空列表
unconfirmed_users = ['alice', 'brian', 'candace']
confirmed_users = []

# 验证每个用户,直到没有未验证用户为止
# 将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
    current_user = unconfirmed_users.pop()
    print("Verifying user: " + current_user.title())
    confirmed_users.append(current_user)

# 显示所有已验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
    print(confirmed_user.title())

# python3 confirmed_users.py

Verifying user: Candace
Verifying user: Brian
Verifying user: Alice

The following users have been confirmed:
Candace
Brian
Alice


# 删除包含特定值的所有列表元素
>>> pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
>>> while 'cat' in pets:
...     pets.remove('cat')
... 
>>> print(pets)
['dog', 'dog', 'goldfish', 'rabbit']

# 使用用户输入来填充字典
root@VM-0-6-ubuntu:~# cat mountain_poll.py 
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 + ".")

七、函数

本章学习了:如何编写函数,以及如何传递实参,让函数能够访问完成其工作所需的信息;如何使用位置实参和关键字实参,以及如何接受任意数量的实参;显示输出的函数和返回值的函数;如何将函数同列表、字典、 if 语句和 while 循环结合起来使用。你还知道了如何将函数存储在被称为模块的独立文件中,让程序文件更简单、更易于理解

7.1 定义函数

# 定义打印问候语的简单函数,名为 greet_user()
>>> def greet_user():
...     """ 显示简单的问候语 """
...     print("Hello!")
... 
>>> greet_user()
Hello!

# 向函数传递信息
>>> def greet_user(username):
...     print("Hello, " + username.title() + "!")
...
>>> greet_user('jesse')
Hello, Jesse!

# 实参和形参
在函数 greet_user() 的定义中,变量 username 是一个形参。在代码 greet_user('jesse') 中,值 'jesse' 是一个实参 。实参是调用函数时传递给函数的信息。我们调用函数时,将要让函数使用的信息放在括号内。在 greet_user('jesse') 中,将实参 'jesse' 传递给了函数 greet_user() ,这个值被存储在形参 username 中。

7.2 传递实参

# 位置实参
>>> 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('hamster', 'harry')

I have a hamster.
My hamster's name is Harry.
>>> describe_pet('dog', 'willie')

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

# 关键字实参
# 是传递给函数的名称 — 值对。你直接在实参中将名称和值关联起来了,因此向函数传递实参时不会混淆
>>> describe_pet(animal_type='hamster', pet_name='harry')

I have a hamster.
My hamster's name is Harry.

# 默认值
>>> 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')

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

7.3 返回值

# 返回简单值
>>> def get_formatted_name(first_name, last_name):
...     """返回整洁的姓名"""
...     full_name = first_name + ' ' + last_name
...     return full_name.title()
... 
>>> musician = get_formatted_name('jimi', 'hendrix')
>>> print(musician)
Jimi Hendrix

# 让实参变成可选的
>>> def get_formatted_name(first_name, last_name, middle_name=''):
...     """ 返回整洁的姓名 """
...     if middle_name:
...         full_name = first_name + ' ' + middle_name + ' ' + last_name
...     else:
...         full_name = first_name + ' ' + last_name
...     return full_name.title()
...
>>> musician = get_formatted_name('jimi', 'hendrix')
>>> print(musician)
Jimi Hendrix

# 返回字典
>>> def build_person(first_name, last_name):
...     """返回一个字典,其中包含有关一个人的信息"""
...     person = {'first': first_name, 'last': last_name}
...     return person
... 
>>> musician = build_person('jimi', 'hendrix')
>>> print(musician)
{'first': 'jimi', 'last': 'hendrix'}

# 结合使用函数和 while  循环
def get_formatted_name(first_name, last_name):
    """ 返回整洁的姓名 """
    full_name = first_name + ' ' + last_name
    return full_name.title()
while True:
    print("\nPlease tell me your name:")
    print("(enter 'q' at any time to quit)")

    f_name = input("First name: ")
    if f_name == 'q':
    break

    l_name = input("Last name: ")
    if l_name == 'q':
    break

    formatted_name = get_formatted_name(f_name, l_name)
    print("\nHello, " + formatted_name + "!")

7.4 传递列表

# 在函数中修改列表
# cat printing_models.py
def print_models(unprinted_designs, completed_models):
    """
    模拟打印每个设计,直到没有未打印的设计为止
    打印每个设计后,都将其移到列表completed_models中
    """
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        # 模拟根据设计制作3D打印模型的过程
        print("Printing model: " + current_design)
        completed_models.append(current_design)

def show_completed_models(completed_models):
    """显示打印好的所有模型"""
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

#函数调用
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

# python3  printing_models.py
Printing model: dodecahedron
Printing model: robot pendant
Printing model: iphone case

The following models have been printed:
dodecahedron
robot pendant
iphone case

# 禁止函数修改列表
# 切片表示法 [:] 创建列表的副本。在 print_models.py 中,如果不想清空未打印的设计列表,可像下面这样调用 print_models()
print_models(unprinted_designs[:], completed_models)

7.5 传递任意数量的实参

# 传递任意数量的实参
>>> def make_pizza(*toppings):
...     """概述要制作的比萨"""
...     print("\nMaking a pizza with the following toppings:")
...     for topping in toppings:
...         print("- " + topping)
... 
>>> make_pizza('pepperoni')

Making a pizza with the following toppings:
- pepperoni
>>> make_pizza('mushrooms', 'green peppers', 'extra cheese')

Making a pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

# 结合使用位置实参和任意数量实参
# 如果要让函数接受不同类型的实参,必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参,再将余下的实参都收集到最后一个形参中。
def make_pizza(size, *toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) +
        "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

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

# 使用任意数量的关键字实参
# 有时候,需要接受任意数量的实参,但预先不知道传递给函数的会是什么样的信息。在这种情况下,可将函数编写成**能够接受任意数量的 键-值对** ——调用语句提供了多少就接受多少。
>>> def build_profile(first, last, **user_info):
...     """创建一个字典,其中包含我们知道的有关用户的一切"""
...     profile = {}
...     profile['first_name'] = first
...     profile['last_name'] = last
...     for key, value in user_info.items():
...         profile[key] = value
...     return profile
... 
>>> user_profile = build_profile('albert', 'einstein',
...                               location='princeton',
...                               field='physics')
>>> print(user_profile)
{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

7.6 将函数存储在模块中

函数的优点之一是,使用它们可将代码块与主程序分离。通过给函数指定描述性名称,可让主程序容易理解得多。你还可以更进一步,将函数存储在被称为 模块 的独立文件中,再将模块 导入 到主程序中。 import 语句允许在当前运行的程序文件中使用模块中的代码。

cat pizza.py
def make_pizza(size, *toppings):
    """ 概述要制作的比萨 """
    print("\nMaking a " + str(size) + "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

# 导入整个模块
# pizza.py 所在的目录中创建另一个名为 making_pizzas.py 的文件,这个文件导入刚创建的模块,再调用 make_pizza() 两次
import pizza

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

# 导入特定的函数
# 通过用逗号分隔函数名,可根据需要从模块中导入任意数量的函数
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')

# 导入模块中的所有函数
from pizza import *
# import 语句中的星号让 Python 将模块 pizza 中的每个函数都复制到这个程序文件中。由于导入了每个函数,可通过名称来调用每个函数,而无需使用句点表示法。然而,使用并非自己编写的大型模块时,最好不要采用这种导入方法:如果模块中有函数的名称与你的项目中使用的名称相同,可能导致意想不到的结果: Python 可能遇到多个名称相同的函数或变量,进而覆盖函数,而不是分别导入所有的函数。
# 最佳的做法是,要么只导入你需要使用的函数,要么导入整个模块并使用句点表示法。这能让代码更清晰,更容易阅读和理解。这里之所以介绍这种导入方法,只是想让你在阅读别人编写的代码时,如果遇到类似于下面的 import 语句,能够理解它们:
from module_name import *

八、类

8.1 创建和使用类

  • 根据约定,在Python中,首字母大写的名称指的是类。
  • 类中的函数称为方法:你前面学到的有关函数的一切都适用于方法,就目前而言,唯一重要的差别是调用方法的方式。
  • 方法init():这是一个特殊的方法,每当你根据Dog 类创建新实例时,Python都会自动运行它。在这个方法的名称中,开头和末尾各有两个下划线,这是一种约定,旨在避免Python默认方法与普通方法发生名称冲突。
    • 我们将方法init() 定义成了包含三个形参:self 、name 和age 。
    • 在这个方法的定义中,形参self 必不可少,还必须位于其他形参的前面。为何必须在方法定义中包含形参self 呢?因为Python调用这个init() 方法来创建Dog 实例时,将自动传入实参self 。
    • 每个与类相关联的方法调用都自动传递实参self ,它是一个指向实例本身的引用,让实例能够访问类中的属性和方法。
  • 我们创建Dog 实例时,Python将调用Dog 类的方法init() 。我们将通过实参向Dog() 传递名字和年龄;self 会自动传递,因此我们不需要传递它。每当我们根据Dog 类创建实例时,都只需给最后两个形参(name 和age )提供值。
  • Dog 类还定义了另外两个方法:sit() 和roll_over() 。由于这些方法不需要额外的信息,如名字或年龄,因此它们只有一个形参self。
# 创建 Dog  类
# cat dog.py
class Dog():
    """一次模拟小狗的简单尝试"""

    def __init__(self, name, age):
        """初始化属性name和age"""
        self.name = name
        self.age = age

    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")

    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + " rolled over!")

# 根据类创建实例
# python3 111.py 
My dog's name is Willie.
My dog is 6 years old.

8.2 使用类和实例

  • 类中的每个属性都必须有初始值,哪怕这个值是0或空字符串。
  • 在有些情况下,如设置默认值时,在方法init() 内指定这种初始值是可行的;如果你对某个属性这样做了,就无需包含为它提供初始值的形参。
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.")

#使用类
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

8.3 继承

  • 一个类继承 另一个类时,它将自动获得另一个类的所有属性和方法;原有的类称为父类 ,而新类称为子类 。
  • 子类继承了其父类的所有属性和方法,同时还可以定义自己的属性和方法。
  • 创建子类时,父类必须包含在当前文件中,且位于子类前面。
  • super() 是一个特殊函数,帮助Python将父类和子类关联起来。通过super调用父类中的属性和方法。
  • 让一个类继承另一个类后,可添加区分子类和父类所需的新属性和方法。
  • 对于父类的方法,只要它不符合子类模拟的实物的行为,都可对其进行重写。为此,可在子类中定义一个这样的方法,即它与要重写的父类方法同名。这样,Python将不会考虑这个父类方法,而只关注你在子类中定义的相应方法。
  • 我们还可以将另一个类的实例用作类的属性。
# 电动汽车是一种特殊的汽车,因此我们可以在前面创建的Car 类的基础上创建新类ElectricCar ,这样我们就只需为电动汽车特有的属性和行为编写代码。
#父类:Car
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

#另一个类:Battery
class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")
    def get_range(self):
        """打印一条消息,指出电瓶的续航里程"""
        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
        message = "This car can go approximately " + str(range)
        message += " miles on a full charge."
        print(message)

#子类:ElectricCar
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """
        初始化父类的属性,再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()


#使用类
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

8.4 导入类

  • 和函数的操作类似。
  • 可根据需要在程序文件中导入任意数量的类。from car import Car, – ElectricCar
  • 有时候,需要将类分散到多个模块中,以免模块太大,或在同一个模块中存储不相关的类。将类存储在多个模块中时,你可能会发现一个模块中的类依赖于另一个模块中的类。在这种情况下,可在前一个模块中导入必要的类。

8.5 Python标准库

  • Python标准库 是一组模块,安装的Python都包含它。

  • 字典让你能够将信息关联起来,但它们不记录你添加键-值对的顺序。要创建字典并记录其中的键-值对的添加顺序,可使用模块 collections 中的OrderedDict类。OrderedDict 实例的行为几乎与字典相同,区别只在于记录了键-值对的添加顺序。

from collections import OrderedDict

favorite_languages = OrderedDict()
favorite_languages['jen'] = 'python'
favorite_languages['sarah'] = 'c'
favorite_languages['edward'] = 'ruby'
favorite_languages['phil'] = 'python'

for name, language in favorite_languages.items():
    print(name.title() + "'s favorite language is " +
        language.title() + ".")
  • 类名应采用驼峰命名法 ,即将类名中的每个单词的首字母都大写,而不使用下划线。实例名和模块名都采用小写格式,并在单词之间加上下划线。
  • 对于每个类,都应紧跟在类定义后面包含一个文档字符串。每个模块也都应包含一个文档字符串,对其中的类可用于做什么进行描述。
  • 在类中,可使用一个空行来分隔方法;而在模块中,可使用两个空行来分隔-类。
  • 需要同时导入标准库中的模块和你编写的模块时,先编写导入标准库模块的import 语句,再添加一个空行,然后编写导入你自己编写的模块的import 语句。

评论

  1. 永远的go神
    1年前
    2021-10-28 10:36:58

    go神太强了,牛逼

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇