第四课_函数及模块.ipynb · BoreasLynn/python2023

forked from 闻香茶主 / python2023

加入 Gitee

与超过 1200万开发者一起发现、参与优秀开源项目，私有仓库也完全免费：）

克隆/下载

第四课_函数及模块.ipynb 235.29 KB

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\\\diyLogo.png\" alt=\"some_text\">\n",
    "<h1> 第四讲 函数及模块基础</h1>\n",
    "<a id=backup></a>\n",
    "<H2>目录</H2>  \n",
    "\n",
    "[4.1 Python函数](#Pythonfunc)  \n",
    "[4.2 Python模块](#Pythonmodule)  \n",
    "[4.3 Numpy](#Numpy_module)     \n",
    "[4.4 Pandas](#Pandas_module)  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Pythonfunc></a>\n",
    "## 4.1 Python函数\n",
    "\n",
    "[目录](#backup)    \n",
    "函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。\n",
    "\n",
    "函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。\n",
    "### 4.1.1定义一个函数\n",
    "你可以定义一个由自己想要功能的函数，以下是简单的规则：\n",
    "\n",
    "+ 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。  \n",
    "+ 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。  \n",
    "+ 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。  \n",
    "+ 函数内容以冒号 : 起始，并且缩进。  \n",
    "+ return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。\n",
    "<img src=\"./img/Function_1.png\" alt=\"some_text\" width=450>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.2语法\n",
    "Python 定义函数使用 def 关键字，一般格式如下：  \n",
    "def 函数名（参数列表）:    \n",
    "> 函数体"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello() :\n",
    "    print(\"Hello World!\")\n",
    "\n",
    "i=hello()\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max(i, j):\n",
    "    if i > j:\n",
    "        return i\n",
    "    else:\n",
    "        return j\n",
    " \n",
    "a = 4\n",
    "b = 5\n",
    "i=1\n",
    "i=max(a, b)\n",
    "print(i,max(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算面积函数\n",
    "def area(width, height):\n",
    "    return width * height\n",
    " \n",
    "def print_welcome(name):\n",
    "    print(\"Welcome\", name)\n",
    " \n",
    "print_welcome(\"zhansan\")\n",
    "w = 4\n",
    "h = 5\n",
    "print(\"width =\", w, \" height =\", h, \" area =\", area(w, h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.3函数调用\n",
    "定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。\n",
    "\n",
    "这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。\n",
    "\n",
    "如下实例调用了 printme() 函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义函数\n",
    "def printme( str ):\n",
    "   # 打印任何传入的字符串\n",
    "   print (str)\n",
    "   return\n",
    " \n",
    "# 调用函数\n",
    "printme(\"我要调用用户自定义函数!\")\n",
    "printme(\"再次调用同一函数\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可更改(mutable)与不可更改(immutable)对象\n",
    "在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。\n",
    "\n",
    "+ 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。\n",
    "\n",
    "+ 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。\n",
    "\n",
    "### python 函数的参数传递：\n",
    "\n",
    "+ 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。\n",
    "\n",
    "+ 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响\n",
    "\n",
    "python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。\n",
    "\n",
    "python 传不可变对象实例\n",
    "通过 id() 函数来查看内存地址变化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#查看参数id\n",
    "def change(a):#虚实结合，避免用局部变量做参数\n",
    "    print(id(a))   # 指向的是同一个对象\n",
    "    a=10\n",
    "    print(id(a))   # 一个新对象\n",
    " \n",
    "a=1\n",
    "print(id(a))\n",
    "change(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 传可变对象实例\n",
    "可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 传入可变对象\n",
    "def changeme( mylist ):\n",
    "   \"修改传入的列表\"\n",
    "   mylist.append([1,2,3,4])\n",
    "   print (\"函数内取值1: \", mylist)\n",
    "   return \n",
    " \n",
    "# 调用changeme函数\n",
    "mylist = [10,20,30]\n",
    "changeme( mylist )\n",
    "print (\"函数外取值2: \", mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.4参数\n",
    "以下是调用函数时可使用的正式参数类型：\n",
    "\n",
    "+ 必需参数\n",
    "+ 关键字参数\n",
    "+ 默认参数\n",
    "+ 不定长参数\n",
    "#### 必需参数\n",
    "必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。\n",
    "\n",
    "调用 printme() 函数，你必须传入一个参数，不然会出现语法错误："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#无参数则出错\n",
    "def printme( str ):\n",
    "   \"打印任何传入的字符串\"\n",
    "   print (str)\n",
    "   return\n",
    " \n",
    "# 调用 printme 函数，不加参数会报错\n",
    "printme(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 关键字参数\n",
    "关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。\n",
    "\n",
    "使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。\n",
    "\n",
    "以下实例在函数 printme() 调用时使用参数名："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#使用关键字传入参数\n",
    "def printme( str ):\n",
    "   \"打印任何传入的字符串\"\n",
    "   print (str)\n",
    "   return\n",
    " \n",
    "#调用printme函数\n",
    "printme( str = \"你是菜鸟\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#以下实例中演示了函数参数的使用不需要使用指定顺序：\n",
    "def printinfo( name, age ):\n",
    "   \"打印任何传入的字符串\"\n",
    "   print (\"名字: \", name)\n",
    "   print (\"年龄: \", age)\n",
    "   return\n",
    " \n",
    "#调用printinfo函数\n",
    "printinfo( age=30, name=\"zhansan\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 默认参数\n",
    "调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#函数默认参数实例\n",
    "def printinfo( name, age = 35 ):\n",
    "   \"打印任何传入的字符串\"\n",
    "   print (\"名字: \", name)\n",
    "   print (\"年龄: \", age)\n",
    "   return\n",
    " \n",
    "#调用printinfo函数\n",
    "printinfo( age=50, name=\"大橘子\" )\n",
    "print (\"------------------------\")\n",
    "printinfo( name=\"二狗子\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 不定长参数\n",
    "你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。\n",
    "\n",
    "基本语法如下："
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'''   \n",
    "def functionname([formal_args,] *var_args_tuple ):   \n",
    "   \"函数_文档字符串\"   \n",
    "   function_suite   \n",
    "   return [expression] \n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 不定长函数参数实例\n",
    "def printinfo( arg1, *vartuple ):\n",
    "   \"打印任何传入的参数\"\n",
    "   print (\"输出: \")\n",
    "   print (arg1)\n",
    "   print (vartuple)\n",
    " \n",
    "# 调用printinfo 函数\n",
    "printinfo( 70, 60, 50, 40, 30, 20, 10 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 可写函数说明\n",
    "def printinfo( arg1, *vartuple ):\n",
    "   \"打印任何传入的参数\"\n",
    "   print (\"输出1: \")\n",
    "   print (arg1)\n",
    "   for var in vartuple:\n",
    "      print (\"输出2：\",var)\n",
    "   return\n",
    " \n",
    "# 调用printinfo 函数\n",
    "printinfo( 10 )\n",
    "printinfo( 2000, 60, 50 )\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#还有一种就是参数带两个星号 **基本语法如下：\n",
    "'''   \n",
    "def functionname([formal_args,] **var_args_dict ):\n",
    "       \"函数_文档字符串\"\n",
    "   function_suite\n",
    "   return [expression]\n",
    "'''  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# 参数带**会以字典的形式导入：\n",
    "#\n",
    "def printinfo( arg1, **vardict ):\n",
    "   #\"打印任何传入的参数\"\n",
    "   print (\"输出: \")\n",
    "   print (arg1)\n",
    "   print (vardict)\n",
    " \n",
    "# 调用printinfo 函数\n",
    "printinfo(1, key=\"myword\",b=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#如果单独出现星号 * 后的参数必须用关键字传入\n",
    "def f(a,b,*,c):\n",
    "     return a+b+c\n",
    "#f(1,2,3) \n",
    "f(1,2,c=3) # 正常"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.5匿名函数\n",
    "python 使用 lambda 来创建匿名函数。\n",
    "\n",
    "所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。\n",
    "\n",
    "+ lambda 只是一个表达式，函数体比 def 简单很多。\n",
    "+ lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。\n",
    "+ lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。\n",
    "+ 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。\n",
    "#### 语法\n",
    "lambda 函数的语法只包含一个语句，如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "lambda [arg1 [,arg2,.....argn]]:expression\n",
    "'''\n",
    "sum = lambda arg1, arg2: arg1 + arg2\n",
    " \n",
    "# 调用sum函数\n",
    "print (\"相加后的值为 : \", sum( 10, 20 ))\n",
    "print (\"相加后的值为 : \", sum( 20, 20 ))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.6 Return语句\n",
    "return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# 带返回值的函数\n",
    "#\n",
    "a=1\n",
    "def sum( arg1, arg2 ):\n",
    "   # 返回2个参数的和.\"\n",
    "   total = arg1 + arg2\n",
    "   print (\"函数内 : \", total+a)\n",
    "   return total\n",
    " \n",
    "# 调用sum函数\n",
    "total = sum( 10, 20 )\n",
    "print (\"函数外 : \", total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1.7强制位置参数\n",
    "Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。\n",
    "\n",
    "在以下的例子中：\n",
    "+ 形参 a 和 b 必须使用指定位置参数\n",
    "+ c 或 d 可以是位置形参或关键字形参\n",
    "+ 而 e 和 f 要求为关键字形参:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b, /, c, d, *, e, f):\n",
    "    print(a, b, c, d, e, f)\n",
    "\n",
    "#f(10, 20, 30, d=40, e=50, f=60)\n",
    "#f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式\n",
    "f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Pythonmodule></a>\n",
    "## 4.2  Python模块\n",
    "[目录](#backup) \n",
    "\n",
    "\n",
    "用 python 解释器编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。\n",
    "\n",
    "为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。\n",
    "\n",
    "模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。\n",
    "\n",
    "下面是一个使用 python 标准库中模块的例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "命令行参数如下:\n",
      "C:\\Users\\zeng_\\AppData\\Roaming\\Python\\Python310\\site-packages\\ipykernel_launcher.py\n",
      "--ip=127.0.0.1\n",
      "--stdin=9003\n",
      "--control=9001\n",
      "--hb=9000\n",
      "--Session.signature_scheme=\"hmac-sha256\"\n",
      "--Session.key=b\"1619aeb2-8e35-428b-8590-960ecd2b487b\"\n",
      "--shell=9002\n",
      "--transport=\"tcp\"\n",
      "--iopub=9004\n",
      "--f=c:\\Users\\zeng_\\AppData\\Roaming\\jupyter\\runtime\\kernel-v2-3704NFbhunP4F8Tt.json\n",
      "\n",
      "\n",
      "Python 路径为： ['c:\\\\VSWork\\\\Pythonwork\\\\0001', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\python310.zip', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\DLLs', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\lib', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310', '', 'C:\\\\Users\\\\zeng_\\\\AppData\\\\Roaming\\\\Python\\\\Python310\\\\site-packages', 'C:\\\\Users\\\\zeng_\\\\AppData\\\\Roaming\\\\Python\\\\Python310\\\\site-packages\\\\win32', 'C:\\\\Users\\\\zeng_\\\\AppData\\\\Roaming\\\\Python\\\\Python310\\\\site-packages\\\\win32\\\\lib', 'C:\\\\Users\\\\zeng_\\\\AppData\\\\Roaming\\\\Python\\\\Python310\\\\site-packages\\\\Pythonwin', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\lib\\\\site-packages', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\lib\\\\site-packages\\\\win32', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\lib\\\\site-packages\\\\win32\\\\lib', 'c:\\\\ProgramData\\\\Anaconda3\\\\envs\\\\python310\\\\lib\\\\site-packages\\\\Pythonwin'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    " \n",
    "print('命令行参数如下:')\n",
    "for i in sys.argv:\n",
    "   print(i)\n",
    " \n",
    "print('\\n\\nPython 路径为：', sys.path, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。\n",
    "+ 2、sys.argv 是一个包含命令行参数的列表。\n",
    "+ 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2.1 import 语句\n",
    "想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import module1[, module2[,... moduleN]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。\n",
    "\n",
    "当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？\n",
    "\n",
    "这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。\n",
    "\n",
    "这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。\n",
    "\n",
    "搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。\n",
    "\n",
    "因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。\n",
    "\n",
    "了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。\n",
    "\n",
    "现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 斐波那契(fibonacci)数列模块\n",
    "'''''' \n",
    "def fib(n):    # 定义到 n 的斐波那契数列\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        print(b, end=' ')\n",
    "        a, b = b, a+b\n",
    "    print()\n",
    " \n",
    "def fib2(n): # 返回到 n 的斐波那契数列\n",
    "    result = []\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        result.append(b)\n",
    "        a, b = b, a+b\n",
    "    return result\n",
    "''''''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后进入Python解释器，使用下面的命令导入这个模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fibo "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 \n"
     ]
    }
   ],
   "source": [
    "f.fib(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibo.fib2(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fibo'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibo.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### from … import 语句\n",
    "\n",
    "Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：   \n",
    "from modname import name1[, name2[, ... nameN]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### from … import * 语句\n",
    "把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from modname import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 55 89 144 233 377 \n",
      "0.9092974268256817\n"
     ]
    }
   ],
   "source": [
    "from fibo import fib, fib2\n",
    "fib(500)\n",
    "from math import sin,cos\n",
    "y=sin(2)\n",
    "print(y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Numpy_module> </a>\n",
    "## 4.3  Numpy\n",
    "\n",
    "NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。\n",
    "\n",
    "NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。\n",
    "\n",
    "NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：\n",
    "\n",
    "+ 一个强大的N维数组对象 ndarray\n",
    "+ 广播功能函数\n",
    "+ 整合 C/C++/Fortran 代码的工具\n",
    "+ 线性代数、傅里叶变换、随机数生成等功能\n",
    "### NumPy 应用\n",
    "+ NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。\n",
    "\n",
    "+ SciPy 是一个开源的 Python 算法库和数学工具包。\n",
    "\n",
    "+ SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。\n",
    "\n",
    "+ Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。\n",
    "\n",
    "### 相关链接\n",
    "+ NumPy 官网 http://www.numpy.org/\n",
    "+ NumPy 源代码：https://github.com/numpy/numpy\n",
    "+ SciPy 官网：https://www.scipy.org/\n",
    "+ SciPy 源代码：https://github.com/scipy/scipy\n",
    "+ Matplotlib 教程：Matplotlib 教程\n",
    "+ Matplotlib 官网：https://matplotlib.org/\n",
    "+ Matplotlib 源代码：https://github.com/matplotlib/matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a=[1,2,3,4,5,6]\n",
    "b=np.array(a)\n",
    "b.resize(2,3)\n",
    "b.transpose()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "a=np.arange(0,12,1)\n",
    "a.resize(3,4)\n",
    "\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 7)\n"
     ]
    }
   ],
   "source": [
    "b=np.linspace(1,7,14)\n",
    "b=np.array(b)\n",
    "b=b.reshape(2,7)\n",
    "b.resize(2,7)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  2.,  3.,  4.,  5.],\n",
       "       [ 6.,  7.,  8.,  9., 10.]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.T\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  2.,  3.,  4.,  5.],\n",
       "       [ 6.,  7.,  8.,  9., 10.]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.argmax()\n",
    "b.conjugate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 1.,  2.,  3.,  4.,  5.],\n",
       "         [ 6.,  7.,  8.,  9., 10.]]]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.squeeze(b)\n",
    "b.resize(1,1,2,5)\n",
    "b.squeeze()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=Pandas_module></a>\n",
    "## 4.4  Pandas\n",
    "\n",
    "Pandas 是 Python 语言的一个扩展程序库，用于数据分析。\n",
    "\n",
    "Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具。\n",
    "\n",
    "Pandas 名字衍生自术语 \"panel data\"（面板数据）和 \"Python data analysis\"（Python 数据分析）。\n",
    "\n",
    "Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）。\n",
    "\n",
    "Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。\n",
    "\n",
    "Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。\n",
    "\n",
    "Pandas 广泛应用在学术、金融、统计学等各个数据分析领域。用 python 。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas 应用\n",
    "Pandas 的主要数据结构是 Series （一维数据）与 DataFrame（二维数据），这两种数据结构足以处理金融、统计、社会科学、工程等领域里的大多数典型用例。\n",
    "\n",
    "### 数据结构\n",
    "+ Series 是一种类似于一维数组的对象，它由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。\n",
    "\n",
    "+ DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。\n",
    "\n",
    "### 相关链接\n",
    "Pandas 官网 https://pandas.pydata.org/\n",
    "Pandas 源代码：https://github.com/pandas-dev/pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object creation   \n",
    "See the Intro to data structures section.\n",
    "\n",
    "Creating a Series by passing a list of values, letting pandas create a default integer index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>ts_code</th>\n",
       "      <th>open</th>\n",
       "      <th>high</th>\n",
       "      <th>low</th>\n",
       "      <th>close</th>\n",
       "      <th>vol</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trade_date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2021-10-26</th>\n",
       "      <td>0</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>15.08</td>\n",
       "      <td>15.20</td>\n",
       "      <td>15.02</td>\n",
       "      <td>15.02</td>\n",
       "      <td>24291.16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-10-25</th>\n",
       "      <td>1</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>15.20</td>\n",
       "      <td>15.20</td>\n",
       "      <td>15.00</td>\n",
       "      <td>15.09</td>\n",
       "      <td>34938.46</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-10-22</th>\n",
       "      <td>2</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>15.25</td>\n",
       "      <td>15.50</td>\n",
       "      <td>15.21</td>\n",
       "      <td>15.25</td>\n",
       "      <td>46717.41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-10-21</th>\n",
       "      <td>3</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>15.26</td>\n",
       "      <td>15.33</td>\n",
       "      <td>15.13</td>\n",
       "      <td>15.20</td>\n",
       "      <td>26697.95</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-10-20</th>\n",
       "      <td>4</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>15.19</td>\n",
       "      <td>15.40</td>\n",
       "      <td>15.13</td>\n",
       "      <td>15.26</td>\n",
       "      <td>31790.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-10</th>\n",
       "      <td>4823</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>10.36</td>\n",
       "      <td>10.74</td>\n",
       "      <td>10.00</td>\n",
       "      <td>10.65</td>\n",
       "      <td>13267.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-07</th>\n",
       "      <td>4824</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>10.27</td>\n",
       "      <td>10.44</td>\n",
       "      <td>10.02</td>\n",
       "      <td>10.35</td>\n",
       "      <td>11930.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-06</th>\n",
       "      <td>4825</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>9.97</td>\n",
       "      <td>10.30</td>\n",
       "      <td>9.68</td>\n",
       "      <td>10.17</td>\n",
       "      <td>8910.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-05</th>\n",
       "      <td>4826</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>9.64</td>\n",
       "      <td>10.18</td>\n",
       "      <td>9.48</td>\n",
       "      <td>10.04</td>\n",
       "      <td>8457.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-04</th>\n",
       "      <td>4827</td>\n",
       "      <td>600848.SH</td>\n",
       "      <td>9.45</td>\n",
       "      <td>9.66</td>\n",
       "      <td>9.15</td>\n",
       "      <td>9.60</td>\n",
       "      <td>3826.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4828 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            Unnamed: 0    ts_code   open   high    low  close       vol\n",
       "trade_date                                                             \n",
       "2021-10-26           0  600848.SH  15.08  15.20  15.02  15.02  24291.16\n",
       "2021-10-25           1  600848.SH  15.20  15.20  15.00  15.09  34938.46\n",
       "2021-10-22           2  600848.SH  15.25  15.50  15.21  15.25  46717.41\n",
       "2021-10-21           3  600848.SH  15.26  15.33  15.13  15.20  26697.95\n",
       "2021-10-20           4  600848.SH  15.19  15.40  15.13  15.26  31790.33\n",
       "...                ...        ...    ...    ...    ...    ...       ...\n",
       "2000-01-10        4823  600848.SH  10.36  10.74  10.00  10.65  13267.00\n",
       "2000-01-07        4824  600848.SH  10.27  10.44  10.02  10.35  11930.00\n",
       "2000-01-06        4825  600848.SH   9.97  10.30   9.68  10.17   8910.00\n",
       "2000-01-05        4826  600848.SH   9.64  10.18   9.48  10.04   8457.00\n",
       "2000-01-04        4827  600848.SH   9.45   9.66   9.15   9.60   3826.00\n",
       "\n",
       "[4828 rows x 7 columns]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data=pd.read_csv(\"./stocktest/stock600848.csv\",parse_dates=[\"trade_date\"],index_col=[\"trade_date\"])\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1.0\n",
       "1    3.0\n",
       "2    5.0\n",
       "3    NaN\n",
       "4    6.0\n",
       "5    8.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([1, 3, 5, np.nan, 6, 8])\n",
    "\n",
    "s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',\n",
       "               '2023-01-05', '2023-01-06', '2023-01-07'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates = pd.date_range(\"20230101\", periods=7)\n",
    "dates\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>-1.321121</td>\n",
       "      <td>0.057394</td>\n",
       "      <td>0.169561</td>\n",
       "      <td>-0.329157</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>1.986053</td>\n",
       "      <td>-0.304579</td>\n",
       "      <td>0.799928</td>\n",
       "      <td>0.716096</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>1.026101</td>\n",
       "      <td>-0.160384</td>\n",
       "      <td>-0.237493</td>\n",
       "      <td>-0.695067</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>1.339618</td>\n",
       "      <td>-1.477273</td>\n",
       "      <td>0.243761</td>\n",
       "      <td>0.333993</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-05</th>\n",
       "      <td>0.868598</td>\n",
       "      <td>-0.464636</td>\n",
       "      <td>-0.705627</td>\n",
       "      <td>1.197284</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-06</th>\n",
       "      <td>1.154911</td>\n",
       "      <td>-1.454133</td>\n",
       "      <td>-1.478631</td>\n",
       "      <td>-0.959069</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-07</th>\n",
       "      <td>-0.507658</td>\n",
       "      <td>2.229784</td>\n",
       "      <td>0.475991</td>\n",
       "      <td>0.196368</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2023-01-01 -1.321121  0.057394  0.169561 -0.329157\n",
       "2023-01-02  1.986053 -0.304579  0.799928  0.716096\n",
       "2023-01-03  1.026101 -0.160384 -0.237493 -0.695067\n",
       "2023-01-04  1.339618 -1.477273  0.243761  0.333993\n",
       "2023-01-05  0.868598 -0.464636 -0.705627  1.197284\n",
       "2023-01-06  1.154911 -1.454133 -1.478631 -0.959069\n",
       "2023-01-07 -0.507658  2.229784  0.475991  0.196368"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(np.random.randn(7, 4), index=dates, columns=list(\"ABCD\"))\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "      <th>F</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2013-01-02</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "      <td>test</td>\n",
       "      <td>foo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2013-01-02</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>foo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2013-01-02</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "      <td>test</td>\n",
       "      <td>foo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2013-01-02</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "      <td>train</td>\n",
       "      <td>foo</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A          B    C  D      E    F\n",
       "0  1.0 2013-01-02  1.0  3   test  foo\n",
       "1  1.0 2013-01-02  1.0  3  train  foo\n",
       "2  1.0 2013-01-02  1.0  3   test  foo\n",
       "3  1.0 2013-01-02  1.0  3  train  foo"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = pd.DataFrame(\n",
    "    {\n",
    "        \"A\": 1.0,\n",
    "        \"B\": pd.Timestamp(\"20130102\"),\n",
    "        \"C\": pd.Series(1, index=list(range(4)), dtype=\"float32\"),\n",
    "        \"D\": np.array([3] * 4, dtype=\"int32\"),\n",
    "        \"E\": pd.Categorical([\"test\", \"train\", \"test\", \"train\"]),\n",
    "        \"F\": \"foo\",\n",
    "    }\n",
    ")\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A           float64\n",
       "B    datetime64[ns]\n",
       "C           float32\n",
       "D             int32\n",
       "E          category\n",
       "F            object\n",
       "dtype: object"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.dtypes\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you’re using IPython, tab completion for column names (as well as public attributes) is automatically enabled. Here’s a subset of the attributes that will be completed:\n",
    "df2. < TAB >  # noqa: E225, E999\n",
    "df2.A                  df2.bool\n",
    "df2.abs                df2.boxplot\n",
    "df2.add                df2.C\n",
    "df2.add_prefix         df2.clip\n",
    "df2.add_suffix         df2.columns\n",
    "df2.align              df2.copy\n",
    "df2.all                df2.count\n",
    "df2.any                df2.combine\n",
    "df2.append             df2.D\n",
    "df2.apply              df2.describe\n",
    "df2.applymap           df2.diff\n",
    "df2.B                  df2.duplicated\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viewing data   \n",
    "See the Basics section.\n",
    "\n",
    "Use DataFrame.head() and DataFrame.tail() to view the top and bottom rows of the frame   \n",
    "respectively:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['A', 'B', 'C', 'D'], dtype='object')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()\n",
    "df.tail(3)\n",
    "df.index\n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.42617925,  0.21491699, -1.39557492, -0.63709394],\n",
       "       [-0.15597782, -0.08090035,  1.6964907 , -1.42085817],\n",
       "       [ 1.57716656,  0.2989674 ,  1.12132911, -1.63155905],\n",
       "       [-0.81414061, -1.50162613,  0.56557247, -0.77898062],\n",
       "       [ 0.63096165,  2.46513493,  1.93998832,  0.88508883],\n",
       "       [ 0.01136164, -0.12850564, -0.96812863, -0.07347257],\n",
       "       [ 0.30480466, -1.65843555, -0.05266834, -0.08216438]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],\n",
       "       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],\n",
       "       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],\n",
       "       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>7.000000</td>\n",
       "      <td>7.000000</td>\n",
       "      <td>7.000000</td>\n",
       "      <td>7.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.282908</td>\n",
       "      <td>-0.055778</td>\n",
       "      <td>0.415287</td>\n",
       "      <td>-0.534149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.740172</td>\n",
       "      <td>1.367420</td>\n",
       "      <td>1.284479</td>\n",
       "      <td>0.865241</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>-0.814141</td>\n",
       "      <td>-1.658436</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>-1.631559</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>-0.072308</td>\n",
       "      <td>-0.815066</td>\n",
       "      <td>-0.510398</td>\n",
       "      <td>-1.099919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.304805</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>-0.637094</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.528570</td>\n",
       "      <td>0.256942</td>\n",
       "      <td>1.408910</td>\n",
       "      <td>-0.077818</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1.577167</td>\n",
       "      <td>2.465135</td>\n",
       "      <td>1.939988</td>\n",
       "      <td>0.885089</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              A         B         C         D\n",
       "count  7.000000  7.000000  7.000000  7.000000\n",
       "mean   0.282908 -0.055778  0.415287 -0.534149\n",
       "std    0.740172  1.367420  1.284479  0.865241\n",
       "min   -0.814141 -1.658436 -1.395575 -1.631559\n",
       "25%   -0.072308 -0.815066 -0.510398 -1.099919\n",
       "50%    0.304805 -0.080900  0.565572 -0.637094\n",
       "75%    0.528570  0.256942  1.408910 -0.077818\n",
       "max    1.577167  2.465135  1.939988  0.885089"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>2023-01-01</th>\n",
       "      <th>2023-01-02</th>\n",
       "      <th>2023-01-03</th>\n",
       "      <th>2023-01-04</th>\n",
       "      <th>2023-01-05</th>\n",
       "      <th>2023-01-06</th>\n",
       "      <th>2023-01-07</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0.426179</td>\n",
       "      <td>-0.155978</td>\n",
       "      <td>1.577167</td>\n",
       "      <td>-0.814141</td>\n",
       "      <td>0.630962</td>\n",
       "      <td>0.011362</td>\n",
       "      <td>0.304805</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>0.214917</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>2.465135</td>\n",
       "      <td>-0.128506</td>\n",
       "      <td>-1.658436</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>-1.395575</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>1.939988</td>\n",
       "      <td>-0.968129</td>\n",
       "      <td>-0.052668</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D</th>\n",
       "      <td>-0.637094</td>\n",
       "      <td>-1.420858</td>\n",
       "      <td>-1.631559</td>\n",
       "      <td>-0.778981</td>\n",
       "      <td>0.885089</td>\n",
       "      <td>-0.073473</td>\n",
       "      <td>-0.082164</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   2023-01-01  2023-01-02  2023-01-03  2023-01-04  2023-01-05  2023-01-06  \\\n",
       "A    0.426179   -0.155978    1.577167   -0.814141    0.630962    0.011362   \n",
       "B    0.214917   -0.080900    0.298967   -1.501626    2.465135   -0.128506   \n",
       "C   -1.395575    1.696491    1.121329    0.565572    1.939988   -0.968129   \n",
       "D   -0.637094   -1.420858   -1.631559   -0.778981    0.885089   -0.073473   \n",
       "\n",
       "   2023-01-07  \n",
       "A    0.304805  \n",
       "B   -1.658436  \n",
       "C   -0.052668  \n",
       "D   -0.082164  "
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>D</th>\n",
       "      <th>C</th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>-0.637094</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>0.214917</td>\n",
       "      <td>0.426179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-1.420858</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>-0.155978</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>-1.631559</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>1.577167</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>-0.778981</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>-0.814141</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-05</th>\n",
       "      <td>0.885089</td>\n",
       "      <td>1.939988</td>\n",
       "      <td>2.465135</td>\n",
       "      <td>0.630962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-06</th>\n",
       "      <td>-0.073473</td>\n",
       "      <td>-0.968129</td>\n",
       "      <td>-0.128506</td>\n",
       "      <td>0.011362</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-07</th>\n",
       "      <td>-0.082164</td>\n",
       "      <td>-0.052668</td>\n",
       "      <td>-1.658436</td>\n",
       "      <td>0.304805</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   D         C         B         A\n",
       "2023-01-01 -0.637094 -1.395575  0.214917  0.426179\n",
       "2023-01-02 -1.420858  1.696491 -0.080900 -0.155978\n",
       "2023-01-03 -1.631559  1.121329  0.298967  1.577167\n",
       "2023-01-04 -0.778981  0.565572 -1.501626 -0.814141\n",
       "2023-01-05  0.885089  1.939988  2.465135  0.630962\n",
       "2023-01-06 -0.073473 -0.968129 -0.128506  0.011362\n",
       "2023-01-07 -0.082164 -0.052668 -1.658436  0.304805"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sort_index(axis=1,ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-07</th>\n",
       "      <td>0.304805</td>\n",
       "      <td>-1.658436</td>\n",
       "      <td>-0.052668</td>\n",
       "      <td>-0.082164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>-0.814141</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>-0.778981</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-06</th>\n",
       "      <td>0.011362</td>\n",
       "      <td>-0.128506</td>\n",
       "      <td>-0.968129</td>\n",
       "      <td>-0.073473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-0.155978</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>-1.420858</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>0.426179</td>\n",
       "      <td>0.214917</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>-0.637094</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>1.577167</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>-1.631559</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-05</th>\n",
       "      <td>0.630962</td>\n",
       "      <td>2.465135</td>\n",
       "      <td>1.939988</td>\n",
       "      <td>0.885089</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2023-01-07  0.304805 -1.658436 -0.052668 -0.082164\n",
       "2023-01-04 -0.814141 -1.501626  0.565572 -0.778981\n",
       "2023-01-06  0.011362 -0.128506 -0.968129 -0.073473\n",
       "2023-01-02 -0.155978 -0.080900  1.696491 -1.420858\n",
       "2023-01-01  0.426179  0.214917 -1.395575 -0.637094\n",
       "2023-01-03  1.577167  0.298967  1.121329 -1.631559\n",
       "2023-01-05  0.630962  2.465135  1.939988  0.885089"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sort_values(by=\"B\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection\n",
    "Note\n",
    "\n",
    "While standard Python / NumPy expressions for selecting and setting are intuitive and come in handy for interactive work, for production code, we recommend the optimized pandas data access methods, DataFrame.at(), DataFrame.iat(), DataFrame.loc() and DataFrame.iloc().\n",
    "\n",
    "See the indexing documentation Indexing and Selecting Data and MultiIndex / Advanced Indexing.\n",
    "\n",
    "#### Getting\n",
    "Selecting a single column, which yields a Series, equivalent to df.A:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',\n",
       "               '2023-01-05', '2023-01-06', '2023-01-07'],\n",
       "              dtype='datetime64[ns]', freq='D')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"A\"]\n",
    "df.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>0.426179</td>\n",
       "      <td>0.214917</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>-0.637094</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-0.155978</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>-1.420858</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>1.577167</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>-1.631559</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2023-01-01  0.426179  0.214917 -1.395575 -0.637094\n",
       "2023-01-02 -0.155978 -0.080900  1.696491 -1.420858\n",
       "2023-01-03  1.577167  0.298967  1.121329 -1.631559"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[0:3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection by label\n",
    "See more in Selection by Label using DataFrame.loc() or DataFrame.at().\n",
    "\n",
    "For getting a cross section using a label:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    0.353124\n",
       "B   -0.952107\n",
       "C   -0.810359\n",
       "D    0.319397\n",
       "Name: 2013-01-01 00:00:00, dtype: float64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[dates[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>0.353124</td>\n",
       "      <td>-0.952107</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-0.021260</td>\n",
       "      <td>-0.387072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>-0.471901</td>\n",
       "      <td>-0.362371</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-0.785147</td>\n",
       "      <td>2.458449</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>0.894152</td>\n",
       "      <td>0.082539</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B\n",
       "2013-01-01  0.353124 -0.952107\n",
       "2013-01-02  1.011881 -1.467853\n",
       "2013-01-03 -0.021260 -0.387072\n",
       "2013-01-04 -0.471901 -0.362371\n",
       "2013-01-05 -0.785147  2.458449\n",
       "2013-01-06  0.894152  0.082539"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[:,[\"A\",\"B\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-0.021260</td>\n",
       "      <td>-0.387072</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>-0.471901</td>\n",
       "      <td>-0.362371</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B\n",
       "2013-01-02  1.011881 -1.467853\n",
       "2013-01-03 -0.021260 -0.387072\n",
       "2013-01-04 -0.471901 -0.362371"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[\"20130102\":\"20130104\", [\"A\", \"B\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    1.011881\n",
       "B   -1.467853\n",
       "Name: 2013-01-02 00:00:00, dtype: float64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[\"20130102\", [\"A\", \"B\"]]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3531243539756235"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.at[dates[0], \"A\"]\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection by position\n",
    "See more in Selection by Position using DataFrame.iloc() or DataFrame.at().\n",
    "\n",
    "Select via the position of the passed integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A   -0.471901\n",
       "B   -0.362371\n",
       "C   -1.663361\n",
       "D    0.417683\n",
       "Name: 2013-01-04 00:00:00, dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>-0.471901</td>\n",
       "      <td>-0.362371</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-0.785147</td>\n",
       "      <td>2.458449</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B\n",
       "2013-01-04 -0.471901 -0.362371\n",
       "2013-01-05 -0.785147  2.458449"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[3:5,0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>0.984630</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-0.021260</td>\n",
       "      <td>0.094271</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-0.785147</td>\n",
       "      <td>0.060556</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         C\n",
       "2013-01-02  1.011881  0.984630\n",
       "2013-01-03 -0.021260  0.094271\n",
       "2013-01-05 -0.785147  0.060556"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[[1, 2, 4], [0, 2]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "      <td>0.984630</td>\n",
       "      <td>-1.423896</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-0.021260</td>\n",
       "      <td>-0.387072</td>\n",
       "      <td>0.094271</td>\n",
       "      <td>0.830802</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2013-01-02  1.011881 -1.467853  0.984630 -1.423896\n",
       "2013-01-03 -0.021260 -0.387072  0.094271  0.830802"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[1:3, :]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For getting a value explicitly:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.4678527958278718"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iloc[1,1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For getting fast access to a scalar (equivalent to the prior method):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.4678527958278718"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.iat[1,1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean indexing   \n",
    "Using a single column’s values to select data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>0.353124</td>\n",
       "      <td>-0.952107</td>\n",
       "      <td>-0.810359</td>\n",
       "      <td>0.319397</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "      <td>0.984630</td>\n",
       "      <td>-1.423896</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>0.894152</td>\n",
       "      <td>0.082539</td>\n",
       "      <td>0.198704</td>\n",
       "      <td>1.096456</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2013-01-01  0.353124 -0.952107 -0.810359  0.319397\n",
       "2013-01-02  1.011881 -1.467853  0.984630 -1.423896\n",
       "2013-01-06  0.894152  0.082539  0.198704  1.096456"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df[\"A\"]>0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>0.353124</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.319397</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.984630</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.094271</td>\n",
       "      <td>0.830802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.417683</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.458449</td>\n",
       "      <td>0.060556</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>0.894152</td>\n",
       "      <td>0.082539</td>\n",
       "      <td>0.198704</td>\n",
       "      <td>1.096456</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D\n",
       "2013-01-01  0.353124       NaN       NaN  0.319397\n",
       "2013-01-02  1.011881       NaN  0.984630       NaN\n",
       "2013-01-03       NaN       NaN  0.094271  0.830802\n",
       "2013-01-04       NaN       NaN       NaN  0.417683\n",
       "2013-01-05       NaN  2.458449  0.060556       NaN\n",
       "2013-01-06  0.894152  0.082539  0.198704  1.096456"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df > 0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>0.353124</td>\n",
       "      <td>-0.952107</td>\n",
       "      <td>-0.810359</td>\n",
       "      <td>0.319397</td>\n",
       "      <td>one</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "      <td>0.984630</td>\n",
       "      <td>-1.423896</td>\n",
       "      <td>one</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-0.021260</td>\n",
       "      <td>-0.387072</td>\n",
       "      <td>0.094271</td>\n",
       "      <td>0.830802</td>\n",
       "      <td>two</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>-0.471901</td>\n",
       "      <td>-0.362371</td>\n",
       "      <td>-1.663361</td>\n",
       "      <td>0.417683</td>\n",
       "      <td>three</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-0.785147</td>\n",
       "      <td>2.458449</td>\n",
       "      <td>0.060556</td>\n",
       "      <td>-0.461612</td>\n",
       "      <td>four</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>0.894152</td>\n",
       "      <td>0.082539</td>\n",
       "      <td>0.198704</td>\n",
       "      <td>1.096456</td>\n",
       "      <td>three</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C         D      E\n",
       "2013-01-01  0.353124 -0.952107 -0.810359  0.319397    one\n",
       "2013-01-02  1.011881 -1.467853  0.984630 -1.423896    one\n",
       "2013-01-03 -0.021260 -0.387072  0.094271  0.830802    two\n",
       "2013-01-04 -0.471901 -0.362371 -1.663361  0.417683  three\n",
       "2013-01-05 -0.785147  2.458449  0.060556 -0.461612   four\n",
       "2013-01-06  0.894152  0.082539  0.198704  1.096456  three"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = df.copy()\n",
    "\n",
    "df2[\"E\"] = [\"one\", \"one\", \"two\", \"three\", \"four\", \"three\"]\n",
    "\n",
    "df2\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting   \n",
    "Setting a new column automatically aligns the data by the indexes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2013-01-02    1\n",
       "2013-01-03    2\n",
       "2013-01-04    3\n",
       "2013-01-05    4\n",
       "2013-01-06    5\n",
       "2013-01-07    6\n",
       "Freq: D, dtype: int64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range(\"20130102\", periods=6))\n",
    "\n",
    "s1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"F\"] = s1\n",
    "\n",
    "df.at[dates[0], \"A\"] = 0\n",
    "df.iat[0, 1] = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[:, \"D\"] = np.array([5] * len(df))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-0.155978</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>-1.696491</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>-1.577167</td>\n",
       "      <td>-0.298967</td>\n",
       "      <td>-1.121329</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>-0.814141</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>-0.565572</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-05</th>\n",
       "      <td>-0.630962</td>\n",
       "      <td>-2.465135</td>\n",
       "      <td>-1.939988</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-06</th>\n",
       "      <td>-0.011362</td>\n",
       "      <td>-0.128506</td>\n",
       "      <td>-0.968129</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-07</th>\n",
       "      <td>-0.304805</td>\n",
       "      <td>-1.658436</td>\n",
       "      <td>-0.052668</td>\n",
       "      <td>-5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C  D   F\n",
       "2023-01-01  0.000000  0.000000 -1.395575 -5 NaN\n",
       "2023-01-02 -0.155978 -0.080900 -1.696491 -5 NaN\n",
       "2023-01-03 -1.577167 -0.298967 -1.121329 -5 NaN\n",
       "2023-01-04 -0.814141 -1.501626 -0.565572 -5 NaN\n",
       "2023-01-05 -0.630962 -2.465135 -1.939988 -5 NaN\n",
       "2023-01-06 -0.011362 -0.128506 -0.968129 -5 NaN\n",
       "2023-01-07 -0.304805 -1.658436 -0.052668 -5 NaN"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = df.copy()\n",
    "\n",
    "df2[df2 > 0] = -df2\n",
    "\n",
    "df2\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing data   \n",
    "pandas primarily uses the value np.nan to represent missing data. It is by default not included in computations. See the Missing Data section.\n",
    "\n",
    "Reindexing allows you to change/add/delete the index on a specified axis. This returns a copy of the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-0.155978</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>1.577167</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>-0.814141</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C  D   F    E\n",
       "2023-01-01  0.000000  0.000000 -1.395575  5 NaN  1.0\n",
       "2023-01-02 -0.155978 -0.080900  1.696491  5 NaN  1.0\n",
       "2023-01-03  1.577167  0.298967  1.121329  5 NaN  NaN\n",
       "2023-01-04 -0.814141 -1.501626  0.565572  5 NaN  NaN"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + [\"E\"])\n",
    "\n",
    "df1.loc[dates[0]: dates[1], \"E\"] = 1\n",
    "\n",
    "df1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [A, B, C, D, F, E]\n",
       "Index: []"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.dropna(how=\"any\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-1.395575</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>-0.155978</td>\n",
       "      <td>-0.080900</td>\n",
       "      <td>1.696491</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>1.577167</td>\n",
       "      <td>0.298967</td>\n",
       "      <td>1.121329</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>-0.814141</td>\n",
       "      <td>-1.501626</td>\n",
       "      <td>0.565572</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C  D    F    E\n",
       "2023-01-01  0.000000  0.000000 -1.395575  5  0.0  1.0\n",
       "2023-01-02 -0.155978 -0.080900  1.696491  5  0.0  1.0\n",
       "2023-01-03  1.577167  0.298967  1.121329  5  0.0  0.0\n",
       "2023-01-04 -0.814141 -1.501626  0.565572  5  0.0  0.0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.fillna(value=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2023-01-01</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-02</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-03</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2023-01-04</th>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                A      B      C      D     F      E\n",
       "2023-01-01  False  False  False  False  True  False\n",
       "2023-01-02  False  False  False  False  True  False\n",
       "2023-01-03  False  False  False  False  True   True\n",
       "2023-01-04  False  False  False  False  True   True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.isna(df1)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations   \n",
    "See the Basic section on Binary Ops.\n",
    "\n",
    "#### Stats   \n",
    "Operations in general exclude missing data.\n",
    "\n",
    "Performing a descriptive statistic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    0.222025\n",
       "B   -0.086481\n",
       "C    0.415287\n",
       "D    5.000000\n",
       "F         NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2023-01-01    0.901106\n",
       "2023-01-02    1.614903\n",
       "2023-01-03    1.999366\n",
       "2023-01-04    0.812451\n",
       "2023-01-05    2.509021\n",
       "2023-01-06    0.978682\n",
       "2023-01-07    0.898425\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.mean(1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operating with objects that have different dimensionality and need alignment. In addition, pandas automatically broadcasts along the specified dimension:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2013-01-01    NaN\n",
       "2013-01-02    NaN\n",
       "2013-01-03    1.0\n",
       "2013-01-04    3.0\n",
       "2013-01-05    5.0\n",
       "2013-01-06    NaN\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=pd.Series([1, 3, 5, np.nan, 6, 8], index=dates).shift(2)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>-1.021260</td>\n",
       "      <td>-1.387072</td>\n",
       "      <td>-0.905729</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>-3.471901</td>\n",
       "      <td>-3.362371</td>\n",
       "      <td>-4.663361</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-5.785147</td>\n",
       "      <td>-2.541551</td>\n",
       "      <td>-4.939444</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C    D    F\n",
       "2013-01-01       NaN       NaN       NaN  NaN  NaN\n",
       "2013-01-02       NaN       NaN       NaN  NaN  NaN\n",
       "2013-01-03 -1.021260 -1.387072 -0.905729  4.0  1.0\n",
       "2013-01-04 -3.471901 -3.362371 -4.663361  2.0  0.0\n",
       "2013-01-05 -5.785147 -2.541551 -4.939444  0.0 -1.0\n",
       "2013-01-06       NaN       NaN       NaN  NaN  NaN"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sub(s, axis=\"index\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply   \n",
    "DataFrame.apply() applies a user defined function to the data:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>F</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2013-01-01</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-0.810359</td>\n",
       "      <td>5</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-02</th>\n",
       "      <td>1.011881</td>\n",
       "      <td>-1.467853</td>\n",
       "      <td>0.174271</td>\n",
       "      <td>10</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-03</th>\n",
       "      <td>0.990621</td>\n",
       "      <td>-1.854924</td>\n",
       "      <td>0.268541</td>\n",
       "      <td>15</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-04</th>\n",
       "      <td>0.518720</td>\n",
       "      <td>-2.217296</td>\n",
       "      <td>-1.394820</td>\n",
       "      <td>20</td>\n",
       "      <td>6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-05</th>\n",
       "      <td>-0.266427</td>\n",
       "      <td>0.241153</td>\n",
       "      <td>-1.334264</td>\n",
       "      <td>25</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2013-01-06</th>\n",
       "      <td>0.627724</td>\n",
       "      <td>0.323692</td>\n",
       "      <td>-1.135561</td>\n",
       "      <td>30</td>\n",
       "      <td>15.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   A         B         C   D     F\n",
       "2013-01-01  0.000000  0.000000 -0.810359   5   NaN\n",
       "2013-01-02  1.011881 -1.467853  0.174271  10   1.0\n",
       "2013-01-03  0.990621 -1.854924  0.268541  15   3.0\n",
       "2013-01-04  0.518720 -2.217296 -1.394820  20   6.0\n",
       "2013-01-05 -0.266427  0.241153 -1.334264  25  10.0\n",
       "2013-01-06  0.627724  0.323692 -1.135561  30  15.0"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.apply(np.cumsum)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A    1.797028\n",
       "B    3.926302\n",
       "C    2.647991\n",
       "D    0.000000\n",
       "F    4.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.apply(lambda x: x.max() - x.min())\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogramming  \n",
    "See more at Histogramming and Discretization.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    4\n",
       "1    5\n",
       "2    0\n",
       "3    4\n",
       "4    3\n",
       "5    6\n",
       "6    3\n",
       "7    5\n",
       "8    0\n",
       "9    1\n",
       "dtype: int32"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series(np.random.randint(0, 7, size=10))\n",
    "\n",
    "s\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods   \n",
    "Series is equipped with a set of string processing methods in the str attribute that make it easy to operate on each element of the array, as in the code snippet below. Note that pattern-matching in str generally uses regular expressions by default (and in some cases always uses them). See more at Vectorized String Methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       a\n",
       "1       b\n",
       "2       c\n",
       "3    aaba\n",
       "4    baca\n",
       "5     NaN\n",
       "6    caba\n",
       "7     dog\n",
       "8     cat\n",
       "dtype: object"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([\"A\", \"B\", \"C\", \"Aaba\", \"Baca\", np.nan, \"CABA\", \"dog\", \"cat\"])\n",
    "\n",
    "s.str.lower()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge   \n",
    "#### Concat   \n",
    "pandas provides various facilities for easily combining together Series and DataFrame objects with various kinds of set logic for the indexes and relational algebra functionality in the case of join / merge-type operations.\n",
    "\n",
    "See the Merging section.\n",
    "\n",
    "Concatenating pandas objects together along an axis with concat():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.070919</td>\n",
       "      <td>-0.909621</td>\n",
       "      <td>-0.058982</td>\n",
       "      <td>1.065355</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.942190</td>\n",
       "      <td>2.307742</td>\n",
       "      <td>1.313294</td>\n",
       "      <td>0.904494</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.206415</td>\n",
       "      <td>-0.255212</td>\n",
       "      <td>0.415303</td>\n",
       "      <td>-0.665433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.528560</td>\n",
       "      <td>-0.424218</td>\n",
       "      <td>-0.674206</td>\n",
       "      <td>0.179578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-1.147629</td>\n",
       "      <td>1.593130</td>\n",
       "      <td>0.083113</td>\n",
       "      <td>-0.375661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>-0.067266</td>\n",
       "      <td>-0.636576</td>\n",
       "      <td>0.025570</td>\n",
       "      <td>0.808047</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>-0.480931</td>\n",
       "      <td>1.140837</td>\n",
       "      <td>0.408431</td>\n",
       "      <td>2.374829</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>-0.035620</td>\n",
       "      <td>0.351948</td>\n",
       "      <td>1.159103</td>\n",
       "      <td>-1.073382</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>-0.940397</td>\n",
       "      <td>0.636860</td>\n",
       "      <td>-0.273128</td>\n",
       "      <td>1.445847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>-2.517698</td>\n",
       "      <td>-0.010000</td>\n",
       "      <td>-0.223322</td>\n",
       "      <td>0.710669</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3\n",
       "0  1.070919 -0.909621 -0.058982  1.065355\n",
       "1  0.942190  2.307742  1.313294  0.904494\n",
       "2 -0.206415 -0.255212  0.415303 -0.665433\n",
       "3  0.528560 -0.424218 -0.674206  0.179578\n",
       "4 -1.147629  1.593130  0.083113 -0.375661\n",
       "5 -0.067266 -0.636576  0.025570  0.808047\n",
       "6 -0.480931  1.140837  0.408431  2.374829\n",
       "7 -0.035620  0.351948  1.159103 -1.073382\n",
       "8 -0.940397  0.636860 -0.273128  1.445847\n",
       "9 -2.517698 -0.010000 -0.223322  0.710669"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(np.random.randn(10, 4))\n",
    "\n",
    "df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.070919</td>\n",
       "      <td>-0.909621</td>\n",
       "      <td>-0.058982</td>\n",
       "      <td>1.065355</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.942190</td>\n",
       "      <td>2.307742</td>\n",
       "      <td>1.313294</td>\n",
       "      <td>0.904494</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.206415</td>\n",
       "      <td>-0.255212</td>\n",
       "      <td>0.415303</td>\n",
       "      <td>-0.665433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.528560</td>\n",
       "      <td>-0.424218</td>\n",
       "      <td>-0.674206</td>\n",
       "      <td>0.179578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-1.147629</td>\n",
       "      <td>1.593130</td>\n",
       "      <td>0.083113</td>\n",
       "      <td>-0.375661</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>-0.067266</td>\n",
       "      <td>-0.636576</td>\n",
       "      <td>0.025570</td>\n",
       "      <td>0.808047</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>-0.480931</td>\n",
       "      <td>1.140837</td>\n",
       "      <td>0.408431</td>\n",
       "      <td>2.374829</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>-0.035620</td>\n",
       "      <td>0.351948</td>\n",
       "      <td>1.159103</td>\n",
       "      <td>-1.073382</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>-0.940397</td>\n",
       "      <td>0.636860</td>\n",
       "      <td>-0.273128</td>\n",
       "      <td>1.445847</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>-2.517698</td>\n",
       "      <td>-0.010000</td>\n",
       "      <td>-0.223322</td>\n",
       "      <td>0.710669</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2         3\n",
       "0  1.070919 -0.909621 -0.058982  1.065355\n",
       "1  0.942190  2.307742  1.313294  0.904494\n",
       "2 -0.206415 -0.255212  0.415303 -0.665433\n",
       "3  0.528560 -0.424218 -0.674206  0.179578\n",
       "4 -1.147629  1.593130  0.083113 -0.375661\n",
       "5 -0.067266 -0.636576  0.025570  0.808047\n",
       "6 -0.480931  1.140837  0.408431  2.374829\n",
       "7 -0.035620  0.351948  1.159103 -1.073382\n",
       "8 -0.940397  0.636860 -0.273128  1.445847\n",
       "9 -2.517698 -0.010000 -0.223322  0.710669"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pieces = [df[:3], df[3:7], df[7:]]\n",
    "pd.concat(pieces)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note\n",
    "\n",
    "Adding a column to a DataFrame is relatively fast. However, adding a row requires a copy, and may be expensive. We recommend passing a pre-built list of records to the DataFrame constructor instead of building a DataFrame by iteratively appending records to it.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Join \n",
    "merge() enables SQL style join types along specific columns. See the Database style joining section.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>lval</th>\n",
       "      <th>rval</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>foo</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>foo</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>foo</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>foo</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   key  lval  rval\n",
       "0  foo     1     4\n",
       "1  foo     1     5\n",
       "2  foo     2     4\n",
       "3  foo     2     5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "left = pd.DataFrame({\"key\": [\"foo\", \"foo\"], \"lval\": [1, 2]})\n",
    "\n",
    "right = pd.DataFrame({\"key\": [\"foo\", \"foo\"], \"rval\": [4, 5]})\n",
    "pd.merge(left, right, on=\"key\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>key</th>\n",
       "      <th>lval</th>\n",
       "      <th>rval</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>foo</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>bar</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   key  lval  rval\n",
       "0  foo     1     4\n",
       "1  bar     2     5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "left = pd.DataFrame({\"key\": [\"foo\", \"bar\"], \"lval\": [1, 2]})\n",
    "\n",
    "right = pd.DataFrame({\"key\": [\"foo\", \"bar\"], \"rval\": [4, 5]})\n",
    "pd.merge(left, right, on=\"key\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grouping   \n",
    "By “group by” we are referring to a process involving one or more of the following steps:\n",
    "\n",
    "  >Splitting the data into groups based on some criteria\n",
    "\n",
    "  >Applying a function to each group independently\n",
    "\n",
    "  >Combining the results into a data structure\n",
    "\n",
    "See the Grouping section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>foo</td>\n",
       "      <td>one</td>\n",
       "      <td>0.469626</td>\n",
       "      <td>-0.453533</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>bar</td>\n",
       "      <td>one</td>\n",
       "      <td>-0.528487</td>\n",
       "      <td>0.102063</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>foo</td>\n",
       "      <td>two</td>\n",
       "      <td>-0.165808</td>\n",
       "      <td>0.726964</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>bar</td>\n",
       "      <td>three</td>\n",
       "      <td>0.934137</td>\n",
       "      <td>2.426803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>foo</td>\n",
       "      <td>two</td>\n",
       "      <td>0.775809</td>\n",
       "      <td>-0.393736</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>bar</td>\n",
       "      <td>two</td>\n",
       "      <td>0.792758</td>\n",
       "      <td>1.703328</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>foo</td>\n",
       "      <td>one</td>\n",
       "      <td>1.664355</td>\n",
       "      <td>-1.335949</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>foo</td>\n",
       "      <td>three</td>\n",
       "      <td>0.005753</td>\n",
       "      <td>0.520489</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A      B         C         D\n",
       "0  foo    one  0.469626 -0.453533\n",
       "1  bar    one -0.528487  0.102063\n",
       "2  foo    two -0.165808  0.726964\n",
       "3  bar  three  0.934137  2.426803\n",
       "4  foo    two  0.775809 -0.393736\n",
       "5  bar    two  0.792758  1.703328\n",
       "6  foo    one  1.664355 -1.335949\n",
       "7  foo  three  0.005753  0.520489"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(\n",
    "    {\n",
    "        \"A\": [\"foo\", \"bar\", \"foo\", \"bar\", \"foo\", \"bar\", \"foo\", \"foo\"],\n",
    "        \"B\": [\"one\", \"one\", \"two\", \"three\", \"two\", \"two\", \"one\", \"three\"],\n",
    "        \"C\": np.random.randn(8),\n",
    "        \"D\": np.random.randn(8),\n",
    "    }\n",
    ")\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>bar</th>\n",
       "      <td>1.198408</td>\n",
       "      <td>4.232194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>foo</th>\n",
       "      <td>2.749736</td>\n",
       "      <td>-0.935764</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            C         D\n",
       "A                      \n",
       "bar  1.198408  4.232194\n",
       "foo  2.749736 -0.935764"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(\"A\")[[\"C\", \"D\"]].sum()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">bar</th>\n",
       "      <th>one</th>\n",
       "      <td>-0.528487</td>\n",
       "      <td>0.102063</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0.934137</td>\n",
       "      <td>2.426803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>0.792758</td>\n",
       "      <td>1.703328</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">foo</th>\n",
       "      <th>one</th>\n",
       "      <td>2.133982</td>\n",
       "      <td>-1.789481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>three</th>\n",
       "      <td>0.005753</td>\n",
       "      <td>0.520489</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>0.610001</td>\n",
       "      <td>0.333228</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  C         D\n",
       "A   B                        \n",
       "bar one   -0.528487  0.102063\n",
       "    three  0.934137  2.426803\n",
       "    two    0.792758  1.703328\n",
       "foo one    2.133982 -1.789481\n",
       "    three  0.005753  0.520489\n",
       "    two    0.610001  0.333228"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby([\"A\", \"B\"]).sum()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping   \n",
    "See the sections on Hierarchical Indexing and Reshaping.\n",
    "\n",
    "Stack\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>first</th>\n",
       "      <th>second</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">bar</th>\n",
       "      <th>one</th>\n",
       "      <td>0.592387</td>\n",
       "      <td>0.720654</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>-0.240999</td>\n",
       "      <td>0.132012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">baz</th>\n",
       "      <th>one</th>\n",
       "      <td>1.181864</td>\n",
       "      <td>0.469986</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>two</th>\n",
       "      <td>-1.677578</td>\n",
       "      <td>0.122411</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     A         B\n",
       "first second                    \n",
       "bar   one     0.592387  0.720654\n",
       "      two    -0.240999  0.132012\n",
       "baz   one     1.181864  0.469986\n",
       "      two    -1.677578  0.122411"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuples = list(\n",
    "    zip(\n",
    "        [\"bar\", \"bar\", \"baz\", \"baz\", \"foo\", \"foo\", \"qux\", \"qux\"],\n",
    "        [\"one\", \"two\", \"one\", \"two\", \"one\", \"two\", \"one\", \"two\"],\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "index = pd.MultiIndex.from_tuples(tuples, names=[\"first\", \"second\"])\n",
    "\n",
    "df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=[\"A\", \"B\"])\n",
    "\n",
    "df2 = df[:4]\n",
    "\n",
    "df2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "first  second   \n",
       "bar    one     A    0.592387\n",
       "               B    0.720654\n",
       "       two     A   -0.240999\n",
       "               B    0.132012\n",
       "baz    one     A    1.181864\n",
       "               B    0.469986\n",
       "       two     A   -1.677578\n",
       "               B    0.122411\n",
       "dtype: float64"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked = df2.stack()\n",
    "\n",
    "stacked\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>first</th>\n",
       "      <th>bar</th>\n",
       "      <th>baz</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>second</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">one</th>\n",
       "      <th>A</th>\n",
       "      <td>0.592387</td>\n",
       "      <td>1.181864</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>0.720654</td>\n",
       "      <td>0.469986</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">two</th>\n",
       "      <th>A</th>\n",
       "      <td>-0.240999</td>\n",
       "      <td>-1.677578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>0.132012</td>\n",
       "      <td>0.122411</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "first          bar       baz\n",
       "second                      \n",
       "one    A  0.592387  1.181864\n",
       "       B  0.720654  0.469986\n",
       "two    A -0.240999 -1.677578\n",
       "       B  0.132012  0.122411"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stacked.unstack()\n",
    "\n",
    "\n",
    "stacked.unstack(1)\n",
    "\n",
    "\n",
    "stacked.unstack(0)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pivot tables  \n",
    "See the section on Pivot Tables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>one</td>\n",
       "      <td>A</td>\n",
       "      <td>foo</td>\n",
       "      <td>0.571207</td>\n",
       "      <td>0.443537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>one</td>\n",
       "      <td>B</td>\n",
       "      <td>foo</td>\n",
       "      <td>0.059570</td>\n",
       "      <td>0.549866</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>two</td>\n",
       "      <td>C</td>\n",
       "      <td>foo</td>\n",
       "      <td>-0.327195</td>\n",
       "      <td>0.222671</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>three</td>\n",
       "      <td>A</td>\n",
       "      <td>bar</td>\n",
       "      <td>-0.142887</td>\n",
       "      <td>-0.280958</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>one</td>\n",
       "      <td>B</td>\n",
       "      <td>bar</td>\n",
       "      <td>1.484399</td>\n",
       "      <td>0.341254</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>one</td>\n",
       "      <td>C</td>\n",
       "      <td>bar</td>\n",
       "      <td>0.657294</td>\n",
       "      <td>0.111515</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>two</td>\n",
       "      <td>A</td>\n",
       "      <td>foo</td>\n",
       "      <td>-1.309137</td>\n",
       "      <td>-1.301511</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>three</td>\n",
       "      <td>B</td>\n",
       "      <td>foo</td>\n",
       "      <td>-0.382706</td>\n",
       "      <td>0.322421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>one</td>\n",
       "      <td>C</td>\n",
       "      <td>foo</td>\n",
       "      <td>-0.217702</td>\n",
       "      <td>0.702098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>one</td>\n",
       "      <td>A</td>\n",
       "      <td>bar</td>\n",
       "      <td>-0.479563</td>\n",
       "      <td>-1.872191</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>two</td>\n",
       "      <td>B</td>\n",
       "      <td>bar</td>\n",
       "      <td>1.102865</td>\n",
       "      <td>-0.331685</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>three</td>\n",
       "      <td>C</td>\n",
       "      <td>bar</td>\n",
       "      <td>-0.626540</td>\n",
       "      <td>-0.590578</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        A  B    C         D         E\n",
       "0     one  A  foo  0.571207  0.443537\n",
       "1     one  B  foo  0.059570  0.549866\n",
       "2     two  C  foo -0.327195  0.222671\n",
       "3   three  A  bar -0.142887 -0.280958\n",
       "4     one  B  bar  1.484399  0.341254\n",
       "5     one  C  bar  0.657294  0.111515\n",
       "6     two  A  foo -1.309137 -1.301511\n",
       "7   three  B  foo -0.382706  0.322421\n",
       "8     one  C  foo -0.217702  0.702098\n",
       "9     one  A  bar -0.479563 -1.872191\n",
       "10    two  B  bar  1.102865 -0.331685\n",
       "11  three  C  bar -0.626540 -0.590578"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(\n",
    "    {\n",
    "        \"A\": [\"one\", \"one\", \"two\", \"three\"] * 3,\n",
    "        \"B\": [\"A\", \"B\", \"C\"] * 4,\n",
    "        \"C\": [\"foo\", \"foo\", \"foo\", \"bar\", \"bar\", \"bar\"] * 2,\n",
    "        \"D\": np.random.randn(12),\n",
    "        \"E\": np.random.randn(12),\n",
    "    }\n",
    ")\n",
    "\n",
    "\n",
    "df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>C</th>\n",
       "      <th>bar</th>\n",
       "      <th>foo</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">one</th>\n",
       "      <th>A</th>\n",
       "      <td>-0.479563</td>\n",
       "      <td>0.571207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1.484399</td>\n",
       "      <td>0.059570</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>0.657294</td>\n",
       "      <td>-0.217702</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">three</th>\n",
       "      <th>A</th>\n",
       "      <td>-0.142887</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.382706</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>-0.626540</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">two</th>\n",
       "      <th>A</th>\n",
       "      <td>NaN</td>\n",
       "      <td>-1.309137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>1.102865</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.327195</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "C             bar       foo\n",
       "A     B                    \n",
       "one   A -0.479563  0.571207\n",
       "      B  1.484399  0.059570\n",
       "      C  0.657294 -0.217702\n",
       "three A -0.142887       NaN\n",
       "      B       NaN -0.382706\n",
       "      C -0.626540       NaN\n",
       "two   A       NaN -1.309137\n",
       "      B  1.102865       NaN\n",
       "      C       NaN -0.327195"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(df, values=\"D\", index=[\"A\", \"B\"], columns=[\"C\"])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time series   \n",
    "pandas has simple, powerful, and efficient functionality for performing resampling operations during frequency conversion (e.g., converting secondly data into 5-minutely data). This is extremely common in, but not limited to, financial applications. See the Time Series section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-01-01    23930\n",
       "Freq: 5T, dtype: int32"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = pd.date_range(\"1/1/2012\", periods=100, freq=\"S\")\n",
    "\n",
    "ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)\n",
    "\n",
    "ts.resample(\"5Min\").sum()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series.tz_localize() localizes a time series to a time zone:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-03-06   -1.069089\n",
       "2012-03-07   -0.231289\n",
       "2012-03-08   -0.710142\n",
       "2012-03-09   -0.830763\n",
       "2012-03-10    1.825935\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = pd.date_range(\"3/6/2012 00:00\", periods=5, freq=\"D\")\n",
    "\n",
    "ts = pd.Series(np.random.randn(len(rng)), rng)\n",
    "\n",
    "ts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-03-06 00:00:00+00:00   -1.069089\n",
       "2012-03-07 00:00:00+00:00   -0.231289\n",
       "2012-03-08 00:00:00+00:00   -0.710142\n",
       "2012-03-09 00:00:00+00:00   -0.830763\n",
       "2012-03-10 00:00:00+00:00    1.825935\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts_utc = ts.tz_localize(\"UTC\")\n",
    "\n",
    "ts_utc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Series.tz_convert() converts a timezones aware time series to another time zone:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-03-05 19:00:00-05:00   -1.069089\n",
       "2012-03-06 19:00:00-05:00   -0.231289\n",
       "2012-03-07 19:00:00-05:00   -0.710142\n",
       "2012-03-08 19:00:00-05:00   -0.830763\n",
       "2012-03-09 19:00:00-05:00    1.825935\n",
       "Freq: D, dtype: float64"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ts_utc.tz_convert(\"US/Eastern\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting between time span representations:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-01-31    0.374555\n",
       "2012-02-29    0.033252\n",
       "2012-03-31    0.377800\n",
       "2012-04-30    0.121815\n",
       "2012-05-31   -0.552315\n",
       "Freq: M, dtype: float64"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = pd.date_range(\"1/1/2012\", periods=5, freq=\"M\")\n",
    "\n",
    "ts = pd.Series(np.random.randn(len(rng)), index=rng)\n",
    "\n",
    "ts\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-01    0.374555\n",
       "2012-02    0.033252\n",
       "2012-03    0.377800\n",
       "2012-04    0.121815\n",
       "2012-05   -0.552315\n",
       "Freq: M, dtype: float64"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ps = ts.to_period()\n",
    "\n",
    "ps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2012-01-01    0.374555\n",
       "2012-02-01    0.033252\n",
       "2012-03-01    0.377800\n",
       "2012-04-01    0.121815\n",
       "2012-05-01   -0.552315\n",
       "Freq: MS, dtype: float64"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ps.to_timestamp()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categoricals   \n",
    "pandas can include categorical data in a DataFrame. For full docs, see the categorical introduction and the API documentation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pandas can include categorical data in a DataFrame. For full docs, see the categorical introduction and the API documentation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>raw_grade</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>a</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>b</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>a</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>a</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>e</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id raw_grade\n",
       "0   1         a\n",
       "1   2         b\n",
       "2   3         b\n",
       "3   4         a\n",
       "4   5         a\n",
       "5   6         e"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(\n",
    "    {\"id\": [1, 2, 3, 4, 5, 6], \"raw_grade\": [\"a\", \"b\", \"b\", \"a\", \"a\", \"e\"]}\n",
    ")\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rename the categories to more meaningful names:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    a\n",
       "1    b\n",
       "2    b\n",
       "3    a\n",
       "4    a\n",
       "5    e\n",
       "Name: grade, dtype: category\n",
       "Categories (3, object): ['a', 'b', 'e']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"grade\"] = df[\"raw_grade\"].astype(\"category\")\n",
    "\n",
    "df[\"grade\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_categories = [\"very good\", \"good\", \"very bad\"]\n",
    "\n",
    "df[\"grade\"] = df[\"grade\"].cat.rename_categories(new_categories)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reorder the categories and simultaneously add the missing categories (methods under Series.cat() return a new Series by default):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    very good\n",
       "1         good\n",
       "2         good\n",
       "3    very good\n",
       "4    very good\n",
       "5     very bad\n",
       "Name: grade, dtype: category\n",
       "Categories (5, object): ['very bad', 'bad', 'medium', 'good', 'very good']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[\"grade\"] = df[\"grade\"].cat.set_categories(\n",
    "    [\"very bad\", \"bad\", \"medium\", \"good\", \"very good\"]\n",
    ")\n",
    "\n",
    "\n",
    "df[\"grade\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>raw_grade</th>\n",
       "      <th>grade</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>e</td>\n",
       "      <td>very bad</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>b</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>b</td>\n",
       "      <td>good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>a</td>\n",
       "      <td>very good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>a</td>\n",
       "      <td>very good</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>a</td>\n",
       "      <td>very good</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   id raw_grade      grade\n",
       "5   6         e   very bad\n",
       "1   2         b       good\n",
       "2   3         b       good\n",
       "0   1         a  very good\n",
       "3   4         a  very good\n",
       "4   5         a  very good"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sort_values(by=\"grade\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "grade\n",
       "very bad     1\n",
       "bad          0\n",
       "medium       0\n",
       "good         2\n",
       "very good    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(\"grade\").size()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting   \n",
    "See the Plotting docs.\n",
    "\n",
    "We use the standard convention for referencing the matplotlib API:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.close(\"all\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ts = pd.Series(np.random.randn(1000),\n",
    "               index=pd.date_range(\"1/1/2000\", periods=1000))\n",
    "\n",
    "ts = ts.cumsum()\n",
    "\n",
    "ts.plot()\n",
    "#plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20ce9501870>"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame(\n",
    "    np.random.randn(1000, 4), index=ts.index, columns=[\"A\", \"B\", \"C\", \"D\"]\n",
    ")\n",
    "\n",
    "\n",
    "df = df.cumsum()\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "df.plot()\n",
    "\n",
    "plt.legend(loc='best')\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing and exporting data \n",
    "\n",
    "CSV   \n",
    "Writing to a csv file: using DataFrame.to_csv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv(\"foo.csv\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading from a csv file: using read_csv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv(\"foo.csv\")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excel \n",
    "Reading and writing to Excel.\n",
    "\n",
    "Writing to an excel file using DataFrame.to_excel():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_excel(\"foo.xlsx\", sheet_name=\"Sheet1\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_excel(\"foo.xlsx\", \"Sheet1\", index_col=None, na_values=[\"NA\"])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('python310')",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "a888cd810c90be07c3c921372a6d7ff433f5a38d5779dfb2a871d99db75673fb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

一键复制编辑原始数据按行查看历史

提交于 2023-03-23 16:20 . add第四章

马建仓 AI 助手

尝试更多

代码解读

代码找茬

代码优化

https://gitee.com/boreaslynn/python2023.git

git@gitee.com:boreaslynn/python2023.git

boreaslynn

python2023

master

BoreasLynn / python2023

简介

发行版

贡献者

近期动态

BoreasLynn / python2023 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

BoreasLynn / python2023