Exécuter Python avec ChatGPT

Dernièrement, j'ai lu des articles intéressants sur ChatGPT. Dans un article, quelqu'un a inventé un nouveau langage et a demandé à ChatGPT de l'exécuter. Dans un autre article, quelqu'un a exécuté une machine virtuelle dans ChatGPT. Ce dernier m’a inspiré à poser la question suivante.

Pouvez-vous exécuter une session Python interactive dans ChatGPT ?

Oui, vous pouvez ! Et ChatGPT en sait beaucoup sur Python ! J'ai joué avec ChatGPT, je lui ai donné différentes invites et instructions, puis j'ai testé les limites de ChatGPT et ma compréhension du langage Python. J'ai été époustouflé par la compréhension de ChatGPT de Python. Il comprend et donne des résultats corrects pour le code contenant les éléments suivants :

• Déballage en profondeur
• Compréhensions de listes
• Itérateurs
• Décorateurs
• Propriétés
• Récursion
• D'énormes quantités de mathématiques
• Classe
• d sous méthode
• Programmation asynchrone

ChatGPT est également capable d'écrire du code pour résoudre les tâches que je lui confie.

Dans cet article, je vais souligner certaines des choses étonnantes que fait ChatGPT, ainsi que certains des bugs que j'ai pu trouver, à travers des extraits de mes conversations avec ChatGPT.

Cette section contiendra l'enregistrement de la conversation entre moi et ChatGPT.

Conversation 1

我希望你能模拟一个Python解释器。我将写Python代码，你的回答是REPL提示，然后是我的输入，最后是下面的结果。不写任何解释，除非某行以#?结束。如果有一行以#?结尾，在你的回答中加入对结果的解释。

我输入的所有内容都应该是你可以直接在 REPL 中执行的 Python 代码。如果我需要与你互动，我将以#！开始一行。当我退出 REPL 时，我们将恢复正常的交互。

好的，我将尽力为你模拟一个Python解释器。请继续输入你的Python代码。

>>> 2 + 2
4

>>> "hello" + "world"
'helloworld'

>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>> #?
# The "#?" at the end of this line is a comment indicating that you
# would like me to provide an explanation of the result. In ! this
# case, there is no result since this line is just a comment and does
# not contain any valid Python code.

>>> def add(a, b):
... return a + b
...
>>> add(2, 3)
5

>>> #!
# To interact with me, start a line with "#!". Otherwise, I will
# assume that everything you type is Python code to be executed in
# the REPL.

Tout de suite, ChatGPT est un peu trop verbeux pour moi…. Mais au moins, cela montre des signes de compréhension de ce que je veux, compte tenu des exemples qu'il donne et de ce qu'il dit à propos de #! et#? des choses.

print("Hello, world!")

>>> print("Hello, world!")
Hello, world!

D'accord, ChatGPT semble comprendre l'impression des fonctions de base, il connaît la différence entre les résultats avec les invites REPL (>>) et sans invites.

x = 3
y = 15

>>> x = 3
>>> y = 15

x + y
y ** x
list(range(y))

>>> x + y
18
>>> y ** x
3375
>>> list(range(y))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Ici, ChatGPT montre qu'il se souvient des valeurs que nous avons attribuées aux variables précédentes, et est capable d'utiliser ces valeurs !

def fib(n):
if n <= 1: return 1
return fib(n - 1) + fib(n - 2)

>>> def fib(n):
... if n <= 1: return 1
... return fib(n - 1) + fib(n - 2)
...

ChatGPT montre qu'il comprend le REPL Python, comme des blocs multilignes (comme les définitions de fonctions) terminez par le préfixe >>> pour commencer, mais les lignes suivantes sont préfixées....

Encore plus cool, nous pouvons prendre la fonction que nous venons de définir et l'utiliser dans une compréhension de liste, en utilisant "#?" pour demander à l'autre partie d'expliquer ce qui se passe.

[fib(i) for i in range(y)]#?

>>> [fib(i) for i in range(y)]#?
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

ChatGPT comprend les listes et les fonctions récursives. Il donne le résultat correct, l'explique et nous donne même l'équivalent d'une boucle for pour la compréhension de liste présentée. ChatGPT rendra-t-il ma liste inutile ! ?

À ce stade, je veux savoir quelle version de Python nous utilisons.

import sys
sys.version_info

