FutureWarning: elementwise comparaison a échoué; retour scalaire, mais à l'avenir sera d'effectuer elementwise comparaison

Je suis en utilisant les Pandas 0.19.1 sur Python 3. Je reçois un avertissement sur ces lignes de code. J'essaie de faire une liste qui contient tous les numéros de ligne où la chaîne Peter est présent au niveau de la colonne Unnamed: 5.

df = pd.read_excel(xls_path)
myRows = df[df['Unnamed: 5'] == 'Peter'].index.tolist()

Avertissement:

"\Python36\lib\site-packages\pandas\core\ops.py:792: FutureWarning: elementwise 
comparison failed; returning scalar, but in the future will perform 
elementwise comparison 
result = getattr(x, name)(y)"

Qu'est-ce que ce FutureWarning et dois-je l'ignorer car il semble fonctionner.

Vous devez fournir des données de l'exemple.

OriginalL'auteur Arturo | 2016-11-17

  1. 32

    Ce FutureWarning n'est pas de Pandas, c'est à partir de numpy et le problème affecte aussi matplotlib et autres, voici comment reproduire l'avertissement plus près de la source du problème:

    import numpy as np
print(np.__version__)   # Numpy version '1.12.0'
'x' in np.arange(5)       #Future warning thrown here

FutureWarning: elementwise comparison failed; returning scalar instead, but in the 
future will perform elementwise comparison
False

    Une autre façon de reproduire ce bogue en utilisant le double est égal à l'opérateur:

    import numpy as np
np.arange(5) == np.arange(5).astype(str)    #FutureWarning thrown here

    Un exemple de Matplotlib touchés par cette FutureWarning sous leur carquois de la parcelle mise en œuvre: https://matplotlib.org/examples/pylab_examples/quiver_demo.html

    Ce qui se passe ici?

    Il y a un désaccord entre Numpy et natif de python sur ce qui devrait se produire lorsque vous comparez une des chaînes de numpy de types numériques. Avis de l'opérande de gauche est python de gazon, une primitive de la chaîne, et le moyen de l'opération est python gazon, mais l'opérande de droite est numpy du gazon. Si vous devez renvoyer un Python de style Scalaire ou un Numpy style ndarray de booléens? Numpy dit ndarray de bool, Pythonic les développeurs sont en désaccord. Classique de l'impasse.

    Devrait-il être elementwise comparaison ou Scalaire si l'élément existe dans le tableau?

    Si votre code ou de la bibliothèque est à l'aide de la in ou == opérateurs de comparer python chaîne de numpy ndarrays, ils ne sont pas compatibles, donc si vous l'essayez, il retourne un scalaire, mais uniquement pour l'instant. Le message d'Avertissement indique que dans l'avenir ce comportement peut changer de sorte que votre code dégueule partout dans le tapis si python/numpy décider de faire adopter Numpy style.

    Soumis les rapports de Bug:

    Numpy et Python sont dans une impasse, pour l'instant, l'opération retourne un scalaire, mais dans l'avenir, il peut changer.

    https://github.com/numpy/numpy/issues/6784

    https://github.com/pandas-dev/pandas/issues/7830

    Deux solutions:

    Soit de verrouillage de votre version de python et de numpy et d'ignorer les mises en garde, ou de garder des enfants à votre gauche et à droite des opérandes d'une commune de gazon.

    Supprimer l'avertissement à l'échelle mondiale:

    import warnings
import numpy as np
warnings.simplefilter(action='ignore', category=FutureWarning)
print('x' in np.arange(5))   #returns False, without Warning

    Supprimer l'avertissement sur ligne par ligne.

    import warnings
import numpy as np

with warnings.catch_warnings():
    warnings.simplefilter(action='ignore', category=FutureWarning)
    print('x' in np.arange(2))   #returns False, warning is suppressed

