String_and_file.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 字符串\n",
    "\n",
    "之前我们已经详细介绍了字符串的基础知识，在这里我们对字符串进行更加详细的介绍。\n",
    "\n",
    "## 格式化字符串\n",
    "\n",
    "在构造字符串时，有时我们需要在字符串中进行替换或者设置数字等的格式，此时我们可能需要使用转换说明符“%”或者format()方法。\n",
    "\n",
    "%操作符用于比较简单的字符串替换和格式设置工作，但是已经能够胜任绝大多数的工作。最经常使用的有如下几种：\n",
    "\n",
    "* %d：整数\n",
    "* %f：浮点数\n",
    "* %s：字符串\n",
    "* %e：将数字换为科学计数法\n",
    "\n",
    "比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：Messi，号码：10\n",
      "球员：Xavi，号码：6\n",
      "球员：ter Stegen，号码：1\n",
      "球员：Busquets，号码：5\n",
      "球员：Pique，号码：3\n",
      "球员：Suárez，号码：9\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：%s，号码：%d\" % (p[0], p[1])\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上我们使用%s和%d分别代表需要使用一个字符串和一个整数在这个字符串里面进行替代，而右边的元组则分别将其对应上去。\n",
    "\n",
    "对于浮点数，同理："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.000000 | 0.000000e+00\n",
      "0.100000 | 1.000000e-01\n",
      "0.200000 | 2.000000e-01\n",
      "0.300000 | 3.000000e-01\n",
      "0.400000 | 4.000000e-01\n",
      "0.500000 | 5.000000e-01\n",
      "0.600000 | 6.000000e-01\n",
      "0.700000 | 7.000000e-01\n",
      "0.800000 | 8.000000e-01\n",
      "0.900000 | 9.000000e-01\n"
     ]
    }
   ],
   "source": [
    "num_list = list(range(0, 10))\n",
    "\n",
    "for n in num_list:\n",
    "    print(\"%f | %e\" % (n / 10, n / 10))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，除了列表之外，%操作符还支持字典，用括号来表示字典的键，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi: 10 \n",
      "Xavi: 6\n"
     ]
    }
   ],
   "source": [
    "code = {\n",
    "    'Messi': 10,\n",
    "    'Xavi': 6,\n",
    "    'ter Stegen': 1,\n",
    "    'Busquets': 5,\n",
    "    'Pique': 3,\n",
    "    'Suárez': 9\n",
    "}\n",
    "print(\"Messi: %(Messi)s \\nXavi: %(Xavi)s\" % code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意在%和s之间括号中表示的是字典的键，但是不需要加引号。\n",
    "\n",
    "以上虽然打印出了数字或者字符串，但是可能还不够好看，使用%操作符还可以设置字符串的格式。比如需要保留多少位小数位、字符串所占的长度等。一般的，可以在%和s,d之间用一个数字表示所占的宽度，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码：10\n",
      "球员：      Xavi，号码： 6\n",
      "球员：ter Stegen，号码： 1\n",
      "球员：  Busquets，号码： 5\n",
      "球员：     Pique，号码： 3\n",
      "球员：    Suárez，号码： 9\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：%10s，号码：%2d\" % (p[0], p[1])\n",
    "    print(pstr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而对于浮点数f和e，可以使用%n.mf表示整数位和小数位分别显示n位和m位。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00 | 0.00e+00\n",
      "0.10 | 1.00e-01\n",
      "0.20 | 2.00e-01\n",
      "0.30 | 3.00e-01\n",
      "0.40 | 4.00e-01\n",
      "0.50 | 5.00e-01\n",
      "0.60 | 6.00e-01\n",
      "0.70 | 7.00e-01\n",
      "0.80 | 8.00e-01\n",
      "0.90 | 9.00e-01\n"
     ]
    }
   ],
   "source": [
    "num_list = list(range(0, 10))\n",
    "for n in num_list:\n",
    "    print(\"%1.2f | %1.2e\" % (n / 10, n / 10))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外我们还可以使用以下几个符号声明对齐方式：\n",
    "\n",
    "* +：正数前加正号\n",
    "* -：左对齐\n",
    "* 空格：右对齐，左边用空格填充\n",
    "* 0：用0填充空白\n",
    "\n",
    "比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码：+10\n",
      "球员：      Xavi，号码：+6\n",
      "球员：ter Stegen，号码：+1\n",
      "球员：  Busquets，号码：+5\n",
      "球员：     Pique，号码：+3\n",
      "球员：    Suárez，号码：+9\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：%+10s，号码：%+2d\" % (p[0], p[1])\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：Messi     ，号码：10\n",
      "球员：Xavi      ，号码：6 \n",
      "球员：ter Stegen，号码：1 \n",
      "球员：Busquets  ，号码：5 \n",
      "球员：Pique     ，号码：3 \n",
      "球员：Suárez    ，号码：9 \n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：%-10s，号码：%-2d\" % (p[0], p[1])\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码：10\n",
      "球员：      Xavi，号码：06\n",
      "球员：ter Stegen，号码：01\n",
      "球员：  Busquets，号码：05\n",
      "球员：     Pique，号码：03\n",
      "球员：    Suárez，号码：09\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：% 10s，号码：%02d\" % (p[0], p[1])\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码： 10\n",
      "球员：      Xavi，号码： 6\n",
      "球员：ter Stegen，号码： 1\n",
      "球员：  Busquets，号码： 5\n",
      "球员：     Pique，号码： 3\n",
      "球员：    Suárez，号码： 9\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = \"球员：%10s，号码：% 2d\" % (p[0], p[1])\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用f-string格式化字符串\n",
    "\n",
    "在Python3.6中，引入了一种新的格式化字符串的方法，即f-string，该方法可以替代以上%号的处理方法，使用更加直观便捷，也是我们接下来会逐步使用的方法。当然，很多比较老的代码（比如本讲义中较早写完的部分）还是用的%号，两种方式可以都掌握，然后根据自己的使用习惯决定。\n",
    "\n",
    "所谓的f-string即在定义字符串之前加一个f前缀：\n",
    "```python\n",
    "s = f\"hello\"\n",
    "```\n",
    "\n",
    "在f-string中，可以使用一个大括号，中间是需要插入的表达式，从而完成字符串内容的补全："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：Messi，号码：10\n",
      "球员：Xavi，号码：6\n",
      "球员：ter Stegen，号码：1\n",
      "球员：Busquets，号码：5\n",
      "球员：Pique，号码：3\n",
      "球员：Suárez，号码：9\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "\n",
    "for p in player_list:\n",
    "    pstr = f\"球员：{p[0]}，号码：{p[1]}\"\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要在大括号中进行运算也是完全可以的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2的10次方=1024\n"
     ]
    }
   ],
   "source": [
    "a=2\n",
    "b=10\n",
    "print(f\"{a}的{b}次方={a**b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要在字符串中加入大括号{}，则要用两个表示：{{}}："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2}的{10}次方=1024\n"
     ]
    }
   ],
   "source": [
    "print(f\"{{{a}}}的{{{b}}}次方={a**b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当然，进行格式化也是完全可以的，可以在大括号中加入冒号完成："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码：10\n",
      "球员：      Xavi，号码：06\n",
      "球员：ter Stegen，号码：01\n",
      "球员：  Busquets，号码：05\n",
      "球员：     Pique，号码：03\n",
      "球员：    Suárez，号码：09\n"
     ]
    }
   ],
   "source": [
    "for p in player_list:\n",
    "    pstr = f\"球员：{p[0]:>10s}，号码：{p[1]:02d}\"\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其中“>10s”的“>”为右对齐，左对齐可以使用“<”，居中对其可以使用“^”："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：  Messi   ，号码：10\n",
      "球员：   Xavi   ，号码：06\n",
      "球员：ter Stegen，号码：01\n",
      "球员： Busquets ，号码：05\n",
      "球员：  Pique   ，号码：03\n",
      "球员：  Suárez  ，号码：09\n"
     ]
    }
   ],
   "source": [
    "for p in player_list:\n",
    "    pstr = f\"球员：{p[0]:^10s}，号码：{p[1]:02d}\"\n",
    "    print(pstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串方法\n",
    "\n",
    "字符串也是一个对象，因而也有自己的方法。在Python中，字符串对象已经内置了足够多的方法供我们使用，非常方便。\n",
    "\n",
    "### 转换大小写\n",
    "\n",
    "可以使用str.upper()和str.lower()两个方法转换大小写。该方法最常用的场景是不知道用户的输入是大写还是小写，但是又要比较字符串的时候，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "aragorn\n",
      "True\n",
      "ARAGORN\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = \"aragorn\"\n",
    "b = \"ARGORN\"\n",
    "c = \"Aragorn\"\n",
    "\n",
    "print(a == b)\n",
    "print(c.lower())\n",
    "print(a.lower() == c.lower())\n",
    "print(c.upper())\n",
    "print(a.upper() == c.upper())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串查找和替换\n",
    "\n",
    "可以使用str.find()方法查找字符串中有没有某一个子字符串，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "search!\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Keep calm and do your research!\"\n",
    "loc = str1.find('search')\n",
    "print(loc)\n",
    "print(str1[loc:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "值得注意的是，find()方法只返回找到的第一个满足要求的字符串，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "search! Research ...\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Keep calm and do your research! Research ...\"\n",
    "loc = str1.find('search')\n",
    "print(loc)\n",
    "print(str1[loc:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要替换字符串，可以使用str.replace(s1,s2)方法进行替换，该方法将str中的所有s1替换为s2，并返回替换后的字符串，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keep calm and do your research! Research ...\n",
      "Keep calm and do your resampling! Resampling ...\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Keep calm and do your research! Research ...\"\n",
    "str2 = str1.replace('search', 'sampling')\n",
    "print(str1)\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意replace()方法将所有符合条件的字符串都进行了替换。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 拼接和分割字符串\n",
    "\n",
    "有时我们需要对字符串进行分割，此时可以使用str.split(s1)方法，该方法将字符串str按照s1进行分割，并返回一个列表。比如对于以下字符串，我们希望将其按照逗号分割，则可以使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Messi', ' 10', ' striker', ' Argentina']\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Messi, 10, striker, Argentina\"\n",
    "strlist = str1.split(',')\n",
    "print(strlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要拼接字符串，可以使用str.join(list)方法，该方法将list中的字符串使用str进行拼接，比如上面的例子，我们希望使用#号重新拼接的话，可以使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi# 10# striker# Argentina\n"
     ]
    }
   ],
   "source": [
    "str2 = '#'.join(strlist)\n",
    "print(str2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 去除左右的空白\n",
    "\n",
    "有时为了比较，需要将字符串左边、右边或者两边的空白删掉，此时可以使用str.strip()、str.lstrip()、str.rstrip()命令，分别进行两边、左侧、右侧的空白的删减。比如在上面的例子中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Messi#10#striker#Argentina\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Messi, 10, striker, Argentina\"\n",
    "strlist = str1.split(',')\n",
    "strlist = [s.strip() for s in strlist]\n",
    "print('#'.join(strlist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 判断字符串是否满足特定格式\n",
    "\n",
    "此外，字符串还自带一些判断函数，比如：\n",
    "\n",
    "* isdigit()：是否字符串只由数字构成\n",
    "* isnumeric()：是否全是数字（包括汉字数字）\n",
    "* isupper()、islower()：是否全大写、全小写\n",
    "\n",
    "比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True\n",
      "False False\n",
      "False True\n"
     ]
    }
   ],
   "source": [
    "a = '123'\n",
    "b = '123#'\n",
    "c = '四十四'\n",
    "\n",
    "print(a.isdigit(), a.isnumeric())\n",
    "print(b.isdigit(), b.isnumeric())\n",
    "print(c.isdigit(), c.isnumeric())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一个示例：词频统计\n",
    "\n",
    "作为示例，我们在这里展示一下使用字典和字符串函数统计词频的方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     the : 23\n",
      "     and : 19\n",
      "      of : 16\n",
      "      to : 13\n",
      "      in : 13\n",
      "      is : 12\n",
      "    said : 11\n",
      "      we : 11\n",
      "   Tesla : 10\n",
      "     our : 10\n",
      "    Wood :  9\n",
      "       a :  9\n",
      "    that :  9\n",
      "    year :  9\n",
      "     she :  8\n",
      "      on :  7\n",
      "    this :  7\n",
      "     000 :  6\n",
      "     has :  6\n",
      "      as :  6\n",
      "     for :  6\n"
     ]
    }
   ],
   "source": [
    "text = \"\"\"\n",
    "Ark Invest chief Catherine Wood is holding firm on her thesis on Tesla — which she believes could run to $4,000 a share or higher — telling CNBC's \"ETF Edge\" on Monday that her conviction in the company has actually increased since last year.\n",
    "\n",
    "\"It is our largest position ... and our conviction has increased in the last year or so,\" said Wood, who is founder, CEO and chief investment officer at Ark. \"It's down about 29% this year. And it's always been our largest position this year, and yet our fund is up 28%.\"\n",
    "\n",
    "The way Ark achieves that is through its unique model, Wood said. The company centers on innovation as a growth driver, offering a number of exchange-traded funds focused on cutting-edge areas of the market like artificial intelligence, the future of finance and genomics.\n",
    "\n",
    "Most of Ark's actively managed ETFs are outperforming the broader market this year, and therein lies the strategy for how Ark — whose top holding is, indeed, the periodically downtrodden stock of Tesla — makes its money.\n",
    "\n",
    "\"Last year, when genomics was under assault because of reimbursement concerns and pricing concerns and so forth, we were leaning into those [stocks] heavily,\" which helped offset Tesla's 2018 declines, Wood explained.\n",
    "\n",
    "\"Our second-largest position, Invitae NVTA  -- which we think is one of the most important molecular diagnostic companies out there riding down the cost curve of DNA sequencing -- [is] up 125%,\" she said. \"It got as low as $5 last year. Today it's $18. So leaning into that has really paid off.\"\n",
    "\n",
    "That rang true for the rest of Ark's investments in the genomics space last year, and this year, \"we're doing the same ... with Tesla,\" the CEO said. \"But our conviction level there is so high that it never left our top position.\"\n",
    "\n",
    "Ark's conviction in Tesla has held strong through a myriad of issues — including concerns around profitability, cash flow and execution — both because Wood believes the company is grossly undervalued by Wall Street, and because of Ark's nimble investing method.\n",
    "\n",
    "\"Disruptive innovation is characterized by controversy and volatility, and so we know we are going to get opportunities to buy stocks. We lie in wait for those opportunities,\" Wood said. \"Many people think, because of what we do – disruptive innovation – that we're momentum driven. Absolutely not. We lie in wait. So take Tesla alone. [...] If you take away the performance of the stock ... and just look at what we delivered in alpha because of our trading around controversy, we delivered 175 basis points just from Tesla. And we get opportunities like that throughout the portfolio.\"\n",
    "\n",
    "Tesla's plan to raise $2.7 billion worth of capital didn't phase Wood either, she said Friday in a phone call with CNBC.\n",
    "\n",
    "\"Our bear case has it going to $700 and our bull case is $4,000, but now we think that's too low,\" she said, explaining that Ark's five-year time horizons for each case already assumed capital raises would occur.\n",
    "\n",
    "\"We understand what they're doing,\" Wood continued. \"In our bear case, even if they just were an electric vehicle manufacturer and nothing else, we expected them to raise $10 billion in capital, and in our bull case, which means they're going to need funding to roll out this autonomous strategy, we thought they were going to raise $20 billion.\"\n",
    "\n",
    "That $4,000 target also bakes in what Tesla CEO Elon Musk predicted on an investor call Thursday: that Tesla's self-driving segment would help drive the business to $500 billion.\n",
    "\n",
    "\"That $4,000,000 forecast is higher than $500 billion in the next five years,\" she said.\n",
    "\n",
    "And if Tesla does indeed rally a whopping 1,500% to the $4,000 level, it'll be because analysts finally value the company properly, the CEO argued.\n",
    "\n",
    "\"The analysts following this stock don't know how to analyze it,\" she said, adding that rather than seeing Tesla as exclusively an auto stock or a tech stock, she and her firm see it as a tech-auto-battery-utility hybrid. \"I don't think research departments out there are set up to analyze this stock.\"\n",
    "\n",
    "\"It's something for everyone, and no one can pull it all together,\" she said.\n",
    "\n",
    "Ark, for one, has four analysts in the areas of robotics, energy storage, artificial intelligence and transportation as a service collaborating on covering Tesla, Wood said.\n",
    "\"\"\"\n",
    "## 统计\n",
    "text_list = text.replace('\\r', ' ').replace('\\n', ' ').replace(\n",
    "    '—', ' ').replace('.', ' ').replace(',', ' ').replace('\"', ' ').split(' ')\n",
    "text_list = [t.strip() for t in text_list if t.strip() != '']\n",
    "text_dict = dict()\n",
    "for l in text_list:\n",
    "    if l not in text_dict:\n",
    "        text_dict[l] = 1\n",
    "    else:\n",
    "        text_dict[l] += 1\n",
    "text_freq = []\n",
    "for k in text_dict:\n",
    "    text_freq.append((k, text_dict[k]))\n",
    "## 排序\n",
    "text_freq.sort(key=lambda x: x[1], reverse=True)\n",
    "max_print = 20\n",
    "times = 0\n",
    "for t in text_freq:\n",
    "    print(\"%8s : %2d\" % t)\n",
    "    times += 1\n",
    "    if times > max_print:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 文件\n",
    "\n",
    "文件分为两类：**文本文件**和**二进制文件**。由于文本文件最经常遇到，所以我们在这里主要介绍文本文件。\n",
    "\n",
    "文本文件区别于二进制文件的最大特点在于：文本文件只包含字符，且以换行符隔开每一行。当然，在不同系统中，换行模式是不一样的。在Windows系统中，换行符是两个字符：\"\\r\\n\"，即一个回车和一个换行符；而在Linux以及Unix中，换行符是\"\\n\"，没有\"\\r\"。Python在处理换行时能够自动识别这两种模式，不需要手动修改，非常方便。\n",
    "\n",
    "不过，在介绍文本文件之前，我们先介绍一个能够将任何类序列化并存储的模块：pickle。在介绍这些之前，我们需要对文件有一个一般的认识。\n",
    "\n",
    "## Python中的文件\n",
    "\n",
    "在Python中，打开一个文件非常简单，使用open()函数就可以直接打开。这里需要强调的是，又打开就要有关闭，在打开一个文件之后，如果该文件不再被使用，必须及时使用f.close()方法关闭这个文件。\n",
    "\n",
    "open()函数的基本语法为：\n",
    "```python\n",
    "f=open(filename, mode)\n",
    "```\n",
    "\n",
    "其中filename为一个字符串，即文件名，而mode也是一个字符串，指明打开文件的模式，包括：\n",
    "\n",
    "文本文件或者二进制文件：\n",
    "\n",
    "* t：文本文件\n",
    "* b：二进制文件\n",
    "\n",
    "读取或者写入方式：\n",
    "\n",
    "* r：只读模式\n",
    "* w：写入模式：完全重写，覆盖\n",
    "* a：附加模式：在文件后面添加，不覆盖\n",
    "* x：独占写入\n",
    "* +：读写模式\n",
    "\n",
    "在打开时应该选择正确的打开方式。默认模式为'rt'，即文本文件，只读。比如，如果需要打开一个可写的二进制文件，可以使用：\n",
    "```python\n",
    "f=open('somefile.xxx','wb')\n",
    "## 一些操作\n",
    "f.close()\n",
    "```\n",
    "\n",
    "以上是打开和关闭一个文件的基本操作。然而，打开文件、对文件的操作本身可能会出现错误，因而如果考虑到错误处理，一个更好的写法是：\n",
    "```python\n",
    "try:\n",
    "    f=open('somefile.xxx','wb')\n",
    "except:\n",
    "    ## 错误处理\n",
    "finally:\n",
    "    f.close()\n",
    "```\n",
    "\n",
    "当对文件的操作出现错误时，可以对错误进行处理；而不管是否有错误发生，都会执行f.close()。\n",
    "\n",
    "当然这样写比较犯错，一个更简洁的写法是：\n",
    "\n",
    "```python\n",
    "with open('somefile.xxx','wb') as f:\n",
    "    ## 一些操作\n",
    "```\n",
    "\n",
    "这样写简洁很多，而且即使产生异常，也会正确的关闭文件。\n",
    "\n",
    "最后，有时打开文件时会报类似「codec cannot encoding...」类似的错误，主要是编码器的问题，此时只需要在open()函数中使用encoding选项就好了，比如Windows通常使用GBK编码，而Linux和Mac普遍采用utf-8编码，如果用Windows打开\\*nix的文件，一般需要：\n",
    "```python\n",
    "f=open('somefile.xxx',encoding='utf8')\n",
    "```\n",
    "\n",
    "如果是\\*nix打开Windows文件，需要：\n",
    "```python\n",
    "f=open('somefile.xxx',encoding='gb18030')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 类的存储：pickle模块\n",
    "\n",
    "有时我们创建对象之后，需要将其保存在硬盘上，方便其他程序调用或者下次打开程序时使用，此时我们可以使用Python中自带的Pickle模块。\n",
    "\n",
    "要使用pickle，需要首先导入：\n",
    "```python\n",
    "import pickle\n",
    "```\n",
    "\n",
    "将对象存储下来很简单，只需要使用pickle.dump(obj, file)就可以了，其中file要求是一个可写的二进制文件，即'rb'。在机器学习中，模型的结果通常是存储在一些对象中的，为了固化模型结果，方便以后调用，pickle是一个非常方便的解决方案。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat  Lucas  is created.\n"
     ]
    }
   ],
   "source": [
    "class Felidae:\n",
    "\n",
    "    def __init__(self, name, weight=None, age=None):\n",
    "        self.name = name\n",
    "        self.__weight = weight\n",
    "        self.__age = age\n",
    "        print(\"cat \", self.name, \" is created.\")\n",
    "\n",
    "    def get_weight(self):\n",
    "        return self.__weight\n",
    "\n",
    "    def get_age(self):\n",
    "        return self.__age\n",
    "\n",
    "    def set_weight(self, weight):\n",
    "        self.__weight = weight\n",
    "\n",
    "    def set_age(self, age):\n",
    "        self.__age = age\n",
    "\n",
    "    def catch(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class Cat(Felidae):\n",
    "\n",
    "    def __init__(self, name, weight=None, age=None, color=None):\n",
    "        super().__init__(name=name, weight=weight, age=age)\n",
    "        self.color = color\n",
    "\n",
    "    def shout(self):\n",
    "        print(\"喵~\")\n",
    "\n",
    "    def catch(self):\n",
    "        print(\"\\N{rat}\")\n",
    "\n",
    "\n",
    "lucas = Cat(\"Lucas\", color=\"三花\", age=2)\n",
    "\n",
    "import pickle\n",
    "with open('lucas.pyobj', 'wb') as f:\n",
    "    pickle.dump(lucas, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上就创建了一个Cat对象，然后打开一个文件（注意这个文件时可写的、二进制的，'wb'）'lucas.pyobj'（后缀名可以随便取），然后使用dump命令将lucas这个对象写入到了f中。\n",
    "\n",
    "为了读取这个对象，可以使用load()函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "喵~\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "with open('lucas.pyobj', 'rb') as f:\n",
    "    lucas2 = pickle.load(f)\n",
    "\n",
    "lucas2.shout()\n",
    "print(lucas.get_age())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 文本文件\n",
    "\n",
    "对文本文件的操作主要是读取和写入，可以分别使用f.write()方法和f.read()方法进行写入。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"text.txt\", 'wt') as f:\n",
    "    f.write(\"a\\nb\\nc\\nd\\ne\\nf\\ng\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上就写入了七行（因为有6个\\\\n）。如果需要读取这个文件，可以："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "with open(\"text.txt\", 'rt') as f:\n",
    "    a = f.read()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "即完整地读取了这个文本文件。\n",
    "\n",
    "但是，需要注意的是，有时文本文件非常的长，一次性写入和读取是非常低效的，更加常用的操作是按照行写入或者读取。此时可以使用readline()方法读取，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "\n",
      "b\n",
      "\n",
      "c\n",
      "\n",
      "d\n",
      "\n",
      "e\n",
      "\n",
      "f\n",
      "\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "with open(\"text.txt\", 'rt') as f:\n",
    "    while True:\n",
    "        a = f.readline()\n",
    "        if a == '':\n",
    "            break\n",
    "        else:\n",
    "            print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里值得注意的有以下几点：\n",
    "\n",
    "* readline()函数每调用一次，都将返回该行的内容，并将游标移到下一行\n",
    "* 每一行读取时都有'\\\\n'，所以我们会看到输出结果是每一行都有两个换行\n",
    "* 如果到了最后一行，返回一个空字符串（甚至连'\\\\n'都没有）\n",
    "\n",
    "如果文件不大，也可以使用readlines()方法，该方法一次性读取整个文件，但是将每一行放入一个列表中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a\\n', 'b\\n', 'c\\n', 'd\\n', 'e\\n', 'f\\n', 'g']\n"
     ]
    }
   ],
   "source": [
    "with open(\"text.txt\", 'rt') as f:\n",
    "    a = f.readlines()\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者，可以直接对文件对象进行迭代："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "with open(\"text.txt\", 'rt') as f:\n",
    "    for l in f:\n",
    "        print(l.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "而对于写入，由于每次执行write()方法时都可以手动写入'\\\\n'，从而没有writeline()方法，两者是等价的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员：     Messi，号码：10\n",
      "球员：      Xavi，号码：06\n",
      "球员：ter Stegen，号码：01\n",
      "球员：  Busquets，号码：05\n",
      "球员：     Pique，号码：03\n",
      "球员：    Suárez，号码：09\n",
      "\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "with open('player_list.txt', 'tw') as f:\n",
    "    for p in player_list:\n",
    "        f.write(\"球员：% 10s，号码：%02d\\n\" % (p[0], p[1]))\n",
    "with open('player_list.txt', 'tr') as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不过有writelines()方法，该方法接受一个字符串列表，并按行写入文本文件："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['球员：     Messi，号码：10\\n', '球员：      Xavi，号码：06\\n', '球员：ter Stegen，号码：01\\n', '球员：  Busquets，号码：05\\n', '球员：     Pique，号码：03\\n', '球员：    Suárez，号码：09\\n']\n",
      "球员：     Messi，号码：10\n",
      "球员：      Xavi，号码：06\n",
      "球员：ter Stegen，号码：01\n",
      "球员：  Busquets，号码：05\n",
      "球员：     Pique，号码：03\n",
      "球员：    Suárez，号码：09\n",
      "\n"
     ]
    }
   ],
   "source": [
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "write_list = [\"球员：% 10s，号码：%02d\\n\" % (p[0], p[1]) for p in player_list]\n",
    "print(write_list)\n",
    "with open('player_list.txt', 'tw') as f:\n",
    "    f.writelines(write_list)\n",
    "with open('player_list.txt', 'tr') as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## csv文件\n",
    "\n",
    "一类比较特殊的文件是所谓的csv文件。csv文件是一种非常通用的数据文件，几乎所有的数据处理软件都可以对其进行操作。在csv文件中，每一行代表一个观测，而不同的变量（列）一般使用逗号\",\"隔开。\n",
    "\n",
    "比如，在csv文件夹下，有个csv文件，是肯德基在中国的开店情况。我们可以看一下其文件格式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id,lon,lat,province,city,name,address,brand,category,birth,all_day,wifi,store_view,basketball,self_service,attractions,train,breakfast\n",
      "\n",
      "15487,116.28094,39.95174,北京市,北京市,板井路,远大路远大居住区二期世纪金源大酒店一层东南角,KFC,餐饮,true,false,false,true,true,true,false,false,true\n",
      "\n",
      "15205,116.362701,39.79407,北京市,北京市,大兴新宫DT,西红门路丙13号一层加二层,KFC,餐饮,true,false,false,true,false,true,false,false,true\n",
      "\n",
      "15184,116.209496,39.75268,北京市,北京市,长阳,长阳镇起步区五号地商业综合体中粮万科半岛商业广场首层L1017A及二层L2030A??,KFC,餐饮,false,false,false,false,false,true,false,false,false\n",
      "\n",
      "15186,116.157956,39.723521,北京市,北京市,良乡长虹东路,拱辰街道东羊庄村18号一层,KFC,餐饮,true,false,false,true,true,true,false,false,true\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('csv/kfc.csv') as f:\n",
    "    for i in range(5):\n",
    "        print(f.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看到这样的数据结构，我们第一反应应该是可以结合字符串的split()方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id', 'lon', 'lat', 'province', 'city', 'name', 'address', 'brand', 'category', 'birth', 'all_day', 'wifi', 'store_view', 'basketball', 'self_service', 'attractions', 'train', 'breakfast\\n']\n",
      "['15487', '116.28094', '39.95174', '北京市', '北京市', '板井路', '远大路远大居住区二期世纪金源大酒店一层东南角', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'true', 'true', 'false', 'false', 'true\\n']\n",
      "['15205', '116.362701', '39.79407', '北京市', '北京市', '大兴新宫DT', '西红门路丙13号一层加二层', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'false', 'true', 'false', 'false', 'true\\n']\n",
      "['15184', '116.209496', '39.75268', '北京市', '北京市', '长阳', '长阳镇起步区五号地商业综合体中粮万科半岛商业广场首层L1017A及二层L2030A??', 'KFC', '餐饮', 'false', 'false', 'false', 'false', 'false', 'true', 'false', 'false', 'false\\n']\n"
     ]
    }
   ],
   "source": [
    "data = []\n",
    "with open('csv/kfc.csv') as f:\n",
    "    for i in range(5):\n",
    "        if i != 0:\n",
    "            data.append(f.readline().split(','))\n",
    "for d in data:\n",
    "    print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然而其实csv文件比我们想象的复杂。比如，一些字符串中可能出现逗号，此时就需要对逗号进行转义，需要进行特殊处理。\n",
    "\n",
    "好在，在Python中，有更加成熟的方式处理这些数据。Python中提供了一个csv模块，可以方便的处理csv文件。比如，对于读取，可以使用csv.reader对象，该对象读取每一行，并自动将每一行分割为一个列表，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['id', 'lon', 'lat', 'province', 'city', 'name', 'address', 'brand', 'category', 'birth', 'all_day', 'wifi', 'store_view', 'basketball', 'self_service', 'attractions', 'train', 'breakfast']\n",
      "['15487', '116.28094', '39.95174', '北京市', '北京市', '板井路', '远大路远大居住区二期世纪金源大酒店一层东南角', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'true', 'true', 'false', 'false', 'true']\n",
      "['15205', '116.362701', '39.79407', '北京市', '北京市', '大兴新宫DT', '西红门路丙13号一层加二层', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'false', 'true', 'false', 'false', 'true']\n",
      "['15184', '116.209496', '39.75268', '北京市', '北京市', '长阳', '长阳镇起步区五号地商业综合体中粮万科半岛商业广场首层L1017A及二层L2030A??', 'KFC', '餐饮', 'false', 'false', 'false', 'false', 'false', 'true', 'false', 'false', 'false']\n",
      "['15186', '116.157956', '39.723521', '北京市', '北京市', '良乡长虹东路', '拱辰街道东羊庄村18号一层', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'true', 'true', 'false', 'false', 'true']\n",
      "['15183', '116.220176', '40.222182', '北京市', '北京市', '昌平京客隆', '西关路20号三号楼京客隆超市一层二层西侧3号商铺', 'KFC', '餐饮', 'true', 'false', 'false', 'true', 'true', 'true', 'false', 'false', 'true']\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "with open('csv/kfc.csv') as f:\n",
    "    reader = csv.reader(f)\n",
    "    i = 0\n",
    "    for r in reader:\n",
    "        print(r)\n",
    "        if i >= 5:\n",
    "            break\n",
    "        i += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上面的代码中，我们没有进行手动分割，而是先使用csv.reader()函数返回了一个reader对象，该对象对于f的每一行自动进行了分割。\n",
    "\n",
    "或者，也可以分割为字典，比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': '15487', 'lon': '116.28094', 'lat': '39.95174', 'province': '北京市', 'city': '北京市', 'name': '板井路', 'address': '远大路远大居住区二期世纪金源大酒店一层东南角', 'brand': 'KFC', 'category': '餐饮', 'birth': 'true', 'all_day': 'false', 'wifi': 'false', 'store_view': 'true', 'basketball': 'true', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'true'}\n",
      "{'id': '15205', 'lon': '116.362701', 'lat': '39.79407', 'province': '北京市', 'city': '北京市', 'name': '大兴新宫DT', 'address': '西红门路丙13号一层加二层', 'brand': 'KFC', 'category': '餐饮', 'birth': 'true', 'all_day': 'false', 'wifi': 'false', 'store_view': 'true', 'basketball': 'false', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'true'}\n",
      "{'id': '15184', 'lon': '116.209496', 'lat': '39.75268', 'province': '北京市', 'city': '北京市', 'name': '长阳', 'address': '长阳镇起步区五号地商业综合体中粮万科半岛商业广场首层L1017A及二层L2030A??', 'brand': 'KFC', 'category': '餐饮', 'birth': 'false', 'all_day': 'false', 'wifi': 'false', 'store_view': 'false', 'basketball': 'false', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'false'}\n",
      "{'id': '15186', 'lon': '116.157956', 'lat': '39.723521', 'province': '北京市', 'city': '北京市', 'name': '良乡长虹东路', 'address': '拱辰街道东羊庄村18号一层', 'brand': 'KFC', 'category': '餐饮', 'birth': 'true', 'all_day': 'false', 'wifi': 'false', 'store_view': 'true', 'basketball': 'true', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'true'}\n",
      "{'id': '15183', 'lon': '116.220176', 'lat': '40.222182', 'province': '北京市', 'city': '北京市', 'name': '昌平京客隆', 'address': '西关路20号三号楼京客隆超市一层二层西侧3号商铺', 'brand': 'KFC', 'category': '餐饮', 'birth': 'true', 'all_day': 'false', 'wifi': 'false', 'store_view': 'true', 'basketball': 'true', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'true'}\n",
      "{'id': '15177', 'lon': '116.354398', 'lat': '40.03694', 'province': '北京市', 'city': '北京市', 'name': '永泰庄', 'address': '清河永泰庄路甲1号', 'brand': 'KFC', 'category': '餐饮', 'birth': 'true', 'all_day': 'true', 'wifi': 'false', 'store_view': 'true', 'basketball': 'false', 'self_service': 'true', 'attractions': 'false', 'train': 'false', 'breakfast': 'true'}\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "with open('csv/kfc.csv') as f:\n",
    "    dict_reader = csv.DictReader(f)\n",
    "    i = 0\n",
    "    for r in dict_reader:\n",
    "        print(r)\n",
    "        if i >= 5:\n",
    "            break\n",
    "        i += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上代码自动将第一行作为字典的key，并将每一行的值赋值给相应的key。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要写入csv文件，可以使用csv.writer()对象返回一个csv写入对象，并传入一个元组或者列表。比如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "球员,号码\n",
      "Messi,10\n",
      "Xavi,6\n",
      "ter Stegen,1\n",
      "Busquets,5\n",
      "Pique,3\n",
      "Suárez,9\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "player_list = [('Messi', 10), ('Xavi', 6), ('ter Stegen', 1), ('Busquets', 5),\n",
    "               ('Pique', 3), ('Suárez', 9)]\n",
    "colnames = ['球员', '号码']\n",
    "with open('player_list.csv', 'wt') as f:\n",
    "    writer = csv.writer(f)\n",
    "    writer.writerow(colnames)\n",
    "    for p in player_list:\n",
    "        writer.writerow(p)\n",
    "with open('player_list.csv') as f:\n",
    "    print(f.read())"
   ]
  }
 ],
 "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.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}