使用Dask映射分区时，解压函数内部的元组
Dask是一个用于并行计算的开源Python库，它提供了高级的并行计算接口，可以在大规模数据集上进行分布式计算。在Dask中，映射分区是一种将函数应用于数据集中每个分区的操作。
当使用Dask映射分区时，解压函数内部的元组是指将函数应用于数据集中每个分区时，将元组解压为独立的参数。这样可以方便地对每个分区进行个别处理。
以下是完善且全面的答案：
概念： Dask：Dask是一个用于并行计算的开源Python库，它提供了高级的并行计算接口，可以在大规模数据集上进行分布式计算。
映射分区：映射分区是Dask中的一种操作，它将函数应用于数据集中的每个分区，以实现并行计算。
解压函数内部的元组：解压函数内部的元组是指在映射分区操作中，将元组解压为独立的参数，以便对每个分区进行个别处理。
分类： 映射分区是Dask中的一种数据操作，属于数据处理和并行计算领域。
优势：
- 并行计算：映射分区操作可以并行地应用于数据集的每个分区，充分利用多核处理能力，提高计算效率。
- 灵活性：解压函数内部的元组可以方便地对每个分区进行个别处理，适用于各种复杂的数据处理需求。
- 分布式计算：Dask可以将映射分区操作应用于分布式计算集群，实现大规模数据集的并行计算。
应用场景： 映射分区操作在以下场景中特别有用：
- 大规模数据处理：当需要对大规模数据集进行复杂的计算或转换时，映射分区操作可以提高计算效率。
- 数据清洗和转换：映射分区操作可以应用于数据清洗和转换过程中，对每个分区进行个别处理，提高数据处理的灵活性和效率。
- 机器学习和数据挖掘：在机器学习和数据挖掘任务中，映射分区操作可以应用于特征提取、模型训练等步骤，加速计算过程。
推荐的腾讯云相关产品和产品介绍链接地址： 腾讯云提供了一系列与云计算相关的产品和服务，以下是其中一些与Dask相关的产品和服务：
- 弹性MapReduce（EMR）：腾讯云弹性MapReduce（EMR）是一种大数据处理和分析服务，可以与Dask结合使用，实现大规模数据集的并行计算。详情请参考：腾讯云弹性MapReduce（EMR）
- 云服务器（CVM）：腾讯云云服务器（CVM）提供了高性能的虚拟服务器实例，可以用于搭建Dask集群进行分布式计算。详情请参考：腾讯云云服务器（CVM）
- 对象存储（COS）：腾讯云对象存储（COS）是一种高可用、高可靠、低成本的云存储服务，可以用于存储和管理Dask计算过程中的数据。详情请参考：腾讯云对象存储（COS）
请注意，以上推荐的腾讯云产品仅作为示例，实际选择产品时应根据具体需求进行评估和选择。
相关·内容
我有拼花文件，也就是800 K行x8.7K列。我把它装进了一个dask数据仓库：
import dask.dataframe as dd
dask_train_df = dd.read_parquet('train.parquet')
dask_train_df.info()
这产生了：
<class 'dask.dataframe.core.DataFrame'>
Columns: 8712 entries, 0 to 8711
dtypes: int8(8712)
当我尝试执行像dask_train_df.head()或dask_train_df
浏览 0提问于2018-12-24得票数 6
回答已采纳
1回答
我想知道是否有可能将dask对象转换为生成器。具体地说，是否可以使用dask数据帧复制以下pandas-based生成器，将每个分区转换为生成器：
import pandas as pd
import dask.dataframe as dd
df = pd.DataFrame(range(10), columns=['a'])
ddf = dd.from_pandas(df, npartitions=3)
def gen_pandas(df):
# this is a sample function, its content is not
# important as l
浏览 7提问于2021-07-09得票数 1
2回答
我正在使用python 3和dask来读取拼图文件的列表，做一些处理，然后将它们全部放入一个新的联合拼图文件中供以后使用。
该过程使用了如此多的内存，以至于它似乎试图在将所有拼图文件写入新的拼图文件之前将它们读取到内存中。
我正在使用下面的代码
def t(path):
import dask.dataframe as dd
ddf = dd.read_parquet(path)
ddf["file"] = path
return ddf
b = bag.from_sequence(parquet_files)
with ProgressBar
浏览 107提问于2019-08-04得票数 2
我想知道为什么Pandas可以分块打开gzip压缩文件，而Dask必须在处理之前将整个文件加载到内存中。
具体地说，我有一个gzip压缩的csv文件，大小约为10 of (未压缩时约为50 of)。我的电脑有16 My的内存。
我认为gzip文件不能分块操作，因为它们需要在分区之前解压缩。但是，我能够使用Pandas的chunk方法处理gzip文件，没有任何问题。
另外，由于我将来想使用Dask，你能推荐给我任何可以被Dask轻松分块读取的压缩格式吗？
浏览 15提问于2020-11-12得票数 0
我有几个gzip文件(每个3.5 as )，到目前为止，我使用Pandas来读取这些文件，但它非常慢，我也尝试过Dask，但它似乎不支持gzip文件中断。有没有更好的方法来快速加载这些庞大的gzip文件？
Dask和Pandas代码：
df = dd.read_csv(r'file', sample = 200000000000,compression='gzip')
我希望它能尽可能快地读取整个文件。
浏览 6提问于2019-08-09得票数 2
我有一个一亿行数据的Dask数据。
我试图在不将整个数据文件加载到RAM的情况下迭代这个数据文件。
在实验中，尝试访问等于1的索引行。
%time dask_df.loc[1].compute()
花费的时间高达8.88秒(华尔街时间)。
为什么要花这么长时间？
我能怎么做才能让它更快？
提前谢谢。
每一个请求，这是代码。它只是读取1亿行数据并尝试访问一行。
`dask_df = dd.read_parquet("/content/drive/MyDrive/AffinityScore_STAGING/staging_affinity_block1.gzip", chunksi
浏览 7提问于2022-07-01得票数 0
回答已采纳
1回答
使用dask返回多个数据帧
、、、、
我使用read_csv()读取csv文件的长列表，并返回两个数据文件。我已经设法用达斯克加速了这一行动。不幸的是，在使用dask时，我无法返回多个变量。
下面的最低工作示例复制了我的问题：
@delayed(nout = 2)
def function(a):
d = 0
c = a + a
if a>4: # random condition to make c and d of different lenghts
d = a * a
return pd.DataFrame([c])#, pd.DataFrame([d])
list = [1,2,3,4,5]
浏览 11提问于2022-04-01得票数 1
我可以很容易地转换成熊猫的字符串，如下所示.
df.date = pd.to_datetime(df.date, format="%m/%d/%Y")
在达斯克似乎没有一条容易的路？
以下是适合日期的熊猫示例：
import pandas as pd
url="http://web.mta.info/developers/data/nyct/turnstile/turnstile_170128.txt"
df=pd.read_csv(url)
df.info()
df.columns=['ca', 'unit', '
浏览 3提问于2017-05-06得票数 2
回答已采纳
我希望在Dataframe上加速一个任务，该任务为每一行保存一个图像到本地文件夹。所以，它什么也不回。我试图使用Dask运行该函数，但是Dask似乎要求函数返回一些内容；我无法使.apply工作.
还有其他办法让这件事成功吗？
更新:最少可复制的示例
import dask.dataframe as dd
import pandas as pd
doc = pd.DataFrame({'file_name': ['Bob', 'Jane', 'Alice','Allan'],
&#
浏览 2提问于2022-10-18得票数 0
当我尝试使用dask清理大量jsonl文件时，如果我使用的分区大小为128MB，它会提示我列顺序不匹配，但如果我使用的分区大小为512MB，则可以很好地工作 所以我的代码看起来像这样： import dask.dataframe as dd
import pandas as pd
from dask.distributed import Client
client = Client(n_workers = 1, threads_per_worker = 4)
meta = dd.utils.make_meta([('x1', 'object'), ('
浏览 20提问于2021-04-06得票数 1
回答已采纳
1回答
的目标：加快在大数据帧(190万行)上应用函数行的速度
尝试：使用dask map_partitions，其中分区==核数。我编写了一个应用于每一行的函数，创建了一个包含可变数量的新值(介于1到55之间)的dict。此功能独立工作。
问题：--我需要一种将每个函数的输出组合成最终数据的方法。我尝试使用df.append，在这里我会将每个数据块附加到一个新的dataframe中并返回这个dataframe。如果我理解Dask，那么Dask应该将它们组合成一个大的DF。不幸的是，这一行正在触发一个错误(ValueError:无法将输入数组从形状(56)广播到形状(1))。这让我相信这与Dask中的
浏览 0提问于2018-07-30得票数 0
回答已采纳
我有11年的数据和记录(行)每秒钟，超过100列。它用一系列的日期时间(用Pandas to_datetime()创建)进行索引，我们需要能够在列之间进行一些相关分析，一次只能加载两个列。我们可能在较低的时间(例如48小时、1小时、月等)重新采样。在长达11年的时间里，把这些关联想象成11年。
数据目前在11个单独的拼花文件中(每年一个)，从11个.txt文件中单独生成Pandas。熊猫没有对任何这些文件进行分区。在内存中，这些拼花文件中的每一个都加载了大约20 In的内存。预期的目标机器只有16 GB，即使在11年中只加载1列也需要10 GB，因此两列也不适合。
是否有一个比使用Pandas
浏览 29提问于2022-06-20得票数 1
当使用pandasv0.25及更高版本时，我可以生成具有自定义名称的聚合列。
import pandas as pd
data = {"x": [1, 1, 2], "y": [-1, 0, 0]}
pd_df = pd.DataFrame(data)
this_is_valid = pd_df.groupby("x").agg(my_custom_name=("y", "mean"))
但是，当我尝试使用dataframe做同样的操作时，我会得到一个“意外的关键字参数”错误。
import dask.data
浏览 3提问于2021-11-18得票数 1
回答已采纳
我读了下面的，现在我正在试着去理解它。下面是我的例子：
import dask.dataframe as dd
import pandas as pd
from dask.multiprocessing import get
import random
df = pd.DataFrame({'col_1':random.sample(range(10000), 10000), 'col_2': random.sample(range(10000), 10000) })
def test_f(col_1, col_2):
return col_1*co
浏览 0提问于2017-11-06得票数 8
回答已采纳
1回答
我有一个非常大的(150米行-30 RAM内存)数据格式。我做一个组(大约40个组)，并对每个组应用一个函数。每件事都需要30分钟的时间。下面是我使用的代码：
df = df.groupby(by='date').apply(func=my_func)
由于这些操作不是相互依赖的，所以我想我应该使用Dask分别并行处理每个组。
所以我使用这个代码：
from dask import dataframe as dd
df_dask = dd.from_pandas(df_pandas, npartitions=40)
template = pd.DataFrame(colu
浏览 5提问于2019-10-21得票数 0
我尝试在Dask数据帧的多个分区上运行一个函数。该代码需要解压元组，并且可以很好地与Pandas一起工作，但不能与Dask map_partitions一起工作。数据对应于元组列表，其中列表的长度可以变化，但元组始终具有已知的固定长度。
import dask.dataframe as dd
import pandas as pd
def func(df):
for index, row in df.iterrows():
tuples = row['A']
for t in tuples:
x, y = t
浏览 27提问于2021-02-24得票数 1
回答已采纳
1回答
我在ETL中使用dask而不是pandas，即从S3存储桶中读取CSV，然后进行一些所需的转换。Until here - dask读取和应用转换的速度比pandas快！
最后，我使用to_sql将转换后的数据转储到Redshift。在dask中这个to_sql转储比在pandas中花费更多的时间。
有没有可能缩短这段时间？如果不是，为什么在这种情况下dask比熊猫慢？
浏览 2提问于2021-09-27得票数 1
1回答
我正在尝试使用我设置的dask集群来运行和并行化这个sqlalchemy查询，因为我没有足够的内存从本地计算机执行它。 我的代码如下-我不确定这是否是实现这一目标的最佳方法： from dask.distributed import Client
import dask.dataframe as dd
from dask.delayed import delayed
client = Client(<IP Address>)
recent_dates = ['2020-04-24', '2020-04-23', 2020-04-22']
浏览 43提问于2020-04-26得票数 0
回答已采纳
1回答
所以我对dask DataFrame.append有个问题。我从主数据中生成了许多派生特征，并将它们附加到主数据框架中。在此之后，任何一组列的dask图都会被放大。下面是一个小示例：
%pylab inline
import numpy as np
import pandas as pd
import dask.dataframe as dd
from dask.dot import dot_graph
df=pd.DataFrame({'x%s'%i:np.random.rand(20) for i in range(5)})
ddf = dd.from_pandas(df
浏览 3提问于2017-02-02得票数 3
回答已采纳
1回答
如何避免任务图中的大对象
、、、
我正在使用dask.distributed运行模拟。我的模型定义在一个延迟函数中，并且我堆叠了几个实现。下面的代码片段中给出了我所做工作的简化版本：
import numpy as np
import xarray as xr
import dask.array as da
import dask
from dask.distributed import Client
from itertools import repeat
@dask.delayed
def run_model(n_time,a,b):
result = np.array([a*np.random.randn(n
浏览 7提问于2018-08-27得票数 2
回答已采纳
dask是否可以一次将一行加载到内存中？我有一个巨大的200 at数据集，我希望dask在给定索引的情况下一次检索一行。然后，我想要从行中获取numpy数组。当我尝试呼叫时：
df_row = df.loc[index]
df_row = df_row.values.compute()
Dask尝试将整个df加载到内存中，而不是只加载一小行。如果我不调用compute而只是调用值，那么df_row仍然是一个dask.array对象。这似乎必须有一个显而易见的解决方案，因为它是一个如此常见和简单的用例。我做错了什么？
浏览 16提问于2018-08-01得票数 2
回答已采纳
1回答
我是Dask的新手，并使用行组将pandas Dataframe导出到Parquet： x.to_parquet(path + 'ohlcv_TRX-PERP_978627_rowgrouped.prq', row_group_size=1000) 然后我尝试用Dask加载它，它似乎工作正常(？)： x = dd.read_parquet(path + 'ohlcv_TRX-PERP_978627_rowgrouped.prq')
x
# Note: The dataframe has almost 2000 columns, I clipped them
浏览 15提问于2021-06-18得票数 1
我有一个3Dnumpy数组(维度:深度、纬度、经度)，我正在尝试使用每个经纬点的深度轴上的数据进行一些并行计算，到目前为止我还没有成功。我看过dask.array.core.map_blocks的文档，但它并没有什么帮助。下面是我正在做的事情：
N2_dask = da.from_array(N2_naned, chunks=(49, 32, (12, 12, 12, 12, 12, 12)))
zN2_dask = da.from_array(-zN2_agg[t], chunks=(49, 32, (12, 12, 12, 12, 12, 12)))
lat_dask = da.from_
浏览 0提问于2016-06-23得票数 0
我正在尝试过滤一个Dask DataFrame，然后使用map_partitions对每个分区应用一个函数。该功能预计熊猫DataFrame至少有一排。
下面是作为pandas DataFrame (然后转换为Dask DataFrame)为MCVE生成一些虚拟数据的代码
def create_data(n):
df = pd.DataFrame(np.random.rand(6 * n), columns=["A"])
random_integers = np.random.default_rng().choice(14, size=n, replace=Fa
浏览 1提问于2020-05-08得票数 1
回答已采纳
基本上，这是对熊猫在的答案。在熊猫里，我采用了这个解决方案
df.sort_values('B', ascending=False).drop_duplicates('A').sort_index()
但我无法有效地将相同的解决方案应用于dask，因为dask不喜欢sort_values。我可以通过
max_idx = df.groupby("A")["B"].idxmax().values
但我必须先计算出最大识别码，然后才能用它们作为df.loc的参数。
df.loc[max_idx.compute()]
在整个dask框架上
浏览 1提问于2021-06-17得票数 0
回答已采纳
我正在努力将Pandas/Numpy代码转换为Dask，以处理更大的数据集。我似乎无法重新创建以下Pandas/Numpy代码：
df['days_to_complete'] = np.busday_count(begindates=df['time_order_date'].values.astype('datetime64[D]'),enddates=df['time_complete_date'],weekmask='1111111',holidays=hols_list)
这将返回time_order_da
浏览 7提问于2020-09-21得票数 0
回答已采纳
我需要从一组dask Series创建一个dask DataFrame，类似于从列表构建一个熊猫DataFrame
pd.DataFrame({'l1': list1, 'l2': list2})
我在API中看不到任何东西。dask DataFrame构造函数不应该被用户直接调用，它以计算图作为其主要参数。
浏览 13提问于2018-01-04得票数 4
回答已采纳
1回答
我有银行账户记录，每行都是账户的每月余额：
Acct.Number Date Balance
1111 2020-03-31 1000
1111 2020-04-30 1300
1111 2020-05-31 1100
1111 2020-06-30 1400
2222 2020-03-31 31000
2222 2020-04-30 32000
2222 202
浏览 13提问于2022-08-08得票数 1
回答已采纳
当我使用带有pyarrow 0.11.1的dask=1.2.2时，我没有观察到这个行为。在更新(dask=2.10.1和pyarrow=0.15.1)之后，当我使用带有给定的partition_on和write_index参数的to_parquet方法时，我无法保存索引。在这里，我创建了一个最小的例子来说明这个问题：
from datetime import timedelta
from pathlib import Path
import dask.dataframe as dd
import pandas as pd
REPORT_DATE_TEST = pd.to_datetime(
浏览 9提问于2020-02-05得票数 2
我有这个非常大的dataframe (大约5,000,000行)，我已经将它分割成20个dask分区。
当我试图保存它时，我的python内核就崩溃了。
有没有办法保存每个分区，一次一个。还是把它分成20个变量？
Dask版本= 2022.01.1
分布式版本= ..。(如使用)
拼花引擎和版本= ..。
浏览 3提问于2022-08-04得票数 0
1回答
我正在使用as_pandas实用程序从impala.util读取从hive获取的dataframe格式的数据。但是，使用熊猫，我想我将无法处理大量的数据，而且速度也会变慢。我一直在阅读dask，它为读取大数据文件提供了极好的功能。我如何使用它有效地从蜂巢中获取数据。
def as_dask(cursor):
"""Return a DataFrame out of an impyla cursor.
This will pull the entire result set into memory. For richer pandas-
like functional
浏览 2提问于2018-10-18得票数 2
回答已采纳
1回答
处理大熊猫数据帧
、、、、
我有一个巨大的数据库(500 it左右)，它可以放进熊猫里。数据库包含大约39705210个观测结果。正如您可以想象的那样，python甚至在打开它时都很困难。现在，我尝试使用Dask将其导出到cdv到20个分区，如下所示：
import dask.dataframe as dd
dask_merge_bodytextknown5 = dd.from_pandas(merge_bodytextknown5, npartitions=20) # Dask DataFrame has 20 partitions
dask_merge_bodytextknown5.to_csv('df_
浏览 2提问于2022-06-29得票数 2
回答已采纳
2回答
我是Dask的新手，我发现它非常有用，但我有一个问题还没能解决。
我有一个大于内存的数据集，并且我想从列中删除重复的值。
问题是，在此删除之后，数据集仍将大于内存。因此，需要通过文件计算结果，并直接保存到磁盘。
当然，我可以构建一段代码来手动执行此删除，但我想知道Dask是否已经实现了这一点。
这是我的代码：
from dask.distributed import Client
import dask.dataframe as dd
client = Client(memory_limit='8GB') # I've tried without this limit
浏览 5提问于2020-10-16得票数 2
1回答
对于dask.bag来说，退货/退货是合法的吗？
有什么好处/陷阱吗？
作为一个简单的例子：
import dask.bag as bag
bg = (bag.from_sequence(['a', 'b', 'c'])
.map(lambda letter: bag.from_sequence([f'{letter} - 1',
f'{letter} - 2']))
.fold(lambda x, y: bag.concat((x, y)))
浏览 5提问于2020-10-04得票数 0
回答已采纳
我阅读了我的地板数据如下：
file_names = glob.glob('./events/*/*/*/*/*/part*.parquet')
pf = fp.ParquetFile(file_names, root='./events')
pf.cats = {'customer': pf.cats['customer']}
dfs = (delayed(pf.read_row_group_file)(rg, pf.columns, pf.cats) for rg in pf.row_groups)
df = dd.from_
浏览 1提问于2018-03-25得票数 1
回答已采纳
我一直在使用Dask处理大型数据帧，并执行连接/过滤器等操作。最终结果是一个我知道有8行的数据帧。但是，如果我的dask数据帧是f，那么我选中f，就会得到npartitions=81和Dask Name: assign, 10633 tasks。为什么会这样呢？我花了将近5个小时写入一个.h5文件，才发现结果中只有8行。有没有什么方法可以加快速度呢？ 分区的数量是81，这似乎太高了。我把它降到了5个小时，还是花了4个小时。
浏览 19提问于2020-05-01得票数 1
1回答
优化散射
、
我有很大的数据问题。具体的问题并不是非常重要，但我已经用达斯克解决了。现在我有两个问题。
from dask import distributed
import numpy as np
local_cluster = distributed.LocalCluster(n_workers=20, processes=True, memory_limit=0)
dask_client = distributed.Client(local_cluster)
hat_matrix = np.random.rand(1000,25000)
weight_matrix = np.random.rand
浏览 2提问于2019-03-07得票数 2
回答已采纳
1回答
我正在尝试将我的应用程序的一部分从pandas移植到dask，但在dask DataFrame上的groupby中使用lamdba函数时遇到了障碍。
import dask.dataframe as dd
dask_df = dd.from_pandas(pandasDataFrame, npartitions=2)
dask_df = dask_df.groupby(
['one', 'two', 'three', 'four'],
浏览 3提问于2016-11-28得票数 6
我想知道如何在调用map_partitions而不是pd.Dataframe时返回dask Dataframe，以避免内存问题。
输入数据帧
id | name | pet_id
---------------------
1 Charlie pet_1
2 Max pet_2
3 Buddy pet_3
4 Oscar pet_4
map_partitions的预期输出
pet_id | name | date | is_healty
------------------------------------------
浏览 2提问于2020-12-01得票数 0
我要把熊猫的数据转换成拼花文件。为此，我使用dask来帮助对生成的文件进行分区。
my_dask_df = dask.dataframe.from_pandas(my_pandas_df, npartitions=1)
my_dask_df = my_dask_df.repartition(partition_size="100MB")
dask.dataframe.to_parquet(my_dask_df, destination_dir, name_function=lambda
i: f"{dataset_name}-{dataset_versi
浏览 8提问于2022-06-14得票数 1
回答已采纳
在下面的代码片段中，我希望日志能够打印数字0- 4。我知道数字可能不是按这个顺序排列的，因为任务将被分解成多个并行操作。
代码片段：
from dask import dataframe as dd
import numpy as np
import pandas as pd
df = pd.DataFrame({'A': np.arange(5),
'B': np.arange(5),
'C': np.arange(5)})
ddf = dd.from_pandas
浏览 0提问于2017-04-14得票数 6
回答已采纳
2回答
我有Dask系列的Dask数据帧。
我想在本系列中建立索引，以获取dask数据帧以供后续工作使用。
但是，使用loc[0]会导致另一个dask系列。使用to_frame也不起作用，因为结果是"Dask系列Dask数据帧的Dask数据帧“。
下面是一个使用Dask系列Pandas数据帧的最小示例(不完全相同，但说明了问题)：
import pandas as pd
import dask.dataframe as dd
pdf1 = pd.DataFrame({'a': [1,2,3,4], 'b': [4,3,2,1]})
pdf2 = pd.Data
浏览 3提问于2020-02-03得票数 1
我正在尝试理解dask中的map_partitions是做什么的。下面是我的例子：
import dask.dataframe as dd
import pandas as pd
from dask.multiprocessing import get
import random
df = pd.DataFrame({'col_1':random.sample(range(10000), 100), 'col_2': random.sample(range(10000), 100) })
def test_f(df):
print(df.col_1)
浏览 0提问于2017-11-06得票数 1
1回答
现在，我正在使用Dask读取大csv文件，并对其进行一些后处理(例如，做一些数学运算，然后通过一些ML模型进行预测并将结果写入数据库)。避免在内存中加载所有数据，我想按当前大小的块读取:读取第一个块、预测、写入、读取第二个块等等。
我尝试了使用skiprows和nrows的下一个解决方案
import dask.dataframe as dd
read_path = "medium.csv"
# Read by chunk
skiprows = 100000
nrows = 50000
res_df = dd.read_csv(read_path, skiprows=skip
浏览 5提问于2020-03-18得票数 3
回答已采纳
有谁能简单地告诉我是如何为比内存更大的数据集工作的呢？例如，我有一个数据集，它是6GB和4GB RAM，有两个核心。dask将如何加载数据并进行简单的计算，如列和。
dask 是否自动检查内存的大小，并将数据集块划分为比内存小的数据集。然后，一旦被请求计算，就会将一个块一个块地放入内存中，并使用每个可用的核心进行计算。我说得对吗。
谢谢
迈克尔
浏览 1提问于2019-02-23得票数 1
回答已采纳
1回答
dask版本1.1.4
dask.dataframe.head()的行为与熊猫不同，这让我措手不及。
过滤后的dask.dataframe似乎将行保留在原始分区中。如果一个分区的所有行都被过滤掉，那么分区将保持为空，但仍保留在生成的dask.dataframe中。如果len(第一个分区)<n，那么head(n)就不会往外看，并错过行。
import dask
import dask.dataframe as dd
dd = dask.datasets.timeseries()
# Original partitions lengths
print(dd.map_partitions(
浏览 0提问于2019-07-03得票数 1
回答已采纳
通常，在使用大型dask.DataFrame时，只获取几行来测试所有后续操作是有用的。
目前，根据的说法，这是不支持的。
当时我希望使用head来实现同样的目标(因为这个命令是受支持的)，但它返回了一个普通的熊猫DataFrame。
我也尝试过df[:1000]，它会执行，但是生成一个不同于您期望的Pandas输出。
有没有办法从dask.DataFrame抓取前1000行？
浏览 0提问于2018-03-06得票数 4
回答已采纳
我在使用dask读取文件时出错，它与pandas一起工作：
import dask.dataframe as dd
import pandas as pd
pdf = pd.read_csv("./tous_les_docs.csv")
pdf.shape
(20140796, 7)
而dask给了我一个错误：
df = dd.read_csv("./tous_les_docs.csv")
df.describe().compute()
ParserError: Error tokenizing data. C error: EOF inside string
浏览 0提问于2019-04-29得票数 0
当运行以下代码时，dask.dataframe.head()的结果取决于n分区：
import dask.dataframe as dd
import pandas as pd
df = pd.DataFrame({'A': [1,2,3], 'B': [2,3,4]})
ddf = dd.from_pandas(df, npartitions = 3)
print(ddf.head())
这将产生以下结果：
A B
0 1 2
但是，当我将n分区设置为1或2时，我得到了预期的结果：
A B
0 1 2
1 2 3
2 3 4
似
浏览 1提问于2016-07-09得票数 8
回答已采纳
目标
打印一个具有电影名称的数据集&它被评级的次数。
这是获得最“受欢迎”电影的简单方法
数据
一个名为"u.data“的文件，带有movieID，userID，评级，时间戳
一个名为"u.item“的文件，其中包含movieID和电影名称以及关于每部电影的信息。
方法
从MovieID文件中创建字典键= u.item，values = Name
将字典广播到集群上的执行程序节点。
在每一行上使用MovieID和1创建一个rdd
通过movieID将此rdd减少，并将每个rdd相加
浏览 0提问于2018-12-26得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