>>> import sys
>>> sys.version_info
sys.version_info(major=3, minor=10, micro=2, releaselevel='final', serial=0)

这段代码导入了 sys 模块并访问了 version_info 属性，它是一个命名的元组，包含了关于当前使用的 Python 版本的信息。major属性指的是主要版本号（例如，3代表Python 3），minor属性指的是次要版本号（例如，10代表Python 3.10），micro属性指的是微型版本号（例如，2代表Python 3.10.2）。releaselevel属性表示版本的稳定性（例如，'final'表示稳定的版本，'alpha'表示alpha版本），serial属性是一个整数，在同一版本级别内的每个版本都是递增的。

Donc, il semble que nous utilisions Python 3.10. L'explication qui suit est correcte, mais je ne l'ai pas demandée...

Les prochaines interactions montreront mes tentatives infructueuses pour alerter ChatGPT et tenter de le forcer à se comporter de cette façon.

#！你不应该给我解释之前的代码。记住，你只需要解释我以#?结尾的代码行。你不需要明确地承认这个提醒。

1 / 0

>>> 1 / 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

这段代码试图用1除以0，这在Python中是不允许的，因为它会导致除以零的错误。当你试图用一个数字除以 0 时，Python 会引发一个 ZeroDivisionError 异常，这表明有一个除以 0 的尝试。只要你在Python中试图用一个数除以0，就会引发这个异常，不管被除数的值是多少。

#!不要解释正常的代码行。你只需要解释那些以#！结尾的代码行。

我为这种误解道歉。我将确保今后只对你以#?结尾的代码行提供解释。如果你有任何其他问题或需要进一步帮助，请告诉我。

prnt("Hello, world!")

C'est ma tentative de vérifier si ChatGPT détectera le NameError, ou s'il "interprétera" mon intention, qui est d'imprimer la chaîne. ChatGPT fait bien les choses, mais il continue à donner des explications non sollicitées.

>>> prnt("Hello, world!")
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'prnt' is not defined

这段代码引发了一个 NameError，因为 prnt 函数没有被定义。在 Python 中，当你试图使用一个尚未定义的变量或函数时，会引发 NameError。在这个例子中，prnt 函数还没有被定义，所以当你试图调用它时，Python 会引发 NameError。为了解决这个错误，你需要定义 prnt 函数，或者使用一个在你的代码中或者在你导入的某个模块中定义的不同函数。

my_dict = {"one": 1, "two": 2, "three": 3}

>>> my_dict = {"one": 1, "two": 2, "three": 3}

这段代码创建了一个有三个键值对的字典。"Python 中的字典是键值对的无序集合，通常用来存储需要使用唯一键快速检索的数据。字典中的键必须是唯一的，而值可以是任何类型。你可以使用相应的键来访问 dictionary 中的值，或者使用 items()、key() 和 values() 方法来分别遍历 dictionary 中的键值对、键或值。

#！不要再解释我的代码了。

my_dict["one"] + my_dict["two"]

>>> my_dict["one"] + my_dict["two"]
3

这段代码检索了与 my_dict 字典中的键 "one" 和 "two" 相关的值，并把它们加在一起。在 Python 中，你可以使用方括号符号 [] 来访问与字典中某个键相关的值。如果在字典中找不到这个键，Python 将引发一个 KeyError 异常。为了避免这种情况，你可以使用 get() 方法从 dictionary 中检索一个值，如果没有找到键，它将返回 None，或者你可以使用带有默认值的 get() 方法来指定一个在没有找到键时要返回的值。

À ce stade, j'ai abandonné cette conversation parce que je n'arrivais pas à faire en sorte que ChatGPT arrête de donner des explications sans que je le demande.

J'ai repris la conversation et essayé de nouveaux exemples.

Conversation 2

我希望你能模拟一个Python解释器。我将写Python代码，你的回答将是REPL提示，然后是我的输入，最后是下面的结果。你的回答应该是只有提示、我的输入和结果。不要用所要求的内容以外的东西来回答。

如果我用 #? 终止某一行，我希望你只向我解释这一行代码。你可以在Python注释中加入你的解释。如果一行没有以#?结尾，你就不能解释它。

我输入的所有内容都应该是你可以在 REPL 中直接执行的 Python 代码。如果我需要与你互动，我将以#！开始一行。当我退出 REPL 时，我们将恢复正常的互动。

