一种选择是使用Python的切片和索引功能来逻辑地评估条件保持的位置并覆盖那里的数据。
假设您可以使用pandas.read_csv将数据直接加载到pandas中，那么下面的代码可能对您有帮助。

import pandas
df = pandas.read_csv("test.csv")
df.loc[df.ID == 103, 'FirstName'] = "Matt"
df.loc[df.ID == 103, 'LastName'] = "Jones"

字符串
正如在注解中提到的，你也可以一次完成对两列的赋值：

df.loc[df.ID == 103, ['FirstName', 'LastName']] = 'Matt', 'Jones'

型

**请注意，您需要pandas版本0.11或更高版本才能使用loc进行覆盖赋值操作。**实际上，对于像0.8这样的旧版本（尽管链式赋值的批评者可能会说），链式赋值是 * 正确的 * 方式，因此即使在更现代的pandas版本中应该避免，了解它也是有用的。

另一种方法是使用所谓的链式赋值。这种方法的行为不太稳定，因此它不被认为是最好的解决方案（在文档中明确不鼓励），但了解以下内容是有用的：

import pandas
df = pandas.read_csv("test.csv")
df['FirstName'][df.ID == 103] = "Matt"
df['LastName'][df.ID == 103] = "Jones"

型

你可以使用map，它可以从一个字典甚至一个自定义函数Mapvales。
假设这是你的DF：

ID First_Name Last_Name
0  103          a         b
1  104          c         d

字符串
创建dicts：

fnames = {103: "Matt", 104: "Mr"}
lnames = {103: "Jones", 104: "X"}

型
和Map：

df['First_Name'] = df['ID'].map(fnames)
df['Last_Name'] = df['ID'].map(lnames)

型
结果将是：

ID First_Name Last_Name
0  103       Matt     Jones
1  104         Mr         X

型
或者使用自定义函数：

names = {103: ("Matt", "Jones"), 104: ("Mr", "X")}
df['First_Name'] = df['ID'].map(lambda x: names[x][0])

型

最初的问题解决了一个特定的狭义用例。对于那些需要更通用答案的人，这里有一些例子：

使用其他列的数据创建新列

考虑到下面的框架：

import pandas as pd
import numpy as np

df = pd.DataFrame([['dog', 'hound', 5],
                   ['cat', 'ragdoll', 1]],
                  columns=['animal', 'type', 'age'])

In[1]:
Out[1]:
  animal     type  age
----------------------
0    dog    hound    5
1    cat  ragdoll    1

字符串
下面我们通过使用+操作添加一个新的description列作为其他列的串联。对于series，+操作被覆盖。花哨的字符串格式，f字符串等在这里不起作用，因为+适用于标量而不是“原始”值：

df['description'] = 'A ' + df.age.astype(str) + ' years old ' \
                    + df.type + ' ' + df.animal

In [2]: df
Out[2]:
  animal     type  age                description
-------------------------------------------------
0    dog    hound    5    A 5 years old hound dog
1    cat  ragdoll    1  A 1 years old ragdoll cat

型
我们得到了猫的1 years（而不是1 year），我们将在下面使用条件修正。

使用条件修改现有列

在这里，我们将原始的animal列替换为其他列的值，并使用np.where根据age的值设置一个条件子串：

# append 's' to 'age' if it's greater than 1
df.animal = df.animal + ", " + df.type + ", " + \
    df.age.astype(str) + " year" + np.where(df.age > 1, 's', '')

In [3]: df
Out[3]:
                 animal     type  age
-------------------------------------
0   dog, hound, 5 years    hound    5
1  cat, ragdoll, 1 year  ragdoll    1

型

使用条件修改多列

一种更灵活的方法是在整个框架上调用.apply()，而不是在单个列上：

def transform_row(r):
    r.animal = 'wild ' + r.type
    r.type = r.animal + ' creature'
    r.age = "{} year{}".format(r.age, r.age > 1 and 's' or '')
    return r

df2 = df.apply(transform_row, axis=1)
print(df2)

In[4]:
Out[4]:
         animal            type      age
----------------------------------------
0    wild hound    dog creature  5 years
1  wild ragdoll    cat creature   1 year

型
在上面的代码中，transform_row(r)函数接受一个表示给定行的Series对象（由axis=1表示，axis=0的默认值将为每列提供一个Series对象）。这简化了处理，因为您可以使用列名访问行中的实际“原始”值，并可以看到给定行/列中的其他单元格。

这个问题可能仍然经常被访问，因此值得为Kemp先生的答案提供一个补充。dict内置类可以被子类化，以便为“丢失”键返回默认值。这种机制在pandas中工作得很好。但请参阅下文。
这样就可以避免关键错误。

>>> import pandas as pd
>>> data = { 'ID': [ 101, 201, 301, 401 ] }
>>> df = pd.DataFrame(data)
>>> class SurnameMap(dict):
...     def __missing__(self, key):
...         return ''
...     
>>> surnamemap = SurnameMap()
>>> surnamemap[101] = 'Mohanty'
>>> surnamemap[301] = 'Drake'
>>> df['Surname'] = df['ID'].apply(lambda x: surnamemap[x])
>>> df
    ID  Surname
0  101  Mohanty
1  201         
2  301    Drake
3  401

字符串
同样的事情可以用下面的方法更简单地完成。对dict对象的get方法使用“default”参数使得没有必要子类化dict。

>>> import pandas as pd
>>> data = { 'ID': [ 101, 201, 301, 401 ] }
>>> df = pd.DataFrame(data)
>>> surnamemap = {}
>>> surnamemap[101] = 'Mohanty'
>>> surnamemap[301] = 'Drake'
>>> df['Surname'] = df['ID'].apply(lambda x: surnamemap.get(x, ''))
>>> df
    ID  Surname
0  101  Mohanty
1  201         
2  301    Drake
3  401

型

df['FirstName']=df['ID'].apply(lambda x: 'Matt' if x==103 else '')
df['LastName']=df['ID'].apply(lambda x: 'Jones' if x==103 else '')

字符串

如果有人正在寻找一种方法来根据每行本身的某些逻辑条件更改多行的值，那么将.apply()与函数一起使用就是一种方法。

df = pd.DataFrame({'col_a':[0,0], 'col_b':[1,2]})

   col_a  col_b
0      0      1
1      0      2

def func(row):
    if row.col_a == 0 and row.col_b <= 1:
        row.col_a = -1
        row.col_b = -1
    return row

df.apply(func, axis=1)

   col_a  col_b
0     -1     -1 # Modified row
1      0      2

字符串
虽然.apply()通常用于向一个嵌套框架添加一个新的行/列，但它也可以用于修改现有行/列的值。

我发现通过打印出每一行满足条件的地方来首次亮相要容易得多：

for n in df.columns:
    if(np.where(df[n] == 103)):
        print(n)
        print(df[df[n] == 103].index)

字符串