python入门（三）：分支、循环、函数

1.分支

if循环格式：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3

以下实例 x 为 0-99 取一个数,y 为 0-199 取一个数,如果 x>y 则输出 x， 如果 x 等于 y 则输出 x+y，否则输出y。

#!/usr/bin/python3
import random

x = random.choice(range(100))
y = random.choice(range(200))
if x > y:
    print('x:',x)
elif x == y:
    print('x+y', x + y)
else:
    print('y:',y)

　　

2.循环

1、while循环格式：
while  condition_1 ：

　　<statements>

#!/usr/bin/python3

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

　　

2、for循环的一般格式如下：
for <variable> in <sequence>:

　　<statements>
else:
　　<statements

3、range()函数
 如果你需要遍历数字序列，可以使用内置range()函数，range以指定数字开始并指定不同的增量（第三个参数）。它会生成数列（列表）,而xrang则会返回一个iterable对象。

ps:break 语句可以跳出 for 和 while 的循环体。
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

4、迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。

对于原生支持随机访问的数据结构（如tuple、list），迭代器和经典for循环的索引访问相比并无优势，反而丢失了索引值（可以使用内建函数enumerate()找回这个索引值）。但对于无法随机访问的数据结构（比如set）而言，迭代器是唯一的访问元素的方式。

另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件，或是斐波那契数列等等。

迭代器更大的功劳是提供了一个统一的访问集合的接口，只要定义了__iter__()方法对象，就可以使用迭代器访问。

迭代器有两个基本的方法：

• next方法：返回迭代器的下一个元素
• __iter__方法：返回迭代器对象本身

5、生成器

使用了 yield 的函数被称为生成器（generator），生成器是一个返回迭代器的函数。

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:
        sys.exit() 

　　ps:在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
    
3.函数

1、一般函数（def）

在python中函数定义的格式如下：

　　def 函数名(形参):

　　　　函数体内部代码块

函数的调用使用 函数名(实参) 就可以调用函数了。

**参数分类

1. 必须参数：调用时传递的参数按顺序一一对应形参。

def f(name,age):
    print(name,age)
f("小明",18)

2.关键字参数：调用时指定参数的名称，且与函数声明时的参数名称一致。

def f(name,age,sex="male"):
    print(name,age,sex)
f(age=18,name="小明")

　　3.默认参数:是在函数声明的时候，可以给某个参数指定默认值。

def f(name,age,sex="male"):
    print(name,age,sex)
f(name="小明",18)

　　4.不定长参数 *args：可以传入不定长参数，将这些参数放到一个tuple里面，可以通过访问args来获取这些不定长参数。

def f(name,*args):
    print(args)
f("小明",18,"male")

　　5.不定长参数 **kwargs:相当于关键字参数的不定长参数，该参数可以接收不定长的命名变量参数，将这些参数放到一个字典里面，可以通过key获取到相应的参数值。

 def f(name,**kwargs):
       print(kwargs)
f("小明",age=18,sex="male")

2、匿名函数，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

4.Python函数的作用域

一共有4中，分别是：
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域
当内部作用域想访问修改外部作用域的变量时，就要用到global和nonlocal关键字了（nonlocal能用在嵌套作用域，而gobal不行）。

5.闭包

如果在一个内部函数里，对在外部作用域的自由变量(外部函数的参数)进行引用，那么内部函数就被认为是闭包（closure）。一个闭包就是你调用了一个外部函数，会返回了一个内部函数给你，这个返回的函数就叫做闭包。你在调用外部函数的时候传递的参数就是自由变量。

在Python中创建一个闭包可以归结为以下三点：

• 闭包函数必须有内嵌函数
• 内嵌函数需要引用该嵌套函数上一级namespace中的变量
• 闭包函数必须返回内嵌函数

#!/usr/bin/python
def FuncX(x):
	def FuncY(y):
		return x * y
	return FuncY

tempFunc = FuncX(3)
result = tempFunc(5)
print(result) 

result = FuncX(3)(5)
print(result)  # 15

一种特殊的闭包即Python的装饰器，可以实现在代码运行期间修改函数的上下文， 即可以定义函数在执行之前进行何种操作和函数执行后进行何种操作， 而函数本身并没有任何的改变。

装饰模式有很多经典的使用场景，例如插入日志、性能测试、事务处理等等，有了装饰器，就可以提取大量函数中与本身功能无关的类似代码，从而达到代码重用的目的。下面就一步步看看Python中的装饰器。

#现在有一个简单的函数”myfunc”，想通过代码得到这个函数的大概执行时间。
import time
def deco(func):
	def wrapper():
		starttime=time.time()
		func()
		endtime=time.time()
		msecs=(endtime-starttime)*1000
		print("func used time %f ms"%msecs)
	return wrapper
'''
def myfunc():
	print("func starting...")
	time.sleep(0.6)
	print("func end!")

#调用闭包
print("myfunc is :",myfunc.__name__)
myfunc=deco(myfunc)
print("myfunc is :",myfunc.__name__)
myfunc()
'''
#装饰器
@deco
def myfunc():
	print("func starting...")
	time.sleep(0.6)
	print("func end!")
print("myfunc is :",myfunc.__name__)
myfunc()