Python les bases du langage
Download
1 / 47

Python - Les bases du langage - PowerPoint PPT Presentation


  • 107 Views
  • Uploaded on

Python - Les bases du langage. Réunion COMICS 18 novembre 2011. Plan. Présentation de Python Les types et les opérations de base Les structures de contrôle Les fonctions Les fichiers Les classes Les exceptions Les modules Ressources. Présentation de Python.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Python - Les bases du langage' - lori


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Python les bases du langage
Python - Les bases du langage

Réunion COMICS

18 novembre 2011


Python les bases du langage
Plan

Présentation de Python

Les types et les opérations de base

Les structures de contrôle

Les fonctions

Les fichiers

Les classes

Les exceptions

Les modules

Ressources


Pr sentation de python
Présentation de Python

Développé en 1989 par Guido van Rossum

Open source

Portable (Windows, linux Mac OS)

Orienté objet

Dynamique

Extensible

Support pour l'intégration d'autre langage


Pr sentation de python1

Il existe 2 technique pour effectuer la traduction en langage machine mon code source:

Interprétation: inconvénient lent!!!

Compilation: Rapide, inconvénient compilation

Présentation de Python Présentation de Python


Pr sentation de python2
Présentation de Python langage machine mon code source:

Et Python ???

Avantages:

Interpréteur permettant de tester n'importe quel petit bout de code

Compilation transparente

Inconvénients:

Peut être lent


Pr sentation de python3
Présentation de Python langage machine mon code source:

Les versions de Python

Il existe 2 version de Python: 2.7 et 3.1

La version 3.x n'est pas une simple amélioration ou extension de 2.7

Portage pas totalement fini de 3.1

L'Interpréteur

2 choix entre python ou Ipython

Quelques options

-c: execute la commande python entrée après

-i passe en mode intéractif apres avoir exécuté un script ou une commande

-d: passe en mode debug


Pr sentation de python4
Présentation de Python langage machine mon code source:

Que peut-on faire avec Python?

Web

Django,Zope,Plone,...

Bases de données

MySQL,PostgrSQL,Oracle,...

Gui

Gtk+,Qt, Tcl/Tk, WxWidgets

Représentation graphique

gnuplot,matplotlib,VTK

Calcul scientifique

numpy, scipy, sage,...

…....


Pr sentation de python5
Présentation de Python langage machine mon code source:

Pourquoi Python pour le calcul

Peut être appris en quelques jours

Permet de faire des tests rapides

Alternative à Matlab, Octave, Scilab

Parallélisation

Multiplateforme

Facilement interfaçable avec des librairies(Fortran, C/C++) de calcul scientifique


Les types et les op rations de base
Les types et les opérations de base langage machine mon code source:

Les types:

Entiers(32 bits)

Entiers longs

Réels (64 bits)

Complexe: 3+4j, ou 3+5J

Booléens ( True, False)


Les types et les op rations de base1
Les types et les opérations de base langage machine mon code source:

Opérations de base

Affectation:

>>> i=3 # i vaut 3

>>>a, pi=True, 3.14159

>>>k=r=2.15

Affichage dans l'interpréteur

>>> i

3

>>> print i

3


Les types et op rations de base
Les types et opérations de base langage machine mon code source:

Opérations de base

Opérateurs +,-,*,/,%,//

Puissance **,pow,abs

Comparaison: ==, is, !=, is not, >,<,>=,<=

Opérateurs bitwise: &,|,<<,>>

Opérateurs logique: or,and, not


Apart
Aparté langage machine mon code source:

En Python tout est objet

dir permet d'avoir les objets et méthodes disponibles

eval evaluer les chaînes de caractères

help permet d avoir une aide

type connaître le type de l'objet

id l'adresse d'un objet

eval evaluer une chaîne de caractère

input et raw_input équivalent du scenf en C


Apart1
Aparté langage machine mon code source:

Ecriture d'un script python (test.py)

#!/usr/bin/env python

# -*- coding: utf-8 -*-

a=2

a

print type(a),a

Exécution python test.py

<type,'int'> 2


Les types et les op rations de base2
Les types et les opérations de base langage machine mon code source:

