Problème compréhension fonctionnement langage Python
Répondre à la discussion
Affichage des résultats 1 à 11 sur 11

Problème compréhension fonctionnement langage Python



  1. #1
    invite105cee1c

    Problème compréhension fonctionnement langage Python


    ------

    Bonjour,

    Comme dis dans le titre, je ne comprend pas le fonctionnement de ce language .
    Par exemple dans le programme suivant ( jeu pong avec kivy), je ne comprend pas à quel moment s'exécute les fonctions ( enfin les méthodes plutôt), de même pour les classes , qui décide à quel moment s'exécute le code dans les fonctions ?
    j'ai l'impression que tout peut s'exécuter en même temps au grès d'évènement inconnu .

    dans l'absolu je m'en fou l'application que je veux réaliser est relativement simple, mais tout se complique avec l'utilisation du port série

    par ex la fonction : def move(self): , comment est elle appelée ?

    c'est franchement fouilli par rapport à d'autres langage comme le C par exemple !

    Par avance merci pour vos lanternes .

    Code:
    from kivy.app import App
    from kivy.uix.widget import Widget
    from kivy.properties import NumericProperty, ReferenceListProperty,\
        ObjectProperty
    from kivy.vector import Vector
    from kivy.clock import Clock
    
    
    class PongPaddle(Widget):
        score = NumericProperty(0)
    
        def bounce_ball(self, ball):
            if self.collide_widget(ball):
                vx, vy = ball.velocity
                offset = (ball.center_y - self.center_y) / (self.height / 2)
                bounced = Vector(-1 * vx, vy)
                vel = bounced * 1.1
                ball.velocity = vel.x, vel.y + offset
    
    
    class PongBall(Widget):
        velocity_x = NumericProperty(0)
        velocity_y = NumericProperty(0)
        velocity = ReferenceListProperty(velocity_x, velocity_y)
    
        def move(self):
            self.pos = Vector(*self.velocity) + self.pos
    
    
    class PongGame(Widget):
        ball = ObjectProperty(None)
        player1 = ObjectProperty(None)
        player2 = ObjectProperty(None)
    
        def serve_ball(self, vel=(4, 0)):
            self.ball.center = self.center
            self.ball.velocity = vel
    
        def update(self, dt):
            self.ball.move()
    
            # bounce of paddles
            self.player1.bounce_ball(self.ball)
            self.player2.bounce_ball(self.ball)
    
            # bounce ball off bottom or top
            if (self.ball.y < self.y) or (self.ball.top > self.top):
                self.ball.velocity_y *= -1
    
            # went of to a side to score point?
            if self.ball.x < self.x:
                self.player2.score += 1
                self.serve_ball(vel=(4, 0))
            if self.ball.x > self.width:
                self.player1.score += 1
                self.serve_ball(vel=(-4, 0))
    
        def on_touch_move(self, touch):
            if touch.x < self.width / 3:
                self.player1.center_y = touch.y
            if touch.x > self.width - self.width / 3:
                self.player2.center_y = touch.y
    
    
    class PongApp(App):
        def build(self):
            game = PongGame()
            game.serve_ball()
            Clock.schedule_interval(game.update, 1.0 / 60.0)
            return game
    
    
    if __name__ == '__main__':
        PongApp().run()

    -----

  2. #2
    pm42

    Re : Problème compréhension fonctionnement language Python

    Citation Envoyé par extremgear Voir le message
    je ne comprend pas à quel moment s'exécute les fonctions ( enfin les méthodes plutôt), de même pour les classes , qui décide à quel moment s'exécute le code dans les fonctions ?
    Quand on les appelle, c'est la même chose qu'en C.

    Citation Envoyé par extremgear Voir le message
    j'ai l'impression que tout peut s'exécuter en même temps au grès d'évènement inconnu .
    Citation Envoyé par extremgear Voir le message
    par ex la fonction : def move(self): , comment est elle appelée ?
    Dans update avec
    self.ball.move()
    .

    Citation Envoyé par extremgear Voir le message
    c'est franchement fouilli par rapport à d'autres langage comme le C par exemple !
    Pas du tout, c'est juste de la programmation objet et il faut comprendre les concepts via les nombreux tutoriaux et cours. Il y en sans doute même certains qui ciblent ceux qui viennent du C ou des langages équivalents.

  3. #3
    invite105cee1c

    Re : Problème compréhension fonctionnement language Python

    Merci

    Mince mauvais exemple !
    Il y a des fonctions qui ne sont pas appelées par des routines visibles dans le programme , je m'explique très mal je le reconnait , mais
    celle ci par exemple :
    Code:
     def on_touch_move(self, touch):

  4. #4
    pm42

    Re : Problème compréhension fonctionnement language Python

    C'est de l'héritage de la classe Widget. Comme déjà dit, pour comprendre un programme objet, il faut apprendre la programmation objet...
    Ensuite, ce genre de méthode est appelé par le framework dans le cadre de la programmation évènementielle mais ce n'est pas très différent des callbacks avec pointeur de fonction en C.
    Dernière modification par pm42 ; 25/04/2017 à 21h01.

  5. A voir en vidéo sur Futura
  6. #5
    invite105cee1c

    Re : Problème compréhension fonctionnement language Python

    ok

    mais par exemple est ce que je peux avoir une routine qui lit constamment le port série et stock les données dans une variable qui peut être lue dans une autre routine à tout instant ?

  7. #6
    pm42

    Re : Problème compréhension fonctionnement language Python

    Citation Envoyé par extremgear Voir le message
    mais par exemple est ce que je peux avoir une routine qui lit constamment le port série et stock les données dans une variable qui peut être lue dans une autre routine à tout instant ?
    Bien sur. Comme dans tout langage, et tu peux faire ça en monothread, en multithread...

  8. #7
    invite105cee1c

    Re : Problème compréhension fonctionnement language Python

    ah , encore un truc qu'il faut que je creuse monothread multithread .

  9. #8
    invite105cee1c

    Re : Problème compréhension fonctionnement language Python

    Par example dans ce programme dans quelle variable je récupère les données arrivant sur le port série , ça m'a l'air bien fouillis tout ça

    Code:
    #!/usr/bin/env python3
    #
    # Working with threading and pySerial
    #
    # This file is part of pySerial. https://github.com/pyserial/pyserial
    # (C) 2015 Chris Liechti <cliechti@gmx.net>
    #
    # SPDX-License-Identifier:    BSD-3-Clause
    """\
    Support threading with serial ports.
    """
    import serial
    import threading
    
    
    class Protocol(object):
        """\
        Protocol as used by the ReaderThread. This base class provides empty
        implementations of all methods.
        """
    
        def connection_made(self, transport):
            """Called when reader thread is started"""
    
        def data_received(self, data):
            """Called with snippets received from the serial port"""
    
        def connection_lost(self, exc):
            """\
            Called when the serial port is closed or the reader loop terminated
            otherwise.
            """
    
    
    class Packetizer(Protocol):
        """
        Read binary packets from serial port. Packets are expected to be terminated
        with a TERMINATOR byte (null byte by default).
    
        The class also keeps track of the transport.
        """
    
        TERMINATOR = b'\0'
    
        def __init__(self):
            self.buffer = bytearray()
            self.transport = None
    
        def connection_made(self, transport):
            """Store transport"""
            self.transport = transport
    
        def connection_lost(self, exc):
            """Forget transport"""
            self.transport = None
    
        def data_received(self, data):
            """Buffer received data, find TERMINATOR, call handle_packet"""
            self.buffer.extend(data)
            while self.TERMINATOR in self.buffer:
                packet, self.buffer = self.buffer.split(self.TERMINATOR)
                self.handle_packet(packet)
    
        def handle_packet(self, packet):
            """Process packets - to be overridden by subclassing"""
            raise NotImplementedError('please implement functionality in handle_packet')
    
    
    class LineReader(Packetizer):
        """
        Read and write (Unicode) lines from/to serial port.
        The encoding is applied.
        """
    
        TERMINATOR = b'\r\n'
        ENCODING = 'utf-8'
        UNICODE_HANDLING = 'replace'
    
        def handle_packet(self, packet):
            self.handle_line(packet.decode(self.ENCODING, self.UNICODE_HANDLING))
    
        def handle_line(self, line):
            """Process one line - to be overridden by subclassing"""
            raise NotImplementedError('please implement functionality in handle_line')
    
        def write_line(self, text):
            """
            Write text to the transport. ``text`` is a Unicode string and the encoding
            is applied before sending ans also the newline is append.
            """
            # + is not the best choice but bytes does not support % or .format in py3 and we want a single write call
            self.transport.write(text.encode(self.ENCODING, self.UNICODE_HANDLING) + self.TERMINATOR)
    
    
    class ReaderThread(threading.Thread):
        """\
        Implement a serial port read loop and dispatch to a Protocol instance (like
        the asyncio.Protocol) but do it with threads.
    
        Calls to close() will close the serial port but it is also possible to just
        stop() this thread and continue the serial port instance otherwise.
        """
    
        def __init__(self, serial_instance, protocol_factory):
            """\
            Initialize thread.
    
            Note that the serial_instance' timeout is set to one second!
            Other settings are not changed.
            """
            super(ReaderThread, self).__init__()
            self.daemon = True
            self.serial = serial_instance
            self.protocol_factory = protocol_factory
            self.alive = True
            self._lock = threading.Lock()
            self._connection_made = threading.Event()
            self.protocol = None
    
        def stop(self):
            """Stop the reader thread"""
            self.alive = False
            self.join(2)
    
        def run(self):
            """Reader loop"""
            self.serial.timeout = 1
            self.protocol = self.protocol_factory()
            try:
                self.protocol.connection_made(self)
            except Exception as e:
                self.alive = False
                self.protocol.connection_lost(e)
                self._connection_made.set()
                return
            error = None
            self._connection_made.set()
            while self.alive and self.serial.is_open:
                try:
                    # read all that is there or wait for one byte (blocking)
                    data = self.serial.read(self.serial.in_waiting or 1)
                except serial.SerialException as e:
                    # probably some I/O problem such as disconnected USB serial
                    # adapters -> exit
                    error = e
                    break
                else:
                    if data:
                        # make a separated try-except for called used code
                        try:
                            self.protocol.data_received(data)
                        except Exception as e:
                            error = e
                            break
            self.alive = False
            self.protocol.connection_lost(error)
            self.protocol = None
    
        def write(self, data):
            """Thread safe writing (uses lock)"""
            with self._lock:
                self.serial.write(data)
    
        def close(self):
            """Close the serial port and exit reader thread (uses lock)"""
            # use the lock to let other threads finish writing
            with self._lock:
                # first stop reading, so that closing can be done on idle port
                self.stop()
                self.serial.close()
    
        def connect(self):
            """
            Wait until connection is set up and return the transport and protocol
            instances.
            """
            if self.alive:
                self._connection_made.wait()
                if not self.alive:
                    raise RuntimeError('connection_lost already called')
                return (self, self.protocol)
            else:
                raise RuntimeError('already stopped')
    
        # - -  context manager, returns protocol
    
        def __enter__(self):
            """\
            Enter context handler. May raise RuntimeError in case the connection
            could not be created.
            """
            self.start()
            self._connection_made.wait()
            if not self.alive:
                raise RuntimeError('connection_lost already called')
            return self.protocol
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            """Leave context: close port"""
            self.close()
    
    
    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # test
    if __name__ == '__main__':
        import sys
        import time
        import traceback
    
        class PrintLines(LineReader):
            def connection_made(self, transport):
                super(PrintLines, self).connection_made(transport)
                sys.stdout.write('port opened\n')
                self.write_line('hello world')
    
            def handle_line(self, data):
                sys.stdout.write('line received: {}\n'.format(repr(data)))
    
            def connection_lost(self, exc):
                if exc:
                    traceback.print_exc(exc)
                sys.stdout.write('port closed\n')
    
        ser = serial.serial_for_url('loop://', baudrate=115200, timeout=1)
        with ReaderThread(ser, PrintLines) as protocol:
            protocol.write_line('hello')
            time.sleep(2)
    
        # alternative usage
        ser = serial.serial_for_url('loop://', baudrate=115200, timeout=1)
        t = ReaderThread(ser, PrintLines)
        t.start()
        transport, protocol = t.connect()
        protocol.write_line('hello')
        time.sleep(2)
        t.close()

  10. #9
    pm42

    Re : Problème compréhension fonctionnement language Python

    Citation Envoyé par extremgear Voir le message
    Par example dans ce programme dans quelle variable je récupère les données arrivant sur le port série , ça m'a l'air bien fouillis tout ça
    Tu l'as déjà dit que tu trouvais ça fouilli mais vu que tu refuses d'apprendre et que tu te contentes de poser des questions, tu vas effectivement avoir du mal à découvrir que curieusement, ce code fonctionne suivant les concepts indiqués dans les réponses plus haut (héritage, surcharge de méthode notamment).
    Comme en plus, c'est dans le code avec les commentaires, tu n'as pas d'excuses.
    Maintenant, tu te débrouilles.

  11. #10
    CM63

    Re : Problème compréhension fonctionnement language Python

    Bonjour,

    Les méthodes des objets sont appelées lorsqu'on fait :

    Code:
    a.methode()
    a est un objet (une instance d'une classe) et methode est une méthode de la classe. Ça c'est la base , mais ce qui est déroutant ce sont les méthodes de type on_quelquechose comme onClick ou autre. De par la façon dont elles sont implémentées, on a l'impression que le principe n'est pas le même, on a l'impression qu'elles vont être appelées de façon "asynchrone" (les formateurs emploient même ce terme), alors qu'elles n'ont rien de plus asynchrone que les autres.

    Lorsqu'on déclare un onClick, on dit ce que doit faire l'objet lorsqu'un événement arrive (le click sur la souris). Mais c'est quoi un événement? Si ce n'est un call "normal" de la classe mère dont hérite la classe que tu es en train d'écrire? En Java ou C# on dirait : "si ce n'est un call "normal" d'une méthode de l'interface implémentée par la classe que tu es en train d'écrire".

    C'est l'interface (ou la classe mère) qui passe son temps à "écouter" le clavier ou la souris et qui fait le call lorsque l’événement arrive.

  12. #11
    CM63

    Re : Problème compréhension fonctionnement language Python

    En Python tout ça est un peu confus car on autorise l'héritage multiple, comme en C++. Mais dans les langages plus récents tels que Java ou C# on interdit l'héritage multiple entre classes "normales" , et si on veut faire de l'héritage multiple on crée ce qu'on appelle une interface: ce sont des classes spéciales qui... autorisent l'héritage multiple . Disons qu'on formalise les choses et ce sont justement ces interfaces qu'on va utiliser pour gérer les événements tels que les clicks souris ou les entrées claviers.
    On utilise les interfaces aussi pour faire des sérialisateurs: donner la possibilité aux objets de se sauvegarder sur fichier ou de se lire sur fichier, mais c'est un autre sujet.

    Autre utilisation : les afficheurs : décider comment un objet va s'afficher à l'écran.
    Dernière modification par CM63 ; 27/04/2017 à 10h14.

Discussions similaires

  1. Langage Python
    Par invitee244f4d2 dans le forum Programmation et langages, Algorithmique
    Réponses: 3
    Dernier message: 03/01/2017, 19h12
  2. [Python] difficulté compréhension programme
    Par invite4fed8452 dans le forum Programmation et langages, Algorithmique
    Réponses: 13
    Dernier message: 25/08/2015, 14h40
  3. Problème langage python (datetime)
    Par invite32886bf8 dans le forum Programmation et langages, Algorithmique
    Réponses: 3
    Dernier message: 20/04/2015, 16h32
  4. langage Python
    Par invited07d9c9d dans le forum Programmation et langages, Algorithmique
    Réponses: 12
    Dernier message: 11/11/2014, 16h09
  5. langage Python
    Par invitefacf0d25 dans le forum Logiciel - Software - Open Source
    Réponses: 4
    Dernier message: 08/12/2006, 18h22