'b' ajouté lors de l'utilisation de numpy loadtxt

J'ai essayé de créer un tableau à partir d'un fichier texte.
J'ai vu plus haut que la numpy avait une méthode loadtxt, alors je l'ai essayer, mais ajouter un peu de cochonneries devant 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'    `--..--`    '"]

Ce que sont ces " b " et les guillemets ? Et d'où viennent-ils ?
J'ai essayé la solution choisi à partir d'internet, comme ouvrir le fichier avec codecs, changer la dtype par 'S20', 'S11', et beaucoup d'autres choses qui ne fonctionnent pas...
Ce que j'attends est un tableau de chaînes unicode qui ressemble à ceci :

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

Info:
Je suis à l'aide de python 3.4 et numpy de la debian stable référentiel

J'ai déjà vérifier cette question avant, et, OK!, b est de type byte, mais pourquoi est-il à l'intérieur un guillemet double chaîne de caractères ? J'ai ré-utiliser ce tableau, plus tard, pour remplacer certains caractères dans un autre tableau, en fonction d'un indice. Donc, si j'ai un b et 2 extra simple guillemets, il cassera la plus récente du programme.
Pourquoi êtes-vous à l'aide de loadtxt pour charger un fichier comme ça? loadtxt est conçu pour les colonnes de données séparées par des virgules ou une autre délimiteur. Vous pourriez tout aussi bien lire ce fichier avec pur python; par exemple, quelque chose comme with open('tile') as f: a = [line.strip('\n') for line in f.readlines() if not line.startswith('#')]
Simple : je suis un total débutant en Python. J'ai commencé à l'utiliser pendant 1 semaine. J'ai plus précis dans le langage du web. Donc, je m'apparaît un peu confus 🙂

OriginalL'auteur krshk | 2015-11-11

np.loadtxt et np.genfromtxt fonctionner en mode octet, qui est la valeur par défaut type chaîne de caractères en Python 2. Mais Python 3 utilise l'unicode, et les marques de bytestrings avec cette b.

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

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 le plus propre d'affichage à l'exception de il des bandes de blancs. J'ai peut-être utiliser un convertisseur pour désactiver cette fonction. Ces fonctions visent à lire csv de données où (blanc)les espaces sont des séparateurs, ne fait pas partie des données.

loadtxt et genfromtxt sont plus tuer pour du texte simple comme cela. Une simple lecture de fichier n'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 définie sur la bande des espaces à droite, d'où le 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]: 
['    .--``--.',
 '.--`        `--.',
 '|              |',
 '|              |',
 '`--.        .--`',
 '    `--..--`']

Je pense que np.loadtxt("tile", dtype=bytes, delimiter="\n").astype(str) pourrait fonctionner, mais je suis entièrement d'accord avec l'excès point.
Formidable ! merci beaucoup !

OriginalL'auteur hpaulj

3

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

N'oubliez pas de spécifier une chaîne de caractères de longueurdtype='U10' que sans la 10 il vous suffit de faire une chaîne vide.

OriginalL'auteur Mojtaba Khodadadi
1

Ce n'est probablement pas le plus "pythonic' ou la meilleure solution, mais certainement le travail effectué à l'aide de numpy.loadtxt dans python3. Je suis conscient que c'est un "sale" solution, 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 permettra d'importer un tableau 2D à partir d'un fichier texte via numpy, enlever le "b "" et "" depuis le début et la fin de chaque chaîne, et de retourner une dépouillé de tableau de chaîne nommée "données".

Sont t-il de meilleures façons de faire? Probablement.

Fait ce travail? Yup. Je l'utilise assez que j'ai eu cette fonction dans mon propre module Python.

OriginalL'auteur ivanarnold
1

Python3 est de travailler avec Unicode. J'ai eu le même problème lors de l'utilisation de loadtxt avec dtype='S'. Mais à l'aide de dtype='U comme Unicode string dans les deux numpy.loadtxt ou numpy.genfromtxt, il va donner de sortie sans b
```
a=numpy.loadtxt('filename',dtype={'names':('col1','col2','col3'),'formats':('U10','U10','i4')},delimiter=',')

print(a)
```
OriginalL'auteur Kamalesh

J'ai eu le même problème et pour moi le moyen le plus simple s'est avéré pour utiliser le csv de la bibliothèque.
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)

OriginalL'auteur Markus Dutschke

Vous devez vous connecter pour publier un commentaire.