Profil de Karnaj

  • Inscrit 17/07/14 à 22h10
  • Dernière visite sur le site : il y a 4 minutes

Signature

Je fais un carnage si ce car nage car je nage, moi, Karnaj ! - Le comble pour un professeur de mathématique ? Mourir dans l’exercice de ses fonctions.

Derniers sujets créés

Derniers tutoriels

Derniers articles


Biographie

Élève de MP depuis fort fort longtemps. Objectif : intégrer malgré un esprit qui dérive.

Ruby ou Python ?

Aucun animal n’a été torturé pour le tournage de ce profil.

Ce profil contient des scènes dangereuses et ses acteurs sont des sportifs surentraînés. Ne faîtes pas ça chez vous1.

Ruby et Python sont souvent comparés, et beaucoup de débutants ne savent pas lequel choisir. Pourtant, comme pour tout, le choix entre les deux doit se faire en fonction de ce que vous voulez faire.

Si vous comptez vous rendre dans un endroit dangereux, le Python sera un excellent moyen de vous protéger et de prévenir les attaques.

Au contraire si vous voulez acquérir quelque chose ou séduire quelqu’un, le Ruby vous sera d’une grande aide à moins que cette personne ne soit un passionné de Python.

Si vous voulez braquer une banque (rappelez-vous, ne faîtes pas ça chez vous), le Python vous sera très utile pour empêcher toute tentative de rébellion.

Le Python semble alors être ¨un ton au dessus du Ruby, tant il semble polyvalent.

Mais, il ne faut pas oublier que si le Python vous aide à braquer une banque, le Ruby vous donne accès à toute la banque. De même, avec le Ruby, vous serez en mesure d’obtenir des gens pour vous protéger si vous allez dans un endroit dangereux ou même d’obtenir que ces dangers ne vous importunent pas.

Finalement, le Python vous aide à accomplir vos objectifs, mais le Ruby, lui, accomplit vos objectifs. La différence est notable, et c’est dès lors cette différence qui doit vous aider à choisir. La manière dont vous obtenez ce que vous voulez vous intéresse-t-elle ? Voulez-vous ressentir la fierté d’accomplir votre objectif ou voulez-vous juste savourer vos possessions ?

Si vous aviez le pouvoir de changer UNE chose sur ZdS qu’est ce que vous changeriez ? et Pourquoi ? Exprimez vous

Je changerais la manière dont sont traités les auteurs pour qu’ils produisent plus (nous savons grâce à un indic qu’il y en a qui bénéficient d’un régime de faveur).

Donc il faudrait peut-être donner plus d’agrumes frais, et puisqu’il y a quand même beaucoup d’espèces animales, on pourrait même obtenir du lait et de la viande fraîche… En étant bien nourri, il produiront sûrement plus.

À côté de çà, il faut faire attention à ne pas dépasser les frais, et pour les motiver, les châtiments corporels devraient naturellement être plus présents. Il faut cependant faire attention à les garder en bonne santé pour qu’ils continuent à attirer d’autres auteurs

Citations ?

Je fais des rimes, Quand je m’exprime. Je fais des vers, Sans en avoir l’air. Mais le plus fort, C’est que j’en fais encore !

Réflexions ?

Terry Pratchett : « La lumière croit voyager plus vite que tout, mais elle se trompe. Elle aura beau foncer le plus vite possible, elle verra toujours que les ténèbres sont arrivées les premières et qu’elles l’attendent. ».

« Le temps est une drogue. À haute dose, il tue. ». Donc faîtes attention. Tuez le temps avant qu’il ne vous tue.

Moi : « L’homme est un loup pour l’homme et l’argent est le chef de la meute… ».

Programmation ?

« Ce qui ce conçoit bien s’énonce clairement. ». Si ça ne s’énonce pas clairement, c’est à remplacer.

  • Less code, less error.
  • Less is more.
  • The best code is no code at all.

Mes tutoriels

C

LaTeX

Mathématiques

Python

Ruby

À écrire

Mathématiques et algorithmie

  • Dénombrement et probabilités.
  • Introduction à la recherche de plus court chemin.

