• Aide
  • Eurêkoi Eurêkoi
Kotlin : les fondamentaux du langage
Livre Kotlin : les fondamentaux du langage

par Roland, Ludovic (1989-....)

Éditions ENI

-

  • Disponible - 681.25 ROL

    Niveau 3 - Informatique

Livre

Kotlin : les fondamentaux du langage

Auteur(s) : Roland, Ludovic (1989-....) Découvrir l'auteur

Résumé

Une présentation de ce langage de programmation, ses variables, ses conditions, ses tableaux ou ses fonctions. Avec un focus sur les notions avancées contenues dans le langage Kotlin, telles que les séquences, les fonctions de portées et les collections, de nombreux exemples ainsi qu'une mise en application.

  • Éditeur(s)
  • Date
    • C 2021
  • Notes
    • La couv. porte en plus : "En téléchargement : code source " ; "+ Quiz" ; "Version en ligne offerte ! pendant 1 an"
    • La 4e de couv. indique : "Sur www.editions-eni.fr : le code source du programme développé en exemple"
    • Contient un "flashcode" permettant d'accéder à un contenu via Internet
  • Langues
    • Français
  • Description matérielle
    • 1 vol. (550 p.) : ill. ; 22 cm
  • Collections
  • Sujet(s)
  • ISBN
    • 978-2-409-02915-8
  • Indice
  • Quatrième de couverture

    • Kotlin

      Les fondamentaux du langage

      Ce livre s'adresse à toute personne désireuse d'apprendre à programmer avec le langage Kotlin (en version 1.4 au moment de l'écriture). Que le lecteur soit débutant ou qu'il ait déjà de l'expérience avec un ou plusieurs langages de programmation, il trouvera dans ce livre, articulé en cinq grandes parties, toutes les connaissances nécessaires à la prise en main de Kotlin, largement illustrées par de nombreux exemples, pour une utilisation dans un contexte JVM (Java Virtual Machine).

      La première partie permet au lecteur de préparer son environnement de travail et d'appréhender les bases de la programmation en Kotlin grâce aux variables, conditions, boucles, tableaux et fonctions. La deuxième partie détaille toutes les possibilités du langage Kotlin autour du concept de programmation orientée objet permettant ainsi au lecteur d'étudier les notions de classes, d'héritage, d'interfaces, d'énumérations, de généricité...

      Une troisième partie donne la possibilité de progresser dans son apprentissage de la programmation avec Kotlin en se familiarisant avec des notions avancées contenues directement dans le langage (conversion de type, réification de type, fonctions de portée...), avant de poursuivre avec une partie dédiée aux collections.

      La dernière partie de ce livre implique le lecteur dans la manipulation de bibliothèques tierces utiles pour la gestion de la programmation asynchrone, de channels, de flows, de requêtes web ou encore de sérialisation JSON.

      L'auteur conclut avec un chapitre dans lequel il propose une mise en application des différentes notions étudiées avec le développement, étape par étape, d'un programme Kotlin destiné à la JVM.


  • Tables des matières

      • Kotlin

      • Les fondamentaux du langage

      • Avant-propos
      • Partie 1 : Les bases de la programmation en Kotlin
      • Chapitre 1-1
      • Bien commencer en Kotlin
      • 1. Installer IntelliJ IDEA21
      • 2. Créer un premier programme avec IntelliJ IDEA22
      • 2.1 La barre d'outils25
      • 2.2 L'onglet Project26
      • 2.3 Le terminal26
      • 3. Créer des fichiers Kotlin27
      • 4. Hello World !27
      • 5. En résumé30
      • Chapitre 1-2
      • Manipuler les variables
      • 1. Qu'est-ce qu'une variable ?31
      • 2. Déclarer une variable31
      • 3. Nommer une variable32
      • 4. Les types de variables33
      • 4.1 Les nombres entiers33
      • 4.2 Les nombres flottants34
      • 4.3 Les caractères34
      • 4.4 Les booléens34
      • 4.5 Les chaînes de caractères35
      • 5. Déclarer une variable (suite)35
      • 6. Affecter une valeur à une variable36
      • 7. Les variables de type « lecture seule »37
      • 8. Les constantes37
      • 9. Formater des nombres38
      • 10. L'inférence de type38
      • 11. Afficher le contenu d'une variable39
      • 12. Place aux calculs !40
      • 12.1 Les calculs de base40
      • 12.1.1 L'addition40
      • 12.1.2 La soustraction41
      • 12.1.3 La multiplication41
      • 12.1.4 La division41
      • 12.1.5 Le modulo42
      • 12.1.6 Des calculs et des variables42
      • 12.2 Écrire moins de code43
      • 12.2.1 Incrémenter une variable43
      • 12.2.2 Décrémenter une variable44
      • 12.2.3 D'autres raccourcis44
      • 12.3 Des calculs plus complexes45
      • 12.3.1 Quelques exemples de fonctions mathématiques45
      • 12.3.2 D'autres fonctions47
      • 13. En résumé47
      • Chapitre 1-3
      • Les structures de contrôle
      • 1. Qu'est-ce qu'une condition ?49
      • 1.1 if... else49
      • 1.1.1 Les symboles de comparaison49
      • 1.1.2 if50
      • 1.1.3 else51
      • 1.1.4 else if51
      • 1.1.5 D'autres symboles ?52
      • 1.2 when55
      • 1.3 Stocker la valeur de retour d'une condition58
      • 2. Qu'est-ce qu'une boucle ?60
      • 2.1 La boucle while60
      • 2.2 La boucle do... while65
      • 2.3 La boucle for67
      • 3. En résumé71
      • Chapitre 1-4
      • Les fonctions
      • 1. Qu'est-ce qu'une fonction ?73
      • 2. Définir une fonction74
      • 3. Appeler une fonction76
      • 4. Affecter des valeurs par défaut77
      • 5. La surcharge de fonction79
      • 6. Aller plus loin80
      • 6.1 Les paramètres sont en lecture seule80
      • 6.2 Une écriture raccourcie81
      • 7. En résumé82
      • 1. Les tableaux à une dimension83
      • 1.1 L'intérêt des tableaux83
      • 1.2 Déclarer un tableau84
      • 1.2.1 Déclarer un tableau « vide »84
      • 1.2.2 Déclarer un tableau « prérempli »85
      • 1.3 Accéder aux éléments d'un tableau85
      • 1.4 Parcourir un tableau87
      • 1.5 Les tableaux et les fonctions88
      • 1.6 Les tableaux de primitives89
      • 2. Les tableaux multidimensionnels91
      • 2.1 Déclarer un tableau multidimensionnel91
      • 2.1.1 Déclarer un tableau « vide »91
      • 2.1.2 Déclarer un tableau « prérempli »92
      • 2.2 Accéder aux éléments d'un tableau multidimensionnel92
      • 2.3 Parcourir un tableau multidimensionnel93
      • 2.4 Les tableaux multidimensionnels et les fonctions94
      • 2.5 Les tableaux multidimensionnels de primitives95
      • 3. En résumé97
      • Partie 2 : La programmation orientée objet en Kotlin
      • Chapitre 2-1
      • Introduction à la programmation orientée objet
      • 1. Qu'est-ce qu'un objet ? :99
      • 2. Qu'est-ce que la programmation orientée objet ?100
      • 3. En résumé100
      • Chapitre 2-2
      • Les classes
      • 1. Créer une classe101
      • 1.1 Un peu de vocabulaire101
      • 1.2 La classe Dog102
      • 2. Ajouter des attributs et des méthodes103
      • 2.1 Les attributs103
      • 2.2 Les méthodes105
      • 3. Utiliser des objets107
      • 4. Afficher un objet108
      • 5. Les droits d'accès110
      • 5.1 Les méthodes110
      • 5.2 Les attributs113
      • 6. Les mutateurs et les accesseurs115
      • 7. Les constructeurs118
      • 7.1 Créer un constructeur119
      • 7.2 Les constructeurs secondaires124
      • 8. En résumé127
      • Chapitre 2-3
      • L'héritage
      • 1. Introduction129
      • 2. Qu'est-ce que l'héritage ?129
      • 3. Mettre en place l'héritage131
      • 3.1 La classe Animal131
      • 3.2 La classe Cat132
      • 3.3 La classe Dog134
      • 3.4 Manipuler les classes134
      • 4. Un nouveau droit d'accès136
      • 5. La covariance138
      • 6. Vérifier le type d'un objet139
      • 7. Le polymorphisme141
      • 8. Les classes abstraites144
      • 8.1 Qu'est-ce qu'une classe abstraite ?144
      • 8.2 Écrire une classe abstraite145
      • 8.3 Les méthodes abstraites146
      • 8.4 La covariance147
      • 8.5 Créer une classe anonyme148
      • 9. En résumé149
      • Chapitre 2-4
      • Des classes dans des classes
      • 1. Les classes internes151
      • 2. Les classes imbriquées153
      • 3. Les classes scellées155
      • 3.1 Qu'est-ce qu'une classe scellée ?155
      • 3.2 Écrire une classe scellée155
      • 3.3 Les méthodes abstraites157
      • 3.4 La covariance159
      • 4. En résumé160
      • Chapitre 2-5
      • Des classes particulières
      • 1. Les énumérations161
      • 1.1 Qu'est-ce qu'une énumération ?161
      • 1.2 Écrire une énumération162
      • 1.3 Lister les valeurs d'une énumération164
      • 1.4 Retrouver la valeur d'une énumération165
      • 1.5 Ajouter des attributs à une énumération166
      • 1.6 Ajouter des méthodes à une énumération167
      • 1.7 Aller plus loin170
      • 2. Les classes de données171
      • 2.1 Qu'est-ce qu'une classe de données ?171
      • 2.2 Écrire une classe de données172
      • 2.3 Les limitations des classes de données173
      • 2.4 Les méthodes générées automatiquement dans les classes de données174
      • 2.4.1 La méthode equals175
      • 2.4.2 La méthode hashCode177
      • 2.4.3 La méthode copy178
      • 3. Les objets Singleton180
      • 3.1 Qu'est-ce qu'un patron de conception ?180
      • 3.2 Le patron de conception Singleton181
      • 3.3 Écrire une classe qui implémente le patron de conception Singleton182
      • 4. En résumé187
      • Chapitre 2-6
      • Les interfaces
      • 1. Qu'est-ce qu'une interface ?189
      • 2. Écrire une interface192
      • 3. Implémenter une interface194
      • 4. Ajouter des attributs et des implémentations par défaut dans les interfaces196
      • 4.1 Les méthodes non abstraites196
      • 4.2 Les attributs abstraits197
      • 5. La covariance199
      • 6. Créer une classe anonyme199
      • 7. En résumé200
      • Chapitre 2-7
      • La généricité
      • 1. Des chiens et des chats201
      • 2. Écrire une classe générique206
      • 3. Utiliser une classe générique207
      • 4. Ajouter une contrainte sur le type de paramètre208
      • 5. Ajouter plusieurs contraintes sur le type de paramètre209
      • 6. Les classes génériques covariantes211
      • 7. Les classes génériques contravariantes212
      • 8. En résumé213
      • Chapitre 2-8
      • Aller plus loin avec les classes
      • 1. Les éléments statiques215
      • 1.1 Les méthodes statiques215
      • 1.1.1 Qu'est-ce qu'une méthode statique ?215
      • 1.1.2 Écrire une méthode statique215
      • 1.1.3 Utiliser une méthode statique217
      • 1.2 Les attributs statiques218
      • 1.2.1 Qu'est-ce qu'un attribut statique ?218
      • 1.2.2 Écrire un attribut statique218
      • 1.2.3 Utiliser un attribut statique220
      • 2. Les extensions220
      • 2.1 Les limites de l'héritage221
      • 2.2 Les méthodes d'extension222
      • 2.3 Les attributs d'extension224
      • 3. Les alias225
      • 3.1 Qu'est-ce qu'un alias ?225
      • 3.2 Créer un alias226
      • 4. En résumé227
      • Partie 3 : Notions avancées du langage Kotlin
      • Chapitre 3-1
      • Le type Nullable
      • 1. Qu'est-ce que le type nullable ?229
      • 2. Indiquer des éléments nullables231
      • 3. Composer avec les éléments nullables233
      • 3.1 L'opérateur ! !234
      • 3.2 L'opérateur ?235
      • 3.3 L'opérateur Elvis237
      • 4. En résumé239
      • Chapitre 3-2
      • Initialiser les attributs autrement
      • 1. Initialiser les attributs plus tard241
      • 2. Initialisation paresseuse des attributs243
      • 3. En résumé245
      • Chapitre 3-3
      • Des fonctions particulières
      • 1. Les expressions lambda et les fonctions d'ordre supérieur247
      • 1.1 Qu'est-ce qu'une expression lambda ?247
      • 1.2 Écrire une expression lambda247
      • 1.3 Utiliser une expression lambda249
      • 1.4 Qu'est-ce qu'une fonction d'ordre supérieur ?251
      • 1.4.1 Écrire une fonction d'ordre supérieur251
      • 1.4.2 Utiliser une fonction d'ordre supérieur252
      • 1.4.3 Optimiser une fonction d'ordre supérieur254
      • 2. Les fonctions de portée256
      • 2.1 Qu'est-ce qu'une fonction de portée ?256
      • 2.2 Manipuler un objet dans une fonction de portée256
      • 2.3 Retourner un résultat dans une fonction de portée257
      • 2.4 La fonction let257
      • 2.5 La fonction with262
      • 2.6 La fonction run265
      • 2.7 La fonction apply267
      • 2.8 La fonction also268
      • 3. En résumé :270
      • Chapitre 3-4
      • Les interfaces fonctionnelles
      • 1. La problématique des instanciations anonymes des interfaces271
      • 2. Écrire une interface fonctionnelle273
      • 3. En résumé276
      • Chapitre 3-5
      • Les exceptions
      • 1. Qu'est-ce qu'une exception ?277
      • 1.1 Analyser une stacktrace277
      • 1.2 Des exceptions et des classes279
      • 2. Capturer une ou plusieurs exceptions280
      • 2.1 Capturer une exception280
      • 2.2 Capturer plusieurs exceptions282
      • 2.3 Exécuter du code systématiquement284
      • 3. Lever des exceptions286
      • 3.1 Quand lever une exception ?286
      • 3.2 Utiliser le mot-clé throw286
      • 3.3 Utiliser l'opérateur Elvis288
      • 3.4 Utiliser la fonction require290
      • 3.5 Utiliser la fonction check291
      • 4. Créer des exceptions personnalisées292
      • 5. En résumé295
      • Chapitre 3-6
      • Les conversions de type
      • 1. Qu'est-ce que la conversion de type ?297
      • 2. Mettre en place la conversion de type298
      • 3. La conversion de type intelligente301
      • 4. En résumé302
      • Partie 4 : Kotlin et les collections
      • Chapitre 4-1
      • Les collections
      • 1. Introduction303
      • 2. List et MutableList304
      • 2.1 Qu'est-ce qu'une liste ?304
      • 2.2 Les listes en lecture seule304
      • 2.2.1 Déclarer une liste en lecture seule304
      • 2.2.2 Parcourir une liste305
      • 2.2.3 Retrouver l'indice d'un élément306
      • 2.2.4 Récupérer un sous-ensemble d'une liste308
      • 2.2.5 Récupérer une valeur à partir de son indice309
      • 2.2.6 Les listes et les fonctions310
      • 2.2.7 Une liste vide311
      • 2.3 Les listes en lecture et en écriture311
      • 2.3.1 Déclarer une liste en lecture et en écriture312
      • 2.3.2 Ajouter un ou plusieurs éléments312
      • 2.3.3 Mettre à jour les éléments d'une liste314
      • 2.3.4 Retirer un élément314
      • 2.3.5 Les listes et les fonctions316
      • 2.4 Passer du type List à MutableList317
      • 2.5 Les listes et la covariance de type317
      • 3. Set et MutableSet320
      • 3.1 Qu'est-ce qu'un « set » ?320
      • 3.2 Les sets en lecture seule321
      • 3.2.1 Déclarer un set en lecture seule321
      • 3.2.2 Parcourir un set322
      • 3.2.3 D'autres opérations322
      • 3.2.4 Les sets et les fonctions323
      • 3.2.5 Un set vide323
      • 3.3 Les sets en lecture et en écriture324
      • 3.3.1 Déclarer un set en lecture et en écriture324
      • 3.3.2 Ajouter un ou plusieurs éléments324
      • 3.3.3 Retirer un élément325
      • 3.3.4 Les sets et les fonctions327
      • 3.4 Passer du type Set à MutableSet328
      • 3.5 Les sets et la covariance de type328
      • 4. Map et MutableMap331
      • 4.1 Qu'est-ce qu'une map ?331
      • 4.2 Les maps en lecture seule332
      • 4.2.1 Déclarer une map en lecture seule332
      • 4.2.2 Parcourir une map333
      • 4.2.3 Récupérer l'ensemble des clés d'une map334
      • 4.2.4 Récupérer l'ensemble des valeurs d'une map335
      • 4.2.5 Récupérer une valeur d'une map à partir d'une clé335
      • 4.2.6 Les maps et les fonctions337
      • 4.2.7 Une map vide338
      • 4.3 Les maps en lecture et en écriture338
      • 4.3.1 Déclarer une map en lecture et en écriture338
      • 4.3.2 Ajouter un ou plusieurs éléments339
      • 4.3.3 Mettre à jour les éléments d'une map340
      • 4.3.4 Retirer un élément340
      • 4.3.5 Les maps et les fonctions342
      • 4.4 Passer du type Map à MutableMap343
      • 4.5 Les maps et la covariance de type344
      • 5. Les opérations sur les collections347
      • 5.1 Transformer une collection347
      • 5.1.1 Le mapping347
      • 5.1.2 Le zipping349
      • 5.2 Filtrer une collection351
      • 5.2.1 Le filtrage351
      • 5.2.2 La partition352
      • 5.3 Regrouper les éléments d'une collection354
      • 5.4 Les opérations de sélection355
      • 5.4.1 Sélectionner plusieurs éléments355
      • 5.4.2 Sélectionner un seul élément357
      • 5.5 Les opérations de tri359
      • 5.5.1 Les opérations de tri non personnalisables359
      • 5.5.2 Les opérations de tri personnalisables362
      • 5.6 Les opérations d'agrégation364
      • 5.6.1 Les valeurs minimales et maximale364
      • 5.6.2 La valeur moyenne365
      • 5.6.3 La somme des valeurs366
      • 5.6.4 Compter le nombre de valeurs367
      • 6. En résumé368
      • Chapitre 4-2
      • Les séquences
      • 1. Qu'est-ce qu'une séquence ?369
      • 2. Pourquoi utiliser les séquences ?370
      • 3. En résumé373
      • Partie 5 : Travailler avec des bibliothèques tierces
      • Chapitre 5-1
      • La programmation asynchrone avec les coroutines
      • 1. Qu'est-ce qu'une bibliothèque tierce ?375
      • 2. Quand utiliser la programmation asynchrone ?376
      • 3. Ajouter les coroutines dans un projet378
      • 4. Créer des coroutines379
      • 4.1 Le constructeur runBlocking379
      • 4.2 Le constructeur launch382
      • 4.3 Le constructeur async384
      • 4.4 Les fonctions suspendues387
      • 5. Annuler et synchroniser des coroutines388
      • 5.1 Connaître l'état d'une coroutine389
      • 5.2 Attendre la fin d'une coroutine390
      • 5.3 Annuler une coroutine392
      • 6. Des coroutines dans des coroutines393
      • 7. La gestion des erreurs dans une coroutine398
      • 7.1 La gestion locale398
      • 7.2 La gestion centralisée400
      • 8. Ajouter des paramètres aux constructeurs403
      • 8.1 Le contexte403
      • 8.1.1 Ajouter un objet de type Job403
      • 8.1.2 Ajouter un objet de type Dispatchers407
      • 8.1.3 Ajouter un objet de type CoroutineExceptionHandler au contexte409
      • 8.1.4 Ajouter des objets de type Job, Dispatchers et CoroutineExceptionHandler409
      • 8.2 Les options de démarrage411
      • 9. Changer de contexte415
      • 10. L'échange de données entre coroutines418
      • 10.1 Les channels418
      • 10.1.1 Qu'est-ce qu'un channel ?418
      • 10.1.2 Différents types de channels424
      • 10.1.3 Les inconvénients des channels437
      • 10.2 Les flows437
      • 10.2.1 Qu'est-ce que l'interface Flow ?437
      • 10.2.2 Utiliser l'interface Flow438
      • 10.2.3 Filtrer, transformer, etc. les données collectées443
      • 10.2.4 Aller plus loin445
      • 11. En résumé445
      • Chapitre 5-2
      • L'introspection et la réification de type
      • 1. Qu'est-ce que l'introspection ?447
      • 2. Utiliser l'introspection dans les projets447
      • 3. Découvrir une classe par introspection448
      • 3.1 Connaître la classe mère et les interfaces implémentées par une classe450
      • 3.2 Connaître les constructeurs d'une classe453
      • 3.3 Connaître les méthodes d'une classe455
      • 3.4 Connaître les attributs d'une classe456
      • 4. Instancier dynamiquement des objets457
      • 5. Aller plus loin462
      • 6. La réification de type464
      • 6.1 La problématique464
      • 6.2 Qu'est-ce que la réification de type ?467
      • 7. En résumé468
      • Chapitre 5-3
      • La sérialisation et la désérialisation
      • 1. Utiliser kotlinx-serialization dans les projets469
      • 2. Qu'est-ce que la sérialisation ?470
      • 3. Des solutions alternatives472
      • 4. La sérialisation JSON avec kotlinx-serialization473
      • 4.1 Qu'est-ce que JSON ?473
      • 4.2 La sérialisation JSON474
      • 4.2.1 Un exemple simple474
      • 4.2.2 Aller plus loin477
      • 4.3 La désérialisation JSON479
      • 4.3.1 Un exemple simple479
      • 4.3.2 Aller plus loin481
      • 5. En résumé482
      • Chapitre 5-4
      • Les requêtes réseau avec ktor
      • 1. Utiliser ktor dans les projets483
      • 2. Qu'est-ce qu'une requête réseau ?484
      • 3. Des solutions alternatives485
      • 4. Faire une requête réseau486
      • 4.1 Présentation de l'API486
      • 4.2 Implémentation technique487
      • 5. En résumé490
      • Chapitre 6
      • Aller plus loin
      • 1. Créer des annotations491
      • 2. Surcharger les opérateurs d'une classe491
      • 3. L'interopérabilité avec Java492
      • 4. Écrire et lire dans des fichiers492
      • 5. T ester un programme493
      • 6. Déboguer un programme493
      • Chapitre 7
      • Création d'un projet complet
      • 1. Description du projet495
      • 2. Créer le projet496
      • 2.1 Ajouter un package497
      • 2.2 Créer les objets métier499
      • 2.3 Créer le service503
      • 2.3.1 La méthode addFilm506
      • 2.3.2 La méthode addPerson507
      • 2.3.3 La méthode getFilmByld507
      • 2.3.4 La méthode getPersonByld507
      • 2.3.5 La méthode getFilmByName507
      • 2.3.6 La méthode getFilmByActorld508
      • 2.3.7 La méthode getFilmByDirectorld508
      • 2.3.8 La méthode getFilmByGenre508
      • 2.4 Écrire et lire dans un fichier508
      • 2.4.1 Implémenter la sérialisation JSON509
      • 2.4.2 La méthode saveDatabase511
      • 2.4.3 La méthode loadDatabase512
      • 2.5 Créer le programme principal513
      • 2.5.1 Créer le menu513
      • 2.5.2 Charger la base de données516
      • 2.5.3 Sauvegarder la base de données517
      • 2.5.4 Ajouter une personne517
      • 2.5.5 Ajouter un film519
      • 2.5.6 Rechercher un film par son nom522
      • 2.5.7 Rechercher les films d'un acteur525
      • 2.5.8 Rechercher les films d'un réalisateur526
      • 2.5.9 Rechercher les films d'un genre particulier528
      • Index531

  • Origine de la notice:
    • BPI

  • Disponible - 681.25 ROL

    Niveau 3 - Informatique

Sur le même thème

Apprendre à programmer avec OCaml : algorithmes et structures de données

Apprendre à programmer
avec OCaml : […]

Conchon, Sylvain,
Filliâtre, […]

Modélisation prédictive et apprentissage statistique avec R

Modélisation
prédictive et […]

Tufféry, Stéphane
(1965-....)

Programmer en Fortran : Fortran 90 et ses évolutions : Fortran 95, 2003 et 2008

Programmer en Fortran :
Fortran 90 et ses […]

Delannoy, Claude
(1946-....)

Programmation et analyse statistique avec R

Programmation et analyse
statistique avec R

Paroissin, Christian
(1976-....)

Programmer en Go : Pourquoi ? Comment ?

Programmer en Go :
Pourquoi ? Comment ?

Rigot, Rudy

R pour les data sciences : importer, classer, transformer, visualiser et modéliser les données

R pour les data sciences
: importer, […]

Wickham, Harvey,
Gromelund, Garrett

La programmation fonctionnelle : introduction et applications en Haskell à l'usage de l'étudiant et du développeur

La programmation
fonctionnelle : […]

Dehos, Julien

Statistiques pour les sciences environnementales

Statistiques pour les
sciences […]

David, Valérie
(1977-...)

Les forêts aléatoires avec R

Les forêts aléatoires
avec R

Genuer, Robin
(1983-....), Poggi,[…]

Learning scala programming : objet-oriented programming meets functional reactive to create scalable and concurrent programs

Learning scala
programming : […]

Sharma, Vikash
(19..-....)

Scratch 3 : s'initier à la programmation et à la robotique par le jeu

Scratch 3 : s'initier à
la programmation et[…]

Lacaze, Sarah

LaTeX : apprentissage, guide et référence

LaTeX : apprentissage,
guide et référence

Desgraupes, Bernard
(1954-....)

Concevez des applications mobiles avec React Native : développement, publication sur les stores et stratégie marketing

Concevez des
applications […]

Barré, Blaise

Langage R : prendre en main les statistiques, accéder à tous types de données

Langage R : prendre en
main les […]

Kolani, Daname,
Deschamps, Aline, […]

Initiation à la programmation et aux algorithmes : Scheme

Initiation à la
programmation et […]

Bloch, Laurent
(1947-....)

LaTeX pour les enseignants

LaTeX pour les
enseignants

Poulain, Nicolas

Flutter : développez vos applications mobiles multiplateformes avec Dart

Flutter : développez
vos applications […]

Trillard, Julien

Kotlin : guide pratique

Kotlin : guide pratique

Kousen, Kenneth A.

Introduction à Latex

Introduction à Latex

Gautrelet, Erwan

Le langage Go : les fondamentaux du langage

Le langage Go : les
fondamentaux du langage

Marand, Frédéric G.

Voir tout les résultats (43)