Python Forum

# hghscores - start

def deserialize(fileName):
    exists = os.path.isfile(fileName)
    if exists:
        # Store configuration file values
        f = open(fileName, 'r')
        board = json.load(f)
        f.close()    
    else:
        # Keep presets
        board = Scoreboard()
        
    return board


def serialize(fileName, players):
    f = open(fileName, 'w')
    json.dump(players, f)
    f.close()


class GameEntry:
  """Represents one entry of a list of high scores."""

  def __init__(self, name, score):
    """Create an entry with given name and score."""
    self._name = name
    self._score = score

  def get_name(self):
    """Return the name of the person for this entry."""
    return self._name
    
  def get_score(self):
    """Return the score of this entry."""
    return self._score

  def __str__(self):
    """Return string representation of the entry."""
    return '({0}, {1})'.format(self._name, self._score) # e.g., '(Bob, 98)'


class Scoreboard:
  """Fixed-length sequence of high scores in nondecreasing order."""

  def __init__(self, capacity=10):
    """Initialize scoreboard with given maximum capacity.

    All entries are initially None.
    """
    self._board = [None] * capacity        # reserve space for future scores
    self._n = 0                            # number of actual entries

  def __getitem__(self, k):
    """Return entry at index k."""
    return self._board[k]

  def __str__(self):
    """Return string representation of the high score list."""
    return '\n'.join(str(self._board[j]) for j in range(self._n))

  def add(self, entry):
    """Consider adding entry to high scores."""
    score = entry.get_score()

    # Does new entry qualify as a high score?
    # answer is yes if board not full or score is higher than last entry
    good = self._n < len(self._board) or score > self._board[-1].get_score()

    if good:
      if self._n < len(self._board):        # no score drops from list
        self._n += 1                        # so overall number increases

      # shift lower scores rightward to make room for new entry
      j = self._n - 1
      while j > 0 and self._board[j-1].get_score() < score:
        self._board[j] = self._board[j-1]   # shift entry from j-1 to j
        j -= 1                              # and decrement j
      self._board[j] = entry                # when done, add new entry


def scoreRecord(username, points):
    board = deserialize("hightscores.txt")

    entry = GameEntry(username, points)
    board.add(entry)
            
    serialize("hightscores.txt", board)
        
    return board
       

import json


class Foo(object):

    def __init__(self):
        self.a = 1
        self.b = 1

    def __json__(self):
        return dict(a=self.a, b=self.b)


class MyUniversalEncoder(json.JSONEncoder):
    def default(self, obj):
        if hasattr(obj, "__json__"):
            return obj.__json__()
        return json.JSONEncoder.default(self, obj)


f = Foo()
print json.dumps(f, cls=MyUniversalEncoder)

Quote:is any python 3 serializer/deserializer build-in func to store the object Scoreboard in file txt

import jsonpickle

class GameEntry:
  """Represents one entry of a list of high scores."""
  def __init__(self, name, score):
    """Create an entry with given name and score."""
    self.name = name
    self.score = score

  def __str__(self):
    """Return string representation of the entry."""
    return f'({self.name}, {self.score})' # e.g., '(Bob, 98)'

obj = GameEntry('Bob', 98)
frozen = jsonpickle.encode(obj)

# To disk
with open('score.json', 'w') as j_out:
    print(frozen, file=j_out)

# From disk
with open('score.json') as j:
    frozen_obj = jsonpickle.decode(j.read())

>>> frozen_obj.name
'Bob'
>>> frozen_obj.score
98

>>> print(frozen_obj)
(Bob, 98)

(Jul-31-2019, 10:10 AM)fishhook Wrote: [ -> ]

Quote:is any python 3 serializer/deserializer build-in func to store the object Scoreboard in file txt

What do you think json.dump does?

(Jul-31-2019, 04:41 PM)lsepolis123 Wrote: [ -> ]

(Jul-31-2019, 10:10 AM)fishhook Wrote: [ -> ]What do you think json.dump does?

If I want save... use binary or text file ?

class Foo:
   pass

a = Foo()

def log(text):
    print(text)

a.log = log

a.log("foo")

def deserialize(fileName):
    # From disk
    with open(fileName) as j:
        frozen_obj = jsonpickle.decode(j.read())
    return frozen_obj

def serialize(fileName, frozen):
    # To disk
    with open(fileName, 'w') as j_out:
        print(frozen, file=j_out)
    


if __name__ == '__main__':
  for e in (
    ('Rob', 750), ('Mike',1105), ('Rose', 590), ('Jill', 740),
    ('Jack', 510), ('Anna', 660), ('Paul', 720), ('Bob', 400),
    ):
    ge = GameEntry(e[0], e[1])
    frozen = jsonpickle.encode(ge)

    serialize("hightscores.json", frozen)

// how to append with jsonpickle... above add only last one... well? Also How get all users back, after append all in json to file?
// hightscores.json
{"_name": "Bob", "_score": 400, "py/object": "__main__.GameEntry"}