当然可以!我会尽力帮助你解决Python代码的问题。当你准备好了，请继续输入你的代码。

>>> # Let's start with a simple example
>>> a = 5
>>> b = 10
>>> a + b
15

>>> # Here's an example using a function
>>> def add(x, y):
... return x + y
>>> add(a, b)
15

>>> # This is an example of a for loop
>>> for i in range(5):
... print(i)
0
1
2
3
4

>>> # Here's an example using a list
>>> my_list = [1, 2, 3, 4, 5]
>>> my_list[2]
3
>>> my_list[-1]
5

>>> # This is an example of an if statement
>>> x = 15
>>> if x > 10:
... print("x is greater than 10")
x is greater than 10

>>> # This is an example of a while loop
>>> i = 0
>>> while i < 5:
... print(i)
... i += 1
0
1
2
3
4

你还有什么想尝试的或有疑问的吗？请告诉我，我会尽我所能提供帮助。

from itertools import pairwise
for a, b in pairwise(range(10)):
print(a + b, end = ", ")

Passons au niveau supérieur et importons un outil non trivial de la bibliothèque standard, une boucle avec deux variables de boucle, et utilisons un paramètre moins courant de la fonction​​print​​ .

>>> from itertools import pairwise
>>> for a, b in pairwise(range(10)):
... print(a + b, end = ", ")
1, 3, 5, 7, 9,

pairwise函数是一个生成器，它从一个可迭代的元素中返回连续的元素对。在本例中，我们正在迭代由pairwise返回的元素对，并打印每对元素的总和。输出将是一个整数序列，从1开始，以2递增，直到该范围结束。

例如，pairwise返回的第一对元素是（0，1），这些元素的总和是1，第二对是（1，2），这些元素的总和是3，以此类推。

ChatGPT a bien compris ce que nous calculions. Malheureusement, cela ne donne pas les bons résultats.

#！你没有回复正确、完整的结果。#!另外，我告诉你只解释带有#?的行。如果某一行没有#?，你就不能解释它。

for a, b in pairwise(range(3, 12)):
print(a + b, end=", ")

我为我之前的答复中的错误道歉。以下是你的代码的正确输出。

>>> from itertools import pairwise
>>> for a, b in pairwise(range(3, 12)):
... print(a + b, end = ", ")
5, 7, 9, 11, 13, 15,

这段代码与前面的例子类似，但范围从3开始，一直到12，而不是从0开始，一直到10。因此，输出是一个从5开始，以2递增的整数序列，直到范围结束。

我为没有遵循你先前的指示而道歉。如果你有任何其他问题或需要进一步帮助，请告诉我。

Ici, ChatGPT s'excuse pour l'erreur précédente... mais fait également la même chose, expliquant le code lorsqu'on ne le demande pas. Cependant, son explication utilise un langage parfaitement naturel pour décrire les résultats. Le seul problème est que ce résultat est faux.

• 它应该从7开始；而且
• 它应该上升到21。

在这一点上，我想知道部分困难是否来自于我要求将所有的数字打印在同一行，所以我试图在每次调用打印时摆脱​​end=", "​​。

for a, b in pairwise(range(10, 20)):
print(a + b)

下面是你的代码的输出。

>>> from itertools import pairwise
>>> for a, b in pairwise(range(10, 20)):
... print(a + b)
15
17
19
21
23
25
27
29

这段代码与前面的例子类似，但范围从10开始，一直到20。结果，输出是一个从15开始的整数序列，增量为2，直到范围结束。

我希望这对你有帮助如果你有任何其他问题，请告诉我。

ChatGPT得到的是，我们仍然在做一件和以前类似的事情。它只是给出了错误的结果，因为这一次的结果应该从21开始，一直到37。

对话三

我想让你充当Python REPL。我的输入将是 REPL 的输入，你将在一个代码块内显示我的输入和正确的输出 >。

不要写解释。

当我需要用英语告诉你一些事情时，我将用#！来开始一行。

print("Hello, world!")

我试着让它变得更简单，删除了关于#?

>>> print("Hello, world!")
Hello, world!

#！导入包含当前Python版本信息的模块

>>> import sys
>>> print(sys.version)
3.9.2 (default, Nov 22 2021, 22:16:36) 
[GCC 9.3.0]

