02.Basic_grammar_and_variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Python 基础语法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 程序可以分解为模块、语句、表达式以及对象：\n",
    "- 程序由模块构成\n",
    "- 模块包含语句\n",
    "- 语句包含表达式\n",
    "- 表达式建立并处理对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Python 注释"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 中单行注释以 **#** 开头"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "# 第一个注释\n",
    "print('Hello, Python!')      # 第二个注释"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多行注释可以用多个 # 号，或者使用三个单引号 ''' 或三个双引号 \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "# 第一个注释\n",
    "# 第二个注释\n",
    " \n",
    "'''\n",
    "第三个注释\n",
    "第四个注释\n",
    "'''\n",
    " \n",
    "\"\"\"\n",
    "第五个注释\n",
    "第六个注释\n",
    "\"\"\"\n",
    "print('Hello, Python!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 行与缩进\n",
    "\n",
    "Python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。代码块内的语句会垂直对齐，块会在碰到缩进量较少的行或文件末尾时结束，而更深层的嵌套块比所在块进一步向右缩进。\n",
    "\n",
    "缩进的空格数是可变的（默认为四个空格），同一个代码块的语句必须包含相同的缩进空格数。多数IDE会在输入代码时自动缩进来符合 Python 规范。\n",
    "\n",
    "避免混合使用制表符和空格。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "block2\n",
      "block1\n",
      "block0\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "if x:\n",
    "    y = 2\n",
    "    if y:\n",
    "        print('block2')\n",
    "    print('block1')\n",
    "print('block0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面代码的块结构如图所示。\n",
    "\n",
    "![2.bolck_indentation](images/chapter02/bolck_indentation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下代码最后一行语句缩进数的空格数不一致，会导致运行错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something\n"
     ]
    }
   ],
   "source": [
    "if False:\n",
    "    print('True')\n",
    "else: \n",
    "    print('Something')\n",
    "  #print(\"False\")    # 缩进不一致，会导致运行错误"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 空行\n",
    "\n",
    "函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。\n",
    "\n",
    "空行与代码缩进不同，书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 同一行显示多条语句\n",
    "\n",
    "Python允许在同一行中编写多条非复合语句（语句内未嵌套其它语句），语句之间使用分号(;)分割。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run\n"
     ]
    }
   ],
   "source": [
    "import sys; x = 'run'; print(x)              # More than one simple statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但是应该坚持每个语句独立一行，这样会使程序更具有可读性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 import 与 from...import\n",
    "\n",
    "在 Python 中用 import 或者 from...import 来导入相应的模块。\n",
    "\n",
    "将整个模块(somemodule)导入，格式为： import somemodule\n",
    "\n",
    "从某个模块中导入某个函数,格式为： from somemodule import somefunction\n",
    "\n",
    "从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc\n",
    "\n",
    "将某个模块中的全部函数导入，格式为： from somemodule import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Command line arguments: \n",
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py\n",
      "-f\n",
      "C:\\Users\\Devon\\AppData\\Roaming\\jupyter\\runtime\\kernel-54fd57e3-aa6a-442b-b72b-cc0cded8b806.json\n",
      "System path:  ['D:\\\\Python\\\\python-deep-learning', 'C:\\\\ProgramData\\\\Anaconda3\\\\python38.zip', 'C:\\\\ProgramData\\\\Anaconda3\\\\DLLs', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib', 'C:\\\\ProgramData\\\\Anaconda3', '', 'C:\\\\Users\\\\Devon\\\\AppData\\\\Roaming\\\\Python\\\\Python38\\\\site-packages', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\locket-0.2.1-py3.8.egg', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin', 'C:\\\\ProgramData\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions', 'C:\\\\Users\\\\Devon\\\\.ipython']\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print('Command line arguments: ')\n",
    "for i in sys.argv:\n",
    "    print(i)\n",
    "print('System path: ', sys.path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.6 Python 关键字\n",
    "\n",
    "这些保留字不能用作常量或变量，或任何其他标识符名称。\n",
    "\n",
    "|  |   |   |   |   |\n",
    "|:--:|:-:|:-:|:-:|:-:|\n",
    "| False | None | True | and | as |\n",
    "| assert | async | await | break | class |\n",
    "| continue | def | del | elif | else |\n",
    "| except | finally |for | from | global |\n",
    "| if | import | in | is | lambda |\n",
    "| nonlocal | not | or | pass | raise |\n",
    "| return | try | while| with | yield |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35 ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(len(keyword.kwlist), keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.7 变量命名规则\n",
    "\n",
    "- 第一个字符必须是字母表中字母或下划线 _ 。\n",
    "\n",
    "- 标识符的其他的部分由字母、数字和下划线组成。\n",
    "      spam、_spam、Spam_1 都是合法的变量名，但是 1_Spam、spam$ 以及 @#! 则不是合法变量名。\n",
    "\n",
    "- 标识符对大小写敏感\n",
    "      例如，spam 和 SPAM 是两个不同的变量名\n",
    "      \n",
    "- 禁止使用关键字\n",
    "      定义的变量名不能和 Python 中关键字相同。例如，如果使用像 class 这样的变量名，会引发语法错误。但允许使用类似 kclass 和 Class 作为变量名。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 变量类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 核心数据类型\n",
    "\n",
    "变量类型是指变量所指的内存中对象的类型。下表是 Python 的核心对象类型和生成这些对象的表达式。\n",
    "\n",
    "|对象类型|英文名|示例|\n",
    "|:------|:-----|:--|\n",
    "|数字    |Numbers|1234, 3.1415, 3+4j, 0b111, Decimal(), Fraction()|\n",
    "|字符串  |Strings|'spam', \"guido's'\", b'a\\x01c', u'sp\\xc4m'|\n",
    "|列表    |Lists|[1, [2, 'three'], 4.5], list(range(10))|\n",
    "|字典    |Dictionaries|{'food': 'spam', 'taste': 'yum'}, dict(hours=10)|\n",
    "|元组    |Tuples|(1, 'spam', 4, 'U'), tuple('spam'), namedtuple|\n",
    "|文件    |Files|open('eggs.txt'), open(r'C:\\ham.bin', 'wb')|\n",
    "|集合    |Sets|set('abc'), {'a', 'b', 'c'}|\n",
    "|其他类型 |Other core types|None|\n",
    "|编程单元类型|Program unit types|函数、模块、类|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。\n",
    "\n",
    "等号运算符（=）用来给变量赋值，运算符左边是一个变量名，运算符右边是存储在变量中的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "counter = 100             # 整型变量\n",
    "miles   = 1000.0          # 浮点型变量\n",
    "name    = 'python'        # 字符串\n",
    " \n",
    "print(type(counter))\n",
    "print(type(miles))\n",
    "print(type(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 不可变类型（数字、字符串、元组、不可变集合）\n",
    "\n",
    "不可变类型的对象不支持原地修改，我们可以创建新的对象来存储表达式的运行结果。\n",
    "\n",
    "### 可变类型（列表、字典、可变集合）\n",
    "\n",
    "可变的类型总是可以通过操作原地修改，而不用创建新的对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 数字(Number)\n",
    "\n",
    "Python 中数字有多种类型：整数、浮点数、布尔类型、分数类型、复数类型和二进制、八进制、十六进制记数。\n",
    "\n",
    "- int (整数)，如 1, 只有一种整数类型 int，表示为长整型，没有 Python2 中的 Long\n",
    "- float (浮点数)，如 1.23、3E-2\n",
    "- bool (布尔类型)，如 True，False\n",
    "- fraction (分数类型)，如 Fraction(1, 4)\n",
    "- complex (复数类型)，如 1 + 2j、 1.1 + 2.2j\n",
    "- binary, octal, hex (二进制、八进制和十六进制)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "# Python可以同时为多个变量赋值\n",
    "a, b, c, d = 20, 5.5, True, 4+3j\n",
    "print(type(a), type(b), type(c), type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "来看几个简单的数字运算的例子，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1267650600228229401496703205376"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \\* 表示乘法，/ 表示除法，// 表示整除（floor除法），** 表示乘方。另外，在Python 2.x中，整数除以整数的结果是整数，比如，7 / 5 的结果是1。但在Python 3.x中，整数除以整数的结果是小数（浮点数）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 内置数学模块\n",
    "除了核心对象类型和表达式之外，和 Python 一起分发的还有一些常用的数学模块，模块只不过是我们导入以供使用的一些额外工具包。**math** 模块包括更高级的数学工具，如数学常量和数学函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592653589793, 2.718281828459045)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.pi, math.e       # Common constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.219544457292887"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(85)         # Square root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03489949670250097"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(2 * math.pi / 180)    # Sine, tangent, cosine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "math 模块中还包含了trunc截断、floor、ceil方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, -3)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(2.567), math.floor(-2.567)     # Floor (next-lower integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, -2)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(2.567), math.ceil(-2.567)      # Ceil (next-uper integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, -2)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.trunc(2.567), math.trunc(-2.567)    # Truncate (drop decimal digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也可以用内置函数 int() 和 round() 进行取整操作，前者会直接省略小数部分，而后者进行四舍五入："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, -2)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.567), int(-2.567)                        # Truncate (integer conversion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 2.57)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.567), round(2.467), round(2.567, 2)    # Round"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('2.6', '2.57')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%.1f' %2.567, '{0:.2f}'.format(2.567)         # Round for display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "标准库中的 random 模块可以作为随机数字的生成器和随机选择器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2864884203924346"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.random()                 # Return the next random floating point number in the range [0.0, 1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(1, 10)           # Return a random integer N such that a <= N <= b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice([1, 2, 3, 4])     # Return a random element from the non-empty sequence seq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 布尔类型\n",
    "\n",
    "与 C/C++ 不同，Python 拥有明确的布尔型数据类型，叫做 bool，其值为 True 和 False，并且其值 True 和 False 是预先定义的内置的变量名。在内部，变量名 True 和 False 是 bool 的实例，实际上仅仅是内置的整数类型 int 的子类（以面向对象的观点来看）。True 和 False 的行为和整数 1 和 0 是一样的，除了它们有特定的显示逻辑：它们是作为关键字 True 和 False 显示的，而不是数字 1 和 0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == 1         # ==操作符测试两个对象是否有相同的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<>:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "<ipython-input-28-dbfe9bb971f2>:1: SyntaxWarning: \"is\" with a literal. Did you mean \"==\"?\n",
      "  True is 1         # is操作符检查两个对象的同一性\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True is 1         # is操作符检查两个对象的同一性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + 4         # 你不可能在真正的 Python 代码中遇到这样的表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 分数类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从 Python 2.6和 Python 3.0 开始引入了分数类型，它明确保留一个分子和一个分母，从而避免了浮点数学的某些不精确性和局限性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/3\n",
      "<class 'fractions.Fraction'>\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "x = Fraction(1, 3)\n",
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/3\n"
     ]
    }
   ],
   "source": [
    "y = Fraction(4, 6)          # Simplified to 2, 3\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦创建了分数，它可以像平常一样用于数学表达式中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Fraction(1, 1), Fraction(-1, 3), Fraction(2, 9))"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y, x- y, x * y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7/3\n",
      "2.3333333333333335\n",
      "5/3\n"
     ]
    }
   ],
   "source": [
    "print(x + 2)\n",
    "print(x + 2.0)\n",
    "print(x + Fraction(4, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分数对象也可以从浮点数字符串来创建，这和小数很相似："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(1, 4)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fraction('.25')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(3, 2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Fraction('.25') + Fraction('1.25')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于那些用内存中给定的有限位数无法精确表示的值，浮点数的局限尤为明显。分数却能提供得到精确结果的方式，虽然要付出一些速度的代价。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.551115123125783e-17"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.1 + 0.1 - 0.3         # This should be zero (close, but not exact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(0, 1)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "Fraction(1, 10) + Fraction(1, 10) + Fraction(1, 10) - Fraction(3, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 复数类型\n",
    "复数表示为两个浮点数（实部和虚部）并接在虚部增加了j或J的后缀。我们能够把非零实部的复数写成由 + 连接起来的两部分。例如，一个复数的实部为2，并且虚部为-3可以写成 2+ -3j。下面是一些复数运算的例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+0j)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1j * 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2+3j)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 1j * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6+3j)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 + 1j) * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 二进制、八进制和十六进制记数\n",
    "\n",
    "Python 整数能够以二进制、八进制和十六进制记数法来编写，作为一般的十进制记数法的补充，分别以 **0b**，**0o** 和 **0x** 开头。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 16, 255)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b1, 0b10000, 0b11111111    # Binary literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 16, 255)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0o1, 0o20, 0o377         # Octal literals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 16, 255)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x01, 0x10, 0xff         # Hex literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 提供了内置的函数，可以将整数转换为其他进制的数字字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('0b1000000', '0o100', '0x40')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(64), oct(64), hex(64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 内置的 int() 函数可以将一个数字的字符串变换为一个整数，并可以通过第二个参数来确定变换后的数字的进制。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64, 64, 64)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('64'), int('1000000', 2), int('100', 8), int('40', 16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('0x40', 16), int('0b1000000', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，我们可以使用字符串格式化方法将一个整数转换成二进制、八进制或十六进制数的字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1000000, 100, 40'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:b}, {1:o}, {2:x}'.format(64, 64, 64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6 位运算\n",
    "\n",
    "除了一般的数学运算，Python 也支持位运算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "x << 2         # Shift left 2 bits: 0100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x | 2          # OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x & 1          # AND"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个领域中，二进制和十六进制数变得特别有用，它们允许我们按照字符串来编写和查看数字："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = 0b0001       # Binary literals\n",
    "x << 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b100'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(x << 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b11'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(X | 0b010)  # Bitwise OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(X & 0b1)    # Bitwise AND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b11111111'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = 0xFF        # Hex literals\n",
    "bin(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "85"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X ^ 0b10101010    # Bitwise XOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1010101'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(X ^ 0b10101010)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 字符串(String)\n",
    "\n",
    "字符串——一个有序的字符的集合，用来存储和表现基于文本的信息。从功能的角度来看，字符串可以用来表示能够像文本那样编辑的任何信息：符号和词语、载入到内存中的文本文件的内容、Internet网址和Python程序等。\n",
    "\n",
    "与 C 语言中的字符串不同，Python 中的字符串变成了一种强大的处理工具集，并且没有单个字符的这种类型。\n",
    "\n",
    "有多种方法编写 Python 中的字符串常量：\n",
    "\n",
    "- 单引号：'spa\"m'\n",
    "- 双引号：\"spa'm\"\n",
    "- 三引号：'''...spam...''', \"\"\"...spam...\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a paragraph,\n",
      "consist of multiple lines.\n"
     ]
    }
   ],
   "source": [
    "paragraph = \"\"\"This is a paragraph,\n",
    "consist of multiple lines.\"\"\"\n",
    "print(paragraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串可以通过 + 操作符进行合并，并且可以通过 * 操作符进行重复："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('abc')         # Length: number of items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' + 'def'      # Concatenation: a new string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ni!Ni!Ni!Ni!'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Ni!' * 4          # Repetition: like \"Ni!\" + \"Ni!\" + ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print('-' * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用 for 语句在一个字符串中进行循环迭代。for 循环指派了一个变量去获取一个字符串中的元素，并为每个元素执行一段语句。这里，变量 c 成为了在这个字符串中步进的指针。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h a c k e r "
     ]
    }
   ],
   "source": [
    "myjob = 'hacker'\n",
    "for c in myjob:\n",
    "    print(c, end=' ')    # Step through items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用 in 表达式操作符对字符和子字符串进行包含关系的测试（实际上是一种搜索）。对于子字符串，in 很像str.find()方法，但是，它返回一个布尔结果而不是子字符串的位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'k' in myjob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'z' in myjob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'spam' in 'abcspamdef'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 单双引号字符串是一样的\n",
    "\n",
    "在 Python 字符串中，单引号和双引号字符是可以互换的。也就是说，字符串常量表达式可以用两个单引号或两个双引号来表示——两种形式同样有效并返回相同类型的对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('strawberry', 'strawberry')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'strawberry', \"strawberry\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之所以这两种形式都能够使用，是因为你可以不使用转义字符就可以实现在一个字符串中包含另外种类的引号。可以在一个双引号字符所包含的字符串中嵌入一个单引号字符，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('knight\"s', \"knight's\")"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'knight\"s', \"knight's\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"knight's\", 'knight\"s')"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'knight\\'s', \"knight\\\"s\"           # 使用转义字符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，Python 自动在任意的表达式中合并相邻的字符串常量（可以简单使用+操作符来明确表示这是一个合并操作）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Meaning of Life'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "title = \"Meaning \" 'of' \" Life\"    # Implicit concatenation\n",
    "title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 用转义序列 (escape sequences) 代表特殊字节\n",
    "\n",
    "转义序列让我们能够在字符串中嵌入不容易通过键盘输入的字节。字符'\\\\'以及在它后边的一个或多个字符，在最终的字符串对象中会被一个单个字符所代替，这个字符通过转义序列定义了一个二进制值。\n",
    "\n",
    "|转义|意义|\n",
    "|:-:|:--|\n",
    "|\\\\\\\\|反斜杠（保留\\\\）|\n",
    "|\\\\\\'|单引号（保留'）|\n",
    "|\\\\\\\"|双引号（保留\"）|\n",
    "|\\\\a|响铃|\n",
    "|\\\\b|倒退|\n",
    "|\\\\f|换页|\n",
    "|\\\\n|换行|\n",
    "|\\\\r|返回|\n",
    "|\\\\t|水平制表符|\n",
    "|\\\\v|垂直制表符|\n",
    "|\\\\xhh|十六进制值（两位数字）|\n",
    "|\\\\ooo|八进制值（三位数字）|\n",
    "|\\\\0|Null|\n",
    "|\\\\other|除此之外的其他字符不转义|\n",
    "\n",
    "\n",
    "例如，下面是一个五个字符的字符串，其中包含了一个换行符和一个制表符："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tsentence\n",
      "\\tsentence\n"
     ]
    }
   ],
   "source": [
    "word1 = '\\tsentence'\n",
    "word2 = r\"\\tsentence\"\n",
    "print(word1)\n",
    "print(word2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\tc\n"
     ]
    }
   ],
   "source": [
    "s = 'a\\nb\\tc'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了清楚地了解这个字符串中到底有多少个字节，可以使用内置的 len() 函数。它会返回一个字符串中到底有多少字节，无论它是如何显示的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 raw字符串抑制转义\n",
    "\n",
    "如上一节所述，转义序列用来处理嵌入在字符串中的特殊字节编码是很有用的。尽管如此，有些时候，为了引人转义字符而使用适应的反斜杠的处理会带来一些麻烦。例如，像下面这样使用文件名参数去尝试打开一个文件："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# myfile = open('C:\\new\\text.dat', 'w')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可能会认为这将打开一个在 *C:\\new* 目录下名为 *text.dat* 的文件。问题是这里有 \"\\n\"，它会被识别为一个换行字符，\"\\t\" 会被一个制表符所替代。结果就是，这个调用是尝试打开一个名为 *C:(换行)ew(制表符)ext.dat* 的文件，而不是我们所期待的结果。\n",
    "\n",
    "这正是使用raw字符串所要解决的问题。如果字母r（小写或大写）出现在字符串引号的前面，它将关闭转义机制，Python 将反斜杠作为常量来保持。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# myfile = open(r'C:\\new\\text.dat', 'w')\n",
    "# myfile = open('C:\\\\new\\\\text.dat', 'w')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 三重引号编写多行字符串块\n",
    "\n",
    "Python 支持三重引号内的字符串常量格式，有时也称之为块字符串，这是一种对编写多行文本数据来说很便捷的语法。三重引号字符串在程序需要输入多行文本的时候很有帮助。例如，嵌入多行错误信息或在源文件中编写HTML或XML代码。\n",
    "\n",
    "这个形式以三重引号开始（单引号和双引号都可以），并紧跟任意行数的文本，并且以开始时的同样的三重引号结尾。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Always look\\n on the bright\\nside of life.'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mantra = '''Always look\n",
    " on the bright\n",
    "side of life.'''\n",
    "mantra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 将所有在三重引号内的文本收集到一个单独的多行字符串中，并在代码换行处嵌入了换行字符(\\n)。要查看带有换行解释的字符串，需要使用 print() 函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Always look\n",
      " on the bright\n",
      "side of life.\n"
     ]
    }
   ],
   "source": [
    "print(mantra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三重引号字符串经常在开发过程中作为一种注释手段。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = 1\n",
    "\"\"\"\n",
    "import os           # Disable this code temporarily\n",
    "print(os.getcwd())\n",
    "\"\"\"\n",
    "Y = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.5 索引和分片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为可以将字符串定义为字符的有序集合，所以我们能够通过其位置获得它们的元素。在 Python 中，字符串中的字符是通过索引提取的。\n",
    "\n",
    "与 C/C++ 语言一样，Python 偏移量是从 0 开始的，并比字符串的长度小1。与 C/C++ 语言不同，Python 还支持在字符串中使用负偏移从序列中获取元素。从技术来讲，一个负偏移与字符串的长度相加后得到这个字符串的正的偏移值。可以将负偏移看做是从结束处反向计数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('s', 'a')"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'sliceofspam'\n",
    "S[0], S[-2]                 # Indexing from front or end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![string](images/chapter02/string_offset.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('li', 'liceofspam', 'sliceofspa')"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S[1:3], S[1:], S[:-1]       # Slicing: extract a section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分片是如何运作的？\n",
    "\n",
    "当时用一对以冒号分隔的偏移来索引字符串时，Python 将返回一个新的对象，其中包含了以这对偏移所标识的连续的内容。左边的偏移作为下边界（**包含下边界在内**），而右边的偏移作为上边界（**不包含上边界在内**）。Python 将获取从下边界直到但不包括上边界的所有元素，并返回一个包含了所获取的元素的新的对象。如果被被省略，上、下边界的默认值分别为 0 和分片对象的长度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "索引（S[i]）获取特定偏移的元素：\n",
    "- 第一个元素的偏移为0\n",
    "- 负偏移索引意味着从最后或右边反向进行计数\n",
    "- S[0]获取了第一个元素\n",
    "- S[-2]获取了导入第二元素（就像S[len(S]-2一样）\n",
    "\n",
    "分片（S[i:j]）提取对应的部分作为一个序列：\n",
    "- 上边界不包含在内\n",
    "- 如果没有给出的话，分片的边界默认为0和序列的长度\n",
    "- S[1:3] 获取了从偏移为1的元素，直到但不包含偏移为3的元素\n",
    "- S[1:] 获取了从偏移为1直到末尾（偏移为序列长度）之间的元素\n",
    "- S[:3] 获取了从偏移为0直到但是不包括偏移为3之间的元素\n",
    "- S[:-1] 获取了从偏移为0直到但是不包括最后一个元素之间的元素\n",
    "- S[:] 获取了从偏移0到末尾之间的元素，这有效实现了顶层S拷贝"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.6 扩展分片：步进\n",
    "\n",
    "分片表达式还有个可选的第三个参数：步进(stride)。完整形式的分片现在变成了 X[I:J:K]，这表示“索引对象 X 中的元素，从偏移为 I 直到偏移为 J-1，每隔 K 元素索引一次”。此处的 K 即为步进，默认值为1，这也是之前我们的切片中从左至右提取每一个元素的原因。如果你定义了一个明确的步长值，那么能够使用第三个限制去跳过某些元素或反向排列它们的顺序。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bdfhj'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'abcdefghijklmnop'\n",
    "S[1:10:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'acegikmo'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以使用负数作为步进，例如分片表达式 'hello' [::-1]返回一个新的字符串 'olleh'。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'olleh'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'hello'\n",
    "S[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fedc'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'abcdefg'\n",
    "S[5:1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*在单次切片操作内，不要同时指定上边界、下边界和步进。如果一定要用步进，那尽量采用正值。*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.7 字符串转换工具"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**int()** 函数可以将字符串转换为整数数字，**float()** 函数可以将浮点数转换成字符串，**str()** 函数可以将数字转换为字符串表达形式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = '42'\n",
    "I = 1\n",
    "# S + I    # TypeError: cannot concatenate 'str' and 'int' objects\n",
    "int(S) + I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'421'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S + str(I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('3.1415', 1.5)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(3.1415), float('1.5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.234e-10"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = '1.234E-10'\n",
    "float(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "单个的字符可以通过将其传给内置的 ord() 函数转换为其对应的 ASCII 码，而 chr() 函数将会执行相反的操作，将 ASCII码转化为对应的字符："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "115\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "print(ord('s'))        # Return an integer of the given single Unicode character\n",
    "print(chr(115))        # Return a string of the given number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用 ord() 和 chr() 函数，可以执行基于字符串的数学运算。预先将当前字符转换为整形并进行如下的数学运算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = '5'\n",
    "S = chr(ord(S) + 1)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'7'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = chr(ord(S) + 1)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将一个表示二进制的字符串转换为等值的十进制整数\n",
    "B = '1101'\n",
    "I = 0\n",
    "while B != '':\n",
    "    I = I * 2 + (ord(B[0]) - ord('0'))\n",
    "    B = B[1:]\n",
    "I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('1101', 2)        # Convert binary to integer: build-in function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.8 修改字符串\n",
    "\n",
    "Python 中字符串属于不可变序列。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = 'spam'\n",
    "# S[0] = 'x'        # TypeError: 'str' object does not support item assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "那么我们如何改变字符串呢？\n",
    "\n",
    "若要改变一个字符串，需要利用合并、分片这样的工具来建立并赋值给一个新的字符串，倘若必要的话，还要将这个结果赋值给字符串最初的变量名。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spamSPAM!'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = S + 'SPAM!'\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spamBurger!'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = S[:4] + 'Burger' + S[-1]\n",
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第一个例子在S后面加了一个字符串，通过合并创建了一个新的字符串，并赋值给S。你可以将它看作是对原字符串的“修改”。第二个例子通过分片、索引、合并将其中4个字符替换为6个字符，这一结果也可以通过 *replace()* 这样的字符串方法来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spamalot'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'splot'\n",
    "S = S.replace('pl', 'pamal')\n",
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这些方法每次都产生了新的字符串对象，如果愿意保留那些对象，可以将其赋值给新的变量名。Python 在运行的过程中，对那些不再使用的字符串对象自动进行垃圾回收（**GC**，Garbage Collection），所以 Python 并不会因为频繁修改字符串而变得效率低下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，可以通过字符串**格式化**表达式来创建新的文本值。在某种意义上，它是把对象转换为字符串并且根据指定的格式来改变最初的字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'That is 1 dead bird!'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'That is %d %s bird!' % (1, 'dead')          # Format expression: all Pythons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'That is 1 dead bird!'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'That is {0} {1} bird!'.format(1, 'dead')    # Format method in 2.6, 2.7, 3.X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.9 字符串方法\n",
    "\n",
    "除表达式运算符之外，字符串还提供了一系列的方法来实现更复杂的文本处理任务。方法就是与特定的对象相关联在一起的函数，也称之为成员函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir('')                                     # 内置的 dir()函数可以获得对象内可用所有属性的列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 查找和替换\n",
    "\n",
    "可以使用 **find()** 方法搜索子字符串。该方法范围子字符串出现处的偏移或者未找到时返回 -1。和此前的 in 表达式同样是进行子字符串的查找操作，但是 **find()** 返回的是所找到的字符串的位置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'xxxxSPAMxxxxSPAMxxxx'\n",
    "where = S.find('SPAM')           # Search for position\n",
    "where                            # Occurs at offset 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xxxxEGGSxxxxEGGSxxxx'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S = 'xxxxSPAMxxxxSPAMxxxx'\n",
    "S.replace('SPAM', 'EGGS')        # Replace all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xxxxEGGSxxxxSPAMxxxx'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S.replace('SPAM', 'EGGS', 1)     # Replace one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 文本解析\n",
    "\n",
    "字符串的 **split()** 方法将一个字符串分割为一个子字符串的列表，以分隔符字符串为标准。如果没有传递分隔符，默认的分隔符为空格。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aaa', 'bbb', 'ccc']"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = 'aaa bbb ccc'\n",
    "cols = line.split()\n",
    "cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bob', 'hacker', '40']"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = 'bob,hacker,40'        # 读取自csv文件\n",
    "line.split(',')               # 使用逗号作为分隔符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分隔符也可以是一个字符串："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"i'm\", 'a', 'lumberjack']"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = \"i'mSPAMaSPAMlumberjack\"\n",
    "line.split(\"SPAM\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 大小写转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THE KNIGHTS WHO SAY NI!\\n'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = \"The knights who say Ni!\\n\"\n",
    "line.upper()        # Upper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the knights who say ni!\\n'"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line.lower()        # Lower"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.10 字符串格式化\n",
    "\n",
    "Python 中的字符串格式化有两种实现形式：\n",
    "\n",
    "- 字符串格式化表达式 %\n",
    "      这是从 Python 诞生之初就有的方法，类似 C 语言的 printf() 函数\n",
    "      在 % 操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个（或多个）嵌入的转换目标，都以 % 开头（例如 %d）\n",
    "      在 % 操作符的右侧放置一个（或多个）对象）（多个对象时使用括号把它们括起来成为一个元组），这些对象将会插入到左侧对应的转换目标的位置上去\n",
    "      \n",
    "- 字符串格式化 format() 方法\n",
    "      这是 Python 2.6 和 Python 3.x 新增加的方法，类似 C# 中 String.Format 方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串格式化表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'That is 1 dead bird!'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'That is %d %s bird!' % (1, 'dead')   # Format expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The knights who say Ni!'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exclamation = 'Ni'\n",
    "'The knights who say %s!' % exclamation  # String substitution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 spam 4 you'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%d %s %g you' % (1, 'spam', 4.0)   # Type-specific substitutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 -- 3.14159 -- [1, 2, 3]'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%s -- %s -- %s' % (42, 3.14159, [1, 2, 3]) # All types match a %s target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于特定类型的格式化，可以在格式化表达式中使用下表列出的转换代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|代码| 意义 |\n",
    "|:-:|:--|\n",
    "|s| 字符串 (或者对象x转成str(x)的字符串)|\n",
    "|r| 和s类似，但是使用repr, 而不是 str|\n",
    "|c| 字符 (int or str)|\n",
    "|d| 十进制整数|\n",
    "|i| 整数|\n",
    "|u| 与d一样|\n",
    "|o| 八进制整数|\n",
    "|x| 十六进制整数|\n",
    "|X| 与 x 一样，但是使用大写字母|\n",
    "|e| 浮点指数|\n",
    "|E| 与 e 一样，但是使用大写字母|\n",
    "|f| 浮点数|\n",
    "|F| 与 f 一样，但是使用大写字母|\n",
    "|g| 浮点数 e 或 f|\n",
    "|G| 浮点数 E or F|\n",
    "|%| 常量 % (等同于 %%)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'integer: ...1234...1234  ...001234'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1234\n",
    "res = 'integer: ...%d...%-6d...%06d' % (x, x, x)    # -:左对齐，0:补零\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.234568e+00 | 1.234568 | 1.23457'"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 1.23456789\n",
    "'%e | %f | %g' % (y, y, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.23   | 01.23 | +001.2'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%-6.2f | %05.2f | %+06.1f' % (y, y, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "还可以通过引用字典中的键来提取相应的值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 more spam'"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'%(qty)d more %(food)s' % {'qty':1, 'food':'spam'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串格式化 format() 方法\n",
    "\n",
    "和格式化表达式不同，格式化方法的意图更加详细而明确，有时比格式化表达式需要更多的代码，且在高级用途的时候很复杂。\n",
    "\n",
    "它使用主体字符串作为模板，接收任意多个表示将要根据模板替换的值作为参数。在主体字符串中，花括号通过**位置**（例如{1}）或者**关键字**（例如{food}）或者**相对位置**指出替换目标及将要插入的参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam, ham and eggs'"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template = '{0}, {1} and {2}'              # By position\n",
    "template.format('spam', 'ham', 'eggs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam, ham and eggs'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template = '{motto}, {pork} and {food}'    # By keyword\n",
    "template.format(motto='spam', pork='ham', food='eggs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam, ham and eggs'"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template = '{motto}, {0} and {food}'      # 实际代码中不建议交换位置次序\n",
    "template.format('ham', motto='spam', food='eggs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam, ham and eggs'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template = '{}, {} and {}'                # By relative position\n",
    "template.format('spam', 'ham', 'eggs')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用format() 方法的也可以是一个临时字符串的常量，并且任意的对象类型都可以替换："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14, 42 and [1, 2]'"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串格式化方法可以指定对象属性和字典键："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My laptop runs win32'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "'My {1[kind]} runs {0.platform}'.format(sys, {'kind': 'laptop'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字符串格式化方法中的方括号可以指定列表（或其他的序列）偏移量以执行索引，但是，只有单个正偏移值才有效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'first=S, last=M'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "somelist = list('SPAM')               # Change string to list\n",
    "'first={0[0]}, last={0[3]}'.format(somelist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面例子的{0:10}意味着第一个位置将被格式化为10字符宽度，{1:<10}意味着第二个位置将被格式化为10字符宽度并且**左对齐**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam       = 123.4567  '"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:10} = {1:<10}'.format('spam', 123.4567)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在格式化方法调用中，浮点数采用与 % 表达式中相同的代码类型和格式化声明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.3333'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:.4f}'.format(1 / 3.0)            # Parameters hardcoded，位置0可以被省略"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.141590e+00, 3.142e+00, 3.141590'"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floating-point numbers\n",
    "'{0:e}, {1:.3e}, {2:f}'.format(3.14159, 3.14159, 3.14159)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 尽量使用新的格式化方法\n",
    "\n",
    "- 有一个更容易记忆的方法名\n",
    "- 拥有表达式 % 所没有的一些额外功能\n",
    "- 可以更明确地进行替代值引用\n",
    "- 表达式 % 在将来可能被废弃"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.11 字符串小结\n",
    "\n",
    "- Python 中的字符串不能改变\n",
    "- Python 中单引号和双引号使用完全相同\n",
    "- 使用三引号('''或\"\"\")可以指定一个多行字符串\n",
    "- 转义符 '\\\\'\n",
    "- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。 如 r\"this is a line with \\n\" 则\\n会显示，并不是换行\n",
    "- 按字面意义级联字符串，如\"this \" \"is \" \"string\"会被自动转换为this is string\n",
    "- 字符串可以用 + 运算符连接在一起，用 * 运算符重复\n",
    "- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始\n",
    "- Python 没有单独的 char 字符类型，一个字符就是长度为 1 的字符串\n",
    "- 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]\n",
    "- 可以用表达式 % 或方法 format() 进行字符串格式化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 练习\n",
    "\n",
    "1. 字符串'a\\nb\\x1f\\000d'共有多少个字符？\n",
    "\n",
    "2. 已知字符串S的值为's,pa,m'，如何从中间抽取两个字符？\n",
    "\n",
    "3. 如何将整数字符串转为二进制字符串？\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}