Les listes

Initialisation [ ],list(),[1, 2,3,4],['point','triangle',6], range(10),range(2,10,2)

Concaténation

In [18]: sept_zeros=[0]*7;sept_zeros

Out[18]: [0, 0, 0, 0, 0, 0, 0]

In [20]: L1,L2=[1,2,3],[4,5]

In [21]: L1+L2

Out[21]: [1, 2, 3, 4, 5]

Une liste est une séquence comme pour une chaîne de caractère


Les types et les op rations de base3
Les types et les opérations de base langage machine mon code source:

ATTENTION !!!!!

In [22]: L=['Dans','python','tout','est','objet']

In [23]: T=L

In [24]: T[4] ='bon'

In [25]: T

Out[25]: ['Dans', 'python', 'tout', 'est', 'bon']

In [26]: L

Out[26]: ['Dans', 'python', 'tout', 'est', 'bon']

In [27]: L=T[:]

In [28]: L[4]='objet'

In [29]: T;L

Out[29]: ['Dans', 'python', 'tout', 'est', 'bon']

Out[29]: ['Dans', 'python', 'tout', 'est', 'objet']


Les types et les op rations de base4
Les types et les opérations de base langage machine mon code source:

Une liste à ses propres méthodes help(list)

len(L) : taille de la liste

L.sort() : trier la liste

L.append() ajout element en fin de,liste

L.reverse(): inversion de la liste

L.index() recher elt dans L

L.remove(): retirer element

L.pop() ajout en fin de liste


Les types et les op rations de base5
Les types et les opérations de base langage machine mon code source:

Les tuples

Initialisation:

(),tuple(),(1,) 'a','b','c',

('a','b','c')

Concaténation

>>>(1,2)*3

>>> (1,2,1,2,1,2)

In [1]: t1,t2=(1,2,3),(4,5)

In [2]: t1+t2

Out[2]: (1, 2, 3, 4, 5)

Un tuple est aussi une séquence.


Les types et les op rations de base6
Les types et les opérations de base langage machine mon code source:

Opération sur un tuple

Un tuple n'est pas modifiable

In [3]: t='a','b','c','d'

In [4]: t[0]='alpha'

TypeError Traceback (most recent call last)

TypeError: 'tuple' object does not support item assignment

In [6]: t=('alpha',)+t[1:]

In [7]: t

Out[7]: ('alpha', 'b', 'c', 'd')

Mais un objet modifiable dans un tuple peut l'êtret

In[8]: t=(1,2,[3,4],6)

In[9]:t[2][0]=1;t

Out[9]: (1,2,[1,4],6)


Les types ete les op rations de base
Les types ete les opérations de base langage machine mon code source:

Les dictionnaires:

Initialisation {}, dict(), {'point':1,'ligne':2}

Un dictionnaire est constitué de clés et de valeurs

Pas de concaténation possible

Ajout d une clé ou modif d'une valeur

>>> dic['triangle']=3

>>> dic

{'ligne': 2, 'triangle': 3, 'point': 1}

>>> dic['point']=3

>>> dic

{'ligne': 2, 'triangle': 3, 'point': 3}


Les types et ls op rations de base
Les types et ls opérations de base langage machine mon code source:

Dictionnaire a ses propres méthodes:

len(dic) taille du dictionnaire

Dico.keys renvoie les clés

Dic.value renvoie les valuers

Dic.has_key renvoie True si clé presente

Dic.get donne valeur de la clé si elle existe sinon une valeur par défaut


Les structures de contr le
Les structures de contrôle langage machine mon code source:

Indentation générale


Structure de contr le
Structure de contrôle langage machine mon code source:

Structure if then

Structure while

While <test1>:

<bloc instruction>

if <test1>: break

if <test2> : continue

Else:

<bloc instruction>

a=10.

if a>0:

print ' est positif'

if a>=10:

print'a est un nombre'

else:

print ' a est un chiffre'

a+=1

elif a is not 0:

print 'a est negatif

else:

print'a est nul'


Structure de contr le1
Structure de contrôle langage machine mon code source:

For <cible> in <objet>:

