Comment déclarer un tableau en Python ?

Je ne trouve aucune référence aux tableaux dans la documentation.

variable = []

Désigne maintenant variableune liste vide ^* .

Bien sûr, c'est une mission, pas une déclaration. Il n'y a aucun moyen de dire en Python "cette variable ne doit jamais faire référence à autre chose qu'à une liste", car Python est typé dynamiquement.

^* Le type Python intégré par défaut est appelé une liste , pas un tableau. C'est un conteneur ordonné de longueur arbitraire qui peut contenir une collection hétérogène d'objets (leurs types n'ont pas d'importance et peuvent être librement mélangés). Cela ne doit pas être confondu avec le arraymodule , qui propose un type plus proche du arraytype C ; le contenu doit être homogène (tous du même type), mais la longueur reste dynamique.

C'est un sujet étonnamment complexe en Python.

Réponse pratique

Les tableaux sont représentés par classe list(voir référence et ne pas les mélanger avec des générateurs ).

Découvrez des exemples d'utilisation:

# empty array
arr = [] 

# init with values (can contain mixed types)
arr = [1, "eels"]

# get item by index (can be negative to access end of array)
arr = [1, 2, 3, 4, 5, 6]
arr[0]  # 1
arr[-1] # 6

# get length
length = len(arr)

# supports append and insert
arr.append(8)
arr.insert(6, 7)

Réponse théorique

Sous le capot, Python listest un wrapper pour un vrai tableau qui contient des références aux éléments. En outre, le tableau sous-jacent est créé avec un espace supplémentaire.

Les conséquences de ceci sont:

• l'accès aléatoire est vraiment bon marché ( arr[6653]c'est pareil pour arr[0])
• append le fonctionnement est «gratuit» tandis que de l'espace supplémentaire
• insert l'opération coûte cher

Consultez cette impressionnante table de complexité des opérations .

En outre, veuillez voir cette image, où j'ai essayé de montrer les différences les plus importantes entre le tableau, le tableau de références et la liste liée:

Vous ne déclarez pas réellement les choses, mais voici comment vous créez un tableau en Python:

from array import array
intarray = array('i')

Pour plus d'informations, consultez le module tableau: http://docs.python.org/library/array.html

Maintenant, il est possible que vous ne vouliez pas d'un tableau, mais d'une liste, mais d'autres y ont déjà répondu. :)

Je pense que vous (vouliez) vouloir une liste avec les 30 premières cellules déjà remplies. Donc

   f = []

   for i in range(30):
       f.append(0)

Un exemple où cela pourrait être utilisé est dans la séquence de Fibonacci. Voir le problème 2 dans Project Euler

C'est ainsi:

my_array = [1, 'rebecca', 'allard', 15]

Pour les calculs, utilisez des tableaux numpy comme celui-ci:

import numpy as np

a = np.ones((3,2))        # a 2D array with 3 rows, 2 columns, filled with ones
b = np.array([1,2,3])     # a 1D array initialised using a list [1,2,3]
c = np.linspace(2,3,100)  # an array with 100 points beteen (and including) 2 and 3

print(a*1.5)  # all elements of a times 1.5
print(a.T+b)  # b added to the transpose of a

ces tableaux numpy peuvent être enregistrés et chargés à partir du disque (même compressés) et les calculs complexes avec de grandes quantités d'éléments sont rapides en C.

Très utilisé dans les environnements scientifiques. Voir ici pour en savoir plus.

Le commentaire de JohnMachin devrait être la vraie réponse. À mon avis, toutes les autres réponses ne sont que des solutions de contournement! Donc:

array=[0]*element_count

Quelques contributions ont suggéré que les tableaux en python sont représentés par des listes. Ceci est une erreur. Python a une implémentation indépendante de array()dans le module de bibliothèque standard array " array.array()", il est donc incorrect de confondre les deux. Les listes sont des listes en python donc soyez prudent avec la nomenclature utilisée.

list_01 = [4, 6.2, 7-2j, 'flo', 'cro']

list_01
Out[85]: [4, 6.2, (7-2j), 'flo', 'cro']

Il y a une différence très importante entre la liste et array.array(). Alors que ces deux objets sont des séquences ordonnées, array.array () est une séquence homogène ordonnée tandis qu'une liste est une séquence non homogène.

Vous ne déclarez rien en Python. Vous l'utilisez simplement. Je vous recommande de commencer avec quelque chose comme http://diveintopython.net .

Je ferais normalement ce a = [1,2,3]qui est en fait un listmais pour arraysregarder cette définition formelle

Pour ajouter à la réponse de Lennart, un tableau peut être créé comme ceci:

from array import array
float_array = array("f",values)

où les valeurs peuvent prendre la forme d'un tuple, d'une liste ou d'un np.array, mais pas d'un tableau:

values = [1,2,3]
values = (1,2,3)
values = np.array([1,2,3],'f')
# 'i' will work here too, but if array is 'i' then values have to be int
wrong_values = array('f',[1,2,3])
# TypeError: 'array.array' object is not callable

et la sortie sera toujours la même:

print(float_array)
print(float_array[1])
print(isinstance(float_array[1],float))

# array('f', [1.0, 2.0, 3.0])
# 2.0
# True

