class graphlab.SFrame(data=list(), format='auto')一个列数可变的表格型数据框架对象，可以适应大数据。SFrame中的数据在GraphLabServer 中以列优先的方式存储，并且存储在持久性存储媒介（例如磁盘）中，避免了被内存大小所限制。SFrame中的每一列都是一个大小不可变的SArray，但是SFrame可以通过增加或者减少列来轻松地改变。一个SFrame基本上表现为SArray的一个有序dict。
目前，我们支持从下列方式建立SFrame。
csv 文件 （逗号分隔值）
sframe存档路径 （一个已经保存了SFrame的路径。）
普通文本文件（解析CSV选项，参见read_csv()）
一个python词典类
pandas.DataFrame
JSON
Apache Avro
PySpark RDD
以及下列数据来源
你的本地文件系统
GraphLab Server文件系统
HDFS
Amazon S3
HTTP(S).
下面仅给出了基本的示例。更多的信息和示例，请参考用户手册,API Translator,How-Tos, 和 数据科学Gallery。
参数列表：
data :array | pandas.DataFrame | string | dict, optional
解释行为取决于参数的格式。如果data参数是一个array或者Pandas DataFrame，其内容将被存储在SFrame中。如果data参数是一个string，它会被解释为一个文件。文件可以从本地文件系统或者urls中读取。(local://,hdfs://, s3://,http://).
format :string, 可选参数
数据的格式。默认情况下，‘auto’会自动推测输入数据的格式。推测规则很简单：如果数据是一个array或者一个dataframe，这个参数会分别被指定为‘array’和‘dataframe’。如果data参数是一个string，它会被作为一个文件来解释，文件的拓展名被用来推测文件类型。下面是各选项的明细：
“auto”
“array”
“dict”
“sarray”
“dataframe”
“csv”
“tsv”
“sframe”.
参考
read_csv
从csv文件中建立SFrame。最好是文本和CSV格式，因为有很多选项来控制解析器。
save
保存SFrame。
注意
在Linux中，从HDFS读取信息时，我们需要推测你的java安装路径。我们默认使用环境变量JAVA_HOME指向的地址。如果未被设定，我们会检测一些常见的安装路径。你可以使用两个环境变量来覆盖这个操作。GRAPHLAB_JAVA_HOME允许你指定一个特定的安装路径并且覆盖掉JAVA_HOME的值。
GRAPHLAB_LIBJVM_DIRECTORY覆盖掉所有值，并需要你希望使用的libjvm的精确路径，这样文件才能被找到。只有当你希望使用一个非标准的JVM时使用它。
示例
>>> import graphlab
>>> from graphlabimport SFrame构造
从dataframe 构造SFrame，并且通过网络转换dataframe 对象。
>>> df =pandas.DataFrame()
>>> sf =SFrame(data=df)从本地csv文件构造SFrame。（仅在本地服务器上工作）
>>> sf = SFrame(data='~/mydata/foo.csv')在Amazon S3上的csv文件中构造SFrame。需要环境变量AWS_ACCESS_KEY_ID 和AWS_SECRET_ACCESS_KEY 在python会话开始前设定。另外，你可以使用graphlab.aws.set_credentials()在python开始运行后设定认证，以及使用 graphlab.aws.get_credentials() 来检查这些环境变量。
>>> sf = SFrame(data='s3://mybucket/foo.csv')使用特定的java installation从HDFS读取数据。（仅在使用LINUX时环境变量适用）
>>> import os
>>>os.environ['GRAPHLAB_JAVA_HOME'] = '/my/path/to/java'
>>> from graphlabimport SFrame
>>> sf =SFrame("hdfs://mycluster.example.com:8020/user/myname/coolfile.txt")SFrame可以从取值的词典类或者SArray中构造
>>> sf =gl.SFrame({'id':[1,2,3],'val':['A','B','C']})
>>> sf
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C >>> ids =SArray([1,2,3])
>>> vals =SArray(['A','B','C'])
>>> sf =SFrame({'id':ids,'val':vals})可以从SArray中创建SFrame，列的名称自动指定。
>>> ids =SArray([1,2,3])
>>> vals =SArray(['A','B','C'])
>>> sf = SFrame([ids,vals])
>>> sf
Columns:
X1 int
X2 str
Rows: 3
Data:
X1 X2
0 1 A
1 2 B
2 3 C如果从一个带值的list中构造SFrame，将创建一个单列的SFrame。
>>> sf =SFrame([1,2,3])
>>> sf
Columns:
X1 int
Rows: 3
Data:
X1
0 1
1 2
2 3解析
graphlab.SFrame.read_csv()方法十分有效，可以导入各种行存储的格式。
首先，一些简单的示例：
>>> !cat ratings.csv
user_id,movie_id,rating
10210,1,1
10213,2,5
10217,2,2
10102,1,3
10109,3,4
10117,5,2
10122,2,4
10114,1,5
10125,1,1
>>>gl.SFrame.read_csv('ratings.csv')
Columns:
user_id int
movie_id int
rating int
Rows: 9
Data:
+---------+----------+--------+
| user_id | movie_id | rating |
+---------+----------+--------+
| 10210 | 1 | 1 |
| 10213 | 2 | 5 |
| 10217 | 2 | 2 |
| 10102 | 1 | 3 |
| 10109 | 3 | 4 |
| 10117 | 5 | 2 |
| 10122 | 2 | 4 |
| 10114 | 1 | 5 |
| 10125 | 1 | 1 |
+---------+----------+--------+
[9 rows x 3 columns]可以指定分隔符。如果“，”不是分隔符，例如此例从“ ”是分隔符。只支持单字节的分隔符。
>>> !cat ratings.csv
user_id movie_id rating
10210 1 1
10213 2 5
10217 2 2
10102 1 3
10109 3 4
10117 5 2
10122 2 4
10114 1 5
10125 1 1
>>>gl.SFrame.read_csv('ratings.csv', delimiter=' ')默认“NA”或者一个丢失的元素被解释为数据缺失。
>>> !cat ratings.csv
user_id movie_id rating
10210 1 1
10213 2 5
10217 2 2
10102 1 3
10109 3 4
10117 5 2
10122 2 4
10114 1 5
10125 1 1
>>>gl.SFrame.read_csv('ratings.csv', delimiter=' ')此外，由于是dict类和list类，可以操作JSON型格式的解释。
>>> !cat ratings3.csv
business, categories, ratings
"Restaurant 1", [1 4 910], {"funny":5, "cool":2}
"Restaurant 2", [],{"happy":2, "sad":2}
"Restaurant 3", [2,11, 12], {}
>>>gl.SFrame.read_csv('ratings3.csv')
Columns:
business str
categories array
ratings dict
Rows: 3
Data:
+--------------+--------------------------------+-------------------------+
| business | categories | ratings |
+--------------+--------------------------------+-------------------------+
| Restaurant 1 | array('d',[1.0, 4.0, 9.0, ... | {'funny': 5, 'cool': 2} |
| Restaurant 2 | array('d') | {'sad': 2, 'happy': 2} |
| Restaurant 3 | array('d',[2.0, 11.0, 12.0]) | {} |
+--------------+--------------------------------+-------------------------+
[3 rows x 3 columns]
List和dict解析器可以十分灵活，接受多种完全格式化的数据。同时，注意list和dict类是可递归的，并允许存放多种类型的值。、
下面这些list形式是合法的：
>>> !catinteresting_lists.csv
list
[]
[1,2,3]
[1;2,3]
[1 2 3]
[{a:b}]
["c",d, e]
[[a]]
>>>gl.SFrame.read_csv('interesting_lists.csv')
Columns:
list list
Rows: 7
Data:
+-----------------+
| list |
+-----------------+
| [] |
| [1, 2, 3] |
| [1, 2, 3] |
| [1, 2, 3] |
| [{'a': 'b'}] |
| ['c', 'd', 'e'] |
| [['a']] |
+-----------------+
[7 rows x 1 columns]下面这些dict是合法的：
>>> !catinteresting_dicts.csv
dict
{"classic":1,"dict":1}
{space:1 seperated:1}
{emptyvalue:}
{}
{:}
{recursive1:[{a:b}]}
{:[{:[a]}]}
>>>gl.SFrame.read_csv('interesting_dicts.csv')
Columns:
dict dict
Rows: 7
Data:
+------------------------------+
| dict |
+------------------------------+
| {'dict': 1, 'classic': 1} |
| {'seperated': 1, 'space': 1} |
| {'emptyvalue': None} |
| {} |
| {None: None} |
| {'recursive1': [{'a': 'b'}]} |
| {None: [{None: array('d')}]} |
+------------------------------+
[7 rows x 1 columns]保存
保存和加载本格式SFrame
>>>sf.save('mysframedir')
>>> sf2 =graphlab.load_sframe('mysframedir')列操作
一个SFrame是由一组SArray列构成。每一个SArray都很容易提取出来。下面示例给出了一个SFrame：
>>> sf =SFrame({'id':[1,2,3],'val':['A','B','C']})
>>> sf
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C“id”这个列可以被提取出来：
>>> sf["id"]
dtype: int
Rows: 3
[1, 2, 3]也可以被删除：
>>> delsf["id"]使用一组列名可以选取多个列。
>>> sf =SFrame({'id':[1,2,3],'val':['A','B','C'],'val2':[5,6,7]})
>>> sf
Columns:
id int
val str
val2 int
Rows: 3
Data:
id val val2
0 1 A 5
1 2 B 6
2 3 C 7
>>> sf2 =sf[['id','val']]
>>> sf2
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C
你也可以通过类型或者一组类型来选取列
>>> sf2 = sf[int]
>>> sf2
Columns:
id int
val2 int
Rows: 3
Data:
id val2
0 1 5
1 2 6
2 3 7或者类型和名称混合使用
>>> sf2 = sf[['id',str]]
>>> sf2
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C同样的技巧可以改变列的排序
>>> sf =SFrame({'id':[1,2,3],'val':['A','B','C']})
>>> sf
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C
>>> sf[['val','id']]
>>> sf
Columns:
val str
id int
Rows: 3
Data:
val id
0 A 1
1 B 2
2 C 3
元素访问和切片
SFrame可是通过整数来访问，这和一个普通的python的list是类似的。这种操作在较大的数据集上会比较慢，所以最好避免循环访问SFrame。
>>> sf =SFrame({'id':[1,2,3],'val':['A','B','C']})
>>> sf[0]
{'id': 1, 'val': 'A'}
>>> sf[2]
{'id': 3, 'val': 'C'}
>>> sf[5]
IndexError: SFrame index out ofrange导航索引可以从末尾开始访问数据。
>>> sf[-1] # returnsthe last element
{'id': 3, 'val': 'C'}
>>> sf[-2] # returnsthe second to last element
{'id': 2, 'val': 'B'}SFrame也支持所有的python切片操作
>>> sf[1000:] # Returnsan SFrame containing rows 1000 to the end
>>> sf[:1000] # Returnsan SFrame containing rows 0 to row 999 inclusive
>>> sf[0:1000:2] #Returns an SFrame containing rows 0 to row 1000 in steps of 2
>>> sf[-100:] # Returnsan SFrame containing last 100 rows
>>> sf[-100:len(sf):2]# Returns an SFrame containing last 100 rows in steps of 2逻辑滤波器
可以对SFrame进行滤波：
>>>sframe[binary_filter]Sframe是一个SFrame对象，binaryfilter是一个同样长度的SArray。结果是一个新的SFrame，仅包含binary对应行非零的数据。
支持所有的布尔运算，可以进行逻辑滤波运算。例如，给出一个SFrame：
>>> sf
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C
>>> sf[(sf['id'] >=1) & (sf['id'] <= 2)]
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B查询SArray获取更多关于逻辑滤波器的细节。
在使用简单的布尔函数比较难以表达时，它可以用于提供更普适的滤波功能，
>>>sf[sf['id'].apply(lambda x: math.log(x) <= 1)]
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B<pre name="code" class="python">
或者：
>>> sf[sf.apply(lambdax: math.log(x['id']) <= 1)]从词典类创建SFrame
>>> from graphlabimport SFrame
>>> sf =SFrame({'id':[1,2,3], 'val':['A','B','C']})
>>> sf
Columns:
id int
val str
Rows: 3
Data:
id val
0 1 A
1 2 B
2 3 C方法列表
| SFrame.add_column(data[, name]) |
向SFrame增加列 |
| SFrame.add_columns(data[, namelist]) |
向SFrame增加多个列 |
| SFrame.add_row_number([column_name, start]) |
返回一个新增列的SFrame，新增列的值为每一行的行数 |
| SFrame.append(other) |
在SFrame的末尾增加一行 |
| SFrame.apply(fn[, dtype, seed]) |
使用特定的函数转换每一行 |
| 返回每一列的名称 |
|
| 返回每一列的类型 |
|
| 返回SFrame的一个副本 |
|
| SFrame.dropna([columns, how]) |
删除缺项的数据 |
| SFrame.dropna_split([columns, how]) |
在缺项数据处分割SFrame |
| 每一列的类型 |
|
| SFrame.export_csv(filename[, delimiter, ...]) |
将SFrame保存为CSV文件 |
| SFrame.export_json(filename[, orient]) |
将SFrame写入CSV文件 |
| SFrame.fillna(column, value) |
向指定列缺项数据处写入指定值 |
| SFrame.filter_by(values, column_name[, exclude]) |
使用可迭代对象内数据进行滤波 |
| SFrame.flat_map(column_names, fn[, ...]) |
使用一个函数就SFrame中的每一行对应新SFrame的多个行 |
| SFrame.from_odbc(db, sql[, verbose]) |
将数据库中的表或者查询转换为SFrame格式 |
| SFrame.from_rdd(rdd, cur_sc) |
将 Spark RDD 转换为SFrame格式 |
| SFrame.from_sql(conn, sql_statement[, ...]) |
将SQL数据库查询结果转换为SFrame格式 |
| SFrame.groupby(key_columns, operations, *args) |
将关键列按给出的列聚合。 |
| SFrame.head([n]) |
返回SFrame的前n行。 |
| SFrame.join(right[, on, how]) |
拼接两个SFrame。 |
| 返回此SFrame的列数。 |
|
| 返回此SFrame的列数。 |
|
| 返回此SFrame的行数。 |
|
| SFrame.pack_columns([columns, ...]) |
将当前多列合并为一列。 |
| SFrame.print_rows([num_rows, num_columns, ...]) |
以人类方便阅读的方式打印SFrame的前N行N列。 |
| SFrame.random_split(fraction[, seed]) |
将一个SFrame按行随机分割成两个SFrame。 |
| SFrame.read_csv(url[, delimiter, header, ...]) |
从一个CSV文件或者一个包含若干CSV文件的路径构造SFrame。 |
| SFrame.read_csv_with_errors(url[, ...]) |
从CSV文件或者一个含有若干CSV文件的路径中构造SFrame，返回两个值，分别是SFrame和一个文件名词典，包含指向每一个解析错误的文件的SArray。 |
| SFrame.read_json(url[, orient]) |
读取JSON文件，表达为SFrame格式。 |
| SFrame.remove_column(name) |
从SFrame删除一个列。 |
| SFrame.remove_columns(column_names) |
从SFrame中删除一个或多个列。 |
| SFrame.rename(names) |
重命名指定列 |
| SFrame.sample(fraction[, seed]) |
将当前SFrame按行取样。 |
| SFrame.save(filename[, format]) |
将SFrame保存在文件系统中。 |
| SFrame.select_column(key) |
得到一个对应指定关键词的SArray的引用。 |
| SFrame.select_columns(keylist) |
选择列名或者列类型在关键词列表中的所有列。 |
| SFrame.show([columns, view, x, y]) |
使用GraphLab Create canvas来使SFrame可视化。 |
| SFrame.sort(sort_columns[, ascending]) |
使用指定列的指定顺序将SFrame排序 |
| SFrame.split_datetime(expand_column[, ...]) |
将SFrame的datetime列分割成多个列，每个值在一个独立的列。 |
| SFrame.stack(column_name[, new_column_name, ...]) |
通过把所有值堆起来，将一个“宽”的列分割成一个或两个“高”的列。 |
| SFrame.swap_columns(column_1, column_2) |
交换SFrame指定列 |
| SFrame.tail([n]) |
SFrame的最后几行 |
| 将当前SFrame转换为 pandas.DataFrame. |
|
| 将SFrame转换为 numpy array |
|
| SFrame.to_odbc(db, table_name[, ...]) |
将SFrame转换为数据库中的一个表。 |
| SFrame.to_rdd(sc[, number_of_partitions]) |
将当前SFrame转换为 Spark RDD. |
| SFrame.to_spark_dataframe(sc, sql[, ...]) |
将当前的SFRame转换为Spark DataFrame. |
| SFrame.to_sql(conn, table_name[, ...]) |
将SFrame转换为一个SQL数据库中的单一表。 |
| SFrame.topk(column_name[, k, reverse]) |
获取指定列的前k行。 |
| 删除SFrame中重复的列。 |
|
| SFrame.unpack(unpack_column[, ...]) |
将一列扩增到多列，每一个值都是一个独立的列。 |
| SFrame.unstack(column[, new_column_name]) |
将一个或两个列合并到一个列，使用其它所有列分组。 |