Créer Vide Dataframe dans les Pandas en spécifiant les types de colonne

Je suis en train de créer un vide de la trame de données avec un index et spécifier les types de colonne. La façon dont je l'ai fait est le suivant:

df = pd.DataFrame(index=['pbp'],columns=['contract',
                                         'state_and_county_code',
                                         'state',
                                         'county',
                                         'starting_membership',
                                         'starting_raw_raf',
                                         'enrollment_trend',
                                         'projected_membership',
                                         'projected_raf'],
                                dtype=['str', 'str', 'str', 'str', 'int', 'float', 'float', 'int', 'float'])

Cependant, j'obtiens l'erreur suivante,

TypeError: data type not understood

Qu'est-ce que cela signifie?

Je ne pense pas que vous pouvez spécifier la dtypes de cette manière, vous pouvez passer d'un type unique comme str mais pas une liste de chaînes de caractères. Le dtype sera déduit lorsque vous affectez les valeurs de la colonne. Je pense qu'il devrait être inutile de préciser à tous
c'est vrai, selon le docs, je me demande bien pourquoi est-il que le constructeur ne permet pas que... ne serait-il pas plus efficace de créer un vide dataframe avec les types à partir du début des fins de répartition?

OriginalL'auteur Vincent | 2016-04-06

pandas python

Ce vraiment sent comme un bug.

Voici un autre (plus simple) solution.

import pandas as pd
import numpy as np

def df_empty(columns, dtypes, index=None):
    assert len(columns)==len(dtypes)
    df = pd.DataFrame(index=index)
    for c,d in zip(columns, dtypes):
        df[c] = pd.Series(dtype=d)
    return df

df = df_empty(['a', 'b'], dtypes=[np.int64, np.int64])
print(list(df.dtypes)) # int64, int64

OriginalL'auteur user48956

6

Juste une remarque.

Vous pouvez obtenir autour de l'Erreur de Type à l'aide de np.dtype:
```
pd.DataFrame(index = ['pbp'], columns = ['a','b'], dtype = np.dtype([('str','float')]))
```
mais vous avez de la place:
```
NotImplementedError: compound dtypes are not implementedin the DataFrame constructor
```
C'est vraiment la bonne réponse. Même la fixation de la TypeError, il n'est toujours pas quelque chose que les pandas pris la peine de les mettre en œuvre. Vous ne pouvez même pas de la copie d'un dtype à partir d'un composé dtype DataFrame de commencer un nouveau vide DataFrame, qui semble vraiment comme un valide de cas d'utilisation.
si vous souhaitez copier le dtypes d'un bloc existant, vous pouvez sélectionner 0 lignes à partir de cette image et votre vide DF avec la même dtypes. Par exemple cpy = df.loc[[False]*len(df)] devrait faire l'affaire

OriginalL'auteur ptrj

J'ai trouvé cette question après l'exécution de la même édition. Je préfère la solution suivante (Python 3) pour la création d'un vide DataFrame avec aucun indice.

import numpy as np
import pandas as pd

def make_empty_typed_df(dtype):
    tdict = np.typeDict
    types = tuple(tdict.get(t, t) for (_, t, *__) in dtype)
    if any(t == np.void for t in types):
        raise NotImplementedError('Not Implemented for columns of type "void"')
    return pd.DataFrame.from_records(np.array([tuple(t() for t in types)], dtype=dtype)).iloc[:0, :]

De tester ce ...

from itertools import chain

dtype = [('col%d' % i, t) for i, t in enumerate(chain(np.typeDict, set(np.typeDict.values())))]
dtype = [(c, t) for (c, t) in dtype if (np.typeDict.get(t, t) != np.void) and not isinstance(t, int)]

print(make_empty_typed_df(dtype))

Empty DataFrame

Columns: [col0, col6, col16, col23, col24, col25, col26, col27, col29, col30, col31, col32, col33, col34, col35, col36, col37, col38, col39, col40, col41, col42, col43, col44, col45, col46, col47, col48, col49, col50, col51, col52, col53, col54, col55, col56, col57, col58, col60, col61, col62, col63, col64, col65, col66, col67, col68, col69, col70, col71, col72, col73, col74, col75, col76, col77, col78, col79, col80, col81, col82, col83, col84, col85, col86, col87, col88, col89, col90, col91, col92, col93, col95, col96, col97, col98, col99, col100, col101, col102, col103, col104, col105, col106, col107, col108, col109, col110, col111, col112, col113, col114, col115, col117, col119, col120, col121, col122, col123, col124, ...]
Index: []

[0 rows x 146 columns]

Et les types de données ...

print(make_empty_typed_df(dtype).dtypes)

col0      timedelta64[ns]
col6               uint16
col16              uint64
col23                int8
col24     timedelta64[ns]
col25                bool
col26           complex64
col27               int64
col29             float64
col30                int8
col31             float16
col32              uint64
col33               uint8
col34              object
col35          complex128
col36               int64
col37               int16
col38               int32
col39               int32
col40             float16
col41              object
col42              uint64
col43              object
col44               int16
col45              object
col46               int64
col47               int16
col48              uint32
col49              object
col50              uint64
               ...       
col144              int32
col145               bool
col146            float64
col147     datetime64[ns]
col148             object
col149             object
col150         complex128
col151    timedelta64[ns]
col152              int32
col153              uint8
col154            float64
col156              int64
col157             uint32
col158             object
col159               int8
col160              int32
col161             uint64
col162              int16
col163             uint32
col164             object
col165     datetime64[ns]
col166            float32
col167               bool
col168            float64
col169         complex128
col170            float16
col171             object
col172             uint16
col173          complex64
col174         complex128
dtype: object

