python

Python/python2/PYTHON初始python.md

@@ -0,0 +1,26 @@
+**\>程序设计的基础知识**
+
+\>\>程序的定义：为了完成某项任务解决某个问题，计算机及执行的一定的指令
+
+\>\>计算机：实现程序的机器,Enia（宾夕法尼亚大学）-电子管-晶体管-集成电路
+
+\>\>cup构成，冯诺依曼的计算机结构：输入设备-存储器-输出设备-控制器-计算器
+
+**\>人与机器的沟通**
+
+\>\>程序设计语言：汇编语言-低级语言-高级语言（python-Java）
+
+\>\>分类：编译型语言source code -compiler- object
+CODe。解释性语言sourcecode-interpreter-output
+
+\>\>创始人：吉多·范·罗苏姆蟒蛇
+
+\>\>python：解释性语言，可移植性强，执行效率低；设计哲学：优雅明确简单
+
+**\>第一个程序hello world**
+
+\>\>‘print python’
+
+\>\>命令行（Linux系统下)优点：无需创建文件，立即看到裕运行的结果
+
+脚本IDE编辑器：适合编写大型程序更容易纠错，更容易修改和执行

Python/python2/yield详解.md

@@ -0,0 +1,160 @@
+当你创建了一个列表，你可以逐项地读取这个列表。这个过程就是迭代
+
+**[python]** [view
+plain](http://blog.csdn.net/a168861888m/article/details/78293251)
+[copy](http://blog.csdn.net/a168861888m/article/details/78293251)
+
+1.  \<span style="font-family:'Times New Roman';font-size:14px;"\>\>\>\> mylist
+    = [1, 2, 3]
+
+2.  \>\>\> **for** i **in** mylist:
+
+3.  ... **print**(i)
+
+4.  1
+
+5.  2
+
+6.  3\</span\>
+
+mylist是一个可迭代对象。当你使用一个列表生成式的时候，你创建了一个列表，也就是一个可迭代对象
+
+**[python]** [view
+plain](http://blog.csdn.net/a168861888m/article/details/78293251)
+[copy](http://blog.csdn.net/a168861888m/article/details/78293251)
+
+1.  \<span style="font-family:'Times New Roman';font-size:14px;"\>\>\>\> mylist
+    = [x\*x **for** x **in** range(3)]
+
+2.  \>\>\> **for** i **in** mylist:
+
+3.  ... **print**(i)
+
+4.  0
+
+5.  1
+
+6.  4\</span\>
+
+所有你可以使用 "for...in..."的都是可迭代对象：列表，字符串，文件等等
+
+你经常使用它们因为你可以如你所愿的读取其中的元素，但是你把所有的数据都存贮在内存里，如果你有许多数据的话，这种做法不会是你想要的
+
+生成器
+
+生成器都是可以迭代的，但是你只可以迭代它们一次，因为他们并不是把所有的数据存贮在内存中，它是实时的生成数据
+
+**[python]** [view
+plain](http://blog.csdn.net/a168861888m/article/details/78293251)
+[copy](http://blog.csdn.net/a168861888m/article/details/78293251)
+
+1.  \<span style="font-family:'Times New Roman';font-size:14px;"\>\>\>\>
+    mygenerator = (x\*x **for** x **in** range(3))
+
+2.  \>\>\> **for** i **in** mygenerator:
+
+3.  ... **print**(i)
+
+4.  0
+
+5.  1
+
+6.  4\</span\>
+
+看上去都是一样的，除了使用（）而不是 []。但是你不可以再次使用 for i in
+mygenerator
+因为生成器只能被逆代一次：他们先计算出0，然后就丢掉了0，然后再继续逐项计算1，计算4
+
+Yield
+
+yield是一个类似 return的关键字，不同的是这个函数返回的是一个生成器
+
+**[python]** [view
+plain](http://blog.csdn.net/a168861888m/article/details/78293251)
+[copy](http://blog.csdn.net/a168861888m/article/details/78293251)
+
+1.  \<span style="font-family:'Times New Roman';font-size:14px;"\>\>\>\> **def**
+    createGenerator():
+
+2.  ... mylist = range(3)
+
+3.  ... **for** i **in** mylist:
+
+4.  ... **yield** i\*i
+
+5.  ...
+
+6.  \>\>\> mygenerator = createGenerator() \# create a generator
+
+7.  \>\>\> **print**(mygenerator) \# mygenerator is an object!
+
+8.  \<generator object createGenerator at 0xb7555c34\>
+
+9.  \>\>\> **for** i **in** mygenerator:
+
+10. ... **print**(i)
+
+11. 0
+
+12. 1
+
+13. 4\</span\>
+
+这个例子没什么用途，但如果你的函数会返回一大批你只需要阅读一次的数据的时候，这是很方便的。
+
+为了精通
+yield，你必须理解：当你调用这个函数的时候，函数里的代码是不会马上执行的。这个函数只是返回生成器对象，这有点蹊跷不是吗？
+
+那么，函数的代码什么时候开始执行呢？使用for迭代的时候
+
+现在到了比较的难的一部分：
+
+第一次迭代的时候，你的函数开始执行，从开始到达yield关键字，然后返回第一次迭代的值。然后，每次执行这个函数都会继续执行你在函数内部定义的那个循环的下一次，再返回那个值，直到没有可以返回的值。如果生成器内部没有定义yield
+关键词，这个生成器被认为是空的。也有可能是因为循环已经结束或者没有满足“If/else”条件
+
+\----------------------------------------------------------------------------------------------------------------------------------------（我是分割线）
+
+更深入聊一下：什么时候使用 field 而不是 return？
+
+yield语句暂停函数的执行，并向调用者发送一个值，但保留足够的状态以使函数能够在其被关闭的位置恢复。
+恢复后，该功能在最后一次产量运行后立即继续执行。
+**这允许其代码随时间产生一系列值，而不是一次计算它们，并将其像列表一样发送回来。**
+
+我们来看一个例子：
+
+**[python]** [view
+plain](http://blog.csdn.net/a168861888m/article/details/78293251)
+[copy](http://blog.csdn.net/a168861888m/article/details/78293251)
+
+1.  \<span style="font-family:'Times New Roman';font-size:14px;"\>**def**
+    simpleGeneratorFun():
+
+2.  **yield** 1
+
+3.  **yield** 2
+
+4.  **yield** 3
+
+5.  
+
+6.  \# Driver code to check above generator function
+
+7.  **for** value **in** simpleGeneratorFun():
+
+8.  **print**(value)\</span\>
+
+输出：
+
+1 2 3
+
+return返回一个指定的值给它的调用者，而yield可以产生一个值序列。当要遍历一个序列但又不想将整个序列存储在内存中的时候，我们应该使用yield
+
+yield用于Python生成器中。
+一个生成器函数被定义为一个正常的函数，但是只要它需要生成一个值，就应该使用 yield
+关键字而不是return。 如果 def 的 body 包含 yield，则该函数自动成为生成器函数。
+
+写博客也参考了一些资料（学习一般都是看英文的）：
+
+（1）https://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do?page=1&tab=votes\#tab-top
+
+（2）http://www.geeksforgeeks.org/use-yield-keyword-instead-return-keyword-python/

Python/python2/函数.md

@@ -0,0 +1,65 @@
+**\>函数**
+
+\>\>函数定义：完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给他求个名字，通过函数名执行
+
+\>\>语法：
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51873452)
+[copy](http://blog.csdn.net/estom_yin/article/details/51873452)
+
+1.  \<span style="font-size:18px;"\> **def** print\_sum(start, stop):
+
+2.  """ to calculate the sum from start to stop """
+
+3.  result = 0
+
+4.  **for** i **in** range(star, stop + 1):
+
+5.  result += i
+
+6.  **print** 'sum is', result\</span\>
+
+>   第一行定义了一个函数，关键字 def ，函数名 print_sum，函数参数start， stop
+
+\>\>函数调用
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51873452)
+[copy](http://blog.csdn.net/estom_yin/article/details/51873452)
+
+1.  \<span style="font-size:18px;"\>print\_sum(a, b)\</span\>
+
+\>\>参数说明
+
+>   形式参数和实际参数
+
+>   缺省参数，定义实参时，给参数赋值
+
+\>\>返回值
+
+>   return 语句会终止当前的函数执行
+
+>   返回一个变量
+
+\>\>变量的作用域
+
+>   局部变量：只能在程序特定部分起作用
+
+>   全局变量：能在程序的全局起作用
+
+>   名称的屏蔽作用
+
+>   global x 表明x是一个全局变量声明
+
+>   pass 语句可作为一个占位符，用于表示此处省略的大量语句
+
+\>\>函数的作用：
+
+>   可以将一个打的问题，分解成一个小的函数，有利于解决问题
+
+>   可以进行信息的封装和隐藏
+
+**\>琐碎的函数知识总结**
+
+\>\>if month in(1, 3, 5, 7, 8, 9, 11, 12):函数in可以表示一个选择范围

Python/python2/列表与元组.md

@@ -0,0 +1,279 @@
+\>列表简介
+
+\>\>是一种内建的数据结构，用来存储一系列的元素
+
+\>\>同JS一样，由于解释性语言不必声明数据类型，所以数组的元素也可以很灵或的不相同。
+
+\>列表的运算
+
+>   index索引运算：[]
+
+>   切片运算：[:]
+
+>   拼接运算+
+
+>   重复运算\*
+
+>   成员运算in
+
+>   长度运算len（）
+
+>   循环for（）
+
+\>列表方法：
+
+>   list.intex()可以返回任意的方法
+
+>   my_list[2] = a \#元素赋值
+
+>   my_list.append()\#末尾追加元素
+
+>   my_list.extend()\#末尾追加子表
+
+>   my_list.insert()\#任意位置插入元素
+
+>   my_list.pop()结尾删除元素
+
+>   my_lise.sort()\#排序
+
+>   my_list.remove()\#删除任意位置元素
+
+>   my_list.reverse()\#倒序
+
+\>列表应用
+
+\>\>内建函数：sum()求和，max（）求最大值，min()求最小值
+
+\>\>列表名本身就是一种指针和地址。所以在赋值是只是一个指针的指向赋值给另一个指针的指向
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>程序一\</span\>
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>a = [1, 2, 3, 4]
+
+2.  b = a
+
+3.  b[1] = 100
+
+4.  **print** a[1]
+
+5.  程序二
+
+6.  a = [1, 2, 3, 4]
+
+7.  b = a[:]
+
+8.  b[1] = 100
+
+9.  **print** a[1]\</span\>
+
+    程序一的输出100，因为a和b指向同一个位置
+
+    程序二的输出1，因为a和b指向不同的位置。
+
+\>\>交换列表中两个元素的值
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>**def** swap(lst, a, b)
+
+2.  tmp = lst[a]
+
+3.  lst[a] = lst[b]
+
+4.  lst[b] = lst[a]
+
+5.  x = [10, 20, 30]
+
+6.  swap(x, 0, 1)\</span\>
+
+\>\>查找并返回元素位置
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>**def** search(lst, x):
+
+2.  **for** i **in** range(len(lst)):
+
+3.  **if** lst[i] == x:
+
+4.  **return** i
+
+5.  **return** -1\</span\>
+
+    也可以直接使用lst.index(待查找元素)直接进行查找
+
+\>\>时间复杂度的计算
+
+\>二分查找
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>**def** bi\_search(lst, v):
+
+2.  low = 0
+
+3.  up = len(lst) - 1
+
+4.  **while** low \<= up
+
+5.  mid = (low + up) / 2
+
+6.  **if** lst[mid] \< v:
+
+7.  low = mid + 1
+
+8.  **elif** lst[mid] == v:
+
+9.  **return** mid
+
+10. **else**:
+
+11. up = mid - 1
+
+12. **return** -1\</span\>
+
+\>排序
+
+\>\>选择排序
+
+![715154122626.png](media/36645b2c7df50743cafd69bff4f6f00e.png)
+
+\>\>冒泡排序
+
+![715154128126.png](media/a524121dffc0de426130c95b7f05fbcf.png)
+
+\>\>使用内置函数
+
+>   sorted（lst）
+
+>   lst.sort()
+
+\>嵌套列表
+
+students = [ ['zhang', 84], ['wang', 77], ['li', 100], ['zhao',53] ]
+
+\>列表的解析
+
+\>\>作用：一种有源列表创建新列表的方法
+
+\>\>语法：[表达式for 变量 in 列表 if 条件]
+
+生成函数-变化范围-约束条件
+
+普通方法
+
+>   lst = []
+
+>   for x in range(1, 10)
+
+>   lst.append(x\*\*2)
+
+>   print lst
+
+列表解析法：
+
+>   lst = [x\*\*2 for x in range(1,10) if x % 2 == 0]
+
+>   生成函数x\*\*2；生成范围1-10；生成条件x%2==0
+
+\>定义匿名函数lambda
+
+g = lambda x: x \*\* 2
+
+print f(8)
+
+所以可以用一下程序实现嵌套列表的值排序
+
+students = [ ['zhang', 84], ['wang', 77], ['li', 100], ['zhao',53] ]
+
+students.sort(key = lambda x: x[1], reverse = true)
+
+\>元组
+
+\>\>注意事项
+
+1、元组同字符串一样具有不可变性，本质上是一个列表
+
+2、append、extend、del等改变列表内容的函数不再适用，其它函数可以用
+
+3、用括号直接创建元组（引号直接创建字符串，方括号直接创建列表）
+
+4、元组的括号可以省略，直接用逗号隔开相同元组里的不同项
+
+\>\>使用元组赋值
+
+使用元组交换两个值
+
+a, b = b , a
+
+name, domai = 'car@163.com'.split('@') //这样就直接将值赋给两个变量了。
+
+\>\>函数和元组
+
+使用元组可以返回多个函数值
+
+![715160502150.png](media/d8ec8dcdb684175683aa827cdec3d19b.png)
+
+\>\>DSU模式（decorate,sort,undecorete）修饰排序反修饰
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>**def** sort_by_length(words):
+
+2.  \#decorate
+
+3.  t = []
+
+4.  **for** word **in** words:
+
+5.  t.append((len(word),word))
+
+6.  \#将元素和元素长度组成一个二元组
+
+7.  \#sort
+
+8.  t.sort(reverse = true)
+
+9.  
+
+10. \#undecorate
+
+11. res = []
+
+12. **for** length, word **in** t:
+
+13. res.append(word)
+
+14. **return** res
+
+15. 
+
+16. \</span\>
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51916941)
+[copy](http://blog.csdn.net/estom_yin/article/details/51916941)
+
+1.  \<span style="font-size:14px;"\>
+
+2.  
+
+3.  words.sort(key = **lambda** x:len(x),reverse =true)\</span\>
+
+//巧妙地利用了元组对应的灵活性完成了合成和分割

Python/python2/基本的命令及操作.md

@@ -0,0 +1,60 @@
+\>基本的数据类型
+
+\>\>字符串string 使用’或“
+
+\>\>整数integer 21 025 0x15
+
+\>\>浮点数1.48 2.1e2有精度损失
+
+\>\>布尔型boolean True或者False
+
+\>\>复数 1+4j
+
+\>\>使用type函数查看数据类型type（’小明‘），区分类型
+
+\>运算符与表达式
+
+\>\>算数运算5.0 / 9 \* （32-8）隐式类型转换bool-\>int-\>float-\>complex
+
+\>\>+ - \* / % \*\*(指数)
+
+\>\>math模块实现更多算术运算
+
+模块：实现一定功能的python脚本的集合
+
+方法：import module_name
+
+查看model：dir(math)
+
+查看function：help（name）
+
+\>\>关系运算== != \< \> \<= \>=结果True False
+
+\>\>逻辑运算符 and or not；
+
+and
+返回最后一次判定的值，因为and只有全部判定结束后或者判定到假是才会停止判定，所以其返回值可能是最后一个真值或者某个第一个假值
+
+or返回第一个遇到的真值，或者最后一个假值，当or中有一个是真值是，他就会返回这个值
+
+\>\>运算顺序：括号具有最高优先级，由内到外结合。括号-一元运算-算数运算乘除取余//-算数运算加减-比较运算-逻辑非-逻辑与-逻辑或-赋值运算
+
+规则一：自上而下括号最高逻辑最低。
+
+规则二：自左向右依次结合统计运算自左向右
+
+\>变量与简单的输入输出
+
+\>\>变量的定义：用于引用绑定对象的标识符
+
+\>\>语法：变量名=对象（数值、表达式）
+
+\>\>普通的赋值运算符，增量赋值运算符
+
+\>\>变量标识符的定义和C++相同，而且大小写敏感
+
+\>\>raw_input(“输入的提示符”)读取键盘输入，将所输入作为字符看待,需要对输入的字符进行强制的类型转化
+
+\>\>print
+“输出提示符”将对象的值输出到控制台上；使用逗号分隔许多对象，输出后会自动添加空格；\\n
+\\\\ \\t\\a \\'

Python/python2/字典和集合.md

@@ -0,0 +1,105 @@
+**\>字典结构**
+
+\>\>键值对（融合了PHP中的特点）
+
+\>\>创建字典，使用成对的花括号{ }，使用冒号表示键值对
+
+>   例如：my_dict = {'John':879798,'Bob':8757,'mike':725466}
+
+>   其他方法：dict(zip([1,2,3],[4,5,6]))或dict([(1,4),(2,5),(3,6)])
+
+\>\>访问字典：使用方括号[ ] ，使用键作为索引
+
+>   例如：print my_dict print my_dict['tom']
+
+\>\>字典运算符和方法
+
+>   len（my_dict）字典中键值对的数量
+
+>   key in my_dict快速判断key是否为字典中的键（=\>my_dict.has_key(key)）
+
+>   for key in my_dict:能够遍历数组中所有的键（不是值）
+
+>   my_dict.items()全部的键值对，以列表的形式存在（好像Python中称数组为列表吧）
+
+>   my_dict.keys() 全部的键
+
+>   my_dict.values()全部的值
+
+>   my_dict.clear() 清空字典
+
+\>\>关于文件处理中涉及到的一些函数
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/52345031)
+[copy](http://blog.csdn.net/estom_yin/article/details/52345031)
+
+1.  \# reading the essay and count the top ten using words
+
+2.  
+
+3.  f = open('emma.txt')
+
+4.  
+
+5.  word_freq = {}
+
+6.  
+
+7.  **for** line **in** f:
+
+8.  words = line.strip().split()
+
+9.  **for** word **in** words:
+
+10. **if** word **in** word_freq:
+
+11. word_freq[word] += 1
+
+12. **else**:
+
+13. word_freq[word] = 1
+
+14. 
+
+15. freq_word = []
+
+16. **for** word, freq **in** word\_freq.items():
+
+17. freq\_word.append((freq, word))
+
+18. 
+
+19. freq\_word.sort(reverse=True)
+
+20. 
+
+21. **for** freq, word **in** freq\_word[:10]:
+
+22. **print** word
+
+23. f.close()
+
+**\>集合**
+
+\>\>定义：无需不重复元素的集合，和字典相同没有值，只有键
+
+\>\>创建集合：x = set() x = {key1,key2,...}
+
+\>\>添加和删除：x.add('body') x.remove('body')
+
+\>\>集合的运算符
+
+>   \-差集
+
+>   &交集
+
+>   \|并集
+
+>   !=不等于判断
+
+>   ==判断相等
+
+>   in成员运算
+
+>   for枚举运算

Python/python2/字符串.md

@@ -0,0 +1,132 @@
+\>字符串的定义
+
+\>\>字符串是一个字符的序列，可以使用‘单引号’或者“双引号”表示。
+
+\>\>使用‘’‘三引号’‘’表示时，可以保留字符串的格式信息。
+
+\>\>可以使用转义字符表示字符串内部的引号。/n回车换行/t制表符
+
+\>字符串的基本运算
+
+\>\>len(字符串)：返回字符串的长度
+
+\>\> + ：拼接操作name = first_name + "jordan"
+
+\>\> \* ：重复操作name \* 3 = "mike mike mike"
+
+\>in运算
+
+\>\> in
+：判断一个字符串是不是另一个字符串的子串（大小写敏感）返回一个true或false
+
+>   name = 'michael jordan'
+
+>   'a' in name
+
+>   返回true
+
+\>\>for语句
+
+>   my_str = "hello word"
+
+>   for char in my_str
+
+>   循环体
+
+\>字符串索引index
+
+\>\>字符创中每个字符都有个索引值（下标）索引0（从前向后）或-1（从后向前）开始
+
+\>\>将其视为数组
+
+\>字符串切片（将字符串视为字符串数组）
+
+>   变量名[start:finish:conuntBy]获得子串
+
+>   start：子序列开始的所以
+
+>   finish：子序列结束位置的下一个位置
+
+>   countby：字符串的方向和步长（同range的第三个参数），当取负数时，逆向输出
+
+\>\>字符串的不可变性
+
+>   一个字符串一旦生成内容不可改变，不支持每项的赋值。
+
+>   通过切片改变某个下标对应的字符。
+
+\>\>通过切片生成新的字符串
+
+my_str = my\_str[:1] + 'a' + my_str[2:]
+
+\>\>通过切片获取逆字符串
+
+reverse_str = my\_str[ : :-1]
+
+\>字符串对象提供的函数(又称为方法)
+
+>   .replace('被替换的字符','新的字符')：返回新的字符串，不能修改原来字符串的内容。
+
+>   .find('查找字符')：查找一个字符
+
+>   .split()：在制定的地方（默认是空格处），进行切分，返回一个字符串数组。
+
+\>\>文件操作：
+
+>   打开文件
+
+>   f =open(filename, mode)/mode=r or w
+
+>   按行读取文件内容
+
+>   for line in f:
+
+>   pass
+
+>   关闭文件：
+
+>   f.close()
+
+>   写入文件
+
+>   f.write()
+
+\>\>定义函数判断是否是回文字符串
+
+非递归算法
+
+递归算法
+
+\>字符串比较
+
+\>\>按字典顺序进行比较，可以直接使用大于小于号，返回true或者false
+
+\>字符串的格式化输入输出
+
+\>\>print "Hello{}good{}.".format(5,'DAY')
+
+用中括号代替需要输出的字符，然后在中括号中进行格式化操作布局，调用.format对象的方法，写入输出的内容。
+
+\>\>例如
+
+print 'pi is {: .4f}'.format(math.pi)
+
+print 'pi is {:e}'.format(math.pi)
+
+\>python的正则表达式
+
+判断整个字符串：name == 'Michael’
+
+判断是否 以 Mi 开始：name[:2] == 'Mi’
+
+包含 cha 子串：'cha' in name
+
+是否包含 c?a 子串：
+
+是否包含 c\*e 子串？
+
+.表示任意字符
+
+\\d表示一系列数字
+
+[a - z]表示任意一个小写字母

Python/python2/正则表达式详解.md

@@ -0,0 +1,3 @@
+基本语法规则
+
+![pyre_ebb9ce1c-e5e8-4219-a8ae-7ee620d5f9f1.png](media/fb96ec92f6caab4ab0ac9fe60df68ddc.png)

Python/python2/程序的控制结构.md

@@ -0,0 +1,74 @@
+\>选择结构
+
+\>\>程序流程图：用简单的图形表示问题的解决步骤；起止框，处理匡，判断框，文档框，流程线，圆形，输入输出框
+
+\>\>语法：（python中大括号不是分区作用，是靠语句块的缩进来体现语句块术语的范围）
+
+if 条件：
+
+缩进语句块
+
+其余的语句
+
+if 条件：
+
+缩进语句块
+
+else ：
+
+缩进语句块
+
+\>\>if语句支持嵌套
+
+\>\>多分支结构elif 条件==else if
+条件，有助于简化缩进，是画面更加清晰，可读性更高
+
+涉及到两个典型的例子：elif计算多分支结构；领先是否安全的例子
+
+\>循环结构
+
+\>\>while：条件判断，成立则执行循环体，不成立则不执行
+
+初始化语句
+
+while 条件语句：
+
+循环体
+
+其它语句
+
+\>\>break，结束当前循环体
+
+\>\>continue，结束这次循环或者说开始新的循环
+
+\>\>for循环
+
+for element in object
+
+循环体
+
+\>\>range(start，stop，step)生成连续整数
+
+\>\>穷举法的使用-鸡兔同笼问题
+
+\>\>循环的嵌套问题
+
+\>程序控制结构的练习题
+
+\>\>if-else 句型
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51854060)
+[copy](http://blog.csdn.net/estom_yin/article/details/51854060)
+
+1.  **for** i **in** range(2,x):
+
+2.  **if** x % i == 0 :
+
+3.  **break**
+
+4.  **else** :
+
+5.  prin 'x is a prime'
+
+当else在循环外与for对齐的时候说明了一个问题，有无数个if与else对应，当其中的任何一个if执行后都不在执行else，否则，若if没有执行过，则会执行else

Python/python2/递归函数.md

@@ -0,0 +1,103 @@
+\>递归的实现：
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51892697)
+[copy](http://blog.csdn.net/estom_yin/article/details/51892697)
+
+1.  \<pre name="code" **class**="python"\>**def** p(n):
+
+2.  **if** n ==1 **or** n == 0:
+
+3.  **return** 1
+
+\>递归的设计：
+
+>   将问题分解成许多同构的问题，然后以相同的方式解决最终分解的小问题。
+
+>   递归的要素：
+
+>   递归执行的操作
+
+>   递归的结束条件
+
+>   递归的参数传递
+
+\>实例一：兔子序列（菲波那切数列，在自然界一些动植物身上都有体现）
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51892697)
+[copy](http://blog.csdn.net/estom_yin/article/details/51892697)
+
+1.  **def** fib(n):
+
+2.  **if** n == 1 **or** n == 2:
+
+3.  **return** 1
+
+4.  **else**:
+
+5.  **return** fib(n - 1) + fib(n - 2)
+
+6.  **print** fib(20)
+
+\>实例二：汉诺塔问题
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51892697)
+[copy](http://blog.csdn.net/estom_yin/article/details/51892697)
+
+1.  **def** hanoi(n, A, B, C):
+
+2.  **if** n == 1:
+
+3.  **print** "move", n, "from", A, "to", C
+
+4.  **else**:
+
+5.  hanoi(n - 1, A, C, B)
+
+6.  **print** 'move', n, 'from', A, 'to', C
+
+7.  hanoi(n - 1, B, A, C)
+
+8.  
+
+9.  hanoi(10, 'left', 'Mid', 'Right')
+
+\>实例三：停车问题
+
+>   要求：在固定长度的马路上随机停车，根据车身长度以及随机性特点确定，马路长度与停车数量的关系
+
+**[python]** [view
+plain](http://blog.csdn.net/estom_yin/article/details/51892697)
+[copy](http://blog.csdn.net/estom_yin/article/details/51892697)
+
+1.  **import** random
+
+2.  \#if the w big enough, lim parking to 3.7472 named Reni constance
+
+3.  
+
+4.  **def** parking(low, high):
+
+5.  **if** high - low \< 1:
+
+6.  **return** 0
+
+7.  **else**:
+
+8.  x = random.uniform(low, high - 1)
+
+9.  **return** parking(low, x) + 1 + parking(x + 1, high)
+
+10. **print** parking(0, 5)
+
+\>递归的优劣
+
+\>\>能使一个蕴含递归关系而且结构复杂的程序简洁精练，增强可读性
+
+\>\>嵌套层次深，函数调用开销大，存在大量的重复计算
+
+\>补充琐碎知识
+
+>   random.uniform(low, high) 能产生从low到high的随机数