web-dev-qa-db-fra.com

Caractère 'b' ajouté lors de l'utilisation de numpy loadtxt

J'ai essayé de créer un tableau à partir d'un fichier texte .J'ai déjà vu que numpy avait une méthode loadtxt, donc je l'essaie, mais il ajoute un caractère indésirable avant chaque ligne ...

# my txt file

    .--``--.
.--`        `--.
|              |
|              |
`--.        .--`
    `--..--`

# my python v3.4 program

import numpy as np
f = open('tile', 'r')
a = np.loadtxt(f, dtype=str, delimiter='\n')
print(a)

# my print output

["b'    .--``--.    '"
 "b'.--`        `--.'"
 "b'|              |'"
 "b'|              |'"
 "b'`--.        .--`'"
 "b'    `--..--`    '"]

Que sont ces "b" et guillemets? Et d'où viennent-ils? J'ai essayé une solution choisie sur Internet, comme ouvrir le fichier avec des codecs, changer le type avec "S20", "S11" et beaucoup d'autres choses qui ne fonctionnent pas. . Ce que j'attends, c'est un tableau de chaînes Unicode ressemblant à ceci:

[['    .--``--.    ']
 ['.--`        `--.']
 ['|              |']
 ['|              |']
 ['`--.        .--`']
 ['    `--..--`    ']]

Info: J'utilise python 3.4 et numpy à partir du référentiel stable Debian

pythonnumpypython-3.4
12
krshk

np.loadtxt et np.genfromtxt fonctionnent en mode octet, qui est le type de chaîne par défaut dans Python 2. Mais Python 3 utilise unicode et marque les bytestrings avec cette b.

J'ai essayé quelques variantes, dans une session python3 ipython:

In [508]: np.loadtxt('stack33655641.txt',dtype=bytes,delimiter='\n')[0]
Out[508]: b'    .--``--.'
In [509]: np.loadtxt('stack33655641.txt',dtype=str,delimiter='\n')[0]
Out[509]: "b'    .--``--.'"
...
In [511]: np.genfromtxt('stack33655641.txt',dtype=str,delimiter='\n')[0]
Out[511]: '.--``--.'
In [512]: np.genfromtxt('stack33655641.txt',dtype=None,delimiter='\n')[0]
Out[512]: b'.--``--.'
In [513]: np.genfromtxt('stack33655641.txt',dtype=bytes,delimiter='\n')[0]
Out[513]: b'.--``--.'

genfromtxt avec dtype=str donne l'affichage le plus propre - sauf qu'il supprime les blancs. Je devrais peut-être utiliser un convertisseur pour désactiver cela. Ces fonctions sont conçues pour lire des données csv où les espaces (blancs) sont des séparateurs et ne font pas partie des données.

loadtxt et genfromtxt remplacent un texte simple comme celui-ci. Un fichier simple lu fait bien:

In [527]: with open('stack33655641.txt') as f:a=f.read()
In [528]: print(a)
    .--``--.
.--`        `--.
|              |
|              |
`--.        .--`
    `--..--`

In [530]: a=a.splitlines()
In [531]: a
Out[531]: 
['    .--``--.',
 '.--`        `--.',
 '|              |',
 '|              |',
 '`--.        .--`',
 '    `--..--`']

(mon éditeur de texte est configuré pour effacer les espaces de fin, d'où les lignes irrégulières).

@DSM's suggestion:

In [556]: a=np.loadtxt('stack33655641.txt',dtype=bytes,delimiter='\n').astype(str)
In [557]: a
Out[557]: 
array(['    .--``--.', '.--`        `--.', '|              |',
       '|              |', '`--.        .--`', '    `--..--`'], 
      dtype='<U16')
In [558]: a.tolist()
Out[558]: 
['    .--``--.',
 '.--`        `--.',
 '|              |',
 '|              |',
 '`--.        .--`',
 '    `--..--`']
14
hpaulj

Vous pouvez utiliser np.genfromtxt('your-file', dtype='U').

3
Mojtaba Khodadadi

Ce n'est probablement pas la solution la plus "pythonique" ni la meilleure solution, mais il faut absolument que le travail soit fait en utilisant numpy.loadtxt dans python3. Je suis conscient que c'est une solution "sale", mais cela fonctionne pour moi.

import numpy as np
def loadstr(filename):
    dat = np.loadtxt(filename, dtype=str)
    for i in range(0,np.size(dat[:,0])):
        for j in range(0,np.size(dat[0,:])):
            mystring = dat[i,j]
            tick = len(mystring) - 1 
            dat[i,j] = mystring[2:tick]

    return (dat)

data = loadstr("somefile.txt")

Cela importera un tableau 2D à partir d'un fichier texte via numpy, supprimera les "b '" et "'" du début et de la fin de chaque chaîne et renverra un tableau de chaînes dépouillé nommé "données".

Y a-t-il de meilleurs moyens? Probablement.

Est-ce que ça marche? Ouaip. Je l'utilise assez pour avoir cette fonction dans mon propre module Python.

1
ivanarnold

Python3 fonctionne avec Unicode. J'ai eu le même problème lorsque j'utilisais loadtxt avec dtype='S'. Mais en utilisant dtype='U en tant que Unicode string à la fois dans numpy.loadtxt et numpy.genfromtxt, cela donnera un résultat sans b

a=numpy.loadtxt('filename',dtype={'names':('col1','col2','col3'),'formats':('U10','U10','i4')},delimiter=',')

print(a)
1
Kamalesh

J'ai eu le même problème et pour moi le moyen le plus simple s'est avéré d'utiliser la bibliothèque csv. Vous obtenez votre sortie désirée par: 

import csv
def loadFromCsv(filename):
    with open(filename,'r') as file:
        list=[elem for elem in csv.reader(file,delimiter='\n')]
    return list

a=loadFromCsv('tile')
print(a)
0
Markus Dutschke