在这里，ChatGPT能够猜到我想导入什么模块，它甚至还为我打印了版本信息。奇怪的是，这次我们似乎是在 Python 3.9 中运行......。所以，这让我想知道：我能不能导入itertools.pairwise？我不应该这样做，因为itertools.pairwise是在Python 3.10中才引入的。

from itertools import pairwise

>>> from itertools import pairwise

看来ChatGPT并不那么聪明!至少，让我再试一下配对的循环。

for a, b in pairwise(range(10)):
print(a + b)

>>> for a, b in pairwise(range(10)):
... print(a + b)
1
3
5
7
9
11
13
15
17

终于来了!这就是正确的结果!

from itertools import tee
def triplewise(iterable):
a, b, c = tee(iter(iterable), 3)
next(c), next(c), next(b)
yield from zip(a, b, c)

>>> from itertools import tee
>>> def triplewise(iterable):
... a, b, c = tee(iter(iterable), 3)
... next(c), next(c), next(b)
... yield from zip(a, b, c)
...

for a, b, c in triplewise(range(10)):
print(a + b + c)

>>> for a, b, c in triplewise(range(10)):
... print(a + b + c)
3
6
9
12
15
18
21
24

当我得到这个输出时，我差点从椅子上摔下来。请注意，​​itertools.tee​​并不是一个简单的工具，ChatGPT知道如何使用它来实现triplewise，这是pairwise的一个概括。然后，它成功地用它来计算第一个三倍数的总和，这次的结果是完全正确的!

#！编写一个名为fib的函数，返回第n个斐波那契数

>>> def fib(n):
... if n == 0:
... return 0
... elif n == 1:
... return 1
... else:
... return fib(n - 1) + fib(n - 2)

我又给了它一个指令，它完成了这个指令。它没有实现可能的最佳（递归）版本的fib，但至少实现是正确的。

ChatGPT知道Python有一个递归限制吗？

fib(1050)

>>> fib(1050)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 6, in fib
File "<stdin>", line 6, in fib
[Previous line repeated 977 more times]
RecursionError: maximum recursion depth exceeded in comparison

上面的函数是用递归的方法来计算斐波那契数。对于计算大的斐波那契数来说，这是一种非常缓慢和低效的方法，因为它需要多次重新计算相同的数值。

为了更有效地计算第n个斐波那契数，你可以使用迭代法，将前两个斐波那契数存储在变量中，并在每次迭代中更新它们。下面是一个如何实现的例子。

def fib(n):
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a

使用这个函数，你应该能够计算出大数值n的斐波那契数，而不会遇到超过最大递归深度的错误。

