Bonjour , j'aimerais savoir pourquoi les indices de chaines sont non-modifiabble, pourquoi leurs méthodes ne modifient pas la chaine mais retournent un objet modifié et j'aimrais aussi comprendre pourquoi les liste ne peuvent être copiées.

aussi j'aimerais comprendre comment on peut retenir cette méthode de split et de join que je ne sais pas sur quoi appeler ni comment avec quel arguments bref je ne comprends pas comment le retenir intuitivment j'ai l'impression que le python est quand même plus ompliqué que le c++ avec le passage de variable a plusieurs arguments (*argument et **argument) merci si vous pouvez m'aidez a retenir les méthodes ou m'aider.

-
Edité par c3r3br4l 14 août 2013 à 2:24:41

Salut,

Les chaînes de caractères en Python sont immutables par conception. Ça permet notamment de garantir qu'on ne fait pas n'importe quoi lorsque l'on les utilise comme clés dans un dictionnaire, au même titre que les tuples.

Ensuite, bien sûr que si, les listes peuvent être copiées (regarde ici). C'est juste que par défaut l'affectation d'une liste à une variable ne copie que sa référence : tout est passé par référence en Python, y compris les objets immutables.

aussi j'aimerais comprendre comment on peut retenir cette méthode de split et de join que je ne sais pas sur quoi appeler ni comment avec quel arguments

C'est sûrement à cause de la syntaxe de join.

>>> liste = 'un,deux,trois'.split(',')
>>> liste
['un', 'deux', 'trois']
>>> ':'.join(liste)
'un:deux:trois'

j'ai l'impression que le python est quand même plus ompliqué que le c++ avec le passage de variable a plusieurs arguments

Tu te rends compte que tu es en train de dire que Python est plus compliqué que C++ parce que tu as du mal à comprendre une de ses features qui n'est quasiment jamais utilisée en C++, et beaucoup plus laborieuse à mettre en oeuvre quand elle l'est ?

Si liste = [1, 2, 3] et que dico = {'un': 1, 'deux': 2, 'trois': 3} alors : func(*liste) est équivalent à func(1, 2, 3) et func(**dico) est équivalent à func(un=1, deux=2, trois=3)

Pour comprendre ce qui se passe dans l'autre sens (quand tu es à l'intérieur de la définition d'une fonction), il suffit de faire un petit test :

>>> def func(*args, **kwargs):
...     print('args: ', repr(args))
...     print('kwargs: ', repr(kwargs))
... 
>>> func(1, 'deux', 'trois', a='A', b=2, c=4)
args:  (1, 'deux', 'trois')
kwargs:  {'a': 'A', 'b': 2, 'c': 4}

Il n'y a rien de bien sorcier là-dedans. Ce qui peut te dérouter à la rigueur, venant du C++, c'est l'existence de paramètres nommés. Ceux-ci permettent simplement de donner des valeurs par défaut aux paramètres qui sont complètement zappés dans l'appel de fonction sans avoir besoin de tous les préciser lorsque l'on n'a besoin que d'un seul d'entre eux. Ça permet de créer des options dont l'utilisateur de la fonction ne s'occupera que lorsqu'il en aura besoin, comme les arguments optionnels de la fonction print(), par exemple :

>>> print('un', 'deux', 'trois', sep=' et ')
un et deux et trois

-
Edité par nohar 14 août 2013 à 10:22:57

Salut

On peut modifier une occurrence d'une chaine avec replace()

mot = "zero"
mot = mot.replace('e', 'i')
# mot vaut maintenant 'ziro'

Par contre en effet je ne peux pas faire : mot[1] = 'i'

les listes ne peuvent pas être copiées ?

liste_1 = ['a', 'b', 'c', 'd']
liste_2 = liste_1
liste_2
# ['a', 'b', 'c', 'd']

join renvoie une chaine qui est la concaténation des éléments de la liste passée en argument. Le séparateur entre les éléments est la chaine sur laquelle tu appliques la méthode

print('-'.join(liste_2))
a-b-c-d
# avec un séparateur vide :
print(''.join(liste_2))
abcd

split renvoie une liste des éléments de la chaine sur laquelle on applique la méthode, en définissant un séparateur

chaine = "a-b-c-d"
liste = chaine.split('-')
liste
# ['a', 'b', 'c', 'd']

EDIT : grillé

-
Edité par noobien 14 août 2013 à 10:30:09

Désolé par avance, mais tu dis quelques bêtises :

noobien a écrit:

On peut modifier une occurrence d'une chaine avec replace()

La chaîne n'est pas modifiée par replace : cette méthode retourne une nouvelle chaîne, par laquelle tu remplaces l'ancienne dans ton exemple.

les listes ne peuvent pas être copiées ?

liste_1 = ['a', 'b', 'c', 'd']
liste_2 = liste_1
liste_2
# ['a', 'b', 'c', 'd']

Ce n'est pas une copie : si tu modifies liste_2, liste_1 sera elle aussi modifiée. Pour faire une vraie copie sans se prendre la tête on peut utiliser le module copy, ou bien le constructeur par recopie de la classe list (pour une copie superficielle).

>>> orig = [1, 2, 3]
>>> copie = orig
>>> copie.append(4)
>>> orig
[1, 2, 3, 4]
>>> # OOPS!
... 
>>> copie = list(orig)
>>> copie.append(5)
>>> orig
[1, 2, 3, 4]
>>> copie
[1, 2, 3, 4, 5]

-
Edité par nohar 14 août 2013 à 11:08:28

Sois pas désolé, si je dis des bêtises c'est normal de corriger !

EDIT : et merci pour l'exemple, je comprends mieux

-
Edité par noobien 14 août 2013 à 11:23:00

Oui j'ai bien compris qu'on pouvait copier une liste mais ce que je ne comprends pas encore une fois c'est pourquoi et si tout est passé par référence pourquoi alors chaine=chaine on a une copie.??

c3r3br4l a écrit:

Oui j'ai bien compris qu'on pouvait copier une liste mais ce que je ne comprends pas encore une fois c'est pourquoi

Parce que c'est comme ça que le langage a été conçu.

> et si tout est passé par référence pourquoi alors chaine=chaine on a une copie.??

On n'a pas de copie. Ce sont deux références sur le même objet :

>>> chaine1 = 'plop'
>>> chaine2 = chaine1
>>> id(chaine1)
139664521936768
>>> id(chaine2)
139664521936768

-
Edité par nohar 14 août 2013 à 15:56:29

Q: Quand on fait maVar=MaClasse() c'est l'équivalent de pointeur=new MaClasse() du C++ et on a donc un pointeur? En passant en quelle différence entre MaClasse maVar() et maVar=MaClasse() (ma question a donc uniquement un rapport au C++ ici)

-
Edité par c3r3br4l 14 août 2013 à 19:27:39

Si tu veux, on peut considérer que c'est un pointeur, quoique c'est plus proche des références de C++ que des pointeurs (y'a pas d'arithmétique des pointeurs, en particulier). Toutes les variables sont des références en Python.

Là où ça devient déroutant pour quelqu'un qui vient du C++, c'est quand tu considères les types natifs (comme int) : les variables sont des références sur des valeurs constantes et non des pointeurs sur des entiers.

Quant à ta seconde question, il n'y a aucune différence entre les deux. C'est juste de la syntaxe.

-
Edité par nohar 14 août 2013 à 20:17:12