Des objets en Python 3

# !/usr/bin/env python3
# -*-coding:utf-8-*
# LessOrMorePython.py

"""
Less or More game, made by Poliorcetics.

First version has been made with the C programming language, but this version
is made with Python 3.4.3 because I want learn it.

Copyright (c) Poliorcetics, 2015. All rights reserved.
"""

# Import randrange to use it in random initialization
import random as ran

###############################################################################
# 'Infos' class
###############################################################################

class Infos(object):
    """
    'Infos' class
    =============

    Contains some informations about the game and the author

    Variables
    ---------

    [String]
     - author : contains informations about the author
     - version : contains the version number
     - copyright : contains informations about the copyright

    [Tuple]
     - all_infos : contains all the previous informations in a tuple
    """

    author = "Poliorcetics, alias Alexis B."
    version = "0.2.1"
    copyright = "Copyright © Poliorcetics, 2015. All rights reserved."
    all_infos = (author, version, copyright)


###############################################################################
# 'Game' class, main class.
###############################################################################

class Game(object):
    """
    'Game' class
    ============

    Contains all of what is basically needed by the game to run.

    Variables
    ---------

    [String]
     - player_name : deprecated right now (line is commented)

    [Tuple]
     - infos : contains informations about the author, the version and the copyright.
                See more by looking at the documentation of the Infos class.

    Functions
    ---------

    The ‘self,’ is omitted in all functions, but it's the first argument everywhere
    (if you use the function outside the class, it doesn't need to be write)

    - introduceGame() : just here to display the title of the game
    - displayRules() : displays the rules
    - chooseDifficulty() : return the choice of the player for the difficulty level
    - computeSearchedNumber(dif, top): create the mysterious number and return it
    - defineTopOfTheRange(dif) : return the top of the range, corresponding to the selected difficulty
    - isLessOrMore(t_nb, s_nb) : displays if the typed number is higher or lower than the searched number
    - searchNumber(s_nb, top) : let the player searching what is the searched number
    - ending(inf) : displays some informations about author, version and copyright

    All functions have their own documentation, look at it for more informations
    """

    # player_name = "Default"
    infos = Infos.all_infos

    def introduceGame(self):
        """Introduces the game with a simple shell display"""

        print("         \n---------------------------")
        print("         >>> Less Or More Game ! <<<")
        print("         ---------------------------\n")


    def displayRules(self):
        """
        Displays the rules of the Less Or More Game. No arg needed, no return.
        """

        print("-- Rules --");
        print("1. The game will create a mysterious number.")
        print("2. The game will ask you to enter a number.")
        print("3. This number MUST BE included in the range \
corresponding to the selected difficulty.")
        print("4. This number MUST BE an integer, like 42 and unlike 3.1415.")
        print("5. If the number you type is in range and is higher \
than the searched number, the game will say \"That's less !\", else it will \
say \"That's more !\".")
        print("6. You have to find the mysterious number with a minimum \
number of tests.")

    def chooseDifficulty(self):
        """
        Displays the difficulty options and returns the player's choice.

        Return 1, 2 or 3.
        """

        dif = 0

        # Displays possible choices for the difficulty
        print("\n-- Difficulty --");
        print("1 : Mysterious number is in range [1;100]")
        print("2 : Mysterious number is in range [1;1000]")
        print("3 : Mysterious number is in range [1;10000]\n")
        print(">> To choose a difficulty, enter 1, 2 or 3.")

        # Asks the user to know what he want
        while not(0 < dif < 4):
            dif = input("Please choose a difficulty : ")
            try:
                dif = int(dif)
            except ValueError:
                dif = 0
            else:
                dif = int(dif)

        return dif

    def computeSearchedNumber(self, dif, top):
        """
        Return 'searched_number' (INT), that the player will have to find to win

        - 'dif' : INT, represents the choosen difficulty
        - 'top' : INT, represents the maximum possible value for the searched number
        """

        # Game displays that it is computing for 'searched_number'
        print("\nCalculation of the mysterious number ...")

        if dif == 1:
            # +1 : to make the true range
            searched_number = ran.randrange(top)+1
        elif dif == 2:
            searched_number = ran.randrange(top)+1
        else: # dif == 3
            searched_number = ran.randrange(top)+1

        # Game lets the user know that it finished to compute searched number
        print("Finished ! \n")

        # Uncomment to get the answer before playing (use it only for tests please)
        print(searched_number, "\n")

        return searched_number

    def defineTopOfTheRange(self, dif):
        """
        Return 'top_of_the_range' (INT), the maximum possible value for the searched number

        - 'dif' : INT, represents the choosen difficulty
        """

        if dif == 1:
            top_of_the_range = 100
        elif dif == 2:
            top_of_the_range = 1000
        else:
            top_of_the_range = 10000

        return top_of_the_range

    def isLessOrMore(self, t_nb, s_nb):
        """
        Displays if the typed number 't_nb' is lower or higher than the searched number 's_nb'

        Returns False if t_nb != s_nb, else True
        """

        if t_nb > s_nb:
            print("\nThat's less !\n")
            return False
        elif t_nb < s_nb:
            print("\nThat's more !\n")
            return False
        else: # t_nb == s_nb
            print("\nCongratulations ! You found the searched number !\n")
            return True

    def searchNumber(self, s_nb, top):
        """
        Return the number of attempts 'nb_of_tests' the player made to found the searched number 's_nb'

        - 's_nb' : INT, the number the player have to find
        - 'top' : INT, represents the maximum possible value for the searched number (and the typed number)

        While the player does not enter the searched number, this function will keep going, asking the player again and again.
        """

        nb_of_tests = 0
        t_nb = 0

        # Begin the real game : the player will have to enter a number and
        # to find the searched number
        while t_nb != s_nb:

            # Player enters an integer that MUST BE included in the choosen range
            while not(0 < t_nb <= top) or not(position):

                nb_of_tests += 1 # every attempt is counted
                t_nb = input("Please, enter an integer in range [1:{}] ".format(top))

                # Checks if the typed number is in range and an integer
                try:
                    t_nb = int(t_nb)
                except (ValueError, TypeError):
                    pass
                    t_nb = 0
                    print("An integer in the range please.")
                else:
                    t_nb = int(t_nb)
                    if (0 < t_nb <= top):
                        break
                    else:
                        print("An integer in the range please.")

            # Displays to the player if he is lower or higher compare to the searched number
            position = Game.isLessOrMore(self, t_nb, s_nb)

        return nb_of_tests

    def ending(self, inf):
        """
        Displays the informations about the author, the version and the copyright.

        - 'inf' : TUPLE, contains the informations. See the 'Infos' class to learn more about it.
        """

        print("Made with Python 3.4.3 and <3 by {}.".format(inf[0]))
        print("Version {}, {cop}\n".format(inf[1], cop=inf[2]))