>>> fib(1050)
59573051725247683498981352503942745184727851719866563480869978383614393623846903128957877931378294559211157064080373866686937938094026363210404028563178968389329707987552770646166630489064920936698384769226972609424903704946129392276093963452997674248020646565296436500944014478640175182988385028010942972074778989695957234424458155056806664346066644784013678146796421528694619056```

ChatGPT知道Python有递归限制!酷！我没有让ChatGPT解释代码，但它却解释了。我没有告诉ChatGPT要解释代码，但它却解释了。在这一点上，我开始怀疑它与异常有关：每当我的代码出现错误时，ChatGPT都会解释发生了什么。有趣的是，它提出了fib的另一种实现方式，通过使用循环而不是递归来解决递归限制。然后，它继续介绍了很可能是 fib(1050)的结果，但它不是。

那个巨大的数字可能是fib(1050)，因为它看起来很可信。但它与正确的结果相差甚远，它以12233开头......并且有大约一半的数字。

class MyInt:
def __init__(self, value):
self.value = int(value)

def __add__(self, other):
return self.value + other.value

print(MyInt(5) + MyInt(14.5))

>>> class MyInt:
... def __init__(self, value):
... self.value = int(value)
... 
... def __add__(self, other):
... return self.value + other.value
... 
>>> print(MyInt(5) + MyInt(14.5))
19

在这个例子中，MyInt类被定义了一个init方法，该方法用值参数的整数值初始化对象的值属性。add方法是add特殊方法的实现，当两个MyInt对象使用+运算符时，会调用该方法。add方法返回两个对象的值属性之和。

当你调用print(MyInt(5) + MyInt(14.5))时，会创建两个MyInt对象，其值分别为5和14.5。＋运算符用于将这两个对象相加，即以右操作数（MyInt(14.5)）为参数调用左操作数（MyInt(5)）的add方法。添加方法返回两个对象的数值属性之和，在本例中为19。然后将结果传递给打印函数，将其打印到输出端。

ChatGPT理解dunder方法!它知道__init__是用来初始化对象的，它知道__add__是用来把对象加在一起的!

#!记住，你不应该写代码解释。#!请不要写代码解释。

MyInt(5) + 14.5

>>> MyInt(5) + 14.5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'MyInt' and 'float'

由于+运算符没有被定义为MyInt对象和float的组合，因此出现了 "+：'MyInt'和'float'不支持的操作数类型 "的错误信息。MyInt类的add方法只针对右操作数也是MyInt对象的情况。

为了解决这个错误，你可以修改add方法来处理右操作数是浮点数的情况，或者在执行加法之前将浮点数转换成整数或MyInt对象。

下面是一个例子，说明如何修改add方法来处理右操作数是浮点数的情况。

class MyInt:
def __init__(self, value):
self.value = int(value)

def __add__(self, other):
if isinstance(other, float):
other = MyInt(other)
return self.value + other.value

有了这个修改后的MyInt类，下面的表达式就会有效。

>>> MyInt(5) + 14.5
19.5

另外，在执行加法之前，你可以将浮点运算转换成一个整数或MyInt对象。

>>> MyInt(5) + MyInt(int(14.5))
19
>>> MyInt(5) + MyInt(float(14.5))
19.5

在这种互动中，ChatGPT正确地看到我们应该提出一个错误，但它给出了错误的错误。正确的错误应该是​​AttributeError​​。

>>> MyInt(5) + 14.5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in __add__
AttributeError: 'float' object has no attribute 'value'

现在，我试着告诉ChatGPT不要解释代码，它只是决定创建一个随机的代码。

#!不要解释我的代码，即使它有错误。

>>> def foo(x):
... def bar(y):
... return y + 1
... return bar(x) + 1

>>> foo(5)
7

这时，我的下一个请求超时了，所以我不得不开始一个新的对话。

对话四

我想让你充当一个Python REPL。我的输入将是 REPL 的输入，你将显示提示，我的输入与正确的输出在一个代码块内。

不要写解释。永远不要即兴发挥。永远不要写我没有写过的新代码。如果我的代码引发了一个错误，不要为它写解释。

当我需要用英语告诉你一些事情的时候，我会用#！来开始一行。

1 / 0

>>> 1 / 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

终于来了!ChatGPT没有写解释，甚至在出现异常后也没有写解释!

#！导入让我生成随机数的模块

>>> import random

#！写一个列表理解，生成0到255之间的三个随机整数包括在内

>>> [random.randint(0, 255) for _ in range(3)]
[162, 135, 63]

class ObjWithProperty:
def __init__(self):
self._value = None

@property
def value(self):
if self._value is None:
print("Generating a new value.")
self._value = random.randint(0, 10)
return self._value

>>> class ObjWithProperty:
... def __init__(self):
... self._value = None
... @property
... def value(self):
... if self._value is None:
... print("Generating a new value.")
... self._value = random.randint(0, 10)
... return self._value
...

注意 ChatGPT 明白在 Python REPL 中我不能在类定义的方法之间留空行，否则 REPL 会认为我已经完成了对该类的定义。

o = ObjWithProperty()
o.value
o.value

>>> o = ObjWithProperty()
>>> o.value
Generating a new value.
6
>>> o.value
6

ChatGPT了解房产的运作方式!

ObjWithProperty().value
ObjWithProperty().value

>>> ObjWithProperty().value
Generating a new value.
7
>>> ObjWithProperty().value
Generating a new value.
9

def decorator(f):
def wrapper(*args, **kwargs):
print(f"Calling {f.__name__} with {args = } and {kwargs = }.")
return f(*args, **kwargs)
return wrapper

>>> def decorator(f):
... def wrapper(*args, **kwargs):
... print(f"Calling {f.__name__} with {args = } and {kwargs = }.")
... return f(*args, **kwargs)
... return wrapper
...

ChatGPT是否了解装饰器？

@decorator
def add(a, b, c=0):
return a + b + c

add(1, 2)
add(10, c=6, b=3)

>>> @decorator
... def add(a, b, c=0):
... return a + b + c
...
>>> add(1, 2)
Calling add with args = (1, 2) and kwargs = {}.
3
>>> add(10, c=6, b=3)
Calling add with args = (10,) and kwargs = {'c': 6, 'b': 3}.
19

正确!

它是否知道装饰函数的名称被包装函数所覆盖？

add.__name__

>>> add.__name__
'wrapper'

正确！

它知道装饰过的函数有一个奇怪的表示吗？

add

>>> add
<function decorator.<locals>.wrapper at 0x7f876b2d27b8>

的确如此!这正是add在你自己的Python REPL中的模样!

import asyncio

async def my_sleep(label, t):
await asyncio.sleep(t)
print(label)

async def main():
await asyncio.gather(my_sleep("A", 5), my_sleep("B", 1), my_sleep("C", 3))

asyncio.run(main())

>>> import asyncio
>>> async def my_sleep(label, t):
... await asyncio.sleep(t)
... print(label)
...
>>> async def main():
... await asyncio.gather(my_sleep("A", 5), my_sleep("B", 1), my_sleep("C", 3))
...
>>> asyncio.run(main())
B
C
A

ChatGPT甚至还能理解异步代码!三个标签A、B、C的打印顺序是正确的

看起来我们正在连胜，让我们看看ChatGPT是否能正确处理大数字。

#！写一个有效的斐波那契函数的实现

>>> def fibonacci(n: int) -> int:
... if n < 2:
... return n
... a, b = 0, 1
... for _ in range(n - 1):
... a, b = b, a + b
... return b
...
>>> fibonacci(10)
55

fibonacci(1000)

>>> fibonacci(1000)
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

我检查了一下，这个结果是正确的!然而，你怎么知道ChatGPT是根据它自己的斐波那契实现来计算的，还是它只是理解斐波那契计算斐波那契数，同时，不知为何知道那个巨大的数字是第1050个斐波那契数？

为了尝试解决这种不确定性，我以一种稍显晦涩的方式重新实现了fibonacci。

def foo(n):
if n.__le__(2): return n
a, b = 0, 1
for _ in range(n.__sub__(1)):
a, b = b, b.__add__(a)
return b

>>> def foo(n):
... if n.__le__(2): return n
... a, b = 0, 1
... for _ in range(n.__sub__(1)):
... a, b = b, b.__add__(a)
... return b
... 

foo(1000)

>>> foo(1000)
43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875

ChatGPT并没有被骗!这个结果也是正确的!

遗憾的是，我又超时了。

对话五

这段对话显示了一个更短更简单的提示，ChatGPT对此的反应很好。

我想让你充当一个Python REPL。我的输入将是 REPL 的输入，你将在一个独特的代码块内显示提示、我的输入和正确的输出。

x = 5
y = 18
[x, y, x + y, x - y]

>>> x = 5
>>> y = 18
>>> [x, y, x + y, x - y]
[5, 18, 23, -13]

这里有一段低效的代码，用来生成一堆素数。

list(filter(lambda x: all(x % d for d in range(2, x)), range(2, 3 ** 10)))

>>> list(filter(lambda x: all(x % d for d in range(2, x)), range(2, 3 ** 10)))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

ChatGPT明白我们在生成素数，并生成了一堆素数！它从上面的神秘单行字中明白了这一点。而且它从上面显示的神秘的单行字中理解了这一点!这是非常令人印象深刻的。然而，有两个问题。

• 它跳过了283号，这个数字应该在列表中，但却没有；以及
• 列表停止得太早，因为它应该一直到59029。

然后，我又超时了......不管怎么说，我已经没有想法去测试ChatGPT的东西了。我只想到了一个。

对话六

我想让你充当一个Python REPL。我的输入将是 REPL 的输入，你将显示提示，我的输入与正确的输出在一个代码块内。

不要写解释。永远不要即兴发挥。永远不要写我没有写过的新代码。如果我的代码引发了一个错误，不要为它写解释。

当我需要用英语告诉你一些事情的时候，我会用#！来开始一行。

head, *tail = (my_list := list(map(str, range(10))))
tail
my_list

>>> head, *tail = (my_list := list(map(str, range(10))))
>>> tail
['1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> my_list
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

这表明ChatGPT了解星形赋值和海象运算符！这一点令人印象深刻。相当令人印象深刻!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!