From 0e26f2084ee3be24288cb1433ce6139b9baae210 Mon Sep 17 00:00:00 2001 From: Zengyan <487339041@qq.com> Date: Sat, 26 Mar 2022 10:15:09 +0000 Subject: [PATCH 1/2] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- homework-python.ipynb | 1076 +++++++++++++++++++++++++++++++++++++++++ name.txt | 2 + 2 files changed, 1078 insertions(+) create mode 100644 homework-python.ipynb create mode 100644 name.txt diff --git a/homework-python.ipynb b/homework-python.ipynb new file mode 100644 index 0000000..4a2340a --- /dev/null +++ b/homework-python.ipynb @@ -0,0 +1,1076 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b2535f92", + "metadata": {}, + "source": [ + "Homework_python" + ] + }, + { + "cell_type": "markdown", + "id": "354df0f8", + "metadata": {}, + "source": [ + "学号：2021100204\n", + "姓名：曾延" + ] + }, + { + "cell_type": "markdown", + "id": "c3ac5cce", + "metadata": { + "scrolled": false + }, + "source": [ + "1. 字符串\n", + "给定一个文章，找出每个单词的出现次数。例如给定下面的一篇短文，进行操作。\n", + "One is always on a strange road, watching strange scenery and listening to strange music. \n", + "Then one day, you will find that the things you try hard to forget are already gone. " + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "a55ada57", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入您想要查找单词出现次数的短文：One is always on a strange road, watching strange scenery and listening to strange music. Then one day, you will find that the things you try hard to forget are already gone.One is always on a strange road, watching strange scenery and listening to strange music. Then one day, you will find that the things you try hard to forget are already gone.\n", + "['one', 'is', 'always', 'on', 'a', 'strange', 'road,', 'watching', 'strange', 'scenery', 'and', 'listening', 'to', 'strange', 'music.', 'then', 'one', 'day,', 'you', 'will', 'find', 'that', 'the', 'things', 'you', 'try', 'hard', 'to', 'forget', 'are', 'already', 'gone.one', 'is', 'always', 'on', 'a', 'strange', 'road,', 'watching', 'strange', 'scenery', 'and', 'listening', 'to', 'strange', 'music.', 'then', 'one', 'day,', 'you', 'will', 'find', 'that', 'the', 'things', 'you', 'try', 'hard', 'to', 'forget', 'are', 'already', 'gone.']\n", + "请输入您想要查找的单词： one\n", + "one出现了3次\n" + ] + } + ], + "source": [ + "paper = input(\"请输入您想要查找单词出现次数的短文：\")\n", + "paperlist = paper.lower()\n", + "paperlist = paperlist.split()\n", + "print(paperlist)\n", + "word = input(\"请输入您想要查找的单词： \")\n", + "word = word.lower()\n", + "b = paperlist.count(word)\n", + "print(\"%s出现了%d次\" %(word,b))" + ] + }, + { + "cell_type": "markdown", + "id": "43c0116b", + "metadata": {}, + "source": [ + "2. 组合\n", + "有 1、2、3、4 个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "40fda69a", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1,2,3,4这几个数字可以组织 24 个互不相同且无重复数字\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'd' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_26764/433604032.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m!=\u001b[0m\u001b[0mj\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m!=\u001b[0m\u001b[0mk\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m!=\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 9\u001b[0m \u001b[1;32mcontinue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'd' is not defined" + ] + } + ], + "source": [ + "a = 4*3*2\n", + "print(\"1,2,3,4这几个数字可以组织 %d 个互不相同且无重复数字\" %a)\n", + "for i in range(4):\n", + " for j in range(4):\n", + " for k in range(4):\n", + " while i!=j and i!=k and i!=k:\n", + " d=i*100+j*10+k\n", + " print(d)\n", + " continue\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "35e8f40e", + "metadata": {}, + "source": [ + "3. 判断\n", + "企业发放的奖金根据利润提成。利润(I)：\n", + "\n", + "低于或等于 10 万元时，奖金可提 10%；\n", + "高于 10 万元，低于 20 万元时，低于 10 万元的部分按 10%提成，高于 10 万元的部分，可提成 7.5%；\n", + "20 万到 40 万之间时，高于 20 万元的部分，可提成 5%；\n", + "40 万到 60 万之间时，高于 40 万元的部分，可提成 3%；\n", + "60 万到 100 万之间时，高于 60 万元的部分，可提成 1.5%，\n", + "高于 100 万元时， 超过 100 万元的部分按 1%提成， 从键盘输入当月利润 I，求应发放奖金总数？" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "40dd44be", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入您的利润： 10000\n", + "利润高于 0 的奖金为: 1000.0\n", + "应发放奖金总数: 1000.0\n" + ] + } + ], + "source": [ + "a = int(input(\"请输入您的利润： \"))\n", + "b = [1000000,600000,400000,200000,100000,0]\n", + "c = [0.01,0.015,0.03,0.05,0.075,0.1]\n", + "r = 0\n", + "for i in range(6):\n", + " if a>b[i]:\n", + " r+=(a-b[i])*c[i]\n", + " print('利润高于',b[i],'的奖金为:',(a-b[i])*c[i])\n", + " a=b[i]\n", + "print('应发放奖金总数:',r)" + ] + }, + { + "cell_type": "markdown", + "id": "c7e4fa9a", + "metadata": {}, + "source": [ + "4. 循环\n", + "输出9x9的乘法口诀表" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1e29d7b7", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1*1= 1 \n", + "1*2= 2 2*2= 4 \n", + "1*3= 3 2*3= 6 3*3= 9 \n", + "1*4= 4 2*4= 8 3*4= 12 4*4= 16 \n", + "1*5= 5 2*5= 10 3*5= 15 4*5= 20 5*5= 25 \n", + "1*6= 6 2*6= 12 3*6= 18 4*6= 24 5*6= 30 6*6= 36 \n", + "1*7= 7 2*7= 14 3*7= 21 4*7= 28 5*7= 35 6*7= 42 7*7= 49 \n", + "1*8= 8 2*8= 16 3*8= 24 4*8= 32 5*8= 40 6*8= 48 7*8= 56 8*8= 64 \n", + "1*9= 9 2*9= 18 3*9= 27 4*9= 36 5*9= 45 6*9= 54 7*9= 63 8*9= 72 9*9= 81 \n" + ] + } + ], + "source": [ + "a=[1,2,3,4,5,6,7,8,9]\n", + "for i in range(9):\n", + " for j in range(i+1):\n", + " print(\"%d*%d=\"%(a[j],a[i]),a[j]*a[i],end=\" \")\n", + " print(\" \")" + ] + }, + { + "cell_type": "markdown", + "id": "031e7e57", + "metadata": {}, + "source": [ + "5. 使用while循环实现输出2-3+4-5+6.....+100的和" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "b164e448", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "51\n" + ] + } + ], + "source": [ + "a=list(range(2,101))\n", + "#print(a)\n", + "i=0\n", + "b=0\n", + "#print(a[0])\n", + "while i<=98:\n", + " b=b+(-1)**(i)*a[i]\n", + " i=i+1\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "id": "90744e2e", + "metadata": {}, + "source": [ + "6. 排序算法\n", + "给一个数字列表，将其按照由大到小的顺序排列\n", + "\n", + "例如输入数据为：\n", + "\n", + "1, 10, 4, 2, 9, 2, 34, 5, 9, 8, 5, 0\n", + "输出为：\n", + "\n", + "0, 1, 2, 2, 4, 5, 5, 8, 9, 9, 10, 34" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "1f32eecc", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入需要排序的数据,按逗号隔开： 1, 10, 4, 2, 9, 2, 34, 5, 9, 8, 5, 0\n", + "[0, 1, 2, 2, 4, 5, 5, 8, 9, 9, 10, 34]\n" + ] + } + ], + "source": [ + "a = list(input(\"请输入需要排序的数据,按逗号隔开： \").split(','))\n", + "#print(a)\n", + "a = [int(a[i]) for i in range(len(a))] #for循环，把每个字符转成int值\n", + "#print(a)\n", + "b = sorted(a)\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "id": "314c4290", + "metadata": {}, + "source": [ + "7. 矩阵搜索\n", + "编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：\n", + "\n", + "每行的元素从左到右升序排列。\n", + "每列的元素从上到下升序排列。\n", + "示例: 现有矩阵 matrix 如下：\n", + "\n", + "[\n", + "[1, 4, 7, 11, 15],\n", + "[2, 5, 8, 12, 19],\n", + "[3, 6, 9, 16, 22],\n", + "[10, 13, 14, 17, 24],\n", + "[18, 21, 23, 26, 30]\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "d5ec32d7", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入目标值： 30\n", + "True\n" + ] + } + ], + "source": [ + "def target_matrix(matrix: list, target: int):\n", + " for i in matrix:\n", + " for j in i:\n", + " if target < j:\n", + " # 当要搜索的数字小于当前数字的时候，结束本次遍历，减少遍历次数\n", + " break\n", + " elif target == j:\n", + " return True\n", + " else:\n", + " pass\n", + " return False\n", + "\n", + "\n", + "if __name__ == '__main__':\n", + " m = [\n", + " [1, 4, 7, 11, 15],\n", + " [2, 5, 8, 12, 19],\n", + " [3, 6, 9, 16, 22],\n", + " [10, 13, 14, 17, 24],\n", + " [18, 21, 23, 26, 30]\n", + " ]\n", + " t = int(input(\"请输入目标值： \"))\n", + " print(target_matrix(m, t))" + ] + }, + { + "cell_type": "markdown", + "id": "060d7256", + "metadata": {}, + "source": [ + "8. 完数计算\n", + "找出1000以内的所有完数，并打印输出。\n", + "\n", + "什么是完数？ 完全数，又被称作完美数或完备数，是一些特殊的自然数。 它所有的真因子（即除了自身以外的约数）的和，恰好等于它本身。如果一个数恰好等于它的因子之和，则称该数为“完全数”。" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "abeac3b8", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "28\n", + "496\n" + ] + } + ], + "source": [ + "for i in range(1, 1000):\n", + " sum = 0\n", + " for j in range(1, i):\n", + " if i%j == 0:\n", + " sum += j;\n", + " if sum == i:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "id": "50afb8ed", + "metadata": {}, + "source": [ + "9. 快乐数\n", + "编写一个算法来判断一个数 n 是不是快乐数。如果 n 是快乐数打印True ；不是，则打印输出False。\n", + "\n", + "「快乐数」定义为：\n", + "\n", + "对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。\n", + "然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。\n", + "如果 可以变为 1，那么这个数就是快乐数。\n", + "示例1：\n", + "\n", + "输入：n = 19\n", + "输出：true\n", + "解释：（这里的个位数2是平方）\n", + "12 + 92 = 82\n", + "82 + 22 = 68\n", + "62 + 82 = 100\n", + "12 + 02 + 02 = 1\n", + "示例 2：\n", + "\n", + "输入：n = 2\n", + "输出：false" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "a52c9b19", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入需要判断的数据： 45\n", + "False\n" + ] + } + ], + "source": [ + "def happy(num):\n", + " b = 0\n", + " for i in range(10):\n", + " if num // (10**i) == 0:\n", + " x = i\n", + " break\n", + " if num == 1:\n", + " print(True)\n", + " elif num < 10:\n", + " print(False)\n", + " else:\n", + " c = num\n", + " for j in range(x-1):\n", + " b = b + (c%10)**2\n", + " c = c//10\n", + " b = b + c**2\n", + " num = b\n", + " return happy(num)\n", + " \n", + "a = int(input(\"请输入需要判断的数据： \"))\n", + "happy(a)" + ] + }, + { + "cell_type": "markdown", + "id": "a8b7b3e7", + "metadata": {}, + "source": [ + "10. 连续的子数组和\n", + "给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：\n", + "\n", + "子数组大小 至少为 2 ，且\n", + "子数组元素总和为 k 的倍数。\n", + "如果存在，返回 True ；否则，返回 False 。\n", + "\n", + "如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。0 始终视为 k 的一个倍数。\n", + "\n", + "示例 1：\n", + "\n", + "输入：nums = [23,2,4,6,7], k = 6\n", + "输出：true\n", + "解释：[2,4] 是一个大小为 2 的子数组，并且和为 6 。\n", + "示例 2：\n", + "\n", + "输入：nums = [23,2,6,4,7], k = 6\n", + "输出：true\n", + "解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42 。 \n", + "42 是 6 的倍数，因为 42 = 7 * 6 且 7 是一个整数。\n", + "示例 3：\n", + "\n", + "输入：nums = [23,2,6,4,7], k = 13\n", + "输出：false" + ] + }, + { + "cell_type": "code", + "execution_count": 201, + "id": "ca2711e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入需要判断的数组 23,2,4,6,7\n", + "请输入整数 6\n", + "[23, 2, 4, 6, 7]\n" + ] + }, + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 201, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def CheckSum(nums, k):\n", + " n = len(nums)\n", + " nums = [int(nums[i]) for i in range(n)]\n", + " k = int(k)\n", + " print(nums)\n", + " if k == 0:\n", + " for i in range(1, n):\n", + " if nums[i] == 0 and nums[i-1] == 0:\n", + " return True\n", + " return False\n", + " mp = {}\n", + " mp[0] = 0\n", + " sum = 0\n", + " for i in range(n):\n", + " sum = sum+nums[i]\n", + " sum = sum%k\n", + " if sum not in mp:\n", + " mp[sum] = i+1\n", + " elif (i+1-mp[sum])>= 2:\n", + " return True\n", + " return False\n", + "c = input(\"请输入需要判断的数组 \" ).split(',')\n", + "k = input(\"请输入整数 \" )\n", + "CheckSum(c,k)" + ] + }, + { + "cell_type": "markdown", + "id": "99057af2", + "metadata": {}, + "source": [ + "11. 确定字符串是否包含唯一字符\n", + "实现一个算法：识别一个字符串中，是否包含唯一的字符。\n", + "\n", + "如果字符串中的字符都是唯一的，则返回 True，如 '123'；如果字符串中的字符有重复，则返回 False，如 '1223'。\n", + "\n", + "样例1：\n", + "\n", + "输入：123\n", + "输出：True\n", + "样例2：\n", + "\n", + "输入：1223\n", + "输出：False" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "95dca010", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入需要判断的字符串： 15864\n", + "True\n" + ] + } + ], + "source": [ + "a = input(\"请输入需要判断的字符串： \")\n", + "if len(set(a)) == len(a):\n", + " print('True')\n", + "else:\n", + " print('False')" + ] + }, + { + "cell_type": "markdown", + "id": "8a04fb04", + "metadata": {}, + "source": [ + "12. 能够拼成多少个单词\n", + "给出一个由小写字母组成的字符串 s，使用 s 中的字符来拼凑单词 'balloon'（气球）。字符串 s 中的每个字符最多只能被使用一次，求出 s 中的字符最多可以拼凑出多少个单词 'balloon'。\n", + "\n", + "例如：\n", + "\n", + "字符串 'nlaebolko' 中的字符最多可以拼凑出1个 'balloon'；\n", + "字符串 'loonbalxballpoon' 中的字符最多可以拼凑出2个 'balloon'；\n", + "字符串 'ballopq' 中的字符最多可以拼凑出0个 'balloon'。\n", + "输入与输出\n", + "\n", + "输入: 共一行，一个字符串。\n", + "输出: 共一行，一个整数，表示能拼凑出单词 \"balloon\"的总个数。\n", + "样例1：\n", + "\n", + "输入: \n", + "nlaebolko\n", + "\n", + "输出: \n", + "1\n", + "样例2：\n", + "\n", + "输入: \n", + "loonbalxballpoon\n", + "\n", + "输出: \n", + "2\n", + "样例3：\n", + "\n", + "输入: \n", + "ballopq\n", + "\n", + "输出: \n", + "0" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "bb89bf6e", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "请输入需要判断的字符串： loonbalxballpoon\n" + ] + }, + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def Balloons(string: str):\n", + " a = [0,0,0,0,0]\n", + " b = len(string)\n", + " for i in range(b):\n", + " if string[i] == 'b':\n", + " a[0]=a[0]+1;\n", + " elif string[i] == 'a':\n", + " a[1]=a[1]+1;\n", + " elif string[i] == 'l':\n", + " a[2]=a[2]+1;\n", + " elif string[i] == 'o':\n", + " a[3]=a[3]+1;\n", + " elif string[i] == 'n':\n", + " a[4]=a[4]+1;\n", + " minn = a[0];\n", + " for i in range(5):\n", + " minn = min(a[i], minn);\n", + " return minn;\n", + "c = input(\"请输入需要判断的字符串： \")\n", + "Balloons(c)" + ] + }, + { + "cell_type": "markdown", + "id": "23c5ad62", + "metadata": {}, + "source": [ + "13. 生成激活码\n", + "做为 Apple Store App 独立开发者，你要搞限时促销，为你的应用生成激活码（或者优惠券），使用 Python 如何生成 200 个激活码（或者优惠券）？\n", + "\n", + "需要考虑什么是激活码？有什么特性？例如KR603guyVvR是一个激活码" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "b3bb51dc", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y3kzizQYJqG\n", + "P0FwamviJXT\n", + "RCOe5EegDW6\n", + "2vmXG8DYk3C\n", + "GhOrar5iWMT\n", + "Hjcxzx7nHiS\n", + "qwrF2Bf6spW\n", + "4Ft4tNhrd8z\n", + "XhqsViTKZ6X\n", + "aQNrW9rDnP3\n", + "fA4Ymw4V9yt\n", + "UOqP3Xuwi4P\n", + "3UrWz4ubOSQ\n", + "OBCmDjqHBk2\n", + "HabAWJJjkU1\n", + "iP5752BmLos\n", + "XnlufffsXeL\n", + "0QrpBilYaW9\n", + "fmx4ca8tjSn\n", + "UTCLpXbm2V7\n", + "FGkBAwVhh8n\n", + "JqnDKsvAZG9\n", + "JtVlpXwUATl\n", + "O5fKbEjn8Yr\n", + "9WLw5i4BCE9\n", + "TCA5YBi7id1\n", + "6E7hPN2qQ8l\n", + "7tSiB8NSMha\n", + "36lPDRg1hB9\n", + "OiHc1A05ltJ\n", + "E0Vw7DAGPnj\n", + "5Spg5IKPugo\n", + "39LCifBnYAH\n", + "Ua5Xxwb7hpR\n", + "5bGcVE5OlDz\n", + "1enEhg5D2St\n", + "f1UGcdudRPm\n", + "ob46BubN020\n", + "00zI7vXw6fm\n", + "rFBDhCAOk7g\n", + "OqoMA6YrhzH\n", + "TVenLUtcSQq\n", + "Co3cyJ8MYe6\n", + "NqbSR1o6gbo\n", + "5Vc3LYpKyW7\n", + "MJCyDfZaH7q\n", + "wZRfYSZMEA9\n", + "cMyBKUCWJXc\n", + "DJ77V7A2q4S\n", + "ye1MQZN5LJL\n", + "mucSJ1P0lXk\n", + "xnqmPclkiwE\n", + "RW8zxDAUndG\n", + "5nQ2IlYwmlI\n", + "EgaabB6hzvD\n", + "QhmayVxv2Sa\n", + "ob9Z6fADdhO\n", + "BtyQd45bhg7\n", + "HGxSIhOaEih\n", + "lDIE7fB7yy9\n", + "IDFGsJogrqG\n", + "aHVWzei7EQZ\n", + "OFHj9xA0Drr\n", + "X1olEaQBoH1\n", + "FXWICipSFSF\n", + "1hTPqcJonwn\n", + "cceeCvYs28o\n", + "VulQw7XUUpH\n", + "uesChJbyBTy\n", + "cqFihTct3JG\n", + "Myia3FIr3Tw\n", + "316uDAWqbxC\n", + "nYMwvgLF4iv\n", + "fqDtQSdcaaT\n", + "plq2c5cyLZx\n", + "9gSVRbWCjhb\n", + "Yx1JIbnDMFT\n", + "DDVOnfiUJca\n", + "7DI3ZaPQiHr\n", + "UOFk3jLoYmz\n", + "zymwhqLCKLA\n", + "FPktr8MpEww\n", + "AvXBG5NBR9f\n", + "GSkamNkJStI\n", + "p7werD4V2V2\n", + "dVEoj3r8yyF\n", + "455CAlgUf8L\n", + "iPBKmgToL6K\n", + "jPgjfHOsLkb\n", + "3gwe7einNII\n", + "BcVGsilXN3E\n", + "VZJnduVtolZ\n", + "5y45XqHUpO2\n", + "iJd3Mn24Mji\n", + "RxoZZ6peUF8\n", + "OWnIzVvE7D7\n", + "CRa9YxyW3Qh\n", + "NDCe2600EAf\n", + "tfcdHI0XfgJ\n", + "35d9y6djSLY\n", + "lcbezw0SNYr\n", + "QskjgAIWiA0\n", + "aX3YBosW4MF\n", + "4OpjjKVskBP\n", + "Ugch5bDGdLe\n", + "srElFK5J0D8\n", + "uACwNTmXjP3\n", + "0RGM375yU1W\n", + "tVrfCEeH8Rz\n", + "ybfjb9gl4bL\n", + "bvvmKlycDMM\n", + "r0JmJ6ojWak\n", + "dP8mPiGovFm\n", + "kIoms5cFEum\n", + "E7yQdENUdUt\n", + "KaMAC0nuy4H\n", + "8126fOAHELq\n", + "RoTNbKNztSq\n", + "i535YuZHPz3\n", + "dvuM7mofi3A\n", + "2BvxRvlLJhM\n", + "yHHj4YTOsLs\n", + "OUAJvY5G1pf\n", + "FIP1kiQSCI3\n", + "WR0bsXenTdp\n", + "UJvUmxiQDyZ\n", + "dKzdfRnrtbb\n", + "lejd6sqDpQX\n", + "dVoNZso12ry\n", + "F5or5f8MpLQ\n", + "mkIaqajJu5y\n", + "x8HtHlCc60n\n", + "vUPhQAH4OSY\n", + "mtjaJ0y32Cy\n", + "LALkFUs83dt\n", + "VwYI64Glgoc\n", + "fKhHCUR2kwi\n", + "JlQ1bmRka5B\n", + "1VZHAbcEr5I\n", + "CwjPsS8GBbs\n", + "6f96lCPmQhT\n", + "0AptrGtzrzZ\n", + "avkbM4FyLt9\n", + "LY390lIV0gY\n", + "6rTO0TQUMI5\n", + "OLvpVVAjBhU\n", + "DaA4XvnTyEr\n", + "QECwNFy4Mf7\n", + "szB1i8EYXqU\n", + "LgRVnWmH0eQ\n", + "Gbj0PDsb9tT\n", + "gUutTrTmul2\n", + "wn2y3T4HGaH\n", + "70uwaRkCJ2k\n", + "4vvs5MgmsKc\n", + "EBcVsBnnlbs\n", + "O9NCENxJwoN\n", + "EJXOH8hKHRG\n", + "LZNvya3RQiY\n", + "kE74AuxKnHr\n", + "kEBcctmwIBl\n", + "chjg0dd2EW9\n", + "LiWLJZi9mUc\n", + "RZSz6jUllBS\n", + "cB0u0cNo2c5\n", + "UEFdZiqUL8h\n", + "h4iD4nCDZdL\n", + "MrkhRUMiBdk\n", + "9yFhQ5YjFJY\n", + "0aRwvvSUnKb\n", + "AbfocNzyZSs\n", + "QMph6J0BrlI\n", + "1bTJzSIsI8M\n", + "Xr2ezBIEgWm\n", + "hdfz1il02Vg\n", + "pKIqD8B2NZ0\n", + "A7kjVq3zRcj\n", + "WuAHfxfaMXl\n", + "vNdLLYiOnPY\n", + "fXvQoI5wMbZ\n", + "wSyA4dht9zP\n", + "A8Z6GkAt06W\n", + "geuREg5tkNO\n", + "bKO7yUefckP\n", + "uq6cfhoMlB6\n", + "7GRsfNrHOIx\n", + "XgiZNJBfOm1\n", + "0T2G7NgPa8t\n", + "N9WorapbUTd\n", + "sRaSXBD1JkL\n", + "XJQ6CFV8RqQ\n", + "O50DGcQRmTx\n", + "hiPVIpycif5\n", + "MuoqEfrHXqx\n", + "uF42cu0ahIh\n", + "yJvLGgUxbRn\n", + "b801TJzQob3\n", + "fiWCnHxq21i\n", + "GiCCHp1lBCW\n", + "aLeUgXuukUN\n" + ] + } + ], + "source": [ + "import random\n", + "list=[]\n", + "for x in range(65,91):\n", + " a=str(chr(x)) \n", + " list.append(a)\n", + "for x in range(97,123):\n", + " a=str(chr(x)) \n", + " list.append(a) \n", + "#生成10个数字\n", + "for x in range(10):\n", + " list.append(str(x))\n", + "'''\n", + "def gen_code():\n", + " a=random.sample(list,16)\n", + " print a\n", + "'''\n", + "def gen_code():\n", + " s=''\n", + " for x in range(11):\n", + " a=random.choice(list)\n", + " s=s+a\n", + " print(s)\n", + "\n", + "#生成200个激活码\n", + "for x in range(200):\n", + " gen_code()" + ] + }, + { + "cell_type": "markdown", + "id": "a7770aed", + "metadata": {}, + "source": [ + "14. 遍历目录\n", + "需要把某个目录下面所有的某种类型的文件找到。 例如把c:下面所有的.dll文件找到。需要注意的是，需要递归到每一个目录去查找。" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "7113a03d", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1: D:\\machine learning\\machinelearning_notebook\\studing1\n", + "2: ['.ipynb_checkpoints']\n", + "3: ['example01.py', 'homewokr-python.ipynb']\n", + "1: D:\\machine learning\\machinelearning_notebook\\studing1\\.ipynb_checkpoints\n", + "2: []\n", + "3: ['homewokr-python-checkpoint.ipynb']\n", + "['D:\\\\machine learning\\\\machinelearning_notebook\\\\studing1\\\\example01.py', 'D:\\\\machine learning\\\\machinelearning_notebook\\\\studing1\\\\homewokr-python.ipynb', 'D:\\\\machine learning\\\\machinelearning_notebook\\\\studing1\\\\.ipynb_checkpoints\\\\homewokr-python-checkpoint.ipynb']\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "def all_path(dirname):\n", + "\n", + " result = []#所有的文件\n", + "\n", + " for maindir, subdir, file_name_list in os.walk(dirname):\n", + "\n", + " print(\"1:\",maindir) \n", + " print(\"2:\",subdir) \n", + " print(\"3:\",file_name_list)\n", + "\n", + " for filename in file_name_list:\n", + " apath = os.path.join(maindir, filename)\n", + " result.append(apath)\n", + "\n", + " return result\n", + "\n", + "print(all_path(\"D:\\machine learning\\machinelearning_notebook\\studing1\"))" + ] + }, + { + "cell_type": "markdown", + "id": "a44892a9", + "metadata": {}, + "source": [ + "15. 统计代码行数\n", + "你有个目录，里面是程序（假如是C或者是Python），统计一下你写过多少行代码。包括空行和注释，但是要分别（例如C程序多少行，Python程序多少行，等等）列出来。" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "id": "a7906e49", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "代码总行数为： 60\n", + "空行总行数为： 9\n", + "注释行总行数为： 0\n" + ] + } + ], + "source": [ + "\n", + "import os\n", + "#定义代码所在的目录\n", + "base_path = 'D:\\machine learning\\machinelearning_notebook\\studing1'\n", + "\n", + "#在指定目录下统计所有的py文件，以列表形式返回\n", + "def collect_files(dir):\n", + " filelist = []\n", + " for parent,dirnames,filenames in os.walk(dir):\n", + " for filename in filenames:\n", + " if filename.endswith('.py'):\n", + " #将文件名和目录名拼成绝对路径，添加到列表里\n", + " filelist.append(os.path.join(parent,filename))\n", + " return filelist\n", + "\n", + "#计算单个文件内的代码行数\n", + "def calc_linenum(file):\n", + " with open(file,encoding='UTF-8') as fp:\n", + " content_list = fp.readlines()\n", + " code_num = 0 #当前文件代码行数计数变量\n", + " blank_num = 0 #当前文件空行数计数变量\n", + " annotate_num =0 #当前文件注释行数计数变量\n", + " for content in content_list:\n", + " content = content.strip()\n", + " # 统计空行\n", + " if content == '':\n", + " blank_num += 1\n", + " # 统计注释行\n", + " elif content.startswith('#'):\n", + " annotate_num += 1\n", + " # 统计代码行\n", + " else:\n", + " code_num += 1\n", + " # 返回代码行数，空行数，注释行数\n", + " return code_num,blank_num,annotate_num\n", + "\n", + "if __name__ == '__main__':\n", + " files = collect_files(base_path)\n", + " total_code_num = 0 #统计文件代码行数计数变量\n", + " total_blank_num = 0 #统计文件空行数计数变量\n", + " total_annotate_num = 0 #统计文件注释行数计数变量\n", + " for f in files:\n", + " code_num, blank_num, annotate_num = calc_linenum(f)\n", + " total_code_num += code_num\n", + " total_blank_num += blank_num\n", + " total_annotate_num += annotate_num\n", + "\n", + " print(u'代码总行数为： %s' % total_code_num)\n", + " print(u'空行总行数为： %s' % total_blank_num)\n", + " print(u'注释行总行数为： %s' % total_annotate_num)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/name.txt b/name.txt new file mode 100644 index 0000000..20eed7f --- /dev/null +++ b/name.txt @@ -0,0 +1,2 @@ +曾延 +2021100204 \ No newline at end of file -- Gitee From 3ccfad3104512fa18be0c5fc28704d8c14505c92 Mon Sep 17 00:00:00 2001 From: Zengyan <487339041@qq.com> Date: Fri, 1 Apr 2022 13:23:22 +0000 Subject: [PATCH 2/2] =?UTF-8?q?=E4=BD=9C=E4=B8=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- homework_02_numpy_matplotlib.ipynb | 810 +++++++++++++++++++++++++++++ 1 file changed, 810 insertions(+) create mode 100644 homework_02_numpy_matplotlib.ipynb diff --git a/homework_02_numpy_matplotlib.ipynb b/homework_02_numpy_matplotlib.ipynb new file mode 100644 index 0000000..ca88d99 --- /dev/null +++ b/homework_02_numpy_matplotlib.ipynb @@ -0,0 +1,810 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e5927991", + "metadata": {}, + "source": [ + "学号：2021100204\n", + "姓名：曾延" + ] + }, + { + "cell_type": "markdown", + "id": "cd1209f9", + "metadata": {}, + "source": [ + "1.1 对于一个存在在数组，如何添加一个用0填充的边界?\n", + "例如对一个二维矩阵\n", + "\n", + "10, 34, 54, 23\n", + "31, 87, 53, 68\n", + "98, 49, 25, 11\n", + "84, 32, 67, 88\n", + "变换成\n", + "\n", + " 0, 0, 0, 0, 0, 0\n", + " 0, 10, 34, 54, 23, 0\n", + " 0, 31, 87, 53, 68, 0\n", + " 0, 98, 49, 25, 11, 0\n", + " 0, 84, 32, 67, 88, 0\n", + " 0, 0, 0, 0, 0, 0" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "3941dfad", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10 34 54 23]\n", + " [31 87 53 68]\n", + " [98 49 25 11]\n", + " [84 32 67 88]]\n", + "[[ 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 10. 34. 54. 23. 0.]\n", + " [ 0. 31. 87. 53. 68. 0.]\n", + " [ 0. 98. 49. 25. 11. 0.]\n", + " [ 0. 84. 32. 67. 88. 0.]\n", + " [ 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "a = np.array([[10,34,54,23],\\\n", + " [31,87,53,68],\\\n", + " [98,49,25,11],\\\n", + " [84,32,67,88]])\n", + "print(a)\n", + "b = np.shape(a)\n", + "#print(b)\n", + "c = np.zeros((6,6))\n", + "#print(c)\n", + "c[1:5,1:5] = a\n", + "print(c)" + ] + }, + { + "cell_type": "markdown", + "id": "2953359f", + "metadata": {}, + "source": [ + "1.2 创建一个 5x5的矩阵，并设置值1,2,3,4落在其对角线下方位置" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f7ec1d8d", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 0 0 0 0]\n", + " [1 0 0 0 0]\n", + " [0 2 0 0 0]\n", + " [0 0 3 0 0]\n", + " [0 0 0 4 0]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "a = np.diag([1,2,3,4], k=-1)\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "id": "7cc7be45", + "metadata": {}, + "source": [ + "1.3 创建一个8x8 的矩阵，并且设置成国际象棋棋盘样式（黑可以用0, 白可以用1）" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "9591b343", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "国际象棋棋盘样式（0表示黑, 1表示白）\n", + "[[1. 0. 1. 0. 1. 0. 1. 0.]\n", + " [0. 1. 0. 1. 0. 1. 0. 1.]\n", + " [1. 0. 1. 0. 1. 0. 1. 0.]\n", + " [0. 1. 0. 1. 0. 1. 0. 1.]\n", + " [1. 0. 1. 0. 1. 0. 1. 0.]\n", + " [0. 1. 0. 1. 0. 1. 0. 1.]\n", + " [1. 0. 1. 0. 1. 0. 1. 0.]\n", + " [0. 1. 0. 1. 0. 1. 0. 1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "a = np.zeros((8,8))\n", + "a\n", + "for i in range(8):\n", + " for j in range(8):\n", + " if (-1)**(i+j)>0:\n", + " a[i,j]=1\n", + "print(\"国际象棋棋盘样式（0表示黑, 1表示白）\")\n", + "print(a)" + ] + }, + { + "cell_type": "markdown", + "id": "722a7360", + "metadata": {}, + "source": [ + "1.4 求解线性方程组\n", + "给定一个方程组，如何求出其的方程解。有多种方法，分析各种方法的优缺点（最简单的方式是消元方）。\n", + "\n", + "例如\n", + "\n", + "3x + 4y + 2z = 10\n", + "5x + 3y + 4z = 14\n", + "8x + 2y + 7z = 20\n", + "编程写出求解的程序" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "9677189e", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6.],\n", + " [ 0.],\n", + " [-4.]])" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "a = np.array([[3,4,2],[5,3,4],[8,2,7]])\n", + "#print(a)\n", + "b = np.array([[10],[14],[20]])\n", + "#print(b)\n", + "c = np.linalg.inv(a)\n", + "#print(c)\n", + "#a.shape\n", + "np.dot(c, b)" + ] + }, + { + "cell_type": "markdown", + "id": "e22b09f2", + "metadata": {}, + "source": [ + "1.5 翻转一个数组（第一个元素变成最后一个）" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "c4df84ad", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "翻转后的数组： [[88 67 32 84]\n", + " [11 25 49 98]\n", + " [98 49 25 11]\n", + " [84 32 67 88]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "a = np.array([[10,34,54,23],\\\n", + " [31,87,53,68],\\\n", + " [98,49,25,11],\\\n", + " [84,32,67,88]])\n", + "for i in range(4):\n", + " for j in range(4):\n", + " a[i,j]=a[3-i,3-j]\n", + "print(\"翻转后的数组：\",a)" + ] + }, + { + "cell_type": "markdown", + "id": "2cf38521", + "metadata": {}, + "source": [ + "1.6 产生一个10x10大小的随机数组，并且找出最大和最小值" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "c0556cd7", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.20350372 2.06473564 -1.06802034 -0.28286087 -1.57128987 0.79740774\n", + " 0.28199015 0.16268785 -0.29150064 -1.1821662 ]\n", + " [-0.16864447 1.490153 -0.89699502 1.6904879 1.27681944 -0.31615288\n", + " 1.34265123 -0.85239028 -0.41947129 0.23917748]\n", + " [-1.65537239 0.69647722 -0.2810413 -0.06412286 -1.51891824 0.01433117\n", + " -1.79122658 0.73706222 -0.13897824 0.11257307]\n", + " [ 0.52443681 0.86324995 -0.45999741 -0.71315841 0.82056634 0.11133349\n", + " -0.47798407 0.5701645 0.45544361 0.19218825]\n", + " [-2.01339597 -0.3324441 -0.62437632 -0.47611825 0.14217562 -0.79754976\n", + " -0.05036679 0.60541843 0.61316935 -0.1916818 ]\n", + " [-1.23988413 1.19050957 1.29802403 2.16707672 1.15225346 -1.06246352\n", + " 0.83655653 -0.50517878 -0.90418293 -1.15985027]\n", + " [ 0.51310362 0.13908421 0.49700705 -0.11607198 0.52832443 0.68643355\n", + " -0.13451339 -0.92426474 -2.95127614 0.6098658 ]\n", + " [-0.27735159 -1.94592682 1.31970682 0.76034711 0.02184816 -1.27433982\n", + " 1.39070956 1.4041426 -1.20675935 -2.55012788]\n", + " [ 0.92061716 1.5117966 0.86459958 1.06330231 -1.22320671 0.09885143\n", + " 1.14729136 -1.70526258 -0.26628212 -0.38941063]\n", + " [ 1.68545977 -1.66387934 -0.21604393 -0.36371669 -0.19457283 -0.5686105\n", + " -0.36311426 0.54157042 1.23048197 0.61227593]]\n", + "2.167076721026069 (array([5], dtype=int64), array([3], dtype=int64)) -2.951276141988252 (array([6], dtype=int64), array([8], dtype=int64))\n" + ] + } + ], + "source": [ + "from numpy import random\n", + "a = random.randn(10,10)\n", + "print(a)\n", + "maxnum = a.max()\n", + "minnum = a.min()\n", + "maxlocal = np.where(a==a.max())\n", + "minlocal = np.where(a==a.min())\n", + "print(maxnum,maxlocal,minnum,minlocal)\n", + "#print(\"数组的最大值%d的\")" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "4c24ae13", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10 34 54 23]\n", + " [31 87 53 68]\n", + " [98 49 25 11]\n", + " [84 32 67 88]]\n" + ] + }, + { + "data": { + "text/plain": [ + "(98, 10)" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from numpy import random\n", + "a = np.array([[10,34,54,23],\\\n", + " [31,87,53,68],\\\n", + " [98,49,25,11],\\\n", + " [84,32,67,88]])\n", + "print(a)\n", + "def extemum(jizhi):\n", + " b = a[0,0]\n", + " c = a[0,0]\n", + " for i in range(4):\n", + " for j in range(4):\n", + " if jizhi[i,j]>=b:\n", + " b=a[i,j]\n", + " if jizhi[i,j]<=c:\n", + " c=jizhi[i,j]\n", + " return b,c\n", + "extemum(a)" + ] + }, + { + "cell_type": "markdown", + "id": "92bdecb9", + "metadata": {}, + "source": [ + "2.1 画出一个二次函数，同时画出梯形法求积分时的各个梯形\n", + "例如： matplot_ex1" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "74c86450", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f7dfb32c4244f03a291868a2b668494", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=15, description='laddernum', max=30, min=1), Output()), _dom_classes=('w…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 206, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def Quadratic(x): # 定义二次函数\n", + " return 2*x**2 +3*x +4\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_ladder(laddernum):\n", + " x = np.linspace(-5, 5, num=100)\n", + " y = Quadratic(x)\n", + " plt.plot(x,y,'r-') # 先画出原函数的图形\n", + " \n", + " a = np.linspace(-5, 5, num=laddernum)\n", + " for i in range(laddernum):\n", + " plt.plot([a[i],a[i]],[0,Quadratic(a[i])],color=\"black\") # 画梯形的上底和下底\n", + "\n", + " ladders = [];\n", + " for i in range(laddernum):\n", + " ladders.append([a[i],Quadratic(a[i])]) # 因为梯形的腰是呈一条直线，所以这里存下各点坐标\n", + " \n", + " npladders = np.array(ladders)\n", + " plt.plot(npladders[:,0],npladders[:,1]); # 把梯形的斜腰连起来\n", + "\n", + "interact(plot_ladder, laddernum=(1, 30, 1)) # 滑动模块在 1 和 30 之间变化，变化区间是 1" + ] + }, + { + "cell_type": "markdown", + "id": "360d84c6", + "metadata": {}, + "source": [ + "2.2 绘制函数 f(x)=sin2(x−2)e−x2\n", + "需要画出标题，x，y轴。x的取值范围是[0, 2]" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "7938c1dd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "x1 = np.arange(0.0, 2.0, 0.1)\n", + "\n", + "def f(x):\n", + " y=x*x\n", + " return np.sin(x-2)*np.sin(x-2)*np.exp(-y) \n", + "\n", + "#plt.figure(1)\n", + "#plt.subplot(2,1,1)\n", + "plt.plot(x1, f(x1), 'g-')\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.show\n" + ] + }, + { + "cell_type": "markdown", + "id": "e05d3efc", + "metadata": {}, + "source": [ + "2.3 模拟一个醉汉在二维空间上的随机漫步。\n", + "例如1维的情况是： random_walk x轴表示步子，y轴表示游走的位置\n", + "\n", + "如果对于二维，则x，y分别是游走的位置。当然也可以画成三维，其中z比表示步子。" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "27ca479c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import math\n", + "\n", + "# 目前的位置\n", + "cur = [0, 0]\n", + "# 总步数\n", + "allstep = 1000\n", + "# 用于存储移动后的每一次位置\n", + "movex, movey = [0], [0]\n", + "while (allstep > 0):\n", + " angle = np.random.randint(360)\n", + " # 将随机角度转化为对应的弧度制\n", + " index = np.deg2rad(angle)\n", + " # 随机移动的x轴与y轴坐标\n", + " x = math.cos(index)\n", + " y = math.sin(index)\n", + " # 移动当前位置\n", + " cur[0] = cur[0] + x\n", + " cur[1] = cur[1] + y\n", + " # 保存目前的位置信息，方便绘制图像\n", + " movex.append(cur[0])\n", + " movey.append(cur[1])\n", + " allstep -= 1\n", + "\n", + "plt.title('random walk')\n", + "# 初始点\n", + "plt.scatter(0, 0, c='r')\n", + "plt.plot(movex, movey)\n", + "# 结束点\n", + "plt.scatter(cur[0], cur[1], c='gold')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "id": "4f3cdd51", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Argument Z must be 2-dimensional.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_18568/2125968188.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[1;31m#作图\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0max3\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot_surface\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mz1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'rainbow'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 18\u001b[0m \u001b[1;31m#ax3.contour(X,Y,Z, zdim='z',offset=-2，cmap='rainbow) #等高线图，要设置offset，为Z的最小值\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\ProgramData\\Anaconda3\\lib\\site-packages\\matplotlib\\_api\\deprecation.py\u001b[0m in \u001b[0;36mwrapper\u001b[1;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[0;32m 429\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mdeprecation_addendum\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 430\u001b[0m **kwargs)\n\u001b[1;32m--> 431\u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minner_args\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0minner_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 432\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 433\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mD:\\ProgramData\\Anaconda3\\lib\\site-packages\\mpl_toolkits\\mplot3d\\axes3d.py\u001b[0m in \u001b[0;36mplot_surface\u001b[1;34m(self, X, Y, Z, norm, vmin, vmax, lightsource, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1656\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1657\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mZ\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1658\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Argument Z must be 2-dimensional.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 1659\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0many\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mZ\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 1660\u001b[0m _api.warn_external(\n", + "\u001b[1;31mValueError\u001b[0m: Argument Z must be 2-dimensional." + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from numpy import random\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "x=np.random.rand(10)\n", + "y=np.random.rand(10)\n", + "x1=sorted(x)\n", + "y1=sorted(y)\n", + "z1=np.arange(0,10,1)\n", + "\n", + "fig = plt.figure() #定义新的三维坐标轴\n", + "ax3 = plt.axes(projection='3d')\n", + "\n", + "#作图\n", + "ax3.plot_surface(x1,y1,z1,cmap='rainbow')\n", + "#ax3.contour(X,Y,Z, zdim='z',offset=-2，cmap='rainbow) #等高线图，要设置offset，为Z的最小值\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "5d4060cc", + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function subplot in module matplotlib.pyplot:\n", + "\n", + "subplot(*args, **kwargs)\n", + " Add an Axes to the current figure or retrieve an existing Axes.\n", + " \n", + " This is a wrapper of `.Figure.add_subplot` which provides additional\n", + " behavior when working with the implicit API (see the notes section).\n", + " \n", + " Call signatures::\n", + " \n", + " subplot(nrows, ncols, index, **kwargs)\n", + " subplot(pos, **kwargs)\n", + " subplot(**kwargs)\n", + " subplot(ax)\n", + " \n", + " Parameters\n", + " ----------\n", + " *args : int, (int, int, *index*), or `.SubplotSpec`, default: (1, 1, 1)\n", + " The position of the subplot described by one of\n", + " \n", + " - Three integers (*nrows*, *ncols*, *index*). The subplot will take the\n", + " *index* position on a grid with *nrows* rows and *ncols* columns.\n", + " *index* starts at 1 in the upper left corner and increases to the\n", + " right. *index* can also be a two-tuple specifying the (*first*,\n", + " *last*) indices (1-based, and including *last*) of the subplot, e.g.,\n", + " ``fig.add_subplot(3, 1, (1, 2))`` makes a subplot that spans the\n", + " upper 2/3 of the figure.\n", + " - A 3-digit integer. The digits are interpreted as if given separately\n", + " as three single-digit integers, i.e. ``fig.add_subplot(235)`` is the\n", + " same as ``fig.add_subplot(2, 3, 5)``. Note that this can only be used\n", + " if there are no more than 9 subplots.\n", + " - A `.SubplotSpec`.\n", + " \n", + " projection : {None, 'aitoff', 'hammer', 'lambert', 'mollweide', 'polar', 'rectilinear', str}, optional\n", + " The projection type of the subplot (`~.axes.Axes`). *str* is the name\n", + " of a custom projection, see `~matplotlib.projections`. The default\n", + " None results in a 'rectilinear' projection.\n", + " \n", + " polar : bool, default: False\n", + " If True, equivalent to projection='polar'.\n", + " \n", + " sharex, sharey : `~.axes.Axes`, optional\n", + " Share the x or y `~matplotlib.axis` with sharex and/or sharey. The\n", + " axis will have the same limits, ticks, and scale as the axis of the\n", + " shared axes.\n", + " \n", + " label : str\n", + " A label for the returned axes.\n", + " \n", + " Returns\n", + " -------\n", + " `.axes.SubplotBase`, or another subclass of `~.axes.Axes`\n", + " \n", + " The axes of the subplot. The returned axes base class depends on\n", + " the projection used. It is `~.axes.Axes` if rectilinear projection\n", + " is used and `.projections.polar.PolarAxes` if polar projection\n", + " is used. The returned axes is then a subplot subclass of the\n", + " base class.\n", + " \n", + " Other Parameters\n", + " ----------------\n", + " **kwargs\n", + " This method also takes the keyword arguments for the returned axes\n", + " base class; except for the *figure* argument. The keyword arguments\n", + " for the rectilinear base class `~.axes.Axes` can be found in\n", + " the following table but there might also be other keyword\n", + " arguments if another projection is used.\n", + " \n", + " Properties:\n", + " adjustable: {'box', 'datalim'}\n", + " agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n", + " alpha: scalar or None\n", + " anchor: 2-tuple of floats or {'C', 'SW', 'S', 'SE', ...}\n", + " animated: bool\n", + " aspect: {'auto', 'equal'} or float\n", + " autoscale_on: bool\n", + " autoscalex_on: bool\n", + " autoscaley_on: bool\n", + " axes_locator: Callable[[Axes, Renderer], Bbox]\n", + " axisbelow: bool or 'line'\n", + " box_aspect: float or None\n", + " clip_box: `.Bbox`\n", + " clip_on: bool\n", + " clip_path: Patch or (Path, Transform) or None\n", + " contains: unknown\n", + " facecolor or fc: color\n", + " figure: `.Figure`\n", + " frame_on: bool\n", + " gid: str\n", + " in_layout: bool\n", + " label: object\n", + " navigate: bool\n", + " navigate_mode: unknown\n", + " path_effects: `.AbstractPathEffect`\n", + " picker: None or bool or float or callable\n", + " position: [left, bottom, width, height] or `~matplotlib.transforms.Bbox`\n", + " prop_cycle: unknown\n", + " rasterization_zorder: float or None\n", + " rasterized: bool\n", + " sketch_params: (scale: float, length: float, randomness: float)\n", + " snap: bool or None\n", + " title: str\n", + " transform: `.Transform`\n", + " url: str\n", + " visible: bool\n", + " xbound: unknown\n", + " xlabel: str\n", + " xlim: (bottom: float, top: float)\n", + " xmargin: float greater than -0.5\n", + " xscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n", + " xticklabels: unknown\n", + " xticks: unknown\n", + " ybound: unknown\n", + " ylabel: str\n", + " ylim: (bottom: float, top: float)\n", + " ymargin: float greater than -0.5\n", + " yscale: {\"linear\", \"log\", \"symlog\", \"logit\", ...} or `.ScaleBase`\n", + " yticklabels: unknown\n", + " yticks: unknown\n", + " zorder: float\n", + " \n", + " Notes\n", + " -----\n", + " Creating a new Axes will delete any pre-existing Axes that\n", + " overlaps with it beyond sharing a boundary::\n", + " \n", + " import matplotlib.pyplot as plt\n", + " # plot a line, implicitly creating a subplot(111)\n", + " plt.plot([1, 2, 3])\n", + " # now create a subplot which represents the top plot of a grid\n", + " # with 2 rows and 1 column. Since this subplot will overlap the\n", + " # first, the plot (and its axes) previously created, will be removed\n", + " plt.subplot(211)\n", + " \n", + " If you do not want this behavior, use the `.Figure.add_subplot` method\n", + " or the `.pyplot.axes` function instead.\n", + " \n", + " If no *kwargs* are passed and there exists an Axes in the location\n", + " specified by *args* then that Axes will be returned rather than a new\n", + " Axes being created.\n", + " \n", + " If *kwargs* are passed and there exists an Axes in the location\n", + " specified by *args*, the projection type is the same, and the\n", + " *kwargs* match with the existing Axes, then the existing Axes is\n", + " returned. Otherwise a new Axes is created with the specified\n", + " parameters. We save a reference to the *kwargs* which we use\n", + " for this comparison. If any of the values in *kwargs* are\n", + " mutable we will not detect the case where they are mutated.\n", + " In these cases we suggest using `.Figure.add_subplot` and the\n", + " explicit Axes API rather than the implicit pyplot API.\n", + " \n", + " See Also\n", + " --------\n", + " .Figure.add_subplot\n", + " .pyplot.subplots\n", + " .pyplot.axes\n", + " .Figure.subplots\n", + " \n", + " Examples\n", + " --------\n", + " ::\n", + " \n", + " plt.subplot(221)\n", + " \n", + " # equivalent but more general\n", + " ax1 = plt.subplot(2, 2, 1)\n", + " \n", + " # add a subplot with no frame\n", + " ax2 = plt.subplot(222, frameon=False)\n", + " \n", + " # add a polar subplot\n", + " plt.subplot(223, projection='polar')\n", + " \n", + " # add a red subplot that shares the x-axis with ax1\n", + " plt.subplot(224, sharex=ax1, facecolor='red')\n", + " \n", + " # delete ax2 from the figure\n", + " plt.delaxes(ax2)\n", + " \n", + " # add ax2 to the figure again\n", + " plt.subplot(ax2)\n", + " \n", + " # make the first axes \"current\" again\n", + " plt.subplot(221)\n", + "\n" + ] + } + ], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} -- Gitee