LaTeX

  • Écrire des codes sources en LaTeX (listings ou minted).
  • Écrire des CV en LaTeX.
  • Bibliographie en LaTeX avec Biber.
  • Indexation en LaTeX avec xindy.
  • Latexmk pour faciliter la compilation.
  • Des liens hypertextes avec hyperref ?

Ruby

  • Le formatage de chaînes en Ruby.

L’opérateur splat en Ruby

Dans de nombreux codes en Ruby, on peut être amené à croiser l’opérateur * dit opérateur splat. Nous verrons ici combien il est puissant et à quoi il peut servir.

Nous ne parlons pas ici de l’opérateur de multiplication. Bien que les symboles soient les mêmes, ils ne font pas la même chose.

=== Avec les tableaux ===

L’opérateur de splat permet tout d’abord de faire des opérations sur les tableaux.

Déconstruction d’un tableau

Déconstruire un tableau consiste à le « casser » en plusieurs éléments. Cela sert par exemple pour de l’assignation multiple. Lorsqu’on a un tableau de deux éléments, on peut faire ceci.

1
2
tab = [1, 2]
a, b = tab # a vaut 1, b vaut 2.

Essayons pour un tableau à plus d’éléments.

1
2
3
tab = [1, 2, 3, 4, 5]
a, b = tab
print "#{a}, #{b}"

On remarque que a vaut 1 et b vaut 2. On ne récupère pas les trois derniers éléments du tableau. L’opérateur de splat nous permet de faire de l’assignation multiple de plusieurs manières. on peut par exemple récupérer le premier élément d’un tableau, et le reste du tableau.

1
2
3
tab = [1, 2, 3, 4, 5]
premier, *reste = tab
print "#{premier}, #{reste}."

Cette fois a contient le premier élément du tableau, et b contient le reste du tableau.

On peut au contraire récupérer le début du tableau et son dernier élément, en utilisant l’opérateur splat sur la première variable.

1
2
3
tab = [1, 2, 3, 4, 5]
début, dernier = tab
print "#{début}, #{dernier}."

En fait, on peut récupérer les éléments qu’on veut grâce à ça. Par exemple, si on veut récupérer le premier élément et le dernier, on écrira ce code.

1
2
3
tab = [1, 2, 3, 4, 5]
premier, *milieu, dernier = tab
print "#{premier}, #{milieu}, #{dernier}."

Dans le cas où seule le premier et le dernier élément nous intéressent, il est possible d’utiliser simplement * (en écrivant par exemple p, *, d = tab) mais il est préférable de ne pas le faire et d’utiliser un nom qui précise le contexte pour des raisons de lisibilité et de le préfixer par _ pour indiquer qu’on ne l’utilise pas (par exemple, si on enlève la fin d’un tableau, _fin pourrait être un bon nom).

Bien sûr, ces opérations ne sont pas sans limites, puisqu’on pour faire le splat, on doit préciser les éléments par rapport au début et la fin du tableau. Ainsi, il ne sera pas possible de récupérer l’élément au milieu du tableau grâce au splat. Pour ce faire, il nous faudra regarder d’autres méthodes d’extraction (ici en l’occurrence, tab[tab.size / 2] suffira).

Construction de tableaux

On peut déconstruire des tableaux, mais on peut aussi les construire avec l’opérateur de splat. Par exemple, ici, on l’utilise pour concaténer deux tableaux.

1
2
3
4
tab1 = [1, 2, 3]
tab2 = [4, 5, 6]
tab = [*tab1, *tab2]
print tab

Ici, il sert à « aplatir » (flat) un tableau. D’ailleurs, un équivalent à ceci est d’utiliser la méthode flat.

1
tab = [tab1, tab2].flatten

On peut alors construire des tableaux de la manière suivante.

1
print [1, 2, *tab1, 5, 6, *tab2]

Et encore mieux, on peut construire des tableaux à partir d’autres objets. Par exemple, à partir d’un intervalle.

1
2
tab = *1..10
print tab

On peut l’utiliser avec plusieurs types de données.

