Prendre en main un nouveau langage

Bonjour, je voudrais me mettre au python et je vais en avoir besoin très prochaiement. Je ne suis pas débutant, je finis mon IUT Informatique à Paris Descartes et surtout je suis passioné. Je vais en avoir besoin pour faire de la recherche avec un prof sur l'analyse d'image.

Bref, tout ça pour vous demander quels étaient les meilleurs moyens d'apprendre un nouveau langage quand on connait plutôt bien les concepts de bases de la programmation impérative et objet.

Plus particulièrement sur python, auriez vous des exercices/mini-projet qui permettent de voir les particularités du langage par rapport au si répandu Java (qui est le langage que j'ai le plus utilisé) ?

J'aurais la même question pour le Haskell tant qu'on y est

Tu peux jeter un coup d'oeil à ça :

• http://learnxinyminutes.com/docs/python3/
• http://sametmax.com/cours-et-tutos/

PS : http://learnxinyminutes.com/docs/haskell/

Python est tellement simple à apprendre que dans mon cas, je l'ai appris en apprenant à utiliser django (donc sur les codes d'exemples de django).

Du coup, je te conseille de prendre un cours (il y en a de très bon sur le site même de python) pour maitriser rapidement la syntaxe et l'esprit, et de t'entrainer surtout sur le traitement d'image (tant qu'à faire).

Si tu en as besoin, OpenCV est disponible pour python, mais sinon, avoir la base pour la bibliothèque numpy parait essentiel.

Pour Haskell, je ne connais pas, mais par contre le passage {C++/python}->ocaml (qui est également fonctionnel) a été bien plus douloureux que pour le python, il y a bien plus de choses qui changent (fonctionnel, variable constante par défaut, …).

Pour le Python, venant de Java, tu dois surtout apprendre a ne pas raisonner en "tout objet" car si Python permet la POO, il autorise aussi d'autres paradigmes. Et évidement fouiller la lib standard pour ne pas ré-inventer la roue.

Apprendre Python quand on a déjà de bonne base en dev est facile. Il y a des TONNES de ressources sur le net. Prend une qui correspond à ton niveau et étudie le. Mais très vite tu va avoir compris le langage. Ce qu'il reste après à faire c'est pratiquer, pratiquer et pratiquer. Prend toi des mini projets, code les et éventuellement vient nous présenter ici le résultat qu'on te donne un avis sur ton code car il y a plein de façon de coder en Python mais il y a des façons plus "pythonesques" que d'autres.

Hésite pas non plus a prendre des lib ou application connu et de regarder les sources. Les programmes et lib python sont en général assez bien documentés et facile à comprendre.

Pour de l'analyse d'image, tu va avoir besoin de travailler avec quelque lib. La principale est numpy qui est LE package de base de tous les modules un peu scientifique en python. Avec des libs compagnons comme scipy, matplotlib, pandas, etc. tu te retrouve avec un environnement "à la matlab" très complet. En fonction de ce que fait ton prof, tu aura probablement aussi à utiliser OpenCv qui fournit de base un binding python. Hésite pas à le télécharger pour regarder les exemples fournit. OpenCV utilise aussi maintenant les array numpy pour représenter les images coté Python.

Pour le haskell, je connais moins mais j'avais apprécié learn you a Haskell qui est dispo gratuitement sur le net. Mais je te déconseille de faire les deux en même temps. Pour bien maitriser Haskell il faut vraiment commencer par faire abstraction de ce que tu connais déjà en prog objet et impérative. Le mieux est donc de ce concentrer sur le dev fonctionnel quand tu l'apprend.

Pour du Python idomatique, il y a ça : https://www.youtube.com/watch?v=OSGv2VnC0go

Merci beaucoup pour toutes ces réponses.

Je vais répondre de manière générale. Je n'ai pas forcément l'habitude de penser objet pur je pense. Ce dont j'ai l'habitude c'est d'avoir mes propres types de données, qui ressemblent plutôt aux structures du C. En plus ça fait 2 mois que je fais du Cobol donc l'objet c'est un peu loin.

Pour le haskell c'était par curiosité, mais je en compte pas faire ça tout de suite effectivement.

Sinon pour les bibliothèques, j'en ai déjà un scope plutôt complet : matplotlib, numpy, scikit-image, IPython et scikit-learn. Mais je voulais prendre un peu en main le python et la pythonesquerie avant de me lancer dedans

En tout cas merci beaucoup ! Dommage qu'il n'y est pas une méthode un peu générale pour apprendre un novueau langage

Parce que la méthode général ne te serais pas adapté. Sincèrement python est globalement simple a prendre en main. Fais toi quelques projets c'est ce qui sera le plus efficace.