# If this file is lauched directly, the game begin
if __name__ == "__main__":

    game = Game()

    game.introduceGame()
    game.displayRules()

    difficultyLevel = game.chooseDifficulty()
    top_of_the_range = game.defineTopOfTheRange(difficultyLevel)
    searched_number = game.computeSearchedNumber(difficultyLevel, top_of_the_range)

    game.searchNumber(searched_number, top_of_the_range)

    game.ending(Game.infos)

# !/usr/bin/env python3
# -*-coding:utf-8-*

import random as ran


class Game:
    __author__ = "Poliorcetics, alias Alexis B."
    __version__ = "0.2.1"
    __copyright__ = "Copyright © Poliorcetics, 2015. All rights reserved."

    _maxis = [100, 1000, 10000]

    def introduceGame(self):
        print("         \n---------------------------")
        print("         >>> Less Or More Game ! <<<")
        print("         ---------------------------\n")

    def displayRules(self):
        print("-- Rules --");
        print("1. The game will create a mysterious number.")
        print("2. The game will ask you to enter a number.")
        print("3. You have to find the mysterious number with a minimum \
number of tests.")

    def chooseDifficulty(self):
        # Displays possible choices for the difficulty
        print("\n-- Difficulty --");
        for i, maxi in enumerate(self._maxis):
            print("%d : Mysterious number is in range [1;%d]" % (i + 1, maxi))
        print()

        level = None
        # Asks the user to know what he want
        while level not in range(len(self._maxis)):
            level = input(">> Please choose a difficulty : ")
            try:
                level = int(level) - 1
            except ValueError:
                pass

        self.top_on_the_range = self._maxis[level]
        self.searched_number = ran.randint(1, self.top_on_the_range)

    def isLessOrMore(self, t_nb):
        if t_nb > self.searched_number:
            print("\tThat's less !")
        elif t_nb < self.searched_number:
            print("\tThat's more !")
        else: # t_nb == self.searched_number
            print("\tCongratulations ! You found the searched number !")

    def searchNumber(self):
        s_nb = self.searched_number
        top = self.top_on_the_range
        nb_of_tests = 0
        t_nb = 0

        # Begin the real game : the player will have to enter a number and
        # to find the searched number
        while t_nb != s_nb:

            # Player enters an integer that MUST BE included in the choosen range
            while True:

                nb_of_tests += 1 # every attempt is counted
                t_nb = input(">> Please, enter an integer in range [1:{}] ".format(top))

                # Checks if the typed number is in range and an integer
                try:
                    t_nb = int(t_nb)
                except (ValueError, TypeError):
                    pass
                else:
                    if 0 < t_nb <= top:
                        break
                    else:
                        print("An integer in the range please.")

            # Displays to the player if he is lower or higher compare to the searched number
            self.isLessOrMore(t_nb)

        print("Finished in %d attempts" % nb_of_tests)

    def ending(self):
        print("Made with Python 3.4.3 and <3 by {}.".format(self.__author__))
        print("Version {}, {cop}\n".format(self.__version__, cop=self.__copyright__))


# If this file is lauched directly, the game begin
if __name__ == "__main__":
    game = Game()
    game.introduceGame()
    game.displayRules()
    game.chooseDifficulty()
    game.searchNumber()
    game.ending()

from random import randint

class Game:
    def __init__(self, level):
        self.level = level

    def __askNumber(self):
        while True:
            value = input("Entrer un nombre : ")
            if value.isdigit():
                break
        return int(value)
    
    def __askPlay(self):
        result = input("Voulez-vous rejouer ? [yes/no] : ").lower()
        if result != 'yes':
            self.game = False
    
    def __displayResult(self, n):
        if n < self.number:
            res = "Plus"
        elif n > self.number:
            res = "Moins"
        else:
            res = "Gagné !"
            
        print(res)
        
    def play(self):
        self.game = True
        while self.game:
            self.number = randint(0, self.level+1)
            numberUser = None
            while numberUser != self.number:
                numberUser = self.__askNumber()
                self.__displayResult(numberUser)
            self.__askPlay()

game = Game(100)
game.play()

# !/usr/bin/env python3
# -*-coding:utf-8-*

class Exemple():

    def __init__(self):

        test = "I'm  a test"

    def print_test(self):

        print(self.test)


exe = Exemple()
exe.print_test()

Traceback (most recent call last):
  File "<string>", line 29, in <module>
  File "<string>", line 26, in print_test
AttributeError: Exemple instance has no attribute 'test'