1
2
3
4
5
tab = *1                     # => tab = [1]
tab = *nil                   # => tab = []
tab = *'mot'                 # => tab = ["mot"]
tab = *[1, 2]                # => tab = [1, 2, 3] 
tab = *{'x' => 2, 'y' => 3}  # => tab = [['x', 2], ['y', 3]]

Cela nous donne plusieurs constructions qui peuvent être utiles.

=== À la rescousse des méthodes ===

Définition de méthode

Appel de méthode

=== Avec les hachages ===


Expressions régulières

Ici, nous allons parler des expressions régulières.

=== Expressions régulières simples ===

Pour commencer, il nous faut voir ce qu’est une expression régulière. En fait, une expression régulière n’est rien d’autre qu’un modèle. Ce modèle décrit un ensemble de chaînes de caractères possible. Ces chaînes correspondent alors au modèle. Par exemple, le mot « chat » correspond au modèle des mots qui commencent par un « c » et se terminent par un « t  », mais ne correspond pas à celui des mots qui commencent par un « c » et comportent un « y ».

Avec les tests unitaires, on peut alors tester si une chaîne de caractère correspond à un modèle, on peut écrire une phrase en suivant un modèle (on parle de formatage de chaîne), etc.

Les expressions basiques

Tester la présence d’un mot dans une chaîne

Le moyen le plus simple d’écrire une expression régulière est de l’écrire entre /. Pour tester si un mot correspond à cette expression, on utilise ensuite le symbole =~. Par exemple, pour vérifier qu’une chaîne contient le mot « chat », on écrira ceci.

1
/chat/ =~ 'Le chat est sur la table.'

Ici, /chat/ est une expression régulière, et on vérifie que cette expression est présente dans la chaîne.

Cette expression ne renvoie pas un booléen comme on pourrait s’y attendre. Elle renvoie l’indice du caractère où la correspondance a été établie. Ici, le c est le quatrième caractère, soit le caractère d’indice 3.

Et si notre chaîne ne correspond pas au modèle, il se passe quoi ?

Essayons, et voyons ce qui se passe.

1
/chat/ =~ 'Le chien est sur la table.'

La chaîne ne comprend pas le mot « chat », l’expression renvoie nil.

Notons que nous pouvons inverser l’écriture. Il est équivalent (à un détail près) d’écrire 'str' =~ /regex/ et /regex/ =~ 'str'. Nous pouvons donc choisir celle qui nous plaît le plus. 

Avec !~, nous faisons l’opération inverse, à savoir que nous vérifions que notre chaîne ne contient pas le modèle testé. Cette fois, c’est un booléen qui est retourné (true si la chaîne ne vérifie pas le modèle, false sinon).

1
2
/chat/ =~ 'Le chien est sur la table.'  # => true
/chat/ =~ 'Le chat est sur la table.'   # => false

Ces exemples ne sont présents que pour introduire les expressions régulières. Si dans un programme, on veut vérifier la présence d’une chaîne dans une autre chaîne, on utilisera plutôt cette syntaxe.

1
2
a = 'Le chat est sur la table.'
a['chat']   # => 'chat'

Les expressions régulières sont à utiliser dans le cas où l’on a un motif (pattern en anglais) plus compliqué à rechercher.

Dans le cas où l’on a une expression régulière simple et qu’on veut obtenir la sous-chaîne qui y correspond dans une chaîne, on peut utiliser la syntaxe chaine[regex]. Elle renvoie nil si la chaîne ne vérifie pas l’expression régulière et renvoie la partie de la chaîne qui la vérifie sinon.

1
2
3
a = 'Le chat est sur la table'
a[/chien/]   # nil
a[/chat/]    # chat 

Les symboles

Maintenant que nous connaissons la syntaxe de base, nous pouvons nous pouvons nous lancer à la découverte de ce qui fait la puissance des expressions régulières.

Les quantificateurs

Jusqu’à maintenant, on testait un nombre exact de caractères. Mais on peut aussi chercher si quelque chose apparaît plusieurs fois dans une chaîne.