print('x' in np.arange(10))   #returns False, Throws FutureWarning

    Juste supprimer l'avertissement par nom, puis mettre un commentaire fort à côté de mentionner la version actuelle de python et de numpy, en disant: ce code est fragile et a besoin de ces versions et de mettre un lien ici. Kick the can en bas de la route.

    Ugh. Donc, si j'ai une certaine quantité thing (qui peut ou peut ne pas être un numpy type; je ne sais pas) et je veux voir si thing == 'some string' et obtenir un simple bool résultat, que dois-je faire? np.atleast_1d(thing)[0] == 'some string'? Mais ce n'est pas robuste à un petit rigolo de mettre 'some string' dans le premier élément d'un tableau. Je suppose que je dois tester le type de thing abord, puis seulement les == test si c'est une chaîne (ou pas une numpy objet).
    Il vous faudra alors passer votre propre style C ou Java style de la vérification de type wrapper code sur chaque ligne afin de s'assurer que == et in fonctionnera comme vous vous attendez via python de l'effondrement de l'idéologie ou de numpy est vectorisé idéologie. Python Développeurs ont été averti à ce sujet, mais vous n'écoutez pas, maintenant vous payez le prix avec double d'égal à égal et in exécution d'un comportement non défini lorsque vous avez accidentellement passer une coutume numpy.googah.blimflarg type dans une pandas fonction attend un pandas.vehicle.subspaceresponder type. Au lieu de vous remettre un bon type d'erreur comme Java/C, c'est juste dégueule partout dans le tapis.
    Jusqu'à présent, il semble que je vais sortir avec str(thing) == 'some string' pour ce cas précis. Il semble que cela pourrait être un énorme gaspillage de temps si j'avais un plus grand ensemble de données à comparer.
    Cette stackoverflow post est un exemple de Python idéologie du "cow-boy duct-tape de programmation: Code rapide, ne faites pas de test de régression, de faire des erreurs, à casser des choses, apprendre, puis le fixer, puis répéter". Dans d'autres, plus rapide et plus sensible des langages tels que C++ et Java, ce problème n'aurait jamais été un problème parce que les types sont clouées et garantie au moment de la compilation, plutôt que d'être autorisés à prendre de un milliard de formes, et de flotter dans l'atmosphère de chaos complet. Je prie de ne pas modifier le contrat plus loin: youtube.com/watch?v=WpE_xMRiCLE
    En fait, ce futur avertissement est également déclenché chaque fois que vous essayez de comparer un numpy.ndarray avec une liste vide. Par exemple, l'exécution np.array([1, 2]) == [] sera d'amasser de l'avertissement.

    OriginalL'auteur Eric Leschinski

  2. 1

    Mon expérience pour le même message d'avertissement a été causé par TypeError.

    TypeError: invalid type de comparaison

    Donc, vous voudrez peut-être vérifier le type de données de la Unnamed: 5

    for x in df['Unnamed: 5']:
  print(type(x))  # are they 'str' ?

    Ici est de savoir comment je peux reproduire le message d'avertissement: 

    import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 2), columns=['num1', 'num2'])
df['num3'] = 3
df.loc[df['num3'] == '3', 'num3'] = 4  # TypeError and the Warning
df.loc[df['num3'] == 3, 'num3'] = 4  # No Error

    Espère que cela aide.

    Votre code a beaucoup d'inutiles pièces mobiles pour illustrer l'avertissement. Les Pandas de grâces vous avec extra TypeError mais c'est dommage de contrôle de Pandas, La source d'avertissement est un désaccord entre Numpy et Python, et se produit à l'évaluation des df['num3'] == '3'.

    OriginalL'auteur yhd.leung

  3. 1

    Je reçois la même erreur lorsque je tente de régler le index_col la lecture d'un fichier dans un Pandade données de l '-cadre:

    df = pd.read_csv('my_file.tsv', sep='\t', header=0, index_col=['0'])  ## or same with the following
