遍历(Iterable) everything

目录

• 前言：处理迭代对象(Iterable)的三种方法
  • 1.zip
  • 2.lambda
  • 3. map
• 一，对dataframe的行和列进行遍历和修改**
  • i.遍历列
    • 1.ix函数（df.ix[条件，操作区域]）
    • 2.iterrows()函数。
    • 3.where函数，np.where(条件，then，else)
    • 4.apply函数你可以对行或列每一个数值进行自己指定函数的操作
  • ii.遍历列 - iloc函数
• （一） 迭代DataFrame**
• （二） iteritems()示例
• （三） iterrows()示例
• （四） itertuples()示例
• 二，遍历字典 （ Dict )**
• 三，enumerate()的用法

简单的说，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