Il y a trois symboles qui servent de quantificateur.

  • Le symbole * indique que le caractère qu’il suit doit être présent zéro, une, ou plusieurs fois.
  • Le symbole + indique que le caractère qu’il suit doit être présent au moins une fois.
  • Le symbole ? indique que le caractère qu’il suit doit être présent au plus une fois.

Ainsi, l’expression régulière /chats?/ est valide pour les mots chat et chats.

Ces caractères sont appelés métacaractères. Ce sont des caractères qui ont une signification particulière dans la construction des motifs de recherche. On ne peut donc pas les utiliser tels quel si on veut les rechercher. Pour les rechercher, on les échappe avec un antislash (par exemple, on teste la présence d’un point d’interrogation avec /\?/).

On peut également rechercher un caractère un certain nombre de fois grâce aux intervalles de reconnaissance. Pour cela, on utilise les accolades (qui sont aussi des métacaractères). On peut les utiliser de plusieurs manières.

  • /a{n}/ signifie que a doit être présent n fois.
  • /a{n,}/ signifie que a doit être présent au moins n fois.
  • /a{,n}/ signifie que a doit être présent au plus n fois.
  • /a{n,m}/ signifie que a doit être présent entre n et m fois.

Nous ne pouvons pas utiliser d’espaces dans les intervalles de reconnaissance. "aaa"[/{2, }] renverra nil contrairement à "aaa"[/{2,}/] qui renverra 0.

Avec tout ça, on peut déjà écrire des expression régulières intéressantes. Par exemple, on peut tester l’existence de caractères entre < et > dans une chaîne de caractère avec l’expression /<.*>/. On regarde s’il y a < puis n’importe quels caractères et enfin >.

Les classes de caractères

Les classes de caractères nous permettent de tester plusieurs caractères. On peut regarder si un caractère est dans une liste de caractères en utilisant les crochets. Ainsi, /[oe]/ signifie « un o ou un e ». Pour rechercher « bon » ou « ben », on utilisera l’expression régulière /b[oe]n/.

1
2
'bon'[/b[oe]n/]  # => 'bon'
'ben'[/b[oe]n/]  # => 'ben'

On peut spécifier un intervalle plutôt que de lister toutes les possibilités grâce au symbole -. Ainsi, nous pouvons rechercher un caractère entre a et m ou un chiffre entre 2 et 7 sans écrire toutes ces lettres.

1
2
3
'bon'[/b[a-m]n/]
'187'[/[2-7]/]
'abo34'[/[a-m2-7]/]

Avec la dernière expression, nous recherchons un caractère entre a et m ou entre 2 et 7.

Pour vérifier qu’un caractère est alphabétique, nous pouvons donc utiliser /a-zA-Z/. Mais pour nous faciliter la vie, des classes ont été inventées. Ainsi [[:alpha:]] signifie « n’importe quelle lettre, [[:digit:]] signifie n’importe que chiffre, [[:punct:]] signifie n’importe quel signe de ponctuation, etc. Et Ruby a des métacaractères qui ont le même comportement et nous permettent d’avoir une expression plus courte et efficace.

TABLEAU ICI

Pour indiquer que le symbole peut être n’importe » quel caractère, nous utilisons le symbole . (il est vérifié pour tous les caractères sauf le retour à la ligne). Ainsi, pour vérifier qu’un mot de trois lettres a le o comme lettre du milieu, nous utiliserons /.o./.

1
2
'bon[/.o./]'
'ben'[/.o./]

Pour tester qu’une chaîne contient un mot de quatre lettres précédées d’un blanc et suivie d’une ponctuation, nous pouvons utiliser l’expression régulières suivante.

1
2
expression = /[[:space:]][[:alpha:]]{4}[[:punct:]]/
chaîne[expression]

Avec ce que l’on sait, on peut chercher l’existence d’une balise <hn> dans un texte avec n un chiffre entre 1 et 6 (balises de titres en HTML) avec l’expression régulière /<h[1-6]>/.

Début et fin de chaîne

=== ===


Exceptions


Lecture et écriture dans un fichier



  1. Par contre, vous pouvez le faire chez des amis, des connaissances, dehors, chez de la famille, à l’école, au travail, chez le médecin, chez le boulanger, etc. (rayez les mentions inutiles).