{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 常用内置函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python有很多内置函数可以非常方便的解决一些问题，本节给出其中三个在列表中使用较多的内置函数:  \n",
    "```python\n",
    "map()  \n",
    "zip()  \n",
    "enumerate()  \n",
    "```\n",
    "\n",
    "map()函数可以将函数作用于可迭代对象中的<font color='red'>每一个元素</font>，返回一个<font color='red'>可迭代对象</font>。常用于将一个序列映射为<font color='red'>另一种数据类型</font>的序列。语法如下：\n",
    "```python\n",
    "map(function, iterable, ...)\n",
    "```\n",
    "第一个参数是一个<font color='red'>函数</font>，如int,float,str等  \n",
    "第二个参数量是一个<font color='red'>可迭代对象</font>，如列表等\n",
    "示例如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<map object at 0x7fd53a932b50>\n",
      "[1, 2, 3]\n",
      "[0.0, 1.0, 2.0, 3.0, 4.0]\n",
      "['0', '1', '2', '3', '4']\n",
      "0+1+2+3+4\n",
      "01234\n"
     ]
    }
   ],
   "source": [
    "s= ['1','2','3']\n",
    "print(map(int,s))\n",
    "# 输出一个可迭代对象 <map object at 0x000002700724EEB8>\n",
    "print(list(map(int,s)))            # 用list()可将其转为列表输出 [1, 2, 3]\n",
    "print(list(map(float,range(5))))   # 整数序列映射为浮点数序列并转为列表\n",
    "# 输出[0.0, 1.0, 2.0, 3.0, 4.0]\n",
    "print(list(map(str,range(5))))     # 整数序列映射为字符串序列并转为列表\n",
    "# 输出['0', '1', '2', '3', '4']\n",
    "print('+'.join(map(str,range(5)))) # 整数序列映射为字符串序列并用‘+’连接\n",
    "# 输出 0+1+2+3+4\n",
    "print(''.join(map(str,range(5)))) # 整数序列映射为字符串序列并用空字符串连接\n",
    "# 输出 01234\n",
    "m,n = map(int,input().split()) \n",
    "# 将在一行中输入的用空格分隔2个数据切分开，转为整型，分别赋值给m,n\n",
    "print(pow(2,64))                  # 结果为数字18446744073709551616\n",
    "print(str(pow(2,64)))             # 结果为字符串'18446744073709551616'\n",
    "print(map(int,str(pow(2,64))))# 可迭代对象<map object at 0x000001A4A11DEEB8>\n",
    "print(sum(map(int,str(pow(2,64))))) # 输出2的64次方结果每位上的数加和 88"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zip函数可以组合多个可遍历对象，生成一个zip生成器，其语法为：  \n",
    "```python\n",
    "zip(iter1[, iter2 […]])\n",
    "```\n",
    "\n",
    "iter1、iter2…都是可遍历对象。  \n",
    "采用惰性求值的方式，可以按需要生成一系列<font color='red'>元组数据</font>，第i元组数据依次为每个可遍历对象的第i个元素组成的元组，直到所有可遍历对象中<font color='red'>最短的元组</font>最后一个元素组成的元组为止。  \n",
    "zip是<font color='red'>生成器对象</font>，需要查看其中的数据时，可以用list()函数将其转为列表。\n",
    "示例如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 4), (2, 5), (3, 6)]\n",
      "[(1, 11, 111), (2, 22, 222), (3, 33, 333)]\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,3)\n",
    "y = (4,5,6,8)\n",
    "z = zip(x,y)   # 惰性求值，生成zip对象，可用list转为列表输出\n",
    "print(list(z)) # [(1, 4), (2, 5), (3, 6)]\n",
    "a = [1,2,3]  # 列表a最短，生成元组个数与a长度相同，其他列表中多余元素被丢弃\n",
    "b = [11,22,33,44]\n",
    "c = [111,222,333,444]\n",
    "z = zip(a,b,c)  # 惰性求值，生成zip对象，可用list转为列表输出\n",
    "print(list(z))  # [(1, 11, 111), (2, 22, 222), (3, 33, 333)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "enumerate函数可以使用一个可遍历对象生成一个enumerate生成器，其语法为：\n",
    "\n",
    "```python \n",
    "enumerate(iter[, start])\n",
    "```\n",
    "iter为可遍历对象，start表示序号的起始值。\n",
    "其采用惰性求值的方式，可以按需要生成一系列两个元素组成的元组数据，第一个元素是以start为起始的一个整数（默认start值为0），第二个元素则是iter可遍历对象的数据元素。  \n",
    "简单的说，就是生成一个新的可遍历序列，给原来iter的每个值对应的增添了一个<font color='red'>序号数据</font>，示例如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'apple'), (1, 'banana'), (2, 'cherry')]\n",
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "a = ['apple', 'banana', 'cherry']\n",
    "E = enumerate(a)              # 生成enumerate对象\n",
    "print(list(E))                # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]\n",
    "\n",
    "for i in a:  ##序号,数据\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，列表a中的所有数据元素都添加了一个序号，形成一个元组，最后构成了enumerate生成器，其也是惰性求值的方式生成数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <font face='楷体' color='red' size=5> 练一练 </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例5.4  蒙特卡洛方法计算圆周率  \n",
    "\n",
    "利用列表推导式和zip()函数，用蒙特卡洛方法计算圆周率。  \n",
    "分析：  \n",
    "random.random()可以生成一个[0.0, 1.0]之间的数，利用列表推导式可以生成一批数据。  \n",
    "利用zip()函数将两组这样的数合并成一组坐标。  \n",
    "再判断其是否落在圆内，根据落在圆内的点的数量与总数量的比值得到面积  \n",
    "再由面积公式便可计算出圆周率的值。\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 利用列表推导式和zip()函数，用蒙特卡洛方法计算圆周率\n",
    "import random\n",
    "\n",
    "N = 100000\n",
    "lsx = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数\n",
    "lsy = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数\n",
    "# 用zip函数将两个列表中对应序号的数据组成N对坐标值，用list()将其转为列表\n",
    "ls = list(zip(lsx,lsy))\n",
    "count = 0\n",
    "for item in ls:\n",
    "    if item[0]**2+item[1]**2<=1: # 判断坐标点是否落在圆内\n",
    "        count=count + 1          # 落在圆内的点数量增加 1\n",
    "PI = 4 * count/N                 # 计算圆周率值\n",
    "print('{:.6f}'.format(PI))       # 输出结果3.141880（每次运行结果可能不同）\n"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}