variable = []

Maintenant variable se réfère à une liste vide ^* .

bien sûr, il s'agit d'une mission, pas d'une déclaration. Il n'y a aucun moyen de dire en Python "cette variable ne devrait jamais se référer à autre chose qu'à une liste", car Python est saisi dynamiquement.

^* le type Python intégré par défaut est appelé list , pas un tableau. C'est un contenant commandé 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 array module , qui offre un type plus proche du type C array ; le contenu doit être homogène (tous du même type), mais la longueur est encore dynamique.

vous ne déclarez pas les choses, mais c'est comme ça que vous créez un tableau en Python:

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

pour plus d'informations voir le module array: http://docs.python.org/library/array.html

maintenant possible vous ne voulez pas un tableau, mais une liste, mais d'autres ont déjà répondu que. :)

c'est un sujet étonnamment complexe en Python.

réponse pratique

sont représentées par la classe list (voir référence et ne les mélangent pas avec générateurs ).

consulter les 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 le list de Python est un wrapper pour un vrai tableau qui contient des références à des articles. Aussi, sous-jacente tableau est créé avec un peu d'espace supplémentaire.

conséquences de ceci sont:

• random access est vraiment bon marché ( arr[6653] est identique à arr[0] )
• append l'utilisation est "gratuite" alors qu'un peu d'espace supplémentaire
• insert l'opération coûte cher

Cochez cette impressionnant tableau de les opérations de complexité .

aussi, s'il vous plaît 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:

je pense que vous (vouliez dire)voulez une liste avec les 30 premières cellules déjà remplies. So

   f = []

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

un exemple où ceci pourrait être utilisé est dans la séquence de Fibonacci. Voir problème 2 dans projet Euler

C'est comme ça:

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

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

pour les calculs, utilisez numpy tableaux comme ceci:

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 sauvegardés et chargés à partir du disque (même comprimé) et des calculs complexes avec de grandes quantités d'éléments est comme C-comme rapide. Très utilisé dans les environnements scientifiques. Voir ici pour plus d'informations...

je ferais normalement a = [1,2,3] qui est en fait un list mais pour arrays regardez ce formel définition

quelques contributions suggèrent que les tableaux en python sont représentés par des listes. Peut-être théoriquement/sous la hotte qui est correcte cependant une distinction majeure entre les deux est le fait que les listes acceptent les types de données mixtes et les types numériques mixtes, d'autre part le tableau exige un code de type limitant tous les éléments au type déterminé:

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

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

ce n'est pas possible en utilisant array().

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.tableau, mais pas 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 pour le travail de liste avec tableau aussi, commun les uns étant pop(), extend (), et append ().

à en juger par les réponses et les commentaires, il semble que le tableau structure de données n'est pas très populaire. Je l'aime bien, même comme on préférerait un tuple à une liste.

la structure du tableau a des règles plus strictes qu'une liste ou un np.tableau, ce qui peut réduire les erreurs et faciliter le débogage, surtout lorsqu'on travaille avec des données.

tente d'insérer/ajouter un flottant à un tableau int lancera une erreur de type:

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

conservation des valeurs qui sont censés être des entiers (par exemple Liste des indices) dans le tableau la forme peut donc empêcher un "TypeError: les indices de liste doivent être des entiers, pas des flotteurs", puisque les tableaux peuvent être itérés plus, semblable à np.tableau et listes:

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

fâcheusement, ajouter un int à un tableau de flotteurs va faire en sorte que l'int devienne un flotteur, sans faire d'exception.

np.tableau conserve le même type de données pour ses entrées aussi, mais au lieu de donner une erreur il changer son type de données pour s'adapter aux nouvelles entrées (généralement à double ou 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 pendant l'affectation. Si le type de données est spécifié, np.array transformera, dans la mesure du possible, les entrées de 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 donnerons tout 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.tableau pour commandes spécifiques à un type. La structure du tableau est utile ici. list 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 (habituellement) le second dans np.tableau.)( : /

la relation avec C est mentionnée ici: Liste Python vs. Tableau - quand les utiliser?

bonne exploration!

Note: et la nature plutôt stricte du tableau penche davantage vers C plutôt que Python, et par conception Python n'a pas beaucoup de contraintes spécifiques au type dans ses fonctions. Son impopularité crée également un feedback positif dans le travail collaboratif, et son remplacement implique principalement un [int(x) Supplémentaire pour x dans le fichier]. Il est donc tout à fait viable et raisonnable d'ignorer l'existence de la matrice. Ça ne devrait pas gêner la plupart d'entre nous. : D

après Lennart, il y a aussi numpy qui implémente des matrices multi-dimensionnelles homogènes.

Python les appelle liste . Vous pouvez écrire une liste littérale avec des crochets et des virgules:

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

que dis-tu de ça?..

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

j'avais un tableau de cordes et j'avais besoin d'un tableau de la même longueur de booléens initiés à 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 des tableaux en utilisant le module de numpy. Voici quelques exemples pour illustrer la même chose. Num PY rend également plus facile de travailler 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 dans une matrice 2X2 en utilisant la fonction remodelage qui prend en entrée que les dimensions de la matrice.

mat = a.reshape(2, 2)

JohnMachin le commentaire de devrait être la vraie réponse. Toutes les autres réponses ne sont que des solutions de rechange à mon avis! So:

array=[0]*element_count