python中一些简便使用的方法

1，range()

range()一般用来控制for循环，它同样也可以循环使用每次的序列元素，而不是序列的下标：

看下面的例子：

S = "jkllmghb"

for i in range(0,len(S),2):

　　print(S[i])

上面的例子中，在range函数中，分别定义上限，下限和每次循环的步长。

2，enumerate()

enumerate()在每次循环中，返回的是一个包含两个元素的定指表，两个元素分别是下标和元素

>>> s = 'liub'
>>> for a,b in enumerate(s):
	print(a,b)

	
0 l
1 i
2 u
3 b
>>> 

3，zip()

如果有多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便实现：

>>> j = [1,2,3,4]
>>> l = ['white','ivory','yellow','seashell']
>>> k = [11,22,33,44]
>>> for (a,b,c) in zip(j,l,k):
	h = (a,b,c)
	print(type(h))
	print(a,b,c)

	
<class 'tuple'>
1 white 11
<class 'tuple'>
2 ivory 22
<class 'tuple'>
3 yellow 33
<class 'tuple'>
4 seashell 44
>>> 

每次循环时，从各个序列分别从左到右取出一个元素，合并成一个tuple,然后tuple的元素赋予给a,b,c

4,循环对象

循环对象是这样一个对象，它包含一个next()方法，这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误

当一个循环结构调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()

open()返回的实际上是一个循环对象，包括next()方法。

for line in open('test.txt'):

　　print line

相对于序列，用循环对象的好处在于：不用在循环还没开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成，这样比较节省空间

5，迭代器 iter()

循环对象和for 循环调用之间还有一个中间层，就是要将循环对象转换成迭代器（iterator）。这一转换是通过使用iter()函数实现的。

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> ls = [1,2,3,4]
>>> it = iter(ls)
>>> print(next(it))
1
>>> for i in range(len(ls)):
	print(next(it))

	
2
3
4
Traceback (most recent call last):
  File "<pyshell#6>", line 2, in <module>
    print(next(it))
StopIteration
>>> 

它包含一个next()方法，这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration（停止迭代）错误

当一个循环结构调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()

6，生成器 yield

生成器（generator）的主要目的是构成一个用户自定义的循环对象

生成器的编写方法和函数定义类似，只是在return的地方改成yield，生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。

当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值。

def gen():

　　a = 100

　　yield a

　　a = a*8

　　yield a

　　yield 1000

该生成器共有三个yield，如果用作循环器时，会进行三次循环

for i in gen():

　　print(i)

生成器表达式：

G=(x for x in range(10))

生成器表达式是生成器的一种简便编写方式

列表推导：

列表推导（com prehension）是快速生成表的方法，它的语法简单，很有使用价值。

列表推导的衍生过程：

L=[]

for x in range(10):

　　L.append(x**2)

用列表推导式表示：

[x**2 for i in range(10)]

列表推导式中使用if-else:

当只有if的时候：

[x*2 for x in range(10) if x>5]

if-else的时候:

[x*2 if x>5 else x for x in range(100)]

lambda函数：

在python里一切皆对象，函数也是一个对象，具有属性，作为对象，可以赋值给其他对象名，或者作为参数传递

例子如下：

f = lambda x,y:x+y

print(f(3,4))

lambda生成一个函数对象，该函数参数为x,y，返回值为x+y。函数对象赋给f，f的调用与正常函数无异。

以上定义可以改写成：

def f(x,y):

　　return x+y

map()函数

map()是python的内置函数，它的第一个参数是一个函数，后面的参数是包含多个元素的表。map()的功能是将函数对象依次作用于表的每一个元素。

例子：

re =map((lambda x:x+3),[1,3,5])

每次作用的结果储存于re表中，在python3.x中，map()的返回值是一个循环对象。可以利用list()函数，将该循环对象转换成列表

filter()函数

filter函数的第一个参数也是一个函数对象，它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True。则该次的元素被储存于返回的表中。

filter通过读入的函数来筛选数据。同样，在python3.x中，filter返回的不是列表，而是循环对象。

使用方法如下：

>>> def func(a):
    if a > 100:
        return True
    else:
        return False

>>> b = filter(func, [98, 100, 107, 108])
>>> for i in b:
	print(i)

	
107
108
>>> 

reduce()函数

reduce函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。如下例：

>>> from functools import reduce
>>> a = reduce((lambda x,y:x+y),[1,2,9,4,5])
>>> a
21
>>> 

验证你们的猜想

sum函数就不用介绍了吧，就是全部加起来的意思

>>> sum([1,2,9,4,5])
21
>>> 

reduce将表中的前两个元素(1和2)传递给lambda函数，得到3。
该返回值（3）将作为lambda函数的第一个参数，而表中的下一个元素（9）作为lambda函数的第二个参数，进行下一次的lambda函数的调用，依次调用lambda函数，每次lambda函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。