You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
628 lines
91 KiB
628 lines
91 KiB
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# 实践4 逻辑判断与分支\n",
|
|
"\n",
|
|
"## 学习目标\n",
|
|
"1. 掌握if...else语句\n",
|
|
"2. 掌握逻辑表达式的书写\n",
|
|
"3. 理解万物皆为布尔值\n",
|
|
"4. 掌握选择结构的算法构造\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"# 逻辑判断与分支"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"如果源代码是我们写出来的故事，那么“逻辑判断与分支”就是故事中的情节编排，是场景之间的关联、排列和衔接——这一点程序和小说、影视剧不那么相近，倒是更像电子游戏。游戏是互动性最强的艺术形式，可以根据玩家的行为走向不同的情节，发生不同的事件和冲突，这种分支多样性极大地增加了表现力和趣味性。\n",
|
|
"\n",
|
|
"程序也一样，如果一个程序只能顺序一条一条指令执行，能表达的东西就太少了。我们需要根据输入的不同执行不同的指令，最终给出不一样的结果，这样程序才有价值。所以所有的编程语言都会提供逻辑判断和分支执行的能力。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 1.if...else 语句"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"所谓分支，其实也很简单，就是“如果这样就 A 否则就 B”，通过这个句式的组合可以实现无穷无尽的变化，这个句式翻译成 Python 的语法就是：\n",
|
|
"\n",
|
|
"```python\n",
|
|
"if X:\n",
|
|
" A\n",
|
|
"else:\n",
|
|
" B\n",
|
|
"```\n",
|
|
"\n",
|
|
"X 是一个“逻辑判断”，其结果要么是真（*True*）要么是假（*False*）；A 和 B 是两个代码段（*code block*），分别缩进以表示从属于 `if` 和 `else`。上面的代码意思是：如果 X 是真就执行代码段 A，否则就执行代码段 B。\n",
|
|
"\n",
|
|
"Python 还可以连着写好几个 `if`，比如：\n",
|
|
"\n",
|
|
"```python\n",
|
|
"if X:\n",
|
|
" A\n",
|
|
"elif Y:\n",
|
|
" B\n",
|
|
"else:\n",
|
|
" C\n",
|
|
"```\n",
|
|
"\n",
|
|
"这里的 `elif` 是 *else if* 的简化写法，整个意思是：如果 X 是真就执行 A（不管 Y 如何），否则继续判断 Y——如果 Y 是真就执行 B，否则就执行 C。\n",
|
|
"\n",
|
|
"下面我们重点看看 X、Y 这些所谓“逻辑判断”可以是什么东西。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 2.逻辑表达式"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"只要最终给出一个逻辑真值或假值的东西都可以算作“逻辑判断”，我们大致分分类可以有这么些：\n",
|
|
"* 布尔类型的变量或者值，要么是 `True` 要么是 `False`；\n",
|
|
"* 上一章介绍的**大小比较操作符**的运算结果，例如 `a <= 6` `a + b == c` 这类；\n",
|
|
"* 返回布尔值的函数，例如我们上一章介绍的 `isinstance()`；\n",
|
|
"* 上面这些东西通过上一章介绍的**逻辑运算操作符**组合起来，例如 `(a > 1) and (a <= 6)` `isinstance(x, int) or isinstance(x, float)`。\n",
|
|
"\n",
|
|
"这些东西通称“逻辑表达式”，因为其结果最终都是一个逻辑真值或者假值，根据其真假 `if...else` 语句就知道到底应该执行哪一个分支。我们来看例子。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"from random import randrange\n",
|
|
"n = randrange(1, 100)\n",
|
|
"if n % 2 == 0:\n",
|
|
" print(n, '是偶数')\n",
|
|
"else:\n",
|
|
" print(n, '是奇数')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"上面的代码首先引入 `random` 模块里的一个函数 `randrange()`，然后调用这个函数来生成一个 1~100 之间的随机数并赋给 n——我们先不去细究这里面的东西，知道这个结果就好，关键是下面的 `if...else` 语句：如果 n 除以 2 的余数是 0（还记得上一章我们介绍的整除操作符 `//` 和 `%` 吧），就打印 ‘n 是偶数’，否则打印 ‘n 是奇数’。由于 n 是随机生成的一个数，所以你可以反复多次运行上面这段代码（运行的方法是选择上面这个 *cell*，按 ⌃+回车），看看不同的结果。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"有了逻辑判断和条件分支，我们可以做好多事情了，比如我们可以实现一个算绝对值的函数："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def abs(x):\n",
|
|
" if x >= 0:\n",
|
|
" return x\n",
|
|
" else:\n",
|
|
" return -x"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"这个函数非常简单，如果是大于等于零的数就直接返回这个数，否则返回它的相反数，我们可以测试下："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"abs(42)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"abs(-3.14)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"我们还可以实现一个我们自己的 `type()` 函数，和官方的 `type()` 功能也差不多，即返回一个变量或者值的数据类型："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def type_0(x):\n",
|
|
" if isinstance(x, bool):\n",
|
|
" return 'bool'\n",
|
|
" elif isinstance(x, int):\n",
|
|
" return 'int'\n",
|
|
" elif isinstance(x, float):\n",
|
|
" return 'float'\n",
|
|
" elif isinstance(x, str):\n",
|
|
" return 'str'\n",
|
|
" else:\n",
|
|
" return 'unknown'"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"type_0(42)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"type_0('abracadabra')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"type_0(False)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"type_0([1, 2, 3])"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"最后一个例子显示出我们的 `type_0` 实现和系统的 `type` 还是有点差距，不过没关系，我们才刚开始嘛。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 3.万物皆为布尔值"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"我们上一节列出了几类逻辑表达式，它们都可以放在 `if` 后面做逻辑判断，但可以放在 `if` 后面的远不止这些，事实上**几乎任何东西**都可以。因为 Python 提供了一组规则来判断一个值“相当于”逻辑真还是假，这种定义是在所谓“合理类比”和方便性的基础上做出的，比如：\n",
|
|
"* 数字 0 “相当于”假，而其他数字都相当于真；\n",
|
|
"* 空字符串“相当于”假，非空的字符串“相当于”真。\n",
|
|
"\n",
|
|
"其他很多情形也类似，一般来说 0 啊、空啊之类的都“相当于”假，其他就算真了。如果我们搞不清楚某个东西相当于真还是假，可以借助于内置函数 `bool()`，这个函数可以把任何东西变成布尔值（`True` 或者 `False`），下面是一些例子："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool(42)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool(0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool(0.0)"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool('')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool('abracadabra')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool('0') # 这是一个非空字符串，不要和 bool(0) 搞混哦~"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool([1, 2, 3]) # 和字符串类似，非空列表相当于真，空列表相当于假"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"bool([])"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"这种“相当于”的逻辑，可以帮助我们写出更简洁的代码，比如下面两段代码是完全等价的："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"a = 42\n",
|
|
"if n != 0:\n",
|
|
" a = a / n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"a = 42\n",
|
|
"if n:\n",
|
|
" a = a / n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"下面两段也完全等价："
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"s = input('请输入您的姓名')\n",
|
|
"if s == '':\n",
|
|
" print('姓名不可为空，请重新输入')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"s = input('请输入您的姓名')\n",
|
|
"if not s:\n",
|
|
" print('姓名不可为空，请重新输入')"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 案例 求解BMI问题（2）判断BMI指标等级（选择结构） \n",
|
|
"计算BMI指数可用于评价身体状况。用于评价身体状况的指标等级分为以下四部分： \n",
|
|
"\t轻体重：BMI<18.5 \n",
|
|
"\t健康体重：18.5≤BMI<24 \n",
|
|
"\t超重：24≤BMI<28 \n",
|
|
"\t肥胖：28≤BMI \n",
|
|
" "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "raw",
|
|
"metadata": {},
|
|
"source": [
|
|
"编写程序，根据体重和身高来判断BMI指标等级。该问题的IPO描述如下：\n",
|
|
"输入：身高和体重\n",
|
|
"处理：STEP1: 计算 BMI = 体重(kg) ÷ 身高2(m2)\n",
|
|
" STEP2: 根据计算得到的BMI值判断指标等级\n",
|
|
"输出：BMI指标等级\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "raw",
|
|
"metadata": {},
|
|
"source": [
|
|
"算法描述\n",
|
|
"1 输入身高height\n",
|
|
"2 输入体重weight\n",
|
|
"3 计算BMI = weight / height2\n",
|
|
"4 如果BMI>=28 则 等级=肥胖\n",
|
|
" 如果BMI<18.5则 等级=轻体重\n",
|
|
" 如果18.5≤BMI<24则 等级=健康体重\n",
|
|
" 如果24≤BMI<28 则 等级=超重\n",
|
|
"5 输出BMI指标等级\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### （1）使用if语句判断指标等级\n",
|
|
"为了判断BMI指标等级，实际上要做的就是判断变量value的数值最终落入哪一个区间。本任务中一共有四个区间，分别为轻体重、健康体重、超重和肥胖。最容易想到的方法是使用四个if语句。\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#【例1】使用if语句判断指标等级\n",
|
|
"height = float(input(\"请输入你的身高(m):\"))\n",
|
|
"weight = float(input(\"请输入你的体重(kg):\"))\n",
|
|
"value = weight / pow(height, 2)\n",
|
|
"if value < 18.5:\n",
|
|
" print(\"轻体重\")\n",
|
|
"if 18.5 <= value < 24:\n",
|
|
" print(\"健康体重\")\n",
|
|
"if 24 <= value < 28:\n",
|
|
" print(\"超重\")\n",
|
|
"if 28 <= value:\n",
|
|
" print(\"肥胖\")\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "raw",
|
|
"metadata": {},
|
|
"source": [
|
|
"在例1中，一共有4条if语句，分别判断value的值是不是在轻体重、健康体重、超重和肥胖之间，如果value的值满足了某一个if中的判断条件，那么就执行if语句内，同一缩进层次下的所有代码。\n",
|
|
"可以看到，4条if语句对value的判断囊括了整个有理数集，一般情况下，给定任意数值，程序都会有输出。\n",
|
|
"Python与C++/Java不同，Python允许使用类似于18.5 <= value < 24的表达式语句，它等价于18.5 <= value and value < 24。但是可以发现写4个if语句的效率不高，对于每个if条件它都必定判断一次，哪怕BMI指数的数值已经落入了之前的区间，并且这个数值已经不会再落入之后的区间。\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### （2）使用if-elif-else语句判断指标等级\n",
|
|
"使用if-elif-else语句则不会做这么多无用的操作。if-elif-else满足了一个条件之后，执行该条件下的语句块，然后跳出该选择结构。如果都不满足，则执行else分支下的语句块。例2使用if-elif-else结构改写了原程序。请读者对照例2-2-1与例2-2-2，比较仅使用if语句和使用if-elif-else结构的差别。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#【例2】使用if-elif-else结构改写程序【例1】\n",
|
|
"height = float(input(\"请输入你的身高(m):\"))\n",
|
|
"weight = float(input(\"请输入你的体重(kg):\"))\n",
|
|
"value = weight / pow(height, 2)\n",
|
|
"if value < 18.5:\n",
|
|
" print(\"轻体重\")\n",
|
|
"elif 18.5 <= value < 24:\n",
|
|
" print(\"健康体重\")\n",
|
|
"elif 24 <= value < 28:\n",
|
|
" print(\"超重\")\n",
|
|
"else:\n",
|
|
" print(\"肥胖\")\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "raw",
|
|
"metadata": {},
|
|
"source": [
|
|
"通过if-elif-else语句，程序按顺序依次判断每个分支的条件。一旦条件匹配成功，进入分支执行分支语句，然后继续执行if-elif-else后面的语句，之后的分支条件表达式将不再运算，这样做可以使程序运行的效率提升。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### （3）改进程序 \n",
|
|
"先给出程序【例3】，请观察改动部分，并尝试根据if-elif-else的特性，指出这样做的原因。"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"#【例3】修改条件表达式\n",
|
|
"height = float(input(\"请输入你的身高(m):\"))\n",
|
|
"weight = float(input(\"请输入你的体重(kg):\"))\n",
|
|
"value = weight / pow(height, 2)\n",
|
|
"if value < 18.5:\n",
|
|
" print(\"轻体重\")\n",
|
|
"elif value < 24:\n",
|
|
" print(\"健康体重\")\n",
|
|
"elif value < 28:\n",
|
|
" print(\"超重\")\n",
|
|
"else:\n",
|
|
" print(\"肥胖\")\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "raw",
|
|
"metadata": {},
|
|
"source": [
|
|
"通过对比例2与例3，可以发现，在两个elif条件判断中的表达式简洁了一些。\n",
|
|
"多分支结构依次评估条件1，条件2，...，直到找到第一个结果为True的条件，按照BMI问题来举例，在进行第一个分支（value < 18.5）的判断的时候，如果不满足第一个分支条件，那么在进行接下来的分支选择时，是已经默认了value是大于等于18.5的。所以，在第二个分支入口处判断18.5 <= value实际上是没有意义的，这仅仅会增加程序运行的开销。对于第三个分支（24 <= value < 28）也是相同的原理。\n"
|
|
]
|
|
},
|
|
{
|
|
"attachments": {
|
|
"image.png": {
|
|
"image/png": "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"
|
|
}
|
|
},
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"### （4） 调试运行\n",
|
|
"当编辑程序完成，并消除了语法错误，程序可以运行，并不代表程序是正确的，还要通过测试来检查程序的正确性，需要设计测试用例来检查程序的运行是否达到预期的设计目标。 \n",
|
|
"测试用例（Test Case）是为某个特殊目标而编制的一组测试输入、执行条件以及预期结果，以便测试某个程序路径或核实是否满足某个特定需求。 \n",
|
|
"本例中包含多分支语句，在对多分支语句的测试用例的设计中，最起码的测试用例设计要包含所有的分支和节点值。在本例中，多分支的测试要测试4个分支和3个节点值。测试用例设计如下所示。前4个测试用例测试进入分支是否正确，后三个测试用例测试节点值进入分支是否正确。 \n",
|
|
"\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"## 小试身手"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"1.编写程序：输入半径r(浮点数)，输出以r为半径的圆的面积。使用math库中的数学函数math.pi，如果输入数据为负数，输出\"ERROR\" \n",
|
|
"运行示例如下： \n",
|
|
"示例一：\n",
|
|
"r=3.5\n",
|
|
"38.48451000647496\n",
|
|
"示例二： \n",
|
|
"r=-2.9\n",
|
|
"ERROR"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"# math.pi的导入方法是在程序开头加上下面一行代码，程序中用 math.pi 表示 pi\n",
|
|
"import math\n"
|
|
]
|
|
},
|
|
{
|
|
"attachments": {
|
|
"image.png": {
|
|
"image/png": "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"
|
|
}
|
|
},
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"2.改错题，程序实现的功能是按照下面的分段函数，对输入的整数x，输出对应的y值。对于超出范围的整数x，输出“ERROR”。\n",
|
|
"\n",
|
|
"下面的程序有三处错误，请找出并修改，试程序能正常运行。 \n",
|
|
"测试用例： \n",
|
|
"输入：12 输出：ERROR \n",
|
|
"输入： 6 输出：36 \n",
|
|
"输入：-1 输出：5 \n",
|
|
"输入： 5 输出：19 "
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": null,
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"x = input()\n",
|
|
"if x > 10 or x < -10:\n",
|
|
" print(\"ERROR\")\n",
|
|
"else:\n",
|
|
" if x < 0:\n",
|
|
" y = 2 * x * x * x + 4 * x * x + 3\n",
|
|
" elif x < 6:\n",
|
|
" y = x + 14\n",
|
|
" else x <= 10:\n",
|
|
" y = 6 * x \n",
|
|
"print(y)\n"
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"kernelspec": {
|
|
"display_name": "Python 3 (ipykernel)",
|
|
"language": "python",
|
|
"name": "python3"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": {
|
|
"name": "ipython",
|
|
"version": 3
|
|
},
|
|
"file_extension": ".py",
|
|
"mimetype": "text/x-python",
|
|
"name": "python",
|
|
"nbconvert_exporter": "python",
|
|
"pygments_lexer": "ipython3",
|
|
"version": "3.9.5"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 4
|
|
}
|