Bienvenue sur IndexError.

Ici vous pouvez poser des questions sur Python et le Framework Django.

Consultez la FAQ pour améliorer vos chances d'avoir des réponses à vos questions.

utilité des types slice et hints ?

+4 votes

j'ai rien compris sur l' utilité des types slice et hints ...

demandé 10-Jun-2015 par buffalo974 (2,956 points)

c'est quoi le type "hints" ?

Tu parles du type hinting de Python 3.5 ?

Je pense qu'il parle de ça

J'imagine que tu as deja lu la bonne parole

oui mes les voies du seigneur sont parfois impénétrables

N'aurait-il pas été plus judicieux de créer deux questions séparées ? Il serait ainsi plus simple de répondre à chacune.

Parce que là, je vois vraiment pas le rapport entre les deux, mise à part ton insatiable soif envie de comprendre.

1 Réponse

+7 votes
 
Meilleure réponse

HINTING

Apprement, le hinting (ça se dit :O ? ) sert à définir explicitement le type des variables en paramètre ainsi que le type de retour d'une fonction :

Premier exemple tiré de S&M :

def add(a: int, b: int) -> int:
    return a + b

Ici, on attend une valeur entière pour les paramètres a et b.
On s'attend aussi à ce que la fonction retourne une valeur entière.

Deuxième exemple tiré de la doc :

def greeting(name: str) -> str:
    return 'Hello ' + name

Ici, on remarque que la fonction greeting avec en entrée une str et va renvoyer une str ^^'

SA SER A KWA !?

ça peut aider à l'utilisation au débugage lorsque l'on sait au premier coup d'oeil les valeurs attendues en entrée et en sortie.
Mais aussi :

Quand un surcroit de rigueur sera nécessaire, on pourra rajouter un
filet de sécurité. Et dans quelques temps, peut-être même gagner
sérieusement en perf.

SLICE

Apprement, euh...comment dire...c'est comme du découpage en tranche =D

[EDIT/]

signature de slice :

slice(start, limit, step)

[/EDIT]

j'ai rien compris sur l' utilité des types slice

En fait, ce dont tu parles c'est l'objet slice ! (on ne parle de type ici)

>>> type(slice(2,4))
<class 'slice'>

c'est un peu spécial, mais un exemple vaut mieux qu'un long discours :

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[2:4]
[2, 3]
>>> items[a]
[2, 3]
>>> items[a] = [10,11]
>>> items
[0, 1, 10, 11, 4, 5, 6]
>>> del items[a]
>>> items
[0, 1, 4, 5, 6]

ET ALORS?

en fait, on crée un objet slice qu'on peut ensuite utiliser n'importe où et n'importe quand, du moment que celui ci est autorisé.

Comment le dirait Sam :

Donc plutôt que de se trimbaler avec des tuples de valeurs dont il
faudra tester ou imposer la taille. Plutôt que d’attendre en paramètre
uniquement des entiers positionnels ou forcer le passage de None, on
peut aussi tout simplement passer un slice à vos fonctions qui font du
slicing.

répondu 11-Jun-2015 par boblinux (3,092 points)
edité 11-Jun-2015 par boblinux

Le hinting me fait furieusement penser au cython. C'est une idée pour s' entrainer avant d' attaquer ce langage dérivé.

Pour slice, ça y'est j'ai commencé à comprendre.
Je vois ça comme une espèce de tranche positionnelle relative et non pas absolue car on peut l' appliquer sur une seconde liste.

>>> items = [0, 1, 2, 3, 4, 5, 6]
>>> a = slice(2, 4)
>>> items[a]
[2, 3]

>>> maliste = ['a','b','c','d','f','g']
>>> maliste[a]
['c', 'd']

Mais à quoi correspond None dans :

>>> a
slice(2, 4, None)

Si tu veux, la signature de slice c'est ça :

slice(start, limit, step)

du coup :

>>> r = range(9)
>>> r
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> r[slice(None, None, 2)]
[0, 2, 4, 6, 8]

Donc le none de :

>>> a
slice(2, 4, None)

c'est le pas exercé (j'crois que par défaut c'est 1 )

j'édite mon post au passage ^^

Mot pr mot, type hint se dirait: indice de type. Mais je pense que la bonne definition, c'est juste: typage statique. L'image est d'autant plus forte parce qu'en face du type hint, on a le duck typing :) An hint to recognize the duck?

j'crois qu'on appelle ça typage nominatif en bon wikipedien

Ha oui marrant cet objet :

Sa signature c'est bien ca :

slice(start, limit, step)

Mais cette forme est valable aussi :

slice(param)

Je m'atendais - naivement- a ce que ce soit un équivalent de

slice(start, limit=None, step=None) # nope

et donc que

"string"[slice(1)] == "string"[1] # nope nope nope

Sauf que non :

In [60]: s = slice(1,2,3)

In [62]: s.start, s.stop, s.step
Out[62]: (1, 2, 3)

In [63]: s = slice(1)

In [64]: s.start, s.stop, s.step
Out[64]: (None, 1, None)

In [65]: s = slice(1, 2)
In [66]: s.start, s.stop, s.step
Out[66]: (1, 2, None)

Quand on lui donne un seul parametre, c'est le stop qui est valorisé.

C'est vraiment l'implémentation de la syntaxe du slicing :

In [107]: "string"[slice(1)] == "string"[:1]
Out[107]: True
# et pas "string"[1]

In [108]: "string"[slice(1, 1)] == "string"[1:1]
Out[108]: True

In [109]: "string"[slice(1, 2, )] == "string"[1:2]
Out[109]: True

In [112]: "string"[slice(1, 2, 1)] == "string"[1:2:1]
Out[112]: True

et au final, ca fait completement sens.

j'upvote les commentaires autant que la réponse.

"Et dans quelques temps, peut-être même gagner sérieusement en perf." ce n'est pas le cas à ma connaissance

...