df = pd.read_csv('my_file.tsv', sep='\t', header=0, index_col=[0])

    Je n'ai jamais rencontré une telle erreur précédemment. Je suis encore à essayer de comprendre la raison derrière cela (à l'aide de @Eric Leschinski explication et autres).

    De toute façon, l'approche suivante résout le problème pour l'instant jusqu'à ce que je figure la raison:

    df = pd.read_csv('my_file.tsv', sep='\t', header=0)  ## not setting the index_col
df.set_index(['0'], inplace=True)

    Je mettrai à jour dès que je figure sur la raison d'un tel comportement.

    J'ai le même problème avec read_csv(). Me semble quelque chose qui pandas doit fixer.

    OriginalL'auteur Dataman

  4. 0

    Si vos tableaux ne sont pas trop gros ou que vous n'en avez trop plusieurs d'entre eux, vous pourriez être en mesure de s'en tirer avec forçant le côté gauche de == être une chaîne de caractères:

    myRows = df[str(df['Unnamed: 5']) == 'Peter'].index.tolist()

    Mais c'est environ 1,5 fois plus lent si df['Unnamed: 5'] est une chaîne de caractères, de 25 à 30 fois plus lent si df['Unnamed: 5'] est un petit tableau numpy (longueur = 10), et de 150 à 160 fois plus lent si c'est un tableau numpy avec une longueur de 100 fois (en moyenne plus de 500 essais).

    a = linspace(0, 5, 10)
b = linspace(0, 50, 100)
n = 500
string1 = 'Peter'
string2 = 'blargh'
times_a = zeros(n)
times_str_a = zeros(n)
times_s = zeros(n)
times_str_s = zeros(n)
times_b = zeros(n)
times_str_b = zeros(n)
for i in range(n):
t0 = time.time()
tmp1 = a == string1
t1 = time.time()
tmp2 = str(a) == string1
t2 = time.time()
tmp3 = string2 == string1
t3 = time.time()
tmp4 = str(string2) == string1
t4 = time.time()
tmp5 = b == string1
t5 = time.time()
tmp6 = str(b) == string1
t6 = time.time()
times_a[i] = t1 - t0
times_str_a[i] = t2 - t1
times_s[i] = t3 - t2
times_str_s[i] = t4 - t3
times_b[i] = t5 - t4
times_str_b[i] = t6 - t5
print('Small array:')
print('Time to compare without str conversion: {} s. With str conversion: {} s'.format(mean(times_a), mean(times_str_a)))
print('Ratio of time with/without string conversion: {}'.format(mean(times_str_a)/mean(times_a)))
print('\nBig array')
print('Time to compare without str conversion: {} s. With str conversion: {} s'.format(mean(times_b), mean(times_str_b)))
print(mean(times_str_b)/mean(times_b))
print('\nString')
print('Time to compare without str conversion: {} s. With str conversion: {} s'.format(mean(times_s), mean(times_str_s)))
print('Ratio of time with/without string conversion: {}'.format(mean(times_str_s)/mean(times_s)))

    Résultat:

    Small array:
Time to compare without str conversion: 6.58464431763e-06 s. With str conversion: 0.000173756599426 s
Ratio of time with/without string conversion: 26.3881526541
Big array
Time to compare without str conversion: 5.44309616089e-06 s. With str conversion: 0.000870866775513 s
159.99474375821288
String
Time to compare without str conversion: 5.89370727539e-07 s. With str conversion: 8.30173492432e-07 s
Ratio of time with/without string conversion: 1.40857605178

    OriginalL'auteur EL_DON

  5. 0

    Une rapide solution pour cela est d'utiliser numpy.core.defchararray. J'ai aussi été confronté au même message d'avertissement et a été en mesure de le résoudre à l'aide de dessus du module.

    import numpy.core.defchararray as npd
resultdataset = npd.equal(dataset1, dataset2)

    OriginalL'auteur Jeet23