diff --git a/README.md b/README.md
index 2f0468eec07a05c38ff7b2a68d9724a6652e9daa..f41ccab4c27fbcec478db4ab81b104cca1e8db72 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@
 
 | 模块 | 说明 |
 |---|---|
+|[base](base/README.md)| 支持的 python3 语法 |
 |[builtin](builtin/README.md)| 内置方法，比如异常处理、列表、字符串等 |
 |[GPIO](machine/GPIO/README.md)| machine.GPIO 库 |
 |[UART](machine/UART/README.md)| machine.UART  库 |
diff --git "a/base/Python3\345\205\203\347\273\204/README.md" "b/base/Python3\345\205\203\347\273\204/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bf6bde2f29995ab8cce32125aa388194212d6cd0
--- /dev/null
+++ "b/base/Python3\345\205\203\347\273\204/README.md"
@@ -0,0 +1,185 @@
+# Python3元组
+
+- [访问元组](#访问元组)
+- [修改元组](#修改元组)
+- [删除元组](#删除元组)
+- [元组运算符](#元组运算符)
+- [元组索引，截取](#元组索引截取)
+- [元组内置函数](#元组内置函数)
+
+  `Python` 的 **元组** 与 **列表** 类似，不同之处在于 **元组** 的元素不能修改。
+
+  **元组** 使用小括号 `( )`，**列表** 使用方括号 `[ ]`。
+
+  元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
+
+  实例演示：
+
+```shell
+>>> tup1 = ('Google', 'Waffle', 1997, 2000)
+>>> tup2 = (1, 2, 3, 4, 5 )
+>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
+>>> type(tup3)
+<class 'tuple'>
+```
+
+&emsp;&emsp;创建空元组:
+
+```python
+tup1 = ()
+```
+
+&emsp;&emsp;元组中只包含一个元素时，需要在元素后面添加逗号 `,` ，否则括号会被当作运算符使用：
+
+```shell
+>>> tup1 = (50)
+>>> type(tup1)     # 不加逗号，类型为整型
+<class 'int'>
+
+>>> tup1 = (50,)
+>>> type(tup1)     # 加上逗号，类型为元组
+<class 'tuple'>
+```
+
+&emsp;&emsp;元组与字符串类似，下标索引从 `0` 开始，可以进行截取，组合等。
+
+```shell
+>>> tup1 = ('Google', 'Waffle', 1997, 2000)
+>>> print(tup1[1])
+Waffle
+```
+
+---
+
+## 访问元组
+
+&emsp;&emsp;元组可以使用下标索引来访问元组中的值，如下实例:
+
+```python
+tup1 = ('Google', 'Waffle', 1997, 2000)
+tup2 = (1, 2, 3, 4, 5, 6, 7 )
+ 
+print ("tup1[0]: ", tup1[0])
+print ("tup2[1:5]: ", tup2[1:5])
+```
+
+以上实例输出结果：
+
+```shell
+tup1[0]:  Google
+tup2[1:5]:  (2, 3, 4, 5)
+```
+
+---
+
+## 修改元组
+
+&emsp;&emsp;元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
+
+```python
+tup1 = (12, 34.56)
+tup2 = ('abc', 'xyz')
+ 
+# 以下修改元组元素操作是非法的。
+# tup1[0] = 100
+ 
+# 创建一个新的元组
+tup3 = tup1 + tup2
+print (tup3)
+```
+
+&emsp;&emsp;以上实例输出结果：
+
+```
+(12, 34.56, 'abc', 'xyz')
+```
+---
+
+## 删除元组
+
+&emsp;&emsp;元组中的元素值是 **不允许** 删除的，但我们可以使用 `del` 语句来删除整个元组，如下实例:
+
+```python
+tup = ('Google', 'Waffle', 1997, 2000)
+ 
+print (tup)
+del tup
+print ("删除后的元组 tup : ")
+print (tup)
+```
+
+&emsp;&emsp;以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
+
+```shell
+删除后的元组 tup : 
+Traceback (most recent call last):
+  File "test.py", line 6, in <module>
+    print (tup)
+NameError: name 'tup' is not defined
+```
+
+---
+
+## 元组运算符
+
+&emsp;&emsp;与字符串一样，元组之间可以使用 `+` 号和 `*` 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
+
+| Python 表达式 | 结果 | 描述 |
+| --- | --- | --- |
+| len((1, 2, 3)) | 3 | 计算元素个数 |
+| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
+| ('Hi!',) * 4  | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 | 
+| 3 in (1, 2, 3) | True | 元素是否存在 |
+| for x in (1, 2, 3): print (x,) | 1 2 3 | 	迭代  |
+
+---
+
+## 元组索引，截取
+
+&emsp;&emsp;因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
+
+元组：
+
+```python
+tup = ('Google', 'Waffle', 'Taobao', 'Wiki', 'Weibo','Weixin')
+```
+
+| Python 表达式 | 结果 | 描述 |
+| --- | --- | --- |
+| tup[1] | 'Waffle' | 读取第二个元素 |
+| tup[-2] | 'Weibo' | 反向读取，读取倒数第二个元素 |
+| tup[1:] | ('Waffle', 'Taobao', 'Wiki', 'Weibo', 'Weixin') | 截取元素，从第二个开始后的所有元素。|
+| tup[1:4] | ('Waffle', 'Taobao', 'Wiki') | 截取元素，从第二个开始到第四个元素（索引为 3）。|
+
+---
+
+## 元组内置函数
+
+&emsp;&emsp;`Python` 元组包含了以下内置函数
+
+| 方法 | 描述 |
+| --- | --- | 
+| len(tuple) | 计算元组元素个数 |
+| max(tuple) | 返回元组中元素最大值。注：元组内必须都是数字类型 |
+| min(tuple) | 返回元组中元素最小值。注：元组内必须都是数字类型 |
+| tuple(iterable) | 将可迭代系列转换为元组。 |
+
+**关于元组是不可变的**
+
+&emsp;&emsp;所谓元组的不可变指的是 **元组所指向的 内存 中的 内容 不可变**。
+
+```shell
+>>> tup = ('W', 'a', 'f', 'f', 'l', 'e')
+>>> tup[0] = 'g'     # 不支持修改元素
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'tuple' object does not support item assignment
+>>> id(tup)     # 查看内存地址
+4440687904
+>>> tup = (1,2,3)
+>>> id(tup)
+4441088800    # 内存地址不一样了
+```
+
+&emsp;&emsp;从以上实例可以看出，重新赋值的元组 `tup`，绑定到新的对象了，不是修改了原来的对象。
+
diff --git "a/base/Python3\345\207\275\346\225\260/README.md" "b/base/Python3\345\207\275\346\225\260/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0fbc1decf859ed9150baed97200029bd4db3c821
--- /dev/null
+++ "b/base/Python3\345\207\275\346\225\260/README.md"
@@ -0,0 +1,498 @@
+# Python3函数
+
+- [定义一个函数](#定义一个函数)
+- [语法](#语法)
+- [函数调用](#函数调用)
+- [参数传递](#参数传递)
+    - [可更改(mutable)与不可更改(immutable)对象](#可更改mutable与不可更改immutable对象)
+    - [python传不可变对象实例](#python传不可变对象实例)
+    - [python传可变对象实例](#python传可变对象实例)
+- [参数](#参数)
+    - [必需参数](#必需参数)
+    - [关键字参数](#关键字参数)
+    - [默认参数](#默认参数)
+    - [不定长参数](#不定长参数)
+- [匿名函数](#匿名函数)
+- [return语句](#return语句)
+
+
+
+
+函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
+
+函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
+
+---
+
+## 定义一个函数
+
+你可以定义一个由自己想要功能的函数，以下是简单的规则：
+
+- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
+- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
+- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
+- 函数内容以冒号 `:` 起始，并且缩进。
+- `return [表达式]` 结束函数，选择性地返回一个值给调用方，不带表达式的 `return` 相当于返回 `None`。
+
+---
+
+## 语法
+
+Python 定义函数使用 def 关键字，一般格式如下：
+
+```
+def 函数名（参数列表）:
+    函数体
+```
+
+默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
+
+实例如下，让我们使用函数来输出"Hello World！"：
+
+```python
+def hello() :
+    print("Hello World!")
+
+hello()
+```
+
+输出如下：
+
+```
+Hello World!
+```
+
+更复杂点的应用，函数中带上参数变量:
+
+```python
+def max(a, b):
+    if a > b:
+        return a
+    else:
+        return b
+ 
+a = 4
+b = 5
+print(max(a, b))
+```
+
+以上实例输出结果：
+```
+5
+```
+
+```python
+# 计算面积函数
+def area(width, height):
+    return width * height
+ 
+def print_welcome(name):
+    print("Welcome", name)
+ 
+print_welcome("Waffle")
+w = 4
+h = 5
+print("width =", w, " height =", h, " area =", area(w, h))
+```
+以上实例输出结果：
+
+```
+Welcome Waffle
+width = 4  height = 5  area = 20
+```
+
+---
+
+## 函数调用
+
+定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
+
+这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
+
+如下实例调用了 printme() 函数：
+
+```python
+# 定义函数
+def printme( str ):
+   # 打印任何传入的字符串
+   print (str)
+   return
+ 
+# 调用函数
+printme("我要调用用户自定义函数!")
+printme("再次调用同一函数")
+```
+以上实例输出结果：
+```
+我要调用用户自定义函数!
+再次调用同一函数
+```
+
+---
+
+## 参数传递
+
+在 python 中，类型属于对象，变量是没有类型的：
+
+```python
+a=[1,2,3]
+
+a="Waffle"
+```
+
+以上代码中，[1,2,3] 是 List 类型，"Waffle" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
+
+### 可更改(mutable)与不可更改(immutable)对象
+
+在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
+
+- **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
+
+- **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
+
+python 函数的参数传递：
+
+- **不可变类型：**类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
+
+- **可变类型：**类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。
+
+python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
+
+### python传不可变对象实例
+
+通过 `id()` 函数来查看内存地址变化：
+
+```python
+def change(a):
+    print(id(a))   # 指向的是同一个对象
+    a=10
+    print(id(a))   # 一个新对象
+ 
+a=1
+print(id(a))
+change(a)
+```
+
+以上实例输出结果为：
+
+```
+3
+3
+21
+```
+
+可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。
+
+
+### python传可变对象实例
+
+可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
+
+```python
+# 可写函数说明
+def changeme( mylist ):
+   "修改传入的列表"
+   mylist.append([1,2,3,4])
+   print ("函数内取值: ", mylist)
+   return
+ 
+# 调用changeme函数
+mylist = [10,20,30]
+changeme( mylist )
+print ("函数外取值: ", mylist)
+```
+
+传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
+
+```
+函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
+函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
+```
+
+
+---
+
+## 参数
+
+以下是调用函数时可使用的正式参数类型：
+
+- 必需参数
+- 关键字参数 
+- 默认参数
+- 不定长参数
+
+### 必需参数
+必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
+
+调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：
+
+```python
+#可写函数说明
+def printme( str ):
+   "打印任何传入的字符串"
+   print (str)
+   return
+ 
+# 调用 printme 函数，不加参数会报错
+printme()
+```
+
+以上实例输出结果：
+
+```
+Traceback (most recent call last):
+  File "<stdin>", line 8, in <module>
+TypeError: printme() takes 1 positional arguments but 0 were given
+```
+
+### 关键字参数 
+
+关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
+
+使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
+
+以下实例在函数 printme() 调用时使用参数名：
+
+```python
+#可写函数说明
+def printme( str ):
+   "打印任何传入的字符串"
+   print (str)
+   return
+ 
+#调用printme函数
+printme( str = "WaffleNano")
+```
+
+以上实例输出结果： 
+
+```
+WaffleNano
+```
+
+以下实例中演示了函数参数的使用不需要使用指定顺序：
+
+```python
+#可写函数说明
+def printinfo( name, age ):
+   "打印任何传入的字符串"
+   print ("名字: ", name)
+   print ("年龄: ", age)
+   return
+ 
+#调用printinfo函数
+printinfo( age=50, name="Waffle" )
+```
+
+
+以上实例输出结果：
+
+```
+名字:  Waffle
+年龄:  50
+```
+
+### 默认参数
+
+调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
+
+```python
+#可写函数说明
+def printinfo( name, age = 35 ):
+   "打印任何传入的字符串"
+   print ("名字: ", name)
+   print ("年龄: ", age)
+   return
+ 
+#调用printinfo函数
+printinfo( age=50, name="Waffle" )
+print ("------------------------")
+printinfo( name="Waffle" )
+```
+
+以上实例输出结果：
+```
+名字:  Waffle
+年龄:  50
+------------------------
+名字:  Waffle
+年龄:  35
+```
+
+### 不定长参数
+
+你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
+
+```
+def functionname([formal_args,] *var_args_tuple ):
+   "函数_文档字符串"
+   function_suite
+   return [expression]
+```
+
+加了星号 `*` 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
+
+```python
+# 可写函数说明
+def printinfo( arg1, *vartuple ):
+   "打印任何传入的参数"
+   print ("输出: ")
+   print (arg1)
+   print (vartuple)
+ 
+# 调用printinfo 函数
+printinfo( 70, 60, 50 )
+```
+
+以上实例输出结果：
+
+```
+输出: 
+70
+(60, 50)
+```
+
+如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
+
+```python
+# 可写函数说明
+def printinfo( arg1, *vartuple ):
+   "打印任何传入的参数"
+   print ("输出: ")
+   print (arg1)
+   for var in vartuple:
+      print (var)
+   return
+ 
+# 调用printinfo 函数
+printinfo( 10 )
+printinfo( 70, 60, 50 )
+```
+
+以上实例输出结果：
+
+```
+输出: 
+10
+输出: 
+70
+60
+50
+```
+
+还有一种就是参数带两个星号 `**` 基本语法如下：
+
+```
+def functionname([formal_args,] **var_args_dict ):
+   "函数_文档字符串"
+   function_suite
+   return [expression]
+```
+
+加了两个星号 `**` 的参数会以字典的形式导入。
+
+```python
+# 可写函数说明
+def printinfo( arg1, **vardict ):
+   "打印任何传入的参数"
+   print ("输出: ")
+   print (arg1)
+   print (vardict)
+ 
+# 调用printinfo 函数
+printinfo(1, a=2,b=3)
+```
+
+以上实例输出结果：
+
+```
+输出: 
+1
+{'a': 2, 'b': 3}
+```
+
+声明函数时，参数中星号 `*` 可以单独出现，例如:
+
+```python
+def f(a,b,*,c):
+    return a+b+c
+```
+
+如果单独出现星号 * 后的参数必须用关键字传入。
+
+```shell
+>>> def f(a,b,*,c):
+...     return a+b+c
+... 
+>>> f(1,2,3)   # 报错
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: f() takes 2 positional arguments but 3 were given
+>>> f(1,2,c=3) # 正常
+6
+>>>
+```
+
+---
+
+## 匿名函数
+
+python 使用 lambda 来创建匿名函数。
+
+所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
+
+- lambda 只是一个表达式，函数体比 def 简单很多。
+- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
+- lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
+- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
+
+**语法**
+
+lambda 函数的语法只包含一个语句，如下：
+
+```
+lambda [arg1 [,arg2,.....argn]]:expression
+```
+
+```python
+# 可写函数说明
+sum = lambda arg1, arg2: arg1 + arg2
+ 
+# 调用sum函数
+print ("相加后的值为 : ", sum( 10, 20 ))
+print ("相加后的值为 : ", sum( 20, 20 ))
+```
+
+以上实例输出结果：
+
+```
+相加后的值为 :  30
+相加后的值为 :  40
+```
+
+---
+
+## return语句
+
+`return [表达式]` 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：
+
+```python
+# 可写函数说明
+def sum( arg1, arg2 ):
+   # 返回2个参数的和."
+   total = arg1 + arg2
+   print ("函数内 : ", total)
+   return total
+ 
+# 调用sum函数
+total = sum( 10, 20 )
+print ("函数外 : ", total)
+```
+以上实例输出结果：
+
+```
+函数内 :  30
+函数外 :  30
+```
+
+
diff --git "a/base/Python3\345\210\227\350\241\250/README.md" "b/base/Python3\345\210\227\350\241\250/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7f2cd73cda96410992e9c94a09698de51428ccc1
--- /dev/null
+++ "b/base/Python3\345\210\227\350\241\250/README.md"
@@ -0,0 +1,235 @@
+# Python3 列表
+
+- [访问列表中的值](#访问列表中的值)
+- [更新列表](#更新列表)
+- [删除列表元素](#删除列表元素)
+- [Python列表脚本操作符](#Python列表脚本操作符)
+- [Python列表截取与拼接](#Python列表截取与拼接)
+- [嵌套列表](#嵌套列表)
+- [Python列表函数&方法](#Python列表函数方法)
+
+
+&emsp;&emsp;序列是 Python 中最基本的数据结构。
+
+&emsp;&emsp;序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
+
+&emsp;&emsp;Python 有 6 个序列的内置类型，但最常见的是列表和元组。
+
+&emsp;&emsp;列表都可以进行的操作包括索引，切片，加，乘，检查成员。
+
+&emsp;&emsp;此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
+
+&emsp;&emsp;列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
+
+&emsp;&emsp;列表的数据项不需要具有相同的类型
+
+&emsp;&emsp;创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
+
+```python
+list1 = ['Waffle', 'Nano', 1997, 2000]
+list2 = [1, 2, 3, 4, 5 ]
+list3 = ["a", "b", "c", "d"]
+list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
+```
+
+---
+
+## 访问列表中的值
+
+&emsp;&emsp;与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
+
+&emsp;&emsp;通过索引列表可以进行截取、组合等操作。
+
+```python
+list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
+print( list[0] )
+print( list[1] )
+print( list[2] )
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+&emsp;&emsp;索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
+
+```python
+list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
+print( list[-1] )
+print( list[-2] )
+print( list[-3] )
+```
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+
+&emsp;&emsp;使用下标索引来访问列表中的值，同样你也可以使用方括号 `[]` 的形式截取字符，如下所示：
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+```python
+nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
+print(nums[0:4])
+```
+
+以上实例输出结果：
+
+> [10, 20, 30, 40]
+
+使用负数索引值截取：
+
+```python
+list = ['Google', 'Waffle', "Nano", "Taobao", "Wiki"]
+ 
+# 读取第二位
+print ("list[1]: ", list[1])
+# 从第二位开始（包含）截取到倒数第二位（不包含）
+print ("list[1:-2]: ", list[1:-2])
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+---
+
+## 更新列表
+
+&emsp;&emsp;你可以对列表的数据项进行修改或更新，你也可以使用 `append()` 方法来添加列表项，如下所示：
+
+```python
+list = ['Google', 'Waffle', 1997, 2000]
+ 
+print ("第三个元素为 : ", list[2])
+list[2] = 2001
+print ("更新后的第三个元素为 : ", list[2])
+ 
+list1 = ['Google', 'Waffle', 'Nano']
+list1.append('Baidu')
+print ("更新后的列表 : ", list1)
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+---
+
+## 删除列表元素
+
+&emsp;&emsp;可以使用 `del` 语句来删除列表的的元素，如下实例：
+
+```python
+list = ['Google', 'Waffle', 1997, 2000]
+ 
+print ("原始列表 : ", list)
+del list[2]
+print ("删除第三个元素 : ", list)
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/6.png" width="500"/></center>
+
+---
+
+## Python列表脚本操作符
+
+&emsp;&emsp;列表对 `+` 和 `*` 的操作符与字符串相似。`+` 号用于组合列表，`*` 号用于重复列表。
+
+如下所示：
+
+| Python 表达式 | 结果 | 描述 |
+| --- | --- | --- |
+| len([1, 2, 3]) | 3 | 	长度 |
+| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
+| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
+| 3 in [1, 2, 3] | True | 元素是否存在于列表中 | 
+| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
+
+---
+
+## Python列表截取与拼接
+
+&emsp;&emsp;`Python` 的列表截取与字符串操作类型，如下所示：
+
+```python
+L=['Google', 'Waffle', 'Taobao']
+```
+
+操作：
+
+| Python 表达式 | 结果 | 描述 |
+| --- | --- | --- |
+| L[2] | 'Taobao' | 读取第三个元素 |
+| L[-2] | 'Waffle' | 从右侧开始读取倒数第二个元素: count from the right | 
+| L[1:] | 	['Waffle', 'Taobao'] | 输出从第二个元素开始后的所有元素 |
+
+```shell
+>>>L=['Google', 'Waffle', 'Taobao']
+>>> L[2]
+'Taobao'
+>>> L[-2]
+'Waffle'
+>>> L[1:]
+['Waffle', 'Taobao']
+>>>
+```
+
+列表还支持拼接操作：
+
+```shell
+>>>squares = [1, 4, 9, 16, 25]
+>>> squares += [36, 49, 64, 81, 100]
+>>> squares
+[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
+>>>
+```
+
+---
+
+## 嵌套列表
+
+使用嵌套列表即在列表里创建其它列表，例如：
+
+```shell 
+>>>a = ['a', 'b', 'c']
+>>> n = [1, 2, 3]
+>>> x = [a, n]
+>>> x
+[['a', 'b', 'c'], [1, 2, 3]]
+>>> x[0]
+['a', 'b', 'c']
+>>> x[0][1]
+'b'
+```
+
+---
+
+## Python列表函数&方法
+
+Python包含以下函数:
+
+| 序号 | 函数 |
+| --- | --- |
+| 1 | len(list)<br>列表元素个数 |
+| 2 | max(list)<br>返回列表元素最大值 |
+| 3 | min(list)<br>返回列表元素最小值 |
+| 4 | list(seq)<br>将元组转换为列表 |
+
+Python包含以下方法:
+
+| 序号 | 方法 |
+| --- | --- |
+| 1 | list.append(obj)<br> 在列表末尾添加新的对象|
+| 2 | list.count(obj)<br> 统计某个元素在列表中出现的次数|
+| 3 | list.extend(seq)<br> 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
+| 4 | list.index(obj)<br> 从列表中找出某个值第一个匹配项的索引位置 |
+| 5 | list.insert(index, obj)<br>将对象插入列表|
+| 6 | list.pop([index=-1])<br>移除列表中的一个元素（默认最后一个元素），并且返回该元素的值| 
+| 7 | list.remove(obj)<br> 移除列表中某个值的第一个匹配项| 
+| 8 | list.reverse()<br> 反向列表中元素|
+| 9 | list.sort( key=None, reverse=False)<br> 对原列表进行排序| 
+| 10 | list.clear()<br>清空列表|
+| 11 | 	list.copy()<br> 复制列表|
\ No newline at end of file
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/1.png" "b/base/Python3\345\210\227\350\241\250/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..f92a25b8239cace0a9854953c4d5083b68f7c4a9
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/1.png" differ
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/2.png" "b/base/Python3\345\210\227\350\241\250/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..101b320e62d2ea51b24b9ab17a0bde17cb2ffa45
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/2.png" differ
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/3.png" "b/base/Python3\345\210\227\350\241\250/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..c57b2386b5d7e4bc7b9ad466a6efa7748d3cea75
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/3.png" differ
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/4.png" "b/base/Python3\345\210\227\350\241\250/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..53ebed7086869df90cf4acacd4c6ff73661b916d
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/4.png" differ
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/5.png" "b/base/Python3\345\210\227\350\241\250/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d3e8156e3039822a7aa591bdbfb5882f25901526
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/5.png" differ
diff --git "a/base/Python3\345\210\227\350\241\250/assets/image/6.png" "b/base/Python3\345\210\227\350\241\250/assets/image/6.png"
new file mode 100644
index 0000000000000000000000000000000000000000..92d19995c9ca98afdd8239b857e72691ac1a6eae
Binary files /dev/null and "b/base/Python3\345\210\227\350\241\250/assets/image/6.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/README.md" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..98eba6a4a8b46b539ecce16c81c9c0144eca185a
--- /dev/null
+++ "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/README.md"
@@ -0,0 +1,536 @@
+# Python3 基本数据类型
+
+- [多个变量赋值](#多个变量赋值)
+- [标准数据类型](#标准数据类型)
+- [Number(数字)](#Number(数字))
+- [数值运算](#数值运算)
+- [String(字符串)](#String(字符串))
+- [List(列表)](#List(列表))
+- [Tuple(元组)](#Tuple(元组))
+- [Set(集合)](#Set(集合))
+- [Dictionary(字典)](#Dictionary(字典))
+- [Python 数据类型转换](#Python数据类型转换)
+
+
+
+
+&emsp;&emsp;`Python` 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
+
+&emsp;&emsp;在 `Python` 中，**变量** 就是 **变量**，它没有 **类型**，我们所说的 **"类型"** 是变量所指的内存中对象的类型。
+
+&emsp;&emsp;等号`（=）`用来给变量赋值。
+
+&emsp;&emsp;等号`（=）`运算符左边是一个变量名,等号`（=）`运算符右边是存储在变量中的值。例如：
+
+```python
+counter = 100          # 整型变量
+miles   = 1000.0       # 浮点型变量
+name    = "Waffle Nano"     # 字符串
+
+print (counter)
+print (miles)
+print (name)
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+<center>(变量赋值)</center>
+
+&emsp;
+
+---
+
+## 多个变量赋值
+
+&emsp;&emsp;`Python` 允许你同时为多个变量赋值。例如：
+
+```python
+a = b = c = 1
+```
+
+&emsp;&emsp;以上实例，创建一个整型对象，值为 `1`，从后向前赋值，三个变量被赋予相同的数值。
+
+&emsp;&emsp;您也可以为多个对象指定多个变量。例如：
+
+```python
+a, b, c = 1, 2.5, "Waffle"
+```
+
+&emsp;&emsp;以上实例，两个整型对象 `1` 和 `2.5` 的分配给变量 `a` 和 `b`，字符串对象 `"Waffle"` 分配给变量 `c`。
+
+---
+
+## 标准数据类型
+
+&emsp;&emsp;`Python3` 中有六个标准的数据类型：
+
+- `Number`(数字)
+- `String`(字符串)
+- `List`(列表)
+- `Tuple`(元组)
+- `Set`(集合)
+- `Dictionary`(字典)
+
+&emsp;&emsp;`Python3` 的六个标准数据类型中：
+
+- **不可变数据（3 个）**：`Number`（数字）、`String`（字符串）、`Tuple`（元组）；
+- **可变数据（3 个）**：`List`（列表）、`Dictionary`（字典）、`Set`（集合）。 
+
+---
+
+## Number(数字)
+
+&emsp;&emsp;`Python3` 支持 `int`、`float`、`bool`、`complex`（复数）。
+
+&emsp;&emsp;在 `Python 3` 里，只有一种整数类型 `int`，表示为长整型，没有 `python2` 中的 `Long`。
+
+&emsp;&emsp;像大多数语言一样，数值类型的赋值和计算都是很直观的。
+
+&emsp;&emsp;内置的 `type()` 函数可以用来查询变量所指的对象类型。
+
+```shell
+>>> a, b, c, d = 20, 5.5, True, 4+3j
+>>> print(type(a), type(b), type(c), type(d))
+<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
+```
+
+&emsp;&emsp;此外还可以用 `isinstance` 来判断：
+
+```shell
+>>> a = 111
+>>> isinstance(a, int)
+True
+>>>
+```
+
+>**注意**：`Python3` 中，`bool `是 `int` 的子类，`True` 和 `False` 可以和数字相加 `True==1`，`False==0` 是会返回 `Ture`，但可以通过 `is` 来判断类型。
+
+```shell
+>>> issubclass(bool, int) 
+True
+>>> True==1
+True
+>>> False==0
+True
+>>> True+1
+2
+>>> False+1
+1
+>>> 1 is True
+False
+>>> 0 is False
+False
+```
+>在 `Python2 `中是没有布尔型的，它用数字 `0` 表示` False`，用 `1` 表示 `True`。
+
+&emsp;&emsp;当你指定一个值时，`Number` 对象就会被创建：
+
+```python
+var1 = 1
+var2 = 10
+```
+
+&emsp;&emsp;您也可以使用 `del` 语句删除一些对象引用。
+
+&emsp;&emsp;`del` 语句的语法是：
+
+```python
+del var1[,var2[,var3[....,varN]]]
+```
+
+&emsp;&emsp;您可以通过使用 `del` 语句删除单个或多个对象。例如：
+
+```python
+del var
+del var_a, var_b
+```
+
+---
+
+## 数值运算
+
+```shell
+>>> 5 + 4  # 加法
+9
+>>> 4.3 - 2 # 减法
+2.3
+>>> 3 * 7  # 乘法
+21
+>>> 2 / 4  # 除法，得到一个浮点数
+0.5
+>>> 2 // 4 # 除法，得到一个整数
+0
+>>> 17 % 3 # 取余
+2
+>>> 2 ** 5 # 乘方
+32
+```
+
+&emsp;&emsp;**注意：**
+
+- `Python` 可以同时为多个变量赋值，如 `a, b = 1, 2`；
+- 一个变量可以通过赋值指向不同类型的对象；
+- 数值的除法包含两个运算符：`/` 返回一个浮点数，`// `返回一个整数；
+- 在混合计算时，`Python` 会把整型转换成为浮点数。
+
+**数值类型实例**
+
+| int | float | complex |
+| --- | --- | --- |
+| 10 | 0.0 | 3.14j |
+| 100 | 15.20 | 45.j |
+| -786 | -21.9 | 9.322e-36j | 
+| 080 | 32.3e+18 | .876j |
+| -0490 | -90 | -.6545+0J |
+| -0x260 | -32.54e100 | 3e+26j |
+| 0x69 | 70.2E-12 | 4.53e-7j |
+
+&emsp;&emsp;`Python` 还支持复数，复数由实数部分和虚数部分构成，可以用 `a + bj`,或者 `complex(a,b)` 表示， 复数的实部 `a` 和虚部 `b` 都是浮点型。
+
+---
+
+## String(字符串)
+
+&emsp;&emsp;`Python` 中的字符串用单引号 `' `或双引号 `"` 括起来，同时使用反斜杠 `\` 转义特殊字符。
+
+&emsp;&emsp;字符串的截取的语法格式如下：
+
+>变量[头下标:尾下标]
+
+&emsp;&emsp;索引值以 `0` 为开始值，`-1` 为从末尾的开始位置。
+
+
+&emsp;&emsp;加号 `+` 是字符串的连接符， 星号 `*` 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：
+
+```pyton
+str = 'Waffle'
+
+print (str)          # 输出字符串
+print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
+print (str[0])       # 输出字符串第一个字符
+print (str[2:5])     # 输出从第三个开始到第五个的字符
+print (str[2:])      # 输出从第三个开始的后的所有字符
+print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
+print (str + "TEST") # 连接字符串
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+&emsp;&emsp;`Python` 使用反斜杠 `\` 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 `r`，表示原始字符串：
+
+```shell
+>>> print('Wa\nffle')
+Wa
+ffle
+>>> print(r'Wa\nffle')
+Wa\nffle
+>>>
+```
+
+&emsp;&emsp;另外，反斜杠 `(\)` 可以作为续行符，表示下一行是上一行的延续。也可以使用 `"""..."""` 或者 `'''...'''` 跨越多行。
+
+&emsp;&emsp;注意，`Python` 没有单独的字符类型，一个字符就是长度为 `1` 的字符串。 
+
+```shell
+>>> word = 'Python'
+>>> print(word[0], word[5])
+P n
+>>> print(word[-1], word[-6])
+n P
+```
+
+>注意：与 `C` 字符串不同的是，`Python` 字符串不能被改变。向一个索引位置赋值，比如 `word[0] = 'm'` 会导致错误。 
+
+---
+
+## List(列表)
+
+&emsp;&emsp;`List`（列表） 是 `Python` 中使用最频繁的数据类型。
+
+&emsp;&emsp;列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
+
+&emsp;&emsp;列表是写在方括号 `[]` 之间、用逗号分隔开的元素列表。
+
+&emsp;&emsp;和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
+
+&emsp;&emsp;列表截取的语法格式如下：
+
+```python
+变量[头下标:尾下标]
+```
+
+&emsp;&emsp;索引值以 `0` 为开始值，`-1` 为从末尾的开始位置。
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+&emsp;&emsp;加号 `+` 是列表连接运算符，星号 `*` 是重复操作。如下实例： 
+
+```python
+list = [ 'abcd', 786 , 2.23, 'Waffle', 70.2 ]
+tinylist = [123, 'Nano']
+
+print (list)            # 输出完整列表
+print (list[0])         # 输出列表第一个元素
+print (list[1:3])       # 从第二个开始输出到第三个元素
+print (list[2:])        # 输出从第三个元素开始的所有元素
+print (tinylist * 2)    # 输出两次列表
+print (list + tinylist) # 连接列表
+```
+
+以上实例输出结果：
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+
+&emsp;&emsp;与 `Python` 字符串不一样的是，列表中的元素是可以改变的：
+
+```shell
+>>> a = [1, 2, 3, 4, 5, 6]
+>>> a[0] = 9
+>>> a[2:5] = [13, 14, 15]
+>>> a
+[9, 2, 13, 14, 15, 6]
+>>> a[2:5] = []   # 将对应的元素值设置为 []
+>>> a
+[9, 2, 6]
+```
+
+&emsp;&emsp;`List` 内置了有很多方法，例如 `append()`、`pop()` 等等，这在后面会讲到。
+
+&emsp;&emsp;**注意：**
+- `List` 写在方括号之间，元素用逗号隔开。
+- 和字符串一样，`list` 可以被索引和切片。
+- `List` 可以使用 `+` 操作符进行拼接。
+- `List` 中的元素是可以改变的。
+
+&emsp;&emsp;`Python` 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 `1` 到索引 `4` 的位置并设置为步长为 `2`（间隔一个位置）来截取字符串:
+
+```shell
+>>>L = ['W','a','f','f','l','e']
+>>>L[1:4:2]
+['a','f','e']
+```
+
+&emsp;&emsp;如果第三个参数为 **负数** 表示 **逆向** 读取，以下实例用于翻转字符串：
+
+```python
+def reverseWords(input):
+     
+    # 通过空格将字符串分隔符，把各个单词分隔为列表
+    inputWords = input.split(" ")
+ 
+    # 翻转字符串
+    # 假设列表 list = [1,2,3,4],  
+    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
+    # inputWords[-1::-1] 有三个参数或者input[::-1]效果一样
+    # 第一个参数 -1 表示最后一个元素
+    # 第二个参数为空，表示移动到列表末尾
+    # 第三个参数为步长，-1 表示逆向
+    inputWords=inputWords[-1::-1]
+ 
+    # 重新组合字符串
+    output = ' '.join(inputWords)
+     
+    return output
+ 
+if __name__ == "__main__":
+    input = 'I like Waffle Nano'
+    rw = reverseWords(input)
+    print(rw)
+```
+
+输出结果为：
+
+>Nano Waffle like I
+
+---
+
+## Tuple(元组)
+
+&emsp;&emsp;元组 `（tuple）` 与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 `()` 里，元素之间用逗号隔开。
+
+&emsp;&emsp;元组中的元素类型也可以不相同： 
+
+```python
+tuple = ( 'abcd', 786 , 2.23, 'Waffle', 70.2  )
+tinytuple = (123, 'Nano')
+
+print (tuple)             # 输出完整元组
+print (tuple[0])          # 输出元组的第一个元素
+print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
+print (tuple[2:])         # 输出从第三个元素开始的所有元素
+print (tinytuple * 2)     # 输出两次元组
+print (tuple + tinytuple) # 连接元组
+```
+
+以上实例输出结果：
+
+<center><img src="assets/image/6.png" width="500"/></center>
+
+&emsp;&emsp;元组与字符串类似，可以被索引且下标索引从 `0` 开始， `-1` 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
+
+&emsp;&emsp;其实，可以把字符串看作一种特殊的元组。
+
+```shell
+>>> tup = (1, 2, 3, 4, 5, 6)
+>>> print(tup[0])
+1
+>>> print(tup[1:5])
+(2, 3, 4, 5)
+>>> tup[0] = 11  # 修改元组元素的操作是非法的
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'tuple' object does not support item assignment
+>>>
+```
+
+&emsp;&emsp;虽然 `tuple` 的元素不可改变，但它可以包含可变的对象，比如 `list` 列表。
+
+构造包含 `0` 个或 `1` 个元素的元组比较特殊，所以有一些额外的语法规则： 
+
+```python
+tup1 = ()    # 空元组
+tup2 = (20,) # 一个元素，需要在元素后添加逗号
+```
+
+&emsp;&emsp;`string`、`list` 和 `tuple` 都属于 `sequence`（序列）。
+
+&emsp;&emsp;**注意：**
+- 与字符串一样，元组的元素不能修改。
+- 元组也可以被索引和切片，方法一样。
+- 注意构造包含 `0` 或 `1` 个元素的元组的特殊语法规则。
+- 元组也可以使用 `+` 操作符进行拼接。
+
+---
+
+## Set(集合)
+
+&emsp;&emsp;集合 `（set）` 是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作 **元素** 或是 **成员**。
+
+&emsp;&emsp;基本功能是 **进行成员关系测试** 和 **删除重复元素**。
+
+&emsp;&emsp;可以使用大括号 `{ }` 或者 `set()` 函数创建集合，注意：创建一个空集合必须用 `set()` 而不是 `{ }`，因为 `{ }` 是用来创建一个空字典。
+
+创建格式：
+
+```python
+parame = {value01,value02,...}
+# 或者
+set(value)
+```
+```python
+sites = {'Waffle', 'Nano', 'Micro', 'Labs'}
+
+print(sites)   # 输出集合，重复的元素被自动去掉
+
+# 成员测试
+if 'Waffle' in sites :
+    print('Waffle 在集合中')
+else :
+    print('Waffle 不在集合中')
+
+
+# set可以进行集合运算
+a = set('abracadabra')
+b = set('alacazam')
+
+print(a)
+
+print(a - b)     # a 和 b 的差集
+
+print(a | b)     # a 和 b 的并集
+
+print(a & b)     # a 和 b 的交集
+
+print(a ^ b)     # a 和 b 中不同时存在的元素
+```
+
+以上实例输出结果：
+
+<center><img src="assets/image/7.png" width="500"/></center>
+
+---
+
+## Dictionary(字典)
+
+&emsp;&emsp;字典 `（dictionary）` 是 `Python` 中另一个非常有用的内置数据类型。
+
+&emsp;&emsp;列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
+
+&emsp;&emsp;字典是一种映射类型，字典用 `{ }` 标识，它是一个无序的 键`(key)` : 值`(value)` 的集合。
+
+&emsp;&emsp;键 `(key)` 必须使用不可变类型。
+
+&emsp;&emsp;在同一个字典中，键 `(key)` 必须是唯一的。 
+
+```python
+dict = {}
+dict['one'] = "1 - WaffleNano"
+dict[2]     = "2 - Waffle"
+
+tinydict = {'name': 'Waffle','code':1, 'site': 'https://gitee.com/paniford/waffle_nano_v1_python_api_document'}
+
+
+print (dict['one'])       # 输出键为 'one' 的值
+print (dict[2])           # 输出键为 2 的值
+print (tinydict)          # 输出完整的字典
+print (tinydict.keys())   # 输出所有键
+print (tinydict.values()) # 输出所有值
+```
+
+以上实例输出结果：
+
+<center><img src="assets/image/8.png" width="1000"/></center>
+
+&emsp;&emsp;构造函数 `dict()` 可以直接从键值对序列中构建字典如下：
+
+```python
+>>> dict([('Waffle', 1), ('blackwalnut', 2), ('Taobao', 3)])
+{'Waffle': 1, 'blackwalnut': 2, 'Taobao': 3}
+>>> {x: x**2 for x in (2, 4, 6)}
+{2: 4, 4: 16, 6: 36}
+>>> dict(WaffleNano=1, blackwalnut=2, Taobao=3)
+{'WaffleNano': 1, 'blackwalnut': 2, 'Taobao': 3}
+>>>
+```
+
+&emsp;&emsp;另外，字典类型也有一些内置的函数，例如 `clear()`、`keys()`、`values()` 等。
+
+&emsp;&emsp;**注意：**
+- 字典是一种映射类型，它的元素是键值对。
+- 字典的关键字必须为不可变类型，且不能重复。
+- 创建空字典使用 `{ }`。
+
+---
+
+## Python数据类型转换
+
+&emsp;&emsp;有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
+
+&emsp;&emsp;以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
+
+| 函数 | 描述 |
+| --- | --- |
+| int(x[,base]) | 将 x 转换为一个整数。 |
+| float(x) | 将 x 转换到一个浮点数。 |
+| complex(real[,imag]) | 创建一个复数。 |
+| str(x) | 将对象 x 转换为字符串。 |
+| repr(x) | 将对象 x 转换为表达式字符串。 |
+| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象。 |
+| tuple(s) | 将序列 s 转换为一个元组。 |
+| list(s) | 将序列 s 转换为一个列表。 |
+| set(s) | 转换为可变集合。 |
+| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
+| frozenset(s) | 转换为不可变集合。 |
+| chr(x) | 将一个整数转换为一个字符。 |
+| ord(x) | 将一个字符转换为它的整数值。 |
+| hex(x) | 将一个整数转换为一个十六进制字符串。 |
+| oct(x) | 将一个整数转换为一个八进制字符串。 |
+
+
+
+
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/1.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..dfb808253da8fc5b7719c6f956cceb47ba33f8cb
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/1.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/2.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..5d31e5615789be9d1b2fba7b7e6a2e2ee2eff76a
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/2.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/3.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..05cd3fb3104aff829f4f6c38197c23396e28d6b5
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/3.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/4.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..57e4da714cca0b74db62ecfc6726fb1d0eac0932
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/4.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/5.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d7b80eb6701d119bc9f4d5b1b386e88df3e8d732
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/5.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/6.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/6.png"
new file mode 100644
index 0000000000000000000000000000000000000000..bae925310b40cca3baade332a197795eaea436dd
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/6.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/7.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/7.png"
new file mode 100644
index 0000000000000000000000000000000000000000..c7a9ddeefd8c68328bc99b24cfdd66b02353a438
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/7.png" differ
diff --git "a/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/8.png" "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/8.png"
new file mode 100644
index 0000000000000000000000000000000000000000..fa47a72344ce6cb83ce4eaff3a5c712cb90befb8
Binary files /dev/null and "b/base/Python3\345\237\272\346\234\254\346\225\260\346\215\256\347\261\273\345\236\213/assets/image/8.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/README.md" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7b253441168b89baec9f6a4ff2936db8685efa48
--- /dev/null
+++ "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/README.md"
@@ -0,0 +1,315 @@
+# Python3 基础语法
+
+- [注释](#注释)
+- [行与缩进](#行与缩进)
+- [多行语句](#多行语句)
+- [数字(Number)类型](#数字(Number)类型)
+- [字符串(String)](#字符串(String))
+- [空行](#空行)
+- [等待用户输入](#等待用户输入)
+- [同一行显示多条语句](#同一行显示多条语句)
+- [多个语句构成代码组](#多个语句构成代码组)
+- [print 输出](#print输出)
+- [import 与 from...import](#import与fromimport)
+
+
+
+## 注释
+
+&emsp;&emsp;`Python` 中单行注释以 `#` 开头，实例如下：
+
+```python
+# 第一个注释
+print ("Hello, Python!") 
+# 第二个注释
+print ("Hello, Waffle Nano!")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+<center>(注释)</center>
+
+&emsp;
+
+多行注释可以用多个 `#` 号，还有 `'''` 和 `"""`：
+
+```python3
+# 第一个注释
+# 第二个注释
+ 
+'''
+第三注释
+第四注释
+'''
+ 
+"""
+第五注释
+第六注释
+"""
+print ("Hello, Python!")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+<center>(多行注释)</center>
+
+&emsp;
+
+---
+
+## 行与缩进
+
+&emsp;&emsp;`python` 最具特色的就是使用缩进来表示代码块，不需要使用大括号` {} `。
+
+&emsp;&emsp;缩进的 **空格数** 是可变的，但是同一个代码块的语句必须包含 **相同** 的缩进空格数。实例如下： 
+
+```python
+if True:
+    print ("True")
+else:
+    print ("False")
+```
+
+&emsp;&emsp;以下代码最后一行语句 **缩进数** 的空格数不一致，会导致运行错误：
+
+```python
+if True:
+    print ("Answer")
+    print ("True")
+else:
+    print ("Answer")
+  print ("False")    # 缩进不一致，会导致运行错误
+```
+
+&emsp;&emsp;以上程序由于缩进不一致，执行后会出现类似以下错误：
+
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+<center>(多行注释)</center>
+
+&emsp;
+
+---
+
+## 多行语句
+
+&emsp;&emsp;`Python` 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 `\` 来实现多行语句，例如：
+
+```python
+total = item_one + \
+        item_two + \
+        item_three
+```
+
+&emsp;&emsp;在 `[]`, `{}`, 或 `()` 中的多行语句，不需要使用反斜杠 `\`，例如：
+
+```python
+total = ['item_one', 'item_two', 'item_three',
+        'item_four', 'item_five']
+```
+
+---
+
+## 数字(Number)类型
+
+&emsp;&emsp;`python` 中数字有四种类型：**整数**、**布尔型**、**浮点数** 和**复数**。
+
+- **int** (整数), 如 1, 只有一种整数类型 `int`，表示为长整型，没有 `python2` 中的 `Long`；
+
+- **bool** (布尔), 如 **True**；
+
+- **float** (浮点数), 如 **1.23**、**3E-2**；
+
+- **complex** (复数), 如 **1 + 2j**、 **1.1 + 2.2j**；
+
+---
+
+## 字符串(String)
+
+- `python` 中单引号和双引号使用完全相同；
+
+- 使用三引号(`'''` 或 `"""`)可以指定一个多行字符串；
+
+- 转义符 `\` ；
+
+- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 `r"this is a line with \n"` 则 `\n` 会显示，并不是换行。
+
+- 按字面意义级联字符串，如`"this "` `"is "` `"string"` 会被自动转换为`this is string`。
+
+- 字符串可以用 `+` 运算符连接在一起，用 `*` 运算符重复；
+
+- `Python` 中的字符串有两种索引方式，从左往右以 `0` 开始，从右往左以 `-1` 开始；
+
+- `Python` 中的字符串不能改变；
+
+- `Python` 没有单独的字符类型，一个字符就是长度为 `1` 的字符串；
+
+- 字符串的截取的语法格式如下：`变量[头下标:尾下标]`，开发板中的 python 在对字符操作的时候不支持 `变量[头下标:尾下标:步长]` 这样的操作。
+
+```python
+word = '字符串'
+sentence = "这是一个句子。"
+paragraph = """这是一个段落，
+可以由多行组成"""
+```
+
+```python
+str='123456789'
+ 
+print(str)                 # 输出字符串
+print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
+print(str[0])              # 输出字符串第一个字符
+print(str[2:5])            # 输出从第三个开始到第五个的字符
+print(str[2:])             # 输出从第三个开始后的所有字符
+print(str * 2)             # 输出字符串两次
+print(str + '你好')         # 连接字符串
+ 
+print('------------------------------')
+ 
+print('hello\nWaffleNano')      # 使用反斜杠(\)+n转义特殊字符
+print(r'hello\nWaffleNano')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
+```
+
+&emsp;&emsp;这里的 `r` 指 `raw`，即 `raw string`，会自动将反斜杠转义，例如：
+
+```shell
+>>> print('\n')       # 输出空行
+>>> print(r'\n')      # 输出 \n
+>>> \n
+```
+
+以上实例输出结果：
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+<center>(字符串操作)</center>
+
+&emsp;
+
+---
+
+## 空行
+
+&emsp;&emsp;函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
+
+&emsp;&emsp;空行与代码缩进不同，空行并不是 `Python` 语法的一部分。书写时不插入空行，`Python` 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
+
+&emsp;&emsp;记住：空行也是程序代码的一部分。
+
+---
+
+## 等待用户输入
+
+&emsp;&emsp;执行下面的程序在按回车键后就会等待用户输入：
+
+```python
+input("\n\n按下 enter 键后退出。")
+```
+
+&emsp;&emsp;以上代码中 ， `"\n\n"` 在结果输出前会输出两个新的空行。一旦用户按下 `enter` 键时，程序将退出。
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+<center>(input输入测试)</center>
+
+&emsp;
+
+---
+
+## 同一行显示多条语句
+
+&emsp;&emsp;`Python` 可以在同一行中使用多条语句，语句之间使用分号 `;` 分割，以下是一个简单的实例：
+
+```python
+print("123");print("456")
+```
+
+使用脚本执行以上代码，输出结果为：
+
+<center><img src="assets/image/6.png" width="500"/></center>
+
+<center>(同一行显示多条语句)</center>
+
+&emsp;
+
+---
+
+## 多个语句构成代码组
+
+&emsp;&emsp;缩进相同的一组语句构成一个代码块，我们称之代码组。
+
+&emsp;&emsp;像 `if` 、 `while` 、`def` 和 `class` 这样的复合语句，首行以关键字开始，以冒号 `( : )` 结束，该行之后的一行或多行代码构成代码组。
+
+&emsp;&emsp;我们将首行及后面的代码组称为一个子句`(clause)`。
+
+如下实例：
+
+```python
+if expression : 
+   suite
+elif expression : 
+   suite 
+else : 
+   suite
+```
+
+---
+
+## print输出
+
+&emsp;&emsp;`print` 默认输出是换行的，如果要实现不换行需要在变量末尾加上 `end=""`：
+
+```python
+x="a"
+y="b"
+# 换行输出
+print( x )
+print( y )
+ 
+print('---------')
+# 不换行输出
+print( x, end=" " )
+print( y, end=" " )
+print()
+```
+以上实例执行结果为：
+
+<center><img src="assets/image/7.png" width="500"/></center>
+
+<center>(print 输出)</center>
+
+&emsp;
+
+---
+
+## import与from...import
+
+&emsp;&emsp;在 `python` 用 `import` 或者 `from...import` 来导入相应的模块。
+
+&emsp;&emsp;将整个模块 `(somemodule)` 导入，格式为： `import somemodule`
+
+&emsp;&emsp;从某个模块中导入某个函数,格式为： `from somemodule import somefunction`
+
+&emsp;&emsp;从某个模块中导入多个函数,格式为： `from somemodule import firstfunc, secondfunc, thirdfunc`
+
+&emsp;&emsp;将某个模块中的全部函数导入，格式为： `from somemodule import *`
+
+```python
+import math
+print('================Python import mode==========================')
+print ('数学中的Π为:')
+print (math.pi)
+```
+
+<center><img src="assets/image/8.png" width="500"/></center>
+
+<center>(import 导入)</center>
+
+&emsp;
+
+---
\ No newline at end of file
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/1.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..9f8bf7d3c2c1817efb5a03d64c02a8c82e297a52
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/1.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/2.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..adc326803b11e279d1215415cadc1a60b9ac0d26
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/2.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/3.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..474dc879d112328a64038990377123449429c9aa
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/3.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/4.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d93681b97c4420c0e742a0b807613eede4b52496
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/4.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/5.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..ddc53df503467316b41d03b0ce1f2c54c64aa282
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/5.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/6.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/6.png"
new file mode 100644
index 0000000000000000000000000000000000000000..28dcf59d6f0236450e7d558d133400b6969e1675
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/6.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/7.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/7.png"
new file mode 100644
index 0000000000000000000000000000000000000000..c861c9b5fc105a42cc39430f88567086e3b60b18
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/7.png" differ
diff --git "a/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/8.png" "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/8.png"
new file mode 100644
index 0000000000000000000000000000000000000000..4dd0e783fb7e2841feb777649cfc07336480cf08
Binary files /dev/null and "b/base/Python3\345\237\272\347\241\200\350\257\255\346\263\225/assets/image/8.png" differ
diff --git "a/base/Python3\345\255\227\345\205\270/README.md" "b/base/Python3\345\255\227\345\205\270/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6518557ac052e6d910ff8623c7a2e64da0b85d6b
--- /dev/null
+++ "b/base/Python3\345\255\227\345\205\270/README.md"
@@ -0,0 +1,175 @@
+## Python3字典
+
+- [访问字典里的值](#访问字典里的值)
+- [修改字典](#修改字典)
+- [删除字典元素](#删除字典元素)
+- [字典内置函数](#字典内置函数)
+
+
+
+&emsp;&emsp;字典是另一种可变容器模型，且可存储任意类型对象。
+
+&emsp;&emsp;字典的每个键值 `key=>value` 对用冒号 `:` 分割，每个对之间用逗号 `(,)` 分割，整个字典包括在花括号 `{}` 中 ,格式如下所示： 
+
+```python
+d = {key1 : value1, key2 : value2, key3 : value3 }
+```
+
+
+&emsp;&emsp;键必须是唯一的，但值则不必。
+
+&emsp;&emsp;值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
+
+&emsp;&emsp;一个简单的字典实例：
+
+```python
+dict = {'name': 'Waffle', 'likes': 123}
+```
+
+&emsp;&emsp;也可如此创建字典：
+
+```python
+dict1 = { 'abc': 456 }
+dict2 = { 'abc': 123, 98.6: 37 }
+```
+---
+
+## 访问字典里的值
+
+&emsp;&emsp;把相应的键放入到方括号中，如下实例:
+
+```python
+dict = {'Name': 'Waffle', 'Age': 7, 'Class': 'First'}
+ 
+print ("dict['Name']: ", dict['Name'])
+print ("dict['Age']: ", dict['Age'])
+```
+
+&emsp;&emsp;以上实例输出结果：
+
+```shell
+dict['Name']:  Waffle
+dict['Age']:  7
+```
+
+&emsp;&emsp;如果用字典里没有的键访问数据，会输出错误如下：
+
+```python
+dict = {'Name': 'Waffle', 'Age': 7, 'Class': 'First'}
+ 
+print ("dict['Alice']: ", dict['Alice'])
+```
+
+以上实例输出结果：
+
+```python
+Traceback (most recent call last):
+  File "test.py", line 3, in <module>
+    print ("dict['Alice']: ", dict['Alice'])
+KeyError: 'Alice'
+```
+
+---
+
+## 修改字典
+
+&emsp;&emsp;向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
+
+```python
+dict = {'Name': 'Waffle', 'Age': 7, 'Class': 'First'}
+ 
+dict['Age'] = 8               # 更新 Age
+dict['School'] = "黑胡桃实验室"  # 添加信息
+ 
+ 
+print ("dict['Age']: ", dict['Age'])
+print ("dict['School']: ", dict['School'])
+```
+
+以上实例输出结果： 
+
+```shell
+dict['Age']:  8
+dict['School']:  黑胡桃实验室
+```
+
+---
+
+## 删除字典元素
+
+&emsp;&emsp;能删单一的元素也能清空字典，清空只需一项操作。
+
+&emsp;&emsp;显示删除一个字典用 `del` 命令，如下实例：
+
+```python
+dict = {'Name': 'Waffle', 'Age': 7, 'Class': 'First'}
+ 
+del dict['Name'] # 删除键 'Name'
+dict.clear()     # 清空字典
+del dict         # 删除字典
+ 
+print ("dict['Age']: ", dict['Age'])
+print ("dict['School']: ", dict['School'])
+```
+
+&emsp;&emsp;但这会引发一个异常，因为用执行 `del` 操作后字典不再存在：
+
+```shell
+Traceback (most recent call last):
+  File "<stdin>", line 7, in <module>
+TypeError: 'type' object isn't subscriptable
+```
+
+注：`del()` 方法后面也会讨论。
+
+**字典键的特性**
+
+&emsp;&emsp;字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
+
+&emsp;&emsp;两个重要的点需要记住：
+
+1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
+
+```python
+dict = {'Name': 'Waffle', 'Age': 7, 'Name': '黑胡桃'}
+ 
+print ("dict['Name']: ", dict['Name'])
+```
+
+以上实例输出结果：
+
+```shell
+dict['Name']:  黑胡桃
+```
+
+2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
+
+```python
+dict = {['Name']: 'Waffle', 'Age': 7}
+ 
+print ("dict['Name']: ", dict['Name'])
+```
+
+以上实例输出结果：
+
+```shell
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: unsupported type for __hash__: 'list'
+```
+
+---
+
+## 字典内置函数
+
+&emsp;&emsp;Python字典包含了以下内置函数：
+
+| 序号 | 函数 | 描述 |
+| --- | --- | --- |
+| 1 | len(dict) | 计算字典元素个数，即键的总数。|
+| 2 | str(dict) | 输出字典，以可打印的字符串表示。 |
+| 3 | 	type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。| 
+
+
+
+
diff --git "a/base/Python3\345\255\227\347\254\246\344\270\262/README.md" "b/base/Python3\345\255\227\347\254\246\344\270\262/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1a068b1bc56f99073b046de3ffa1663cac2adf78
--- /dev/null
+++ "b/base/Python3\345\255\227\347\254\246\344\270\262/README.md"
@@ -0,0 +1,232 @@
+# Python3 字符串
+
+- [Python访问字符串中的值](#Python访问字符串中的值)
+- [Python字符串更新](#Python字符串更新)
+- [Python转义字符](#Python转义字符)
+- [Python字符串运算符](#Python字符串运算符)
+- [Python字符串格式化](#Python字符串格式化)
+- [Python三引号](#Python三引号)
+- [Unicode字符串](#Unicode字符串)
+
+&emsp;&emsp;字符串是 `Python` 中最常用的数据类型。我们可以使用引号( `'` 或 `"` )来创建字符串。
+
+&emsp;&emsp;创建字符串很简单，只要为变量分配一个值即可。例如：
+
+```python
+var1 = 'Hello World!'
+var2 = "Runoob"
+```
+---
+
+## Python访问字符串中的值
+
+&emsp;&emsp;`Python` 不支持单字符类型，单字符在 `Python` 中也是作为一个字符串使用。
+
+&emsp;&emsp;`Python` 访问子字符串，可以使用方括号 `[]` 来截取字符串，字符串的截取的语法格式如下：
+
+```
+变量[头下标:尾下标]
+```
+
+&emsp;&emsp;索引值以 `0` 为开始值，`-1` 为从末尾的开始位置。
+
+如下实例：
+
+```python
+var1 = 'Hello World!'
+var2 = "Waffle Nano"
+ 
+print ("var1[0]: ", var1[0])
+print ("var2[1:5]: ", var2[1:5])
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+---
+
+## Python字符串更新
+
+&emsp;&emsp;你可以截取字符串的一部分并与其他字段拼接，如下实例：
+
+```python
+var1 = 'Hello World!'
+ 
+print ("已更新字符串 : ", var1[:6] + 'Waffle!')
+```
+
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+---
+
+## Python转义字符
+
+&emsp;&emsp;在需要在字符中使用特殊字符时，`python` 用反斜杠 `\` 转义字符。如下表：
+
+| 转义字符 | 描述 | 实例 |
+| --- | --- | --- |
+| `\`(在行尾时) | 续行符 | `>>> print("line1 \ `<br>`... line2 \` <br>`... line3")`<br>`line1 line2 line3`<br>`>>>` |
+| `\\` | 反斜杠符号 | `>>> print("\\")` <br> `\`|
+| `\'` | 单引号 | `>>> print('\'')`<br>`'`|
+| `\"` | 双引号 | `>>> print('\"')`<br>`"` |
+| `\b` | 退格`(Backspace)`  | `>>> print("Hello \b World!")` <br> `Hello World` |
+| `\000` |  空 | `>>> print("\000")` <br> `>>>`|
+| `\n` | 换行 | `>>> print("\n")`<br><br>`>>>`|
+| `\v` | 纵向制表符 | `>>> print("Hello \v World!")`<br>Hello<br>&emsp;&emsp;&emsp;World!<br>`>>>` |
+| `\t` | 横向制表符 | `>>> print("Hello \t World!")` <br> Hello      World! <br>`>>>`|
+| `\r` |  回车，将 `\r` 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 `\r` 后面的内容完全替换完成。| `>>> print("Hello\rWorld!")` <br> `World!` |
+| `\f` | 换页 | `>>> print("Hello \v World!")`<br>Hello<br>&emsp;&emsp;&emsp;World!<br>`>>>` |
+| `\yyy` | 八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 | `>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")`<br> `Hello World!` |
+| `\xyy` |  十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 | `>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")` <br> `Hello World!` |
+| `\other` | 其它的字符以普通格式输出 | |
+
+---
+
+## Python字符串运算符
+
+&emsp;&emsp;下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
+
+| 操作符 | 描述 | 实例 |
+| --- | --- | --- |
+| + | 字符串连接 | a + b 输出结果： HelloPython |
+| * | 重复输出字符串 | a*2 输出结果：HelloHello |
+| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e | 
+| [ : ] | 截取字符串中的一部分，遵循 **左闭右开** 原则，str[0:2] 是不包含第 3 个字符的。| 	a[1:4] 输出结果 `ell` |
+| in | 	成员运算符 : 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
+| not in  | 成员运算符 : 如果字符串中不包含给定的字符返回 True |  	'M' not in a 输出结果 True |
+| r | 原始字符串 : 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 `r`（可以大小写）以外，与普通字符串有着几乎完全相同的语法。| `print( r'\n' )` |
+| % | 格式字符串 | |
+
+实例如下：
+
+```python
+a = "Hello"
+b = "Python"
+ 
+print("a + b 输出结果：", a + b)
+print("a * 2 输出结果：", a * 2)
+print("a[1] 输出结果：", a[1])
+print("a[1:4] 输出结果：", a[1:4])
+ 
+if( "H" in a) :
+    print("H 在变量 a 中")
+else :
+    print("H 不在变量 a 中")
+ 
+if( "M" not in a) :
+    print("M 不在变量 a 中")
+else :
+    print("M 在变量 a 中")
+ 
+print (r'\n')
+```
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+---
+
+## Python字符串格式化
+
+&emsp;&emsp;`Python` 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 `%s` 的字符串中。
+
+&emsp;&emsp;在 `Python` 中，字符串格式化使用与 `C` 中 `sprintf` 函数一样的语法。
+
+```python
+print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
+```
+
+以上实例输出结果：
+
+> 我叫 小明 今年 10 岁!
+
+python字符串格式化符号:
+
+| 符 号 | 描 述|
+| --- | --- |
+| %c | 格式化字符及其ASCII码 |
+| %s | 格式化字符串 | 
+| %d | 格式化整数 |
+| %u | 格式化无符号整型 |
+| %o | 格式化无符号八进制数 | 
+| %x | 格式化无符号十六进制数 |
+| %X | 格式化无符号十六进制数（大写） |
+| %f | 格式化浮点数字，可指定小数点后的精度 |
+| %e | 用科学计数法格式化浮点数 |
+| %E | 作用同%e，用科学计数法格式化浮点数 |
+| %g | %f和%e的简写 |
+| %G | %f 和 %E 的简写 |
+| %p | 用十六进制数格式化变量的地址 |
+
+格式化操作符辅助指令:
+
+| 符 号 | 功 能|
+| --- | --- |
+| * | 定义宽度或者小数点精度  |
+| - | 用做左对齐  |
+| + | 在正数前面显示加号( + )  |
+| `<sp>` | 在正数前面显示空格 |
+| # | 	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')|
+| 0 | 显示的数字前面填充'0'而不是默认的空格  |
+| % | '%%'输出一个单一的'%' |
+| (var) | 映射变量(字典参数) |
+| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)|
+
+---
+
+## Python三引号 
+
+&emsp;&emsp;`python` 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下:
+
+```python
+para_str = """这是一个多行字符串的实例
+多行字符串可以使用制表符
+TAB ( \t )。
+也可以使用换行符 [ \n ]。
+"""
+print (para_str)
+```
+
+以上实例执行结果为：
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+&emsp;&emsp;三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
+
+&emsp;&emsp;一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
+
+
+```
+errHTML = '''
+<HTML><HEAD><TITLE>
+Friends CGI Demo</TITLE></HEAD>
+<BODY><H3>ERROR</H3>
+<B>%s</B><P>
+<FORM><INPUT TYPE=button VALUE=Back
+ONCLICK="window.history.back()"></FORM>
+</BODY></HTML>
+'''
+cursor.execute('''
+CREATE TABLE users (  
+login VARCHAR(8), 
+uid INTEGER,
+prid INTEGER)
+''')
+```
+
+
+---
+
+## Unicode字符串
+
+&emsp;&emsp;在 `Python2` 中，普通字符串是以 `8` 位 `ASCII` 码进行存储的，而 `Unicode` 字符串则存储为 `16` 位 `unicode` 字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 `u`。
+
+&emsp;&emsp;在 `Python3` 中，所有的字符串都是 `Unicode` 字符串。 
+
+ 
+
diff --git "a/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/1.png" "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..e770be1c6d732b1a169cb2cf94e93ffec23c7c1b
Binary files /dev/null and "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/1.png" differ
diff --git "a/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/2.png" "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..282526d9407d84ff1ac8991edb3f7bc6ff125fe2
Binary files /dev/null and "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/2.png" differ
diff --git "a/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/3.png" "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..325b107db3725d13c6e2a020ba2e7ce82145cbd1
Binary files /dev/null and "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/3.png" differ
diff --git "a/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/4.png" "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..f2b2bd0dbb8ae61071767c2816194ed7d80caf21
Binary files /dev/null and "b/base/Python3\345\255\227\347\254\246\344\270\262/assets/image/4.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/README.md" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3df9f4267ce3d234af22df696a7736767d1456b1
--- /dev/null
+++ "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/README.md"
@@ -0,0 +1,427 @@
+# Python3 循环语句
+
+- [while循环](#while循环)
+- [无限循环](#无限循环)
+- [while循环使用else语句](#while循环使用else语句)
+- [简单语句组](#简单语句组)
+- [for语句](#for语句)
+- [range()函数](#range()函数)
+- [break和continue语句及循环中的else子句](#break和continue语句及循环中的else子句)
+- [pass语句](#pass语句)
+
+
+本章节将为大家介绍 Python 循环语句的使用。
+
+Python 中的循环语句有 for 和 while。
+
+---
+
+## while循环 
+
+Python 中 while 语句的一般形式：
+
+```
+while 判断条件(condition)：
+    执行语句(statements)……
+```
+
+执行 Gif 演示：
+
+<center><img src="assets/image/1.gif" width="500"/></center>
+
+同样需要注意冒号和缩进。另外，在 `Python` 中没有 `do..while` 循环。 
+
+以下实例使用了 while 来计算 1 到 100 的总和：
+
+```python
+n = 100
+ 
+sum = 0
+counter = 1
+while counter <= n:
+    sum = sum + counter
+    counter += 1
+ 
+print("1 到 %d 之和为: %d" % (n,sum))
+```
+
+执行结果如下：
+
+```
+1 到 100 之和为: 5050
+```
+
+---
+
+## 无限循环
+
+我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：
+
+```python
+var = 1
+while var == 1 :  # 表达式永远为 true
+   num = int(input("输入一个数字  :"))
+   print ("你输入的数字是: ", num)
+ 
+print ("Good bye!")
+```
+
+执行以上脚本，输出结果如下：
+
+```
+输入一个数字  :5
+你输入的数字是:  5
+输入一个数字  :
+```
+
+你可以使用 `CTRL+C` 来退出当前的无限循环。
+
+无限循环在服务器上客户端的实时请求非常有用。
+
+---
+
+## while循环使用else语句
+
+如果 while 后面的条件语句为 false 时，则执行 else 的语句块。
+
+语法格式如下：
+
+```
+while <expr>:
+    <statement(s)>
+else:
+    <additional_statement(s)>
+```
+
+
+expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。
+
+循环输出数字，并判断大小：
+
+```python
+count = 0
+while count < 5:
+   print (count, " 小于 5")
+   count = count + 1
+else:
+   print (count, " 大于或等于 5")
+```
+
+执行以上代码输出结果如下：
+
+```
+0  小于 5
+1  小于 5
+2  小于 5
+3  小于 5
+4  小于 5
+5  大于或等于 5
+```
+---
+
+## 简单语句组
+
+类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：
+
+```python
+flag = 1
+ 
+while (flag): print ('欢迎使用Waffle Nano!')
+ 
+print ("Good bye!")
+```
+
+注意：以上的无限循环你可以使用 CTRL+C 来中断循环。
+
+&emsp;&emsp;执行以上程序会输出如下结果：
+
+```shell
+欢迎使用Waffle Nano!
+欢迎使用Waffle Nano!
+欢迎使用Waffle Nano!
+欢迎使用Waffle Nano!
+欢迎使用Waffle Nano!
+...
+```
+
+---
+
+## for语句
+
+Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。
+
+for循环的一般格式如下：
+
+```
+for <variable> in <sequence>:
+    <statements>
+else:
+    <statements>
+```
+
+Python for 循环实例：
+
+```shell
+>>>languages = ["C", "C++", "Perl", "Python"] 
+>>> for x in languages:
+...     print (x)
+... 
+C
+C++
+Perl
+Python
+>>>
+```
+
+以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：
+
+```python
+sites = ["Baidu", "Google","Waffle","Taobao"]
+for site in sites:
+    if site == "Waffle":
+        print("黑胡桃!")
+        break
+    print("循环数据 " + site)
+else:
+    print("没有循环数据!")
+print("完成循环!")
+```
+
+执行以上代码输出结果如下：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+---
+
+## range()函数
+
+如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如: 
+
+```shell
+>>>for i in range(5):
+...     print(i)
+...
+0
+1
+2
+3
+4
+```
+
+你也可以使用range指定区间的值：
+
+```shell
+>>>for i in range(5,9) :
+    print(i) 
+5
+6
+7
+8
+>>>
+```
+
+也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'): 
+
+```shell
+>>>for i in range(0, 10, 3) :
+    print(i)
+ 
+    
+0
+3
+6
+9
+>>>
+```
+
+负数：
+
+```shell
+>>>for i in range(-10, -100, -30) :
+    print(i)
+ 
+    
+-10
+-40
+-70
+>>>
+```
+
+您可以结合range()和len()函数以遍历一个序列的索引,如下所示:
+
+```shell
+>>>a = ['Google', 'Baidu', 'Waffle', 'Taobao', 'QQ']
+>>> for i in range(len(a)):
+...     print(i, a[i])
+... 
+0 Google
+1 Baidu
+2 Waffle
+3 Taobao
+4 QQ
+>>>
+```
+
+还可以使用range()函数来创建一个列表：
+
+```shell
+>>>list(range(5))
+[0, 1, 2, 3, 4]
+>>>
+```
+
+---
+
+## break和continue语句及循环中的else子句 
+
+while 语句代码执行过程：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
+
+continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。 
+
+实例如下：
+
+while 中使用 break：
+
+```python
+n = 5
+while n > 0:
+    n -= 1
+    if n == 2:
+        break
+    print(n)
+print('循环结束。')
+```
+
+输出结果为：
+
+```
+4
+3
+循环结束。
+```
+
+while 中使用 continue：
+
+```python
+n = 5
+while n > 0:
+    n -= 1
+    if n == 2:
+        continue
+    print(n)
+print('循环结束。')
+```
+
+输出结果为：
+
+```
+4
+3
+1
+0
+循环结束。
+```
+
+更多实例如下：
+
+```python
+for letter in 'Waffle':     # 第一个实例
+   if letter == 'b':
+      break
+   print ('当前字母为 :', letter)
+  
+var = 10                    # 第二个实例
+while var > 0:              
+   print ('当期变量值为 :', var)
+   var = var -1
+   if var == 5:
+      break
+ 
+print ("Good bye!")
+```
+
+执行以上代码输出结果如下：
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+以下实例循环字符串 Waffle，碰到字母 f 跳过输出： 
+
+```python
+for letter in 'Waffle':     # 第一个实例
+   if letter == 'f':        # 字母为 o 时跳过输出
+      continue
+   print ('当前字母 :', letter)
+ 
+var = 10                    # 第二个实例
+while var > 0:              
+   var = var -1
+   if var == 5:             # 变量为 5 时跳过输出
+      continue
+   print ('当前变量值 :', var)
+print ("Good bye!")
+```
+
+执行以上代码输出结果如下：
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。
+
+如下实例用于查询质数的循环例子:
+
+```python
+for n in range(2, 10):
+    for x in range(2, n):
+        if n % x == 0:
+            print(n, '等于', x, '*', n//x)
+            break
+    else:
+        # 循环中没有找到元素
+        print(n, ' 是质数')
+```
+
+执行以上脚本输出结果为：
+
+执行以上代码输出结果如下：
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+---
+
+## pass语句
+
+Python pass是空语句，是为了保持程序结构的完整性。
+
+pass 不做任何事情，一般用做占位语句，如下实例
+
+```
+>>>while True:
+...     pass  # 等待键盘中断 (Ctrl+C)
+```
+
+最小的类:
+
+```
+>>>class MyEmptyClass:
+...     pass
+```
+
+以下实例在字母为 f 时 执行 pass 语句块:
+
+```python
+for letter in 'Waffle': 
+   if letter == 'f':
+      pass
+      print ('执行 pass 块')
+   print ('当前字母 :', letter)
+ 
+print ("Good bye!")
+```
+
+执行以上代码输出结果如下：
+
+<center><img src="assets/image/6.png" width="500"/></center>
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.gif" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.gif"
new file mode 100644
index 0000000000000000000000000000000000000000..9aebb3b3d1e63dc3f6fab8b980c1575261f3fdb5
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.gif" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b5d080b207e5f42617ca4860ebdb3d1b74425f68
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/1.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/2.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..2ee1bb916f1fbd07da28be606c1bb28d0a8b673c
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/2.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/3.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..dc0bf6f761ab467c48ade201d0e2cd01915414df
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/3.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/4.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..48a6e6c73ad9ce8adf04f5536315d02a35341ccf
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/4.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/5.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..1da8104e4813d2f19f75b4c9e7bbd7f5c522bc96
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/5.png" differ
diff --git "a/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/6.png" "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/6.png"
new file mode 100644
index 0000000000000000000000000000000000000000..6b2b56880c1a7e5ca1cb8bd56712817861b80e75
Binary files /dev/null and "b/base/Python3\345\276\252\347\216\257\350\257\255\345\217\245/assets/image/6.png" differ
diff --git "a/base/Python3\346\225\260\345\255\227(Number)/README.md" "b/base/Python3\346\225\260\345\255\227(Number)/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9e568a1728b9f028365587efc68747eab0ad5d18
--- /dev/null
+++ "b/base/Python3\346\225\260\345\255\227(Number)/README.md"
@@ -0,0 +1,240 @@
+# Python3 数字(Number)
+
+- [数字类型转换](#数字类型转换)
+- [Python数字运算](#Python数字运算)
+- [数学函数](#数学函数)
+- [三角函数](#三角函数)
+- [数学常量](#数学常量)
+
+
+&emsp;&emsp;`Python` 数字数据类型用于存储数值。
+
+&emsp;&emsp;数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
+
+&emsp;&emsp;以下实例在变量赋值时 `Number` 对象将被创建：
+
+```python
+var1 = 1
+var2 = 10
+```
+
+&emsp;&emsp;您也可以使用 `del` 语句删除一些数字对象的引用。
+
+&emsp;&emsp;`del` 语句的语法是：
+
+```python
+del var1[,var2[,var3[....,varN]]]
+```
+
+&emsp;&emsp;您可以通过使用del语句删除单个或多个对象的引用，例如：
+
+```python
+del var
+del var_a, var_b
+```
+
+&emsp;&emsp;Python 支持三种不同的数值类型：
+
+- **整型(int)**: 通常被称为是整型或整数，是正或负整数，不带小数点。`Python3` 整型是没有限制大小的，可以当作 `Long` 类型使用，所以 `Python3` 没有 `Python2` 的 `Long` 类型。布尔(`bool`)是整型的子类型。
+
+- **浮点型(float)**: 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示 `（2.5e2 = 2.5 x 102 = 250）`。
+
+- **复数( (complex))**： 复数由实数部分和虚数部分构成，可以用 `a + bj`,或者 `complex(a,b)` 表示， 复数的实部 `a` 和虚部 `b` 都是浮点型。
+
+&emsp;&emsp;我们可以使用 **十六进制** 和 **八进制** 来代表整数：
+
+```shell
+>>> number = 0xA0F # 十六进制
+>>> number
+2575
+
+>>> number=0o37 # 八进制
+>>> number
+31
+```
+
+| int | float | complex |
+| --- | --- | --- |
+| 10 | 0.0 | 3.14j |
+| 100 | 15.20 | 45.j |
+| -786 | -21.9 | 9.322e-36j | 
+| 080 | 32.3e+18 | .876j |
+| -0490 | -90 | -.6545+0J |
+| -0x260 | -32.54e100 | 3e+26j |
+| 0x69 | 70.2E-12 | 4.53e-7j |
+
+- `Python` 支持复数，复数由实数部分和虚数部分构成，可以用 `a + bj`,或者 `complex(a,b)` 表示， 复数的实部 `a` 和虚部 `b` 都是浮点型。 
+
+---
+
+## 数字类型转换
+
+&emsp;&emsp;有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
+
+- **int(x)** ：将 `x` 转换为一个整数。
+- **float(x)**： 将 `x` 转换到一个浮点数。
+- **complex(x)**： 将x转换到一个复数，实数部分为 `x`，虚数部分为 `0`。
+- **complex(x, y)**： 将 `x` 和 `y` 转换到一个复数，实数部分为 `x`，虚数部分为 `y`。`x` 和 `y` 是数字表达式。
+
+&emsp;&emsp;以下实例将浮点数变量 `a` 转换为整数：
+
+```shell
+>>> a = 1.0
+>>> int(a)
+1
+```
+---
+
+## Python数字运算
+
+&emsp;&emsp;`Python` 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
+
+&emsp;&emsp;表达式的语法很直白： `+`, `-`, `*` 和` /`, 和其它语言（如 `Pascal` 或 `C`）里一样。例如：
+
+```shell
+>>> 2 + 2
+4
+>>> 50 - 5*6
+20
+>>> (50 - 5*6) / 4
+5.0
+>>> 8 / 5  # 总是返回一个浮点数
+1.6
+```
+
+&emsp;&emsp;**注意：**在不同的机器上浮点运算的结果可能会不一样。
+
+&emsp;&emsp;在整数除法中，除法 `/` 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 `//` ：
+
+```shell
+>>> 17 / 3  # 整数除法返回浮点型
+5.666666666666667
+>>>
+>>> 17 // 3  # 整数除法返回向下取整后的结果
+5
+>>> 17 % 3  # ％操作符返回除法的余数
+2
+>>> 5 * 3 + 2 
+17
+```
+
+&emsp;&emsp;**注意：** `//` 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
+
+
+```shell
+>>> 7//2
+3
+>>> 7.0//2
+3.0
+>>> 7//2.0
+3.0
+>>> 
+```
+
+&emsp;&emsp;等号 `=` 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。
+
+```shell
+>>> width = 20
+>>> height = 5*9
+>>> width * height
+900
+```
+
+&emsp;&emsp;`Python` 可以使用 `**` 操作来进行幂运算：
+
+```shell
+>>> 5 ** 2  # 5 的平方
+25
+>>> 2 ** 7  # 2的7次方
+128
+```
+
+&emsp;&emsp;变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：
+
+
+```shell
+>>> n   # 尝试访问一个未定义的变量
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'n' is not defined
+```
+
+&emsp;&emsp;不同类型的数混合运算时会将整数转换为浮点数：
+
+```shell
+>>> 3 * 3.75 / 1.5
+7.5
+>>> 7.0 / 2
+3.5
+```
+
+&emsp;&emsp;在交互模式中，最后被输出的表达式结果被赋值给变量 `_` 。例如： 
+
+
+```shell
+>>> tax = 12.5 / 100
+>>> price = 100.50
+>>> price * tax
+12.5625
+>>> price + _
+113.0625
+>>> round(_, 2)
+113.06
+```
+
+&emsp;&emsp;此处，`_` 变量应被用户视为只读变量。 
+
+---
+
+## 数学函数
+
+&emsp;&emsp;随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
+
+&emsp;&emsp;`Python` 包含以下常用随机数函数：
+
+| 函数 | 返回值（描述）|
+| --- | --- |
+| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
+| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
+| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x > y)-(x < y) 替换。 |
+| exp(x) | 	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
+| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回 10.0 |
+| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
+| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
+| log10(x)  | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
+| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。|
+| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
+| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。|
+| pow(x, y) | x**y 运算后的值。|
+| round(x [ ,n]) | 	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。<br>其实准确的说是保留值将保留到离上一位更近的一端。|
+| sqrt(x) | 返回数字x的平方根。|
+
+---
+
+## 三角函数
+
+&emsp;&emsp;`Python` 包括以下三角函数：
+
+| 函数 | 描述 |
+| --- | --- |
+| acos(x) | 返回x的反余弦弧度值。|
+| asin(x) |	返回x的反正弦弧度值。|
+| atan(x) | 返回x的反正切弧度值。|
+| atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。|
+| cos(x) | 	返回x的弧度的余弦值。|
+| hypot(x, y) | 返回欧几里德范数 sqrt(x * x + y * y)。|
+| sin(x) | 返回的x弧度的正弦值。|
+| tan(x) | 返回x弧度的正切值。|
+| degrees(x) | 将弧度转换为角度,如 degrees(math.pi/2) ， 返回 90.0 。 |
+| radians(x) | 将角度转换为弧度。|
+
+---
+
+## 数学常量
+
+| 常量 | 描述 |
+| --- | --- |
+| pi | 数学常量 pi（圆周率，一般以π来表示） |
+| e | 数学常量 e，e即自然常数（自然常数）。|
+
+
diff --git "a/base/Python3\346\225\260\346\215\256\347\273\223\346\236\204/README.md" "b/base/Python3\346\225\260\346\215\256\347\273\223\346\236\204/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2833fe9f57e12fc7ef4ec3e82108903238ce6ca8
--- /dev/null
+++ "b/base/Python3\346\225\260\346\215\256\347\273\223\346\236\204/README.md"
@@ -0,0 +1,385 @@
+# Python3 数据结构
+
+- [列表](#列表)
+- [将列表当做堆栈使用](#将列表当做堆栈使用)
+- [列表推导式](#列表推导式)
+- [嵌套列表解析](#嵌套列表解析)
+- [del语句](#del语句)
+- [元组和序列](#元组和序列)
+- [集合](#集合)
+- [字典](#字典)
+- [遍历技巧](#遍历技巧)
+
+
+本章节我们主要结合前面所学的知识点来介绍Python数据结构。
+
+---
+
+## 列表
+
+Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
+
+以下是 Python 中列表的方法：
+
+| 方法 | 描述 |
+| --- | --- |
+| list.append(x) | 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 |
+| list.extend(L)  | 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。 |
+| list.insert(i, x)  | 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。 |
+| list.pop([i])  |从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。） |
+| list.clear()  |  	移除列表中的所有项，等于del a[:]。 |
+| list.index(x) | 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。 |
+| list.count(x) | 返回 x 在列表中出现的次数。 |
+| list.sort()  | 对列表中的元素进行排序。  |
+| list.reverse() | 	倒排列表中的元素。|
+| list.copy() | 返回列表的浅复制，等于a[:]。 |
+
+下面示例演示了列表的大部分方法：
+
+```shell
+>>> a = [66.25, 333, 333, 1, 1234.5]
+>>> print(a.count(333), a.count(66.25), a.count('x'))
+2 1 0
+>>> a.insert(2, -1)
+>>> a.append(333)
+>>> a
+[66.25, 333, -1, 333, 1, 1234.5, 333]
+>>> a.index(333)
+1
+>>> a.remove(333)
+>>> a
+[66.25, -1, 333, 1, 1234.5, 333]
+>>> a.reverse()
+>>> a
+[333, 1234.5, 1, 333, -1, 66.25]
+>>> a.sort()
+>>> a
+[-1, 1, 66.25, 333, 333, 1234.5]
+```
+
+注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。
+
+---
+
+## 将列表当做堆栈使用
+
+列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如： 
+
+```python
+>>> stack = [3, 4, 5]
+>>> stack.append(6)
+>>> stack.append(7)
+>>> stack
+[3, 4, 5, 6, 7]
+>>> stack.pop()
+7
+>>> stack
+[3, 4, 5, 6]
+>>> stack.pop()
+6
+>>> stack.pop()
+5
+>>> stack
+[3, 4]
+```
+
+---
+
+## 列表推导式
+
+列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
+
+每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
+
+这里我们将列表中每个数值乘三，获得一个新的列表：
+
+```python
+>>> vec = [2, 4, 6]
+>>> [3*x for x in vec]
+[6, 12, 18]
+```
+
+现在我们玩一点小花样：
+
+```python
+>>> [[x, x**2] for x in vec]
+[[2, 4], [4, 16], [6, 36]]
+```
+
+这里我们对序列里每一个元素逐个调用某方法： 
+
+```
+>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
+>>> [weapon.strip() for weapon in freshfruit]
+['banana', 'loganberry', 'passion fruit']
+```
+
+我们可以用 if 子句作为过滤器： 
+
+```python
+>>> [3*x for x in vec if x > 3]
+[12, 18]
+>>> [3*x for x in vec if x < 2]
+[]
+```
+
+以下是一些关于循环和其它技巧的演示：
+
+```python
+>>> vec1 = [2, 4, 6]
+>>> vec2 = [4, 3, -9]
+>>> [x*y for x in vec1 for y in vec2]
+[8, 6, -18, 16, 12, -36, 24, 18, -54]
+>>> [x+y for x in vec1 for y in vec2]
+[6, 5, -7, 8, 7, -5, 10, 9, -3]
+>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
+[8, 12, -54]
+```
+
+---
+
+## 嵌套列表解析
+
+Python的列表还可以嵌套。
+
+以下实例展示了3X4的矩阵列表：
+
+```python
+>>> matrix = [
+...     [1, 2, 3, 4],
+...     [5, 6, 7, 8],
+...     [9, 10, 11, 12],
+... ]
+```
+
+以下实例将3X4的矩阵列表转换为4X3列表：
+
+```python
+>>> [[row[i] for row in matrix] for i in range(4)]
+[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
+```
+
+以下实例也可以使用以下方法来实现：
+
+```python
+>>> transposed = []
+>>> for i in range(4):
+...     transposed.append([row[i] for row in matrix])
+...
+>>> transposed
+[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
+```
+
+另外一种实现方法：
+
+```python
+>>> transposed = []
+>>> for i in range(4):
+...     # the following 3 lines implement the nested listcomp
+...     transposed_row = []
+...     for row in matrix:
+...         transposed_row.append(row[i])
+...     transposed.append(transposed_row)
+...
+>>> transposed
+[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
+```
+
+---
+
+## del语句
+使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如： 
+
+```python
+>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
+>>> del a[0]
+>>> a
+[1, 66.25, 333, 333, 1234.5]
+>>> del a[2:4]
+>>> a
+[1, 66.25, 1234.5]
+>>> del a[:]
+>>> a
+[]
+```
+
+也可以用 del 删除实体变量：
+
+```python
+>>> del a
+```
+
+---
+
+## 元组和序列 
+
+元组由若干逗号分隔的值组成，例如： 
+
+```python
+>>> t = 12345, 54321, 'hello!'
+>>> t[0]
+12345
+>>> t
+(12345, 54321, 'hello!')
+>>> # Tuples may be nested:
+... u = t, (1, 2, 3, 4, 5)
+>>> u
+((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
+```
+
+如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。
+
+---
+
+## 集合
+
+集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
+
+可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。
+
+以下是一个简单的演示：
+
+```python
+>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
+>>> print(basket)                      # 删除重复的
+{'orange', 'banana', 'pear', 'apple'}
+>>> 'orange' in basket                 # 检测成员
+True
+>>> 'crabgrass' in basket
+False
+
+>>> # 以下演示了两个集合的操作
+...
+>>> a = set('abracadabra')
+>>> b = set('alacazam')
+>>> a                                  # a 中唯一的字母
+{'a', 'r', 'b', 'c', 'd'}
+>>> a - b                              # 在 a 中的字母，但不在 b 中
+{'r', 'd', 'b'}
+>>> a | b                              # 在 a 或 b 中的字母
+{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
+>>> a & b                              # 在 a 和 b 中都有的字母
+{'a', 'c'}
+>>> a ^ b                              # 在 a 或 b 中的字母，但不同时在 a 和 b 中
+{'r', 'd', 'b', 'm', 'z', 'l'}
+```
+
+集合也支持推导式：
+
+```python
+>>> a = {x for x in 'abracadabra' if x not in 'abc'}
+>>> a
+{'r', 'd'}
+```
+---
+
+## 字典
+
+另一个非常有用的 Python 内建数据类型是字典。
+
+序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
+
+理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
+
+一对大括号创建一个空的字典：{}。
+
+这是一个字典运用的简单例子： 
+
+```python
+>>> tel = {'jack': 4098, 'sape': 4139}
+>>> tel['guido'] = 4127
+>>> tel
+{'sape': 4139, 'guido': 4127, 'jack': 4098}
+>>> tel['jack']
+4098
+>>> del tel['sape']
+>>> tel['irv'] = 4127
+>>> tel
+{'guido': 4127, 'irv': 4127, 'jack': 4098}
+>>> list(tel.keys())
+['irv', 'guido', 'jack']
+>>> sorted(tel.keys())
+['guido', 'irv', 'jack']
+>>> 'guido' in tel
+True
+>>> 'jack' not in tel
+False
+```
+
+构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
+
+```python
+>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
+{'sape': 4139, 'jack': 4098, 'guido': 4127}
+```
+
+此外，字典推导可以用来创建任意键和值的表达式词典：
+
+```python
+>>> dict(sape=4139, guido=4127, jack=4098)
+{'sape': 4139, 'jack': 4098, 'guido': 4127}
+```
+---
+
+## 遍历技巧
+
+在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来： 
+
+```python
+>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
+>>> for k, v in knights.items():
+...     print(k, v)
+...
+gallahad the pure
+robin the brave
+```
+
+在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
+
+```python
+>>> for i, v in enumerate(['tic', 'tac', 'toe']):
+...     print(i, v)
+...
+0 tic
+1 tac
+2 toe
+```
+
+同时遍历两个或更多的序列，可以使用 zip() 组合： 
+
+```shell
+>>> questions = ['name', 'quest', 'favorite color']
+>>> answers = ['lancelot', 'the holy grail', 'blue']
+>>> for q, a in zip(questions, answers):
+...     print('What is your {0}?  It is {1}.'.format(q, a))
+...
+What is your name?  It is lancelot.
+What is your quest?  It is the holy grail.
+What is your favorite color?  It is blue.
+```
+
+要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数： 
+
+```python
+>>> for i in reversed(range(1, 10, 2)):
+...     print(i)
+...
+9
+7
+5
+3
+1
+```
+
+要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值： 
+
+```python
+>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
+>>> for f in sorted(set(basket)):
+...     print(f)
+...
+apple
+banana
+orange
+pear
+```
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/README.md" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8219a959329d7705a14839d332cd4675cb20b067
--- /dev/null
+++ "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/README.md"
@@ -0,0 +1,196 @@
+# Python3 条件控制
+
+- [if语句](#if语句)
+- [修改元组](#修改元组)
+- [删除元组](#删除元组)
+- [元组运算符](#元组运算符)
+- [元组索引，截取](#元组索引截取)
+- [元组内置函数](#元组内置函数)
+
+&emsp;&emsp;Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。
+
+可以通过下图来简单了解条件语句的执行过程:
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+---
+
+## if语句
+
+&emsp;&emsp;`Python` 中 `if` 语句的一般形式如下所示：
+
+```python
+if condition_1:
+    statement_block_1
+elif condition_2:
+    statement_block_2
+else:
+    statement_block_3
+```
+
+- 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
+
+- 如果 "condition_1" 为False，将判断 "condition_2"
+
+- 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
+
+- 如果 "condition_2" 为False，将执行"statement_block_3"块语句
+
+&emsp;&emsp;`Python` 中用 `elif` 代替了 `else if`，所以 `if` 语句的关键字为：`if – elif – else`。
+
+**注意：**
+
+- 1、每个条件后面要使用冒号 `:`，表示接下来是满足条件后要执行的语句块。
+
+- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
+
+- 3、在Python中没有switch – case语句。
+
+Gif 演示：
+
+<center><img src="assets/image/1.gif" width="500"/></center>
+
+实例演示：
+
+以下是一个简单的 `if` 实例：
+
+```python
+var1 = 100
+if var1:
+    print ("1 - if 表达式条件为 true")
+    print (var1)
+ 
+var2 = 0
+if var2:
+    print ("2 - if 表达式条件为 true")
+    print (var2)
+print ("Good bye!")
+```
+
+执行以上代码，输出结果为：
+
+```shell
+1 - if 表达式条件为 true
+100
+Good bye!
+```
+
+&emsp;&emsp;从结果可以看到由于变量 `var2` 为 `0`，所以对应的 `if` 内的语句没有执行。
+
+&emsp;&emsp;以下实例演示了狗的年龄计算判断：
+
+```python
+age = int(input("请输入你家狗狗的年龄: "))
+print("")
+if age <= 0:
+    print("你是在逗我吧!")
+elif age == 1:
+    print("相当于 14 岁的人。")
+elif age == 2:
+    print("相当于 22 岁的人。")
+elif age > 2:
+    human = 22 + (age -2)*5
+    print("对应人类年龄: ", human)
+ 
+### 退出提示
+input("点击 enter 键退出")
+```
+
+&emsp;&emsp;执行以上程序并 **输入** `1` 会输出如下结果：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+以下为if中常用的操作运算符:
+
+| 操作符 | 描述 |
+| --- | --- |
+| < | 小于 |
+| <= |  小于或等于 |
+| > | 大于 |
+| >= | 大于或等于 |
+| == | 等于，比较两个值是否相等 |
+| != | 不等于 |
+
+实例如下：
+
+```python
+# 程序演示了 == 操作符
+# 使用数字
+print(5 == 6)
+# 使用变量
+x = 5
+y = 8
+print(x == y)
+```
+
+以上实例输出结果：
+
+```shell
+False
+False
+```
+
+数字的比较运算：
+
+```python
+# 该实例演示了数字猜谜游戏
+number = 7
+guess = -1
+print("数字猜谜游戏!")
+while guess != number:
+    guess = int(input("请输入你猜的数字："))
+ 
+    if guess == number:
+        print("恭喜，你猜对了！")
+    elif guess < number:
+        print("猜的数字小了...")
+    elif guess > number:
+        print("猜的数字大了...")
+```
+
+执行以上脚本，实例输出结果如下： 
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+---
+
+## if嵌套
+
+&emsp;&emsp;在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。 
+
+```
+if 表达式1:
+    语句
+    if 表达式2:
+        语句
+    elif 表达式3:
+        语句
+    else:
+        语句
+elif 表达式4:
+    语句
+else:
+    语句
+```
+
+实例如下：
+
+```python
+num=int(input("输入一个数字："))
+if num%2==0:
+    if num%3==0:
+        print ("你输入的数字可以整除 2 和 3")
+    else:
+        print ("你输入的数字可以整除 2，但不能整除 3")
+else:
+    if num%3==0:
+        print ("你输入的数字可以整除 3，但不能整除 2")
+    else:
+        print  ("你输入的数字不能整除 2 和 3")
+```
+
+执行以上代码实例输出结果如下： 
+
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.gif" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.gif"
new file mode 100644
index 0000000000000000000000000000000000000000..6c1eeeb4710c8dd3eff16f6569c130ff51c37df6
Binary files /dev/null and "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.gif" differ
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.png" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..609da3b0e7c283e9e86fa04e7ffdf7ec48f199ed
Binary files /dev/null and "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/1.png" differ
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/2.png" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..16bf1b7d93c11393ef83b0017009022d1b462731
Binary files /dev/null and "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/2.png" differ
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/3.png" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..f4fc084895202aef5a119ee25e9e92404a5824f2
Binary files /dev/null and "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/3.png" differ
diff --git "a/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/4.png" "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..4bc0cd8a6422ddbfac5110e19c050982b1c1bd25
Binary files /dev/null and "b/base/Python3\346\235\241\344\273\266\346\216\247\345\210\266/assets/image/4.png" differ
diff --git "a/base/Python3\346\250\241\345\235\227/README.md" "b/base/Python3\346\250\241\345\235\227/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6108754c187737fd6de67575b39795d6197bf607
--- /dev/null
+++ "b/base/Python3\346\250\241\345\235\227/README.md"
@@ -0,0 +1,81 @@
+# Python3 模块
+
+
+
+在前面的几个章节中我们基本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。
+
+为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
+
+---
+
+## import语句
+想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
+
+```python
+import module1[, module2[,... moduleN]
+```
+
+当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
+
+一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
+
+搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。做一个简单的实验，我们在桌面创建一个文本文件 `(fibo.txt)`，打开后输入:
+
+```python
+def fib(n):    # 定义到 n 的斐波那契数列
+    a, b = 0, 1
+    while b < n:
+        print(b, end=' ')
+        a, b = b, a+b
+    print()
+ 
+def fib2(n): # 返回到 n 的斐波那契数列
+    result = []
+    a, b = 0, 1
+    while b < n:
+        result.append(b)
+        a, b = b, a+b
+    return result
+```
+
+然后将文本文件保存后关闭，并重命名为 `fibo.py`。
+
+<center><img src="assets/image/1.png" width="300"/></center>
+
+然后打开我们的在线编程界面，选择右上角更多中的上传文件，将刚刚创建的 `fibo.py` 上传至开发板中，如下图所示：
+
+
+<center><img src="assets/image/2.png" width="1000"/></center>
+
+<center><img src="assets/image/3.png" width="1000"/></center>
+
+
+<center><img src="assets/image/4.png" width="1000"/></center>
+
+然后进入Python解释器，使用下面的命令导入这个模块：
+
+```python
+import fibo
+```
+
+这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。
+
+可以使用模块名称来访问函数： 
+
+```python
+>>>fibo.fib(1000)
+1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
+>>> fibo.fib2(100)
+[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
+>>> fibo.__name__
+'fibo'
+```
+如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：
+
+```python
+>>> fib = fibo.fib
+>>> fib(500)
+1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+
diff --git "a/base/Python3\346\250\241\345\235\227/assets/image/1.png" "b/base/Python3\346\250\241\345\235\227/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..8ba8c2ade1596a383b467c62b46f9e2a27ec97ad
Binary files /dev/null and "b/base/Python3\346\250\241\345\235\227/assets/image/1.png" differ
diff --git "a/base/Python3\346\250\241\345\235\227/assets/image/2.png" "b/base/Python3\346\250\241\345\235\227/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..3045ba38dc31c30ad67b012ab170525aa65e3df5
Binary files /dev/null and "b/base/Python3\346\250\241\345\235\227/assets/image/2.png" differ
diff --git "a/base/Python3\346\250\241\345\235\227/assets/image/3.png" "b/base/Python3\346\250\241\345\235\227/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..d97be44799c08579d68b5de3427c64a8b6fa1775
Binary files /dev/null and "b/base/Python3\346\250\241\345\235\227/assets/image/3.png" differ
diff --git "a/base/Python3\346\250\241\345\235\227/assets/image/4.png" "b/base/Python3\346\250\241\345\235\227/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..b3bf25a9d1978a00317dcf88a2b45cbbc018f478
Binary files /dev/null and "b/base/Python3\346\250\241\345\235\227/assets/image/4.png" differ
diff --git "a/base/Python3\346\263\250\351\207\212/README.md" "b/base/Python3\346\263\250\351\207\212/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fc9e43f9b5338d4cc76c8379f4229bd610d6d7c0
--- /dev/null
+++ "b/base/Python3\346\263\250\351\207\212/README.md"
@@ -0,0 +1,50 @@
+# Python3 注释
+
+&emsp;&emsp;确保对模块, 函数, 方法和行内注释使用正确的风格
+
+&emsp;&emsp;`Python` 中的注释有单行注释和多行注释：
+
+&emsp;&emsp;`Python` 中单行注释以 `#` 开头，例如：
+
+```python
+# 这是一个注释
+print("Hello, World!")
+```
+
+**1、单引号（'''）**
+
+```python
+'''
+这是多行注释，用三个单引号
+这是多行注释，用三个单引号 
+这是多行注释，用三个单引号
+'''
+print("Hello, World!")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+<center>(注释)</center>
+
+&emsp;
+
+**2、双引号（"""）**
+
+```python
+"""
+这是多行注释，用三个双引号
+这是多行注释，用三个双引号 
+这是多行注释，用三个双引号
+"""
+print("Hello, World!")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+<center>(注释)</center>
+
+&emsp;
diff --git "a/base/Python3\346\263\250\351\207\212/assets/image/1.png" "b/base/Python3\346\263\250\351\207\212/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..376996c9dc2fa06ba31d47774d975fbeb7f1cbbe
Binary files /dev/null and "b/base/Python3\346\263\250\351\207\212/assets/image/1.png" differ
diff --git "a/base/Python3\350\276\223\345\205\245\345\222\214\350\276\223\345\207\272/README.md" "b/base/Python3\350\276\223\345\205\245\345\222\214\350\276\223\345\207\272/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c2c0fb6fdea5f75b859d80c2ae1d58aa5497ce3d
--- /dev/null
+++ "b/base/Python3\350\276\223\345\205\245\345\222\214\350\276\223\345\207\272/README.md"
@@ -0,0 +1,134 @@
+# Python3 输入和输出
+
+- [输出格式美化](#输出格式美化)
+- [旧式字符串格式化](#旧式字符串格式化)
+- [读取键盘输入](#读取键盘输入)
+
+---
+
+## 输出格式美化
+
+Python两种输出值的方式: 表达式语句和 print() 函数。
+
+第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
+
+如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
+
+如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
+
+- str()： 函数返回一个用户易读的表达形式。
+- repr()： 产生一个解释器易读的表达形式。
+
+实例如下：
+
+```python
+>>> s = 'Hello, Waffle'
+>>> str(s)
+'Hello, Waffle'
+>>> repr(s)
+"'Hello, Waffle'"
+>>> str(1/7)
+'0.14285714285714285'
+>>> x = 10 * 3.25
+>>> y = 200 * 200
+>>> s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'
+>>> print(s)
+x 的值为： 32.5,  y 的值为：40000...
+>>> #  repr() 函数可以转义字符串中的特殊字符
+... hello = 'hello, Waffle\n'
+>>> hellos = repr(hello)
+>>> print(hellos)
+'hello, Waffle\n'
+>>> # repr() 的参数可以是 Python 的任何对象
+... repr((x, y, ('Google', 'Waffle')))
+"(32.5, 40000, ('Google', 'Waffle'))"
+```
+
+注意：在第一个例子中, 每列间的空格由 print() 添加。
+
+str.format() 的基本使用如下:
+
+```python
+>>> print('{} "{}!"'.format('WaffleNano', 'WOW'))
+WaffleNano "WOW!"
+```
+
+位置及关键字参数可以任意的结合: 
+
+```python
+>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Waffle', other='Taobao'))
+Google, Waffle,  Taobao
+```
+
+`!a` (使用 `ascii()`), `!s` (使用 `str()`) 和 `!r` (使用 `repr()`) 可以用于在格式化某个值之前对其进行转化:
+
+```python
+>>> import math
+>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
+常量 PI 的值近似为： 3.141592653589793。
+>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
+常量 PI 的值近似为： 3.141592653589793。
+```
+
+可选项 `:` 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 `Pi` 保留到小数点后三位：
+
+```python
+>>> import math
+>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
+常量 PI 的值近似为 3.142。
+```
+
+在 `:` 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。 
+
+```python
+>>> table = {'Google': 1, 'Waffle': 2, 'Taobao': 3}
+>>> for name, number in table.items():
+...     print('{0:10} ==> {1:10d}'.format(name, number))
+...
+Taobao     ==>          3
+Waffle     ==>          2
+Google     ==>          1
+```
+
+也可以通过在 table 变量前使用 `**` 来实现相同的功能：
+
+```python
+>>> table = {'Google': 1, 'Waffle': 2, 'Taobao': 3}
+>>> print('Waffle: {Waffle:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
+Waffle: 2; Google: 1; Taobao: 3
+```
+
+---
+
+## 旧式字符串格式化
+
+`%` 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如: 
+
+```python
+>>> import math
+>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
+常量 PI 的值近似为：3.142。
+```
+
+因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format(). 
+
+--- 
+
+## 读取键盘输入
+
+Python 提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。
+
+
+```python
+str = input("请输入：")
+print ("你输入的内容是: ", str)
+```
+
+这会产生如下的对应着输入的结果： 
+
+```
+请输入：Waffle Nano
+你输入的内容是:  Waffle Nano
+```
+---
+
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/README.md" "b/base/Python3\350\277\220\347\256\227\347\254\246/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ba477ea50e36d826ee787d17a457c5103a382907
--- /dev/null
+++ "b/base/Python3\350\277\220\347\256\227\347\254\246/README.md"
@@ -0,0 +1,497 @@
+# Python3 运算符
+
+- [什么是运算符](#什么是运算符)
+- [Python算数运算符](#Python算数运算符)
+- [比较（关系）运算符](#比较（关系）运算符)
+- [赋值运算符](#赋值运算符)
+- [逻辑运算符](#逻辑运算符)
+- [位运算符](#位运算符)
+- [成员运算符](#成员运算符)
+- [身份运算符](#身份运算符)
+- [运算符优先级](#运算符优先级)
+
+
+
+## 什么是运算符
+
+&emsp;&emsp;本章节主要说明 Python 的运算符。
+
+&emsp;&emsp;举个简单的例子：
+
+```
+4 + 5 = 9
+```
+
+&emsp;&emsp;例子中，`4` 和 `5` 被成为 **操作数**，`+` 称为运算符。
+
+&emsp;&emsp;`Python` 语言支持以下类型的运算符：
+
+- [算术运算符](#Python算数运算符)
+- [比较（关系）运算符](#比较（关系）运算符)
+- [赋值运算符](#赋值运算符)
+- [逻辑运算符](#逻辑运算符)
+- [位运算符](#位运算符)
+- [成员运算符](#成员运算符)
+- [身份运算符](#身份运算符)
+- [运算符优先级](#运算符优先级)
+
+---
+## Python算数运算符
+
+&emsp;&emsp;以下假设变量 `a=10` ,变量 `b=21`:
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| + | 加法：两个对象相加 | a + b 输出结果 31 |
+| - | 减法：得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
+| * | 乘法：两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
+| / | 除法：两个对象相除 | b/a 输出结果 2.1  |
+| % | 取模：返回除法的余数 | b % a 输出结果 1|
+| ** | 幂：返回 x 的 y 次幂 | a ** b 的 10 的 21 次方 |
+| // | 取整数：向下取接近商的整数 | >>> 9//2<br>4<br>>>>-9//2<br>-5|
+
+&emsp;&emsp;以下实例演示了 `Python` 所有算术运算符的操作：
+
+```python
+a = 21
+b = 10
+c = 0
+ 
+c = a + b
+print ("1 - c 的值为：", c)
+ 
+c = a - b
+print ("2 - c 的值为：", c)
+ 
+c = a * b
+print ("3 - c 的值为：", c)
+ 
+c = a / b
+print ("4 - c 的值为：", c)
+ 
+c = a % b
+print ("5 - c 的值为：", c)
+ 
+# 修改变量 a 、b 、c
+a = 2
+b = 3
+c = a**b 
+print ("6 - c 的值为：", c)
+ 
+a = 10
+b = 5
+c = a//b 
+print ("7 - c 的值为：", c)
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+
+---
+
+## 比较（关系）运算符
+
+&emsp;&emsp;以下假设变量 `a` 为 `10`，变量 `b` 为 `20`：
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| == | 等于：比较对象是否相等 | (a==b)返回False。|
+| != | 不等于：比较两个对象是否不相等 | (1!=b)返回True。|
+| > | 大于：返回 x 是否大于 y | (a>b)返回False。|
+| < | 小于：返回 x 是否小于 y。所有比较运算符返回 1 代表真，返回 0 代表假。这分别与特殊的变量 True 与 False 等价。注意： 这些变量名的大写。| (a < b)返回True。|
+| >= | 大于等于：返回x是否大于等于y。 | 	(a >= b) 返回 False。|
+| <= | 小于等于：返回x是否小于等于y。| (a <= b) 返回 True。 |
+
+&emsp;&emsp;以下实例演示了 `Python` 所有比较运算符的操作：
+
+```python
+a = 21
+b = 10
+c = 0
+ 
+if ( a == b ):
+   print ("1 - a 等于 b")
+else:
+   print ("1 - a 不等于 b")
+ 
+if ( a != b ):
+   print ("2 - a 不等于 b")
+else:
+   print ("2 - a 等于 b")
+ 
+if ( a < b ):
+   print ("3 - a 小于 b")
+else:
+   print ("3 - a 大于等于 b")
+ 
+if ( a > b ):
+   print ("4 - a 大于 b")
+else:
+   print ("4 - a 小于等于 b")
+ 
+# 修改变量 a 和 b 的值
+a = 5
+b = 20
+if ( a <= b ):
+   print ("5 - a 小于等于 b")
+else:
+   print ("5 - a 大于  b")
+ 
+if ( b >= a ):
+   print ("6 - b 大于等于 a")
+else:
+   print ("6 - b 小于 a")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+
+---
+
+## 赋值运算符
+
+&emsp;&emsp;以下假设变量 `a` 为 `10`，变量 `b` 为 `20`：
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+| += | 加法赋值运算符 | c += a 等效于 c = c + a |
+| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
+| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
+| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
+| %= | 	取模赋值运算符 | c %= a 等效于 c = c % a | 
+| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
+| //= | 取整除赋值运算符 | 	c //= a 等效于 c = c // a |
+
+&emsp;&emsp;以下实例演示了 `Python` 所有赋值运算符的操作：
+
+```python
+a = 21
+b = 10
+c = 0
+ 
+c = a + b
+print ("1 - c 的值为：", c)
+ 
+c += a
+print ("2 - c 的值为：", c)
+ 
+c *= a
+print ("3 - c 的值为：", c)
+ 
+c /= a 
+print ("4 - c 的值为：", c)
+ 
+c = 2
+c %= a
+print ("5 - c 的值为：", c)
+ 
+c **= a
+print ("6 - c 的值为：", c)
+ 
+c //= a
+print ("7 - c 的值为：", c)
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+---
+## 逻辑运算符
+
+&emsp;&emsp;以下假设变量 `a` 为 `10`，变量 `b` 为 `20`：
+
+| 运算符 | 逻辑表达式 | 描述 | 实例 |
+| --- | --- | --- | --- |
+| and | x and y | 布尔"与" : 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。| (a and b) 返回 20。|
+| or | 	x or y | 布尔"或":  如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。| (a or b) 返回 10。|
+| not | not x | 布尔"非" : 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。| not(a and b) 返回 False |
+
+&emsp;&emsp;以下实例演示了 `Python` 所有逻辑运算符的操作：
+
+```python
+a = 10
+b = 20
+ 
+if ( a and b ):
+   print ("1 - 变量 a 和 b 都为 true")
+else:
+   print ("1 - 变量 a 和 b 有一个不为 true")
+ 
+if ( a or b ):
+   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
+else:
+   print ("2 - 变量 a 和 b 都不为 true")
+ 
+# 修改变量 a 的值
+a = 0
+if ( a and b ):
+   print ("3 - 变量 a 和 b 都为 true")
+else:
+   print ("3 - 变量 a 和 b 有一个不为 true")
+ 
+if ( a or b ):
+   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
+else:
+   print ("4 - 变量 a 和 b 都不为 true")
+ 
+if not( a and b ):
+   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
+else:
+   print ("5 - 变量 a 和 b 都为 true")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+---
+## 位运算符
+
+&emsp;&emsp;按位运算符是把数字看作二进制来进行计算的。`Python` 中的按位运算法则如下：
+
+&emsp;&emsp;下表中变量 `a` 为 `60`，`b` 为 `13` 二进制格式如下：
+
+```
+a = 0011 1100
+
+b = 0000 1101
+
+-----------------
+
+a&b = 0000 1100
+
+a|b = 0011 1101
+
+a^b = 0011 0001
+
+~a  = 1100 0011
+```
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
+| &#124; | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a &#124; b) 输出结果 61 ，二进制解释： 0011 1101 |
+| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
+| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。`~x` 类似于 `-x-1` |
+| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。| a << 2 输出结果 240 ，二进制解释： 1111 0000 |
+| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
+
+&emsp;&emsp;以下实例演示了 `Python` 所有位运算符的操作：
+
+```python
+a = 60            # 60 = 0011 1100 
+b = 13            # 13 = 0000 1101 
+c = 0
+ 
+c = a & b        # 12 = 0000 1100
+print ("1 - c 的值为：", c)
+ 
+c = a | b        # 61 = 0011 1101 
+print ("2 - c 的值为：", c)
+ 
+c = a ^ b        # 49 = 0011 0001
+print ("3 - c 的值为：", c)
+ 
+c = ~a           # -61 = 1100 0011
+print ("4 - c 的值为：", c)
+ 
+c = a << 2       # 240 = 1111 0000
+print ("5 - c 的值为：", c)
+ 
+c = a >> 2       # 15 = 0000 1111
+print ("6 - c 的值为：", c)
+```
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+---
+## 成员运算符
+
+&emsp;&emsp;除了以上的一些运算符之外，`Python` 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| in | 如果在指定的序列中找到值返回 True，否则返回 False。| x 在 y 序列中 , 如果 x 在 y 序列中返回 True。|
+| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。| x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。|
+
+&emsp;&emsp;以下实例演示了 `Python` 所有成员运算符的操作：
+
+```python
+a = 10
+b = 20
+list = [1, 2, 3, 4, 5 ]
+ 
+if ( a in list ):
+   print ("1 - 变量 a 在给定的列表中 list 中")
+else:
+   print ("1 - 变量 a 不在给定的列表中 list 中")
+ 
+if ( b not in list ):
+   print ("2 - 变量 b 不在给定的列表中 list 中")
+else:
+   print ("2 - 变量 b 在给定的列表中 list 中")
+ 
+# 修改变量 a 的值
+a = 2
+if ( a in list ):
+   print ("3 - 变量 a 在给定的列表中 list 中")
+else:
+   print ("3 - 变量 a 不在给定的列表中 list 中")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/6.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+---
+## 身份运算符
+
+&emsp;&emsp;身份运算符用于比较两个对象的存储单元。
+
+| 运算符 | 描述 | 实例 |
+| --- | --- | --- |
+| is | 	is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
+| is not | 	is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
+
+>注： id() 函数用于获取对象内存地址。
+
+&emsp;&emsp;以下实例演示了 `Python` 所有身份运算符的操作：
+
+```python
+a = 20
+b = 20
+ 
+if ( a is b ):
+   print ("1 - a 和 b 有相同的标识")
+else:
+   print ("1 - a 和 b 没有相同的标识")
+ 
+if ( id(a) == id(b) ):
+   print ("2 - a 和 b 有相同的标识")
+else:
+   print ("2 - a 和 b 没有相同的标识")
+ 
+# 修改变量 b 的值
+b = 30
+if ( a is b ):
+   print ("3 - a 和 b 有相同的标识")
+else:
+   print ("3 - a 和 b 没有相同的标识")
+ 
+if ( a is not b ):
+   print ("4 - a 和 b 没有相同的标识")
+else:
+   print ("4 - a 和 b 有相同的标识")
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/7.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+is 与 == 区别：
+
+is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
+
+```shell
+>>>a = [1, 2, 3]
+>>> b = a
+>>> b is a 
+True
+>>> b == a
+True
+>>> b = a[:]
+>>> b is a
+False
+>>> b == a
+True
+```
+
+---
+## 运算符优先级
+
+&emsp;&emsp;以下表格列出了从最高到最低优先级的所有运算符：
+
+| 运算符 | 描述 |
+| --- | --- |
+| ** | 指数 (最高优先级) |
+| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
+| * / % // | 乘，除，求余数和取整除 |
+| + - | 加法减法 |
+| >> << | 右移，左移运算符 |
+| & | 位 'AND' |
+| ^ &#124; | 位运算符 |
+| <= < > >= | 比较运算符 |
+| == != | 等于运算符 |
+| = %= /= //= -= += *= **= | 赋值运算符 |
+| is is not | 身份运算符 |
+| in not in | 成员运算符 |
+| not and or | 逻辑运算符 |
+
+&emsp;&emsp;以下实例演示了Python所有运算符优先级的操作：
+
+```python
+a = 20
+b = 10
+c = 15
+d = 5
+e = 0
+ 
+e = (a + b) * c / d       #( 30 * 15 ) / 5
+print ("(a + b) * c / d 运算结果为：",  e)
+ 
+e = ((a + b) * c) / d     # (30 * 15 ) / 5
+print ("((a + b) * c) / d 运算结果为：",  e)
+ 
+e = (a + b) * (c / d)    # (30) * (15/5)
+print ("(a + b) * (c / d) 运算结果为：",  e)
+ 
+e = a + (b * c) / d      #  20 + (150/5)
+print ("a + (b * c) / d 运算结果为：",  e)
+```
+
+执行以上代码，输出结果为：
+
+<center><img src="assets/image/8.png" width="500"/></center>
+
+<center>(运算结果)</center>
+
+&emsp;&emsp;and 拥有更高优先级:
+
+```python
+x = True
+y = False
+z = False
+ 
+if x or y and z:
+    print("yes")
+else:
+    print("no")
+```
+
+以上实例输出结果：
+
+>yes
+
+
+
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/1.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..6a79930a350c4d2bbeea5aaeedc923c75d780722
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/1.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/2.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..049373b073a49d41fc2e2ee51058e4c1d1ede51d
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/2.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/3.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..ba75230f557f89e9198f4f0ee9b1b44a2760d2d5
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/3.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/4.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..38be87066045a34b43d700c907250dd1a2b91aca
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/4.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/5.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..1df7c5ae507e690f899b43f344e2a5277a9e3a02
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/5.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/6.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/6.png"
new file mode 100644
index 0000000000000000000000000000000000000000..7f895ce1af17dbe05b274f3ec66476478013148e
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/6.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/7.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/7.png"
new file mode 100644
index 0000000000000000000000000000000000000000..444d944954d835ad8bbeae8e1c05e0b63b12fcb4
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/7.png" differ
diff --git "a/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/8.png" "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/8.png"
new file mode 100644
index 0000000000000000000000000000000000000000..2dc9040cffb26b826e472cc789745cc37b195ecd
Binary files /dev/null and "b/base/Python3\350\277\220\347\256\227\347\254\246/assets/image/8.png" differ
diff --git "a/base/Python3\350\277\255\344\273\243\345\231\250\344\270\216\347\224\237\346\210\220\345\231\250/README.md" "b/base/Python3\350\277\255\344\273\243\345\231\250\344\270\216\347\224\237\346\210\220\345\231\250/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..950a9894de4dca69235a0f6d5082cdf881612719
--- /dev/null
+++ "b/base/Python3\350\277\255\344\273\243\345\231\250\344\270\216\347\224\237\346\210\220\345\231\250/README.md"
@@ -0,0 +1,209 @@
+# Python3迭代器与生成器
+
+- [迭代器](#迭代器)
+- [创建一个迭代器](#创建一个迭代器)
+- [StopIteration](#StopIteration)
+- [生成器](#生成器)
+
+
+## 迭代器
+
+迭代是Python最强大的功能之一，是访问集合元素的一种方式。
+
+迭代器是一个可以记住遍历的位置的对象。
+
+迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
+
+迭代器有两个基本的方法：`iter()` 和 `next()`。
+
+字符串，列表或元组对象都可用于创建迭代器：
+
+```shell
+>>> list=[1,2,3,4]
+>>> it = iter(list)    # 创建迭代器对象
+>>> print (next(it))   # 输出迭代器的下一个元素
+1
+>>> print (next(it))
+2
+>>>
+```
+
+迭代器对象可以使用常规for语句进行遍历：
+
+```python
+list=[1,2,3,4]
+it = iter(list)    # 创建迭代器对象
+for x in it:
+    print (x, end=" ")
+```
+
+执行以上程序，输出结果如下：
+
+```
+1 2 3 4
+```
+
+也可以使用 next() 函数：
+
+```python
+list=[1,2,3,4]
+it = iter(list)    # 创建迭代器对象
+ 
+while True:
+    try:
+        print (next(it))
+    except StopIteration:
+        print("超出列表范围")
+        break
+```
+
+执行以上程序，输出结果如下：
+```
+1
+2
+3
+4
+```
+
+---
+
+## 创建一个迭代器
+
+把一个类作为一个迭代器使用需要在类中实现两个方法 `__iter__()` 与 `__next__()` 。
+
+如果你已经了解的面向对象编程，就知道类都有一个构造函数，`Python` 的构造函数为 `__init__()`, 它会在对象初始化的时候执行。
+
+`__iter__()` 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 `__next__()` 方法并通过 `StopIteration` 异常标识迭代的完成。
+
+`__next__()` 方法（`Python 2` 里是 `next()`）会返回下一个迭代器对象。
+
+创建一个返回数字的迭代器，初始值为 `1`，逐步递增 `1`：
+
+```python
+class MyNumbers:
+  def __iter__(self):
+    self.a = 1
+    return self
+ 
+  def __next__(self):
+    x = self.a
+    self.a += 1
+    return x
+ 
+myclass = MyNumbers()
+myiter = iter(myclass)
+ 
+print(next(myiter))
+print(next(myiter))
+print(next(myiter))
+print(next(myiter))
+print(next(myiter))
+```
+
+执行输出结果为：
+
+```
+1
+2
+3
+4
+5
+```
+
+---
+
+## StopIteration
+
+`StopIteration` 异常用于标识迭代的完成，防止出现无限循环的情况，在 `__next__()` 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
+
+在 `20` 次迭代后停止执行：
+
+```python
+class MyNumbers:
+  def __iter__(self):
+    self.a = 1
+    return self
+ 
+  def __next__(self):
+    if self.a <= 20:
+      x = self.a
+      self.a += 1
+      return x
+    else:
+      raise StopIteration
+ 
+myclass = MyNumbers()
+myiter = iter(myclass)
+ 
+for x in myiter:
+  print(x)
+```
+
+执行输出结果为：
+
+```
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+```
+
+---
+
+## 生成器
+
+在 Python 中，使用了 yield 的函数被称为生成器（generator）。
+
+跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
+
+在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
+
+调用一个生成器函数，返回的是一个迭代器对象。
+
+以下实例使用 yield 实现斐波那契数列：
+
+```python
+def fibonacci(n): # 生成器函数 - 斐波那契
+    a, b, counter = 0, 1, 0
+    while True:
+        if (counter > n): 
+            return
+        yield a
+        a, b = b, a + b
+        counter += 1
+f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
+ 
+while True:
+    try:
+        print (next(f), end=" ")
+    except StopIteration:
+        print("执行完成")
+        break
+```
+
+执行以上程序，输出结果如下：
+
+```
+0 1 1 2 3 5 8 13 21 34 55 执行完成
+```
+
+
+
+
+
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/README.md" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f10ed4b4f351c0879d84c5ad1c308070ee263369
--- /dev/null
+++ "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/README.md"
@@ -0,0 +1,321 @@
+## Python3 错误和异常
+
+- [语法错误](#语法错误)
+- [异常](#异常)
+- [异常处理](#异常处理)
+- [抛出异常](#抛出异常)
+- [用户自定义异常](#用户自定义异常)
+- [定义清理行为](#定义清理行为)
+
+作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。
+
+Python 有两种错误很容易辨认：语法错误和异常。
+
+Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。
+
+<center><img src="assets/image/1.png" width="500"/></center>
+
+## 语法错误
+
+Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例:
+
+```python
+>>> while True print('Hello world')
+Traceback (most recent call last):
+  File "<stdin>", line 1
+SyntaxError: invalid syntax
+```
+
+这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 `:` 。
+
+语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。
+
+## 异常
+
+即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
+
+大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
+
+```python
+>>> 10 * (1/0)             # 0 不能作为除数，触发异常
+Traceback (most recent call last):
+  File "<stdin>", line 1, in ?
+ZeroDivisionError: division by zero
+>>> 4 + spam*3             # spam 未定义，触发异常
+Traceback (most recent call last):
+  File "<stdin>", line 1, in ?
+NameError: name 'spam' is not defined
+>>> '2' + 2               # int 不能与 str 相加，触发异常
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: can only concatenate str (not "int") to str
+```
+
+异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。
+
+错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。 
+
+## 异常处理
+
+**try/except**
+
+异常捕捉可以使用 `try/except` 语句。
+
+<center><img src="assets/image/2.png" width="500"/></center>
+
+以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。 
+
+```python
+while True:
+    try:
+        x = int(input("请输入一个数字: "))
+        break
+    except ValueError:
+        print("您输入的不是数字，请再次尝试输入！")
+```
+
+try 语句按照如下方式工作；
+
+- 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
+
+- 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
+
+- 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
+
+- 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
+
+一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
+
+处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
+
+一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如: 
+
+```python
+except (RuntimeError, TypeError, NameError):
+    pass
+```
+最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
+
+**try/except...else**
+
+
+`try/except` 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
+
+else 子句将在 try 子句没有发生任何异常的时候执行。
+
+<center><img src="assets/image/3.png" width="500"/></center>
+
+以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容： 
+
+```python
+for arg in sys.argv[1:]:
+    try:
+        f = open(arg, 'r')
+    except IOError:
+        print('cannot open', arg)
+    else:
+        print(arg, 'has', len(f.readlines()), 'lines')
+        f.close()
+```
+
+使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
+
+异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:
+
+```python
+>>> def this_fails():
+        x = 1/0
+   
+>>> try:
+        this_fails()
+    except ZeroDivisionError as err:
+        print('Handling run-time error:', err)
+   
+Handling run-time error: int division or modulo by zero
+```
+
+**try-finally 语句**
+
+try-finally 语句无论是否发生异常都将执行最后的代码。
+
+<center><img src="assets/image/4.png" width="500"/></center>
+
+以下实例中 finally 语句无论异常是否发生都会执行：
+
+```python
+try:
+    Waffle()
+except AssertionError as error:
+    print(error)
+else:
+    try:
+        with open('file.log') as file:
+            read_data = file.read()
+    except FileNotFoundError as fnf_error:
+        print(fnf_error)
+finally:
+    print('这句话，无论异常是否发生都会执行。')
+```
+
+---
+
+## 抛出异常
+
+Python 使用 raise 语句抛出一个指定的异常。
+
+raise语法格式如下：
+
+```python
+raise [Exception [, args [, traceback]]]
+```
+
+<center><img src="assets/image/5.png" width="500"/></center>
+
+以下实例如果 x 大于 5 就触发异常:
+
+```python
+x = 10
+if x > 5:
+    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
+```
+
+执行以上代码会触发异常：
+
+```python
+Traceback (most recent call last):
+  File "test.py", line 3, in <module>
+    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
+Exception: x 不能大于 5。x 的值为: 10
+```
+
+raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
+
+如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
+
+
+```python
+>>> try:
+        raise NameError('HiThere')
+    except NameError:
+        print('An exception flew by!')
+        raise
+   
+An exception flew by!
+Traceback (most recent call last):
+  File "<stdin>", line 2, in ?
+NameError: HiThere
+```
+
+---
+
+## 用户自定义异常
+
+你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:
+
+```python
+>>> class MyError(Exception):
+        def __init__(self, value):
+            self.value = value
+        def __str__(self):
+            return repr(self.value)
+   
+>>> try:
+        raise MyError(2*2)
+    except MyError as e:
+        print('My exception occurred, value:', e.value)
+   
+My exception occurred, value: 4
+>>> raise MyError('oops!')
+Traceback (most recent call last):
+  File "<stdin>", line 1, in ?
+__main__.MyError: 'oops!'
+```
+
+在这个例子中，类 Exception 默认的 `__init__()` 被覆盖。
+
+当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:
+
+```python
+class Error(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+class InputError(Error):
+    """Exception raised for errors in the input.
+
+    Attributes:
+        expression -- input expression in which the error occurred
+        message -- explanation of the error
+    """
+
+    def __init__(self, expression, message):
+        self.expression = expression
+        self.message = message
+
+class TransitionError(Error):
+    """Raised when an operation attempts a state transition that's not
+    allowed.
+
+    Attributes:
+        previous -- state at beginning of transition
+        next -- attempted new state
+        message -- explanation of why the specific transition is not allowed
+    """
+
+    def __init__(self, previous, next, message):
+        self.previous = previous
+        self.next = next
+        self.message = message
+```
+
+大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
+
+---
+
+## 定义清理行为
+
+try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:
+
+```python
+>>> try:
+...     raise KeyboardInterrupt
+... finally:
+...     print('Goodbye, world!')
+...
+Goodbye, world!
+Traceback (most recent call last):
+  File "<stdin>", line 2, in <module>
+KeyboardInterrupt
+```
+
+以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。
+
+如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。
+
+下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:
+
+```python
+>>> def divide(x, y):
+        try:
+            result = x / y
+        except ZeroDivisionError:
+            print("division by zero!")
+        else:
+            print("result is", result)
+        finally:
+            print("executing finally clause")
+   
+>>> divide(2, 1)
+result is 2.0
+executing finally clause
+>>> divide(2, 0)
+division by zero!
+executing finally clause
+>>> divide("2", "1")
+executing finally clause
+Traceback (most recent call last):
+  File "<stdin>", line 1, in ?
+  File "<stdin>", line 3, in divide
+TypeError: unsupported operand type(s) for /: 'str' and 'str'
+```
+
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/1.png" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/1.png"
new file mode 100644
index 0000000000000000000000000000000000000000..e79c2638a121ff339890ffce85aecf541471d93f
Binary files /dev/null and "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/1.png" differ
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/2.png" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/2.png"
new file mode 100644
index 0000000000000000000000000000000000000000..f3b77585a3ee341364dcca7b8ab05879f9f67e2b
Binary files /dev/null and "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/2.png" differ
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/3.png" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/3.png"
new file mode 100644
index 0000000000000000000000000000000000000000..4797d512b731b221c8df62905a1a5d68d26b7d1c
Binary files /dev/null and "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/3.png" differ
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/4.png" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/4.png"
new file mode 100644
index 0000000000000000000000000000000000000000..ffc3ee56d6a0197b6c68958f9974711ce9feecbe
Binary files /dev/null and "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/4.png" differ
diff --git "a/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/5.png" "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/5.png"
new file mode 100644
index 0000000000000000000000000000000000000000..58a4ec9c03d34d1a124d727ec95015df3d564196
Binary files /dev/null and "b/base/Python3\351\224\231\350\257\257\345\222\214\345\274\202\345\270\270/assets/image/5.png" differ
diff --git "a/base/Python3\351\233\206\345\220\210/README.md" "b/base/Python3\351\233\206\345\220\210/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0c48ce4a74f7b6e9d275cc4847b0a0e30120ae94
--- /dev/null
+++ "b/base/Python3\351\233\206\345\220\210/README.md"
@@ -0,0 +1,218 @@
+# Python3 集合
+
+- [集合的基本操作](#集合的基本操作)
+    - [添加元素](#添加元素)
+    - [移除元素](#移除元素)
+    - [计算集合元素个数](#计算集合元素个数)
+    - [清空集合](#清空集合)
+    - [判断元素是否在集合中存在](#判断元素是否在集合中存在)
+    - [集合内置方法完整列表](#集合内置方法完整列表)
+
+&emsp;&emsp;集合`（set）`是一个无序的不重复元素序列。
+
+&emsp;&emsp;可以使用大括号 `{ }` 或者 `set()` 函数创建集合，注意：创建一个空集合必须用 `set()` 而不是 `{ }`，因为 `{ }` 是用来创建一个空字典。
+
+&emsp;&emsp;创建格式：
+
+```
+parame = {value01,value02,...}
+或者
+set(value)
+```
+
+实例如下：
+
+```shell
+>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
+>>> print(basket)                      # 这里演示的是去重功能
+{'orange', 'banana', 'pear', 'apple'}
+>>> 'orange' in basket                 # 快速判断元素是否在集合内
+True
+>>> 'crabgrass' in basket
+False
+
+>>> # 下面展示两个集合间的运算.
+...
+>>> a = set('abracadabra')
+>>> b = set('alacazam')
+>>> a                                  
+{'a', 'r', 'b', 'c', 'd'}
+>>> a - b                              # 集合a中包含而集合b中不包含的元素
+{'r', 'd', 'b'}
+>>> a | b                              # 集合a或b中包含的所有元素
+{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
+>>> a & b                              # 集合a和b中都包含了的元素
+{'a', 'c'}
+>>> a ^ b                              # 不同时包含于a和b的元素
+{'r', 'd', 'b', 'm', 'z', 'l'}
+```
+
+&emsp;&emsp;类似列表推导式，同样集合支持集合推导式 `(Set comprehension)`:
+
+```shell
+>>> a = {x for x in 'abracadabra' if x not in 'abc'}
+>>> a
+{'r', 'd'}
+```
+
+---
+
+## 集合的基本操作
+
+
+### 添加元素
+
+语法格式如下：
+
+```python
+s.add( x )
+```
+
+&emsp;&emsp;将元素 `x` 添加到集合 `s` 中，如果元素已存在，则不进行任何操作。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> thisset.add("Facebook")
+>>> print(thisset)
+{'Google', 'Facebook', 'Waffle', 'Taobao'}
+```
+
+&emsp;&emsp;还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
+
+```python
+s.update( x )
+```
+
+&emsp;&emsp;x 可以有多个，用逗号分开。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> thisset.update({1,3})
+>>> print(thisset)
+{1, 'Google', 3, 'Waffle', 'Taobao'}
+>>> thisset.update([1,4],[5,6])  
+>>> print(thisset)
+{6, 1, 'Waffle', 3, 4, 'Google', 'Taobao', 5}
+>>>
+```
+
+---
+
+### 移除元素
+
+语法格式如下：
+
+```python
+s.remove( x )
+```
+
+&emsp;&emsp;将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> thisset.remove("Taobao")
+>>> print(thisset)
+{'Google', 'Waffle'}
+>>> thisset.remove("Facebook")   # 不存在会发生错误
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+KeyError: Facebook
+>>>
+```
+
+&emsp;&emsp;此外还有一个方法也是移除集合中的元素，且如果元素不存在，**不会** 发生错误。格式如下所示：
+
+```python
+s.discard( x )
+```
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> thisset.discard("Facebook")  # 不存在不会发生错误
+>>> print(thisset)
+{'Taobao', 'Google', 'Waffle'}
+```
+
+&emsp;&emsp;我们也可以设置 **随机** 删除集合中的一个元素，语法格式如下：
+
+```python
+s.pop()
+```
+
+```python
+thisset = set(("Google", "Waffle", "Taobao", "Facebook"))
+x = thisset.pop()
+
+print(x)
+```
+
+输出结果：
+
+```shell
+Google
+```
+
+&emsp;&emsp;多次执行测试结果都不一样。
+
+&emsp;&emsp;set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
+
+---
+
+### 计算集合元素个数
+
+语法格式如下：
+
+```python
+len(s)
+```
+
+计算集合 s 元素个数。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao", "Facebook"))
+>>> len(thisset)
+4
+```
+
+---
+
+### 清空集合
+
+语法格式如下：
+
+```python
+s.clear()
+```
+
+清空集合 s。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> thisset.clear()
+>>> print(thisset)
+set()
+```
+
+### 判断元素是否在集合中存在
+
+语法格式如下：
+
+```python
+x in s
+```
+
+判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
+
+```shell
+>>> thisset = set(("Google", "Waffle", "Taobao"))
+>>> "Waffle" in thisset
+True
+>>> "Facebook" in thisset
+False
+>>>
+```
+
+
+
+
+
diff --git "a/base/Python3\351\235\242\345\220\221\345\257\271\350\261\241/README.md" "b/base/Python3\351\235\242\345\220\221\345\257\271\350\261\241/README.md"
new file mode 100644
index 0000000000000000000000000000000000000000..75631f94cae5105788696095c05153c84a097b7e
--- /dev/null
+++ "b/base/Python3\351\235\242\345\220\221\345\257\271\350\261\241/README.md"
@@ -0,0 +1,355 @@
+# Python3 面向对象
+
+- [语法错误](#语法错误)
+    - [类定义](#类定义)
+    - [类对象](#类对象)
+- [类的方法使用方法](#类的方法使用方法)
+- [继承](#继承)
+- [多继承](#多继承)
+- [方法重写](#方法重写)
+- [类属性与方法](#类属性与方法)
+    - [类的私有属性](#类的私有属性)
+    - [类的方法](#类的方法)
+    - [类的私有方法](#类的私有方法)
+    - [类的专有方法](#类的专有方法)
+    - [运算符重载](#运算符重载)
+
+
+
+Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
+
+如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。
+
+接下来我们先来简单的了解下面向对象的一些基本特征。
+
+
+
+---
+
+## 面向对象技术简介
+
+- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
+- 方法：类中定义的函数。
+- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
+- 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
+- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
+- 局部变量：定义在方法中的变量，只作用于当前实例的类。
+- 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
+- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
+- 实例化：创建一个类的实例，类的具体对象。
+- 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
+
+和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
+
+Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
+
+对象可以包含任意数量和类型的数据。 
+
+### 类定义
+
+语法格式如下：
+
+```
+class ClassName:
+    <statement-1>
+    .
+    .
+    .
+    <statement-N>
+```
+类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。
+
+### 类对象
+
+类对象支持两种操作：属性引用和实例化。
+
+属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
+
+类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:
+
+```python
+class MyClass:
+    """一个简单的类实例"""
+    i = 12345
+    def f(self):
+        return 'hello world'
+ 
+# 实例化类
+x = MyClass()
+ 
+# 访问类的属性和方法
+print("MyClass 类的属性 i 为：", x.i)
+print("MyClass 类的方法 f 输出为：", x.f())
+```
+
+以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。
+
+执行以上程序输出结果为：
+
+```
+MyClass 类的属性 i 为： 12345
+MyClass 类的方法 f 输出为： hello world
+```
+
+类有一个名为 `__init__()` 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
+
+```python
+def __init__(self):
+    self.data = []
+```
+
+类定义了 `__init__()` 方法，类的实例化操作会自动调用 `__init__()` 方法。如下实例化类 `MyClass`，对应的 `__init__()` 方法就会被调用:
+
+```python
+x = MyClass()
+```
+
+当然， `__init__()` 方法可以有参数，参数通过 `__init__()` 传递到类的实例化操作上。例如: 
+
+```python
+class Complex:
+    def __init__(self, realpart, imagpart):
+        self.r = realpart
+        self.i = imagpart
+x = Complex(3.0, -4.5)
+print(x.r, x.i)   # 输出结果：3.0 -4.5
+```
+
+**self代表类的实例，而非类**
+
+类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的 **第一个参数名称**, 按照惯例它的名称是 `self`。
+
+```python
+class Test:
+    a = 10
+    def prt(self):
+        print(self)
+        print(self.a)
+ 
+t = Test()
+t.prt()
+```
+
+以上实例执行结果为：
+
+```python
+<Test object at e66d0>
+10
+```
+
+从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 `self.a` 则指向 **类中的变量**。
+
+self 不是 python 关键字，我们把他换成 Waffle 也是可以正常执行的:
+
+```python
+class Test:
+    a = 10
+    def prt(Waffle):
+        print(Waffle)
+        print(Waffle.a)
+ 
+t = Test()
+t.prt()
+```
+
+以上实例执行结果为：
+
+```
+<Test object at e6a60>
+10
+```
+
+---
+
+## 类的方法使用方法
+
+在类的内部，使用 `def` 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。 
+
+```python
+#类定义
+class people:
+    #定义基本属性
+    name = ''
+    age = 0
+    #定义私有属性,私有属性在类外部无法直接进行访问
+    __weight = 0
+    #定义构造方法
+    def __init__(self,n,a,w):
+        self.name = n
+        self.age = a
+        self.__weight = w
+    def speak(self):
+        print("%s 说: 我 %d 岁。" %(self.name,self.age))
+ 
+# 实例化类
+p = people('Waffle',1,30)
+p.speak()
+```
+
+
+执行以上程序输出结果为：
+
+```
+Waffle 说: 我 1 岁。
+```
+
+---
+
+## 继承
+
+Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:
+
+```
+class DerivedClassName(BaseClassName):
+    <statement-1>
+    .
+    .
+    .
+    <statement-N>
+```
+
+子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
+BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用: 
+
+
+```python
+class DerivedClassName(modname.BaseClassName):
+```
+
+```python
+#类定义
+class people:
+    #定义基本属性
+    name = ''
+    age = 0
+    #定义私有属性,私有属性在类外部无法直接进行访问
+    __weight = 0
+    #定义构造方法
+    def __init__(self,n,a,w):
+        self.name = n
+        self.age = a
+        self.__weight = w
+    def speak(self):
+        print("%s 说: 我 %d 岁。" %(self.name,self.age))
+ 
+#单继承示例
+class student(people):
+    grade = ''
+    def __init__(self,n,a,w,g):
+        #调用父类的构函
+        people.__init__(self,n,a,w)
+        self.grade = g
+    #覆写父类的方法
+    def speak(self):
+        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
+ 
+ 
+ 
+s = student('ken',10,60,3)
+s.speak()
+```
+
+执行以上程序输出结果为：
+
+```
+ken 说: 我 10 岁了，我在读 3 年级
+```
+
+---
+
+## 多继承
+
+目前还不支持多继承
+
+---
+
+## 方法重写
+
+如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：
+
+```python
+class Parent:        # 定义父类
+   def myMethod(self):
+      print ('调用父类方法')
+ 
+class Child(Parent): # 定义子类
+   def myMethod(self):
+      print ('调用子类方法')
+ 
+c = Child()          # 子类实例
+c.myMethod()         # 子类调用重写方法
+super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
+```
+super() 函数是用于调用父类(超类)的一个方法。
+
+执行以上程序输出结果为：
+
+```
+调用子类方法
+调用父类方法
+```
+
+---
+
+## 类属性与方法
+
+### 类的私有属性
+
+目前不支持
+
+### 类的方法
+
+在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
+
+self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。
+
+### 类的私有方法
+
+目前不支持
+
+### 类的专有方法：
+
+
+- `__init__` : 构造函数，在生成对象时调用
+- `__del__` : 析构函数，释放对象时使用
+- `__repr__` : 打印，转换
+- `__setitem__` : 按照索引赋值
+- `__getitem__`: 按照索引获取值
+- `__len__`: 获得长度
+- `__cmp__`: 比较运算
+- `__call__`: 函数调用
+- `__add__`: 加运算
+- `__sub__`: 减运算
+- `__mul__`: 乘运算
+- `__truediv__`: 除运算
+- `__mod__`: 求余运算
+- `__pow__`: 乘方
+
+### 运算符重载
+
+Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：
+
+```python
+class Vector:
+   def __init__(self, a, b):
+      self.a = a
+      self.b = b
+ 
+   def __str__(self):
+      return 'Vector (%d, %d)' % (self.a, self.b)
+   
+   def __add__(self,other):
+      return Vector(self.a + other.a, self.b + other.b)
+ 
+v1 = Vector(2,10)
+v2 = Vector(5,-2)
+print (v1 + v2)
+```
+
+以上代码执行结果如下所示:
+```
+Vector(7,8)
+```
+
+
+
diff --git a/base/README.md b/base/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac7cc4a2449762fb5415809699d0df8f25c28f1b
--- /dev/null
+++ b/base/README.md
@@ -0,0 +1,36 @@
+# 支持的 Python3 语法
+
+
+&emsp;&emsp;`Python` 是一个高层次的结合了 **解释性**、**编译性**、**互动性** 和 **面向** 对象的脚本语言。
+
+&emsp;&emsp;`Python` 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
+
+
+
+## 目录
+
+| 语法 | 说明 |
+|---|---|
+|[Python3 基础语法](Python3基础语法/README.md)|  python3 基础语法展示 |
+|[Python3 基本数据类型](Python3基本数据类型/README.md)| Python3 中的六个标准的数据类型 |
+|[Python3 注释](Python3注释/README.md)| 确保对模块, 函数, 方法和行内注释使用正确的风格 |
+|[Python3 运算符](Python3运算符/README.md)| 本章节主要说明 Python 的运算符 |
+|[Python3 数字(Number)](Python3数字(Number)/README.md)| Python 数字数据类型用于存储数值。 |
+|[Python3 字符串](Python3字符串/README.md)| 字符串是 Python 中最常用的数据类型。 |
+|[Python3 列表](Python3列表/README.md)| 序列是 Python 中最基本的数据结构。 |
+|[Python3 元组](Python3元组/README.md)| Python 的元组与列表类似，不同之处在于元组的元素不能修改。 |
+|[Python3 字典](Python3字典/README.md)| 字典是另一种可变容器模型，且可存储任意类型对象 |
+|[Python3 集合](Python3集合/README.md)| 集合（set）是一个无序的不重复元素序列 |
+|[Python3 条件控制](Python3条件控制/README.md)| Python3中的条件控制 |
+|[Python3 循环语句](Python3循环语句/README.md)| Python3中的循环语句 |
+|[Python3 迭代器与生成器](Python3迭代器与生成器/README.md)| Python3中的迭代器与生成器 |
+|[Python3 函数](Python3函数/README.md)| 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 |
+|[Python3 数据结构](Python3数据结构/README.md)| Python3 数据结构 |
+|[Python3 模块](Python3模块/README.md)| Python3 模块 |
+|[Python3 输入和输出](Python3输入和输出/README.md)| Python 的输入输出 |
+|[Python3 错误和异常](Python3错误和异常/README.md)| Python 有两种错误很容易辨认：语法错误和异常 |
+|[Python3 面向对象](Python3面向对象/README.md)| Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。 |
+
+
+
+转载自：[菜鸟教程](https://www.runoob.com/python3/python3-tutorial.html) 
\ No newline at end of file