Python for Machine Learning 快速入门课程。
7天学会核心 Python。
Python 是一门非常棒的编程语言。它不仅广泛应用于机器学习项目,还可以用于系统工具、Web项目等众多领域。掌握 Python 技能可以提高工作效率,因为 Python 以其简洁性而闻名。你可以更快地尝试你的想法,并用简洁的 Python 代码来表达你的想法。
作为一名实践者,你无需了解语言的底层构建,但你应该知道它可以在各种任务中帮助你。你可以看到 Python 代码的简洁性,以及其库中的函数能完成多少工作。
在这门快速课程中,你将在七天内通过练习来学习一些常见的 Python 技术。
这是一篇内容丰富且重要的文章。您可能想把它加入书签。
让我们开始吧。

Python for Machine Learning (7天迷你课程)
照片来源:David Clode,部分版权保留。
本速成课程适合谁?
在开始之前,让我们确保你来到了正确的地方。
本课程适合有一定编程基础的开发者。也许你熟悉另一种语言,或者你能够用 Python 写几行代码来完成简单的任务。
本课程的课程假设您具备以下几点:
- 您熟悉基本的Python。
- 你理解基本的编程概念,例如变量、数组、循环和函数。
- 你可以在命令行或 IDE 中使用 Python。
您不需要是
- 明星程序员
- Python 专家
这门快速课程可以帮助你从一名新手程序员转变为一名能够自信使用 Python 编写代码的专家。
本快速课程假定你已安装了可用的 Python 3.7 环境。如果你需要环境设置方面的帮助,可以按照此处的教程一步步进行:
速成课程概览
本速成课程分为七节课。
您可以每天完成一节课(推荐),或者在一天内完成所有课程(硬核)。这真的取决于您的可用时间和热情程度。
下面是七节课程的列表,它们将帮助你开始并高效地使用 Python
- 第 01 课:列表操作
- 第 02 课:字典
- 第 03 课:元组
- 第 04 课:字符串
- 第 05 课:列表推导式
- 第 06 课:enumerate 和 zip
- 第 07 课:map、filter 和 reduce
每节课可能需要 5 到 30 分钟。请按照自己的节奏学习。随时提问,甚至可以在在线评论区分享你的学习成果。
课程可能会要求你自行查找如何完成某些操作。本指南会提供一些提示,但每节课的一部分目的是促使你学习去哪里寻找与算法和 Python 中最佳工具相关的信息。
在评论中发布您的结果;我会为您加油!
坚持下去;不要放弃。
第 01 课:列表操作
在本课中,你将学习 Python 中的一种基本数据结构——列表。
在其他编程语言中,有数组。Python 中的对应物是 **list**。Python 列表不限制其存储的元素数量。你可以随时向其中添加元素,它会自动扩展其大小。Python 列表也不要求其元素是相同的数据类型。你可以在一个列表中混合搭配不同的元素。
下面,我们创建一个包含一些整数的列表,然后向其中添加一个字符串。
1 2 |
x = [1, 2, 3] x.append("that's all") |
Python 列表是零索引的。也就是说,要获取上面列表的第一个元素,我们这样做:
1 |
print(x[0]) |
这将在屏幕上打印 1
。
Python 列表允许使用负数索引来从末尾开始计数。所以打印上面列表中最后一个元素的方法是:
1 |
print(x[-1]) |
Python 还提供了一种方便的语法来获取列表的切片。要打印最后两个元素,我们这样做:
1 |
print(x[-2:]) |
通常,切片语法是 start:end
,其中 end 不包含在结果中。如果省略,默认是从第一个元素开始,直到整个列表的末尾。我们还可以使用切片语法来设置“步长”。例如,这是提取奇数和偶数的方法:
1 2 3 4 5 |
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] odd = x[::2] even = x[1::2] print(odd) print(even) |
您的任务
在上面的例子中,从 1 到 10 的列表中获取奇数,你可以设置步长为 -2
来让列表倒序。如何使用切片语法打印 [9,7,5,3,1]
?如何打印 [7,5,3]
?
请在下面的评论中发布您的答案。我很想看看您能想出什么。
在下一课中,你将学习 Python 字典。
第 02 课:字典
在本课中,你将学习 Python 中存储映射(mapping)的方式。
类似于 Perl,关联数组(associative array)也是 Python 的原生数据结构。它被称为字典(dictionary)或 dict。Python 使用方括号 []
表示列表,使用花括号 {}
表示字典。Python 字典用于键值对映射,但键必须是**可哈希的**(hashable),例如数字或字符串。因此,我们可以这样做:
1 2 3 4 5 6 |
price = { "apple": 1.5, "orange": 1.25, "banana": 0.5 } print("apple costs $", price["apple"]) |
向字典添加键值对映射类似于对列表进行索引:
1 2 |
price["lemon"] = 0.6 print("lemon costs $", price["lemon"]) |
我们可以使用 `in` 操作符检查一个键是否在字典中,例如:
1 2 3 4 5 |
if "strawberry" in price: print("strawberry costs $", price["strawberry"]) else: # 如果找不到价格,则假定为 $1 print("strawberry costs $1") |
但在 Python 字典中,我们可以使用 `get()` 函数,在键不存在时提供一个默认值:
1 |
print("strawberry costs $", price.get("strawberry", 1)) |
但实际上,你不需要为 `get()` 提供默认值。如果省略它,它将返回 `None`。例如:
1 |
print("strawberry costs $", price.get("strawberry")) |
这将产生:
1 |
strawberry costs $ None |
由于 Python 字典是键值对映射,我们可以使用以下方式仅提取键或值:
1 2 3 4 |
fruits = list(price.keys()) numbers = list(price.values()) print(fruits) print(numbers) |
我们使用 `list()` 将键或值转换为列表,以便更好地打印。
%
另一种操作列表的方法是使用 `items()` 函数。它的结果将是键值对:
1 2 |
pairs = list(price.items()) print(pairs) |
输出如下:
1 |
[('apple', 1.5), ('orange', 1.25), ('banana', 0.5), ('lemon', 0.6)] |
因为它们是列表中的对(pair),我们可以使用列表操作语法将两个字典的项合并成一个合并后的字典。示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 |
price1 = { "apple": 1.5, "orange": 1.25, "strawberry": 1.0 } price2 = { "banana": 0.5 } pairs1 = list(price1.items()) pairs2 = list(price2.items()) price = dict(pairs1 + pairs2) print(price) |
这将打印:
1 |
{'apple': 1.5, 'orange': 1.25, 'strawberry': 1.0, 'banana': 0.5} |
您的任务
根据你的 Python 版本,最后一个示例可能有更简洁的语法:
1 2 |
price = price1 | price2 price = {**price1, **price2} |
请在你的安装环境中尝试运行,看看是否能重现与最后一个示例相同的结果。
在下一课中,你将学习元组,它就像一个只读列表。
第 03 课:元组
在本课中,你将学习元组作为一种只读数据结构。
Python 有一种列表,它的行为类似于混合数据的数组。Python 的元组(tuple)非常像列表,但它在创建后不能被修改。它是**不可变的**(immutable)。创建元组就像创建列表一样,只是使用了圆括号 `()`。
1 |
x = (1, 2, 3) |
你可以像访问列表一样,通过 `x[0]` 来引用第一个元素。但由于元组是不可变的,你不能给 `x[0]` 赋新值。如果你尝试这样做,Python 将抛出一个 `TypeError`,并提示元组不支持项赋值。
元组非常适合表示函数返回的多个值。例如,下面的函数将一个值的多个幂作为元组返回:
1 2 3 4 |
def powers(n): return n, n**2, n**3 x = powers(2) print(x) |
这将打印:
1 |
(2, 4, 8) |
结果是一个元组。但我们通常使用解包语法:
1 |
itself, squared, cubed = powers(2) |
实际上,这是 Python 中一种强大的语法,可以在一行中同时给多个变量赋值。例如:
1 |
count, elements = 0, [] |
这将把变量 `count` 赋值为整数 `0`,变量 `elements` 赋值为空列表。由于解包语法,这是交换两个变量值的**Pythonic**方式:
1 |
a, b = b, a |
您的任务
考虑一个元组列表:
1 |
x = [("alpha", 0.5), ("gamma", 0.1), ("beta", 1.1), ("alpha", -3)] |
你可以使用 `sorted(x)` 对此列表进行排序。结果是什么?根据元组的比较结果,Python 是如何理解哪个元组大于或小于另一个的?元组 `("alpha", 0.5)` 或元组 `("alpha", 0.5, 1)` 哪个更大?
请在下面的评论中发布您的答案。我很想看看您能想出什么。
在下一课中,你将学习 Python 字符串。
第 04 课:字符串
在本课中,你将学习如何在 Python 中创建和使用字符串。
字符串是 Python 中存储文本的基本方式。所有 Python 字符串都是 Unicode 字符串,这意味着你可以将 Unicode 放入其中。例如:
1 2 |
x = "Hello ????" print(x) |
这个笑脸字符的 Unicode 代码点是 0x1F600。Python 字符串附带了许多函数。例如,我们可以使用以下方法检查字符串是否以某个子字符串开头或结尾:
1 2 3 4 |
if x.startswith("Hello"): print("x starts with Hello") if not x.endswith("World"): print("x does not end with World") |
然后,要检查一个字符串是否包含子字符串,请使用 “in
” 操作符:
1 2 |
if "ll" in x: print("x contains double-l") |
还有很多其他功能,例如 `split()` 用于分割字符串,或 `upper()` 用于将整个字符串转换为大写。
Python 字符串的一个特殊属性是**隐式连接**。所有以下方法都将生成字符串 "hello world"
:
1 2 3 4 5 |
x = "hel" \ "lo world" x = "hello" " world" x = ("hello " "world") |
规则是,Python 通常将 `\` 用作行续符。但是,如果 Python 看到两个字符串并排放置而没有任何分隔符,则这些字符串将被连接起来。因此,上面的第一个例子是将 "hel"
与 "lo world"
连接起来。同样,最后一个例子连接了两个字符串,因为它们放在了括号内。
Python 字符串也可以使用模板创建。这通常在 `print()` 函数中看到。例如,下面的所有方法都会为变量 `y` 生成 "hello world"
:
1 2 3 4 |
x = "world" y = "hello %s" % x y = "hello {}".format(x) y = f"hello {x}" |
您的任务
尝试运行此代码:
1 2 3 |
coord = {"lat": 51.5072, "lon": -0.1276} print("latitude %(lat)f, longitude %(lon)f" % coord) print("latitude {lat}, longitude {lon}".format(**coord)) |
这是使用字典填充模板。第一个使用 `%` 语法,第二个使用 format 语法。你能修改上面的代码来只打印 2 位小数吗?提示:查看 https://docs.pythonlang.cn/3/library/string.html!
请在下面的评论中发布您的答案。我很想看看您能想出什么。
在下一课中,你将学习 Python 中的列表推导式语法。
第 05 课:列表推导式
在本课中,你将看到列表推导式语法如何动态构建列表。
著名的 FizzBuzz 问题打印 1 到 100,将所有 3 的倍数替换为“fizz”,所有 5 的倍数替换为“buzz”,如果一个数既是 3 的倍数又是 5 的倍数,则打印“fizzbuzz”。你可以使用 `for` 循环和一些 `if` 语句来完成此操作。但我们也可以在一行中完成:
1 2 3 |
numbers = ["fizzbuzz" if n%15==0 else "fizz" if n%3==0 else "buzz" if n%5==0 else str(n) for n in range(1,101)] print("\n".join(numbers)) |
我们使用列表推导式语法设置了列表 `numbers`。该语法看起来像一个列表,但其中包含一个 `for` 循环。在 `for` 关键字之前,我们定义了列表中每个元素将如何被创建。
列表推导式可以更复杂。例如,这是如何生成 1 到 100 的所有 3 的倍数:
1 |
mul3 = [n for n in range(1,101) if n%3 == 0] |
这是如何打印一个 10x10 的乘法表:
1 2 3 |
table = [[m*n for n in range(1,11)] for m in range(1,11)] for row in table: print(row) |
这是如何组合字符串:
1 2 |
directions = [a+b for a in ["north", "south", ""] for b in ["east", "west", ""] if not (a=="" and b=="")] print(directions) |
输出如下:
1 |
['northeast', 'northwest', 'north', 'southeast', 'southwest', 'south', 'east', 'west'] |
您的任务
Python 还有字典推导式。语法是:
1 |
double = {n: 2*n for n in range(1,11)} |
现在尝试使用字典推导式创建一个字典 mapping
,该字典将字符串 x
映射到其长度 len(x)
,针对这些字符串
1 2 |
keys = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"] mapping = {...} |
请在下面的评论中发布您的答案。我很想看看您能想出什么。
在下一课中,您将学习两个非常有用的 Python 函数:enumerate()
和 zip()
。
第 06 课:Enumerate 和 Zip
在本课中,您将学习 enumerate()
函数和 zip()
函数。
您经常会看到像这样的 for 循环的写法
1 2 3 |
x = ["alpha", "beta", "gamma", "delta"] for n in range(len(x)): print("{}: {}".format(n, x[n])) |
但是在这里,我们只需要循环变量 n
作为索引来访问列表 x
。在这种情况下,我们可以让 Python 在循环时索引列表,使用 enumerate()
1 2 3 |
x = ["alpha", "beta", "gamma", "delta"] for n,string in enumerate(x): print("{}: {}".format(n, string)) |
enumerate()
的结果会产生一个包含计数器(默认从零开始)和列表元素的元组。我们使用解包语法将它设置为两个变量。
如果我们像这样使用 for 循环
1 2 3 4 |
x = ["blue", "red", "green", "yellow"] y = ["cheese", "apple", "pea", "mustard"] for n in range(len(x)): print("{} {}".format(x[n], y[n])) |
Python 有一个 zip()
函数来提供帮助
1 2 3 4 |
x = ["blue", "red", "green", "yellow"] y = ["cheese", "apple", "pea", "mustard"] for a, b in zip(x, y): print("{} {}".format(a, b)) |
zip()
函数就像一个拉链,从每个输入列表中取出一个元素并将它们并排放在一起。您可以提供两个以上的列表给 zip()
。它将产生所有匹配的项(即,在达到最短输入列表的末尾时停止)。
你的任务
在 Python 程序中,我们经常这样做
1 2 3 4 |
results = [] for n in range(1, 11): squared, cubed = n**2, n**3 results.append([n, squared, cubed]) |
然后,我们可以使用 zip()
获取从 1 到 10 的列表、它们的平方以及它们的立方(请注意参数中 results
前面的 *
)
1 |
numbers, squares, cubes = zip(*results) |
试试看。您能否使用 zip()
将 numbers
、squares
和 cubes
重组回 results
?提示:只需使用 zip()
。
在下一课中,您将学习另外三个 Python 函数:map()
、filter()
和 reduce()
。
第 07 课:Map、Filter 和 Reduce
在本课中,您将学习 Python 函数 map()
、filter()
和 reduce()
。
这三个函数的名称来源于函数式编程范式。简单来说,map()
是使用某个函数转换列表的元素,而 filter()
是根据特定标准筛选列表的元素。如果您学过列表推导式,它们只是列表推导式的另一种方法。
让我们看一个之前看过的例子
1 2 3 4 5 6 7 8 9 10 11 |
def fizzbuzz(n): if n%15 == 0: return "fizzbuzz" if n%3 == 0: return "fizz" if n%5 == 0: return "buzz" return str(n) numbers = map(fizzbuzz, range(1,101)) print("\n".join(numbers)) |
这里我们定义了一个函数,map()
使用该函数作为第一个参数,并使用列表作为第二个参数。它将从列表中获取每个元素,并使用提供的函数对其进行转换。
使用 filter()
也一样
1 2 3 4 5 |
def multiple3(n): return n % 3 == 0 mul3 = filter(multiple3, range(1,101)) print(list(mul3)) |
如果合适,您可以将 map()
的返回值传递给 filter()
,反之亦然。
您可以将 map()
和 filter()
视为另一种编写列表推导式的方法(有时更容易阅读,因为逻辑被模块化了)。reduce()
函数不能被列表推导式替代。它扫描列表中的元素并使用函数将它们组合起来。
虽然 Python 内置了 max()
函数,但我们可以使用 reduce()
来实现相同的功能。请注意,reduce()
是来自 functools
模块的函数
1 2 3 4 5 6 7 8 9 10 |
from functools import reduce def maximum(a,b): if a > b: return a else: return b x = [-3, 10, 2, 5, -6, 12, 0, 1] max_x = reduce(maximum, x) print(max_x) |
默认情况下,reduce()
将前两个元素传递给提供的函数,然后将结果与第三个元素再次传递给函数,依此类推,直到输入列表用尽。但还有另一种调用 reduce()
的方法
1 2 3 |
x = [-3, 10, 2, 5, -6, 12, 0, 1] max_x = reduce(maximum, x, -float("inf")) print(max_x) |
结果相同,但第一次调用函数时使用的是默认值(在本例中为 -float("inf")
,即负无穷大)和列表的第一个元素。然后使用结果和列表中的第二个元素,依此类推。在某些情况下,提供默认值是合适的,例如下面的练习。
您的任务
让我们考虑一种将位图转换为整数的方法。如果提供列表 [6,2,0,3]
,我们应该将列表视为要断言的位,结果应为二进制 1001101,或十进制 77。在这种情况下,位 0 定义为最低有效位或最右边的位。
我们可以使用 reduce 来执行此操作并打印 77
1 2 3 4 5 6 |
def setbit(bitmap, bit): return bitmap | (2**bit) assertbits = [6, 2, 0, 3] bitmap = reduce(setbit, assertbits, ???) print(bitmap) |
上面的 ???
应该是什么?为什么?
请在下面的评论中发布您的答案。我很想看看您能想出什么。
这是最后一课。
结束!
(看看您取得了多大的进步)
您做到了。干得好!
花点时间回顾一下您已经走了多远。
您发现了:
- Python 列表和切片语法
- Python 字典,如何使用它,以及如何组合两个字典
- 元组、解包语法以及如何使用它来交换变量
- 字符串,包括从模板创建新字符串的多种方法
- 列表推导式
- 函数
enumerate()
和zip()
的用法 - 如何使用
map()
、filter()
和reduce()
总结
您对这个迷你课程的学习情况如何?
您喜欢这个速成课程吗?
您有任何问题吗?有没有遇到什么难点?
告诉我。在下面留言。
>>> print(x[8::-2])
[9, 7, 5, 3, 1]
>>> print(x[6:0:-2])
[7, 5, 3]
保持出色的工作 Mike!
对于 [9,7,5,3,1]
x[-2::-2]
对于 [7,5,3,1]
x[-4::-2]
感谢您的反馈 Rishabh!
亲爱的 James,
对于 [9,7,5,3,1]
print(x[8::-2]) 或 print(x[-2::-2])
对于 [7,5,3]
print(x[-4:-10:-2]) 或 print(x[-4:0:-2]) 或 print(x[6:0:-2]) 或 print(x[6:-10:-2])
非常感谢。
非常欢迎您 Clara!
[9,7,5,3,1] =========> print(x[-2:-11:-2])
[7,5,3,1] ==========> print(x[-4:-10:-2])
x = [(“alpha”,0.5),(“gamma”,0.1),(“beta”,1.1),(“alpha”,-3)]
sorted(x)
[('alpha', -3), ('alpha', 0.5), ('beta', 1.1), ('gamma', 0.1)]
Python 首先按相应位置对列表中的每个元组进行排序,无论是按字母顺序(a,b,c,d,...)还是按数字顺序(负数、零、正数)。如果某个位置有两个相同值的元组,它会继续比较这些元组的下一个项目位置,然后才排序到同一位置的下一个较高值的项目。
元组 ('alpha', 0.5) 小于 ('alpha', 0.5, 1)
感谢您的反馈 Balaji!继续保持出色的工作!
我完全同意 Balaji 的观点。
感谢大家提供的课程。
此致,
非常欢迎您 Alberto!
x = [(“alpha”, 0.5), (“gamma”, 0.1), (“beta”, 1.1), (“alpha”, -3)]
a = sorted(x)
print(a)
它打印:[('alpha', -3), ('alpha', 0.5), ('beta', 1.1), ('gamma', 0.1)]
x = [(“alpha”, 0.5), (“gamma”, 0.1), (“beta”, 1.1), (“alpha”, 0.5, 1)]
a = sorted(x)
print(a)
它打印:[('alpha', 0.5), ('alpha', 0.5, 1), ('beta', 1.1), ('gamma', 0.1)]
继续保持出色的工作 Nanda!
对于我来说,这是一个关于列表操作方法/函数的一个很好的入门介绍,这些方法/函数可以使 Python 代码(至少对我而言)读起来更令人愉快。但是,正如标题所示,它们与机器学习有什么关系呢?
虽然我确实使用过列表推导式、切片、元组解包、zip()、map()、filter() 等进行数据操作、数据清洗和数据整理,但其中没有任何内容专门应用于机器学习。我可能已经将结果数据集用于回归分析、时间序列分析,甚至用于一些非数据科学目的。
您能否为七个课程中的每一个提供一些示例,说明您是如何(或可能如何)专门将其用于机器学习目的的?
你好 Felix…感谢你的反馈!提到的方法/函数可以被视为机器学习中“数据准备”的子集。这是一个非常广泛的主题,以下是一个很好的起点
https://machinelearning.org.cn/what-is-data-preparation-in-machine-learning/
用于两位小数显示
print(“latitude {lat:.2f}, longitude {lon:.2f}”.format(**coord))
if “strawberry” in price
# if price is not found, assume $1
print(“strawberry costs $1”)
else
print(“strawberry costs $”, price[“strawberry”])
需要是 “not in”
感谢您的反馈 DV!
对于 [7, 5, 3]
back = x[6:1:-2]
print (back)
mapping = {key : len(key) for key in keys}
results = []
for n, s, c in zip(numbers, squares, cubes)
results.append([n,s,c])
第五课
keys = [“one”, “two”, “three”, “four”, “five”, “six”, “seven”, “eight”, “nine”, “ten”]
mapping = {key: len(key) for key in keys}
print(mapping)
感谢您的反馈!
第07课
bitmap = reduce(setbit, assertbits, 0)
1: 0,6 返回 64
2: 64, 2 返回 68
3. 68, 0 返回 69
4. 69, 3 返回 77
感谢您的反馈 Yoohwany!
rev = x[-2::-2]
print(rev) # [9, 7, 5, 3, 1]
limit = x[-4:1:-2]
print(limit) # [7, 5, 3]
继续保持出色的工作 Ahmed!如果您有任何问题需要我们协助,请告知。
第2课
对我来说,语句:price = dict(pairs1 + pairs2) 不起作用
我正在使用 v s code
第3课
问题 1
排序后
[('alpha', -3), ('alpha', 0.5), ('beta', 1.1), ('gamma', 0.1)]
问题 2
排序后
[('alpha', 0.5), ('alpha', 0.5, 1)]
字符串按字母顺序排序
第五课
keys = [“one”, “two”, “three”, “four”, “five”, “six”, “seven”, “eight”, “nine”, “ten”]
mapping = {i: len(i) for i in keys}
print(mapping)
第四课
print(“latitude %(lat)0.2f, longitude %(lon)0.2f” % coord)
第七课
???=6, bitmap=79
???=2, bitmap=79
???=0, bitmap=77
???=3, bitmap=79
num_list = [1,2,3,4,5,6,7,8,9,10]
num_list2 = num_list[-4:0:-2]
num_list2
--> [7, 5, 3]
感谢您的反馈 Aminu!
x=[1,2,3,4,5,6,7,8,9,10]
even=x[-1::-2]
odd=x[-2::-2]
f753=x[-4:0:-2]
print(even)
print(odd)
print(f753)
输出
[10, 8, 6, 4, 2]
[9, 7, 5, 3, 1]
[7, 5, 3]
感谢您的反馈 mahdi!
很棒的素材,易于遵循,Colab 作为环境也运行得很好。感谢您提供的所有帮助、时间和使这些内容可用。
蒂姆
非常欢迎您 Tim!我们感谢您的支持!
第1课
对于 [9,7,5,3,1]:print(x[-2: : -2])
对于 [7, 5,3]:print (x[-4: -9: -2])
第六课
zip
result =[]
for n in range(1,11)
squared,cubed = n**2, n**3
result.append([n, squared, cubed])
#print(result)
number, squre, cubes = zip(*result)
print(number)
print(squre)
print(cubes)
op
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
(1, 8, 27, 64, 125, 216, 343, 512, 729, 1000)
for n in range(len(number))
print(“{} {} {}”.format(number[n], squre[n],cubes[n]))
op
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
第六课 zip
for a, b, c in zip(number, squre, cubes )
print(“{} {} {}”.format(a, b, c))
op
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> print(x[-2::-2])
[9, 7, 5, 3, 1]
>>> print(x[-4:-9:-2])
[7, 5, 3]
继续保持出色的工作 Luke!在学习课程的过程中,如果您有任何问题,请告诉我们。
print(x[::-2])
对于 [9, 7, 5, 3, 1]
print(x[6:1:-2])
对于 [7, 5, 3]
你好 Teh…继续保持出色的工作!