5.function_and_variable_scope.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python3入门到精通——函数与变量作用域\n",
    "\n",
    "作者： Daniel Meng\n",
    "\n",
    "GitHub： [LibertyDream](https://github.com/LibertyDream)\n",
    "\n",
    "博客：[明月轩](https://libertydream.github.io/)\n",
    "\n",
    "> 本系列教程采用[知识共享署名-非商业性使用-相同方式共享 2.5 中国大陆许可协议](http://creativecommons.org/licenses/by-nc-sa/2.5/cn/)\n",
    "\n",
    "## 函数\n",
    "\n",
    "所谓函数，就是能执行特定任务的一段被命了名的程序。不管什么编程语言都会有函数这一概念，因为其有很重要的功能：\n",
    "\n",
    "* 功能性\n",
    "\n",
    "如定义所说，一个函数一定具备解决某一特定场景下问题的能力。或者说一个函数就是一个小工具、一个套路\n",
    "\n",
    "* 封装性\n",
    "\n",
    "一个良好的函数无论多么复杂，都能很好的隐藏自身的细节，暴露在外面的只是返回值、接受参数和函数说明而已，具体的功能实现外面的人都不用了解。\n",
    "\n",
    "* 重用性\n",
    "\n",
    "函数的存在大大降低了重复编码带来的成本损耗，从而提升了效率。而经常用于解决某类问题的函数们通常会进一步封装成一个函数库供人们使用。\n",
    "\n",
    "一个标准的函数定义形式如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funcname(parameter_list):\n",
    "    pass "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里注意几点：\n",
    "\n",
    "1. 参数列表部分`parameter_list`可以没有\n",
    "2. 如果函数有返回值，通过关键字`return`进行返回，如果没有返回值，python会返回一个`None`\n",
    "3. python中不需要像c，java语言那样明确每个函数的返回值类型\n",
    "\n",
    "函数可以嵌套使用，但为了良好的代码阅读体验和编程规范，**不推荐超过两层的嵌套调用**\n",
    "\n",
    "~~func(func1(func2(func(...))))~~\n",
    "\n",
    "下面简单实现两个函数以作示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "3 None\n"
     ]
    }
   ],
   "source": [
    "def add_two_num(x, y):\n",
    "    result = x + y\n",
    "    return result\n",
    "\n",
    "def print_code(code):\n",
    "    print(code)\n",
    "    \n",
    "result_add = add_two_num(1, 2)\n",
    "result_print = print_code('Python')\n",
    "print(result_add, result_print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "RecursionError",
     "evalue": "maximum recursion depth exceeded",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-f1cb3df65552>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Python'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-3-f1cb3df65552>\u001b[0m in \u001b[0;36mprint\u001b[1;34m(code)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 无限递归的错误示例\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Python'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "... last 1 frames repeated, from the frame below ...\n",
      "\u001b[1;32m<ipython-input-3-f1cb3df65552>\u001b[0m in \u001b[0;36mprint\u001b[1;34m(code)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 无限递归的错误示例\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcode\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Python'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
     ]
    }
   ],
   "source": [
    "# 无限递归的错误示例\n",
    "def print(code):\n",
    "    print(code)\n",
    "\n",
    "print('Python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里注意几点：\n",
    "\n",
    "1. 先定义再使用，和变量一样。python是解释型语言，运行时编译，所以不能在定义之前调用函数，否则python解释器找不到。\n",
    "2. 自定义函数的名称避免和内置函数同名。如注释代码所示，会陷入无限递归，运行时会报错\n",
    "3. 函数参数赋值顺序和传参顺序一致，从左到右依次赋值。这里额外留意下，目前自定义的`add_two_num()`有且只能接受两个参数，多了少了都不行，而内置函数`print()`通过`,`分隔可以接受任意数量的参数\n",
    "\n",
    "> python会监测递归动态，根据机器性能状况的差异，当发现一段代码自循环超过一定次数（995,998,1000等），就会报错。可以通过`sys.setrecursionlimit(recur_nums)指定递归深度。但python内部有额外机制，并不会允许特别大的深度\n",
    "\n",
    "对于返回值，传统语言一般只允许返回一个值，也有通过`out/ref`返回多值的方法。python想要返回多个值，方法很简单，通过`,`分隔开即可，如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'> 12 10\n",
      "12 10\n"
     ]
    }
   ],
   "source": [
    "def damage(skill_one, skill_two):\n",
    "    damage_one = skill_one * 3\n",
    "    damage_two = skill_two + 2\n",
    "    return damage_one, damage_two\n",
    "\n",
    "# 下标解包\n",
    "damages = damage(4,8)\n",
    "print(type(damages),damages[0],damages[1])\n",
    "\n",
    "# 序列解包\n",
    "skill_damage1,skill_damage2 = damage(4,8)\n",
    "print(skill_damage1,skill_damage2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多返回值的函数会将多个返回值封装成一个元组。注意样例代码中获取返回值的方式，第一种具有传统语言和新手风格，但并不赞成使用，当返回值众多，每个都用下标访问调用，日后维护代码时很难以理解。\n",
    "\n",
    "第二种就是一种 pythonic 风格的解包方式了，通过明晰、有意义的变量接收返回值，易于理解且代码简介。这种方式叫做**序列解包**\n",
    "\n",
    "更好的理解序列解包，先来了解下pythonic的赋值方式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 传统方式\n",
    "a = 1\n",
    "b = 2\n",
    "c = 3\n",
    "\n",
    "# pythonic\n",
    "a,b,c = 1,2,3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两种方式的效果等价，但后一种更显“优美”。而进一步的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "d = 1,2,3\n",
    "print(type(d))\n",
    "\n",
    "a,b,c = d\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`d = 1,2,3`这样的也是一种快速获得一个序列变量的方式。而`a,b,c = d`这样，通过**和序列内元素数目相等**的变量获取各个元素值，这样的方式就是序列解包。\n",
    "\n",
    "当多个变量的赋值相同时，可以使用**链式赋值**——`a=b=c=1`\n",
    "\n",
    "## 参数\n",
    "\n",
    "python中参数类型很多，主要是这么几种：\n",
    "\n",
    "### 必须参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    result = x + y\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对上述函数定义，指定了函数接收的两个参数`x`和`y`，定义里指定的参数也叫**形式参数**。当调用该函数时，如`c = add(x_value,y_value)`,必须传入和函数定义中数量一致的参数，默认从左向右依次赋值。函数调用时传入的参数也叫**实际参数**，即这里的`x_value`,`y_value`。\n",
    "\n",
    "这种函数定义多少就必须传入多少否则报错的参数类型就是必须参数\n",
    "\n",
    "### 关键字参数\n",
    "\n",
    "上面提到调用函数时传入参数默认是自左向右依次赋值，对函数`add`来说就是先给`x`赋值，再给`y`赋值。如果想要改变赋值顺序，或者说自定义赋值顺序，可以这样：\n",
    "\n",
    "`c = add(y=3, x=2)`\n",
    "\n",
    "这样的参数形式就是关键字参数，通过`参数名 = 参数赋值`的形式明确各个参数的传入值，可阅读性良好，也能改变传参顺序。\n",
    "\n",
    "### 默认参数\n",
    "\n",
    "很多时候对于一个函数的调用，多数参数值是一样的，重复输入相同的内容开发效率很低。这时候就可以使用默认参数了，义同其名，当没有明确指定参数值时，解释器会将默认值赋值给参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫小旋风\n",
      "我今年18岁\n",
      "我是男生\n",
      "我在狮驼岭上学\n"
     ]
    }
   ],
   "source": [
    "def print_student_files(name, gender, age, college):\n",
    "    print('我叫' + name)\n",
    "    print('我今年' + str(age) + '岁')\n",
    "    print('我是' + gender + '生')\n",
    "    print('我在' + college + '上学')\n",
    "\n",
    "print_student_files('小旋风', '男', 18, '狮驼岭')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "比如对如上函数定义，在`狮驼岭`上学的学生在`gender,age,college`一栏或几栏里内容都是一致的。这时就可以修改函数定义如下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_student_files(name, gender='男', age=18, college='狮驼岭'):\n",
    "    print('我叫' + name)\n",
    "    print('我今年' + str(age) + '岁')\n",
    "    print('我是' + gender + '生')\n",
    "    print('我在' + college + '上学')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这时如果个人数据和默认值无异，就可以只传入唯一的必须参数`print_student_files('奔波灞')`。如果有数据不同，则将对应值传入即可`print_student_files('蜘蛛精','女',16,'盘丝洞')`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫奔波灞\n",
      "我今年18岁\n",
      "我是男生\n",
      "我在狮驼岭上学\n"
     ]
    }
   ],
   "source": [
    "print_student_files('奔波灞')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫蜘蛛精\n",
      "我今年16岁\n",
      "我是女生\n",
      "我在盘丝洞上学\n"
     ]
    }
   ],
   "source": [
    "print_student_files('蜘蛛精', '女', 16, '盘丝洞')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目前为止默认参数看起来很简单，但有这么一些坑必须小心：\n",
    "\n",
    "* **不能跳过默认值赋值**\n",
    "\n",
    "当不显式的给参数赋值时，默认从左到右依次赋值，所以不能自以为是的跳跃赋值。比如对上面的函数，有一个学生`糊涂虫`，它的数据只有年龄和默认值不同，但函数调用不能这么写`print_student_files('糊涂虫',17)`，解释器会将实参`17`赋值给`gender`一栏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫糊涂虫\n",
      "我今年18岁\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-bfc83b4de022>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint_student_files\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'糊涂虫'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m17\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-6-938facb24f9a>\u001b[0m in \u001b[0;36mprint_student_files\u001b[1;34m(name, gender, age, college)\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'我叫'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'我今年'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mage\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'岁'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'我是'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mgender\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'生'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'我在'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mcollege\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m'上学'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "print_student_files('糊涂虫', 17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "正确的方式是`print_student_files('糊涂虫', age = 17)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我叫糊涂虫\n",
      "我今年17岁\n",
      "我是男生\n",
      "我在狮驼岭上学\n"
     ]
    }
   ],
   "source": [
    "print_student_files('糊涂虫', age=17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **默认参数和非默认参数不能混杂**\n",
    "\n",
    "函数定义时，默认参数和非默认参数不能穿插，下面的定义形式是非法的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-12-71526d0e917e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-71526d0e917e>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def print_student_files(name, gender='男', age=18, college='狮驼岭',teacher):\u001b[0m\n\u001b[1;37m                           ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def print_student_files(name, gender='男', age=18, college='狮驼岭',teacher):\n",
    "    print('我叫' + name)\n",
    "    print('我今年' + str(age) + '岁')\n",
    "    print('我是' + gender + '生')\n",
    "    print('我在' + college + '上学')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要加入一个必须参数，其应该在默认参数之前"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_student_files(name, num_id, gender='男', age=18, college='狮驼岭'):\n",
    "    print('我叫' + name)\n",
    "    print('我今年' + str(age) + '岁')\n",
    "    print('我是' + gender + '生')\n",
    "    print('我在' + college + '上学')\n",
    "    print('我的id是' + num_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **调用传参时定位参数和关键字参数不能混杂**\n",
    "\n",
    "和上一个坑类似，调用时默认的传参和关键字传参不能穿插，下面的调用是非法的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-13-72741bab2308>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-13-72741bab2308>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print_student_files('糊涂虫', gender='男', 17, college='魔王寨')\u001b[0m\n\u001b[1;37m                                                  ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "print_student_files('糊涂虫', gender='男', 17, college='魔王寨')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可变参数\n",
    "\n",
    "在我们已接触的函数中，有一个很特殊的函数`print()`，它可以接受任意多个参数。那么我们能否自己设计一个这样的函数，每次接收一组参数且数量不限，答案是肯定的。\n",
    "\n",
    "一般的实现思路是通过元组`()`和列表`[]`进行传参，但Python内通过`*param_name`形式定义的可变参数，可以自动的将一组参数平铺式的逐个传入函数中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def var_param(*param):\n",
    "    print(param)\n",
    "    print(type(param))\n",
    "\n",
    "var_param(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python自动将可变参数列表中给出的实参封装成一个元组，如果不喜欢这样的形式，可以自行将要传递的参数封装成一个元组，然后传给函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def other_var_param(param):\n",
    "    print(param)\n",
    "    print(type(param))\n",
    "\n",
    "other_var_param((1,2,3,4,5)) # 直接传入封装后的元组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果已经定义了可变参数`*param_name`，如果将元组传入，将会构成二维元组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((1, 2, 3, 4, 5),)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "var_param((1,2,3,4,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`*param_name`中`*`的作用类似于解包，所以如果自己想要传递的参数中有序列类型，不想构成二维元组，可以将其赋值给一个变量，然后将变量当做参数传递给函数,并在其前加上`*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "seris_var = (1,2,3,4,5)\n",
    "\n",
    "var_param(*seris_var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "seris_var = [1,2,3,4,5]\n",
    "\n",
    "var_param(*seris_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当一个函数的参数中既有可变参数，也有其他类型参数时，必须参数放在前面，其他类型参数顺序没有强制要求，但要注意与赋值方式匹配"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "1\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "def mixed_param(m_param, def_param=2, *var_param):\n",
    "    print(m_param)\n",
    "    print(def_param)\n",
    "    print(var_param)  # 逐类打印参数\n",
    "\n",
    "mixed_param('a', 1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上例所示，定了一个同时接收多种参数类型的函数`mixed_param`,我们希望逐类打印参数，并跳过默认参数，只赋值必须采参数和可变参数，但Python还是默认依次赋值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "(1, 2, 3)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def mixed_param(m_param, *var_param, def_param=2):\n",
    "    print(m_param)\n",
    "    print(var_param)\n",
    "    print(def_param)  # 逐类打印参数\n",
    "\n",
    "mixed_param('a', 1,2,3, 'param')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调换可变参数和默认参数的位置，还是逐类打印，希望`var_param`接收`1,2,3`，`def_param`接收`param`。但是因为`var_name`是可以接收任意多个参数的，所以除了必须参数拿走的，其余参数都被Python分配给了`var_param`,以至于`def_name`只能使用默认值。\n",
    "\n",
    "如果想让Python按照我们的意图赋值，必须显示的使用关键字参数给默认参数赋值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "(1, 2, 3)\n",
      "param\n"
     ]
    }
   ],
   "source": [
    "mixed_param('a', 1,2,3, def_param='param')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "传参时是无法预知实际参数都会分配给什么类型的参数的，所以再次注意传参顺序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-10-42557d71b452>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-10-42557d71b452>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    mixed_param('a', def_param='param', 1,2,3)\u001b[0m\n\u001b[1;37m                                       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "mixed_param('a', def_param='param', 1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上述案例只是展示不同参数类型在一起的场合，**编程实践中，强烈建议参数列表尽可能的简单，不要混合多种类型的参数**\n",
    "\n",
    "在实际应用中，可变参数通常通过for循环来遍历使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square_sum(*nums):  # 求数列平方和\n",
    "    num_sum = 0\n",
    "    for num in nums:\n",
    "        num_sum += num * num\n",
    "    return num_sum\n",
    "\n",
    "square_sum(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的传参都还只是序列类型的实参，那么当传入参数是任意多个关键字参数，或者干脆是字典类型会怎么样呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "city_temp() got an unexpected keyword argument 'Beijing'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-564f69151207>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[1;32mpass\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mcity_temp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mBeijing\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'36c'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mShanghai\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'32c'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mWuhai\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'27c'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: city_temp() got an unexpected keyword argument 'Beijing'"
     ]
    }
   ],
   "source": [
    "def city_temp(*citys): # 输出城市气温\n",
    "    pass\n",
    "\n",
    "city_temp(Beijing='36c', Shanghai='32c', Wuhai='27c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到，`*param_name`形式的可变参数不能应付任意多个的关键字参数列表。这种情况下需要`**param_name`形式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Beijing': '36c', 'Shanghai': '32c', 'Wuhai': '27c'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "def city_temp(**citys): # 输出城市气温\n",
    "    print(citys)\n",
    "    print(type(citys))\n",
    "\n",
    "city_temp(Beijing='36c', Shanghai='32c', Wuhai='27c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到Python将关键字参数列表转换成了字典进行存储，当我们使用的时候需要遍历字典来使用。\n",
    "\n",
    "字典的遍历方式很pythonic,类似于序列解包，大多是`key,value in dict.items()`形式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weather Now\n",
      "Beijing: 36c\n",
      "Shanghai: 32c\n",
      "Wuhai: 27c\n"
     ]
    }
   ],
   "source": [
    "def city_temp(**citys): # 输出城市气温\n",
    "    print('Weather Now')\n",
    "    for city, temp in citys.items():\n",
    "        print('%s: %s' % (city, temp))\n",
    "\n",
    "city_temp(Beijing='36c', Shanghai='32c', Wuhai='27c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当字典作为可变参数的接收对象的时候，类似于序列，可以将字典赋值给一个变量，然后以`**param`的方式使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weather Now\n",
      "Beijing: 36c\n",
      "Shanghai: 32c\n",
      "Wuhai: 27c\n"
     ]
    }
   ],
   "source": [
    "eg_citys={'Beijing':'36c', 'Shanghai':'32c', 'Wuhai':'27c'}\n",
    "\n",
    "city_temp(**eg_citys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可变参数既然可以接收任意多个参数，那么一个都不传自然也是能够接受的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weather Now\n"
     ]
    }
   ],
   "source": [
    "eg_citys={}\n",
    "\n",
    "city_temp(**eg_citys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此，就有了常见的参数接收形式`(must_param, **var_param)`,可以只传递必须参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in function print>\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "def func_show(func_name, **des):\n",
    "    print(func_name)\n",
    "    print(des)\n",
    "    \n",
    "func_show(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 变量作用域\n",
    "\n",
    "每一个变量都有自己能够起作用的范围，我们称之为作用域，作用域的概念所有编程语言内都有。通常在变量作用域之外访问不到该变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "c = 0\n",
    "\n",
    "def add(x, y):\n",
    "    c = x + y\n",
    "    print(c)\n",
    "\n",
    "add(1, 2)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数内定义的 c 外部无法访问，同名变量优先使用内部定义的变量。所以函数内的 c 打印值为3，外部 c 的打印值为0。\n",
    "\n",
    "还有更加直观方式的展示作用域"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-33-bfda2886468c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "def demo_func():\n",
    "    a = 10\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在一个模块内，`.py`文件内定义的变量称之为全局变量，像函数内定义的变量称之为局部变量。全局变量覆盖整个模块，能被多个函数调用；局部变量只能作用在自己所处的局部\n",
    "\n",
    "所谓局部是一个相对概念，比如对于函数内的语句来说，函数内定义的变量当然是可以访问的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "def demo_func():\n",
    "    b = 0\n",
    "    for x in range(1,10):\n",
    "        b += 1\n",
    "    print(b)\n",
    "\n",
    "demo_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意，Python没有块级作用域的概念，即`if elif else`,`for while`这样的选择、循环语句不构成作用域，即期内定义的变量，在语句外部是可以访问的。有其他语言经验的人要格外注意"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "def demo_func():\n",
    "    for x in range(0, 9):\n",
    "        a = 'a'\n",
    "    print(a)\n",
    "    \n",
    "demo_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "变量的作用域有链式特性，也叫做作用域链，即局部同名变量会屏蔽全局同名变量，嵌套层数多的作用域内的同名变量会屏蔽掉嵌套层数少的作用域内的变量，访问变量时从最近的作用域开始寻找变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "d = 0\n",
    "\n",
    "def func1():\n",
    "    d = 1\n",
    "    def func2():  # 函数内定义函数是允许的\n",
    "        d = 2\n",
    "        print(d)\n",
    "    func2()\n",
    "\n",
    "func1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "d = 0\n",
    "\n",
    "def func1():\n",
    "    d = 1\n",
    "    def func2():\n",
    "        # d = 2\n",
    "        print(d)  # 本作用域没有，向上一级寻找\n",
    "    func2()\n",
    "\n",
    "func1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "d = 0\n",
    "\n",
    "def func1():\n",
    "    # d = 1  # 本作用域没有，向上一级寻找\n",
    "    def func2():\n",
    "        # d = 2\n",
    "        print(d)  # 本作用域没有，向上一级寻找\n",
    "    func2()\n",
    "\n",
    "func1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面全局变量作用于整个模块内的函数，实际上全局变量在整个应用程序内都是可以被访问到的，即不同的包间也可以互相访问彼此定义的全局变量。比如说`aaa.bbb`内定义的全局变量，在`ccc.ddd`内，在导入`aaa.bbb`模块后即可访问\n",
    "\n",
    "此外 Python 还提供了`global`关键字申明变量是全局变量，这时即使变量是在`aaa.bbb`下某一函数内定义的，`ccc.ddd`导入后依旧可以访问到，前提是该函数至少执行过一次以初始化变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def demo_func():\n",
    "    global e\n",
    "    e = 2\n",
    "\n",
    "demo_func()  # 至少执行一次函数，否则 e 是不存在的\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.6.9"
  },
  "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": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}