Erreurs courantes que commettent les novices lorsqu'ils commencent à apprendre Python

Lorsque les novices commenceront à apprendre le langage Python, ils feront des erreurs d'une sorte ou d'une autre. Nous avons fait quelques résumés ici, dans l'espoir d'accorder une certaine attention aux amis qui commencent tout juste à apprendre Python.

Erreurs de grammaire

Les erreurs de grammaire peuvent être les erreurs les plus courantes lorsque vous apprenez encore Python

>>> while True print "hi~"
  File "<stdin>", line 1    
  while True print "hi~"
               ^
SyntaxError: invalid syntax

Oui Une flèche pointe vers l'endroit où l'erreur a été découverte pour la première fois, ici elle pointe vers l'impression, car les deux points

manquent après Ture et j'ai oublié d'ajouter : (ce qui donne "SyntaxError:" à la fin du if, elif, else, for, while, class, def déclarations : syntaxe invalide") Cette erreur se produira dans un code similaire au suivant :

if spam == 42 print('Hello!')

Utilisez = au lieu de == (résultant en "SyntaxError : syntaxe invalide") = est l'opérateur d'affectation et == est l'opérateur de comparaison égal. L'erreur se produit dans le code suivant :

if spam = 42: print('Hello!')

Utilisation incorrecte de l'indentation. (résultant en "IndentationError : indentation inattendue", "IndentationError : unindent ne correspond à aucun niveau d'indentation externe" et "IndentationError : un bloc indenté attendu") N'oubliez pas que l'augmentation de l'indentation n'est utilisée qu'après les instructions se terminant par : et doit être restaurée. puis au format d'indentation précédent. Cette erreur se produit dans le code suivant :

print('Hello!') 
   print('Howdy!')

ou :

if spam == 42: 
print('Hello!') 
print('Howdy!')

ou :

 if spam == 42: 
print('Hello!')

J'ai oublié d'appeler len() dans l'instruction de la boucle for. (Provoque "TypeError : l'objet 'list' ne peut pas être interprété comme un entier") Habituellement, vous souhaitez parcourir les éléments d'une liste ou d'une chaîne par index, ce qui nécessite d'appeler la fonction range(). N'oubliez pas de renvoyer la valeur len au lieu de la liste. L'erreur se produit dans le code suivant :

spam = ['cat', 'dog', 'mouse'] for i in range(spam): 
     print(spam[i])

Tentative de modification de la valeur de la chaîne (résultant en "TypeError : l'objet 'str' ne prend pas en charge l'affectation d'élément") string est un type de données immuable, l'erreur se produit dans le code suivant :

spam = 'I have a pet cat.' 
spam[13] = 'r' print(spam)

lorsque vous souhaitez réellement faire cela :

spam = 'I have a pet cat.' 
spam = spam[:13] + 'r' + spam[14:] print(spam)

Tentative de concaténer une valeur autre qu'une chaîne avec une chaîne (résultant en "TypeError : Impossible de convertir implicitement l'objet 'int' en str") L'erreur se produit dans un code tel que :

numEggs = 12 print('I have ' + numEggs + ' eggs.')

Et vous voulez réellement faire ceci :

numEggs = 12 print('I have ' + str(numEggs) + ' eggs.')

ou :

 numEggs = 12 print('I have %s eggs.' % (numEggs))

Vous avez oublié d'ajouter des guillemets au début et à la fin de la chaîne (ce qui donne "SyntaxError: EOL lors de l'analyse du littéral de chaîne") Cette erreur se produit dans le code suivant :

print(Hello!') 或者: print('Hello!)

ou :

myName = 'Al' print('My name is ' + myName + . How are you?')

Le nom de la variable ou de la fonction est mal orthographié (ce qui entraîne "NameError: name ' fooba' n'est pas défini"). Cette erreur se produit comme suit Dans le code :

foobar = 'Al' print('My name is ' + fooba)

ou :

spam = ruond(4.2)

ou :

spam = Round(4.2)

erreur d'orthographe du nom de la méthode (résultant en "AttributeError : l'objet 'str' n'a pas d'attribut 'lowerr'") Cette erreur se produit dans le code suivant :

spam = 'THIS IS IN LOWERCASE.' spam = spam.lowerr()

Exception

Même si la syntaxe des instructions et des expressions est correcte, des erreurs peuvent survenir lors de l'exécution. Ces erreurs sont appelées exceptions. Les exceptions ne sont pas toujours fatales ; vous apprendrez comment les gérer dans un instant. De nombreuses routines d'exception ne le gèrent pas et renvoient un message d'erreur, par exemple :

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>ZeroDivisionError: integer division or modulo by zero
>>> 4 + git*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>NameError: name &#39;git&#39; is not defined
>>> &#39;2&#39; + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>TypeError: cannot concatenate &#39;str&#39; and &#39;int&#39; objects
>>>

错误消息的最后一行就是异常消息，冒号前是异常的类型。上面的 ZeroDivisionError, NameError, TypeError, 都是系统内置的异常。

处理异常

可以自己编写程序来处理异常，比如下面这个例子，它会返回异常，直到用户输入有效数据为止。

>>> while True:
...     try:
...         x = int(raw_input("Please enter a number: "))
...         break...     except ValueError:
...         print "Oops! That was no valid number. Try again..."... 
Please enter a number: x
Oops! That was no valid number. Try again...
Please enter a number: 32x
Oops! That was no valid number. Try again...
Please enter a number: 038

使用 try 和 except ExceptionName 来处理异常

如果没有异常产生，except 段会被跳过

如果某处有异常产生，后面的语句会被跳过，如果产生的异常类型和except后的类型一致，except后的语句会被执行

如果发生异常，但和except后的类型不一致，异常会传递到try语句外面，如果没有相应处理，那么就会打印出像上 一个例子那样的信息。

一个try语句可能有多个except与之对应，分别处理不同类型的异常，最多只有一种处理会被执行。一个except可以包含多 个类型名，比如：

... except (RuntimeError, TypeError, NameError):
...     pass

注意上面的三种异常类型，必须用括号把它们括起来，因为在现代python中， except ValueError, e 的意思是 except ValueError as e:(后面会讲这是什么意思)

最后一个except一般不指定名字，用于处理其余情况

import systry:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as e:    
       print "I/O error({0}): {1}".format(e.errno, e.strerror)
except ValueError:    
       print "Could not convert data to an integer."
except:    
       print "Unexpected error:", sys.exc_info()[0]    
       raise

try..except 语句还可以选择使用else,例如

for arg in sys.argv[1:]:    
     try:
        f = open(arg, 'r')    
   except IOError:        
           print 'cannot open', arg    
   else:        
           print arg, 'has', len(f.readlines()), 'lines'
        f.close()

需要注意，一旦使用else,每个except后都要有else,这种方式用于需要指定某一异常不出现时执行什么操作。

except子句可以在异常名后指定参数，这些参数被存储在异常实例产生时的 instance.arg

>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print type(inst)
...     print inst.args
...     print inst
...     x, y = inst.args
...     print 'x =', x
...     print 'y =', y
... 
<type &#39;exceptions.Exception&#39;>
(&#39;spam&#39;, &#39;eggs&#39;)
(&#39;spam&#39;, &#39;eggs&#39;)
x = spam
y = eggs

异常处理不仅仅处理直接在try中出现的异常，还可以处理在try中调用函数的异常

>>> def mdiv():
...     x = 1/0
... 
>>> try:
...     mdiv()
... except ZeroDivisionError as detail:
...      print 'Handling run-time error:', detail
... 
Handling run-time error: integer division or modulo by zero

用户自定义异常

程序可以通过创建一个异常类来命令一个新的异常，这个异常类需要通过直接或者间接的方式由 Exception 类派生。

>>> class MyError(Exception):
...     def __init__(self, value):
...          self.value = value
...     def __str__(self):
...          return repr(self.value)
... 
>>> try:
...     raise MyError(1+5)
... except MyError as e:
...     print 'My exception occurred, value:', e.value
... 
My exception occurred, value: 6
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.MyError: &#39;oops!&#39;

在上面的例子中，__ init __ (), 覆盖了默认的 init 函数，新的行为创建了 value 属性， 替换了原有的 创建args属性的行为。

其它类可以做的事情，通过定义Exception类都可以完成。但是Exception类总是被设计地非常简单， 它们提供一些属性，这样错误处理时就可能方便地提取出这些属性。 当设计一个模块处理多种异常时，常常先定义一个基本的类，其它类在此基础上处理一些特殊情况。

class Error(Exception):    
    """Base class for exceptions in this module."""
    pass
    
class InputError(Error):    
    """Exception raised for errors in the input.    
    Attributes:        
       expr -- input expression in which the error occurred        
       msg  -- explanation of the error    """

    def __init__(self, expr, msg):        
       self.expr = expr        
       self.msg = msg
class TransitionError(Error):    
    """Raised when an operation attempts a state transition that's not    
       allowed.    
       
       Attributes:        
          prev -- state at beginning of transition        
          next -- attempted new state        
          msg  -- explanation of why the specific transition is not allowed    
       """

    def __init__(self, prev, next, msg):        
        self.prev = prev        
        self.next = next
        self.msg = msg

在定义局部变量前在函数中使用局部变量

（此时有与局部变量同名的全局变量存在）（导致“UnboundLocalError: local variable 'foobar' referenced before assignment”） 在函数中使用局部变来那个而同时又存在同名全局变量时是很复杂的，使用规则是：如果在函数中定义了任何东西，如果它只是在函数中使用那它就是局部的，反之就是全局变量。 这意味着你不能在定义它之前把它当全局变量在函数中使用。 该错误发生在如下代码中：

someVar = 42 def myFunction(): 
   print(someVar) 
   someVar = 100 
   myFunction()

尝试使用 range()创建整数列表

（导致“TypeError: 'range' object does not support item assignment”） 有时你想要得到一个有序的整数列表，所以 range() 看上去是生成此列表的不错方式。然而，你需要记住 range() 返回的是 “range object”，而不是实际的 list 值。 该错误发生在如下代码中：

spam = range(10) 
spam[4] = -1

也许这才是你想做：

spam = list(range(10)) 
spam[4] = -1

（注意：在 Python 2 中 spam = range(10) 是能行的，因为在 Python 2 中 range() 返回的是list值，但是在 Python 3 中就会产生以上错误）

错在 ++ 或者 -- 自增自减操作符。

（导致“SyntaxError: invalid syntax”） 如果你习惯于例如 C++ , Java , PHP 等其他的语言，也许你会想要尝试使用 ++ 或者 -- 自增自减一个变量。在Python中是没有这样的操作符的。 该错误发生在如下代码中：

spam = 1
spam++

也许这才是你想做的：

spam = 1 
spam += 1

忘记为方法的第一个参数添加self参数

（导致“TypeError: myMethod() takes no arguments (1 given)”） 该错误发生在如下代码中：

class Foo(): def myMethod(): 
       print('Hello!') a = Foo() a.myMethod()