<bloc instruction>

if <test1>: break

if <test2> : continue

else:

<bloc instruction>

sum =0

for i in [1,2,3,4]:

sum+=i

prod=1

for p in range(1,10):

prod*= p

s='bonnjour'

for c in s:

print c


Les fonctions
Les fonctions langage machine mon code source:

Syntaxe:

def <nom_fonction>( arg1,arg2,.....):

<bloc instruction>

return valeur

Exemple:

def table(base):

N=1

while n<11:

print n*base,

N+=1

return n


Les fichiers
Les fichiers langage machine mon code source:

f=open(filename, mode='r', bufsize=-1)

'r' le fichier qui doit déja exister ouvert en lecture

'w' en ecriture seule si il existe déjà il est écrsé et créé sinon

'b' ouvre un fichier binaire

Option '+' ouvre en lectuere et écriture

'a' en écriture son contenu est conservé

Les méthode:close(),read() et renvoie sous forme de chaîne, readline() lit une ligne du fichier, readlines(), write(s) ecrit la chaine s, writelines(lst)


Les classes
Les classes langage machine mon code source:

Syntaxe:

classe <nom_classe>(superclass,....):

donnee=valeur

def methode(self,....):

self.membre=valeur

Exemple classe vecteur:


Python les bases du langage

Les classes langage machine mon code source:

class vecteur:

def __init__(self, x, y, z = 0):

self.coords = [x, y, z]

def __str__(self):

s = ''

for c in self.coords:

s += '( ' + str(c) + ' )\n'

return s

def __add__(self, v):

return vecteur(self.coords[0] + v.coords[0],

self.coords[1] + v.coords[1],

self.coords[2] + v.coords[2])

>>> v1 = vecteur(1, 2)

>>> v2 = vecteur(4.1, 3.4, 1.)

>>> v3 = v1 + v2

>>> print v3

( 5.1 )

( 5.4 )

( 1.0 )


Python les bases du langage

NumPy langage machine mon code source:

▶Le module incontournable

▬ Heritier de Numeric et numarray

▬ Classes de base pour SciPy

▶Installation

▬ Module Python standard

▬ Optimisation plateforme: blas, lapack...

▶Utilisation

▬ Traitement Python des tableaux pour calcul numerique

◆ Nombreuses fonctions de manipulation

◆ Bibliothèque mathématique importante

▬ Support pour vos propres bibliotheques

◆ Interface Python pur

◆ API pour encapsulation de codes Fortran, C/C++


Python les bases du langage

Le tableau NumPy langage machine mon code source:

▶ndarray

▬ L'objet Tableau

◾ Collection indexable et contigue en mémoire d‘éléments de même type

◾ Implémentation avec un vrai tableau en mémoire optimise pour les performances

◾ Manipulation similaire a tout autre objet Python

◾ ▬ Multi-dimensionnel, tous types de données

◾ Les dimensions et parcours sont modifiables, les indexations souples

◾ Optimisations internes pour les 1D, 2D et 3D

◾ ▬ Interfaçable avec les codes, en particulier Fortran

◾ Permet l'encapsulation de codes fortran

◾ Gestion possible des interfacages multiples Fortran/C/C++

Appel au module

>>> import numpy


Python les bases du langage

Creation – 1 langage machine mon code source:

▶La création d'un tableau définit...

▬ Son contenu

◾ Par exemple sous forme d'une liste de valeurs

a=array([1,3,5,7,9,11,13,17])

▬ Ses dimensions

◾ Une liste: dimension 1, une liste de listes: dimension 2, une liste de listes de listes: dimension 3...

a=array([0.1, 0.0, 0.2])

b=array([[1,2,3],[4,5,6]])

▬ Son type d'element

◾ Un entier Python est un long, un reel est un double

◾ Il est necessaire de preciser si les valeurs en arguments ne sont pas les types Python

a=array([0.1, 0.0, 0.2],dtype='f')

b=array([[1,2,3],[4,5,6]],dtype='i')


Python les bases du langage

Creation – 2 langage machine mon code source:

▶Diverses methodes de creation

