PYTHON - signification de tableau dans une classe

[Linuxman99]

Bonjour à tous ,

Je suis débutant sous python , je souhaiterais savoir si quelqu'un peut m'aider à comprendre la signification de cette classe et surtout l'instruction _block[point[1] + 3 * point[0] , est ce une liste dansune liste ? point [1] signifie quoi par rapport à _block , point [0]

point et value sont des tableau à donner en paramètres ?

Merci

-------------------------------------------------------------------------------------------------------------------------------------
class Block(object):
def __init__(self):
self._block = [0, 0, 0, 0, 0, 0, 0, 0, 0] # création de liste

def __setitem__(self, point, value):

if abs(self._block[point[1] + 3 * point[0]]) == abs(value):
self._block[point[1] + 3 * point[0]] = value
return
-----

[pm42]

Cela met value dans le tableau à l'indice calculé par

point[1] + 3 * point[0]

Sans savoir d'où vient le code, difficile d'en savoir plus parce qu'il est mal écrit, aberrant et buggé.

[Linuxman99]

J'ai trouvé ce code sur le net :

#!/usr/bin/python3
# Copyright (C) 2010 Julian Andres Klode <jak@jak-linux.org>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Sudoku Game.
A simple Sudoku game that uses backtracking for solving and creating
Sudokos."""


import curses
import random
import time


class Block(object):
    """Store a single 3x3 block in the complete field."""

    def __init__(self):
        self._block = [0, 0, 0, 0, 0, 0, 0, 0, 0]    # création de liste 

    def __setitem__(self, point, value):
        """Set the value, check that value is not already in the block."""
        # n == -n, as n < 0 means user generated abs(n).
        if abs(self._block[point[1] + 3 * point[0]]) == abs(value):
            self._block[point[1] + 3 * point[0]] = value
            return
        if value != 0 and (value in self._block or -value in self._block):
            raise ValueError("Block already contains %d" % value)
        self._block[point[1] + 3 * point[0]] = value

    def __getitem__(self, point):
        """Return the value at the given point."""
        return self._block[point[1] + 3 * point[0]]


class Sudoku(object):

    def __init__(self):
        self._field = [Block() for i in range(9)]
        # Cached values used in solve() and populate()
        self._values = list(range(1, 10))
        self._points = [(x, y) for y in range(9) for x in range(9)]

    def clear(self):
        """Reset the game to empty."""
        for b in self._field:
            b._block = [0, 0, 0, 0, 0, 0, 0, 0, 0]

    def candidates(self, point):
        """Return all candidates at the point (x, y)."""
        candidates = set()
        previous = self[point]
        for i in self._values:
            try:
                self[point] = i
            except ValueError:
                pass
            else:
                candidates.add(i)
        self[point] = previous
        return candidates

    def populate(self, n=36):
        """Populate ca. n fields of the Sudoku.
        Clear the Sudoku, run the solver using random values and
        remove as many values as possible.
        """
        # Randomize the list of points and values
        random.shuffle(self._points)
        random.shuffle(self._values)
        self.clear()
        self.solve()

        for point in self._points:
            if self[point] == 0:
                continue
            val = self[point]
            for v in self.candidates(point):
                if v == val:
                    continue
                self[point] = v
                if self.solve(True):
                    self[point] = val
                    break
            else:
                if (81 - sum(b._block.count(0) for b in self._field) < n):
                    self[point] = val
                    break
                self[point] = 0

        for point in self._points:
            self[point] *= -1

    def __str__(self):
        """Represent the Sudoku as a string (for debugging purposes)."""
        s = ""
        for y in range(9):
            for x in range(9):
                s += '%d ' % self[x, y]
                if (x + 1) % 3 == 0:
                    s += " "
            s += "\n"
            if (y + 1) % 3 == 0:
                s += "\n"
        return s.strip()

    def __getitem__(self, p):
        pb = (p[0] // 3, p[1] // 3)
        block = self._field[pb[1] + 3 * pb[0]]

        return block[p[0] % 3, p[1] % 3]

    def __setitem__(self, p, val):
        if self[p] < 0 and val >= 0:
            raise ValueError("Value at point %s is pre-defined" % str(p))
        if val != 0:
            for i in range(9):
                if i != p[1] and abs(self[p[0], i]) == abs(val):
                    raise ValueError("Already in column: %d" % val)
                if i != p[0] and abs(self[i, p[1]]) == abs(val):
                    raise ValueError("Already in row: %d" % val)

        pb = (p[0] // 3, p[1] // 3)
        block = self._field[pb[1] + 3 * pb[0]]

        block[p[0] % 3, p[1] % 3] = val

    def is_solved(self):
        return all(0 not in self._field[i]._block for i in range(0, 9))

    def solve(self, reset=False):
        """Solve the Sudoku.
        If 'reset' is True, just check whether the sudoku can be solved,
        after return the sudoku will be identical to before the call.
        """
        if self.is_solved():
            return True

        field = None
        for x in range(9):
            if field is not None:
                break
            for y in range(9):
                if self[x, y] == 0:
                    field = (x, y)
                    break

        if field is None:
            return True

        for new in self._values:
            try:
                self[field] = new
            except ValueError:
                continue
            else:
                if self.solve(reset):
                    if reset:
                        self[field] = 0
                    return True
                else:
                    self[field] = 0


class CursesUI(object):
    """Command-line 'curses' interface."""

    def __init__(self):
        self._screen = curses.initscr()
        self._sudoku = Sudoku()

        # Draw the borders
        self._screen.vline(0, 4 * 3 - 2, curses.ACS_VLINE, 2 * 9 - 1)
        self._screen.vline(0, 4 * 6 - 2, curses.ACS_VLINE, 2 * 9 - 1)
        self._screen.hline(2 * 3 - 1, 0, curses.ACS_HLINE, 4 * 9 - 3)
        self._screen.hline(2 * 6 - 1, 0, curses.ACS_HLINE, 4 * 9 - 3)
        self._screen.addch(2 * 3 - 1, 4 * 3 - 2, curses.ACS_PLUS)
        self._screen.addch(2 * 3 - 1, 4 * 6 - 2, curses.ACS_PLUS)
        self._screen.addch(2 * 6 - 1, 4 * 3 - 2, curses.ACS_PLUS)
        self._screen.addch(2 * 6 - 1, 4 * 6 - 2, curses.ACS_PLUS)
        self._draw_sudoku()
        curses.noecho()
        curses.cbreak()
        self._screen.keypad(1)

    def __enter__(self, *a):
        return self

    def __exit__(self, *a):
        curses.nocbreak()
        self._screen.keypad(0)
        curses.echo()
        curses.endwin()

    def _draw_sudoku(self):
        for y in range(0, 9):
            for x in range(0, 9):
                value = self._sudoku[x, y]
                attr = curses.A_BOLD if value < 0 else 0
                # Mark cells with only one possible solution.
                #if len(self._sudoku.candidates((x,y))) == 1:
                #    attr  |= curses.A_UNDERLINE
                self._screen.addch(2 * y, 4 * x, ord('0') + abs(value), attr)

    def _print_string(self, string):
        self._screen.move(20, 0)
        self._screen.deleteln()
        self._screen.addstr(string)

    def _help(self):
        self._print_string("Commands: (q)uit, (p)opulate, (P)opulate, "
                           "(r)eset, (c)andidates, (s)olve")

    def main(self):
        x = 0
        y = 0
        self._help()
        while True:
            self._screen.move(y, x)
            c = chr(self._screen.getch())
            if c == ':':
                self._print_string(":")
                curses.echo()
                #self._screen.move(20, 0)
                c = self._screen.getstr()
                curses.noecho()
            if c == 'q':
                break  # Exit the while()
            elif c == 'h':
                self._help()
            elif c in ('p', 'P'):
                if c == 'P':
                    self._print_string("Enter number of fields: ")
                    curses.echo()
                    n = int(self._screen.getstr())
                    curses.noecho()
                else:
                    n = 36
                start = time.time()
                self._sudoku.populate(n)
                end = time.time()
                self._draw_sudoku()
                self._print_string("Populated with %d fields in %.3f seconds"
                                   % (n, end - start))
            elif c == 's':
                if not self._sudoku.solve():
                    self._print_string("Could not solve sudoku")
                self._draw_sudoku()
            elif c == 'r':
                self._sudoku = Sudoku()
                self._draw_sudoku()
            elif c == 'c':
                point = (x // 4, y // 2)
                self._print_string("Candidates for %s are: %s" %
                                   (point, self._sudoku.candidates(point)))
            elif c == chr(curses.KEY_LEFT):
                x -= x >= 4 and 4 or 0
            elif c == chr(curses.KEY_RIGHT):
                x += x + 4 < 4 * 9 and 4 or 0
            elif c == chr(curses.KEY_UP):
                y -= y >= 2 and 2 or 0
            elif c == chr(curses.KEY_DOWN):
                y += y + 2 < 2 * 9 and 2 or 0
            elif c in "0123456789":
                try:
                    self._sudoku[x // 4, y // 2] = ord(c) - ord('0')
                    self._screen.addch(y, x, c)
                    # If single-candidate cells should be highlighted, use the
                    # following instead of self._screen.addch():
                    #self._draw_sudoku()
                except Exception as e:
                    self._print_string(str(e))
                else:
                    if self._sudoku.is_solved():
                        self._print_string("Solved")
                    else:
                        self._print_string("")
            else:
                self._print_string("Error: Invalid command '%s'" % c)


if __name__ == '__main__':
    with CursesUI() as ui:
        ui.main()

[pm42]

J'ai trouvé ce code sur le net :

Sans les balises CODE autour, c'est illisible.
Pour le reste, c'est de la simulation d'un tableau à 2 dimensions de taille 3x3 avec le tableau à 1 dimension de taille 9 appelé _block.
C'est une méthode classique mais dont j'ai du mal à voir l'intérêt ici sauf au cas où cela serait plus performant mais j'ai un doute.

Globalement, c'est très médiocrement programmé.

[A voir en vidéo sur Futura]

[Jack]

Sans les balises CODE autour, c'est illisible.

En effet. C'est pourtant demandé et expliqué ici.

[Linuxman99]

Merci pour les balises

J'avais une autre question svp : quand on met des points de la forme : X.Y.Z en orienté objet cela veut dire qu'on cherche à lire ou modifier le paramètre Z (attribut) en passant par les classes Y puis Z ?

Merci

[umfred]

Merci pour les balises

J'avais une autre question svp : quand on met des points de la forme : X.Y.Z en orienté objet cela veut dire qu'on cherche à lire ou modifier le paramètre Z (attribut) en passant par les classes Y puis Z ?

Merci

puis X (pas Z ^^ )

[Linuxman99]

Je n'ai pas compris votre réponse

[umfred]

Relis ta phrase:

quand on met des points de la forme : X.Y.Z en orienté objet cela veut dire qu'on cherche à lire ou modifier le paramètre Z (attribut) en passant par les classes Y puis Z ?

X.Y.Z : accès à Z de l'objet/classe Y qui est un objet/classe de X (d'où mon "puis X (pas Z)" car tu as du faire une faute de frappe dans ton message en mettant 2 fois Z dans la phrase)

[pm42]

X.Y.Z : accès à Z de l'objet/classe Y qui est un objet/classe de X (d'où mon "puis X (pas Z)" car tu as du faire une faute de frappe dans ton message en mettant 2 fois Z dans la phrase)

En fait, c'est plus exactement et si c'est vraiment écrit comme ça : on a une variable X qui contient un objet. Cet objet un attribut Y d'une classe indéterminé qui contient un attribut Y.
Dans certains cas, cela peut aussi ne pas être des attributs mais des méthodes si on peut les appeler sans ().

En général également, on ne va pas avoir exactement ça parce que les langages les plus fréquents poussent ou forcent à ne pas utiliser de majuscules pour commencer un nom d'attribut ou de méthode.

Par rapport à la question initiale, un paramètre est très différent d'un attribut. Un paramètre, c'est quelque chose qu'on passe en entrée à une méthode. Un attribut, c'est un élément d'une classe.
Et on ne "passe PAS" par les classes : on passe par les attributs.
Quand on écrit x.y.z, le type réel de x, y et z n'est pas connu sauf exception et peut varier au fil du programme. Suivant le langage, ce qu'on sait, c'est soit le type de base de chaque attribut soit dans le cas de Python, que x est d'un type qui a un attribut y qui lui même est d'un type qui a un attribut z et rien de plus. Et ça, c'est si tout va bien : si le programmeur s'est trompé, ce n'est même pas le cas et on aura un message à l'exécution (là encore en python sauf à utiliser les indicateurs de type).

[Linuxman99]

oui c'est bien cela , merci

[Linuxman99]

est ce que cela peut se généraliser à plus de 3 imbrications genre X.Y.Z.T ? ou plus ?

Donc en résumé : la classe X contient un objet (association , agrégation composition , de type Y)
L'objet Y de la classe Y contient lui même un objet de la classe Z ) ?
ça peut auss être un accès par nom de classe et non pas par objet de classe lors des imports ?

X.Y.Z --> on accède à l'attribut Z qui est contenu dans la classe Y par le nom de la classe Y / cette classe est un objet de la classe ou l'objet X

Est-ce valable aussi ?

Merci

[pm42]

est ce que cela peut se généraliser à plus de 3 imbrications genre X.Y.Z.T ? ou plus ?

Autant qu'on veux. Bien sur cela devient moins lisible à chaque fois.

Donc en résumé : la classe X contient un objet (association , agrégation composition , de type Y)
L'objet Y de la classe Y contient lui même un objet de la classe Z ) ?

Tu mélanges nom de classe et nom d'attribut.

ça peut auss être un accès par nom de classe et non pas par objet de classe lors des imports ?

Je ne suis pas sur de ce que tu veux dire mais comme ça, cela n'a pas vraiment de sens.

X.Y.Z --> on accède à l'attribut Z qui est contenu dans la classe Y par le nom de la classe Y / cette classe est un objet de la classe ou l'objet X

Revoir les explications plus haut et la remarque sur le mélange entre attribut et classe.

[Linuxman99]

j'ai bien relu , mais ce que j'ai compris c'est qu'in attribut peut aussi être un objet d'une autre classe ?
corrigez moi si je me trompe .

[Linuxman99]

X.Y.Z pour moi veut dire :
Z : attribut (variable) qui fait partie d'une classe , appelons la classZ

Y est un objet de la la classY contient la classe Z dans ses attributs d'ou la possibilité d'accéder à l'objet Z .

La clasxe X , ici définir par un objet X , elle , contient dans ses attributs l'objet Y .

Merci

exemple :
Class carrefour , class rayon_fruits , class tomate

X = objet de carrefour
Y = Objet de rayon_fruits
Z = attribut de la class tomate

X.Y.Z pour moi si Z est définit = (tomate_grappe) c'est comme si on aura : carrefour.rayon_fruits.tomate_ grappe

Voilà mon raisonnement !!

les X et Y doivent forcément être des objets et le Z un attribut : soit variable soit methode

Merci
Je suis novice pour info

[pm42]

Y est un objet de la la classY contient la classe Z dans ses attributs d'ou la possibilité d'accéder à l'objet Z .

Tu continues à mélanger classe, attribut et objet. Tant que ce sera le cas, tu ne progresseras pas.

[Linuxman99]

EClaire moi , je n'arrive pas à te comprendre

[Ikhar84]

Une classe est un "moule" qui sert à forger des objets... Initiale en majuscule...

Un objet est une instanciation d'une classe, une "réalisation" d'une classe avec des "caractéristiques" précises, représentées par l'état (la valeur) de ses attributs... Initiale en minuscule...

Un attribut est une des caractéristiques d'une classe/d'un objet...
C'est à dire le truc qui avec son "état" va différencier un objet d'un autre ("visuellement, la vrai différenciation entre un objet et un autre est le fait qu'il aient une "réference" (une adresse en mémoire) différente...

Si tu parles d'un objet qui peut porter une couleur... la classe possède un attribut couleur... mais c'est l'objet qui instancie la classe qui aura un état (qui portera une couleur, le rouge par exemple...)...

Un attribut d'une classe peut lui même être un objet (et non une classe, car il sera nécessairement instancié) pour être crée/"prendre vie/moulé...

On peut "appeller" un attribut ou une méthode d'une classe "directement" sans avoir à instancier cette classe en un objet, mais c'est un mécanisme précis et qui ne peut être justifié que dans des cas précis...

Obtenir un String depuis un "nombre" en passant par une méthode "statique" de la classe String, par exemple (exemple assez foireux, mais si on imagine une type "primitif", comme un int (et non un Integer), pas moyen d'en appeller une méthode !

Résumé très simplifié et imagé !

[Linuxman99]

Une classe est un "moule" qui sert à forger des objets... Initiale en majuscule...

Un objet est une instanciation d'une classe, une "réalisation" d'une classe avec des "caractéristiques" précises, représentées par l'état (la valeur) de ses attributs... Initiale en minuscule...

Un attribut est une des caractéristiques d'une classe/d'un objet...
C'est à dire le truc qui avec son "état" va différencier un objet d'un autre ("visuellement, la vrai différenciation entre un objet et un autre est le fait qu'il aient une "réference" (une adresse en mémoire) différente...

Si tu parles d'un objet qui peut porter une couleur... la classe possède un attribut couleur... mais c'est l'objet qui instancie la classe qui aura un état (qui portera une couleur, le rouge par exemple...)...

Un attribut d'une classe peut lui même être un objet (et non une classe, car il sera nécessairement instancié) pour être crée/"prendre vie/moulé...

On peut "appeller" un attribut ou une méthode d'une classe "directement" sans avoir à instancier cette classe en un objet, mais c'est un mécanisme précis et qui ne peut être justifié que dans des cas précis...

Obtenir un String depuis un "nombre" en passant par une méthode "statique" de la classe String, par exemple (exemple assez foireux, mais si on imagine une type "primitif", comme un int (et non un Integer), pas moyen d'en appeller une méthode !

Résumé très simplifié et imagé !

Oui mais qu'est ce qui ne va pas avec la citation que j'ai faite de classe carrefour , rayon_fruit ...
je n'arrive pas à comprendre !

[umfred]

carrefour serait un objet créé à partir d'une classe supermarché, rayon_fruit un objet de la classe rayon, et tomate un objet de la classe produit par exemple

[Linuxman99]

merci beaucoup
donc c'est toujours objet1.objet2.objet1.attribut , si on veut accéder aux attributs , avec attribut faisaint partie de l'objet1 ?

Merci

[Linuxman99]

Tu continues à mélanger classe, attribut et objet. Tant que ce sera le cas, tu ne progresseras pas.

Tu peux me conseiller des projets python que je peux trouver sur internet intéressants ?

[pm42]

Tu peux me conseiller des projets python que je peux trouver sur internet intéressants ?

Je n'ai rien en tête parce que ce que j'ai fait en python, c'est de l'IA et c'est en général pas vraiment abordable pour un débutant.

[Linuxman99]

Je n'ai rien en tête parce que ce que j'ai fait en python, c'est de l'IA et c'est en général pas vraiment abordable pour un débutant.

Tu peux quand même partager le projet IA avec moi ?

[pm42]

Tu peux quand même partager le projet IA avec moi ?

Tu peux regarder la discussion ici et le code dans le lien : https://forums.futura-sciences.com/c...ml#post6604263

[Linuxman99]

merci ,
est ce que il y a un sens d'injecter une fonction dans une autre fonction en python ? avec self.function1
un bout de code du type :

x = function2 (x,y,self.function1)
je l'ai vu par hasard mais je sais si cela est juste

Merci encore

[pm42]

est ce que il y a un sens d'injecter une fonction dans une autre fonction en python ? avec self.function1

Bien sur, c'est même un grand classique. Par exemple, tu fais une interface graphique et dedans, il y a un bouton. Quand on presse sur ce bouton, tu veux qu'une fonction a toi soit appelée.
Et donc, tu passes cette fonction à la fonction qui va créer le bouton.

Autre exemple : tu veux trier un tableau d'objets en comparant par un attribut à toi. L'algorithme de tri existe déjà, il est dans la librairie standard mais il ne sait pas comment comparer tes objets.
Tu l'appelles donc en lui passant une fonction qui prend 2 objets et renvoie -1, 0, ou 1 suivant que le 1er est inférieur, égal ou supérieur au second. Et avec ça, l'algo de tri peut se débrouiller.

Il y a plein d'exemples dans ce genre.

[Linuxman99]

donc ou bien on appel une fonction dans une fonction , ou bien on appel la valeur de retour d'une fonction dans une fonction ,
y a t-il d'autres cas ?

Merci PM42

[Linuxman99]

c'est quoi la difference entre passer une fonction en paramètre dans une fonction et appeler cette fonction dans la fonction :

func1(x,y,func2)

func1(x,y):
-----func2()

[pm42]

c'est quoi la difference entre passer une fonction en paramètre dans une fonction et appeler cette fonction dans la fonction :

La réponse est dans la question : tu passes une fonction en paramètre et le receveur peut l'appeler.
C'est exactement comme de passer une variable et de lire son contenu.