Ensuite regarde numpy car toutes les autres que tu cite reposent dessus (sauf IPython mais c'est pas vraiment une lib)

Pusique vous m'avez dit que vous me corrigeriez, voici ce que j'ai fait. Le but est de calculer la somme des termes pair de la suite de fibonacci sous une certaine limite

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def fibonacciL(limit):
    currentI = 2
    list = []
    list.append(1)
    list.append(1)
    list.append(2)

    while(list[-1] < limit):
        list.append(list[currentI] + list[currentI - 1])
        currentI += 1
    del list[-1]
    return list


"""
list = fibonacciL(400000000)
print("{}".format(list))
listEven = list[2::3]
print("{}".format(listEven))
"""
print(sum(iter(fibonacciL(400000000)[2::3])))

Je vois comment tu fais mais si tu regardes ton algo, tu maintiens une liste alors que tu peux te contenter de maintenir une variable contenant la somme "jusque-là". Fibonacci c'est une suite définie par récurrence double. Tu pourrais essayer d'écrire une fonction récursive pour calculer le terme d'indice n de la suite de Fibonacci ? Tu vas voir, avec une fonction récursive ça s'implémente facilement.Une fois que tu aurais fait ça, ça sera plus facile de modifier ta fonction pour calculer cette somme.

Grimur : sauf que le recursif est à éviter en python, qui n'est volontairement pas optimisé pour et qui le dit dans ses règles du bon développeur. Le vrai "récursif" en python, c'est quand c'est toi qui gère toi même la pile, et que tu as une boucle.

Bon, en soit, ca a un avantage indéniable, tu vois quand ta fonction est "recursive terminale" lorsque tu peux te passer de la boucle, mais c'est moins naturel, et sinon python coupe au bout d'un petit nombre d'appel.

Je ne sais pas où tu en es de ton apprentissage du Python, mais la liste n'est pas forcément une mauvaise chose, puisque tu pourras aisément la remplacer par un générateur. Seul problème: [2::3], qui n'est de toute façon pas très lisible, et que tu ne pourras pas utiliser sur un générateur.

Ainsi, pour ta dernière ligne, ceci sera sûrement préférable:

1

print(sum(i for i in fibonacciL(400000000) if i % 2 == 0))

Aussi, je vois que tu utilises du camel case, c'est généralement déconseillé pour les noms de variables en Python, et réservé aux noms de classes. Enfin, appeler une variable list n'est pas judicieux.

@Grimur: il veut apparemment obtenir la suite, normal d'utiliser une liste pour ça.

@Ricocotam:

Le même code, en plus "pythonesque" :

1
2
3
4
5

def fib(limit):
    lst = [1, 1]
    while lst[-1] < limit:
        lst.append(lst[-1] + lst[-2])
    return lst[:-1]

Ou en évitant le slice au return (du coup c'est un peu plus C-like) :

1
2
3
4
5
6
7
8

def fib(limit):
    lst = [1, 1]
    while True:
        x = lst[-1] + lst[-2]
        if x > limit:
            break
        lst.append(x)
    return lst

Au passage, on évite généralement de nommer une variable avec le nom d'un type python, ce n'est pas interdit, mais c'est source d'erreurs.

EDIT: Comme mentionné par entwanne, un générateur est ici judicieux. Exemple :

1
2
3
4
5

def fib(limit):
    a, b = 0, 1
    while a < limit:
        yield a
        a, b = b, a + b

La limite n'est même plus nécessaire, on peut sans problème utiliser un générateur "infini", et la combinaison de générateurs permet par exemple de faire des trucs comme ça :

1

sum(islice(takewhile(lambda x: x < 10000, fib()), 0, None, 3))

Quelques remarques :

Ligne 1-2 : les noms de fonctions et variables s'écrivent en snake_case par convention. Il y a pas grand chose d'imposé par Python par contre il y a plein de conventions (cf pep 8 entre autre).

Ligne 3-6 : peuvent etre raccourcis en list = [1, 1, 2]. De plus list est un très mauvais nom car c'est le type/constructeur des listes et est utilisé très souvent.

currentI est inutile. Une fois initialisé tu peux faire ta ligne 9 par : list.append(list[-1] + list[-2]) ou list.append(sum(list[-2:]))

Ligne 11-12 : un return list[:-1] serait suffisant.

Enfin derniere ligne, iter est inutile et pourquoi prendre les éléments toutes les 3 cases si tu veux tous les pairs ?

@Grimur: il veut apparemment obtenir la suite, normal d'utiliser une liste pour ça.

J'avais compris qu'il voulait juste itérer parmi les termes de la suite de Fibonacci. Pour ça il n'avait pas besoin de liste, deux variables seulement suffisent, comme ce que tu as fait:

D'ailleurs, OP, vu que tu t'intéresses apparemment à Haskell, les programmeurs fonctionnels auraient tendance à combiner des fonctions un peu comme ce que disait yoch.

Petite précision concernant l'apprentissage du Haskell : le tuto que te conseille Kje (et que je recommande chaudement aussi) a été fort bien traduit en français, alors autant en profiter.

Si l'OP s'intéresse au Haskell, voici une façon d'écrire le programme que tu as fait plus haut:

1
2
3
4
5
6
7
8
9

import ReadArgs

fib :: [Integer]
fib = 1: scanl (+) 1 fib

main :: IO ()
main = do
    limit <- readArgs
    print . sum . filter even $ takeWhile (< limit) fib

Bonjour, donc si j'ai bien compris, il faut que j'utilise un peu plus les " [::] " ? Je n'avais pas compris qu'on pouvait faire des lst[-x], c'est pour ça que je ne l'avais pas fait

Sinon, il se trouve que dans la suite de fibonacci, tout les 3 termes sont pairs (si on commence avec [0, 1]), je vous laisse chercher pourquoi.

En tout cas merci beaucoup, je vous reposterais quelques trucs de temps en temps pour que vous me corrigiez :p.

Merci à ceux qui me montre pour le fonctionnel, je m'y interesserais dans quelques temps donc je le garde sous la main !