La plupart des méthodes de liste fonctionnent également avec array, les plus courantes étant pop (), extend () et append ().

À en juger par les réponses et les commentaires, il semble que la structure des données du tableau ne soit pas si populaire. Je l'aime cependant, de la même manière que l'on pourrait préférer un tuple à une liste.

La structure du tableau a des règles plus strictes qu'une liste ou np.array, ce qui peut réduire les erreurs et faciliter le débogage, en particulier lorsque vous travaillez avec des données numériques.

Les tentatives d'insertion / ajout d'un flottant dans un tableau int lèveront une TypeError:

values = [1,2,3]
int_array = array("i",values)
int_array.append(float(1))
# or int_array.extend([float(1)])

# TypeError: integer argument expected, got float

Garder des valeurs qui sont censées être des entiers (par exemple une liste d'index) sous la forme d'un tableau peut donc empêcher une "TypeError: les index de la liste doivent être des entiers, pas des flottants", car les tableaux peuvent être itérés, comme np.array et lists:

int_array = array('i',[1,2,3])
data = [11,22,33,44,55]
sample = []
for i in int_array:
    sample.append(data[i])

De façon ennuyeuse, l'ajout d'un int à un tableau flottant entraînera l'int int devenir un flottant, sans lever une exception.

np.array conserve également le même type de données pour ses entrées, mais au lieu de donner une erreur, il changera son type de données pour s'adapter aux nouvelles entrées (généralement en double ou en str):

import numpy as np
numpy_int_array = np.array([1,2,3],'i')
for i in numpy_int_array:
    print(type(i))
    # <class 'numpy.int32'>
numpy_int_array_2 = np.append(numpy_int_array,int(1))
# still <class 'numpy.int32'>
numpy_float_array = np.append(numpy_int_array,float(1))
# <class 'numpy.float64'> for all values
numpy_str_array = np.append(numpy_int_array,"1")
# <class 'numpy.str_'> for all values
data = [11,22,33,44,55]
sample = []
for i in numpy_int_array_2:
    sample.append(data[i])
    # no problem here, but TypeError for the other two

Cela est également vrai lors de l'affectation. Si le type de données est spécifié, np.array transformera, dans la mesure du possible, les entrées en ce type de données:

int_numpy_array = np.array([1,2,float(3)],'i')
# 3 becomes an int
int_numpy_array_2 = np.array([1,2,3.9],'i')
# 3.9 gets truncated to 3 (same as int(3.9))
invalid_array = np.array([1,2,"string"],'i')
# ValueError: invalid literal for int() with base 10: 'string'
# Same error as int('string')
str_numpy_array = np.array([1,2,3],'str')
print(str_numpy_array)
print([type(i) for i in str_numpy_array])
# ['1' '2' '3']
# <class 'numpy.str_'>

ou, en substance:

data = [1.2,3.4,5.6]
list_1 = np.array(data,'i').tolist()
list_2 = [int(i) for i in data]
print(list_1 == list_2)
# True

tandis que le tableau donnera simplement:

invalid_array = array([1,2,3.9],'i')
# TypeError: integer argument expected, got float

Pour cette raison, ce n'est pas une bonne idée d'utiliser np.array pour les commandes spécifiques au type. La structure du tableau est utile ici. La liste conserve le type de données des valeurs.

Et pour quelque chose que je trouve plutôt embêtant: le type de données est spécifié comme premier argument dans array (), mais (généralement) le second dans np.array (). : |

La relation avec C est référencée ici: Python List vs. Array - quand l'utiliser?

Amusez-vous à explorer!

Remarque: La nature typée et plutôt stricte du tableau penche davantage vers C que vers Python, et par conception Python n'a pas beaucoup de contraintes spécifiques au type dans ses fonctions. Son impopularité crée également une rétroaction positive dans le travail collaboratif, et le remplacer implique principalement un [int (x) pour x dans le fichier] supplémentaire. Il est donc tout à fait viable et raisonnable d'ignorer l'existence d'un tableau. Cela ne devrait en aucun cas gêner la plupart d'entre nous. :RÉ

Que dis-tu de ça...

>>> a = range(12)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> a[7]
6

Python les appelle des listes . Vous pouvez écrire un littéral de liste avec des crochets et des virgules:

>>> [6,28,496,8128]
[6, 28, 496, 8128]

Dans la continuité de Lennart, il existe également numpy qui implémente des tableaux multidimensionnels homogènes.

J'avais un tableau de chaînes et j'avais besoin d'un tableau de la même longueur de booléens initié à True. C'est ce que j'ai fait

strs = ["Hi","Bye"] 
bools = [ True for s in strs ]

Vous pouvez créer des listes et les convertir en tableaux ou vous pouvez créer un tableau à l'aide du module numpy. Voici quelques exemples pour illustrer la même chose. Numpy facilite également le travail avec des tableaux multidimensionnels.

import numpy as np
a = np.array([1, 2, 3, 4])

#For custom inputs
a = np.array([int(x) for x in input().split()])

Vous pouvez également remodeler ce tableau en une matrice 2X2 en utilisant la fonction de remodelage qui prend en entrée les dimensions de la matrice.

mat = a.reshape(2, 2)