Python/sage: le liste possono iniziare dall'indice 1?

Question

Ho scaricato da una fonte apparentemente seria uno script saggio. Non funziona sul mio computer, e un rapido debug ha mostrato che un problema deriva dal fatto che ad un certo punto, gli autori stavano facendo come se una lista di elementi n fosse numerata da 1 an (considerando la numerazione "normale"). in Python e (quindi) saggio è 0..n-1).

Cosa mi manca? C'è una variabile globale nascosta da qualche parte che modifica questa convenzione, come in APL?

Grazie per il vostro aiuto (Spero che la mia domanda è chiara, nonostante la mia comprensione debole di inglese e CSish ...)

Answer 1

Python (e quindi salvia) liste sono sempre numerati da 0, e non c'è un modo per cambiarlo.

Guardando fonte di CPython, in http://hg.python.org/cpython/file/70274d53c1dd/Objects/listobject.c on line 449:

static PyObject * 
list_item(PyListObject *a, Py_ssize_t i) 
{ 
    if (i < 0 || i >= Py_SIZE(a)) { 
     if (indexerr == NULL) { 
      indexerr = PyString_FromString(
       "list index out of range"); 
      if (indexerr == NULL) 
       return NULL; 
     } 
     PyErr_SetObject(PyExc_IndexError, indexerr); 
     return NULL; 
    } 
    Py_INCREF(a->ob_item[i]); 
    return a->ob_item[i]; 
} 

La voce di ricerca delega direttamente nella matrice C sottostante, e C arrays are always zero-based. Quindi gli elenchi Python sono sempre a base zero.

Answer 2

Bene anche io stavo affrontando la stessa idea su come implementare il metodo di indicizzazione da iniziare da 1. ho voluto implementare l'Insertion Sort algoritmo che è la seguente:

Come già sappiamo lista python parte da 0, quello che ho fatto è stata la seguente:

A = ['dummy',5,2,6,4,1,3] 
for j in range(2,len(A)): 
    key = A[j] 
    i=j-1 
    while i>0 and A[i]>key: 
     A[i+1] = A[i] 
     i = i-1 
    A[i+1] = key 
A.pop(0) 
print A 

ho appena aggiunto un 'Dummy' in indice 0, ha fatto tutto il lavoro come in Algoritmo e rimosso il 'manichino' di nuovo. Questo era solo un metodo per imbrogliare.

Answer 3

Una semplice classe che sposta l'indice per voi fornisce un'interfaccia pulita a qualcosa riutilizzabile.

class Array(object): 

    def __init__(self, items: list) -> None: 
     self.items = items 

    def __repr__(self) -> str: 
     return '{}({})'.format(self.__class__.__name__, self.items) 

    def __len__(self) -> int: 
     return len(self.items) 

    def __contains__(self, item: any) -> bool: 
     return item in self.items 

    def __getitem__(self, key: int) -> any: 
     return self.items[key - 1] 

    def __setitem__(self, key: int, value: any) -> None: 
     self.items[key - 1] = value 

    def __delitem__(self, key: int) -> None: 
     del self.items[key - 1]