Unit 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 基本数据类型\n",
    "> ## 3.1 数据类型及操作\n",
    "> ## 3.2 实例3：天天向上的力量\n",
    "> ## 3.3 字符串类型及操作  \n",
    "> ## 3.4 模块2：time库的使用  \n",
    "> ## 3.5 实例4：文本进度条  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 数字类型及操作  \n",
    "> 整数类型、浮点数类型、复数类型、数值运算操作符、数值运算函数  \n",
    "### 3.1.1 整数类型  \n",
    "1. 与数学里面一样，可正可负，没有取值范围限制  \n",
    "` pow(x,y)`：计算$x^y$   \n",
    "2. 四种进制表示形式  \n",
    "十进制：1010、99、-127；二进制：0b1010、-0B1100；八进制：0o123、-0O456（第二个为英文o/O）；十六进制：0x9a、-0X89；  \n",
    "\n",
    "### 3.1.2 浮点数类型  \n",
    "1. 与数学的实数一样，带有小数点及小数的数字，取值范围（$ -10^{308} \\to 10^{308} $）和小数精度有限制（$ 10^{-16} $）  \n",
    "2. 浮点数运算间存在不确定尾数，通过添加` round(x,d) `解决：对x四舍五入，d是小数截取位数；也用于浮点数间运算及比较；不确定尾数一般在$ 10^{-16} $；  \n",
    "3. 浮点数可采用科学计数法表示：使用字母e或者E表示，以10为基数，例如：4.3e-3为0.0043；\n",
    "\n",
    "### 3.1.3 复数类型   \n",
    " 与数学里面一样。\n",
    " \n",
    "### 3.1.4 数值运算操作符  \n",
    "1. 使用`+, -, *, /, //(整除), %(取余), **(幂运算或开方运算), 二元操作符等`；  \n",
    "2. 可使用混合运算，结果一般为“最宽”的类型：整数 $ \\to $ 浮点数 $ \\to $ 复数;  \n",
    "3. 函数运算符：`abs(x)`：取绝对值；`divmod(x,y)`：商余，同时输出商和余数（eg. divmod(10,3)为(3,1)）；  `pow(x,y,z)`：幂余，`(x**y)%z`（`pow(3,pow(3,99),10000)`的结果为4587）；  `round(x,d)`：四舍五入，d是保留小数位数，默认0，（`round(-10.123,2)`：为-10.12）；  $ max(x_1,x_2,\\dots,x_n) ,min(x_1,x_2, \\dots, x_n) $：取最大最小值；  `int(x)`：将x变为整数，舍弃小数部分；  `float(x)`：将x变成浮点数，增加小数部分；  `complex(x)`：将x变成复数，增加虚数部分；    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math.pow(100, 2) :  10000.0\n",
      "pow(100, 2) :  10000\n",
      "math.pow(100, -2) :  0.0001\n",
      "math.pow(2, 4) :  16.0\n",
      "math.pow(3, 0) :  1.0\n",
      "math.pow(3,5) :  243\n",
      "pow(3,5,100) :  43\n"
     ]
    }
   ],
   "source": [
    "import math   # 导入 math 模块\n",
    "\n",
    "print (\"math.pow(100, 2) : \", math.pow(100, 2))\n",
    "# 使用内置，查看输出结果区别\n",
    "print (\"pow(100, 2) : \", pow(100, 2))\n",
    "print (\"math.pow(100, -2) : \", math.pow(100, -2))\n",
    "print (\"math.pow(2, 4) : \", math.pow(2, 4))\n",
    "print (\"math.pow(3, 0) : \", math.pow(3, 0))\n",
    "print (\"math.pow(3,5) : \", pow(3,5))\n",
    "print (\"pow(3,5,100) : \", pow(3,5,100))  #幂余不能使用math.pow()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 实例练习   \n",
    " \n",
    "问题1：千分之一：  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "向上：1.44, 向下：0.69\n"
     ]
    }
   ],
   "source": [
    "# DayDayUpQ1.py\n",
    "dayup = pow(1.001, 365) \n",
    "daydown = pow(0.999, 365)\n",
    "print(\"向上：{:.2f}, 向下：{:.2f}\".format(dayup, daydown))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "向上：6.17，向下：0.16\n"
     ]
    }
   ],
   "source": [
    "# 千分之五和千分之一的力量\n",
    "# DayDayUpQ2.py\n",
    "dayfactor = 0.005\n",
    "dayup = pow(1 + dayfactor, 365)\n",
    "daydown = pow(1 - dayfactor, 365)\n",
    "print(\"向上：{:.2f}，向下：{:.2f}\".format(dayup,daydown))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "工作时间的力量：4.63\n"
     ]
    }
   ],
   "source": [
    "# DayDayUpQ3.py  \n",
    "dayup = 1.0\n",
    "dayfactor = 0.01\n",
    "for i in range(365):\n",
    "    if i % 7 in [6, 0]:\n",
    "        dayup = dayup*(1-dayfactor)\n",
    "    else:\n",
    "        dayup = dayup*(1+dayfactor)\n",
    "print(\"工作时间的力量：{:.2f}\".format(dayup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "工作日的努力参数是：0.019\n"
     ]
    }
   ],
   "source": [
    "# DayDayUpQ4.py\n",
    "def dayUp(df):   # 定义函数\n",
    "    dayup = 1\n",
    "    for i in range(365):\n",
    "        if i % 7 in [6,0]:\n",
    "            dayup = dayup * (1 - 0.01)\n",
    "        else:\n",
    "            dayup = dayup * (1 + df)\n",
    "    return dayup\n",
    "dayfactor = 0.01\n",
    "while dayUp(dayfactor) < 37.78:\n",
    "    dayfactor += 0.001\n",
    "print(\"工作日的努力参数是：{:.3f}\".format(dayfactor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 字符串类型及操作  \n",
    "> 3.3.1字符串类型的表示  \n",
    "> 3.3.2字符串操作符  \n",
    "> 3.3.3字符串处理函数  \n",
    "> 3.3.4字符串处理方法  \n",
    "> 3.3.5字符串类型的格式化  \n",
    "\n",
    "### 3.3.1   \n",
    "1. 字符串有2类共4种表示方法：  \n",
    "    1） 由一对单引号或双引号表示，仅表示单行字符串；   \n",
    "    2） 由一对三单引号或三双引号表示，可表示多行字符串；  \n",
    "2. 字符串序号：正向递增和反向递减；  \n",
    "3. 使用[]获取字符串中一个或多个字符：  \n",
    "    1） 索引：返回字符串中单个字符  `<字符串>[M]`   \n",
    "    2） 切片：返回字符串中一段字符字串 `<字符串>[M:N]`   \n",
    "    3） 使用[M:N:K]根据步长对字符串切片：1 `<字符串>[M:N]`，M缺失表示至开头，N缺失表示至结尾；2 `<字符串>[M:N:K]`，根据步长K对字符串切片：E.g：\"0123456789\"[::-1]结果为：\"9876543210\"；   \n",
    "4. 使用`\\`：转义符表达特定字符的本意；转义符形成一些组合，表达一些不可打印的含义：`\\b`：回退，`\\n`：换行（光标移动到下行首），`\\r`：回车（光标移动到本行首）   \n",
    "### 3.3.2 \n",
    "1. `x + y`：连接两个字符串x和y；   \n",
    "2. `n*x 或 x*n`：复制n次字符串x；  \n",
    "3. `x in s`：如果x是s的子串，返回True，否则返回False；  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "请输入数字（1-7）：3\n",
      "星期三\n"
     ]
    }
   ],
   "source": [
    "# WeekNamePrintV1.py  \n",
    "weekStr = \"星期一星期二星期三星期四星期五星期六星期日\"\n",
    "weekId = eval(input(\"请输入数字（1-7）：\"))\n",
    "pos = (weekId - 1) * 3\n",
    "print(weekStr[pos: pos + 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "请输入星期数字（1-7）：3\n",
      "星期三\n"
     ]
    }
   ],
   "source": [
    "# WeekNamePrintV2.py\n",
    "weekStr = \"一二三四五六日\"\n",
    "weekId = eval(input(\"请输入星期数字（1-7）：\"))   #eval将字符串两侧的引号去掉变成python能运行的语句\n",
    "print(\"星期\" + weekStr[weekId - 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.3    \n",
    "处理字符串的函数：    \n",
    "1. `len(x)`：长度，返回字符串x的长度；   \n",
    "2. `str(x)`：任意类型x所对应的字符串形式；   \n",
    "3. `hex(x) 或 oct(x)`：整数x的十六进制或八进制小写形式字符串；    \n",
    "4. `chr(u)`：u为Unicode编码，返回其对应的字符；   \n",
    "5. `ord(x)`：x为字符，返回其对应的Unicode编码；Unicode编码：统一字符编码，即覆盖几乎所有字符的编码方式，从0到1114111（0x10FFFF）空间每个编码对应一个字符，Python字符串中每个字符都是Unicode编码字符；   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "♈♉♊♋♌♍♎♏♐♑♒♓"
     ]
    }
   ],
   "source": [
    "# 星座的unicode编码 \n",
    "# ConstellationUc.py\n",
    "for i in range(12):\n",
    "    print(chr(9800 + i),end = \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.4   \n",
    "1. “方法”在编程中是专有名词（方法用`.`来使用）    \n",
    "    “方法”特指`<a>.<b>()`风格中的函数`<b>()`；  \n",
    "    方法本身也是函数，但与`<a>`有关，`<a>.<b>()`风格使用；   \n",
    "    字符串及变量也是`<a>`，存在一些方法；   \n",
    "2. 以方法形式提供的字符串处理功能   \n",
    "    `str.lower() 或 str.upper()`：返回字符串的副本，全部字符小写/大写；   \n",
    "    `str.split(sep = None)`：返回一个列表，由str根据sep被分隔的部分组成；E.g：\"A,B,C\".split(\",\")结果为['A','B','C']；    \n",
    "    `str.count(sub)`：返回子串sub在str中出现的次数；   \n",
    "    `str.replace(old,new)`：返回字符串str副本，所有old子串被替换为new；  \n",
    "    `str.center(width,fillchar)`：字符串str根据宽度width居中，fillchar可选；E.g：\"python\".center(20,\"==\")结果为‘=======python=======’；   \n",
    "    `str.strip(chars)`：从str中去掉在其左侧和右侧chars中列出的字符；E.g：\"= python=\".strip(\" =np\")结果为\"ytho\"；  \n",
    "    `str.join(iter)`：在iter变量除最后元素外每个元素后增加一个str；E.g：\",\".join(\"12345\")结果为\"1,2,3,4,5\"，主要用于字符串分隔等；   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.5   \n",
    "> 格式化是对字符串进行格式表达的方式   \n",
    "\n",
    "1. 字符串格式化使用`.format()`方法，用法如下：    \n",
    "`<模板字符串>.format(<逗号分隔的参数>)`     \n",
    "2. 槽：     \n",
    "\n",
    "|  \"{ }      |   :计算机   |   { }        | 的CPU占用率为 |    { }      |  %\"  |  .format(  |  \"2018-10-10\",  |  \"C\"      |    \"10\"    |\n",
    "| :--------: | ----------- | :----------: | ------------- | :---------: | ---- | ---------- | :-------------: | :-------: | :--------: |\n",
    "|$\\uparrow $ |             | $ \\uparrow $ |               | $\\uparrow $ |      |            |   $\\uparrow $   | $\\uparrow$|$\\uparrow $ |\n",
    "|     0      |             |     1        |               |  2          |      |            |      0          |     1     |     2      |\n",
    "\n",
    "`format()`方法的格式控制：`{<参数序号>:<格式控制标记>}`\n",
    "\n",
    "|      :     |  <填充>    |   <对齐>   |   <宽度>   |    <, >    | <.精度>    |    <类型>     |                   |\n",
    "| :--------: | :--------: | :--------: | :--------: | :--------: | :--------: | :--------:    |    :--------:     |\n",
    "|    引号    | 用于填充的 | <左对齐    | 槽设定的   |   数字的   | 浮点数小数 | 整数类型      | >>>\"{0:=^20}\".format(\"PYTHON\")  |\n",
    "|   符号     | 单个字符   | >右对齐    | 输出宽度   |千位分隔符  |精度或字符串| b,c,d,o,x,X   | '=======PYTHON======='          |    \n",
    "|            |            | ^居中对齐  |            |            |最大输出长度| 浮点数类型    | >>>\"{0:\\*>20}\".format(\"BIT\")    |\n",
    "|            |            |            |            |            |            | e,E,f,%       | '\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*BIT'|\n",
    "|            |            |            |            |            |            |               | >>> \"{:10}\".format(\"BIT\")  |\n",
    "|            |            |            |            |            |            |               |  'BIT(空格)'   |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=======PYTHON=======\n",
      "*****************BIT\n",
      "BIT       \n",
      "12,345.68\n",
      "110101001,Ʃ,425,651,1a9,1A9\n",
      "3.140000e+00,3.140000E+00,3.140000,314.000000%\n"
     ]
    }
   ],
   "source": [
    "# format用法\n",
    "for i in range(6):\n",
    "    if(i == 0):\n",
    "        print(\"{0:=^20}\".format(\"PYTHON\"))\n",
    "    elif(i == 1):\n",
    "        print(\"{0:*>20}\".format(\"BIT\"))\n",
    "    elif(i == 2):\n",
    "        print(\"{:10}\".format(\"BIT\"))\n",
    "    elif(i == 3):\n",
    "        print(\"{0:,.2f}\".format(12345.6789))\n",
    "    elif(i == 4):\n",
    "        print(\"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}\".format(425))\n",
    "    elif(i == 5):\n",
    "        print(\"{0:e},{0:E},{0:f},{0:%}\".format(3.14))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 time库的使用（处理时间的标准库）\n",
    "> time库基本格式\n",
    "> 时间获取\n",
    "> 时间格式化\n",
    "> 程序计时应用\n",
    "\n",
    "* 计算机时间的表达；提供获取系统时间并格式化输出功能；提供系统级精确计时功能，用于程序性能分析；  \n",
    "\n",
    "使用：`import time`和`time.<b>()`调用函数即可；   \n",
    "time库包括三类函数：  \n",
    "1. 时间获取：`time()`,`ctime()`,`gmtime()`;   \n",
    "2. 时间格式化：`strftime()`,`strptime()`;   \n",
    "3. 程序计时：`sleep()`,`perf_counter()`;    \n",
    "\n",
    "具体使用：\n",
    "* `time()`：获取时间戳，即计算机内部时间值，浮点数；   \n",
    "* `ctime()`：获取当前时间并以易读方式表示，返回字符串；   \n",
    "* `gmtime()`：获取当前时间，表示为计算机可处理的时间格式；   \n",
    "\n",
    "时间格式化：（将时间以合理的方式展示出来）   \n",
    "* 类似字符串格式化，需要有展示模板；   \n",
    "* 展示模板由特定的格式化控制符组成；   \n",
    "* `strftime(tpl,ts)`：`tpl`是格式化模板字符串，用来定义输出效果；`ts`是计算机内部时间类型变量；\n",
    "* `strptime(str,tpl)`：`str`是字符串形式的时间值，`tpl`：是格式化模板字符串，用来定义输入效果；   \n",
    "\n",
    "| 格式化字符串  |  日期/时间说明  |  值范围和实例  |\n",
    "| :----------:  | :-------------: | :------------: |\n",
    "|      %Y       |      年份       | 0000-9999，例如：1900 |\n",
    "|      %m       |      月份       | 01-12，例如：10  |\n",
    "|      %B       |    月份名称     | January-December，例如：April |\n",
    "|      %b       |   月份名称缩写  | Jan-Dec，例如：Apr   |\n",
    "|      %d       |      日期       | 01-31，例如：25    |\n",
    "|      %A       |      星期       | Monday-Sunday，例如：Wednesday  |\n",
    "|      %a       |    星期缩写     | Mon-Sun，例如：Wed     |\n",
    "|      %H       |   小时（24h制） | 00-23，例如：12     |\n",
    "|      %I       |   小时（12h制） | 01-12，例如：7    |\n",
    "|      %p       |      上/下午    | AM，PM，例如：PM  |\n",
    "|      %M       |        分钟     | 00-59，例如：26   |\n",
    "|      %S       |        秒       | 00-59，例如：26   |    \n",
    "\n",
    "程序计时：   \n",
    "* 测量时间：`perf_counter()`：返回一个CPU级别的精确时间计数值，单位为秒，由于这个计数值起点不确定，连续调用差值（减法操作）才有意义；     \n",
    "* 产生时间：`sleep(s)`：s拟休眠的时间，单位为秒，可以是浮点数；   \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 文本进度条   \n",
    "> 采用字符串方式打印动态变化的文本进度条；进度条需要在一行中逐渐变化；   \n",
    "\n",
    "* 采用`sleep()`模拟一个持续的进度；   \n",
    "* 单行动态刷新：用后打印的字符覆盖之前的字符；`print()`需要被控制；打印后光标退回到之前的位置`\\r`；    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------执行开始---------\n",
      " 0 %[->..........]\n",
      "10 %[*->.........]\n",
      "20 %[**->........]\n",
      "30 %[***->.......]\n",
      "40 %[****->......]\n",
      "50 %[*****->.....]\n",
      "60 %[******->....]\n",
      "70 %[*******->...]\n",
      "80 %[********->..]\n",
      "90 %[*********->.]\n",
      "100%[**********->]\n",
      "-------执行结束-------\n"
     ]
    }
   ],
   "source": [
    "# TextProBarV1.py  文本条多行刷新\n",
    "import time   #引入time库\n",
    "scale = 10    #文本进度条的宽度\n",
    "print(\"---------执行开始---------\")   #开始的标签\n",
    "for i in range(scale+1):\n",
    "    a = '*' * i     #字符串与整数的乘积表示字符串复制的次数\n",
    "    b = '.' * (scale - i)\n",
    "    c = (i/scale) * 100    #输入与输出的百分比\n",
    "    print(\"{:^3.0f}%[{}->{}]\".format(c,a,b))\n",
    "    time.sleep(0.1)\n",
    "print(\"-------执行结束-------\")    #结束的标签"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100%"
     ]
    }
   ],
   "source": [
    "# TextProBarV2.py   文本条单行刷新\n",
    "import time\n",
    "for i in range(101):\n",
    "    print(\"\\r{:3}%\".format(i),end=\"\")   #end= ：改变print默认在最后增加一个换行换到下一行，变为光标停留在当次输出字符串的后面\n",
    "    time.sleep(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------执行开始----------\n",
      "100%[**************************************************->]5.51s\n",
      "-----------执行结束----------\n"
     ]
    }
   ],
   "source": [
    "# TextProBarV3.py   \n",
    "import time\n",
    "scale = 50\n",
    "print(\"执行开始\".center(scale//2,\"-\"))   #在执行开始字符两侧添加‘-’\n",
    "start = time.perf_counter()    #计时\n",
    "for i in range(scale + 1):\n",
    "    a = '*' * i\n",
    "    b = '.' * (scale - i)\n",
    "    c = (i/scale) * 100\n",
    "    dur = time.perf_counter() - start\n",
    "    print(\"\\r{:^3.0f}%[{}->{}]{:.2f}s\".format(c,a,b,dur),end='')\n",
    "    time.sleep(0.1)\n",
    "print(\"\\n\"+\"执行结束\".center(scale//2,'-'))"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}