>>> a=arange(10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> a=zeros((2,4),dtype='f')

array([[ 0., 0., 0., 0.],

[ 0., 0., 0., 0.]], dtype=float32)

>>> a=ones((3,5))*nan

array([[ nan, nan, nan, nan, nan],

[ nan, nan, nan, nan, nan],

[ nan, nan, nan, nan, nan]])

>>> a=identity(3)

array([[ 1., 0., 0.],

[ 0., 1., 0.],

[ 0., 0., 1.]])

>>> a=mat([[1,0],[0,1]])

matrix([[1, 0],

[0, 1]])


Python les bases du langage

Creation – 3 langage machine mon code source:

▬ Fonction des indices

>>> def initfunction(i,j):

... return 100+10*i+j

>>> c=fromfunction(initfunction,(5,3))

array([[ 100., 101., 102.],

[ 110., 111., 112.],

[ 120., 121., 122.],

[ 130., 131., 132.],

[ 140., 141., 142.]])

▬ A partir d'un fichier

>>> import numpy

>>> a=numpy.ones((3,5,7))

>>> numpy.save("data.npy",a)

>>> b=numpy.load("data.npy")


Python les bases du langage

Attributs – 1 langage machine mon code source:

▶flat

▬ Vue 1D d'un tableau

◆ Pas de modification du tableau

◆ Iterateur

>>> a=indices((2,5))

>>> a

array([[[0, 0, 0, 0, 0],

[1, 1, 1, 1, 1]],

[[0, 1, 2, 3, 4],

[0, 1, 2, 3, 4]]])

>>> a.flat

<numpy.flatiter object at 0xc9db80>

>>> a.flat[0]

0

>>> a.flat[:]

array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4])

>>>


Python les bases du langage

Attributs – 2 langage machine mon code source:

▶shape

▬ Tuple des dimensions d'un tableau

Attribut accessible en lecture et en ecriture

>>> a=ones((3,5,7))

>>> a.shape

(3,5,7)

>>> a.shape=(21,5)

>>> shape(a)

(21,5)

▬ Le nombre d'elements doit rester inchange

len(a.flat) = Constante

▬ La methode reshape permet aussi de changer le shape

>>> a=arange(105).reshape((3,5,7))


Python les bases du langage

Attributs – 3 langage machine mon code source:

▶Fortran

▬ Type d'implantation memoire

◆ C (par defaut) line major, Boucle en i,j,k

◆ Fortran column major, Boucle en k,j,i

▬ Pas d'impact sur le shape

>>> a=ones((2,3,4),order='Fortran')

>>> isfortran(a)

True

▶OwnData

▬ Python est proprietaire de la zone memoire

>>> a.flags.owndata

True


Python les bases du langage

Indexation – 1 langage machine mon code source:

▶Un element dans le tableau

▬ Syntaxe similaire aux sequences

>>> a=arange(24).reshape(2,3,4)

>>> a[0][2][1]

9

>>> a[0][0:1]

array([[0, 1, 2, 3],[4, 5, 6, 7]])

▬ Syntaxe avec implementation optimisee pour l'acces

>>> a[0,2,1]

9

>>> a[0,0:1]

array([[0, 1, 2, 3],[4, 5, 6, 7]])

▬ La syntaxe fonctionne pour la la reference et l'assignation

>>> b=a[0:2]

>>> a[0:2]=9


Python les bases du langage

Indexation - 2 langage machine mon code source:

▬ Prendre un axe complet

>>> a=arange(24).reshape(2,3,2,2)

>>> a.tolist()

[[[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[8, 9], [10, 11]]], [[[12, 13],

[14, 15]], [[16, 17], [18, 19]], [[20, 21], [22, 23]]]]

>>> a[0,:,:,0]

array([[ 0, 2],

[ 4, 6],

[ 8, 10]])

>>> a[0,...,0]


Python les bases du langage

Indexation - 3 langage machine mon code source:

▶Ajout du step

▬ [<start>:<stop>:<step>]

>>> a=arange(24).reshape(2,6,2)

>>> a

