遍历(Iterable) everything
简单的说，Python 中一个对象只要实现了__iter__() 或 getitem() 方法，就成为可迭代(Iterable)的对象，通俗的讲就是这个对象是可数的。常见的可迭代对象包括：列表（list）、元组（tuple）、字典（dict）、集合（set）、字符串（str）等。
前言：处理迭代对象(Iterable)的三种方法
1.zip
zip() 是把几个可迭代对象(Iterable)叠在一起，按照对应0,1,2...的顺序将各个对象的重新分组，组成一个个元组（tuple），最后返回包含这些元组的列表（list）。
在 Python 3.x 中 zip() 返回的是一个对象，如需展示列表，需手动 list() 转换。
a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9, 10]
zz = zip(a, b)
print(list(zz))
# 输出 [(1, 4), (2, 5), (3, 6)]
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
zz1 = zip(a, c)
print(list(zz1))
# 输出 [(1, 7), (2, 8), (3, 9)]
利用 * 号操作符，可以将元组解压为列表。
x,y = zip(*zz)
print(x)
print(y)
# 输出
# (1, 2, 3)
# (4, 5, 6)
2.lambda
Python中 lambda 指的是匿名函数，通俗的讲就是我在某处需要处理一些问题，又不想为此去单独定义一个函数，因为用一次就完了，不再用第二次，这个时候就需要这个 Lambda 匿名函数了。
它的写法为：
lambda arguments(所给的参数) : expression(表达式)
比如参数 a 加 10 ，并返回结果
x = lambda a : a + 10
print(x(5))
# 输出 5
参数 a,b 相乘并返回结果
x = lambda a, b : a * b
print(x(5, 6))
# 输出 30
通常 lambda 与 map 结合来处理可迭代对象。
3. map
Python 中的 map 函数应用于可迭代对象的每一个元素，返回的是一个结果list。 如果有其他的可迭代参数传进来，map 函数则会把每一个参数都以相应的处理函数进行迭代处理。 map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
例如：
a = [1, 2, 3, 4, 5]
print(list(map(str,a)))
# 输出 ['1', '2', '3', '4', '5']
str 是 python 的内置函数，这里是把列表的每个元素变成了str类型，然后以列表的形式返回。 当然也可以传入自定义函数：
def mul(x):
return x*x
n = [1, 2, 3, 4, 5]
res = map(mul, n)
print(list(res))
# 输出 [1, 4, 9, 16, 25]
这里的自定义函数完全可以用上面提到的匿名函数代替：
res = map(lambda x: x*x, n)
其输出结果是一样的。
一，对dataframe的行和列进行遍历和修改**
首先先定一个这样的字典,然后我们用不同的方法对其遍历和修改
df=pd.DataFrame({"A":[1,2,3,4],"B":[5,6,7,8],"C":[1,1,1,1]})
A B C
0 1 5 1
1 2 6 1
2 3 7 1
3 4 8 1
i.遍历列
1.ix函数（df.ix[条件，操作区域]）
df.ix[df.A>1,'B']=-1
df
A B C
0 1 5 1
1 2 **-1** 1
2 3 **-1** 1
3 4 **-1** 1
2.iterrows()函数。
这个函数一般跟index和row一起使用，应为他会返回两个值，一个就是index，一个是行
for index,row in df.iterrows():
if row['A']>1:
row['B']=-1
A B C
0 1 5 1
1 2 **-1** 1
2 3 **-1** 1
3 4 **-1** 1
3.where函数，np.where(条件，then，else)
df["then"]=np.where(df.A<3,1,0)
df
A B C then
0 1 5 1 1
1 2 6 1 1
2 3 7 1 0
3 4 8 1 0
4.apply函数你可以对行或列每一个数值进行自己指定函数的操作
def judgeLevel(df):
if df['A'] < 2:
return 'C'
elif df['A'] > 3:
return 'A'
else:
return 'B'
df['level']=df.apply(lambda r:judgeLevel(r),axis=1)
df
A B C level
0 1 5 1 C
1 2 6 1 B
2 3 7 1 B
3 4 8 1 A
ii.遍历列 - iloc函数
for i in range(0, len(df)):
print (df.iloc[i]['A'], df.iloc[i]['B'])
1 5
2 6
3 7
4 8
Pandas对象之间的基本迭代的行为取决于类型。当迭代一个系列时，它被视为数组式，基本迭代产生这些值。其他数据结构，如：DataFrame和Panel，遵循类似惯例迭代对象的键。简而言之，基本迭代(对于i在对象中)产生。
Series – 值
DataFrame – 列标签
Pannel – 项目标签
（一） 迭代DataFrame**
迭代DataFrame提供列名。现在来看看下面的例子来理解这个概念。
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
for col in df:
print (col)
执行上面示例代码，得到以下结果 –
A
C
D
x
y
要遍历数据帧(DataFrame)中的行，可以使用以下函数 –
• iteritems() – 迭代(key，value)对
• iterrows() – 将行迭代为(索引，系列)对
• itertuples() – 以namedtuples的形式迭代行
（二） iteritems()示例
将每个列作为键，将值与值作为键和列值迭代为Series对象。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
print(key,value)
执行上面示例代码，得到以下结果 –
col1 0 0.459280
1 0.302563
2 -0.925297
3 -1.701360
Name: col1, dtype: float64
col2 0 -2.577661
1 -0.840329
2 0.277956
3 0.141397
Name: col2, dtype: float64
col3 0 -0.819635
1 0.826029
2 -0.038953
3 0.379977
Name: col3, dtype: float64
观察一下，单独迭代每个列作为系列中的键值对。
（三） iterrows()示例
iterrows()返回迭代器，产生每个索引值以及包含每行数据的序列。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
print(row_index,row)
执行上面示例代码，得到以下结果 –
0 col1 0.589103
col2 -1.344540
col3 -0.273822
Name: 0, dtype: float64
1 col1 -1.799794
col2 0.191032
col3 -0.470350
Name: 1, dtype: float64
2 col1 1.538743
col2 -0.443371
col3 -1.234744
Name: 2, dtype: float64
3 col1 -1.700915
col2 0.637768
col3 0.320671
Name: 3, dtype: float64
注意 – 由于iterrows()遍历行，因此不会跨该行保留数据类型。0,1,2是行索引，col1，col2，col3是列索引。
（四） itertuples()示例
itertuples()方法将为DataFrame中的每一行返回一个产生一个命名元组的迭代器。元组的第一个元素将是行的相应索引值，而剩余的值是行值。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
print(row)
执行上面示例代码，得到以下结果 –
Pandas(Index=0, col1=-0.459994067109029, col2=-1.3589032966943688, col3=-0.8378124266875753)
Pandas(Index=1, col1=-0.675609143041429, col2=0.9365900839103676, col3=0.16686318229869906)
Pandas(Index=2, col1=-0.32119668362802845, col2=0.31388056160597017, col3=1.3433307873076799)
Pandas(Index=3, col1=1.2368409605416566, col2=1.184780890409777, col3=-0.27277256974192443)
注意 – 不要尝试在迭代时修改任何对象。迭代是用于读取，迭代器返回原始对象(视图)的副本，因此更改将不会反映在原始对象上。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for index, row in df.iterrows():
row['a'] = 10
print(df)
执行上面示例代码，得到以下结果 –
col1 col2 col3
0 0.534370 0.245170 0.247378
1 -0.375285 -0.370878 -0.258897
2 0.910811 -1.566585 -0.857689
3 0.468804 -1.407227 -0.791819
注意观察结果，修改变化并未反映出来。
二，遍历字典 （ Dict )**
d.items()将字典转换为可遍历的列表
d = {'a':1,'b':2,'c':3}
for key, val in d.items():
print(key,val)
输出：
a 1
b 2
c 3
d.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])
下面的写法会报错
In [180]: d = {'a':1,'b':2,'c':3}
In [181]: for key, val in d:
...: print(key,val)
...:
---------------------------------------------------------------------------
ValueError: not enough values to unpack (expected 2, got 1)
可以这样写，直接遍历所有的键
In [180]: d = {'a':1,'b':2,'c':3}
In [183]: for key in d:
...: print(key)
...:
字典遍历
.keys() 获取字典的所有键，生成一个列表，通过遍历key键来实现字典的遍历
>>> students={'姓名':'小明','年龄':'22','联系方式':'123456','邮箱':'sunyue2019@qq.com','住址':'地球村'}
>>> students
{'姓名': '小明', '年龄': '22', '联系方式': '123456', '邮箱': 'sunyue2019@qq.com', '住址': '地球村'}
>>> for key in students.keys():
print('%s是%s'%(key,students[key]))
姓名是小明
年龄是22
联系方式是123456
邮箱是sunyue2019@qq.com
住址是地球村
.values() 获取字典的所有值，生成一个列表，可以来直接遍历value值
>>> for var in students.values():
print('获取的值为：%s'%var)
获取的值为：小明
获取的值为：22
获取的值为：123456
获取的值为：sunyue2019@qq.com
获取的值为：地球村
.items() 获取所有键值对，生成一个具有键值对的复合元组，可以来遍历字典的键与值（元素）
（ 通过两个变量进行一次性赋值，遍历key-value（键值对））
for key,var in students.items():
print('键为%s，值为%s'%(key,var))
键为姓名，值为小明
键为年龄，值为22
键为联系方式，值为123456
键为邮箱，值为sunyue2019@qq.com
键为住址，值为地球村
三，enumerate()的用法
Python enumerate() 函数， 该函数可用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
语法
enumerate(sequence, [start=0])
参数
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回值
返回 enumerate(枚举) 对象。
实例
以下展示了使用 enumerate() 方法的实例：
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
普通的 for 循环
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
... print i, seq[i]
... i +=1
...
0 one
1 two
2 three
for 循环使用 enumerate
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print i, element
...
0 one
1 two
2 three
