python课件五——基本数据类型——元组.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#元组\" data-toc-modified-id=\"元组-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>元组</a></span><ul class=\"toc-item\"><li><span><a href=\"#元组的定义\" data-toc-modified-id=\"元组的定义-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>元组的定义</a></span><ul class=\"toc-item\"><li><span><a href=\"#使用tuple()将其他可迭代对象转化成元组\" data-toc-modified-id=\"使用tuple()将其他可迭代对象转化成元组-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>使用tuple()将其他可迭代对象转化成元组</a></span></li><li><span><a href=\"#使用(-)来定义\" data-toc-modified-id=\"使用(-)来定义-1.1.2\"><span class=\"toc-item-num\">1.1.2&nbsp;&nbsp;</span>使用( )来定义</a></span></li><li><span><a href=\"#易错点，只包含一个元素的元组的定义\" data-toc-modified-id=\"易错点，只包含一个元素的元组的定义-1.1.3\"><span class=\"toc-item-num\">1.1.3&nbsp;&nbsp;</span>易错点，只包含一个元素的元组的定义</a></span></li></ul></li><li><span><a href=\"#元祖的一些运算\" data-toc-modified-id=\"元祖的一些运算-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>元祖的一些运算</a></span><ul class=\"toc-item\"><li><span><a href=\"#+号运算，把元祖的元素全部添加到一个新的元祖当中\" data-toc-modified-id=\"+号运算，把元祖的元素全部添加到一个新的元祖当中-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>+号运算，把元祖的元素全部添加到一个新的元祖当中</a></span></li><li><span><a href=\"#*号运算，重复元祖当中的元素\" data-toc-modified-id=\"*号运算，重复元祖当中的元素-1.2.2\"><span class=\"toc-item-num\">1.2.2&nbsp;&nbsp;</span>*号运算，重复元祖当中的元素</a></span></li><li><span><a href=\"#in包含运算,-判断元素是否在元祖当中\" data-toc-modified-id=\"in包含运算,-判断元素是否在元祖当中-1.2.3\"><span class=\"toc-item-num\">1.2.3&nbsp;&nbsp;</span>in包含运算, 判断元素是否在元祖当中</a></span></li></ul></li><li><span><a href=\"#元组的索引和切片\" data-toc-modified-id=\"元组的索引和切片-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>元组的索引和切片</a></span><ul class=\"toc-item\"><li><span><a href=\"#练一练，不同数据类型之间的复合索引和切片\" data-toc-modified-id=\"练一练，不同数据类型之间的复合索引和切片-1.3.1\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>练一练，不同数据类型之间的复合索引和切片</a></span></li></ul></li><li><span><a href=\"#元组对象的常用方法\" data-toc-modified-id=\"元组对象的常用方法-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>元组对象的常用方法</a></span><ul class=\"toc-item\"><li><span><a href=\"#计数tuple.count()\" data-toc-modified-id=\"计数tuple.count()-1.4.1\"><span class=\"toc-item-num\">1.4.1&nbsp;&nbsp;</span>计数tuple.count()</a></span></li><li><span><a href=\"#索引tuple.index()\" data-toc-modified-id=\"索引tuple.index()-1.4.2\"><span class=\"toc-item-num\">1.4.2&nbsp;&nbsp;</span>索引tuple.index()</a></span></li></ul></li><li><span><a href=\"#[易错点]-元组不可变的真正含义\" data-toc-modified-id=\"[易错点]-元组不可变的真正含义-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>[易错点] 元组不可变的真正含义</a></span></li></ul></li><li><span><a href=\"#挑战题\" data-toc-modified-id=\"挑战题-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>挑战题</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置全部行输出\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 元组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 元组是不可变数据类型\n",
    "- 元组中的数据类型不限\n",
    "- 元组中的元素之间用逗号分割\n",
    "- 最外层用( )括起来\n",
    "- 由于元组和列表极其相似，元组又常常被称之为  只读列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组的定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用tuple()将其他可迭代对象转化成元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'hello world'\n",
    "t = tuple(s)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('life', 'is', 'short', 'I', 'use', 'python')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['life', 'is', 'short', 'I', 'use', 'python']\n",
    "t = tuple(L)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3], '数据分析70期')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tu = ([1, 2, 3], '数据分析70期')\n",
    "tu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用( )来定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'hello world', ['人生苦短', 'I use python'], (1, '123', [1, 2]))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1, 'hello world', ['人生苦短', 'I use python'], (1, '123', [1, 2]))\n",
    "a\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 易错点，只包含一个元素的元组的定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ('hello world')\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ([1, 2, 3])\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**只含有一个元素的元组的定义，后面必须加一个逗号**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1,)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello world',)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ('hello world',)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3],)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ([1, 2, 3],)\n",
    "t\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元祖的一些运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### +号运算，把元祖的元素全部添加到一个新的元祖当中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (1, 2, 3)\n",
    "b = (4, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *号运算，重复元祖当中的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 2)*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "print((1,)*10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### in包含运算, 判断元素是否在元祖当中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in (1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 in (1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2] in (1, 2, 3, [1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组的索引和切片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**这里和列表是一模一样的，没有任何区别，这里就给大家练一练切片和索引**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('life', 'is', 'short', 'I', 'use', 'python')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = ('life', 'is',  'short', 'I', 'use', 'python')\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#取出索引为0的元素\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#取出倒数第一个元素\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#从索引为1的地方开始，取出索引为1,2,3的元素\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出('is', 'I')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练一练，不同数据类型之间的复合索引和切片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'Hello', (1, 2, ([1, 1, '我最特殊', 3], 3), 4, 5))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 =(1, 2, 3, 'Hello',(1, 2,([1, 1, '我最特殊', 3], 3) , 4, 5)) \n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出'Hello'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出 'Hel'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出 'lle'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出列表 [1, 1, '我最特殊', 3]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出  '我最特殊'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何取出 ‘特殊’\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组对象的常用方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们之前说了元组是不可变数据类型，那么他就没有增 删 改的方法，相比列表就少了很多。  \n",
    "如果需要修改，可先转化为列表，通过列表进行修改，再转变成元组。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计数tuple.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('life', 'is', 'short', 'I', 'use', 'python', 'python')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = ('life', 'is',  'short', 'I', 'use', 'python', 'python')\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1.count('python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  索引tuple.index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('life', 'is', 'short', 'I', 'use', 'python', 'python')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = ('life', 'is',  'short', 'I', 'use', 'python', 'python')\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1.index('python')   #返回某元素第一次出现的索引位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "tuple.index(x): x not in tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-5af542c37a9a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtuple1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'python'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# 指定范围内查找，找不到，就报错\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: tuple.index(x): x not in tuple"
     ]
    }
   ],
   "source": [
    "tuple1.index('python',0, 4)  # 指定范围内查找，找不到，就报错"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [易错点] 元组不可变的真正含义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 'hello world', ['人生', '苦短', '我用python'])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = (1, 2, 'hello world', ['人生', '苦短', '我用python'])\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-39-a6c49905432f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtuple1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m     \u001b[1;31m#我们说了元组是不能改变的，所以报错了，没有问题\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tuple1[1] = 1     #我们说了元组是不能改变的，所以报错了，没有问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1[3][0]='life'    #为什么这里没有报错"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 'hello world', ['life', '苦短', '我用python'])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1     # 看样子我们的元组tuple1改变了...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**元组的不可变是指，元组本身自己的元素不可变，同理列表可变是指列表自己本身的元素可变。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', ['A', 'B'])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple2 = ('a', 'b', ['A', 'B'])\n",
    "tuple2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', ['X', 'Y'])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple2[2][0] = 'X'\n",
    "tuple2[2][1] = 'Y'\n",
    "tuple2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple2[2].append('aaa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'b', ['X', 'Y', 'aaa'])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple2"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**当我们把list的元素’A'和‘B'修改为’X'和‘Y'后， tuple2变为：**"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "表面上看， tuple2的元素好像变了，但其实变得不是tuple的元素而是list的元素。  \n",
    "tuple2开始指向的list并没有改成别的list，所以tuple2所谓的 ”不变“ 是指， tuple的每个元素，**指向永远不变**。  \n",
    "即指向’a'，就不能改成指向‘b'，指向一个list，就不能改成指向其他对象，但**指向的这个list本身是可变的！**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "309.141px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}