PythonBase3 数据类型.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python常用数据类型操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数值型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```Python\n",
    "表现形式：\n",
    "    整数 int (二进制、八进制、十进制、十六进制)\n",
    "    浮点数 float\n",
    "    复数 complex\n",
    "note：python3中int可以自动调整大小，可以当做long类型\n",
    "     分正负\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 常用操作\n",
    "\n",
    "'''\n",
    "1.适合所有Python运算符\n",
    "2.数学函数\n",
    " # 内建函数\n",
    " abs(num) \n",
    " max(num1,num2,...) min(num1,num2,...) \n",
    " round(num[,n])\n",
    " pow(x,y)\n",
    "\n",
    " # math模块函数\n",
    " ceil(num) floor(num) sqrt(num) log(x,base)\n",
    " \n",
    " note:先导入对应模块 ( import math )，通过 模块名.函数名(参数) 使用 ( math.fabs(-10) )\n",
    " \n",
    "3.随机函数 import random\n",
    ".random() [0,1)内的随机小数\n",
    ".choice(seq) 从一个序列中挑选一个随机数值 random.choice((1,2,48,9))\n",
    ".randint(x,y) [x,y]内的随机整数\n",
    ".randrange(start,stop=None,step=1) 给定区间[start,stop)内随机整数\n",
    ".uniform(x,y) [x,y]内的随机小数\n",
    "\n",
    "4.三角函数(非内置，math库)\n",
    ".sin(x) .cos(x) .tan(x) .asin(x) .acos(x) .atan(x) # x是弧度\n",
    ".degrees(x) 弧度转角度\n",
    ".radians(x) 角度转弧度\n",
    "\n",
    "5.数学常量\n",
    "math.pi\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "****************************************************************"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "dir(math) # 查看库里的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function fsum in module math:\n",
      "\n",
      "fsum(seq, /)\n",
      "    Return an accurate floating point sum of values in the iterable seq.\n",
      "    \n",
      "    Assumes IEEE-754 floating point arithmetic.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.fsum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.fsum([2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "****************************************************************"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.195278260146031\n",
      "1\n",
      "2.2497009052188184\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "print(random.random()) # [0,1)内小数\n",
    "print(random.choice([1,2,3,8,7]))\n",
    "print(random.uniform(1,4)) # [1,4]内小数\n",
    "print(random.randint(3,9)) # [3,9]内整数\n",
    "print(random.randrange(3,9,2)) # [3,9)内整数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "****************************************************************"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.9880316240928618\n",
      "0.49999999999999994\n",
      "0.49999999999999994\n"
     ]
    }
   ],
   "source": [
    "print(math.sin(30))\n",
    "print(math.sin(30/180*math.pi))\n",
    "print(math.sin(math.radians(30)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 布尔类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True + 2)\n",
    "\n",
    "# bool类型 是 int 的子类\n",
    "print(issubclass(bool,int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love python\n",
      "\n",
      "i am \\n wxy.\n",
      "i am \\n wxy\n",
      "a\taa\taaa\n",
      "b\tbbbb\t\n",
      "a\u000b",
      "aa\u000b",
      "aaa\n",
      "b\u000b",
      "bbbb\u000b",
      "bb\n"
     ]
    }
   ],
   "source": [
    "\n",
    "'''\n",
    "转义符\n",
    "'''\n",
    "\n",
    "# \\ 在行尾则为续行符，或反斜杠符号\n",
    "print('I love\\\n",
    " python\\n')\n",
    "print('i am \\\\n wxy.')\n",
    "print(r'i am \\n wxy') # 前面加个r表示原始字符串\n",
    "\n",
    "# \\t 横向制表符\n",
    "# \\v 纵向制表符\n",
    "print('a\\taa\\taaa\\nb\\tbbbb\\t')\n",
    "print('a\\vaa\\vaaa\\nb\\vbbbb\\vbb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 基本操作-字符串拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is wxy.\n",
      "my name is wxy.my name is wxy.\n"
     ]
    }
   ],
   "source": [
    "# + *\n",
    "result ='my name is'+ ' wxy.'\n",
    "print(result)\n",
    "print(result*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is wxy, age is 24.\n"
     ]
    }
   ],
   "source": [
    "# '%s,%d,...'%(a,b,...)\n",
    "result1 = 'my name is %s, age is %d.'%('wxy',24)\n",
    "print(result1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 基本操作-字符串切片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a d\n",
      "g d a \n",
      "\n",
      "3 \n",
      "\n",
      "7 \n",
      "\n",
      "abc\n",
      "defg \n",
      "\n",
      "aceg\n",
      "geca\n"
     ]
    }
   ],
   "source": [
    "name = 'abcdefg'\n",
    "# 获取某一个字符\n",
    "print(name[0],name[3])\n",
    "print(name[-1],name[-4],name[-7],'\\n')\n",
    "\n",
    "# 获取字符下标\n",
    "print(name.index('d'),'\\n') \n",
    "\n",
    "# 获取字符串长度\n",
    "print(len(name),'\\n')\n",
    "\n",
    "# 获取字符串\n",
    "print(name[0:3]) # 只取下标是0，1，2的，3取不到\n",
    "print(name[3:],'\\n') # 取到最后 name[3:len(name)]\n",
    "# 步长>0 从左到右，步长<0 从右到左\n",
    "print(name[::2]) # 隔一个取\n",
    "print(name[::-2]) # name[0::-1]❌"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本操作-常用函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.## 内建函数\n",
    "2.#  对象方法类  对象.方法(参数)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "查找计算类\n",
    "'''\n",
    "# len(str)\n",
    "\n",
    "#******************************************************************************************#\n",
    "\n",
    "# s.find(sub,start=0,end=len(str)) 查找，从左往右找到返回指定索引，找不到返回-1\n",
    "\n",
    "name = 'my name is wxy'\n",
    "num = name.find('wx')\n",
    "print(num)\n",
    "\n",
    "# s.rfind() 同find 从右往左查找\n",
    "\n",
    "# s.index() 获取索引，类似find 找不到返回错误\n",
    "# s.rindex() 从右往左 \n",
    "\n",
    "#******************************************************************************************#\n",
    "\n",
    "# s.count(sub,start=0,end=len(str))\n",
    "print(name.count('y',4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mY name is wxy\n",
      "my name is wxy \n",
      "\n",
      "My name is wxy\n",
      "My Name Is Wxy \n",
      "\n",
      "MY NAME IS WXY\n",
      "my name is wxy\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "转换类\n",
    "'''\n",
    "# s.replace(old,new[,count])\n",
    "print(name.replace('y','Y',1))\n",
    "print(name,'\\n') # 原字符串不改变\n",
    "\n",
    "# s.capitalize() 首字母大写,不改变原字符串\n",
    "print(name.capitalize())\n",
    "# s.title() 每个单词首字母大写,不改原str\n",
    "print(name.title(),'\\n')\n",
    "\n",
    "# s.upper() s.lower() 所有改成大/小写，不改原str\n",
    "print(name.upper())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******my name is wxy \n",
      "\n",
      " mmmyyy name is ritta. \n",
      "name is ritta. \n",
      " mmmyyy name is ri\n",
      "yyy name is ri\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "填充压缩\n",
    "'''\n",
    "# s.ljust(width,fillchar) 原字符串靠左，不改原str，fillchar只能一个字符\n",
    "# s.rjust(width,fillchar)\n",
    "# s.center(width,fillchar) 原字符串居中，不够右多\n",
    "print(name.rjust(20,'*'),'\\n')\n",
    "\n",
    "# s.lstrip(char) 从左检索，仅移除左侧字符,不写char默认空格\n",
    "# s.rstrip(char) 从右\n",
    "str1 = ' mmmyyy name is ritta. '\n",
    "print(str1,str1.lstrip(' my'),sep='\\n') \n",
    "'''\n",
    "   是从左开始第一个，注意有空格，光str1.lstrip('my')则m和y不删除，删除的是每一个m和y\n",
    "'''\n",
    "print(str1.rstrip(' .ta'))\n",
    "# s.strip(char)去掉左右两边\n",
    "print(str1.strip(' .amt')) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s.split(sep[,maxsplit]):\n",
      "['1996', '24', 'female', 'wxy', '0510-89'] \n",
      " 1996-24-female-wxy-0510-89 \n",
      "\n",
      "s.partition(sep):\n",
      "('1996-24-female-wxy-0510', '-', '89') \n",
      "\n",
      "splitlines(keepends):\n",
      "1992-24\n",
      "female\r",
      " wxy-0510\n",
      "['1992-24\\n', 'female\\r', ' wxy-0510']\n",
      "\n",
      "\n",
      "s.join(iterable):\n",
      "['1996', '24', 'wxy'] \n",
      " 1996,24,wxy\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "分割拼接\n",
    "'''\n",
    "# s.split(sep[,maxsplit]) 分隔符，最大分割次数，分割后的子字符串形成list,不改原\n",
    "info = '1996-24-female-wxy-0510-89'\n",
    "print('s.split(sep[,maxsplit]):')\n",
    "print(info.split('-',4),'\\n',info,'\\n')\n",
    "\n",
    "# s.partition(sep) 返回元组（分隔符左侧的，分隔符，分隔符右侧的） 找不到分隔符则（原字符串，空，空）\n",
    "print('s.partition(sep):')\n",
    "print(info.rpartition('-'),'\\n') \n",
    "# s.rpartition(sep) 从右找到分隔符为止\n",
    "\n",
    "# splitlines(keepends) 依据\\r(回车) \\n分割，保存到list，keepends是否保留换行符True/False(默认)\n",
    "print('splitlines(keepends):')\n",
    "info2 = '1992-24\\nfemale\\r wxy-0510'\n",
    "print(info2,info2.splitlines(True),'\\n',sep='\\n')\n",
    "\n",
    "# s.join(iterable) 根据指定字符串,将给定可迭代对象拼接，得到字符串，和split相反\n",
    "print('s.join(iterable):')\n",
    "item = ['1996','24','wxy']\n",
    "print(item,'\\n',','.join(item))\n",
    "\n",
    "\n",
    "# rpartition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False \n",
      "\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "判定类\n",
    "'''\n",
    "# s.isalpha() 是否所有都是(大/小)字母，空串也是False\n",
    "# s.isdigit() 是否都是数字\n",
    "# s.isalnum() 是否都是数字和字母\n",
    "\n",
    "# s.isspace() 是否都是空格等不可见转义符\n",
    "\n",
    "print('ab 123'.isalnum())\n",
    "print(''.isspace(),'\\n')\n",
    "\n",
    "# s.startswith(prefix,start=0,end=len(str))\n",
    "# s.endswith(suffix,start=0,end=len(str))\n",
    "namefile = '2018-9,wxy:table'\n",
    "print(namefile.startswith('-9',4))\n",
    "print(namefile.endswith('table'))\n",
    "\n",
    "# 补充 in, not in\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 概念定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "定义方法1:\n",
      "['wxy', 24, True]\n",
      "[]\n",
      "['123', [], 45, ['wxy', 24, True]]\n",
      "<class 'list'>\n",
      "\n",
      "定义方法2:\n",
      "[1, 4, 9, 16, 25]\n",
      "[1, 9, 25]\n",
      "\n",
      "定义方法3：\n",
      "range(0, 5) <class 'range'> 1\n"
     ]
    }
   ],
   "source": [
    "# 有序可变的元素集合，可存放不同类型元素\n",
    "\n",
    "#字符串 不可改 里面的字符，不可变 str[2]='d'❎\n",
    "#列表 可变 里面的内容\n",
    "\n",
    "# 定义方法1\n",
    "print('定义方法1:')\n",
    "list1 = ['wxy',24,True]\n",
    "list2 = []\n",
    "list3 = ['123',list2,45,list1] # 列表嵌套\n",
    "print(list1,list2,list3,type(list3),sep='\\n')\n",
    "\n",
    "#定义方法2 映射解析，过滤\n",
    "print('\\n定义方法2:')\n",
    "list4 = [1,2,3,4,5]\n",
    "list5 = [i**2 for i in list4]\n",
    "list6 = [i**2 for i in list4 if i%2 != 0]\n",
    "print(list5,list6,sep='\\n')\n",
    "\n",
    "# 定义方法3 range()\n",
    "# 只有使用时才会生成列表\n",
    "print('\\n定义方法3：')\n",
    "list7 = range(5)\n",
    "print(list7,type(list7),list7[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常用操作方法\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 增 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [5]]\n",
      "[1, 2, 100, 3, [5]]\n",
      "[1, 2, 100, 3, [5], 'a', 'b', 'c']\n",
      "[1, 2, 100, 3, [5], 'a', 'b', 'c', 1, 2, 100, 3, [5], 'a', 'b', 'c']\n",
      "[1, 2, 100, 3, [5], 'a', 'b', 'c', 'wx', 'op']\n"
     ]
    }
   ],
   "source": [
    "# 都是方法，对象.方法\n",
    "\n",
    "'''\n",
    "增 \n",
    "# 改变原列表,返回None\n",
    "'''\n",
    "# l.append(object)\n",
    "myList = [1,2,3]\n",
    "myList.append([5]) #把 一个元素 追加到最后\n",
    "print(myList) # 改变原列表\n",
    "\n",
    "# l.insert(index,object)\n",
    "myList.insert(2,100)\n",
    "print(myList)  # 改变原列表\n",
    "\n",
    "# l.extend(iterable)\n",
    "myList.extend(['a','b','c']) # 迭代对象中分解开 再追加（与append不同）\n",
    "print(myList)\n",
    "\n",
    "'''\n",
    "加乘不改变原列表\n",
    "列表与列表才能相加\n",
    "'''\n",
    "# 乘法\n",
    "print(myList*2)\n",
    "print(myList+['wx','op'])\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 删"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4] \n",
      "\n",
      "[1, 2, 3, 4]\n",
      "2 \t [1, 3, 4] \n",
      "\n",
      "[1, 2, 3, 4, 2]\n",
      "None \t [1, 3, 4, 2]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "删\n",
    "#修改原列表\n",
    "'''\n",
    "# del 语句\n",
    "myList1 = [1,2,3,4]\n",
    "del myList1[1]\n",
    "print(myList1,'\\n')\n",
    "\n",
    "    # a = 999\n",
    "    # del a\n",
    "    # print(a) 会报错，相当于没有定义变量a\n",
    "    \n",
    "# l.pop(index=-1) 移除并返回返回删除的\n",
    "myList1.insert(1,2)\n",
    "print(myList1)\n",
    "num = myList1.pop(1)\n",
    "print(num,'\\t',myList1,'\\n')\n",
    "\n",
    "# l.remove(object) 移除左边起第一个出现的\n",
    "myList1.insert(1,2)\n",
    "myList1.insert(4,2)\n",
    "print(myList1)\n",
    "num1 = myList1.remove(2)\n",
    "print(num1,'\\t',myList1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "删除操作留下的坑\n",
    "'''\n",
    "numlist = [1,2,2,2,3,4,2,5,2,1]\n",
    "for i  in numlist:\n",
    "    if i == 2:\n",
    "        numlist.remove(2)\n",
    "print(numlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'a', 4]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "改\n",
    "'''\n",
    "nums = [1,2,3,4]\n",
    "nums[nums.index(3)] = 'a' #索引值越界则报错\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 查"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 10) 6\n",
      "5\n",
      "1\n",
      "[3, 5, 7] \n",
      "\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "查\n",
    "'''\n",
    "# 获取单个元素 list[index]\n",
    "nums = range(1,10) # 使用时生成列表[1,2,3,4,5,6,7,8,9]\n",
    "print(nums,nums[5])\n",
    "\n",
    "# 获取索引 l.index(value,start=None,stop=None)\n",
    "nums = [1,2,3,4,5,6,7,8,9]\n",
    "idx = nums.index(6) # 查到的是第一个\n",
    "print(idx)\n",
    "\n",
    "# 获取指定元素个数\n",
    "count = nums.count(6)\n",
    "print(count)\n",
    "\n",
    "# 获取多个元素 list[start:end:step]\n",
    "pic = nums[2:8:2] #不包含index=end的那个元素\n",
    "print(pic,'\\n')\n",
    "\n",
    "pic1 = nums[::-1]\n",
    "print(nums,pic1,sep='\\n') # 切片反转\n",
    "\n",
    "pic1.reverse() #改变原列表\n",
    "print(pic1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 遍历"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'a', 1, 2, 3, 4] \n",
      "\n",
      "1.根据元素遍历:\n",
      "a:0\tb:1\tc:2\ta:3\t1:4\t2:5\t3:6\t4:7\t \n",
      "\n",
      "2.根据索引遍历:\n",
      "a:0\tb:1\tc:2\ta:3\t1:4\t2:5\t3:6\t4:7\t\n",
      "\n",
      "3.根据枚举遍历:\n",
      "<enumerate object at 0x10f61fd70>\t<class 'enumerate'>\n",
      "[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'a'), (4, 1), (5, 2), (6, 3), (7, 4)]\n",
      "a:2\tb:3\tc:4\ta:5\t1:6\t2:7\t3:8\t4:9\t\n",
      "\n",
      "4.使用迭代器遍历:\n",
      "True\n",
      "False\n",
      "迭代对象不一定是迭代器\n",
      "<list_iterator object at 0x10e916210>\n",
      "a\n",
      "b\n",
      "for in :\n",
      "c\ta\t1\t2\t3\t4\t"
     ]
    }
   ],
   "source": [
    "'''\n",
    "遍历\n",
    "'''\n",
    "\n",
    "values = ['a','b','c','a',1,2,3,4]\n",
    "print(values,'\\n')\n",
    "\n",
    "# 1.根据元素遍历\n",
    "print('1.根据元素遍历:')\n",
    "currentIdx = 0\n",
    "for item in values:\n",
    "    #print(item,values.index(item,currentIdx),sep=':',end='\\t')\n",
    "    print('{}:{}'.format(item,values.index(item,currentIdx)),end='\\t')\n",
    "    currentIdx +=1\n",
    "print('','\\n')\n",
    "    # print(values.index(item)) × 列表里有重复元素，但求index是左边第一个出现的\n",
    "    \n",
    "\n",
    "# 2.根据索引遍历\n",
    "print('2.根据索引遍历:')\n",
    "for idx in range(len(values)):\n",
    "    print(values[idx],idx,sep=':',end='\\t')\n",
    "    \n",
    "# 3.根据枚举对象遍历（创建对应枚举对象，遍历）\n",
    "'''\n",
    "enumerate(sequence[,start]) #列表里面是元组，有索引和值\n",
    "'''\n",
    "print('\\n')\n",
    "print('3.根据枚举遍历:')\n",
    "meiju=enumerate(values)\n",
    "print(meiju,type(meiju),sep='\\t')\n",
    "print(list(meiju))\n",
    "\n",
    "#枚举对象可以直接被遍历\n",
    "for idx,val in enumerate(values,2):\n",
    "    print(val,idx,sep=':',end='\\t')\n",
    "    \n",
    "# 4.使用迭代器遍历\n",
    "'''\n",
    "迭代：按照某种顺序访问集合中每一个\n",
    "可迭代对象：能被迭代的对象，判定依据：能用于 for in\n",
    "                        判定方法： import collections \n",
    "                                 isinstance(obj,collections.Iterable)\n",
    "                                 \n",
    "迭代器：可以记录遍历位置的对象，可迭代\n",
    "       从第一个元素开始，只能往后 通过next()函数进行遍历\n",
    "       判定依据：能作用于 next()\n",
    "       判定方法： import collections \n",
    "                isinstance(obj,collections.Iterator)\n",
    "       生成迭代器: iter(function,sentinel)\n",
    "       \n",
    "       仅在迭代到某元素时处理该元素，在此之前元素可以不存在，在之后元素可销毁\n",
    "       适应于遍历一些巨大或无限的集合，如斐波那切数列\n",
    "       \n",
    "       提供了统一访问集合的接口，可把所有可迭代对象转化成迭代器使用\n",
    "       一般不能多次迭代\n",
    "                                 \n",
    "'''\n",
    "print('\\n')\n",
    "print('4.使用迭代器遍历:')\n",
    "import collections\n",
    "print(isinstance(values,collections.Iterable))\n",
    "print(isinstance(values,collections.Iterator))\n",
    "print('迭代对象不一定是迭代器')\n",
    "\n",
    "print(iter(values)) #iter(str/list/dict/tuple)\n",
    "\n",
    "# 首先有一个迭代器对象，使用next()函数从迭代器取出下一个对象，从第一个元素开始\n",
    "#1.创建迭代器\n",
    "it = iter(values)\n",
    "# next()\n",
    "print(next(it))# 自动记下当前遍历位置，下一次从这里开始往后\n",
    "print(next(it)) # 如果取完再接着取，报错StopIteration\n",
    "\n",
    "# for in 会自动调用next()并处理完毕错误\n",
    "print('for in :')\n",
    "for v in it:\n",
    "    print(v,end='\\t') # 如果再来一次不会报错，自动处理\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 额外操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'a', 'a', 'we', 'tt', [99, 8]] \n",
      "\n",
      "判定 in/not in:\n",
      "False \n",
      "\n",
      "比较，针对每个元素从左到右逐一比较\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "判定及比较\n",
    "'''\n",
    "ll = [1,2,3,'a','a','we','tt',[99,8]]\n",
    "print(ll,'\\n')\n",
    "print('判定 in/not in:')\n",
    "print('t' in ll,'\\n')\n",
    "\n",
    "print('比较，针对每个元素从左到右逐一比较')\n",
    "print([1,2,3,'a']<=ll)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> ['k', 'j', 'h', 'e', 'b', 'a']\n",
      "[('a', 2), ('b', 0), ('d', 9)]\n",
      "[('d', 9), ('a', 2), ('b', 0)]\n",
      "*************************\n",
      "\n",
      "None\n",
      "[('d', 9), ('a', 2), ('b', 0)]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "排序\n",
    "'''\n",
    "# 1.内建函数，可以对所有可迭代对象排序\n",
    "# sorted(iterable,key=None,reverse=False) (对象/排序关键词,值为一个函数，此函数\n",
    "#                                          只有一个参数且返回一个值 )\n",
    "# 返回值 list\n",
    "st = 'ahjkeb'\n",
    "result_s=sorted(st,reverse = True)\n",
    "print(type(result_s),result_s)\n",
    "\n",
    "tup = [('a',2),('d',9),('b',0)]\n",
    "print(sorted(tup)) # 默认按照元组第一个元素排序\n",
    "\n",
    "#要用key，依据第二个元素排序\n",
    "def getKey(x):\n",
    "    return x[1]\n",
    "print(sorted(tup,key=getKey,reverse=True))\n",
    "\n",
    "print('*************************\\n')\n",
    "\n",
    "# 2.列表对象法\n",
    "# list.sort(key=None,reverse=False) 无返回值，只能操作列表\n",
    "'''\n",
    "改变原列表\n",
    "'''\n",
    "print(tup.sort(key=getKey,reverse=True))\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "乱序：\n",
      "None\n",
      "[1, 4, 5, 'b', 2, 'a']\n",
      "\n",
      "反转1：\n",
      "None\n",
      "['a', 2, 'b', 5, 4, 1]\n",
      "\n",
      "反转2：切片\n",
      "[1, 4, 5, 'b', 2, 'a']\n",
      "['a', 2, 'b', 5, 4, 1]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "乱序和反转\n",
    "'''\n",
    "print('乱序：')\n",
    "la = [1,2,'a','b',4,5]\n",
    "import random\n",
    "res = random.shuffle(la) # 随机顺序,改变la\n",
    "print(res,la,sep='\\n')\n",
    "\n",
    "print('\\n反转1：')\n",
    "res_r = la.reverse() # la本身变化\n",
    "print(res_r,la,sep='\\n')\n",
    "\n",
    "print('\\n反转2：切片') # 不改变la\n",
    "print(la[::-1],la,sep='\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "### 概念定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\t<class 'int'>\n",
      "正确的一个元素写法：\n",
      "(1,)\t<class 'tuple'>\n",
      "\n",
      "(1, 1, 2, [3, 4], 'b')\t<class 'tuple'>\n",
      "\n",
      "(1, 2, 's', 'a', 3, [2, 'e'])\t<class 'tuple'>\n",
      "\n",
      "(1, 'a', ('w',))\t<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "有序 不可变元素集合（列表可变）\n",
    "'''\n",
    "# 一个元素写法\n",
    "tup1 = (1) #()代表元组\n",
    "print(tup1,type(tup1),sep='\\t') #类型变为int\n",
    "print('正确的一个元素写法：')\n",
    "tup1 = (1,)\n",
    "print(tup1,type(tup1),sep='\\t')\n",
    "print('')\n",
    "\n",
    "# 多个元素\n",
    "tup2 = (1,2,'a')\n",
    "tup3 = 1,1,2,[3,4],'b' # 多个元素逗号隔开默认是元组\n",
    "print(tup3,type(tup3),sep='\\t')\n",
    "print('')\n",
    "\n",
    "# 列表转换成元组\n",
    "lt = [1,2,'s','a',3,[2,'e']]\n",
    "change = tuple(lt)\n",
    "print(change,type(change),sep='\\t')\n",
    "print('')\n",
    "\n",
    "# 元组嵌套\n",
    "tup4 = (1,'a',('w',))\n",
    "print(tup4,type(tup4),sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常用操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 查询"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n",
      "('b', 'a', 8)\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "由于不可变，所以！！！增删改 都不可以！！！\n",
    "'''\n",
    "t = (1,3,8,'a','b','c')\n",
    "print(t[0:2],t[4:1:-1],sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 获取判定比较"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'a')\n",
      "0\n",
      "3\n",
      "\n",
      "4\n",
      "4 1\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "获取：\n",
    "1. 内建函数 ()\n",
    "   len(tup) max(tup) min(tup)\n",
    "2.对象方法 ()\n",
    "tuple.count(item) tuple.index(item)\n",
    "'''\n",
    "tp = (1,2,3,'a')\n",
    "print(tp)\n",
    "print(tp.count(0)) # 如果不在，返回0\n",
    "print(tp.index('a')) # 如果不在，会报错\n",
    "print('')\n",
    "\n",
    "print(len(tp)) \n",
    "print(max((1,2,3,4,)),min((1,2,3,4))) #元素种类不同会报错\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True \n",
      "\n",
      "True\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'>=' not supported between instances of 'list' and 'tuple'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-296-5fac6fd5e6fc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0mtp\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#逐一比较\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0mtp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '>=' not supported between instances of 'list' and 'tuple'"
     ]
    }
   ],
   "source": [
    "'''\n",
    "判定比较\n",
    "'''\n",
    "print(1 in tp,'\\n')\n",
    "\n",
    "print((1,3,3,'a')>=tp) #左到右逐一比较\n",
    "\n",
    "print([1,3,3,'a']>=tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 拼接和拆包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 1, 2, 1, 2) \n",
      "\n",
      "1 3\n",
      "1 99\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "拼接\n",
    "（元素1,元素2,元素3）*int -> （元素1,元素2,元素3，元素1,元素2,元素3,...)\n",
    " (元素1,元素2,元素3)+(元1,元2) -> (元素1,元素2,元素3,元1,元2) \n",
    "'''\n",
    "print((1,2)*3,'\\n')\n",
    "\n",
    "'''\n",
    "拆包\n",
    "a,b = (1,2)\n",
    "'''\n",
    "a,b=(1,3)\n",
    "print(a,b)\n",
    "\n",
    "# 交换变量值\n",
    "t1 = 99\n",
    "t2 = 1\n",
    "t2,t1 =(t1,t2)\n",
    "print(t1,t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 概念定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "定义1：\n",
      "{'name': 'wxy', 'age': 24}\t<class 'dict'>\n",
      "wxy\n",
      "\n",
      " 定义2  类调用：\n",
      "{2: None, 'w': None, 9: None}\n",
      "{'a': 23, 'b': 23, 'c': 23}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\n  对象调用 无意义\\n  {1:2,3:4}.fromkeys('abc',678)\\n\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "无序 可变 键值对集合\n",
    "'''\n",
    "# 定义1 \n",
    "print('定义1：')\n",
    "info1 = {'name':'wxy','age':24}\n",
    "print(info1,type(info1),sep='\\t')\n",
    "\n",
    "print(info1['name'])\n",
    "  # print(info1[0]) # 中括号里是键值 KeyError:0❌\n",
    "\n",
    "# 定义2 借助静态方法（类和对象都可以调用）\n",
    "'''\n",
    "  类调用: dict.fromkeys(seq,value) dict指字典类型\n",
    "'''\n",
    "print('\\n','定义2  类调用：')\n",
    "d = dict.fromkeys([2,'w',9])\n",
    "print(d)\n",
    "d = dict.fromkeys('abc',23)\n",
    "print(d)\n",
    "\n",
    "# 定义3\n",
    "names = ['wxy','www']\n",
    "ages = [25,12]\n",
    "dict(zip(names,ages))\n",
    "'''\n",
    "  对象调用 无意义\n",
    "  {1:2,3:4}.fromkeys('abc',678)\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'c', 2: 'b'} \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\nd2 = {[1,2,3]:'123'}\\nprint(d2) \\n\\nTypeError: unhashable type: 'list'\\n\""
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "note: \n",
    "1、key不能重复\n",
    "2、key必须是任意不可变类型\n",
    "'''\n",
    "\n",
    "d1 = {1:'a',2:'b',1:'c'} # key相同，则后值会覆盖前面的\n",
    "print(d1,'\\n')\n",
    "\n",
    "'''\n",
    "d2 = {[1,2,3]:'123'}\n",
    "print(d2) \n",
    "\n",
    "TypeError: unhashable type: 'list'\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4472804784 4472805104\n",
      "4512949424\t4512949424\n"
     ]
    }
   ],
   "source": [
    "# 判断是否可变\n",
    "num1 = 10\n",
    "num2 = 20\n",
    "print(id(num1),id(num2)) # 值不同，id不同--->不可变\n",
    "\n",
    "list1 = [1,2,3]\n",
    "print(id(list1),end='\\t')\n",
    "list1.append(4)\n",
    "print(id(list1)) # 在原地址改变\n",
    "\n",
    "'''\n",
    "可变：列表、字典、可变集合...\n",
    "不可变：数值、布尔、字符串、元组...\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常用操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 增"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'wxy', 'age': 24, 'hobby': 'eat'}\n"
     ]
    }
   ],
   "source": [
    "# dic[key] = value\n",
    "dd = {'name':'wxy','age':24}\n",
    "dd['hobby'] = 'eat'\n",
    "print(dd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 删"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'wxy', 'age': 24, 'hobby': 'eat'}\n",
      "{'name': 'wxy', 'age': 24} \n",
      "\n",
      "{'name': 'wxy'} 24\n",
      "888 {'name': 'wxy'} \n",
      "\n",
      "{'name': 'wxy', 'age': 24}\t('hobby', 'eat')\t\n",
      "\n",
      "{}\tNone\n"
     ]
    }
   ],
   "source": [
    "# del 语句 del[key] key必须要存在\n",
    "dd = {'name': 'wxy', 'age': 24, 'hobby': 'eat'}\n",
    "print(dd)\n",
    "del dd['hobby'] # 如果不存在则KeyError\n",
    "print(dd,'\\n')\n",
    "\n",
    "# dic.pop(key[,default]) 删除并返回key的值\n",
    "v = dd.pop('age')\n",
    "print(dd,v)\n",
    "\n",
    "print(dd.pop('age',888),dd,'\\n') #如果key不存在，不写default则报错，写了返回default 原dic不变\n",
    "\n",
    "# dic.popitem() 删除按升序排序后的第一个键值对，并以元组形式返回键值对\n",
    "dd2 = {'name': 'wxy', 'age': 24, 'hobby': 'eat'}\n",
    "v2 = dd2.popitem()\n",
    "print(dd2,v2,'\\n',sep='\\t')\n",
    "\n",
    "# dic.clear() 删除所有键值对\n",
    "dd3 = {'name': 'wxy', 'age': 24, 'hobby': 'eat'}\n",
    "v3 = dd3.clear()\n",
    "print(dd3,v3,sep='\\t') # 字典本身存在，清除内容\n",
    "'''\n",
    "del dd3\n",
    "print(dd3) # 会报错，直接删除本身\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'wxy', 'age': 24}\n",
      "{'name': 'wxy', 'age': 18, 'address': 'Wuxi'}\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "改值 不能改key\n",
    "dic[key] = value key不存在则新增\n",
    "'''\n",
    "ddd = {'name':'wxy','age':26}\n",
    "ddd['age']=24\n",
    "print(ddd)\n",
    "\n",
    "'''\n",
    "批量修改键值对\n",
    "oldDic.update(newDic) 如有则改，无则增\n",
    "'''\n",
    "ddd.update({'age':18,'address':'Wuxi'})\n",
    "print(ddd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 查"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wuxi\n",
      "9\n",
      "None {'name': 'wxy', 'age': 18, 'address': 'Wuxi', 'age1': None}\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "单个值 dic[key] key不存在则报错\n",
    "'''\n",
    "d2d = {'name': 'wxy', 'age': 18, 'address': 'Wuxi'}\n",
    "print(d2d['address'])\n",
    "# print(d2d[2]) 按索引则会当成key，报错❌\n",
    "\n",
    "'''\n",
    "dic.get(key[,default]) \n",
    "如果key不存在，则取返回的default/None，不会报错，原字典不会新增\n",
    "'''\n",
    "v2v = d2d.get('t',9)\n",
    "print(v2v)\n",
    "\n",
    "'''\n",
    "d2d.setdefault(key[,default]) 与上面不同的是 会新增\n",
    "'''\n",
    "v2v2 = d2d.setdefault('age1')\n",
    "print(v2v2,d2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'wxy', 'age': 18, 'address': 'Wuxi'} \n",
      "\n",
      "dict_values(['wxy', 18, 'Wuxi'])\n",
      "dict_keys(['name', 'age', 'address'])\n",
      "dict_items([('name', 'wxy'), ('age', 18), ('address', 'Wuxi')])\n",
      "<class 'dict_keys'>\n",
      "\n",
      "dict_values(['wxy', 18, 'Wuxi', 'female'])\n",
      "dict_keys(['name', 'age', 'address', 'gender'])\n",
      "dict_items([('name', 'wxy'), ('age', 18), ('address', 'Wuxi'), ('gender', 'female')])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\nvs = ds.values()\\nprint(vs[1]) ❌\\nTypeError: 'dict_values' object is not subscriptable\\n\\n可以先list(vs) tuple(vs)\\n\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "所有值、键。键值对\n",
    "dic.values() \n",
    "dic.keys()\n",
    "dic.items() 每一组形成元组\n",
    "字典改变，上述都会改变 是view objects\n",
    "'''\n",
    "ds = {'name': 'wxy', 'age': 18, 'address': 'Wuxi'}\n",
    "print(ds,'\\n')\n",
    "print(ds.values(),ds.keys(),ds.items(),sep='\\n')\n",
    "print(type(ds.keys()))\n",
    "ds['gender'] = 'female'\n",
    "print('')\n",
    "print(ds.values(),ds.keys(),ds.items(),sep='\\n')\n",
    "'''\n",
    "vs = ds.values()\n",
    "print(vs[1]) ❌\n",
    "TypeError: 'dict_values' object is not subscriptable\n",
    "\n",
    "可以先list(vs) tuple(vs)\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 遍历"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name-wxy\tage-18\taddress-Wuxi\t\n",
      "name->wxy\tage->18\taddress->Wuxi\tgender->female\t"
     ]
    }
   ],
   "source": [
    "'''\n",
    "遍历\n",
    "for in\n",
    "for x,y in info.items()\n",
    "'''\n",
    "# 先遍历所有的key 再根据key获得对应值\n",
    "db = {'name': 'wxy', 'age': 18, 'address': 'Wuxi'}\n",
    "  # 先获取所有key\n",
    "keys = db.keys()\n",
    "  # 遍历所有的key\n",
    "for key in keys:\n",
    "    print(key,db[key],sep='-',end = '\\t')\n",
    "    \n",
    "# 直接遍历所有键值对\n",
    "print('')\n",
    "kvs = db.items()\n",
    " # 因为是view object，所有kvs先获取，再改字典，kvs会跟着变\n",
    "db['gender'] = 'female' \n",
    "for k,v in kvs:\n",
    "    print('{}->{}'.format(k,v),end='\\t')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 计算判定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 \n",
      "\n",
      "False\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'dict' object has no attribute 'has_key'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-8f3106d2321f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m '''\n\u001b[1;32m     12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wxy'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhas_key\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'gender'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'dict' object has no attribute 'has_key'"
     ]
    }
   ],
   "source": [
    "'''\n",
    "计算键值对个数\n",
    "len(info)\n",
    "'''\n",
    "print(len(db),'\\n')\n",
    "\n",
    "'''\n",
    "判定\n",
    "判定的是key\n",
    "in，not in\n",
    "'''\n",
    "print('wxy' in db)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 概念定义"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "可变集合:\n",
      "{1, 2, 3} <class 'set'> \n",
      "\n",
      "{'age', 'name'} <class 'set'> \n",
      "\n",
      "不可变集合:\n",
      "frozenset({'a', 'c', 'b'}) <class 'frozenset'> \n",
      "\n",
      "frozenset({2, 4, 6, 8, 10, 12, 14, 16, 18}) <class 'frozenset'> \n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "无序的，不可随机访问， 不可重复 的元素集合\n",
    "分可变集合(set) 和 非可变集合(frozenset,不可增删减等)\n",
    "'''\n",
    "\n",
    "# 可变集合\n",
    "# s = {1,2,3}\n",
    "# 集合内元素要不可变，否则报错\n",
    "print('可变集合:')\n",
    "\n",
    "s = {1,2,3,3} # 不可重复\n",
    "print(s,type(s),'\\n')\n",
    "'''\n",
    "# s2 = {1,2,'a',{1:2,3:4}} \n",
    "# print(s2)\n",
    "# #TypeError: unhashable type: 'list'\n",
    "# TypeError: unhashable type: 'dict'\n",
    "'''\n",
    "\n",
    "s = {i for i in range(1,20) if i%2==0}\n",
    "s = set(i for i in range(1,20) if i%2==0)\n",
    "\n",
    "# 转变其他类型 set(iterable)\n",
    "# 空集合一定要用set，用第一种会识别为字典\n",
    "ss = set({'name':'wxy','age':24}) # 如果是字典，则集合里是key\n",
    "print(ss,type(ss),'\\n')\n",
    "\n",
    "# 不可变集合（仅少第一种）\n",
    "print('不可变集合:')\n",
    "fs = frozenset('abc')\n",
    "print(fs,type(fs),'\\n')\n",
    "fss = frozenset(i for i in range(1,20) if i%2==0)\n",
    "print(fss,type(fss),'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "应用：去重\n",
    "'''\n",
    "sel = [1,2,2,3,4,4,6,9]\n",
    "se = set(sel)\n",
    "se1 = list(se)\n",
    "print(se1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常用操作"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "单一集合操作\n",
    "1.可变集合：增删改查\n",
    "2.不可变集合操作：查\n",
    "  （1）通过 for in遍历\n",
    "  （2）通过迭代器访问\n",
    "  \n",
    "集合之间的操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 新增"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-9e1b74a9bf76>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m '''\n\u001b[1;32m      4\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "'''\n",
    "单一集合操作\n",
    "'''\n",
    "s = {1,2,3}\n",
    "s.add([1,2])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 删"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5, 6, 7} None \n",
      "\n",
      "{1, 3, 4, 5, 6, 7} None \n",
      "\n",
      "{3, 4, 5, 6, 7} 1 \n",
      "\n",
      "set() None \n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "单一集合操作\n",
    "'''\n",
    "s = {1,2,3,4,5,6,7,}\n",
    "res = s.remove(2) # 不存在则报错\n",
    "print(s,res,'\\n')\n",
    "\n",
    "res1 = s.discard(2) # 不存在则什么都不做\n",
    "print(s,res1,'\\n')\n",
    "\n",
    "res2 = s.pop() # 随机删除一个，集合为空则报错keyError\n",
    "print(s,res2,'\\n')\n",
    "\n",
    "res3 = s.clear() # 清空，集合存在\n",
    "print(s,res3,'\\n')\n",
    "\n",
    "# 删除集合可以用del\n",
    "#del s\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 查询遍历"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "hidden": true
   },
   "source": [
    "因为无序，所以不可通过索引或key查询\n",
    "1.for in遍历\n",
    "2.迭代器访问"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  4  5  6  7  \n",
      "1 2\n",
      "3  4  5  6  7  "
     ]
    }
   ],
   "source": [
    "s = {1,2,3,4,5,6,7,}\n",
    "for i in s:\n",
    "    print(i,end = '  ')\n",
    "    \n",
    "print('')\n",
    "\n",
    "# 1.生成迭代器\n",
    "its = iter(s)\n",
    "# 2.使用next或for in\n",
    "print(next(its),end=' ')\n",
    "print(next(its))\n",
    "\n",
    "for v in its:\n",
    "    print(v,end='  ')\n",
    "    \n",
    "# s = frozenset(1,2,3,4,5,6,7)\n",
    "# for i in s:\n",
    "#     print(i,end = '  ')\n",
    "    \n",
    "# print('')\n",
    "\n",
    "# # 1.生成迭代器\n",
    "# its = iter(s)\n",
    "# # 2.使用next或for in\n",
    "# print(next(its),end=' ')\n",
    "# print(next(its))\n",
    "\n",
    "# for v in its:\n",
    "#     print(v,end='  ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 交集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4} <class 'set'> \n",
      "\n",
      "frozenset({2, 4}) <class 'frozenset'> \n",
      "\n",
      "None <class 'NoneType'> {2, 4} \n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "集合间操作\n",
    "intersection(Iterable)\n",
    "逻辑与&\n",
    "intersection_update()\n",
    "'''\n",
    "s1 = {1,2,3,4,5}\n",
    "#s2 = {4,2,7,6,8}\n",
    "s2 = frozenset([4,2,7,6,8])\n",
    "\n",
    "\n",
    "res = s1.intersection(s2) # 返回类型是s1的，前面那个\n",
    "print(res,type(res),'\\n')# 集合本身不变\n",
    "\n",
    "res2 = s2 & s1 # 返回类型是s2的，前面那个\n",
    "print(res2,type(res2),'\\n') # 集合本身不变\n",
    "\n",
    "'''\n",
    "res2 = s2.intersection_update(s1) # 返回类型是s1的，前面那个\n",
    "print(res2,type(res2),s2,'\\n') ❌\n",
    "AttributeError: 'frozenset' object has no attribute 'intersection_update'\n",
    "'''\n",
    "res2 = s1.intersection_update(s2) # 无返回值，将前一个集合改成 重合的交集\n",
    "print(res2,type(res2),s1,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'1', '3', '2'}\n",
      "{4, 5}\n",
      "{4, 5}\n",
      "{'3'}\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "和其他可遍历类型\n",
    "'''\n",
    "ss = {'1','2','3',4,5}\n",
    "print(ss.intersection('123'))\n",
    "print(ss.intersection([4,5]))\n",
    "# print(ss.intersection((4,5,['1']))) ❌ \n",
    "print(ss.intersection((4,5)))\n",
    "print(ss.intersection({1:4,'3':5})) # key的交集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 并集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8} <class 'set'> \n",
      "\n",
      "frozenset({1, 2, 3, 4, 5, 6, 7, 8}) <class 'frozenset'> \n",
      "\n",
      "None <class 'NoneType'> {1, 2, 3, 4, 5, 6, 7, 8} \n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "集合间操作\n",
    "union(Iterable)\n",
    "逻辑或|\n",
    "update()\n",
    "'''\n",
    "s1 = {1,2,3,4,5}\n",
    "#s2 = {4,2,7,6,8}\n",
    "s2 = frozenset([4,2,7,6,8])\n",
    "\n",
    "\n",
    "res = s1.union(s2) # 返回类型是s1的，前面那个\n",
    "print(res,type(res),'\\n')# 集合本身不变\n",
    "\n",
    "res2 = s2 | s1 # 返回类型是s2的，前面那个\n",
    "print(res2,type(res2),'\\n') # 集合本身不变\n",
    "\n",
    "res3 = s1.update(s2) # 无返回值，将前一个集合改成 重合的并集\n",
    "print(res3,type(res3),s1,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 差集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 5} <class 'set'> \n",
      "\n",
      "frozenset({8, 6, 7}) <class 'frozenset'> \n",
      "\n",
      "None <class 'NoneType'> {1, 3, 5} \n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "集合间操作 属于a且不属于b\n",
    "difference()\n",
    "算数运算符-\n",
    "difference_update()\n",
    "'''\n",
    "s1 = {1,2,3,4,5}\n",
    "#s2 = {4,2,7,6,8}\n",
    "s2 = frozenset([4,2,7,6,8])\n",
    "\n",
    "\n",
    "res = s1.difference(s2) # 返回类型是s1的，前面那个\n",
    "print(res,type(res),'\\n')# 集合本身不变\n",
    "\n",
    "res2 = s2 - s1 # 返回类型是s2的，前面那个\n",
    "print(res2,type(res2),'\\n') # 集合本身不变\n",
    "\n",
    "res3 = s1.difference_update(s2) # 无返回值，将前一个集合改成 差集\n",
    "print(res3,type(res3),s1,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "#### 判定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False <class 'bool'> \n",
      "\n",
      "False <class 'bool'> \n",
      "\n",
      "True <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "集合间操作\n",
    "isdisjoint() 两个不相交\n",
    "issuperset() 是否(完全)包含另一个\n",
    "issubset()   是否(完全)包含于\n",
    "'''\n",
    "s1 = {1,2,3,4,5}\n",
    "s2 = {4,5,}\n",
    "#s2 = frozenset([4,2,7,6,8])\n",
    "\n",
    "\n",
    "res = s1.isdisjoint(s2) # 返回类型是s1的，前面那个\n",
    "print(res,type(res),'\\n')# 集合本身不变\n",
    "\n",
    "res2 = s2.issuperset(s1) # 返回类型是s2的，前面那个\n",
    "print(res2,type(res2),'\\n') # 集合本身不变\n",
    "\n",
    "res3 = s2.issubset(s1) \n",
    "print(res3,type(res3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 时间日历"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### time模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "提供处理时间和表示之间转换的功能\n",
    "获取当前时间戳\n",
    "获取时间元组\n",
    "获取格式化的时间\n",
    "格式化日期字符串<-->时间戳\n",
    "获取当前cpu时间\n",
    "休眠n秒\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1585060515.398572\n",
      "2020.2619392249674\n"
     ]
    }
   ],
   "source": [
    "# 时间戳：从0时区的1970年1月1日0时0分0秒，到所给定的日期时间的秒数\n",
    "# 时间戳 float （如果是北京时间，则是1970年1月1日8时0分0秒）\n",
    "# 获取方式：1.import time\n",
    "#        2.time.time()\n",
    "import time\n",
    "res = time.time()\n",
    "print(res)\n",
    "years = res/(24*60*60*365) + 1970 # 验证一下\n",
    "print(years)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time.struct_time(tm_year=2014, tm_mon=5, tm_mday=14, tm_hour=0, tm_min=53, tm_sec=20, tm_wday=2, tm_yday=134, tm_isdst=0)\n"
     ]
    }
   ],
   "source": [
    "# 时间元组\n",
    "# 1. import time\n",
    "# 2. time.localtime([seconds]) 不填默认当前时间戳\n",
    "import time\n",
    "res =  time.localtime(1400000000.398572)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Mar 24 22:46:09 2020\n",
      "*****\n",
      "Tue Mar 24 22:46:09 2020\n"
     ]
    }
   ],
   "source": [
    "# 格式化的时间\n",
    "# 可以对时间戳、时间元组格式化\n",
    "# 秒-->可读时间\n",
    "#   time.ctime([seconds])\n",
    "# 时间元组-->可读时间\n",
    "#   time.asctime([p_tuple])\n",
    "import time\n",
    "now = time.time()\n",
    "res = time.ctime(now)\n",
    "print(res)\n",
    "print('*****')\n",
    "nowt = time.localtime()\n",
    "rest = time.asctime(nowt)\n",
    "print(rest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20-03-24 22:58:38 \n",
      "\n",
      "time.struct_time(tm_year=2020, tm_mon=3, tm_mday=24, tm_hour=10, tm_min=51, tm_sec=50, tm_wday=1, tm_yday=84, tm_isdst=-1)\n",
      "1585018310.0\n"
     ]
    }
   ],
   "source": [
    "# 自定义格式化时间\n",
    "# 时间元组-->格式化日期 time.strftime(格式字符串，时间元组)\n",
    "# 格式化日期-->时间元组 time.strptime(日期字符串，格式符字符串)\n",
    "# 时间元组-->时间戳    time.mktime(时间元组) \n",
    "# 常用格式符\n",
    "# %H 24h制小时数，%I 12h制小时数，\n",
    "ref=time.strftime('%y-%m-%d %H:%M:%S',time.localtime())\n",
    "print(ref,'\\n')\n",
    "\n",
    "pt = time.strptime('20-03-24 10:51:50','%y-%m-%d %H:%M:%S')\n",
    "print(pt)\n",
    "rep = time.mktime(pt)\n",
    "print(rep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 \n",
      "0.0008559999999999679\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead\n",
      "  after removing the cwd from sys.path.\n",
      "/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:8: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "# 获取当前cpu时间\n",
    "# time.clock(浮点秒数)\n",
    "# 可用于统计程序时间\n",
    "start = time.clock()\n",
    "for i in range(0,10):\n",
    "    print(i,end = ' ')\n",
    "print('')\n",
    "end = time.clock()\n",
    "print(end-start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 休眠n秒\n",
    "# 推迟线程的执行\n",
    "while True:\n",
    "    ref=time.strftime('%y-%m-%d %H:%M:%S',time.localtime())\n",
    "    print(ref,'\\n')\n",
    "    time.sleep(1) #每隔1s打印一次\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### calendar模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     March 2020\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                   1\n",
      " 2  3  4  5  6  7  8\n",
      " 9 10 11 12 13 14 15\n",
      "16 17 18 19 20 21 22\n",
      "23 24 25 26 27 28 29\n",
      "30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "提供与日历相关功能，比如为给定年份或月份打印文本日历功能\n",
    "获取某月日历\n",
    "'''\n",
    "import calendar\n",
    "print(calendar.month(2020,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### datetime模块"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```Python\n",
    "计算，模块里有datetime类 date类 time类\n",
    "\n",
    "获取当天日期\n",
    "单独获取当前的年月日分秒\n",
    "计算两个日期的天数差\n",
    "获取两个日期时间的时间差\n",
    "计算n天之后的日期\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-03-24 23:11:27.252728\n",
      "2020-03-24 23:11:27.252973\n",
      "<class 'datetime.datetime'>\n",
      "2020\n",
      "3\n",
      "24\n",
      "23\n",
      "11\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "print(datetime.datetime.now()) # 模块.类.功能（）\n",
    "print(datetime.datetime.today())\n",
    "t = datetime.datetime.now() # 对象\n",
    "print(type(t))\n",
    "print(t.year)\n",
    "print(t.month)\n",
    "print(t.day)\n",
    "print(t.hour)\n",
    "print(t.minute)\n",
    "print(t.second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-03-24 23:14:42.303650\n",
      "2020-03-27 23:14:42.303650\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "t = datetime.datetime.today()\n",
    "res = t + datetime.timedelta(days = 3) # 计算n天之后\n",
    "print(t,res,sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2017-09-02 12:00:00 <class 'datetime.datetime'>\n",
      "1 day, 0:00:00 <class 'datetime.timedelta'>\n",
      "86400.0\n"
     ]
    }
   ],
   "source": [
    "first = datetime.datetime(2017,9,2,12,0,0)\n",
    "print(first,type(first))\n",
    "second = datetime.datetime(2017,9,3,12,0,0)\n",
    "delta = second -first\n",
    "print(delta,type(delta))\n",
    "print(delta.total_seconds())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input a number:38\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-89e2836ee183>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumLen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m                \u001b[0mnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mipnum\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m         \u001b[0mcount\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0mipnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-1-89e2836ee183>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumLen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m                \u001b[0mnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mipnum\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m         \u001b[0mcount\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0mipnum\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "ipnum = list(input('Please input a number:'))\n",
    "numLen = len(ipnum)\n",
    "count = 0\n",
    "while True:\n",
    "        num = 1\n",
    "        for i in range(numLen):\n",
    "               num = str((lambda x:x*int(ipnum[i]))(num))\n",
    "        count += 1\n",
    "        ipnum = list(num)\n",
    "        numLen = len(ipnum)\n",
    "        if numLen == 1:\n",
    "                break\n",
    "print(count)"
   ]
  },
  {
   "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "169px",
    "width": "202px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "206.797px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}