array([[[ 0, 1],

[ 2, 3],

[ 4, 5],

[ 6, 7],

[ 8, 9],

[10, 11]],

[[12, 13],

[14, 15],

[16, 17],

[18, 19],

[20, 21],

[22, 23]]])

>>> a[0]

array([[ 0, 1],

[ 2, 3],

[ 4, 5],

[ 6, 7],

[ 8, 9],

[10, 11]])

>>> a[0,::2]

array([[0, 1],

[4, 5],

[8, 9]])

>>> a[0,::2,:1]

array([[0],

[4],

[8]])


Python les bases du langage

Ufuncs - 1 langage machine mon code source:

▶Universal functions

▬ Opere sur un tableau element par element

◾ add(a,b) avec a et b ndarrays est plus performant qu'une boucle

▬ Vectorisable

◾ Une fonction prend des vecteurs en entree et produit un vecteur en sortie

◾ L'utilisateur peut utiliser l'API pour creer ses propres ufuncs

▬ Broadcasting

◾ Il est parfois necessaire de faire des adaptations pour que les vecteurs en entree aient la meme taille

◾ a=array([1,2,3,4,5])*2

◾ Provoque le broadcasting b=array([2,2,2,2,2])

▬ Syntaxe compacte

◾ Pas de boucles

◾ Parfois difficile a lire

>>> x=arange(10)

>>> x[(x**39*

x**2+23*x15)==

0]

array([1, 3, 5])


Python les bases du langage

Ufuncs – 2 langage machine mon code source:

sin() Trigonometric sine, element-wise.

cos() Cosine elementwise.

tan() Compute tangent element-wise.

arcsin() Inverse sine, element-wise.

arccos() Trigonometric inverse cosine, element-wise.

arctan() Trigonometric inverse tangent, elementwise.

add(x1) Add arguments element-wise.

subtract(x1) Subtract arguments, element-wise.

multiply(x1) Multiply arguments element-wise.

divide(x1) Divide arguments element-wise.

logaddexp(x1) Logarithm of the sum of exponentiations of the inputs.

logaddexp2(x1) Logarithm of the sum of exponentiations of the inputs in base-2.

true_divide(x1) Returns a true division of the inputs, element-wise.

floor_divide(x1) Return the largest integer smaller or equal to the division of the

inputs.

negative() Returns an array with the negative of each element of the original

array.

power(x1) First array elements raised to powers from second array, element-wise.

remainder(x1) Return element-wise remainder of division.

mod(x1) Return element-wise remainder of division.

fmod(x1) Return the element-wise remainder of division.

absolute() Calculate the absolute value element-wise.

rint() Round elements of the array to the nearest integer.

sign() Returns an element-wise indication of the sign of a number.

conj() Return the complex conjugate, element-wise.

exp() Calculate the exponential of all elements in the input array.

exp2() Calculate 2**p for all p in the input array.

log() Natural logarithm, element-wise.

log2() Base-2 logarithm of x.

log10() Return the base 10 logarithm of the input array, element-wise.

expm1() Calculate exp(x) - 1 for all elements in the array.

log1p() Return the natural logarithm of one plus the input array, element-wise.

sqrt() Return the positive square-root of an array, element-wise.

square() Return the element-wise square of the input.

reciprocal() Return the reciprocal of the argument, element-wise.

ones_like() Returns an array of ones ……………………………………………..


Python les bases du langage

F2py langage machine mon code source:

f2py nécessite l’installation de Numpy et trois méthodes pour

créer une interface sont proposées :

• Interfacer des subroutines simples sans écrire de code

supplémentaire.

• Ajouter des directives pour f2py dans le source Fortran

pour un interfaçage plus complexe.

• Écrire un fichier d’interface décrivant les subroutines et

les données à interfacer. f2py génère automatiquement

un fichier d’interface simple qu’on peut ensuite éditer et

modifier.


