diff --git a/README.md b/README.md
index fe70126..9a493c2 100644
--- a/README.md
+++ b/README.md
@@ -12,4 +12,5 @@
 |草根学 Python（二）基本数据类型和变量|[掘金](https://juejin.im/post/5946b7f25c497d006bef5704)，[简书](http://www.jianshu.com/p/b5388a6c2e72)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73478060)，[个人博客](http://twowater.com.cn/2017/06/19/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%BA%8C-%E5%9F%BA%E6%9C%AC%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%8F%98%E9%87%8F/)|
 |草根学 Python（三）List 和 Tuple|[掘金](https://juejin.im/post/593fdb87128fe1006a02ce92)，[简书](http://www.jianshu.com/p/97c97d5a5a7c)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73524367)，[个人博客](http://twowater.com.cn/2017/06/21/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%B8%89-List-%E5%92%8C-Tuple/)|
 |草根学Python（四） Dict 和 Set|[掘金](https://juejin.im/post/5947bf84ac502e5490e4a6a1)，[简书](http://www.jianshu.com/p/90f5b897ce77)，[CSDN](http://blog.csdn.net/two_water/article/details/73719026)，[个人博客](http://twowater.com.cn/2017/06/25/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%9B%9B-Dict-%E5%92%8C-Set/)|
-|草根学Python（五） 条件语句和循环语句|[掘金](https://juejin.im/post/594c6c52f265da6c1f75f164)，[简书](http://www.jianshu.com/p/2b80009b1e8c)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73762517)，[个人博客](http://twowater.com.cn/2017/06/27/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%BA%94-%E6%9D%A1%E4%BB%B6%E8%AF%AD%E5%8F%A5%E5%92%8C%E5%BE%AA%E7%8E%AF%E8%AF%AD%E5%8F%A5/)|
\ No newline at end of file
+|草根学Python（五） 条件语句和循环语句|[掘金](https://juejin.im/post/594c6c52f265da6c1f75f164)，[简书](http://www.jianshu.com/p/2b80009b1e8c)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73762517)，[个人博客](http://twowater.com.cn/2017/06/27/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E4%BA%94-%E6%9D%A1%E4%BB%B6%E8%AF%AD%E5%8F%A5%E5%92%8C%E5%BE%AA%E7%8E%AF%E8%AF%AD%E5%8F%A5/)|
+|草根学Python（六） 函数|[掘金](https://juejin.im/post/5946784461ff4b006cf1d8ec)，[简书](http://www.jianshu.com/p/d8f2a55edc75)，[CSDN](http://blog.csdn.net/Two_Water/article/details/73865622)，[个人博客](http://twowater.com.cn/2017/06/29/%E8%8D%89%E6%A0%B9%E5%AD%A6Python-%E5%85%AD-%E5%87%BD%E6%95%B0/)|
\ No newline at end of file
diff --git a/SUMMARY.md b/SUMMARY.md
index c0ec946..6725e50 100644
--- a/SUMMARY.md
+++ b/SUMMARY.md
@@ -24,4 +24,10 @@
 * [条件语句和循环语句](/python5/Preface.md)
   * [一、条件语句](/python5/If.md)
   * [二、循环语句](/python5/Cycle.md)
-  * [三、条件语句和循环语句综合实例](/python5/Example.md)
\ No newline at end of file
+  * [三、条件语句和循环语句综合实例](/python5/Example.md)
+* [函数](/python6/Preface.md)
+  * [一、Python 自定义函数的基本步骤](/python6/1.md)
+  * [二、函数传值问题](/python6/2.md)
+  * [三、函数返回值](/python6/3.md)
+  * [四、函数的参数](/python6/4.md)
+  * [五、匿名函数](/python6/5.md)
diff --git a/python6/1.md b/python6/1.md
new file mode 100644
index 0000000..4c3c075
--- /dev/null
+++ b/python6/1.md
@@ -0,0 +1,42 @@
+# 一、Python 自定义函数的基本步骤 #
+
+函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
+
+自定义函数，基本有以下规则步骤：
+
+* 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
+* 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
+* 函数的第一行语句可以选择性地使用文档字符串（用于存放函数说明）
+* 函数内容以冒号起始，并且缩进
+* return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
+
+语法示例：
+
+```python
+def functionname( parameters ):
+   "函数_文档字符串"
+   function_suite
+   return [expression]
+```
+
+实例：
+
+1. def 定义一个函数，给定一个函数名 sum 
+2. 声明两个参数 num1 和 num2
+3. 函数的第一行语句进行函数说明：两数之和
+4. 最终 return 语句结束函数，并返回两数之和
+
+```python
+def sum(num1,num2):
+	"两数之和"
+	return num1+num2
+
+# 调用函数
+print(sum(5,6))
+```
+
+输出结果：
+
+```python
+11
+```
\ No newline at end of file
diff --git a/python6/2.md b/python6/2.md
new file mode 100644
index 0000000..ffba1c2
--- /dev/null
+++ b/python6/2.md
@@ -0,0 +1,90 @@
+# 二、函数传值问题 #
+
+先看一个例子：
+
+```python
+# -*- coding: UTF-8 -*-
+def chagne_number( b ):
+    b = 1000
+
+b = 1
+chagne_number(b)
+print( b ) 
+```
+
+最后输出的结果为：
+
+```txt
+1
+```
+
+这里可能有些人会有疑问，为啥不是通过函数`chagne_number`更改了 b
+的值吗？为啥没有变化，输出的结果还是 1 ，这个问题很多编程语言都会讲到，原理解释也是差不多的。
+
+这里主要是函数参数的传递中，传递的是类型对象，之前也介绍了 Python 中基本的数据类型等。而这些类型对象可以分为可更改类型和不可更改的类型
+
+在 Python 中，字符串，整形，浮点型，tuple 是不可更改的对象，而 list ， dict 等是可以更改的对象。
+
+例如：
+
+**不可更改的类型**：变量赋值 `a = 1`，其实就是生成一个整形对象 1 ，然后变量 a 指向 1，当 `a = 1000` 其实就是再生成一个整形对象 1000，然后改变 a 的指向，不再指向整形对象 1 ，而是指向 1000，最后 1 会被丢弃
+
+**可更改的类型**：变量赋值 `a = [1,2,3,4,5,6]` ，就是生成一个对象 list ，list 里面有 6 个元素，而变量 a 指向 list ，`a[2] = 5`则是将 list a 的第三个元素值更改,这里跟上面是不同的，并不是将 a 重新指向，而是直接修改 list 中的元素值。
+
+![指向问题](https://user-gold-cdn.xitu.io/2017/6/27/d23fb1478065a0bcc19949cfbc88c5a0)
+
+这也将影响到函数中参数的传递了：
+
+**不可更改的类型**：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是 a 的值，没有影响 a 对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
+
+**可更改的类型**：类似 c++ 的引用传递，如 列表，字典。如 fun（a），则是将 a 真正的传过去，修改后 fun 外部的 a 也会受影响
+
+因此，在一开始的例子中，`b = 1`,创建了一个整形对象 1 ，变量 b 指向了这个对象，然后通过函数 chagne_number 时，按传值的方式复制了变量 b ，传递的只是 b 的值，并没有影响到 b 的本身。具体可以看下修改后的实例，通过打印的结果更好的理解。
+
+```python
+# -*- coding: UTF-8 -*-
+def chagne_number( b ):
+    print('函数中一开始 b 的值：{}' .format( b ) )
+    b = 1000
+    print('函数中 b 赋值后的值：{}' .format( b ) )
+    
+
+b = 1
+chagne_number( b )
+print( '最后输出 b 的值：{}' .format( b )  )
+
+
+```
+
+打印的结果：
+
+```txt
+函数中一开始 b 的值：1
+函数中 b 赋值后的值：1000
+最后输出 b 的值：1
+```
+
+当然，如果参数中的是可更改的类型，那么调用了这个函数后，原来的值也会被更改，具体实例如下：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def chagne_list( b ):
+    print('函数中一开始 b 的值：{}' .format( b ) )
+    b.append(1000)
+    print('函数中 b 赋值后的值：{}' .format( b ) )
+    
+
+b = [1,2,3,4,5]
+chagne_list( b )
+print( '最后输出 b 的值：{}' .format( b )  )
+
+```
+
+输出的结果：
+
+```txt
+函数中一开始 b 的值：[1, 2, 3, 4, 5]
+函数中 b 赋值后的值：[1, 2, 3, 4, 5, 1000]
+最后输出 b 的值：[1, 2, 3, 4, 5, 1000]
+```
diff --git a/python6/3.md b/python6/3.md
new file mode 100644
index 0000000..0f06fb9
--- /dev/null
+++ b/python6/3.md
@@ -0,0 +1,54 @@
+# 三、函数返回值 #
+
+通过上面的学习，可以知道通过 return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。
+
+具体示例：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def sum(num1,num2):
+	# 两数之和
+	if not (isinstance (num1,(int ,float)) or isinstance (num2,(int ,float))):
+		raise TypeError('参数类型错误')
+	return num1+num2
+
+print(sum(1,2))
+```
+
+返回结果：
+
+```txt
+3
+```
+
+这个示例，还通过内置函数`isinstance()`进行数据类型检查，检查调用函数时参数是否是整形和浮点型。如果参数类型不对，会报错，提示 `参数类型错误`,如图：
+
+![检查函数参数是否正确](https://user-gold-cdn.xitu.io/2017/6/28/d844f6a7b80370797dfea8f251f2a709)
+
+当然，函数也可以返回多个值，具体实例如下：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def  division ( num1, num2 ):
+	# 求商与余数
+         a = num1 % num2
+         b = (num1-a) / num2
+         return b , a 
+
+num1 , num2 = division(9,4)
+tuple1 = division(9,4)
+
+print (num1,num2)
+print (tuple1)
+```
+
+输出的值：
+
+```txt
+2.0 1
+(2.0, 1)
+```
+
+认真观察就可以发现，尽管从第一个输出值来看，返回了多个值，实际上是先创建了一个元组然后返回的。回忆一下，元组是可以直接用逗号来创建的，观察例子中的 ruturn ，可以发现实际上我们使用的是逗号来生成一个元组。
\ No newline at end of file
diff --git a/python6/4.md b/python6/4.md
new file mode 100644
index 0000000..e807b77
--- /dev/null
+++ b/python6/4.md
@@ -0,0 +1,206 @@
+# 四、函数的参数 #
+
+## 1、默认值参数 ##
+
+有时候，我们自定义的函数中，如果调用的时候没有设置参数，需要给个默认值，这时候就需要用到默认值参数了。
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_user_info( name , age , sex = '男' ):
+    # 打印用户信息
+    print('昵称：{}'.format(name) , end = ' ')
+    print('年龄：{}'.format(age) , end = ' ')
+    print('性别：{}'.format(sex))
+    return;
+
+# 调用 print_user_info 函数
+
+print_user_info( '两点水' , 18 , '女')
+print_user_info( '三点水' , 25 )
+```
+
+输出结果：
+
+```txt
+昵称：两点水 年龄：18 性别：女
+昵称：三点水 年龄：25 性别：男
+```
+
+可以看到，当你设置了默认参数的时候，在调用函数的时候，不传该参数，就会使用默认值。但是这里需要注意的一点是：**只有在形参表末尾的那些参数可以有默认参数值**，也就是说你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=1) 是有效的，但是 def func(a=1, b) 是 无效 的。 
+
+默认值参数就这样结束了吗？还没有的，细想一下，如果参数中是一个可修改的容器比如一个 lsit （列表）或者 dict （字典），那么我们使用什么来作为默认值呢？我们可以使用 None 作为默认值。就像下面这个例子一样：
+
+```python
+# 如果 b 是一个 list ，可以使用 None 作为默认值
+def print_info( a , b = None ):
+    if b is None :
+        b=[]
+    return;
+```
+
+认真看下例子，会不会有这样的疑问呢？在参数中我们直接 `b=[]` 不就行了吗？也就是写成下面这个样子：
+
+```python
+def print_info( a , b = [] ):
+    return;
+```
+对不对呢？运行一下也没发现错误啊，可以这样写吗？这里需要特别注意的一点：**默认参数的值是不可变的对象，比如None、True、False、数字或字符串**，如果你像上面的那样操作，当默认值在其他地方被修改后你将会遇到各种麻烦。这些修改会影响到下次调用这个函数时的默认值。
+
+示例如下：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_info( a , b = [] ):
+    print(b)
+    return b ;
+
+result = print_info(1)
+
+result.append('error')
+
+print_info(2)
+```
+
+输出的结果：
+
+```txt
+[]
+['error']
+```
+
+认真观察，你会发现第二次输出的值根本不是你想要的，因此切忌不能这样操作。
+
+
+还有一点，有时候我就是不想要默认值啊，只是想单单判断默认参数有没有值传递进来，那该怎么办？我们可以这样做：
+
+```python
+_no_value =object()
+
+def print_info( a , b = _no_value ):
+    if b is _no_value :
+        print('b 没有赋值')
+    return;
+```
+这里的 `object` 是python中所有类的基类。 你可以创建 `object` 类的实例，但是这些实例没什么实际用处，因为它并没有任何有用的方法， 也没有任何实例数据(因为它没有任何的实例字典，你甚至都不能设置任何属性值)。 你唯一能做的就是测试同一性。也正好利用这个特性，来判断是否有值输入。
+
+## 2、关键字参数 ##
+
+在 Python 中，可以通过参数名来给函数传递参数，而不用关心参数列表定义时的顺序，这被称之为关键字参数。使用关键参数有两个优势 ：
+
+一、由于我们不必担心参数的顺序，使用函数变得更加简单了。
+
+二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_user_info( name ,  age  , sex = '男' ):
+    # 打印用户信息
+    print('昵称：{}'.format(name) , end = ' ')
+    print('年龄：{}'.format(age) , end = ' ')
+    print('性别：{}'.format(sex))
+    return;
+
+# 调用 print_user_info 函数
+
+print_user_info( name = '两点水' ,age = 18 , sex = '女')
+print_user_info( name = '两点水' ,sex = '女', age = 18 )
+
+```
+
+输出的值：
+
+```txt
+昵称：两点水 年龄：18 性别：女
+昵称：两点水 年龄：18 性别：女
+```
+
+## 3、不定长参数 ##
+
+
+有时我们在设计函数接口的时候，可会需要可变长的参数。也就是说，我们事先无法确定传入的参数个数。Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 `*` 。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
+
+例如：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_user_info( name ,  age  , sex = '男' , * hobby):
+    # 打印用户信息
+    print('昵称：{}'.format(name) , end = ' ')
+    print('年龄：{}'.format(age) , end = ' ')
+    print('性别：{}'.format(sex) ,end = ' ' )
+    print('爱好：{}'.format(hobby))
+    return;
+
+# 调用 print_user_info 函数
+print_user_info( '两点水' ,18 , '女', '打篮球','打羽毛球','跑步')
+
+```
+
+输出的结果：
+
+```python
+昵称：两点水 年龄：18 性别：女 爱好：('打篮球', '打羽毛球', '跑步')
+```
+
+通过输出的结果可以知道，`*hobby`是可变参数，且 hobby其实就是一个 tuple （元祖）
+
+
+可变长参数也支持关键参数，没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 `**`,更改上面的示例如下：
+
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_user_info( name ,  age  , sex = '男' , ** hobby ):
+    # 打印用户信息
+    print('昵称：{}'.format(name) , end = ' ')
+    print('年龄：{}'.format(age) , end = ' ')
+    print('性别：{}'.format(sex) ,end = ' ' )
+    print('爱好：{}'.format(hobby))
+    return;
+
+# 调用 print_user_info 函数
+print_user_info( name = '两点水' , age = 18 , sex = '女', hobby = ('打篮球','打羽毛球','跑步'))
+
+```
+
+输出的结果：
+
+```txt
+昵称：两点水 年龄：18 性别：女 爱好：{'hobby': ('打篮球', '打羽毛球', '跑步')}	
+```
+
+通过对比上面的例子和这个例子，可以知道，`*hobby`是可变参数，且 hobby其实就是一个 tuple （元祖），`**hobby`是关键字参数，且 hobby 就是一个 dict （字典）
+
+
+## 4、只接受关键字参数 ##
+
+关键字参数使用起来简单，不容易参数出错，那么有些时候，我们定义的函数希望某些参数强制使用关键字参数传递，这时候该怎么办呢？
+
+将强制关键字参数放到某个`*`参数或者单个`*`后面就能达到这种效果,比如：
+
+```python
+# -*- coding: UTF-8 -*-
+
+def print_user_info( name , *, age  , sex = '男' ):
+    # 打印用户信息
+    print('昵称：{}'.format(name) , end = ' ')
+    print('年龄：{}'.format(age) , end = ' ')
+    print('性别：{}'.format(sex))
+    return;
+
+# 调用 print_user_info 函数
+print_user_info( name = '两点水' ,age = 18 , sex = '女' )
+
+# 这种写法会报错，因为 age ，sex 这两个参数强制使用关键字参数
+#print_user_info( '两点水' , 18 , '女' )
+print_user_info('两点水',age='22',sex='男')
+```
+
+通过例子可以看，如果 `age` , `sex` 不适用关键字参数是会报错的。
+
+很多情况下，使用强制关键字参数会比使用位置参数表意更加清晰，程序也更加具有可读性。使用强制关键字参数也会比使用 `**kw` 参数更好且强制关键字参数在一些更高级场合同样也很有用。
\ No newline at end of file
diff --git a/python6/5.md b/python6/5.md
new file mode 100644
index 0000000..34982e9
--- /dev/null
+++ b/python6/5.md
@@ -0,0 +1,60 @@
+# 五、匿名函数 #
+
+有没有想过定义一个很短的回调函数，但又不想用 `def` 的形式去写一个那么长的函数，那么有没有快捷方式呢？答案是有的。
+
+python 使用 lambda 来创建匿名函数，也就是不再使用 def 语句这样标准的形式定义一个函数。
+
+匿名函数主要有以下特点：
+
+* lambda 只是一个表达式，函数体比 def 简单很多。
+* lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
+* lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
+
+**基本语法**
+
+```python
+lambda [arg1 [,arg2,.....argn]]:expression
+```
+
+示例：
+
+```python
+# -*- coding: UTF-8 -*-
+
+sum = lambda num1 , num2 : num1 + num2;
+
+print( sum( 1 , 2 ) )
+
+```
+
+输出的结果：
+
+```txt
+3
+```
+
+注意：**尽管 lambda 表达式允许你定义简单函数，但是它的使用是有限制的。 你只能指定单个表达式，它的值就是最后的返回值。也就是说不能包含其他的语言特性了， 包括多个语句、条件表达式、迭代以及异常处理等等。**
+
+匿名函数中，有一个特别需要注意的问题，比如，把上面的例子改一下：
+
+```python
+# -*- coding: UTF-8 -*-
+
+num2 = 100
+sum1 = lambda num1 : num1 + num2 ;
+
+num2 = 10000
+sum2 = lambda num1 : num1 + num2 ;
+
+print( sum1( 1 ) )
+print( sum2( 1 ) )
+```
+
+你会认为输出什么呢？第一个输出是 101，第二个是 10001，结果不是的，输出的结果是这样：
+
+```txt
+10001
+10001
+```
+
+这主要在于 lambda 表达式中的 num2 是一个自由变量，在运行时绑定值，而不是定义时就绑定，这跟函数的默认值参数定义是不同的。所以建议还是遇到这种情况还是使用第一种解法。
\ No newline at end of file
diff --git a/python6/Preface.md b/python6/Preface.md
new file mode 100644
index 0000000..14a4538
--- /dev/null
+++ b/python6/Preface.md
@@ -0,0 +1,7 @@
+# 前言 #
+
+前天创了个 Python 微信讨论群，以为没人进的，哈哈，想不到还真有小伙伴进群学习讨论。如果想进群，可以加我微信： androidwed ，拉进群，就不贴微信群二维码了，一是会失效，二影响文章。
+
+# 目录 #
+
+![草根学Python（六）  函数](https://user-gold-cdn.xitu.io/2017/6/29/a5a5a69256f99d6eba4799bf837bc2cc)
\ No newline at end of file