L'ajout d'un index qui est difficile car il n'existe pas une véritable valeur manquante pour la plupart des types de données de sorte qu'ils finissent par obtenir jeté d'un autre type avec un natif de la valeur manquante (par exemple, ints sont exprimés à floats ou objects), mais si vous avez des données complètes des types que vous avez spécifié, alors vous pouvez toujours insérer des lignes au besoin, et vos types seront respectés. Ceci peut être accompli avec:

df.loc[index, :] = new_row

Encore une fois, comme @Hun souligné, ce n'est PAS la façon dont les Pandas est destiné à être utilisé.

OriginalL'auteur JaminSore

3

pandas n'offre pas de pure colonne de type integer. Vous pouvez soit utiliser float colonne et de convertir cette colonne de type entier ou de la traiter comme un objet. Ce que vous essayez de mettre en œuvre n'est pas la façon dont les pandas est censé être utilisé. Mais si VRAIMENT vous voulez VRAIMENT, vous pouvez obtenir autour de la TypeError message en faisant cela.
```
df1 =  pd.DataFrame(index=['pbp'], columns=['str1','str2','str2'], dtype=str)
df2 =  pd.DataFrame(index=['pbp'], columns=['int1','int2'], dtype=int)
df3 =  pd.DataFrame(index=['pbp'], columns=['flt1','flt2'], dtype=float)
df = pd.concat([df1, df2, df3], axis=1)

    str1 str2 str2 int1 int2  flt1  flt2
pbp  NaN  NaN  NaN  NaN  NaN   NaN   NaN
```
Vous pouvez réorganiser le col de l'ordre que vous le souhaitez. Mais encore une fois, ce n'est pas la façon pandas a été censé être utilisé.
```
 df.dtypes
str1     object
str2     object
str2     object
int1     object
int2     object
flt1    float64
flt2    float64
dtype: object
```
Noter que l'int est traitée comme un objet.

Ce que le diable parlez-vous? Bien sûr, les Pandas prend en charge les colonnes de type entier.
Il ne semble pas être un problème avec le passage dtype=int l'absence de données, cependant.
Cette absolument ressemble à un bug est toujours le comportement dans la dernière version. Avez-vous l'envoyer?
Son comportement attendu, cotées sur les mises en garde. Son car il n'y a pas de nan pour int. Vous pouvez en lire plus à ce sujet sur le docs
Cela n'explique pas pourquoi aucun int colonnes peut être spécifié dans le constructeur. Si vous demandez une colonne int et, plus tard, insérer un nan, la bonne attitude serait de promouvoir la colonne à flotteur, ou lever une exception

OriginalL'auteur Hun
2

Vous pouvez le faire en passant un dictionnaire dans le DataFrame constructeur:
```
df = pd.DataFrame(index=['pbp'],
                  data={'contract' : np.full(1, "", dtype=str),
                        'starting_membership' : np.full(1, np.nan, dtype=float),
                        'projected_membership' : np.full(1, np.nan, dtype=int)
                       }
                 )
```
Ce sera correctement vous donner un dataframe qui ressemble à:
```
     contract  projected_membership   starting_membership
pbp     ""             NaN           -9223372036854775808
```
Avec dtypes:
```
contract                 object
projected_membership    float64
starting_membership       int64
```
Cela dit, il y a deux choses à noter:

1) str n'est pas réellement un type qu'un DataFrame colonne peut traiter; au lieu de cela, il tombe en arrière pour le cas général,object. Ça va encore fonctionner correctement.

2) Pourquoi ne voyez-vous pas que NaN sous starting_membership? Eh bien, NaN est définie uniquement pour les flotteurs; il n'y a pas de "None" pour les entiers, de sorte qu'il jette np.NaN à un entier. Si vous souhaitez une autre valeur par défaut, vous pouvez changer cela dans la np.full appel.

Pas besoin de mettre un tas de données factices dans les colonnes quand vous pourriez utiliser des tableaux vides.

OriginalL'auteur Eric G.

Vous pouvez le faire comme ceci

import numpy
import pandas

dtypes = numpy.dtype([
          ('a', str),
          ('b', int),
          ('c', float),
          ('d', numpy.datetime64),
          ])
data = numpy.empty(0, dtype=dtypes)
df = pandas.DataFrame(data)

OriginalL'auteur ryanjdillon

C'est une vieille question, mais je ne vois pas une réponse solide (bien que @eric_g était super proche).

Vous suffit de créer un vide dataframe avec une liste de clé de dictionnaire:paires de valeurs. La clé de votre nom de colonne, et la valeur à vide type de données.

Donc dans votre exemple de jeu de données, il se présenterait comme suit:

df = pd.DataFrame(,columns=[{'contract':'',
                              'state_and_county_code':'',
                              'state':'',
                              'county':'',
                              'starting_membership':int(),
                              'starting_raw_raf':float(),
                              'enrollment_trend':float(),
                              'projected_membership':int(),
                              'projected_raf':float(),
                              'pbp':int() #just guessing on this data type
                                      }]).set_index=("pbp")

Je ne pense pas que fonctionne parce que les Pandas renvoyait un message d'erreur disant que dict is unhashable type (ce qui est compréhensible). Et, il n'y a aucune mention de ce format dans la documentation.
Je suis activement à l'aide de ce dans mon code et il fonctionne très bien. Je suis en utilisant les pandas 0.22.0, que diriez-vous?

OriginalL'auteur SummerEla

Vous devez vous connecter pour publier un commentaire.