Python les bases du langage

  • Exemple de subroutine simple langage machine mon code source:

  • Calcul de la norme.

  • Fortran 90/95 format libre

    • subroutine norme (a, b, c)

    • real(8), intent(in) :: a, b

    • real(8), intent(out) :: c

    • c= sqrt (a*a+b*b)

    • end subroutine norme

  • Fortran 77 format fixe

    • subroutine norme (a, b, c)

    • real*8 a,b,c

    • Cf2py intent(out) c

    • c=sqrt (a*a+b*b)

    • end


  • Python les bases du langage

    • Compilation et exécution langage machine mon code source:

    • • Génération de l’interface Python avec f2py

    • f2py -c norme.f90 -m vect --fcompiler=gnu95 --f90flags=-O3

    • • Appel depuis un shell Python

      • >>> import vect

      • >>> vect.norme(3,4)

      • 5.0

      • >>> c = vect.norme(3,4)

      • >>> c

      • 5.0

  • • Documentation générée automatiquement par f2py

    • >>> print vect.norme.__doc__

    • norme - Function signature :

    • c = norme(a,b)

    • Required arguments :

    • a : input float

    • b : input float

    • Return objects :

    • c : float


  • Python les bases du langage

    • Ajout de directive f2py dans le source Fortran langage machine mon code source:

    • Ces ajouts dans le code source fortran permettent préciser le

    • rôle et la définition des variables d’entrés-sorties. Sont

    • utilisés :

    • • Les attributs du F90 : intent(in), dimension(2,3).

    • • Les attributs spécifiques : !f2py intent(hide), depend(a).

      • subroutine norme(a,c,n)

      • integer :: n

      • real(8),dimension(n),intent(in) :: a

      • !f2py optional , depend(a) :: n=len(a)

      • real(8),intent(out) :: c

      • real(8) :: sommec

      • integer :: i

      • sommec = 0

      • do i=1,n

      • sommec=sommec+a( i )*a( i )

      • end do

      • c=sqrt (sommec)

      • end subroutine norme


    Python les bases du langage

    Liste Python ou tableau numpy en argument langage machine mon code source:

    >>> from vect import *

    >>> a=[2,3,4] #Une liste Python

    >>> type(a)

    <type 'list'>

    >>> norme(a)

    5.3851648071345037

    >>> from numpy import *

    >>> a=arange(2,5) # Un tableau numpy

    >>> type(a)

    <type 'numpy.ndarray'>

    >>> norme(a)

    5.3851648071345037

    >>> print norme.__doc__ # Documentation

    norme - Function signature :

    c = norme(a,[n])

    Required arguments :

    a : input rank-1 array('d') with bounds (n)

    Optional arguments :

    n := len(a) input int

    Return objects :

    c : float


    Python les bases du langage

    Utilisation d’un fichier signature langage machine mon code source:

    • On peut générer automatiquement un fichier signature

    f2py vecteur.f90 -h vecteur.pyf

    • Contenu de vecteur.pyf

    ! -*- f90 -*-

    ! Note: the context of this file is case sensitive.

    subroutine norme(a,c,n) ! in norme.f90

    real(kind=8) dimension(n),intent(in) :: a

    real(kind=8) intent(out) :: c

    integer optional,check(len(a)>=n),depend(a) :: n=len(a)

    end subroutine norme

    ! This file was auto-generated with f2py (version:2).

    ! See http://cens.ioc.ee/projects/f2py2e/


    Python les bases du langage

    Les tableaux multi dimensionnels langage machine mon code source:

    subroutine move( positions, vitesses, dt, n)

    integer, intent(in) :: n

    real(8), intent(in) :: dt

    real(8), dimension(n,3), intent(in) :: vitesses

    real(8), dimension(n,3) :: positions

    do i = 1, n

    positions(i,:) = positions(i,:) + dt*vitesses(i,:)

    end do

    end subroutine move

    >>> print vitesses

    [[0, 1, 2], [0, 3, 2], [0, 1, 3]]

    >>> print positions

    [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

    >>> move(positions, vitesses, 0.1)

    >>> print positions #le tableau n'est pas mis a jour, stockage C

    [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

    >>> positions = numpy.array(positions, dtype='f8', order='F')

    >>> move(positions, vitesses, 0.1)

    >>> print positions #le tableau est modifie, stockage Fortran

    [[ 0. 0.1 0.2]

    [ 0. 0.3 0.2]

    [ 0. 0.1 0.3]]