python_example.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Python学习笔记\n",
    "\n",
    "#思维导图\n",
    "\n",
    "#https://www.processon.com/mindmap/6669018e0d53821802b910e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "None\n",
      "True\n",
      "and\n",
      "as\n",
      "assert\n",
      "async\n",
      "await\n",
      "break\n",
      "class\n",
      "continue\n",
      "def\n",
      "del\n",
      "elif\n",
      "else\n",
      "except\n",
      "finally\n",
      "for\n",
      "from\n",
      "global\n",
      "if\n",
      "import\n",
      "in\n",
      "is\n",
      "lambda\n",
      "nonlocal\n",
      "not\n",
      "or\n",
      "pass\n",
      "raise\n",
      "return\n",
      "try\n",
      "while\n",
      "with\n",
      "yield\n"
     ]
    }
   ],
   "source": [
    "#Python keyword\n",
    "\n",
    "import keyword\n",
    "for each in keyword.kwlist:\n",
    "    print(each)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Python keyword list\n",
    "\n",
    "False\n",
    "True\n",
    "\n",
    "if\n",
    "elif\n",
    "else\n",
    "\n",
    "while\n",
    "for\n",
    "\n",
    "break\n",
    "continue\n",
    "\n",
    "and\n",
    "or\n",
    "not\n",
    "\n",
    "import\n",
    "\n",
    "assert\n",
    "try\n",
    "except\n",
    "\n",
    "pass\n",
    "raise\n",
    "await\n",
    "async\n",
    "\n",
    "\n",
    "def\n",
    "global\n",
    "from\n",
    "with\n",
    "in\n",
    "is\n",
    "as\n",
    "\n",
    "None\n",
    "nonlocal\n",
    "\n",
    "del\n",
    "\n",
    "return\n",
    "\n",
    "class\n",
    "\n",
    "finally\n",
    "\n",
    "lambda\n",
    "yield\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#python keyword\n",
    "\n",
    "False\n",
    "True\n",
    "\n",
    "if\n",
    "elif\n",
    "else\n",
    "\n",
    "while\n",
    "for\n",
    "\n",
    "break\n",
    "continue\n",
    "\n",
    "and\n",
    "or\n",
    "not\n",
    "\n",
    "import\n",
    "\n",
    "assert\n",
    "try\n",
    "except\n",
    "\n",
    "pass\n",
    "raise\n",
    "await\n",
    "async\n",
    "\n",
    "\n",
    "def\n",
    "global\n",
    "from\n",
    "with\n",
    "in\n",
    "is\n",
    "as\n",
    "\n",
    "None\n",
    "nonlocal\n",
    "\n",
    "del\n",
    "\n",
    "return\n",
    "\n",
    "class\n",
    "\n",
    "finally\n",
    "\n",
    "lambda\n",
    "yield\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "Interrupted by user",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[68], line 9\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;124;03m编写一个成绩评级程序，要求用户输入分数，程序返回对应的评级\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;124;03m - 分数 < 60，D\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[38;5;124;03m - 分数 == 100，S\u001b[39;00m\n\u001b[0;32m      8\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m----> 9\u001b[0m score \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m请输入分数：\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[0;32m     11\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m score \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m60\u001b[39m:\n\u001b[0;32m     12\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\ipykernel\\kernelbase.py:1282\u001b[0m, in \u001b[0;36mKernel.raw_input\u001b[1;34m(self, prompt)\u001b[0m\n\u001b[0;32m   1280\u001b[0m     msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mraw_input was called, but this frontend does not support input requests.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1281\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m StdinNotImplementedError(msg)\n\u001b[1;32m-> 1282\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_input_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1283\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mprompt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1284\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_parent_ident\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mshell\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1285\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_parent\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mshell\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1286\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpassword\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[0;32m   1287\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python312\\site-packages\\ipykernel\\kernelbase.py:1325\u001b[0m, in \u001b[0;36mKernel._input_request\u001b[1;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[0;32m   1322\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m:\n\u001b[0;32m   1323\u001b[0m     \u001b[38;5;66;03m# re-raise KeyboardInterrupt, to truncate traceback\u001b[39;00m\n\u001b[0;32m   1324\u001b[0m     msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInterrupted by user\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m-> 1325\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyboardInterrupt\u001b[39;00m(msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1326\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[0;32m   1327\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog\u001b[38;5;241m.\u001b[39mwarning(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInvalid Message:\u001b[39m\u001b[38;5;124m\"\u001b[39m, exc_info\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "编写一个成绩评级程序，要求用户输入分数，程序返回对应的评级\n",
    " - 分数 < 60，D\n",
    " - 60 <= 分数 < 80，C\n",
    " - 80 <= 分数 < 90，B\n",
    " - 90 <= 分数 < 100，A\n",
    " - 分数 == 100，S\n",
    "\"\"\"\n",
    "score = int(input(\"请输入分数：\"))\n",
    "\n",
    "if score < 60:\n",
    "    print(\"D\")\n",
    "elif 60 <= score < 80:\n",
    "    print(\"C\")\n",
    "elif 80 <= score < 90:\n",
    "    print(\"B\")\n",
    "elif 90 <=score < 100:\n",
    "    print(\"A\")\n",
    "elif score == 100:\n",
    "    print(\"S\")\n",
    "else:\n",
    "    print(\"输入错误！\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18446744073709551615\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "<<舍罕王的失算>>\n",
    "相传国际象棋是古印度舍罕王的宰相达依尔发明的。\n",
    "舍罕王十分喜爱国际象棋，便决定让宰相自己选择何种赏赐。\n",
    "这位聪明的宰相指着 8×8 共 64 格的象棋棋盘说：陛下，请您赏给我一些麦子吧。\n",
    "就在棋盘的第 1 格中放 1 粒，第 2 格放 2 粒，第 3 格放 4 粒，\n",
    "以后每一格都比前一格增加一倍，依此放完棋盘上 64 格，我就感激不尽了……\n",
    "舍罕王听了达依尔这个“小小”的要求，便让人扛来一袋麦子，他要兑现许诺。\n",
    "结果，在给达依尔发放麦子时，舍罕王发现他要给达依尔的麦子比自己想象的要多得多，\n",
    "一袋麦子是远远不够的……\n",
    "\n",
    "请编程计算舍罕王应该给达依尔多少粒麦子？\n",
    "\"\"\"\n",
    "\n",
    "sum = 0\n",
    "\n",
    "for i in range(1,8*8+1):\n",
    "    sum += pow(2,i-1)\n",
    "print(sum)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n"
     ]
    }
   ],
   "source": [
    "#求和1+2+3+...+100\n",
    "sum = 0\n",
    "for i in range(1,101):\n",
    "    sum += i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 1 = 1\t\n",
      "1 * 2 = 2\t2 * 2 = 4\t\n",
      "1 * 3 = 3\t2 * 3 = 6\t3 * 3 = 9\t\n",
      "1 * 4 = 4\t2 * 4 = 8\t3 * 4 = 12\t4 * 4 = 16\t\n",
      "1 * 5 = 5\t2 * 5 = 10\t3 * 5 = 15\t4 * 5 = 20\t5 * 5 = 25\t\n",
      "1 * 6 = 6\t2 * 6 = 12\t3 * 6 = 18\t4 * 6 = 24\t5 * 6 = 30\t6 * 6 = 36\t\n",
      "1 * 7 = 7\t2 * 7 = 14\t3 * 7 = 21\t4 * 7 = 28\t5 * 7 = 35\t6 * 7 = 42\t7 * 7 = 49\t\n",
      "1 * 8 = 8\t2 * 8 = 16\t3 * 8 = 24\t4 * 8 = 32\t5 * 8 = 40\t6 * 8 = 48\t7 * 8 = 56\t8 * 8 = 64\t\n",
      "1 * 9 = 9\t2 * 9 = 18\t3 * 9 = 27\t4 * 9 = 36\t5 * 9 = 45\t6 * 9 = 54\t7 * 9 = 63\t8 * 9 = 72\t9 * 9 = 81\t\n"
     ]
    }
   ],
   "source": [
    "#打印九九乘法口诀表\n",
    "for i in range(1,10):\n",
    "    for j in range(1,i+1):\n",
    "        print(j,\"*\",i,\"=\",j*i,end=\"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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 "
     ]
    }
   ],
   "source": [
    "#求100以内质数\n",
    "\n",
    "\n",
    "for num in range(2,100):\n",
    "    for i in range(2,num):\n",
    "        if num % i == 0:\n",
    "            break\n",
    "    else:\n",
    "        print(num,end=\" \")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#1)引用\n",
    "a = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "b = a\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "a[1][1] = 100\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#2)浅拷贝Copy\n",
    "a = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "b = a.copy()\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "a[1][1] = 100\n",
    "\n",
    "print(a)\n",
    "print(b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#3)Copy模块 - 浅拷贝 - shallow copy\n",
    "import copy\n",
    "a = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "b = copy.copy(a)\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "a[1][1] = 100\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 100, 6], [7, 8, 9]]\n",
      "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#4)Copy模块 - 深拷贝 - deep copy\n",
    "import copy\n",
    "a = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "b = copy.deepcopy(a)\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "a[1][1] = 100\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#BIF函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"F\")  #ord() 用于将指定的单个字符串转换成对应的 Unicode 编码。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'F'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(70)   #chr() 用于将指定的 Unicode 编码转换成对应的字符。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#列表推导式\n",
    "#list = [expression for item in iterable if condition]\n",
    "#list(range(0,10))\n",
    "\n",
    "#[pow(i,2) for i in list(range(1,7))]\n",
    "\n",
    "[[i,i+2] for i in range(0,6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.choice(range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__class_getitem__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#列表list\n",
    "#https://www.processon.com/mindmap/6669018e0d53821802b910e2\n",
    "\n",
    "\n",
    "#创建一个新的空列表\n",
    "list1 = []\n",
    "print(list1)\n",
    "\n",
    "#创建一个新的列表\n",
    "list1 = [1,2,3,4,5]\n",
    "print(list1)\n",
    "\n",
    "#元组转换列表\n",
    "list1 = list((\"a\",\"b\",\"c\",\"d\"))\n",
    "print(list1)\n",
    "\n",
    "list1 = list(range(0,10))\n",
    "print(list1)\n",
    "\n",
    "#添加列表\n",
    "list1 = []\n",
    "list1.append(1)\n",
    "list1.append(2)\n",
    "list1.append(3)\n",
    "print(list1)\n",
    "\n",
    "#for循环添加列表\n",
    "list1 = []\n",
    "for i in range(0,10):\n",
    "    list1.append(i)\n",
    "print(list1)\n",
    "\n",
    "#扩展列表\n",
    "list1 = []\n",
    "list1.extend([1,2,3])\n",
    "list1.extend([4,5,6])\n",
    "print(list1)\n",
    "\n",
    "#插入列表\n",
    "list1 = []\n",
    "list1.insert(0,1)\n",
    "list1.insert(1,2)\n",
    "list1.insert(2,3)\n",
    "list1.insert(3,4)\n",
    "list1.insert(4,5)\n",
    "print(list1)\n",
    "\n",
    "#访问列表\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "print(list1[0])\n",
    "print(list1[1])\n",
    "print(list1[2])\n",
    "print(list1[-1])\n",
    "print(list1[-2])\n",
    "print(list1[-3])\n",
    "\n",
    "#列表切片\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "print(list1[1:2])\n",
    "print(list1[:2])\n",
    "print(list1[2:])\n",
    "print(list1[:])\n",
    "print(list1[::2])\n",
    "print(list1[1::2])\n",
    "print(list1[::-1])\n",
    "\n",
    "#遍历列表\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "for i in list1:\n",
    "    print(i)\n",
    "#列表推导式\n",
    "[print(i) for i in list1 if i%2==0]\n",
    "\n",
    "#更新列表\n",
    "list1 = [\"Apple\",\"Facebook\",\"Tecent\",\"Baidu\",\"Xiaomi\"]\n",
    "print(list1)\n",
    "list1[2] = \"Alibaba\"\n",
    "print(list1)\n",
    "list1[-2] = \"Microsoft\"\n",
    "print(list1)\n",
    "\n",
    "#删除列表\n",
    "list1 = [1,2,3,4,5]\n",
    "print(list1)\n",
    "list1.remove(1)\n",
    "print(list1)\n",
    "list1 = [\"Apple\",\"Facebook\",\"Tecent\",\"Baidu\",\"Xiaomi\"]\n",
    "print(list1)\n",
    "list1.remove(\"Apple\")\n",
    "print(list1)\n",
    "\n",
    "#弹出列表\n",
    "list1 = [1,2,3,4,5]\n",
    "print(list1)\n",
    "list1.pop()\n",
    "print(list1)\n",
    "list1.pop(1)\n",
    "print(list1)\n",
    "\n",
    "#清空列表\n",
    "list1 = [1,2,3,4,5]\n",
    "print(list1)\n",
    "list1.clear()\n",
    "print(list1)\n",
    "\n",
    "#删除列表\n",
    "list1 = [1,2,3,4,5]\n",
    "print(list1)\n",
    "del list1[0]\n",
    "print(list1)\n",
    "del list1\n",
    "#print(list1)\n",
    "\n",
    "#列表操作\n",
    "#统计\n",
    "list1 = [1,2,2,2,2,3,4,5]\n",
    "print(list1.count(2))\n",
    "\n",
    "#排序\n",
    "list1 = [1,2,3,4,5,6]\n",
    "list1.sort(reverse=True)\n",
    "print(list1)\n",
    "list1.sort()\n",
    "print(list1)\n",
    "\n",
    "list1 = [\"Apple\",\"Facebook\",\"Tecent\",\"Baidu\",\"Xiaomi\"]\n",
    "list1.sort()\n",
    "print(list1)\n",
    "list1.sort(reverse=True)\n",
    "print(list1)\n",
    "print(sorted(list1))\n",
    "\n",
    "#翻转\n",
    "list1 = [\"Apple\",\"Facebook\",\"Tecent\",\"Baidu\",\"Xiaomi\"]\n",
    "list1.reverse()\n",
    "print(list1)\n",
    "\n",
    "#索引\n",
    "list1 = [\"Apple\",\"Facebook\",\"Tecent\",\"Baidu\",\"Xiaomi\"]\n",
    "print(list1.index(\"Tecent\"))\n",
    "\n",
    "#拷贝\n",
    "list1 = [1,2,3,4,5]\n",
    "list2 = list1.copy()\n",
    "print(list1)\n",
    "print(list2)\n",
    "list1[2] = 100\n",
    "print(list1)\n",
    "print(list2)\n",
    "list2[3] = 200\n",
    "print(list1)\n",
    "print(list2)\n",
    "\n",
    "#拼接\n",
    "list1 = [1,2,3,4,5]\n",
    "list2 = [6,7,8,9,10]\n",
    "list3 = list1 + list2\n",
    "print(list3)\n",
    "list1.extend([list2])\n",
    "print(list1)\n",
    "\n",
    "#重复\n",
    "list1 = [1,2,3]\n",
    "print(list1 * 3)\n",
    "\n",
    "#列表运算\n",
    "#比较\n",
    "list1 = [1,2,3]\n",
    "list2 = [4,5,6]\n",
    "print(list1 == list2)\n",
    "print(list1 > list2)\n",
    "print(list1 < list2)\n",
    "\n",
    "list1 = [\"a\",\"b\",\"c\"]\n",
    "list2 = [\"d\",\"e\",\"f\"]\n",
    "print(list1 == list2)\n",
    "print(list1 > list2)\n",
    "print(list1 < list2)\n",
    "\n",
    "print([\"a\",\"b\"] == [\"a\",\"b\"] and [\"A\",\"B\"] == [\"A\",\"b\"])\n",
    "print([\"a\",\"b\"] == [\"a\",\"b\"] or [\"A\",\"B\"] == [\"A\",\"b\"])\n",
    "\n",
    "\n",
    "#判断\n",
    "list1 = [\"a\",\"b\",\"c\",\"d\"]\n",
    "print(\"a\" in list1)\n",
    "print(\"e\" in list1)\n",
    "print(\"b\" not in list1)\n",
    "print(\"e\" not in list1)\n",
    "\n",
    "\n",
    "list1 = [1,2,3]\n",
    "list2 = [1,2,3]\n",
    "list3 = list1\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(list3)\n",
    "print(list1 is list2)\n",
    "print(list1 is list3)\n",
    "print(list1 == list2)\n",
    "print(list1 == list3)\n",
    "\n",
    "print(iter(list1))\n",
    "print(iter(list2))\n",
    "print(iter(list3))\n",
    "print(id(list1))\n",
    "print(id(list2))\n",
    "print(id(list3))\n",
    "\n",
    "\n",
    "list1 = [\"a\",\"b\",\"c\"]\n",
    "list2 = [\"a\",\"b\",\"c\"]\n",
    "list3 = list1\n",
    "print(list1)\n",
    "print(list2)\n",
    "print(list3)\n",
    "print(list1 is list2)\n",
    "print(list1 is list3)\n",
    "print(list1 == list2)\n",
    "print(list1 == list3)\n",
    "print(iter(list1))\n",
    "print(iter(list2))\n",
    "print(iter(list3))\n",
    "print(id(list1))\n",
    "print(id(list2))\n",
    "print(id(list3))\n",
    "\n",
    "#列表函数\n",
    "#长度\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "print(len(list1))\n",
    "\n",
    "#类型\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "print(type(list1))\n",
    "\n",
    "#转换列表\n",
    "print(list((\"a\",\"b\",\"c\",\"d\",\"e\",\"f\")))\n",
    "\n",
    "#最大值\n",
    "list1 = [1,2,3,4,5,6]\n",
    "print(max(list1))\n",
    "\n",
    "#最小值\n",
    "list1 = [1,2,3,4,5,6]\n",
    "print(min(list1))\n",
    "\n",
    "#排序\n",
    "list1 = [\"a\",\"b\",\"d\",\"1\",\"2\"]\n",
    "print(sorted(list1))\n",
    "\n",
    "#去重复\n",
    "list1 = [1,2,3,3,4,5,5,6,]\n",
    "print(set(list1))\n",
    "\n",
    "\n",
    "#列表嵌套\n",
    "list1 = [1,2,3,[4,5,6]]\n",
    "print(list1)\n",
    "print(list1[0])\n",
    "print(list1[-1])\n",
    "print(len(list1))\n",
    "\n",
    "#二维列表\n",
    "list1 = [[1,2,3],\n",
    "         [4,5,6],\n",
    "         [7,8,9]]\n",
    "print(list1)\n",
    "print(list1[0])\n",
    "print(list1[0][0])\n",
    "\n",
    "list2 = []\n",
    "for i in list1:\n",
    "    for j in i:\n",
    "        list2.append(j)\n",
    "print(list2)\n",
    "\n",
    "\n",
    "#map\n",
    "name = [\"小明\",\"小红\",\"小刚\"]\n",
    "score = [85,76,95]\n",
    "\n",
    "\n",
    "#列表推导式\n",
    "list1 = [1,2,3,4,5,6,7,8,9]\n",
    "print([i**2 for i in list1 if i%2==0])\n",
    "print([i**2 for i in list1 if i%2!=0])\n",
    "\n",
    "list2 = [i**2 for i in range(0,10)]\n",
    "print(list2)\n",
    "\n",
    "list1 = [[1,2,3],\n",
    "         [4,5,6],\n",
    "         [7,8,9]]\n",
    "\n",
    "list2 = []\n",
    "\n",
    "for i in list1:\n",
    "    for j in i:\n",
    "        list2.append(j)\n",
    "        print(list2)\n",
    "\n",
    "\n",
    "list1 = [[1,2,3],\n",
    "         [4,5,6],\n",
    "         [7,8,9]]\n",
    "list2 = [i for j in list1 for i in j]\n",
    "print(list2)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "明日科技公司\n",
    "\n",
    "人形具身机器人\n",
    "1、硬件\n",
    "    （1）\n",
    "    （2）\n",
    "    （3）\n",
    "    （4）\n",
    "    （5）\n",
    "    （6）\n",
    "    （7）\n",
    "    （8）\n",
    "2、软件\n",
    "    （1）\n",
    "    （2）\n",
    "    （3）\n",
    "    （4）\n",
    "    （5）\n",
    "    （6）\n",
    "    （7）\n",
    "    （8）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[524, 219, 833], [813, 174, 918], [970, 129, 132]]\n",
      "524\t219\t833\t\n",
      "813\t174\t918\t\n",
      "970\t129\t132\t\n",
      "幸运数字是： 219\n",
      "没有幸运数字！\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "[课后作业] 第023讲：列表（V）| 课后测试题及答案\n",
    "https://fishc.com.cn/thread-175566-1-3.html\n",
    "1. 请编程找出矩阵中的幸运数字.\n",
    "说明：假设给定一个 m * n 的矩阵（矩阵中数值的取值范围是 0~1024，且各不相同），\n",
    "如果某一个元素的值在同一行的所有元素中最小，并且在同一列的所有元素中最大，那么该元素便是幸运数字。\n",
    "\n",
    "假设给定的矩阵如下：\n",
    "matrix = [[10, 36, 52],\n",
    "          [33, 24, 88],\n",
    "          [66, 76, 99]]\n",
    "          \n",
    "那么输出结果应该是 66（同时满足同一行的所有元素中最小，并且在同一列的所有元素中最大）。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "import random\n",
    "matrix = []\n",
    "\n",
    "for m in range(3):\n",
    "    matrix.append([])\n",
    "    for n in range(3):\n",
    "        matrix[m].append(random.randint(0,1024))\n",
    "print(matrix)\n",
    "\n",
    "row = len(matrix)\n",
    "col = len(matrix[0])\n",
    "\n",
    "for i in range(row):\n",
    "    for j in range(col):\n",
    "        print(matrix[i][j],end=\"\\t\")\n",
    "    print()\n",
    "\n",
    "\n",
    "min_row = [1024] * row\n",
    "max_col = [0] * col\n",
    "\n",
    "for i in range(row):\n",
    "    for j in range(col):\n",
    "        min_row[i] = matrix[i][j] if matrix[i][j] < min_row[i] else min_row[i]\n",
    "        max_col[j] = matrix[i][j] if matrix[i][j] > max_col[j] else max_col[j]\n",
    "\n",
    "for i in range(row):\n",
    "    for j in range(col):\n",
    "        if matrix[i][j] == min_row[i] and matrix[i][j] == max_col[j]:\n",
    "            print(\"幸运数字是：\",matrix[i][j])\n",
    "else:\n",
    "    print(\"没有幸运数字！\")\n",
    "#代码还有问题，需要修改\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n",
      "[4, 8, 12, 16, 20]\n"
     ]
    }
   ],
   "source": [
    "#列表推导式\n",
    "\n",
    "s = [1,2,3,4,5]\n",
    "\n",
    "for i in range(len(s)):\n",
    "    s[i] = s[i] * 2\n",
    "print(s)\n",
    "\n",
    "s = [i * 2 for i in s]\n",
    "print(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "\n",
    "\n",
    "for row in matrix:\n",
    "    print(row[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "print([row[1] for row in matrix])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 9]\n"
     ]
    }
   ],
   "source": [
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "diag = [matrix[i][i] for i in range(len(matrix))]\n",
    "\n",
    "print(diag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36]\n",
      "[[0, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]]\n",
      "['FF', 'ii', 'ss', 'hh', 'CC']\n",
      "[0, 5, 18]\n",
      "FishC\n",
      "['1', '2', '3']\n"
     ]
    }
   ],
   "source": [
    "#第024讲：列表（VI）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-176229-1-3.html\n",
    "\n",
    "#0. 请使用列表推导式，创建一个内容为 [1, 4, 9, 16, 25, 36] 的列表？\n",
    "list1 = [i**2 for i in range(1,7)]\n",
    "print(list1)\n",
    "\n",
    "#1. 请使用列表推导式，创建一个内容为 [[0, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]] 的列表？\n",
    "#list2 = [[i,j] for i in range(0,6) for j in range(2,8)]\n",
    "list2 = [[i,i+2] for i in range(0,6)]\n",
    "print(list2)\n",
    "\n",
    "#2. 请将下面的列表推导式转换为循环的形式实现？\n",
    "\"\"\"\n",
    "doub = [c*2 for c in \"FishC\"]\n",
    "print(doub)\n",
    "\"\"\"\n",
    "\n",
    "doub = []\n",
    "for c in \"FishC\":\n",
    "    #doub.append([c]*2)\n",
    "    doub.append(c*2)\n",
    "print(doub)\n",
    "\n",
    "#3. 请将下面的循环转换为列表推导式的形式实现？\n",
    "\"\"\"\n",
    ">>> matrix = [[1, 2, 3],\n",
    "...           [4, 5, 6],\n",
    "...           [7, 8, 9]]\n",
    ">>> diag = []\n",
    ">>> for i in range(len(matrix)):\n",
    "...     i *= matrix[i][i]\n",
    "...     diag.append(i)\n",
    "...\n",
    ">>> diag\n",
    "[0, 5, 18]\n",
    "\n",
    "\n",
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "diag = []\n",
    "\n",
    "for i in range(len(matrix)):\n",
    "    i = i * matrix[i][i]\n",
    "    diag.append(i)\n",
    "print(diag)\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "diag = [i*matrix[i][i] for i in range(len(matrix))]\n",
    "print(diag)\n",
    "\n",
    "\n",
    "#4. 请问下面代码执行后，变量 x 和 y 的值分别是什么？\n",
    "#>>> x = \"FishC\"\n",
    "#>>> y = [x for x in \"123\"]\n",
    "\n",
    "x = \"FishC\"\n",
    "y = [x for x in \"123\"]\n",
    "print(x)\n",
    "print(y)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "9\n",
      "[1, 5, 9]\n",
      "3\n",
      "5\n",
      "7\n",
      "3\n",
      "5\n",
      "7\n",
      "[3, 5, 7]\n",
      "[3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "#5.1. 解决一下课堂中遗留的问题吧，如何获取矩阵从左上角到右下角这条对角线上的元素？\n",
    "#5.2. 解决一下课堂中遗留的问题吧，如何获取矩阵从右上角到左下角这条对角线上的元素？\n",
    "\n",
    "matrix = [[1,2,3],\n",
    "          [4,5,6],\n",
    "          [7,8,9]]\n",
    "\n",
    "print(matrix[0][0])\n",
    "print(matrix[1][1])\n",
    "print(matrix[2][2])\n",
    "\n",
    "diag1 = [matrix[i][i] for i in range(len(matrix))]    #从左上角到右下角这条对角线\n",
    "print(diag1)\n",
    "\n",
    "\n",
    "print(matrix[0][2])\n",
    "print(matrix[1][1])\n",
    "print(matrix[2][0])\n",
    "\n",
    "print(matrix[0][-1])\n",
    "print(matrix[1][-2])\n",
    "print(matrix[2][-3])\n",
    "\n",
    "diag2 = [matrix[i][-i-1] for i in range(len(matrix))]  #从右上角到左下角这条对角线\n",
    "print(diag2)\n",
    "\n",
    "diag3 = [matrix[i][2-i] for i in range(len(matrix))]\n",
    "print(diag3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]\n",
      "[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 1]]\n",
      "[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 2, 1, 0, 0, 0, 0, 0, 0, 0], [1, 3, 3, 1, 0, 0, 0, 0, 0, 0], [1, 4, 6, 4, 1, 0, 0, 0, 0, 0], [1, 5, 10, 10, 5, 1, 0, 0, 0, 0], [1, 6, 15, 20, 15, 6, 1, 0, 0, 0], [1, 7, 21, 35, 35, 21, 7, 1, 0, 0], [1, 8, 28, 56, 70, 56, 28, 8, 1, 0], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]]\n",
      "1 \n",
      "1 1 \n",
      "1 2 1 \n",
      "1 3 3 1 \n",
      "1 4 6 4 1 \n",
      "1 5 10 10 5 1 \n",
      "1 6 15 20 15 6 1 \n",
      "1 7 21 35 35 21 7 1 \n",
      "1 8 28 56 70 56 28 8 1 \n",
      "1 9 36 84 126 126 84 36 9 1 \n",
      "\t \t \t \t \t 1\t\n",
      "\t \t \t \t  1\t 1\t\n",
      "\t \t \t \t 1\t2\t1\t\n",
      "\t \t \t  1\t 3\t 3\t 1\t\n",
      "\t \t \t 1\t4\t6\t4\t1\t\n",
      "\t \t  1\t 5\t 10\t 10\t 5\t 1\t\n",
      "\t \t 1\t6\t15\t20\t15\t6\t1\t\n",
      "\t  1\t 7\t 21\t 35\t 35\t 21\t 7\t 1\t\n",
      "\t 1\t8\t28\t56\t70\t56\t28\t8\t1\t\n",
      " 1\t 9\t 36\t 84\t 126\t 126\t 84\t 36\t 9\t 1\t\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\"\"\"\n",
    "0. 打印杨辉三角形\n",
    "杨辉三角形是中国古代数学的杰出研究成果之一，是我国北宋数学家贾宪于 1050 年首先发现并使用的。而后南宋数学家杨辉在《详解九章算法》一书中记载并保存了“贾宪三角形“。因此，贾宪三角形又被称为杨辉三角形。\n",
    "简单地说，杨辉三角形的构成如下面动图所示：\n",
    "\n",
    "从上面的动图我们可以得出一个道公式：杨辉三角形第i行j列的值 = 第 (i-1) 行 (j-1) 列的值 + 第 (i-1) 行 (j) 列的值\n",
    "好，大家知道它的构成形式就可以开干了，千万不要以“我不懂数学，没听说过杨辉三角形”为理由放弃对本题目的挑战哦^o^\n",
    "好了，大家开拔吧！\n",
    "\"\"\"\n",
    "\n",
    "# 初始化杨辉三角形\n",
    "# 创建一个10*10的二维列表，并将所有的元素初始化为0\n",
    "tri = []\n",
    "\n",
    "for i in range(10):\n",
    "    tri.append([])\n",
    "    for j in range(10):\n",
    "        tri[i].append(0)\n",
    "print(tri)\n",
    "\n",
    "# 计算杨辉三角形\n",
    "# 根据观察，我们知道杨辉三角形左右两边的元素均为1\n",
    "for i in range(10):\n",
    "    tri[i][0] = 1\n",
    "    tri[i][i] = 1\n",
    "print(tri)\n",
    "\n",
    "# 第i行j列的值 = 第(i-1)行(j-1)列的值 + 第(i-1)行(j)列的值\n",
    "for i in range(2,10):\n",
    "    for j in range(1,i):\n",
    "        tri[i][j] = tri[i-1][j-1] + tri[i-1][j]\n",
    "print(tri)\n",
    "\n",
    "\n",
    "# 输出杨辉三角形\n",
    "\n",
    "for i in range(10):\n",
    "    for j in range(i+1):\n",
    "        print(tri[i][j],end=\" \")\n",
    "    print()\n",
    "\n",
    "\n",
    "#1. 更改杨辉三角形的打印样式\n",
    "for i in range(10):\n",
    "    for k in range((10-i)//2):\n",
    "        print(\"\\t\",end=\" \")\n",
    "    for j in range(i+1):\n",
    "        if i%2==1:\n",
    "            print(\" \",end=\"\")\n",
    "        print(tri[i][j],end=\"\\t\")\n",
    "    print()\n",
    "\n",
    "#等待更加牛逼的我"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n",
      "[[1, 100, 1], [1, 100, 1], [1, 100, 1]]\n",
      "[[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n",
      "[[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第025讲：列表（VII）\n",
    "#https://fishc.com.cn/thread-178185-1-3.html\n",
    "\n",
    "#错误创建嵌套列表 -- 引用\n",
    "a = [[1] * 3] *3\n",
    "print(a)\n",
    "\n",
    "a[1][1] = 100\n",
    "print(a)\n",
    "\n",
    "\n",
    "#for循环创建嵌套列表\n",
    "b = [1]*3\n",
    "for i in range(3):\n",
    "    b[i] = [1]*3\n",
    "\n",
    "print(b)\n",
    "\n",
    "#列表推导式\n",
    "c = [[1]*3 for i in range(3)]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8]]\n",
      "[[8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8]]\n",
      "[[8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8], [8, 8, 8, 8, 8]]\n"
     ]
    }
   ],
   "source": [
    "#第025讲：列表（VII）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-178186-1-3.html\n",
    "\n",
    "#1. 请使用列表推导式创建一个 4 * 5 的二维列表，并将每个元素初始化为数字 8。\n",
    "\n",
    "#方法一：for循环\n",
    "\n",
    "a = [8] * 4\n",
    "for i in range(4):\n",
    "    a[i] = [8]*5\n",
    "print(a)\n",
    "\n",
    "\n",
    "#方法二：for循环\n",
    "\n",
    "matrix = []\n",
    "\n",
    "for i in range(4):\n",
    "    matrix.append([])\n",
    "    for j in range(5):\n",
    "        matrix[i].append(8)\n",
    "print(matrix)\n",
    "\n",
    "\n",
    "#方法三：列表推导式\n",
    "\n",
    "list1 = [list([8]*5) for i in range(4)]\n",
    "print(list1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 2.0, 3.0, 4.0]\n"
     ]
    }
   ],
   "source": [
    "#2. 请将下面列表推导式还原成循环语句的实现形式。\n",
    "\n",
    "#result = [i / 2 for i in range(10) if i % 2 == 0]\n",
    "\n",
    "\n",
    "result = []\n",
    "\n",
    "for i in range(10):\n",
    "    if i % 2 == 0:\n",
    "        result.append(i / 2)\n",
    "\n",
    "print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1], [0, 3], [0, 5], [0, 7], [0, 9], [2, 1], [2, 3], [2, 5], [2, 7], [2, 9], [4, 1], [4, 3], [4, 5], [4, 7], [4, 9], [6, 1], [6, 3], [6, 5], [6, 7], [6, 9], [8, 1], [8, 3], [8, 5], [8, 7], [8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#3. 请将下面的嵌套循环语句使用列表推导式实现。\n",
    "\n",
    "\"\"\"\n",
    "result = []\n",
    "for x in range(10):\n",
    "    if x % 2 == 0:\n",
    "        for y in range(10):\n",
    "            if y % 2 != 0:\n",
    "                result.append([x, y])\n",
    "print(result)\n",
    "\"\"\"\n",
    "\n",
    "# 列表推导式实现：\n",
    "result = [[x,y] for x in range(10) if x%2 == 0 for y in range(10) if y%2!=0]\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "#4. 请将下面 matrix 矩阵反向展开，即使得最终的结果为 [9, 8, 7, 6, 5, 4, 3, 2, 1]。\n",
    "matrix = [[1, 2, 3],\n",
    "          [4, 5, 6],\n",
    "          [7, 8, 9]]\n",
    "\n",
    "result = []\n",
    "for i in range(len(matrix)):\n",
    "    for j in range(len(matrix[i])):\n",
    "        result.append(matrix[i][j])\n",
    "result.reverse()\n",
    "print(result)\n",
    "\n",
    "\n",
    "list1 = [col for row in matrix for col in row][::-1]\n",
    "print(list1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['BLACK', 'WS'], ['BLACK', 'WM'], ['BLACK', 'WL'], ['BLACK', 'S'], ['BLACK', 'M'], ['BLACK', 'L'], ['BLACK', 'XL'], ['BLACK', '2XL'], ['BLACK', '3XL'], ['BLACK', '4XL'], ['WHITE', 'WS'], ['WHITE', 'WM'], ['WHITE', 'WL'], ['WHITE', 'S'], ['WHITE', 'M'], ['WHITE', 'L'], ['WHITE', 'XL'], ['WHITE', '2XL'], ['WHITE', '3XL'], ['WHITE', '4XL']]\n",
      "[['BLACK', 'WS'], ['BLACK', 'WM'], ['BLACK', 'WL'], ['BLACK', 'S'], ['BLACK', 'M'], ['BLACK', 'L'], ['BLACK', 'XL'], ['BLACK', '2XL'], ['BLACK', '3XL'], ['BLACK', '4XL'], ['WHITE', 'WS'], ['WHITE', 'WM'], ['WHITE', 'WL'], ['WHITE', 'S'], ['WHITE', 'M'], ['WHITE', 'L'], ['WHITE', 'XL'], ['WHITE', '2XL'], ['WHITE', '3XL'], ['WHITE', '4XL']]\n"
     ]
    }
   ],
   "source": [
    "#5. 鱼C-T恤总共提供了有 2 种颜色（\"BLACK\", \"WHITE\"）和 10 个码数（\"WS\", \"WM\", \"WL\", \"S\", \"M\", \"L\", \"XL\", \"2XL\", \"3XL\", \"4XL\"）的选择，\n",
    "# 请使用列表推导式统计所有颜色和尺码的组合（要求将每个组合使用一个内嵌的列表包含起来，如下所示）。\n",
    "\n",
    "colors = [\"BLACK\", \"WHITE\"]\n",
    "sizes = [\"WS\", \"WM\", \"WL\", \"S\", \"M\", \"L\", \"XL\", \"2XL\", \"3XL\", \"4XL\"]\n",
    "\n",
    "result1 = [[colors[i], sizes[j]] for i in range(len(colors)) for j in range(len(sizes))]\n",
    "print(result1)\n",
    "\n",
    "result2 = [[color,size] for color in colors for size in sizes]\n",
    "print(result2)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]\n",
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "#动动手\n",
    "#0. 请使用列表推导式，获得 matrix 矩阵的转置矩阵 Tmatrix（将 matrix 的行列互换之后得到的矩阵，称为 matrix 的转置矩阵）。\n",
    "#什么是转置矩阵？\n",
    "#一个矩阵 matrix，把它的第一行变成第一列，第二行变成第二列，……，最末一行变为最末一列，从而得到一个新的矩阵 Tmatrix。这一过程称为矩阵的转置。\n",
    "\n",
    "\n",
    "matrix = [[1,2,3,4],\n",
    "          [5,6,7,8],\n",
    "          [9,10,11,12]]\n",
    "\n",
    "print(matrix)\n",
    "\n",
    "\n",
    "Tmatrix = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]\n",
    "\n",
    "print(Tmatrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1. 请按照顺时针螺旋顺序输出矩阵中的所有元素。\n",
    "\n",
    "matrix = [[1,2,3,4],\n",
    "          [5,6,7,8],\n",
    "          [9,10,11,12]]\n",
    "\n",
    "\n",
    "#臣妾不会"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.04283789999317378,\n",
       " 0.04699649999383837,\n",
       " 0.034463100018911064,\n",
       " 0.04053820000262931,\n",
       " 0.03662930001155473,\n",
       " 0.035017000016523525,\n",
       " 0.039341700001386926,\n",
       " 0.023830499994801357,\n",
       " 0.02640960001735948,\n",
       " 0.029218000010587275]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[知识点备忘] 第026讲：元组\n",
    "#https://fishc.com.cn/thread-183225-1-3.html\n",
    "\n",
    "t = (1,2,3,4,5,6)\n",
    "print(t)\n",
    "\n",
    "import timeit\n",
    "\n",
    "timeit.timeit(\"x = 123\", number=1000000)\n",
    "\n",
    "timeit.repeat(\"x = 123\",repeat=10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "列表平均时间： 0.08149622999946587\n",
      "元组平均时间： 0.02564551199990092\n",
      "0.7823403999791481\n",
      "0.2839618000143673\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#https://fishc.com.cn/thread-183226-1-3.html\n",
    "#请编写代码，测试一下到底是创建列表的速度快，还是创建元组的速度快？为了得到更精准的数据，请重复测试 100 次，并分别计算出平均时间。\n",
    "\n",
    "#timeit -- 测量代码片段的执行时间\n",
    "\n",
    "import timeit\n",
    "\n",
    "l_speed = timeit.repeat(\"l = [1,2,3,4,5]\", repeat=100)\n",
    "t_speed = timeit.repeat(\"t = (1,2,3,4,5)\", repeat=100)\n",
    "\n",
    "l_avg = sum(l_speed) / len(l_speed)\n",
    "t_avg = sum(t_speed) / len(t_speed)\n",
    "\n",
    "print(\"列表平均时间：\",l_avg)\n",
    "print(\"元组平均时间：\",t_avg)\n",
    "\n",
    "#为什么运行这么慢，需要12s\n",
    "\n",
    "print(timeit.timeit(\"l = [1,2,3,4,5]\",number=10000000))\n",
    "print(timeit.timeit(\"t = (1,2,3,4,5)\",number=10000000))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i am a boy'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#字符串的各种方法大合集\n",
    "\n",
    "#[知识点备忘] 第027讲：字符串（I）\n",
    "#https://fishc.com.cn/thread-185046-1-3.html\n",
    "\n",
    "x = \"I am a boy\"\n",
    "x.capitalize()\n",
    "x.casefold()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['12321', '13531']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#第027讲：字符串（I）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185047-1-3.html\n",
    "\n",
    "#5. 请使用一行代码来检测列表中的每个元素是否为回文数，并返回一个结果为回文数构成的列表。\n",
    "#提供的列表：[\"123\", \"33211\", \"12321\", \"13531\", \"112233\"]\n",
    "#返回的结果：['12321', '13531']\n",
    "\n",
    "list1 = [\"123\", \"33211\", \"12321\", \"13531\", \"112233\"]\n",
    "\n",
    "[i for i in list1 if i==i[::-1]]\n",
    "\n",
    "\n",
    "#动动手：\n",
    "#0. 请按照以下规则整理一个给定的字符串 s。\n",
    "#一个整理好的字符串中，两个相邻字符 s[j] 和 s[j+1]，其中 0 <= j <= s.length - 2，要满足如下条件：\n",
    "# - 若 s[j] 是小写字符，则 s[j+1] 不可以是相同的大写字符\n",
    "# - 若 s[j] 是大写字符，则 s[j+1] 不可以是相同的小写字符\n",
    "# - 如果 s[j] 和 s[j+1] 满足以上两个条件，则将它们一并删除\n",
    "\n",
    "\n",
    "#1. 给定的字符串 s 是按照如下规则存放的：它的偶数下标为小写英文字母，奇数下标为正整数。\n",
    "#题目要求：编写代码，将奇数下标的数字转换为相对于上一个字母偏移后的字母。\n",
    "#比如 s = \"a1b2c3\" 转换后的结果是 \"abbdcf\"（a1 -> ab，b2 -> bd，c3 -> cf）；s = \"x7y8z9\" 转换后的结果是 \"xeygzi\"（遇到最后字母 z ，则从 a 继续计算偏移）\n",
    "\n",
    "\n",
    "#为啥我看不懂题目\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "v2\n"
     ]
    }
   ],
   "source": [
    "#第028讲：字符串（II）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185426-1-3.html\n",
    "#动动手：\n",
    "#0. 用户输入两个版本号 v1 和 v2，请编写代码比较它们，找出较新的版本。\n",
    "#从左到右的顺序依次比较它们的修订号，点号（.）左侧的值要比右侧的权重大，即 0.1 要比 0.0.99 大。\n",
    "\n",
    "#version1 = input(\"请输入第一个版本号：v1=\")\n",
    "#version2 = input(\"请输入第二个版本号：v2=\")\n",
    "\n",
    "version1 = \"1.3\"\n",
    "version2 = \"1.2\"\n",
    "\n",
    "\n",
    "print(version1.find(\".\"))\n",
    "print(version2.find(\".\"))\n",
    "\n",
    "if version1.find(\".\") > version2.find(\".\"):\n",
    "    print(\"v1\")\n",
    "else:\n",
    "    print(\"v2\")\n",
    "\n",
    "\n",
    "#菜鸟不会\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第028讲：字符串（II）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185426-1-3.html\n",
    "#1. 编写一个加密程序，其实现原理是通过替换指定的字符进行加密，附加要求是实现密文逆向检测。\n",
    "\n",
    "\n",
    "plain = input(\"请输入需要加密的明文：\")\n",
    "x = input(\"请输入需要替换的字符：\")\n",
    "y = input(\"请输入将要替换的字符：\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第029讲：字符串（III）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185428-1-3.html\n",
    "#0. 给定一个字符串 text 和字符串列表 words，返回 words 中每个单词在 text 中的位置（要求最终的位置从小到大进行排序）。\n",
    "\n",
    "#1. 编写一个程序，判断输入的字符串是否由多个子字符串重复多次构成。\n",
    "\n",
    "\n",
    "#未完成\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O Rubk loyinI\n"
     ]
    }
   ],
   "source": [
    "#第030讲：字符串（IV）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185988-1-3.html\n",
    "#0. 编写一个生成凯撒密码的程序来\n",
    "\n",
    "\"\"\"\n",
    "#凯撒密码最早由古罗马军事统帅盖乌斯·尤利乌斯·凯撒在军队中用来传递加密信息，故称凯撒密码。\n",
    "原理：\n",
    "凯撒密码是一种通过位移加密的方法，对 26 个（大小写）字母进行位移加密，比如下方是正向位移 6 位的字母对比表：\n",
    "\n",
    "明文字母表如下：\n",
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n",
    "密文字母表如下：\n",
    "GHIJKLMNOPQRSTUVWXYZABCDEFghijklmnopqrstuvwxyzabcdef\n",
    "\n",
    "所以，如果给定加密的明文是：\n",
    "I love FishC\n",
    "那么程序加密后输出的密文便是：\n",
    "O rubk LoynI\n",
    "\n",
    "\n",
    "plain = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\"\n",
    "scrt = \"GHIJKLMNOPQRSTUVWXYZABCDEFghijklmnopqrstuvwxyzabcdef\"\n",
    "\n",
    "#A1 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "#a1 = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "plain_text = input(\"请输入需要加密的明文（只支持英文字母）：\")\n",
    "shift = int(input(\"请输入移动的位数：\"))\n",
    "\n",
    "crypt_text = \"\"\n",
    "\n",
    "for char in plain_text:\n",
    "    if char.isalpha():\n",
    "        if char.isupper():\n",
    "            crypt_text += chr((ord(char) - ord(\"A\") + shift) % 26 + ord(\"A\"))\n",
    "        elif char.islower():\n",
    "            crypt_text += chr((ord(char) - ord(\"a\") + shift) % 26 + ord(\"a\"))\n",
    "        else:\n",
    "            crypt_text = char\n",
    "    else:\n",
    "        crypt_text += char\n",
    "\n",
    "print(crypt_text)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Twitter', 'TOTO', 'ASL']\n"
     ]
    }
   ],
   "source": [
    "#第030讲：字符串（IV）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-185988-1-3.html\n",
    "#1. 给定一个字符串数组 words，只返回可以使用在美式键盘同一行的字母打印出来的单词，键盘布局如下图所示。\n",
    "\n",
    "\"\"\"\n",
    "美式键盘中：\n",
    " - 第一行由字符 \"qwertyuiop\" 组成\n",
    " - 第二行由字符 \"asdfghjkl\" 组成\n",
    " - 第三行由字符 \"zxcvbnm\" 组成\n",
    "\n",
    "举例\n",
    "输入：words = [\"Twitter\", \"TOTO\", \"FishC\", \"Python\", \"ASL\"]\n",
    "输出：['Twitter', 'TOTO', 'ASL']\n",
    "\"\"\"\n",
    "\n",
    "words = [\"Twitter\", \"TOTO\", \"FishC\", \"Python\", \"ASL\"]\n",
    "\n",
    "res = []\n",
    "\n",
    "for i in words:\n",
    "    j = i.lower()\n",
    "    if j.strip(\"qwertyuiop\") == \"\" or j.strip(\"asdfghjkl\") == \"\" or j.strip(\"zxcvbnm\") == \"\":\n",
    "        res.append(i)\n",
    "print(res)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (4047856551.py, line 26)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[48], line 26\u001b[1;36m\u001b[0m\n\u001b[1;33m    \"我叫{name}，我爱{0}，喜爱{0}的人，运气都不会太差^o^\".format(name=\"小甲鱼\",\"python\")\u001b[0m\n\u001b[1;37m                                                                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "#字符串格式化语法参考\n",
    "\n",
    "\"{0:#=10}{1:#<10}\".format(250,520)\n",
    "\"{:+}{:-}\".format(250,520)  #此处有bug\n",
    "\n",
    "\"{:,}\".format(1234567890)\n",
    "\"{:_}\".format(1234567890)\n",
    "\n",
    "\"{:.2f}\".format(3.1415926)\n",
    "\"{:.2g}\".format(3.1415926)\n",
    "\n",
    "\"{:.2e}\".format(3.1415926)\n",
    "\n",
    "\"{:.6}\".format(\"abcdefg\")\n",
    "\n",
    "#\"{:.6}\".format(1234567890)\n",
    "\n",
    "\"{:b}\".format(80)\n",
    "\"{:c}\".format(80)\n",
    "\"{:d}\".format(80)\n",
    "\"{:o}\".format(80)\n",
    "\"{:x}\".format(80)\n",
    "\n",
    "\"{:#b}\".format(80)\n",
    "\n",
    "\"我叫{name}，我爱{0}，喜爱{0}的人，运气都不会太差^o^\".format(name=\"小甲鱼\",\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#第031讲：字符串（V）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-189146-1-3.html\n",
    "#0. 请编写一个程序，统计字符串中的单词个数（“单词”以空格进行分隔）\n",
    "\n",
    "text = input(\"输入：\")\n",
    "\n",
    "\"\"\"\n",
    "if text[0] == \" \":\n",
    "    count = 0\n",
    "else:\n",
    "    for each in text:\n",
    "        count += 1\n",
    "print(\"输出：\", count-1)\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "print(len(text.split()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第032讲：字符串（VI）| 课后测试题及答案\n",
    "#https://fishc.com.cn/forum.php?mod=viewthread&tid=190734\n",
    "#0. 相信大家对于压缩和解压缩的操作并不陌生，但对其内部的实现原理，你又知道多少呢？\n",
    "#1. 请大家编写一个解压程序，将上一题压缩后的字符串进行解压缩。\n",
    "\"\"\"\n",
    "接下来请大家跟着题目的提示，一起来实现字符串的压缩和解压缩吧。\n",
    "利用字符重复出现的次数，编写一个程序，实现基本的字符串压缩功能。比如，字符串 FFiiiisshCCCCCC 压缩后变成 F2i4s2h1C6（15字符 -> 10字符，66% 压缩率）。\n",
    "这种朴素的压缩算法并不总是理想的，比如 FFishCC 压缩后反而变长了 F2i1s1h1C2，这可就不是我们想要的了，所以对于重复次数小于 3 的字符，我们的程序应该选择不对其进行压缩。\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "s = input(\"请输入待压缩字符串：\")\n",
    "\n",
    "ch = s[0]\n",
    "result =\"\"\n",
    "count = 0\n",
    "\n",
    "for each in s:\n",
    "    if each == ch:\n",
    "        count += 1\n",
    "    else:\n",
    "        if count > 2:\n",
    "            result += ch + str(count)\n",
    "        elif count == 2:\n",
    "            result += ch + ch\n",
    "        elif count == 1:\n",
    "            result += ch\n",
    "        ch = each\n",
    "        count = 1\n",
    "\n",
    "\n",
    "\n",
    "#未完成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第033讲：序列（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-190848-1-3.html\n",
    "#0. 判断子序列\n",
    "#给定字符串 s 和 t ，请编程判断 s 是否为 t 的子序列。\n",
    "#字符串的子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串（例如，\"ace\" 是 \"abcde\" 的子序列，而 \"aec\" 则不是）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 7, 3, 5]\n",
      "[8, 6, 4, 2]\n",
      "[1, 3, 5, 7, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "#第034讲：序列（中）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-191252-1-4.html\n",
    "#0. 给定一个整数列表，请编程来调整该列表中整数的顺序，使得所有奇数排好序后放在数组的前半部分，所有偶数排好序后放在数组的后半部分。\n",
    "#比如给定的整数列表是 [1, 8, 7, 3, 6, 5, 4, 2]，那么调整后的结果应该是 [1, 3, 5, 7, 2, 4, 6, 8]。\n",
    "\n",
    "s = [1, 8, 7, 3, 6, 5, 4, 2]\n",
    "target1 = []\n",
    "target2 = []\n",
    "\n",
    "for each in s:\n",
    "    if each%2!=0:\n",
    "        target1.append(each)\n",
    "    elif each%2==0:\n",
    "        target2.append(each)\n",
    "sorted(target1)\n",
    "print(target1)\n",
    "sorted(target2)\n",
    "print(target2)\n",
    "print(sorted(target1)+sorted(target2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FishC. Love I\n"
     ]
    }
   ],
   "source": [
    "#第034讲：序列（中）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-191252-1-4.html\n",
    "#1. 翻转单词顺序。\n",
    "#用户输入一个英文句子，请编程翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。\n",
    "#例如输入字符串是 \"I love FishC.\"，则输出 \"FishC. love I\"。\n",
    "#注意1：用户输入的字符串可能会在前面或者后面包含任意数量的空格，但是反转后的结果将会去除这些空格（例如输入字符串是 \"   I love FishC.   \"，结果依然输出 \"FishC. love I\"）。\n",
    "#注意2：用户输入的字符串中，单词之间可能不止一个空格，但是反转后的结果将统一使用一个空格作为单词之间的间隔（例如输入字符串是 \"I   love        FishC.\"，结果依然输出 \"FishC. love I\"）\n",
    "\n",
    "text = \"I Love FishC.\"\n",
    "\n",
    "target = \" \".join(text.split()[::-1])\n",
    "print(target)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[9], line 47\u001b[0m\n\u001b[0;32m     42\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFishC\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m     44\u001b[0m lenth \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mmin\u001b[39m(\u001b[38;5;28mlen\u001b[39m(x),\u001b[38;5;28mlen\u001b[39m(y))\n\u001b[1;32m---> 47\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i,j \u001b[38;5;129;01min\u001b[39;00m x,y:\n\u001b[0;32m     48\u001b[0m     result\u001b[38;5;241m.\u001b[39mappend(x,y)\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)"
     ]
    }
   ],
   "source": [
    "#第035讲：序列（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-199906-1-4.html\n",
    "#0. 请使用学过的知识，自己动手编写代码，利用 for 循环语句，模拟 all()、any()、enumerate()、zip() 这4个函数的实现。\n",
    "\n",
    "\n",
    "x = [1,1,0]\n",
    "\n",
    "print(all(x))\n",
    "\n",
    "#all()\n",
    "for i in x:\n",
    "    if not i:\n",
    "        print(False)\n",
    "        break\n",
    "else:\n",
    "    print(True)\n",
    "\n",
    "#any()\n",
    "for i in x:\n",
    "    if i:\n",
    "        print(True)\n",
    "        break\n",
    "else:\n",
    "    print(False)\n",
    "\n",
    "#enumerate()\n",
    "a = [\"Spring\",\"Summer\",\"Fall\",\"Winter\"]\n",
    "\n",
    "\n",
    "start = 0\n",
    "out_put = []\n",
    "\n",
    "for i in a:\n",
    "    out_put.append((start,i))\n",
    "    start += 1\n",
    "print(out_put)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'F'), (2, 'i'), (3, 's')]\n"
     ]
    }
   ],
   "source": [
    "#zip()\n",
    "\n",
    "x = [1,2,3]\n",
    "y = \"FishC\"\n",
    "\n",
    "result = []\n",
    "\n",
    "\n",
    "for i in range(min(len(x),len(y))):\n",
    "    result.append((x[i],y[i]))\n",
    "print(result)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0.5\n",
      "3.0\n",
      "3.0\n",
      "0.5\n",
      "0.8000000000000007\n"
     ]
    }
   ],
   "source": [
    "#第035讲：序列（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-199906-1-4.html\n",
    "#1. 假设有一个密室，每次只能放一个人进去，在进去之前和出来之后都要求摁一下门口的打卡机按钮，打卡机会依次将名字和进出时间戳记录为以下的格式：\n",
    "\"\"\"\n",
    "times = [1, 3, 3.5, 6.5, 9.5, 10, 10.8]\n",
    "names = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\"]\n",
    "这里表示：\n",
    "A 君是从时间戳为 0 的时候进入，从时间戳为 1 的时候出来，总共耗时为 1\n",
    "B 君是从时间戳为 1 的时候进入，从时间戳为 3 的时候出来，总共耗时为 2\n",
    "C 君是从时间戳为 3 的时候进入，从时间戳为 3.5 的时候出来，总共耗时为 0.5\n",
    "...\n",
    "G 君是从时间戳为 10 的时候进入，从时间戳为 10.8 的时候出来，总共耗时为 0.8\n",
    "#题目要求大家编写代码，统计给定的数据，打印耗时最长和最短的人员名称。\n",
    "\"\"\"\n",
    "\n",
    "times = [1, 3, 3.5, 6.5, 9.5, 10, 10.8]\n",
    "names = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\"]\n",
    "\n",
    "for i in range(1,len(times)):\n",
    "    spend_time = times[i] - times[i-1]\n",
    "    print(spend_time)\n",
    "\n",
    "\n",
    "#未完成\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['S', 'O', 'S']\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第036讲：字典（上）\n",
    "#https://fishc.com.cn/thread-201226-1-4.html\n",
    "#https://morsecode.bmcx.com/\n",
    "#摩尔斯电码\n",
    "\n",
    "#摩尔斯密文表\n",
    "#使用两个列表表示映射\n",
    "c_table = [\".-\", \"-...\", \"-.-.\", \"-..\", \".\", \"..-.\",\n",
    "           \"--.\", \"....\", \"..\", \".---\", \"-.-\", \".-..\",\n",
    "           \"--\", \"-.\", \"---\", \".--.\", \"--.-\", \".-.\",\n",
    "           \"...\", \"-\", \"..-\", \"...-\", \".--\", \"-..-\",\n",
    "           \"-.--\", \"--..\", \".----\", \"..---\", \"...--\", \"....-\",\n",
    "           \".....\", \"-....\", \"--...\", \"---..\", \"----.\", \"-----\"]\n",
    "\n",
    "#摩尔斯明文标\n",
    "d_table = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\",\n",
    "           \"G\", \"H\", \"I\", \"J\", \"K\", \"L\",\n",
    "           \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\",\n",
    "           \"S\", \"T\", \"U\", \"V\", \"W\", \"X\",\n",
    "           \"Y\", \"Z\", \"1\", \"2\", \"3\", \"4\",\n",
    "           \"5\", \"6\", \"7\", \"8\", \"9\", \"0\"]\n",
    "\n",
    "code = input(\"请输入摩尔斯密码：\")\n",
    "\n",
    "split_code = code.split(\" \")\n",
    "\n",
    "result = [d_table[c_table.index(each)] for each in split_code]\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['S', '0', 'S']\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第036讲：字典（上）\n",
    "#https://fishc.com.cn/thread-201226-1-4.html\n",
    "\n",
    "#摩尔斯电码\n",
    "\n",
    "# 摩斯密码对比表\n",
    "#使用一个列表表示映射\n",
    "c_table = [\".-\", \"A\", \"-...\", \"B\", \"-.-.\", \"C\", \"-..\", \"D\",\n",
    "           \".\", \"E\", \"..-.\", \"F\", \"--.\", \"G\", \"....\", \"H\",\n",
    "           \"..\", \"I\", \".---\", \"J\", \"-.-\", \"K\", \".-..\", \"L\", \n",
    "           \"--\", \"M\", \"-.\", \"N\", \"---\", \"O\", \".--.\", \"P\",\n",
    "           \"--.-\", \"Q\", \".-.\", \"R\", \"...\", \"S\", \"-\", \"T\",\n",
    "           \"..-\", \"U\", \"...-\", \"V\", \".--\", \"W\", \"-..-\", \"X\",\n",
    "           \"-.--\", \"Y\", \"--..\", \"Z\", \".----\", \"1\", \"..---\", \"2\",\n",
    "           \"...--\", \"3\", \"....-\", \"4\", \".....\", \"5\", \"-....\", \"6\",\n",
    "           \"--...\", \"7\", \"---..\", \"8\", \"----.\", \"9\", \"-----\", \"0\"]\n",
    "\n",
    "\n",
    "code = input(\"请输入摩尔斯密码：\")\n",
    "\n",
    "split_code = code.split(\" \")\n",
    "\n",
    "result = [c_table[c_table.index(each)+1] for each in split_code]\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['O', 'R', 'U', 'B', 'K', 'L', 'O', 'Y', 'N', 'I']\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第036讲：字典（上）\n",
    "#https://fishc.com.cn/thread-201226-1-4.html\n",
    "\n",
    "#摩尔斯电码\n",
    "\n",
    "# 摩斯密码对比表\n",
    "#使用字典实现莫斯密码解密\n",
    "c_table = {\".-\":\"A\", \"-...\":\"B\", \"-.-.\":\"C\", \"-..\":\"D\",\n",
    "           \".\":\"E\", \"..-.\":\"F\", \"--.\":\"G\", \"....\":\"H\",\n",
    "           \"..\":\"I\", \".---\":\"J\", \"-.-\":\"K\", \".-..\":\"L\", \n",
    "           \"--\":\"M\", \"-.\":\"N\", \"---\":\"O\", \".--.\":\"P\",\n",
    "           \"--.-\":\"Q\", \".-.\":\"R\", \"...\":\"S\", \"-\":\"T\",\n",
    "           \"..-\":\"U\", \"...-\":\"V\", \".--\":\"W\", \"-..-\":\"X\",\n",
    "           \"-.--\":\"Y\", \"--..\":\"Z\", \".----\":\"1\", \"..---\":\"2\",\n",
    "           \"...--\":\"3\", \"....-\":\"4\", \".....\":\"5\", \"-....\":\"6\",\n",
    "           \"--...\":\"7\", \"---..\":\"8\", \"----.\":\"9\", \"-----\":\"0\"}\n",
    "\n",
    "\n",
    "code = input(\"请输入摩尔斯密码：\")\n",
    "\n",
    "split_code = code.split(\" \")\n",
    "\n",
    "result = [c_table[each] for each in split_code]\n",
    "print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0441047999775037\n",
      "2.4086492001079023\n",
      "3.0204895000206307\n",
      "16.21107280009892\n",
      "23.678497400018387\n",
      "33.343920600018464\n"
     ]
    }
   ],
   "source": [
    "#莫斯密码解码效率大比拼（列表VS字典）\n",
    "\n",
    "\n",
    "def morse_code1(code):\n",
    "      #使用两个列表表示映射\n",
    "      #摩尔斯密文表\n",
    "      c_table = [\".-\", \"-...\", \"-.-.\", \"-..\", \".\", \"..-.\",\n",
    "           \"--.\", \"....\", \"..\", \".---\", \"-.-\", \".-..\",\n",
    "           \"--\", \"-.\", \"---\", \".--.\", \"--.-\", \".-.\",\n",
    "           \"...\", \"-\", \"..-\", \"...-\", \".--\", \"-..-\",\n",
    "           \"-.--\", \"--..\", \".----\", \"..---\", \"...--\", \"....-\",\n",
    "           \".....\", \"-....\", \"--...\", \"---..\", \"----.\", \"-----\"]\n",
    "      \n",
    "      #摩尔斯明文表\n",
    "      d_table = [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\",\n",
    "           \"G\", \"H\", \"I\", \"J\", \"K\", \"L\",\n",
    "           \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\",\n",
    "           \"S\", \"T\", \"U\", \"V\", \"W\", \"X\",\n",
    "           \"Y\", \"Z\", \"1\", \"2\", \"3\", \"4\",\n",
    "           \"5\", \"6\", \"7\", \"8\", \"9\", \"0\"]\n",
    "      \n",
    "      split_code = code.split(\" \")\n",
    "      result = [d_table[c_table.index(each)] for each in split_code]\n",
    "      return result\n",
    "\n",
    "def morse_code2(code):\n",
    "      #使用一个列表表示映射\n",
    "      #摩尔斯密码对比表\n",
    "      c_table = [\".-\", \"A\", \"-...\", \"B\", \"-.-.\", \"C\", \"-..\", \"D\",\n",
    "           \".\", \"E\", \"..-.\", \"F\", \"--.\", \"G\", \"....\", \"H\",\n",
    "           \"..\", \"I\", \".---\", \"J\", \"-.-\", \"K\", \".-..\", \"L\", \n",
    "           \"--\", \"M\", \"-.\", \"N\", \"---\", \"O\", \".--.\", \"P\",\n",
    "           \"--.-\", \"Q\", \".-.\", \"R\", \"...\", \"S\", \"-\", \"T\",\n",
    "           \"..-\", \"U\", \"...-\", \"V\", \".--\", \"W\", \"-..-\", \"X\",\n",
    "           \"-.--\", \"Y\", \"--..\", \"Z\", \".----\", \"1\", \"..---\", \"2\",\n",
    "           \"...--\", \"3\", \"....-\", \"4\", \".....\", \"5\", \"-....\", \"6\",\n",
    "           \"--...\", \"7\", \"---..\", \"8\", \"----.\", \"9\", \"-----\", \"0\"]\n",
    "      \n",
    "      split_code = code.split(\" \")\n",
    "      result = [c_table[c_table.index(each)+1] for each in split_code]\n",
    "      return result\n",
    "\n",
    "def morse_code3(code):\n",
    "      #使用一个字典表示映射\n",
    "      #摩尔斯密码对比表\n",
    "      c_table = {\".-\":\"A\", \"-...\":\"B\", \"-.-.\":\"C\", \"-..\":\"D\",\n",
    "           \".\":\"E\", \"..-.\":\"F\", \"--.\":\"G\", \"....\":\"H\",\n",
    "           \"..\":\"I\", \".---\":\"J\", \"-.-\":\"K\", \".-..\":\"L\", \n",
    "           \"--\":\"M\", \"-.\":\"N\", \"---\":\"O\", \".--.\":\"P\",\n",
    "           \"--.-\":\"Q\", \".-.\":\"R\", \"...\":\"S\", \"-\":\"T\",\n",
    "           \"..-\":\"U\", \"...-\":\"V\", \".--\":\"W\", \"-..-\":\"X\",\n",
    "           \"-.--\":\"Y\", \"--..\":\"Z\", \".----\":\"1\", \"..---\":\"2\",\n",
    "           \"...--\":\"3\", \"....-\":\"4\", \".....\":\"5\", \"-....\":\"6\",\n",
    "           \"--...\":\"7\", \"---..\":\"8\", \"----.\":\"9\", \"-----\":\"0\"}\n",
    "      \n",
    "      split_code = code.split(\" \")\n",
    "      #result = [c_table(each) for each in split_code]\n",
    "      result = [c_table[each] for each in split_code]\n",
    "      return result\n",
    "\n",
    "\n",
    "test_code = \"... --- ...\"\n",
    "\n",
    "import timeit\n",
    "\n",
    "print(timeit.timeit(\"morse_code1(test_code)\", setup=\"from __main__ import morse_code1, test_code\"))\n",
    "print(timeit.timeit(\"morse_code2(test_code)\", setup=\"from __main__ import morse_code2, test_code\"))\n",
    "print(timeit.timeit(\"morse_code3(test_code)\", setup=\"from __main__ import morse_code3, test_code\"))\n",
    "\n",
    "print(timeit.timeit(\"morse_code1(test_code)\", setup=\"from __main__ import morse_code1, test_code\",number=10000000))\n",
    "print(timeit.timeit(\"morse_code2(test_code)\", setup=\"from __main__ import morse_code2, test_code\",number=10000000))\n",
    "print(timeit.timeit(\"morse_code3(test_code)\", setup=\"from __main__ import morse_code3, test_code\",number=10000000))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['S', 'O', 'S']\n",
      "['..', '.-..', '---', '...-', '.', '..-.', '..', '...', '....', '-.-.']\n"
     ]
    }
   ],
   "source": [
    "#摩斯密码morse code\n",
    "\n",
    "\n",
    "#摩斯密码表\n",
    "morse_code = {\".-\":\"A\", \"-...\":\"B\", \"-.-.\":\"C\", \"-..\":\"D\",\n",
    "           \".\":\"E\", \"..-.\":\"F\", \"--.\":\"G\", \"....\":\"H\",\n",
    "           \"..\":\"I\", \".---\":\"J\", \"-.-\":\"K\", \".-..\":\"L\", \n",
    "           \"--\":\"M\", \"-.\":\"N\", \"---\":\"O\", \".--.\":\"P\",\n",
    "           \"--.-\":\"Q\", \".-.\":\"R\", \"...\":\"S\", \"-\":\"T\",\n",
    "           \"..-\":\"U\", \"...-\":\"V\", \".--\":\"W\", \"-..-\":\"X\",\n",
    "           \"-.--\":\"Y\", \"--..\":\"Z\", \".----\":\"1\", \"..---\":\"2\",\n",
    "           \"...--\":\"3\", \"....-\":\"4\", \".....\":\"5\", \"-....\":\"6\",\n",
    "           \"--...\":\"7\", \"---..\":\"8\", \"----.\":\"9\", \"-----\":\"0\"}\n",
    "\n",
    "#密文转成明文\n",
    "crypt_text = \"... --- ...\"\n",
    "morse_decode = [morse_code[i] for i in crypt_text.split(\" \") if i in morse_code]\n",
    "print(morse_decode)\n",
    "\n",
    "#明文转成密文\n",
    "plain_text = \"I love FishC\"\n",
    "\n",
    "#生成反向的摩斯密码表\n",
    "morse_code_reverse = {v:k for k,v in morse_code.items()}\n",
    "\n",
    "morse_encode = [morse_code_reverse[i] for i in list(plain_text.upper()) if i in morse_code_reverse]\n",
    "print(morse_encode)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O rubk LoynI\n",
      "['---', '.-.', '..-', '-...', '-.-', '.-..', '---', '-.--', '-.', '..']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#第036讲：字典（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-201227-1-4.html\n",
    "\n",
    "#0. 请改进课堂中的代码，实现双重加密（先执行凯撒加密，再执行莫斯加密）\n",
    "#举个例子，比如明文 I love FishC，执行凯撒加密（正向位移 6 位）后的结果是 O rubk LoynI，接着再执行莫斯加密，结果就是 --- .-. ..- -... -.- .-.. --- -.-- -. ..\n",
    "#提示：凯撒加密的原理和实现请参考（动动手第 0 题，上次没有自己写出来的童鞋这次请务必加把劲）\n",
    "\n",
    "plain_text = \"I love FishC\"\n",
    "caesar_cipher = \"\"\n",
    "\n",
    "for each in plain_text:\n",
    "    if each.isalpha():\n",
    "        if each.isupper():\n",
    "            caesar_cipher += chr((ord(each) - ord(\"A\") + 6) % 26 + ord(\"A\"))\n",
    "        elif each.islower():\n",
    "            caesar_cipher += chr((ord(each) - ord(\"a\") + 6) % 26 + ord(\"a\"))\n",
    "        else:\n",
    "            caesar_cipher = each\n",
    "    else:\n",
    "        caesar_cipher += each\n",
    "print(caesar_cipher)\n",
    "\n",
    "morse_code = {\".-\":\"A\", \"-...\":\"B\", \"-.-.\":\"C\", \"-..\":\"D\",\n",
    "           \".\":\"E\", \"..-.\":\"F\", \"--.\":\"G\", \"....\":\"H\",\n",
    "           \"..\":\"I\", \".---\":\"J\", \"-.-\":\"K\", \".-..\":\"L\", \n",
    "           \"--\":\"M\", \"-.\":\"N\", \"---\":\"O\", \".--.\":\"P\",\n",
    "           \"--.-\":\"Q\", \".-.\":\"R\", \"...\":\"S\", \"-\":\"T\",\n",
    "           \"..-\":\"U\", \"...-\":\"V\", \".--\":\"W\", \"-..-\":\"X\",\n",
    "           \"-.--\":\"Y\", \"--..\":\"Z\", \".----\":\"1\", \"..---\":\"2\",\n",
    "           \"...--\":\"3\", \"....-\":\"4\", \".....\":\"5\", \"-....\":\"6\",\n",
    "           \"--...\":\"7\", \"---..\":\"8\", \"----.\":\"9\", \"-----\":\"0\"}\n",
    "\n",
    "morse_code_reverse = {v:k for k,v in morse_code.items()}\n",
    "\n",
    "morse_crypt = [morse_code_reverse[i] for i in list(caesar_cipher.upper()) if i in morse_code_reverse]\n",
    "print(morse_crypt)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "欢迎进入鱼C影评小程序\n",
      "1.数据录入\n",
      "2.查询数据\n",
      "3.退出程序\n"
     ]
    }
   ],
   "source": [
    "#第036讲：字典（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-201227-1-4.html\n",
    "#1. 请使用列表的知识，编写一个存储电影数据的小程序。\n",
    "\"\"\"\n",
    "需要存放的数据如下：\n",
    " - 电影名称\n",
    " - 上映时间\n",
    " - 导演（可能有多人）\n",
    " - 主演（通常有多人）\n",
    " - 电影评分\n",
    "\"\"\"\n",
    "\n",
    "\"\"\"\n",
    "#user_input = input(\"请输入想要的功能(1,2,3)：\")\n",
    "\n",
    "movie = {}\n",
    "\n",
    "movie = {[\"name\":\"这个杀手不太冷,\"date\":\"1994-09-14\",\"director\":[\"吕克.贝松\"],\"actor\":[\"\",\"\",\"\"],\"score\":\"9.4\"]}\n",
    "print(movie)\n",
    "\n",
    "\n",
    "while user_input == \"1\":\n",
    "    movie[\"name\"] = str(input(\"请输入电影名称：\"))\n",
    "    movie[\"date\"] = str(input(\"请输入上映日期：\"))\n",
    "    movie[\"director\"] = list(input(\"请输入导演名字（多人请用/分割）:\"))\n",
    "    movie[\"actor\"] = list(input(\"请输入演员名字（多人请用/分割）：\"))\n",
    "    movie[\"score\"] = float(input(\"请输入电影评分：\"))\n",
    "\n",
    "    while user_input == \"Y\":\n",
    "        continue\n",
    "    while user_input == \"N\":\n",
    "        break\n",
    "\n",
    "while user_input == \"2\":\n",
    "    result = input(\"请输入电影名称：\")\n",
    "    movie[result]\n",
    "    print(\"电影名称：\",movie[])\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "print(\"欢迎进入鱼C影评小程序\")\n",
    "print(\"1.数据录入\")\n",
    "print(\"2.查询数据\")\n",
    "print(\"3.退出程序\")\n",
    "op = int(input(\"请输入想要的功能(1,2,3)：\"))\n",
    "\n",
    "movies = []\n",
    "dates = []\n",
    "directors = []\n",
    "actors = []\n",
    "scores = []\n",
    "\n",
    "\n",
    "while op!=3:\n",
    "    if op == 1:\n",
    "        go = True\n",
    "        while go:\n",
    "            movies.append(input(\"请输入电影名称：\"))\n",
    "            dates.append(input(\"请输入上映日期：\"))\n",
    "            directors.append([i.strip() for i in input(\"请输入导演名字（多人请用/分割）:\").split(\"/\")])\n",
    "            actors.append([i.strip() for i in input(\"请输入演员名字（多人请用/分割）：\").split(\"/\")])\n",
    "            scores.append(input(\"请输入电影评分：\"))\n",
    "\n",
    "            if input(\"请问是否继续录入（Y/N）：\") == \"N\":\n",
    "                go = False\n",
    "    if op == 2:\n",
    "        name = input(\"请输入电影名称：\")\n",
    "        for each in movies:\n",
    "            if each.find(name) !=-1:\n",
    "                print(f\"电影名称：{each}\")\n",
    "                print(f\"上映日期：{dates[movies.index(each)]}\")\n",
    "                print(f\"导演名单：{directors[moives.index(each)]}\")\n",
    "                print(f\"演员名单：{actors[movies.index(each)]}\")\n",
    "                print(f\"当前评分：{socres[movies.index(each)]}\")\n",
    "                break\n",
    "        else:\n",
    "            print(\"查无此片！\")\n",
    "    \n",
    "\n",
    "                \n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "#未完成，特困生\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第036讲：字典（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-201227-1-4.html\n",
    "#1. 请使用列表的知识，编写一个存储电影数据的小程序。\n",
    "\"\"\"\n",
    "需要存放的数据如下：\n",
    " - 电影名称\n",
    " - 上映时间\n",
    " - 导演（可能有多人）\n",
    " - 主演（通常有多人）\n",
    " - 电影评分\n",
    "\"\"\"\n",
    "\n",
    "name = []\n",
    "date = []\n",
    "director = []\n",
    "actor = []\n",
    "score = []\n",
    "\n",
    "print(\"欢迎进入鱼C影评小程序\")\n",
    "print(\"1.数据录入\")\n",
    "print(\"2.查询数据\")\n",
    "print(\"3.退出程序\")\n",
    "user_selection = int(input(\"请输入想要的功能(1,2,3)：\"))\n",
    "\n",
    "while user_selection !=3 and flag == True:\n",
    "    if user_selection == 1：\n",
    "        name.append(input(\"请输入电影名称：\"))\n",
    "        date.append(input(\"请输入上映日期：\"))\n",
    "        director.append([input(\"请输入导演名字（多人请用/分割）:\").split(\"/\")])\n",
    "        actor.append([input(\"请输入演员名字（多人请用/分割）：\").split(\"/\")])\n",
    "        score.append(input(\"请输入电影评分：\"))\n",
    "\n",
    "        continue_input = input(\"请问是否继续录入：\")\n",
    "        if continue_input == \"Y\":\n",
    "            flag = True\n",
    "        elif continue_input == \"N\":\n",
    "            flag = False\n",
    "    elif user_selection == 2:\n",
    "        movie = input(\"请输入电影名称：\")\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "while user_input == \"1\":\n",
    "    name.append(input(\"请输入电影名称：\"))\n",
    "    date.append(input(\"请输入上映日期：\"))\n",
    "    director.append([input(\"请输入导演名字（多人请用/分割）:\").split(\"/\")])\n",
    "    actor.append([input(\"请输入演员名字（多人请用/分割）：\").split(\"/\")])\n",
    "    score.append(input(\"请输入电影评分：\"))\n",
    "\n",
    "    continue_input = input(\"请问是否继续录入：\")\n",
    "\n",
    "    if continue_input == \"N\":\n",
    "        continue\n",
    "    elif continue_input == \"Y\":\n",
    "        break\n",
    "\n",
    "    \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第037讲：字典（中）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-202716-1-4.html\n",
    "#1. 请编写一个电话簿程序。\n",
    "\n",
    "\n",
    "\n",
    "#未完成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "该用户名已被注册！\n",
      "-----------------\n",
      "目前已注册的用户有：\n",
      "小甲鱼\n",
      "不二如是\n",
      "张三\n"
     ]
    }
   ],
   "source": [
    "#第038讲：字典（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-203083-1-4.html\n",
    "\n",
    "#0. 请按照要求编写一个网站的注册模块\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "我们知道，通常一个网站的用户名都是唯一的，这就要求注册的时候，系统代码可以识别当前输入的用户名是否已经存在？\n",
    "如果存在，则不允许注册！\n",
    "那么现在请大家一起来动手，编写一个网站的注册模块。\n",
    "要求：\n",
    "    用户名不允许重复\n",
    "    数据库需要保存用户名及密码\n",
    "    初始用户及密码（\"小甲鱼\":\"I_love_FishC\"，\"不二如是\":\"FishC5201314\"）\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "data = {\"小甲鱼\":\"I_love_FishC\",\"不二如是\":\"FishC5201314\"}\n",
    "\n",
    "name = input(\"请输入用户名：\")\n",
    "\n",
    "\n",
    "while True:\n",
    "    if name in data.keys():\n",
    "        print(\"该用户名已被注册！\")\n",
    "        name = input(\"请重新输入用户名：\")\n",
    "    else:\n",
    "        break\n",
    "\n",
    "secret = input(\"请输入密码：\")\n",
    "data.update([(name,secret)])\n",
    "\n",
    "print(\"-----------------\")\n",
    "\n",
    "print(\"目前已注册的用户有：\")\n",
    "for each in data:\n",
    "    print(each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "该用户名已被注册！\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "Strings must be encoded before hashing",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[5], line 38\u001b[0m\n\u001b[0;32m     34\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m     36\u001b[0m secret \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m请输入密码：\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 38\u001b[0m data[name] \u001b[38;5;241m=\u001b[39m \u001b[43mhashlib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmd5\u001b[49m\u001b[43m(\u001b[49m\u001b[43msecret\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mhexdigest()\n\u001b[0;32m     41\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m-----------------\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     43\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m目前已注册的用户有：\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: Strings must be encoded before hashing"
     ]
    }
   ],
   "source": [
    "#第038讲：字典（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-203083-1-4.html\n",
    "\n",
    "#0. 请按照要求编写一个网站的注册模块\n",
    "#1. 提升网站的安全性\n",
    "\n",
    "\"\"\"\n",
    "我们知道，通常一个网站的用户名都是唯一的，这就要求注册的时候，系统代码可以识别当前输入的用户名是否已经存在？\n",
    "如果存在，则不允许注册！\n",
    "那么现在请大家一起来动手，编写一个网站的注册模块。\n",
    "要求：\n",
    "    用户名不允许重复\n",
    "    数据库需要保存用户名及密码\n",
    "    初始用户及密码（\"小甲鱼\":\"I_love_FishC\"，\"不二如是\":\"FishC5201314\"）\n",
    "\n",
    "作为一个成熟的网站，是不可能会去保存用户的明文密码\n",
    "换句话说，用户的密码在传输到服务器数据库之前，会被单向加密为密文。\n",
    "也就是说，服务器数据库保存的是加密后的密文，而非用户的明文密码（很多鱼油密码忘了之后跑来问小甲鱼，其实我也是无能为力的……）。\n",
    "那么这里就涉及到一个单向加密的算法实现（单向加密，即仅通过密码无法逆向获得明文的加密手段），譬如 MD5 就是一种朴素的单向加密方案。\n",
    "使用 Python 如何将明文通过 MD5 加密算法生成密文呢？\n",
    "\"\"\"\n",
    "\n",
    "import hashlib\n",
    "\n",
    "data = {\"小甲鱼\":\"I_love_FishC\",\"不二如是\":\"FishC5201314\"}\n",
    "\n",
    "name = input(\"请输入用户名：\")\n",
    "\n",
    "while True:\n",
    "    if name in data.keys():\n",
    "        print(\"该用户名已被注册！\")\n",
    "        name = input(\"请重新输入用户名：\")\n",
    "    else:\n",
    "        break\n",
    "\n",
    "secret = input(\"请输入密码：\")\n",
    "\n",
    "data[name] = hashlib.md5(secret).hexdigest()\n",
    "\n",
    "\n",
    "print(\"-----------------\")\n",
    "\n",
    "print(\"目前已注册的用户有：\")\n",
    "\n",
    "for each in data:\n",
    "    print(each)\n",
    "\n",
    "\n",
    "#未完成\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "一共找到633个匹配。\n",
      "查找过程一共消耗107.32010519993491秒。\n"
     ]
    }
   ],
   "source": [
    "#第039讲：集合（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-204817-1-4.html\n",
    "#0. 请下载附件（  optimize.zip (655 Bytes, 下载次数: 1284) ），想办法优化源代码，使得程序的执行效率提高 10000 倍以上。\n",
    "\n",
    "\n",
    "import random\n",
    "import timeit\n",
    "\n",
    "haystack = [random.randint(1, 10000000) for i in range(10000000)]\n",
    "needles = [random.randint(1, 1000) for i in range(1000)]\n",
    "\n",
    "# 请在此处添加一行代码，使得查找过程的执行效率提高 10000 倍以上。\n",
    "\n",
    "def find():\n",
    "    found = 0\n",
    "    for each in needles:\n",
    "        if each in haystack:\n",
    "            found += 1\n",
    "\n",
    "    print(f\"一共找到{found}个匹配。\")\n",
    "\n",
    "t = timeit.timeit(\"find()\", setup=\"from __main__ import find\", number=1)\n",
    "print(f\"查找过程一共消耗{t}秒。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "一共找到646个匹配。\n",
      "查找过程一共消耗0.01353160000871867秒。\n"
     ]
    }
   ],
   "source": [
    "#第039讲：集合（上）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-204817-1-4.html\n",
    "#0. 请下载附件（  optimize.zip (655 Bytes, 下载次数: 1284) ），想办法优化源代码，使得程序的执行效率提高 10000 倍以上。\n",
    "\n",
    "\n",
    "import random\n",
    "import timeit\n",
    "\n",
    "haystack = [random.randint(1, 10000000) for i in range(10000000)]\n",
    "needles = [random.randint(1, 1000) for i in range(1000)]\n",
    "\n",
    "# 请在此处添加一行代码，使得查找过程的执行效率提高 10000 倍以上。\n",
    "haystack = set(haystack)\n",
    "\n",
    "def find():\n",
    "    found = 0\n",
    "    for each in needles:\n",
    "        if each in haystack:\n",
    "            found += 1\n",
    "\n",
    "    print(f\"一共找到{found}个匹配。\")\n",
    "\n",
    "t = timeit.timeit(\"find()\", setup=\"from __main__ import find\", number=1)\n",
    "print(f\"查找过程一共消耗{t}秒。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[75, 93, 62, 100, 59, 86, 73, 77, 78, 71, 81, 74, 61, 89, 52, 63, 88, 70, 50, 82]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#第040讲：集合（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-205370-1-5.html\n",
    "\n",
    "#0. 最开始的时候，Python 是没有 set() 的，那么当时伟大的程序猿是如何实现 “集合” 这个的概念呢？\n",
    "#现在我们将时间回拨到那个 “一穷二白” 年代，现在大家没有 set() 可用了，只能利用 dict() 来实现交集和并集。\n",
    "\n",
    "\"\"\"\n",
    "题目要求：\n",
    " - 生成一个随机数列表，一共有 100 个元素，每个元素取 1~100 的随机值，赋值给变量 x\n",
    " - 生成另一个随机数列表，一共有 100 个元素，每个元素取 50~150 的随机值，赋值给变量 y\n",
    "利用字典的 “键” 不会重复的特点，计算 x 和 y 的交集（就是两者共有的元素）\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "import random\n",
    "\n",
    "x = [random.randint(1,100) for i in range(100)]\n",
    "y = [random.randint(50,150) for i in range(100)]\n",
    "\n",
    "inter = dict.fromkeys([z for z in x if z in y])\n",
    "print(list(inter.keys()))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第040讲：集合（下）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-205370-1-5.html\n",
    "#1. 破解 MD5 哈希加密！！\n",
    "\"\"\"\n",
    "在前面的课后作业中（传送门），我们提到过通常服务器是不会保存用户的明文密码的（那样就太不安全了），取而代之的是存储单向哈希加密后的密文。\n",
    "不过尽管如此，也并非绝对的安全！\n",
    "虽然说单向哈希加密是无法逆向，但聪明的黑客们想出了彩虹表破解法：\n",
    "\n",
    "\"彩虹表是一个用于加密散列函数逆运算的预先计算好的表，常用于破解加密过的密码散列。彩虹表常常用于破解长度固定且包含的字符范围固定的密码（如信用卡、数字等）。这是以空间换时间的典型实践，比暴力破解（Brute-force attack）使用的时间更少，空间更多；但与储存密码空间中的每一个密码及其对应的哈希值（Hash）实现的查找表相比，其花费的时间更多，空间更少。\"\n",
    "\n",
    "密码及其对应的哈希值（Hash）实现的查找表相比，其花费的时间更多，空间更少。\n",
    "说人话就是：所谓的彩虹表，其实就是将所有可能的字符串组合都给预先哈希一遍，然后将映射结果保存起来，当黑客拿到一个哈希值时，通过查表的方式获取密码明文。\n",
    "虽然密码安全宣传多年来都有在开展，但还是难以阻止使用出生日期等 6 位数字的人们，这一次，我们就用实际行动告诉大家，6 位数字的哈希密码有多容易被破解……\n",
    "\n",
    "题目要求：\n",
    "\n",
    "生成 0~999999 所有整数组成密码的哈希值\n",
    "将上面生成的哈希值保存为映射类型\n",
    "通过查表的方式，计算下面 3 个哈希值对应的明文密码\n",
    "021bbc7ee20b71134d53e20206bd6feb\n",
    "e10adc3949ba59abbe56e057f20f883e\n",
    "655d03ed12927aada3d5bd1f90f06eb7\n",
    "\n",
    "友情提示：\n",
    "hashlib.md5() 的参数是需要一个 b 字符串（即 bytes 类型的对象），这里可以使用 bytes(\"123\", \"utf-8\") 的方式将 \"123\" 转换为 b\"123\"。\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "import hashlib\n",
    "\n",
    "\n",
    "rain_bow_table = {}\n",
    "\n",
    "for i in range(999999):\n",
    "    bstr = bytes(str(i),\"utf-8\")\n",
    "    s = hashlib.md5(bstr).hexdigest()\n",
    "    rain_bow_table[s] = i\n",
    "\n",
    "\n",
    "print(rain_bow_table)\n",
    "\n",
    "s1 = \"021bbc7ee20b71134d53e20206bd6feb\"\n",
    "s2 = \"e10adc3949ba59abbe56e057f20f883e\"\n",
    "s3 = \"655d03ed12927aada3d5bd1f90f06eb7\"\n",
    "\n",
    "\n",
    "print(f\"{s1}对应的明文是：{rain_bow_table[s1]}\")\n",
    "print(f\"{s2}对应的明文是：{rain_bow_table[s2]}\")\n",
    "print(f\"{s3}对应的明文是：{rain_bow_table[s3]}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function\n",
    "\n",
    "def myfuntion():\n",
    "    pass\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第041讲：函数（I）| 课后测试题及答案\n",
    "#https://fishc.com.cn/forum.php?mod=viewthread&tid=206416\n",
    "#0. 请编写一个实现【注册】和【登陆】功能的代码，这次要求将不同的功能封装成独立的函数。\n",
    "\n",
    "\"\"\"\n",
    "程序要求如下：\n",
    " - 编写 4 个函数分别用于获取用户指令（get_int()）、注册（register()）、登陆（login()）、MD5加密（encrypt()）\n",
    " - 使用一个 Python 的字典作为数据库。\n",
    " - 注册时需验证用户名是否已存在于数据库\n",
    " - 登陆时需验证用户名和密码是否匹配\n",
    " - 密码保存需使用 MD5 加密\n",
    "\n",
    "题目要求：请先分别画出程序主结构、注册函数和登陆函数的流程图，再编写实现代码。\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "#未完成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "强国中属中国强 是拼音回文！\n"
     ]
    }
   ],
   "source": [
    "#第042讲：函数（II）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-206751-1-5.html\n",
    "\n",
    "#0. 检测输入的中文字符串是否符合回文的语法，这个前面大家已经做过练习了，不过这一次我们将要放宽，只要该字的拼音一样，字不相同没有关系，比如 “前任只认钱” 可以符合要求。\n",
    "\n",
    "\"\"\"\n",
    "提示一：放宽要求后，只要文字的发音构成前后回文，即认定为符合要求。\n",
    "提示二：将汉字转换为对应拼音的方法 -> https://fishc.com.cn/thread-213439-1-1.html\n",
    "提示三：请将各个独立的功能封装为函数。\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "from xpinyin import Pinyin\n",
    "p = Pinyin()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def pinyin_huiwen(text):\n",
    "    if p.get_pinyin(text,\" \").split() == p.get_pinyin(text,\" \").split()[::-1]:\n",
    "        print(text,\"是拼音回文！\")\n",
    "    else:\n",
    "        print(text,\"不是拼音回文！\")\n",
    "\n",
    "\n",
    "pinyin_huiwen(\"强国中属中国强\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第042讲：函数（II）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-206751-1-5.html\n",
    "#1. 利用函数模拟创建【栈】的数据结构操作。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第043讲：函数（III）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-207160-1-5.html\n",
    "\n",
    "\"\"\"\n",
    "罗马数字包含 I、V、X、L、C、D、M 七种字符，分别表示数值 1、5、10、50、100、500、1000。\n",
    "将数字 2 写做罗马字符的形式是 II（即 I + I），数字 12 写做 XII（即 X + I + I），27 写做 XXVII（即 X + X + V + I + I），这就有点像咱平时上市场买菜给钱的算法（一颗大白菜 27 元，那么就给两张10元，一张5元和两张1元这样的组合）。\n",
    "罗马字符的组合也存在一些特殊规则，比如 4 不写做 IIII，而是 IV（即 I 在 V 的左边，表示 5 - 1，因此得到数字 4），类似的特例如下：\n",
    " - I 可以放在 V（5）和 X（10）的左边，表示 4 和 9\n",
    " - X 可以放在 L（50）和 C（100）的左边，表示 40 和 90\n",
    " - C 可以放在 D（500）和 M（1000）的左边，表示 400 和 900\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "#0. 题目要求：编写一个函数，将指定的罗马字符转换为数字的形式。\n",
    "#1. 题目要求：编写一个函数，将指定的数字转换为罗马字符的形式。\n",
    "\n",
    "\n",
    "#未完成\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第044讲：函数（IV）| 课后测试题及答案\n",
    "\n",
    "#https://fishc.com.cn/thread-207298-1-5.html\n",
    "\n",
    "\"\"\"\n",
    "不知道大家有没有听说过洗牌算法 —— Fisher-Yates\n",
    "下面，小甲鱼大概花三分钟的时间给大家讲一下这个洗牌算法。\n",
    "所谓洗牌算法，就是将一组数据打乱的算法，比如像 random 模块中的 shuffle 函数做的就是这么一个事儿。\n",
    "Fisher-Yates 就是洗牌算法中的其中一种，它的原始版本，最初描述在 1938 年的 Ronald Fisher 和 Frank Yates 写的书中（《Statistical tables for biological, agricultural and medical research》）。\n",
    "对于该算法的实现描述如下（假设需要打乱 N 个数）：\n",
    "1.写下从 1 到 N 的数字\n",
    "2.获取一个 1 到剩下数字（包括这个数字）的随机数 k\n",
    "3.从低位开始，取出第 k 个数字（这个数字还没有被取出），把它写在独立的一个列表的最后一位\n",
    "4.重复前两个步骤，直到所有数据都被取出\n",
    "5.现在，新的列表中就是打乱了顺序的结果\n",
    "好了，基本教学到这里就结束了，开始做题！\n",
    "\"\"\"\n",
    "\n",
    "#0. 请封装一个 fy_shuffle() 函数\n",
    "\n",
    "#参数1：可迭代对象类型，存储原始的数据\n",
    "#参数2：整数类型，指定洗牌的次数\n",
    "#返回值：列表类型，存储打乱后的数据\n",
    "#要求：请按 Fisher-Yates 要求的算法步骤实现。\n",
    "\n",
    "#1. 运用上面的打乱算法，设计一个 “斗地主” 的发牌程序\n",
    "\"\"\"\n",
    "游戏介绍：\n",
    "斗地主游戏由 54 张牌组成，包含两张 Joker 牌（大王和小王），游戏人数一般为三人，一人为地主，另外两人为农民。双方出牌对战，地主先出牌，任何一方有一人出完牌时，该方获胜。\n",
    "发牌规则：\n",
    "每人先发 17 张牌，留 3 张作为地主牌，再随机选择 1 名地主，将地主牌给到他。\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "def fy_shuffle(text,times):\n",
    "\n",
    "\n",
    "\n",
    "#未完成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第045讲：函数（V）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-207568-1-5.html\n",
    "\n",
    "#0. 请设计一个函数，每次调用传入一个参数，并返回所有参数的平均值。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第045讲：函数（V）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-207568-1-5.html\n",
    "\n",
    "#1. 请设计一个闭包函数，它的功能是每次调用返回一个斐波那契数列。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫大肠，今年5岁。\n",
      "我的技能是拱大白菜~\n",
      "风口来了，猪都能飞~\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def say(self):\n",
    "        print(f\"我叫{self.name}，今年{self.age}岁。\")\n",
    "\n",
    "class FlyMixin(Animal):\n",
    "    def fly(self):\n",
    "        print(f\"风口来了，猪都能飞~\")\n",
    "\n",
    "\n",
    "#class Pig(Animal,FlyMixin):\n",
    "class Pig(FlyMixin,Animal):\n",
    "    def special(self):\n",
    "        print(\"我的技能是拱大白菜~\")\n",
    "\n",
    "p = Pig(\"大肠\",5)\n",
    "p.say()\n",
    "\n",
    "p.special()\n",
    "p.fly()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正方形\n",
      "圆\n",
      "三角形\n",
      "16\n",
      "78.5\n",
      "10.0\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "class Square(Shape):\n",
    "    def __init__(self,length):\n",
    "        super().__init__(\"正方形\")\n",
    "        self.length = length\n",
    "    def area(self):\n",
    "        return self.length * self.length\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self,radius):\n",
    "        super().__init__(\"圆\")\n",
    "        self.radius = radius\n",
    "    def area(self):\n",
    "        return 3.14*self.radius * self.radius\n",
    "\n",
    "class Triangle(Shape):\n",
    "    def __init__(self,base,height):\n",
    "        super().__init__(\"三角形\")\n",
    "        self.base = base\n",
    "        self.height = height\n",
    "    def area(self):\n",
    "        return self.base * self.height / 2\n",
    "\n",
    "s = Square(4)\n",
    "c = Circle(5)\n",
    "t = Triangle(4,5)\n",
    "\n",
    "print(s.name)\n",
    "print(c.name)\n",
    "print(t.name)\n",
    "\n",
    "print(s.area())\n",
    "print(c.area())\n",
    "print(t.area())\n",
    "\n",
    "\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我是一只凯迪猫，我叫Web，今年4岁。\n",
      "mua~\n",
      "None\n",
      "我是一只奶狗，我叫布布，今年7岁。\n",
      "yahoo~\n",
      "None\n",
      "我是一只忙碌猪，我叫九转肥肠，今年3岁。\n",
      "Oink~\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class Cat:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def intro(self):\n",
    "        print(f\"我是一只凯迪猫，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"mua~\")\n",
    "\n",
    "class Dog:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def intro(self):\n",
    "        print(f\"我是一只奶狗，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"yahoo~\")\n",
    "\n",
    "class Pig:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def intro(self):\n",
    "        print(f\"我是一只忙碌猪，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"Oink~\")\n",
    "\n",
    "c = Cat(\"Web\",4)\n",
    "d = Dog(\"布布\",7)\n",
    "p = Pig(\"九转肥肠\",3)\n",
    "\n",
    "def animal(x):\n",
    "    x.intro()\n",
    "    x.say()\n",
    "\n",
    "print(animal(c))\n",
    "print(animal(d))\n",
    "print(animal(p))\n",
    "\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我是一只凯迪猫，我叫Web，今年4岁。\n",
      "mua~\n",
      "None\n",
      "我是一只奶狗，我叫布布，今年7岁。\n",
      "yahoo~\n",
      "None\n",
      "我是一只忙碌猪，我叫九转肥肠，今年3岁。\n",
      "Oink~\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "from abc import ABCMeta,abstractmethod\n",
    "\n",
    "class Animal(metaclass=ABCMeta):\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    @abstractmethod\n",
    "    def intro(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def say(self):\n",
    "        pass\n",
    "\n",
    "class Cat(Animal):\n",
    "    def intro(self):\n",
    "        print(f\"我是一只凯迪猫，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"mua~\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def intro(self):\n",
    "        print(f\"我是一只奶狗，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"yahoo~\")\n",
    "\n",
    "class Pig(Animal):\n",
    "\n",
    "    def intro(self):\n",
    "        print(f\"我是一只忙碌猪，我叫{self.name}，今年{self.age}岁。\")\n",
    "    def say(self):\n",
    "        print(\"Oink~\")\n",
    "\n",
    "c = Cat(\"Web\",4)\n",
    "d = Dog(\"布布\",7)\n",
    "p = Pig(\"九转肥肠\",3)\n",
    "\n",
    "\n",
    "def animal(x):\n",
    "    x.intro()\n",
    "    x.say()\n",
    "\n",
    "print(animal(c))\n",
    "print(animal(d))\n",
    "print(animal(p))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "金灿灿说：我叫金灿灿，我今年8岁啦，我有130cm高，现在读3年级。\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "class People:\n",
    "    name = \"\"\n",
    "    age = 0\n",
    "    __weight = 0\n",
    "    def __init__(self,n,a,w):\n",
    "        self.name = n\n",
    "        self.age = a\n",
    "        self.weight = w\n",
    "\n",
    "    def speak(self):\n",
    "        print(f\"{self.name}说：我叫{self.name}，我今年{self.age}岁啦，我有{self.weight}cm高。\")\n",
    "\n",
    "class Student(People):\n",
    "    grade = \"\"\n",
    "\n",
    "    def __init__(self,n,a,w,g):\n",
    "        People.__init__(self,n,a,w)\n",
    "        self.grade = g\n",
    "\n",
    "    def speak(self):\n",
    "        print(f\"{self.name}说：我叫{self.name}，我今年{self.age}岁啦，我有{self.weight}cm高，现在读{self.grade}年级。\")\n",
    "\n",
    "\n",
    "class Speaker():\n",
    "    topic = \"\"\n",
    "    name = \"\"\n",
    "    def __init__(self,n,t):\n",
    "        self.name = n\n",
    "        self.topic = t\n",
    "\n",
    "    def speak(self):\n",
    "        print(f\"{self.name}说：我今天演讲的主题是{self.topic}。\")\n",
    "\n",
    "\n",
    "\n",
    "s1 = Student(\"金灿灿\",8,130,3)\n",
    "\n",
    "print(s1.speak())\n",
    "              \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#第060讲：类和对象（III）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-213592-1-6.html\n",
    "\n",
    "#0. 请帮开餐馆的小花开发一个点餐程序，要求如下。\n",
    "\n",
    "\"\"\"\n",
    "菜品种类如下：\n",
    "1.洋葱炒牛肉（1 份洋葱、1 份牛肉）\n",
    "2.洋葱炒羊肉（1 份洋葱、1 份羊肉）\n",
    "3.煎蛋（2 份蛋）\n",
    "4.番茄炒蛋（2 份番茄、3 份蛋）\n",
    "5.土豆萝卜炖羊肉（2 份土豆、1份萝卜、2 份羊肉）\n",
    "\n",
    "肉类价格：\n",
    " - 鸡蛋：1 元 1 份\n",
    " - 牛肉：25 元 1 份\n",
    " - 羊肉：30 元 1 份\n",
    "\n",
    "菜类价格：\n",
    " - 洋葱：2 元 1 份\n",
    " - 番茄：2 元 1 份\n",
    " - 土豆：3 元 1 份\n",
    " - 萝卜：3 元 1 份\n",
    "\n",
    "题目要求：\n",
    " - Memu 类用于实例化菜单\n",
    " - Memu 类需要有 order() 方法，用于点菜\n",
    " - Memu 类需要有 pay() 方法，用于统计最终价格\n",
    " - 需要考虑同时点多个菜品的需求\n",
    " - 需要考虑一个菜品点多次的需求\n",
    "\n",
    "程序实现如下（考虑同时点多个菜品的需求）：\n",
    "\"\"\"\n",
    "\n",
    "class Meet:\n",
    "    nums = 0\n",
    "\n",
    "class Egg(Meet):\n",
    "    name = \"鸡蛋\"\n",
    "    price = 1\n",
    "\n",
    "class Beef(Meet):\n",
    "    name = \"牛肉\"\n",
    "    price = 25\n",
    "\n",
    "class Mutoon(Meet):\n",
    "    name = \"羊肉\"\n",
    "    price = 30\n",
    "\n",
    "class Vegetable:\n",
    "    nums = 0\n",
    "\n",
    "class Onion(Vegetable):\n",
    "    name = \"洋葱\"\n",
    "    price = 2\n",
    "\n",
    "class Tomato(Vegetable):\n",
    "    name = \"番茄\"\n",
    "    price = 2\n",
    "\n",
    "class Potato(Vegetable):\n",
    "    name = \"土豆\"\n",
    "    price = 3\n",
    "\n",
    "class Radish(Vegetable):\n",
    "    name = \"萝卜\"\n",
    "    price = 3\n",
    "\n",
    "class Menu:\n",
    "    def order(self)\n",
    "        \n",
    "\n",
    "\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        self.menu = {\n",
    "            '1': {'name': '洋葱炒牛肉', 'price': 25, 'count': 0},\n",
    "            '2': {'name': '洋葱炒羊肉', 'price': 30, 'count': 0},\n",
    "            '3': {'name': '煎蛋', 'price': 1, 'count': 0},\n",
    "            '4': {'name': '番茄炒蛋', 'price': 5, 'count': 0},\n",
    "            '5': {'name': '土豆萝卜炖羊肉', 'price': 30, 'count': 0},\n",
    "        } \n",
    "\n",
    "\n",
    "    def order(self):\n",
    "        if name in self.menu:\n",
    "            self.menu[name]['count'] += count\n",
    "        else:\n",
    "            print('没有这个菜品')\n",
    "\n",
    "    def pay(self):\n",
    "        total = 0\n",
    "        for item in self.menu.values():\n",
    "            total += item['price'] * item['count']\n",
    "        return total\n",
    "    \n",
    "menu = Menu() \n",
    "\n",
    "\n",
    "\n",
    "#未完成\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "0\n",
      "ZeroDivisionError\n",
      "None\n",
      "14\n",
      "6\n",
      "40\n",
      "2.5\n"
     ]
    }
   ],
   "source": [
    "#https://fishc.com.cn/thread-213949-1-6.html\n",
    "#构造函数（__init__(self[, ...])）\n",
    "\n",
    "class C:\n",
    "    def __init__(self,x,y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    def add(self):\n",
    "        return self.x + self.y\n",
    "    def minus(self):\n",
    "        return self.x - self.y\n",
    "    def mul(self):\n",
    "        return self.x * self.y\n",
    "    def div(self):\n",
    "        try:\n",
    "            return self.x / self.y\n",
    "        except ZeroDivisionError:\n",
    "            print(\"ZeroDivisionError\")\n",
    "\n",
    "c = C(10,0)\n",
    "\n",
    "print(c.add())\n",
    "print(c.minus())\n",
    "print(c.mul())\n",
    "print(c.div())\n",
    "\n",
    "\n",
    "#重写\n",
    "\n",
    "class D(C):\n",
    "    def __init__(self,x,y,z):\n",
    "        C.__init__(self,x,y)\n",
    "        self.z = z\n",
    "    \n",
    "    def add(self):\n",
    "        return self.x + self.y + self.z\n",
    "    \n",
    "    def minus(self):\n",
    "        return self.x - self.y - self.z\n",
    "    \n",
    "    def mul(self):\n",
    "        return self.x * self.y * self.z\n",
    "    def div(self):\n",
    "        try:\n",
    "            return self.x / self.y / self.z\n",
    "        except ZeroDivisionError:\n",
    "            print(\"ZeroDivisionError\")\n",
    "\n",
    "d = D(10,2,2)\n",
    "\n",
    "print(d.add())\n",
    "print(d.minus())\n",
    "print(d.mul())\n",
    "print(d.div())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我是A\n",
      "我是B1\n",
      "我是A\n",
      "我是B2\n",
      "我是C\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第061讲：类和对象（IV）\n",
    "#https://fishc.com.cn/thread-213949-1-6.html\n",
    "#钻石继承\n",
    "\n",
    "class A:\n",
    "    def __init__(self):\n",
    "        print(\"我是A\")\n",
    "\n",
    "class B1(A):\n",
    "    def __init__(self):\n",
    "        A.__init__(self)\n",
    "        print(\"我是B1\")\n",
    "\n",
    "class B2(A):\n",
    "    def __init__(self):\n",
    "        A.__init__(self)\n",
    "        print(\"我是B2\")\n",
    "\n",
    "class C(B1,B2):\n",
    "    def __init__(self):\n",
    "        B1.__init__(self)\n",
    "        B2.__init__(self)\n",
    "        print(\"我是C\")\n",
    "\n",
    "c = C()\n",
    "\n",
    "#print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我是A\n",
      "我是B2\n",
      "我是B1\n",
      "我是C\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[__main__.C, __main__.B1, __main__.B2, __main__.A, object]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[知识点备忘] 第061讲：类和对象（IV）\n",
    "#https://fishc.com.cn/thread-213949-1-6.html\n",
    "#super()函数\n",
    "\n",
    "class A:\n",
    "    def __init__(self):\n",
    "        print(\"我是A\")\n",
    "\n",
    "class B1(A):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        print(\"我是B1\")\n",
    "\n",
    "class B2(A):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        print(\"我是B2\")\n",
    "\n",
    "class C(B1,B2):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        print(\"我是C\")\n",
    "\n",
    "c = C()\n",
    "C.mro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "class C:\n",
    "    x = []\n",
    "    def add_x(self, x):\n",
    "        self.x.append(x)\n",
    "\n",
    "c = C()\n",
    "c.add_x(1)\n",
    "c.add_x(2)\n",
    "c.add_x(3)\n",
    "print(c.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    x=250\n",
    "\n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(B):\n",
    "    pass\n",
    "\n",
    "class D:\n",
    "    x=520\n",
    "\n",
    "class E(C,D):\n",
    "    pass\n",
    "\n",
    "print(E.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "301\n",
      "[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    x = 250\n",
    "    def add_x(self):\n",
    "        self.x += 1\n",
    "\n",
    "class B(A):\n",
    "    x = 300\n",
    "    def add_x(self):\n",
    "        A.add_x(self)\n",
    "\n",
    "class C(A):\n",
    "    x = 500\n",
    "    def add_x(self):\n",
    "        A.add_x(self)\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "d = D()\n",
    "d.add_x()\n",
    "\n",
    "print(d.x)\n",
    "print(D.mro())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "301\n",
      "[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    x = 250\n",
    "    def add_x(self):\n",
    "        self.x += 1\n",
    "\n",
    "class B(A):\n",
    "    x = 300\n",
    "    def add_x(self):\n",
    "        #A.add_x(self)\n",
    "        super().add_x()\n",
    "\n",
    "class C(A):\n",
    "    x = 500\n",
    "    def add_x(self):\n",
    "        #A.add_x(self)\n",
    "        super().add_x()\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "d = D()\n",
    "d.add_x()\n",
    "\n",
    "print(d.x)\n",
    "print(D.mro())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]\n",
      "A ping\n",
      "B pong\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def ping(self):\n",
    "        print(\"A ping\")\n",
    "\n",
    "class B(A):\n",
    "    def pong(self):\n",
    "        print(\"B pong\")\n",
    "\n",
    "class C(A):\n",
    "    def pong(self):\n",
    "        print(\"C pong\")\n",
    "\n",
    "class D(B,C):\n",
    "    def pingpong(self):\n",
    "        self.ping()\n",
    "        self.pong()\n",
    "\n",
    "d = D()\n",
    "\n",
    "print(D.mro())\n",
    "\n",
    "print(d.pingpong())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫大肠，今年3岁。\n",
      "我的技能是拱大白菜！\n",
      "我叫大肠，今年2岁。\n",
      "我的技能是拱大白菜！\n",
      "我的技能是飞！\n"
     ]
    }
   ],
   "source": [
    "#[知识点备忘] 第062讲：类和对象（V）\n",
    "#https://fishc.com.cn/thread-214130-1-6.html\n",
    "#Mix-in\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    def say(self):\n",
    "        print(f\"我叫{self.name}，今年{self.age}岁。\")\n",
    "\n",
    "class Pig(Animal):\n",
    "    def special(self):\n",
    "        print(\"我的技能是拱大白菜！\")\n",
    "\n",
    "p = Pig(\"大肠\", 3)\n",
    "p.say()\n",
    "p.special()\n",
    "\n",
    "class FlyMixin:\n",
    "    def fly(self):\n",
    "        print(\"我的技能是飞！\")\n",
    "\n",
    "class Pig(FlyMixin, Animal):\n",
    "    def special(self):\n",
    "        print(\"我的技能是拱大白菜！\")\n",
    "\n",
    "p = Pig(\"大肠\", 2)\n",
    "p.say()\n",
    "p.special()\n",
    "p.fly()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.C'>, <class '__main__.B1'>, <class '__main__.A'>, <class '__main__.B2'>, <class 'object'>)\n",
      "Hi from B2\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def say_hi(self):\n",
    "        print(\"Hi from A\")\n",
    "\n",
    "    def say(self):\n",
    "        super().say_hi()\n",
    "\n",
    "class B1(A):\n",
    "    def say_hi(self):\n",
    "        print(\"Hi from B1\")\n",
    "    \n",
    "    def say(self):\n",
    "        super().say()\n",
    "\n",
    "class B2:\n",
    "    def say_hi(self):\n",
    "        print(\"Hi from B2\")\n",
    "    \n",
    "    def say(self):\n",
    "        super().say()\n",
    "    \n",
    "class C(B1,B2):\n",
    "    def say(self):\n",
    "        super().say()\n",
    "\n",
    "c = C()\n",
    "print(C.__mro__)\n",
    "c.say()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class '__main__.D'>, <class '__main__.B'>, <class 'object'>)\n",
      "FishA\n",
      "FishC\n",
      "FishE\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def say(self):\n",
    "        print(\"FishA\")\n",
    "\n",
    "class B:\n",
    "    def say(self):\n",
    "        print(\"FishB\")\n",
    "\n",
    "class C(A):\n",
    "    def say(self):\n",
    "        super().say()\n",
    "        print(\"FishC\")\n",
    "\n",
    "class D(B):\n",
    "    def say(self):\n",
    "        super().say()\n",
    "        print(\"FishD\")\n",
    "\n",
    "class E(C,D):\n",
    "    def say(self):\n",
    "        super().say()\n",
    "        print(\"FishE\")\n",
    "\n",
    "e = E()\n",
    "print(E.__mro__)\n",
    "e.say()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#[课后作业] 第062讲：类和对象（V）| 课后测试题及答案\n",
    "#https://fishc.com.cn/thread-214131-1-6.html\n",
    "#动动手：\n",
    "##0. 这次要求大家编写一个鱼C超市会员管理系统。\n",
    "\"\"\"\n",
    "程序功能要求如下：\n",
    "1. 会员开卡\n",
    "    会员开卡自动赋予一个新的卡号（默认从 10000 开始递增）\n",
    "    要求输入用户名和密码\n",
    "    密码要求长度不低于 6 位\n",
    "\n",
    "2. 修改密码\n",
    "    先确认输入卡号是否存在\n",
    "    再判断旧密码是否正确\n",
    "    新密码长度同样不能低于 6 位\n",
    "\n",
    "3. 商品支付\n",
    "    先确认输入卡号是否存在\n",
    "    再判断密码是否正确\n",
    "    根据输入的消费金额增加会员卡积分（比如输入 250 消费金额，那么积分增加 250）\n",
    "\n",
    "4. 积分查询\n",
    "    先确认输入卡号是否存在\n",
    "    再判断密码是否正确\n",
    "\n",
    "代码要求：\n",
    "1. 创建一个会员类（Member），包含信息：卡号、用户名、密码（要求密码需要以 MD5 哈希值的形式存储）、积分、注册日期\n",
    "2. 创建一个管理类（Manage），用于实现上方要求的主要程序功能\n",
    "3. 创建一个 Mixin 类（PasswdMixin），用于实现密码相关的功能组件（密码长度检测和将明文密码转换为 MD5 的操作）\n",
    "4. 创建一个 Mixin 类（LoggerMixin），用于实现日志记录相关的功能组件\n",
    "\"\"\"\n",
    "\n",
    "# 作者：小甲鱼\n",
    "# 来源：https://fishc.com.cn/thread-214131-1-1.html\n",
    "# 本代码著作权归作者所有，禁止商业或非商业转载，仅供个人学习使用，违者必究！\n",
    "# Copyright (c) fishc.com.cn All rights reserved\n",
    "\n",
    "import time\n",
    "import hashlib\n",
    "\n",
    "# 会员类：记录会员的关键信息\n",
    "class Member:\n",
    "    def __init__(self, cardid, name, passwd, scores, regdate):\n",
    "        self.cardid = cardid\n",
    "        self.name = name\n",
    "        self.passwd = passwd\n",
    "        self.scores = scores\n",
    "        self.regdate = regdate\n",
    "\n",
    "\n",
    "# Mixin类：密码相关的功能组件\n",
    "class PasswdMixin:\n",
    "    # 密码长度检测\n",
    "    def is_tooshort(self, passwd, require=6):\n",
    "        while len(passwd) < require:\n",
    "            passwd = input(\"会员密码不能小于6位，请重新输入：\")\n",
    "        return passwd\n",
    "\n",
    "    # 将明文密码转换为MD5\n",
    "    def to_md5(self, passwd):\n",
    "        bstr = bytes(passwd, \"utf-8\")\n",
    "        passwd = hashlib.md5(bstr).hexdigest()\n",
    "        return passwd\n",
    "\n",
    "\n",
    "# Mixin类：日志记录相关的功能组件\n",
    "class LoggerMixin:\n",
    "    def log(self, message, filename=\"log.txt\"):\n",
    "        with open(filename, \"a\") as f:\n",
    "            f.write(message)\n",
    "\n",
    "    \n",
    "# 管理类：所有功能的实现    \n",
    "class Manage(PasswdMixin, LoggerMixin):\n",
    "    def __init__(self):\n",
    "        self.members = {}\n",
    "        self.cardid = 10000\n",
    "\n",
    "    # 程序功能入口\n",
    "    def welcome(self):\n",
    "        ins = 0\n",
    "        print(\"欢迎使用鱼C超市会员管理系统\")\n",
    "        while ins != '5':\n",
    "            ins = input(\"\\n1.创建新卡;2.修改密码;3.商品支付;4.积分查询;5.退出程序：\")\n",
    "            if ins == '1':\n",
    "                self.create_member()\n",
    "            if ins == '2':\n",
    "                self.modify_passwd()\n",
    "            if ins == '3':\n",
    "                self.pay_money()\n",
    "            if ins == '4':\n",
    "                self.view_scores()\n",
    "            if ins == '5':\n",
    "                print(\"感谢使用鱼C超市会员管理系统\")\n",
    "\n",
    "    # 确认卡号及密码是否匹配            \n",
    "    def confirm_passwd(self):\n",
    "        cardid = int(input(\"请输入卡号：\"))\n",
    "        while not self.members.get(cardid):\n",
    "            cardid = int(input(\"该卡号不存在，请重新输入：\"))\n",
    "            \n",
    "        passwd = input(\"请输入密码：\")\n",
    "        passwd = self.to_md5(passwd)\n",
    "        while not self.members.get(cardid).passwd == passwd:\n",
    "            passwd = input(\"密码不正确，请重新输入：\")\n",
    "            passwd = self.to_md5(passwd)\n",
    "\n",
    "        return cardid\n",
    "\n",
    "    # 程序功能：创建新卡\n",
    "    def create_member(self):\n",
    "        name = input(\"请输入名字：\")\n",
    "        passwd = input(\"请输入密码：\")\n",
    "        passwd = self.is_tooshort(passwd)\n",
    "        passwd = self.to_md5(passwd)\n",
    "        scores = 0\n",
    "        regdate = time.localtime()\n",
    "        member = Member(self.cardid, name, passwd, scores, regdate)\n",
    "        self.members[self.cardid] = member\n",
    "        print(f\"创建成功，卡号为 {self.cardid}，关联用户 -> {name}\")\n",
    "        self.log(f\"开卡成功：{self.cardid} -> {name}，时间：{time.strftime('%Y-%m-%d %H:%M:%S', regdate)}\\n\")\n",
    "        self.cardid += 1\n",
    "\n",
    "    # 程序功能：修改密码\n",
    "    def modify_passwd(self):        \n",
    "        cardid = self.confirm_passwd()\n",
    "        newpasswd = input(\"请输入新密码：\")\n",
    "        newpasswd = self.is_tooshort(newpasswd)\n",
    "        newpasswd = self.to_md5(newpasswd)\n",
    "        self.members[cardid].passwd = newpasswd\n",
    "        self.log(f\"修改密码：卡号 -> {self.cardid}，时间：{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}\\n\")\n",
    "        print(\"密码修改成功。\")\n",
    "\n",
    "    # 程序功能：商品支付\n",
    "    def pay_money(self):\n",
    "        cardid = self.confirm_passwd()\n",
    "        money = int(input(\"请输入支付金额：\"))\n",
    "        self.members[cardid].scores += money\n",
    "        self.log(f\"积分累计：卡号 -> {self.cardid}，+{money}分，时间：{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}\\n\")\n",
    "\n",
    "    # 程序功能：积分查询\n",
    "    def view_scores(self):\n",
    "        cardid = self.confirm_passwd()\n",
    "        print(f\"卡号 {cardid} 当前的消费积分为：{self.members[cardid].scores}\")\n",
    "\n",
    "\n",
    "def main():\n",
    "    m = Manage()\n",
    "    m.welcome()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23:59:58\n",
      "23:59:59\n",
      "00:00:00\n",
      "00:00:01\n",
      "00:00:02\n",
      "00:00:03\n",
      "00:00:04\n",
      "00:00:05\n",
      "00:00:06\n",
      "00:00:07\n",
      "00:00:08\n",
      "00:00:09\n",
      "00:00:10\n",
      "00:00:11\n",
      "00:00:12\n",
      "00:00:13\n",
      "00:00:14\n",
      "00:00:15\n",
      "00:00:16\n",
      "00:00:17\n",
      "00:00:18\n",
      "00:00:19\n",
      "00:00:20\n",
      "00:00:21\n",
      "00:00:22\n",
      "00:00:23\n",
      "00:00:24\n",
      "00:00:25\n",
      "00:00:26\n",
      "00:00:27\n",
      "00:00:28\n",
      "00:00:29\n",
      "00:00:30\n",
      "00:00:31\n",
      "00:00:32\n",
      "00:00:33\n",
      "00:00:34\n",
      "00:00:35\n",
      "00:00:36\n",
      "00:00:37\n",
      "00:00:38\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[47], line 45\u001b[0m\n\u001b[0;32m     41\u001b[0m         clock\u001b[38;5;241m.\u001b[39mrun()\n\u001b[0;32m     44\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m---> 45\u001b[0m     \u001b[43mmain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[1;32mIn[47], line 40\u001b[0m, in \u001b[0;36mmain\u001b[1;34m()\u001b[0m\n\u001b[0;32m     38\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m     39\u001b[0m     \u001b[38;5;28mprint\u001b[39m(clock\u001b[38;5;241m.\u001b[39mshow())\n\u001b[1;32m---> 40\u001b[0m     \u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     41\u001b[0m     clock\u001b[38;5;241m.\u001b[39mrun()\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from time import sleep\n",
    "\n",
    "\n",
    "class Clock(object):\n",
    "    \"\"\"数字时钟\"\"\"\n",
    "\n",
    "    def __init__(self, hour=0, minute=0, second=0):\n",
    "        \"\"\"初始化方法\n",
    "\n",
    "        :param hour: 时\n",
    "        :param minute: 分\n",
    "        :param second: 秒\n",
    "        \"\"\"\n",
    "        self._hour = hour\n",
    "        self._minute = minute\n",
    "        self._second = second\n",
    "\n",
    "    def run(self):\n",
    "        \"\"\"走字\"\"\"\n",
    "        self._second += 1\n",
    "        if self._second == 60:\n",
    "            self._second = 0\n",
    "            self._minute += 1\n",
    "            if self._minute == 60:\n",
    "                self._minute = 0\n",
    "                self._hour += 1\n",
    "                if self._hour == 24:\n",
    "                    self._hour = 0\n",
    "\n",
    "    def show(self):\n",
    "        \"\"\"显示时间\"\"\"\n",
    "        return '%02d:%02d:%02d' % \\\n",
    "               (self._hour, self._minute, self._second)\n",
    "\n",
    "\n",
    "def main():\n",
    "    clock = Clock(23, 59, 58)\n",
    "    while True:\n",
    "        print(clock.show())\n",
    "        sleep(1)\n",
    "        clock.run()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}