Ajouter des Zéros à Cordes dans les Pandas Dataframe

J'ai une pandas bloc de données où les 3 premières colonnes sont des chaînes de caractères:

         ID        text1    text 2
0       2345656     blah      blah
1          3456     blah      blah
2        541304     blah      blah        
3        201306       hi      blah        
4   12313201308    hello      blah

Je veux ajouter des zéros au ID:

                ID    text1    text 2
0  000000002345656     blah      blah
1  000000000003456     blah      blah
2  000000000541304     blah      blah        
3  000000000201306       hi      blah        
4  000012313201308    hello      blah

J'ai essayé:

df['ID'] = df.ID.zfill(15)
df['ID'] = '{0:0>15}'.format(df['ID'])

OriginalL'auteur jgaw | 2014-05-23

40

Essayer:
```
df['ID'] = df['ID'].apply(lambda x: '{0:0>15}'.format(x))
```
ou même
```
df['ID'] = df['ID'].apply(lambda x: x.zfill(15))
```
Pas besoin de le lambda sur la première: apply('{:0>15}'.format) devrait fonctionner aussi.
Nice. Ne le savaient pas.
Il peut être réalisé avec une seule ligne alors que l'initialisation, voir ma réponse ci-dessous.

OriginalL'auteur Rohit
30

str attribut contient la plupart des méthodes en chaîne.
```
df['ID'] = df['ID'].str.zfill(15)
```
Voir plus: http://pandas.pydata.org/pandas-docs/stable/text.html

OriginalL'auteur Guangyang Li
4

Avec Python 3.6+, vous pouvez également utiliser f-chaînes:
```
df['ID'] = df['ID'].map(lambda x: f'{x:0>15}')
```
Les performances sont comparables ou légèrement pire contre df['ID'].map('{:0>15}'.format). D'autre part, f-chaînes de permis de sortie plus complexe, et vous pouvez les utiliser plus efficacement grâce à une compréhension de liste.

Analyse comparative de la Performance
```
# Python 3.6.0, Pandas 0.19.2

df = pd.concat([df]*1000)

%timeit df['ID'].map('{:0>15}'.format)                  # 4.06 ms per loop
%timeit df['ID'].map(lambda x: f'{x:0>15}')             # 5.46 ms per loop
%timeit df['ID'].astype(str).str.zfill(15)              # 18.6 ms per loop

%timeit list(map('{:0>15}'.format, df['ID'].values))    # 7.91 ms per loop
%timeit ['{:0>15}'.format(x) for x in df['ID'].values]  # 7.63 ms per loop
%timeit [f'{x:0>15}' for x in df['ID'].values]          # 4.87 ms per loop
%timeit [str(x).zfill(15) for x in df['ID'].values]     # 21.2 ms per loop

# check results are the same
x = df['ID'].map('{:0>15}'.format)
y = df['ID'].map(lambda x: f'{x:0>15}')
z = df['ID'].astype(str).str.zfill(15)

assert (x == y).all() and (x == z).all()
```
a essayé avec un débit de 6 gbits fichier fonctionne de manière plus rapide que les autres méthodes, aussi plus efficace. merci @jpp
Vous pouvez même utiliser .map au lieu de .apply
I crois ils sont interchangeables d'ici et d'effectuer aussi. Vous avez une raison de penser autrement?
Dans certains exemples, c'est plus rapide. Essayez df['text1'].map('{:015}'.format).
Merci, je vois une très légère amélioration de changer apply vs map, je ne sais pas si c'est l'installation de la dépendance. J'ai mis à jour les horaires et les conseils dans ma réponse que str.format sans lambda semble gagner.

OriginalL'auteur jpp
3

Il peut être réalisé avec une seule ligne alors que l'initialisation. Utilisez simplement convertisseurs argument.
```
df = pd.read_excel('filename.xlsx', converters={'ID': '{:0>15}'.format})
```
de sorte que vous allez réduire le code à longueur de moitié 🙂
```
df = pd.read_excel('filename.xlsx')
df['ID'] = df['ID'].str.zfill(15) # df['ID'] = df['ID'].apply(lambda x: '{0:0>15}'.format(x))
```
PS: read_csv ont cet argument.

Super merci!!!!

OriginalL'auteur Daniil Mashkin
0

Si vous rencontrez le message d'erreur:

Pandas erreur: ne Peut utiliser .str accesseur avec les valeurs de chaîne, qui utilisent des np.object_ dtype dans les pandas
```
df['ID'] = df['ID'].astype(str).str.zfill(15)
```
OriginalL'auteur Deskjokey

Vous devez vous connecter pour publier un commentaire.

Analyse comparative de la Performance