DataFrame

• 惰性创建 DataFrame

import pandas as pd

df = pd.DataFrame({"A": [1,2,3], "B": ["a", "b", "C"]}, index=["A1", "A2", "A3"])
df
// output:
  A  B

A1  1  a
A2  2  b
A3  3  C 

• 非惰性创建 DataFrame

df = pd.DataFrame({"A": [1,2,3], "B": ["a", "b", "C"]}, None, False)
// output:
 A  B

0  1  a
1  2  b
2  3  C

df = pd.DataFrame({"A": [1,2,3], "B": ["a", "b", "C"]}, [`x,`y,`z], False)
// output:
 A  B

x  1  a
y  2  b
z  3  C

创建一个 DolphinDB 的内存表 tableForDf。

timetag =[2018.01.02, 2018.01.03, 2018.01.04, 2018.01.08].toddb()
name = [`AAPL, `AAPL, `GS, `AAPL].toddb()
flag = [`A, `A, `B, `C].toddb()
p = [10, 20, 30, 40].toddb()
tableForDf = table(p as price, flag as bsFlag, name, timetag)

• 惰性创建 DataFrame

指定 lazy = True 时，index 只能是表中的列名。

df = pd.DataFrame(tableForDf, 'timetag', True)
df
// output：
      price  bsFlag  name
timetag
2018.01.02     10       A  AAPL
2018.01.03     20       A  AAPL
2018.01.04     30       B    GS
2018.01.08     40       C  AAPL

指定 lazy = False 时，index 不能是表中的列名。

• 非惰性创建 DataFrame

level1 = ['0001', '0002', '0002', '0001']
df = pd.DataFrame(tableForDf, level1, False)
df
// output：
price  bsFlag  name     timetag

0001     10       A  AAPL  2018.01.02
0002     20       A  AAPL  2018.01.03
0002     30       B    GS  2018.01.04
0001     40       C  AAPL  2018.01.08

通过分布式表只能创建惰性 DataFrame

n=1000
month=take(seq(2000.01M, 2016.12M), n);
x=rand(1.0, n);
t=table(month, x);
dbName="dfs://test_pandas"
if(exists(dbName)):
dropDatabase(dbName)
db=database(dbName, ddb.VALUE, partitionScheme=seq(2000.01M, 2016.12M))
pt=db.createPartitionedTable(t, `pt, `month).append!(t)

# index 必须指定为表中的列名，且 lazy = True
df=pd.DataFrame(pt,index="month", lazy=True)  

df=pd.DataFrame(pt,lazy=False)   # lazy 设置为 False，则报错：cannot create non-lazy DataFrame with segmented table

创建一个内存表

timetag =[2018.01.02, 2018.01.03, 2018.01.04, 2018.01.08].toddb()
name = [`AAPL, `AAPL, `GS, `AAPL].toddb()
flag = [`A, `A, `B, `C].toddb()
p = [10, 20, 30, 40].toddb()
tableForDf = table(p as price, flag as bsFlag, name, timetag)

（1）隐式访问。因为惰性模式的 DataFrame 是原对象的一个视图，故不支持隐式访问。下例中使用非惰性的 DataFrame。

level = ['0001', '0002', '0002', '0001']
df_nonlazy=pd.DataFrame(tableForDf, level, False)

• 访问元素

df_nonlazy.iat[0, 3]
// output: 2018.01.02

• 访问列

df_nonlazy.iloc[:,1]

// output:
0001  A
0002  A
0002  B
0001  C
dtype: STRING

df_nonlazy.iloc[:,1:3] 
// output:
    bsFlag  name
  
0001       A  AAPL
0002       A  AAPL
0002       B    GS
0001       C  AAPL

df_nonlazy.iloc[:,2:]   
// output:
    name     timetag
  
0001  AAPL  2018.01.02
0002  AAPL  2018.01.03
0002    GS  2018.01.04
0001  AAPL  2018.01.08

df_nonlazy.iloc[:,:3] # select col0~col3
// output:
    price  bsFlag  name
  
0001     10       A  AAPL
0002     20       A  AAPL
0002     30       B    GS
0001     40       C  AAPL

• 访问行

df_nonlazy.iloc[1]
// output：
  price          20
bsFlag           A
  name        AAPL
timetag  2018.01.03
dtype: ANY

df_nonlazy.iloc[1:3] 
// output：
    price  bsFlag  name     timetag
  
0002     20       A  AAPL  2018.01.03
0002     30       B    GS  2018.01.04

• 行列组合访问

df_nonlazy.iloc[[0,3], [2]]
// output：
    name
  
0001  AAPL
0001  AAPL

df_nonlazy.iloc[0:3, 0:1]
// output:
    price
  
0001     10
0002     20
0002     30

df_nonlazy.iat[3, 3]
// output:
2018.01.08

（2）显式访问

• 访问列索引

df_nonlazy.price # 暂不支持属性方式访问

df_nonlazy['price']
// output：
0001  10
0002  20
0002  30
0001  40
dtype: INT

df_nonlazy[['timetag', 'price']]
// output：
       timetag  price
  
0001  2018.01.02     10
0002  2018.01.03     20
0002  2018.01.04     30
0001  2018.01.08     40

df_nonlazy.loc[:, ['timetag', 'price']]
// output：
       timetag  price
  
0001  2018.01.02     10
0002  2018.01.03     20
0002  2018.01.04     30
0001  2018.01.08     40

• 访问行索引

df_nonlazy.loc[`0001]
// output：
    price  bsFlag  name     timetag
  
0001     10       A  AAPL  2018.01.02
0001     40       C  AAPL  2018.01.08

df_nonlazy.loc[[`0001,`0002]]
// output：
    price  bsFlag  name     timetag
  
0001     10       A  AAPL  2018.01.02
0002     20       A  AAPL  2018.01.03
0002     30       B    GS  2018.01.04
0001     40       C  AAPL  2018.01.08

• 行列组合访问

df_nonlazy['name'][`0001]
// output：
0001  AAPL
0001  AAPL
dtype: STRING

df_nonlazy.at[`0001, 'name']
// output：
0001  AAPL
0001  AAPL
dtype: STRING

df_nonlazy.loc[[`0001, `0002], ['name']]
// output：
    name
  
0001  AAPL
0002  AAPL
0002    GS
0001  AAPL

（3）通过布尔掩码访问

df_nonlazy.loc[[True,True,False, False]]
df_nonlazy.iloc[[True, True,False, False]]
df_nonlazy[[True, True,False, False]]
// output:
    price  bsFlag  name     timetag
  
0001     10       A  AAPL  2018.01.02
0002     20       A  AAPL  2018.01.03 

（4）条件访问

df_nonlazy[df_nonlazy["price"]>20]
// output:
    price  bsFlag  name     timetag
  
0002     30       B    GS  2018.01.04
0001     40       C  AAPL  2018.01.08 

惰性 DataFrame 对象不支持追加、更新和删除数据。以下示例创建的 DataFrame 均为非惰性的。

（1）追加数据

• insert 追加列

df_nonlazy.insert(0, `tep, [33,33,37,37])

• 直接赋值追加行（暂不支持）

row = {"price":30, "bsFlag":'B', "name":"GS", "timetag":2018.01.09}
df_nonlazy.iloc[1] = row

（2）更新数据

# 创建一个示例 DataFrame
data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

# 使用 at 方法修改单个元素的值
df.at[0, 'A'] = 10
df.iat[1, 1] = 50

# 使用 apply 方法对整列进行操作
df['A'] = df['A'].apply(lambda x: x * 2)

如果 DataFrame 对象是通过表构建的，则通过赋值方法修改它的数据时，原表的数据也会被修改。

# 通过内存表，创建一个示例 DataFrame
t1=table([1,2,3].toddb() as value)
df=pd.DataFrame(t1,lazy=False)

# 使用 at 方法修改单个元素的值
df.at[0, 'value']=10
df.iat[1, 0] = 20
t1
// output:
value
10
20
3  

（3）删除数据

• 调用 drop 方法删除数据

df_nonlazy.drop(['name'], axis=1)