method_format.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La méthode format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 00) Bases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = \"one\"\n",
    "var2 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var1 = one et var2 = 2\n",
      "var1 = one et var2 = 2\n",
      "var2 = 2, var1 = one et var2 toujours = 2\n",
      "var1 = one et var2 = 2\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('var1 = %s et var2 = %s'  % (var1, var2))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('var1 = {} et var2 = {}'.format(var1, var2))\n",
    "print('var2 = {1}, var1 = {0} et var2 toujours = {1}'.format(var1, var2))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'var1 = {var1} et var2 = {var2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01) Conversions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Data(object):\n",
    "    def __str__(self):\n",
    "        return 'str'\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'räpr'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str räpr r\\xe4pr\n",
      "str räpr r\\xe4pr\n",
      "str räpr r\\xe4pr\n"
     ]
    }
   ],
   "source": [
    "# s : string // r : repr // a : ascii\n",
    "\n",
    "# Ancienne syntaxe :\n",
    "print('%s %r %a' % (Data(), Data(), Data()))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{0!s} {0!r} {0!a}'.format(Data()))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{Data()!s} {Data()!r} {Data()!a}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02) Aligner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      test\n",
      "test      \n",
      "      test\n",
      "test      \n",
      "      test\n",
      "test      \n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%10s' % ('test'))\n",
    "print('%-10s' % ('test'))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:>10}'.format('test'))\n",
    "print('{:10}'.format('test'))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{\"test\":>10}')\n",
    "print(f'{\"test\":10}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03) Remplir et centrer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 'test'\n",
    "var2 = 'zip'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Impossible avec l'ancienne syntaxe.\n",
    "\n",
    "Quand on centre avec une valeur impair, l'espace supplémentaire se place sur la droite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "testxxxxxx\n",
      "   test   \n",
      "   zip    \n",
      "test______\n",
      "   test   \n",
      "   zip    \n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:_<10}'.format('test'))\n",
    "print('{:^10}'.format('test'))\n",
    "print('{:^10}'.format('zip'))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{var1:_<10}')\n",
    "print(f'{var1:^10}')\n",
    "print(f'{var2:^10}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 04) Tronquer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 'xylophone'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xylop\n",
      "xylop\n",
      "xylop\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%.5s' % ('xylophone',))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:.5}'.format('xylophone'))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{var1:.5}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 05) Tronquer + remplir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     xylop\n",
      "xylop     \n",
      "     xylop\n",
      "xylop     \n",
      "     xylop\n",
      "xylop     \n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%10.5s' % ('xylophone'))\n",
    "print('%-10.5s' % ('xylophone'))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:>10.5}'.format('xylophone'))\n",
    "print('{:10.5}'.format('xylophone'))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{var1:>10.5}')\n",
    "print(f'{var1:10.5}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les Nombres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 00) Conversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "42\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "# Integers\n",
    "\n",
    "# Ancienne syntaxe :\n",
    "print('%d' % (42))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:d}'.format(42))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{42:d}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42.000000\n",
      "42.000000\n",
      "42.000000\n"
     ]
    }
   ],
   "source": [
    "# Float\n",
    "\n",
    "# Ancienne syntaxe :\n",
    "print('%f' % (42))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:f}'.format(42))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{42:f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01) Alignement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  42\n",
      "  3.14\n",
      "  42\n",
      "  3.14\n",
      "  42\n",
      "  3.14\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%4d' % (42))\n",
    "print('%6.2f' % (3.141592653589793))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:4d}'.format(42))\n",
    "print('{:6.2f}'.format(3.141592653589793))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{42:4d}')\n",
    "print(f'{3.141592653589793:6.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02) Remplissage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0042\n",
      "003.14\n",
      "0042\n",
      "003.14\n",
      "0042\n",
      "003.14\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%04d' % (42))\n",
    "print('%06.2f' % (3.141592653589793))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:04d}'.format(42))\n",
    "print('{:06.2f}'.format(3.141592653589793))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{42:04d}')\n",
    "print(f'{3.141592653589793:06.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03) Nombres signés"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Par défaut, seuls les nombres négatifs sont préfixé.\n",
    "On peut :\n",
    "- afficher les + et les -\n",
    "- afficher les moins et mettre un espace à la place du +"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+42\n",
      "-23\n",
      " 42\n",
      "+42\n",
      "-23\n",
      " 42\n",
      "+42\n",
      "-23\n",
      " 42\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%+d' % (42))\n",
    "print('% d' % (- 23))\n",
    "print('% d' % (42))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:+d}'.format(42))\n",
    "print('{: d}'.format(- 23))\n",
    "print('{: d}'.format(42))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{42:+d}')\n",
    "print(f'{-23: d}')\n",
    "print(f'{42: d}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut maintenant également contrôlé la position du symbole par rapport au nombre en remplissant entre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-       42\n",
      "+       42\n",
      "-       42\n",
      "+       42\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:=10d}'.format((- 42)))\n",
    "print('{:=+10d}'.format(42))\n",
    "\n",
    "# Python 3.6+\n",
    "print(f'{-42:=10d}')\n",
    "print(f'{42:=+10d}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Autres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 00) Named placeholders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {'first': 'Alan', 'last': 'Turing !'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alan Turing !\n",
      "Alan Turing !\n",
      "Alan Turing !\n",
      "Alan Turing !\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%(first)s %(last)s' % data)\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{first} {last}'.format(**data))\n",
    "print('{first} {last}'.format(first='Alan', last='Turing !'))\n",
    "\n",
    "# Python 3.6+ :\n",
    "print(f\"{data['first']} {data['last']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01) Getitem et Getattr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {'first': 'Alan', 'last': 'Turing'}\n",
    "data = [4, 8, 15, 16, 23, 42]\n",
    "class Plant(object):\n",
    "    type = 'tree'\n",
    "    kinds = [{'name': 'oak'}, {'name': 'maple'}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alan Turing\n",
      "23 42\n",
      "tree\n",
      "tree: oak\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{p[first]} {p[last]}'.format(p=person))\n",
    "print('{d[4]} {d[5]}'.format(d=data))\n",
    "\n",
    "print('{p.type}'.format(p=Plant()))\n",
    "print('{p.type}: {p.kinds[0][name]}'.format(p=Plant()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02) Datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2001-02-03 04:05\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:%Y-%m-%d %H:%M}'.format(datetime(2001, 2, 3, 4, 5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "%a : 3 premiers caractères de la semaine. Ex. : \"Wed\"\n",
    "\n",
    "%A : Nom complet de la semaine. Ex. : \"Wedesday\"\n",
    "\n",
    "%B : Nom complet du mois. Ex. : \"September\"\n",
    "\n",
    "%w : Le jour de la semaine sous forme de nombre, de 0 à 6. (Dimanche = 0)\n",
    "\n",
    "%m : Le mois sous forme de nombre, de 01 à 12.\n",
    "\n",
    "%p : AM/PM pour l'heure.\n",
    "\n",
    "%y : L'année au formt de deux chiffres. Ex. : \"20\"\n",
    "\n",
    "%f : Microsecondes de 000000 à 999999.\n",
    "\n",
    "%Z : La timezone.\n",
    "\n",
    "%z : Le décallage horaire UTC.\n",
    "\n",
    "%j : Le numéro du jour, de 001 à 366.\n",
    "\n",
    "%W : Le numéro de la semaine, de 00 à 53, avec Lundi comme premier jour de la semaine.\n",
    "\n",
    "%U : Le numéro de la semaine, de 00 à 53, avec Dimanche comme premier jour de la semaine.\n",
    "\n",
    "%c : Version locale de la date et l'heure.\n",
    "\n",
    "%x : Version locale de la date.\n",
    "\n",
    "%X : Version locale de l'heure.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03) Formats paramétrisés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gib = 2.718\n",
      " 2.72\n",
      "Gib = 2.718\n",
      " 2.72\n"
     ]
    }
   ],
   "source": [
    "# Ancienne syntaxe :\n",
    "print('%.*s = %.*f' % (3, 'Gibberish', 3, 2.7182))\n",
    "print('%*.*f' % (5, 2, 2.7182))\n",
    "\n",
    "# Python 3.+ :\n",
    "print('{:.{prec}} = {:.{prec}f}'.format('Gibberish', 2.7182, prec=3))\n",
    "print('{:{width}.{prec}f}'.format(2.7182, width=5, prec=2))\n",
    "\n",
    "# Python 3.6+ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   test   \n",
      "Gib = 2.72\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:{align}{width}}'.format('test', align='^', width='10'))\n",
    "print('{:{prec}} = {:{prec}}'.format('Gibberish', 2.7182, prec='.3'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "dt = datetime(2001, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2001-02-03 04:05\n",
      "     +2.72\n",
      "     +2.72\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:{dfmt} {tfmt}}'.format(dt, dfmt='%Y-%m-%d', tfmt='%H:%M'))\n",
    "print('{:{}{}{}.{}}'.format(2.7182818284, '>', '+', 10, 3))\n",
    "print('{:{}{sign}{}.{}}'.format(2.7182818284, '>', 10, 3, sign='+'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 04) Objets personnalisés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Warcraft(object):\n",
    "\n",
    "    def __format__(self, format):\n",
    "        if (format == 'click_paysan'):\n",
    "            return \"Encore du travail ?\"\n",
    "        return 'Warcraft'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encore du travail ?\n"
     ]
    }
   ],
   "source": [
    "# Python 3.+ :\n",
    "print('{:click_paysan}'.format(Warcraft()))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}