transfer value (a.k.a score) in bge from scene to another in BGE
As these game status is part of your game model I strongly suggest to keep it in a way that does not get removed with the scene.

There are many ways to do that (e.g. use an overlay scene that you keep during the game).

Here is a more practical approach:

Store your game model in Python

To do so you need a Python structure to keep your data:

model.py

class GameModel():
   def __init__(self):
      self.points = 0

model = GameModel()


I hope you see it keeps the number of collected points starting with zero. This storage is your model. But you need some operations on it. Lets say you want to show the points in a scene via a text object. So lets add a points viewer - e.g. call it "Points.viewer":

Always sensor [no level trigger!] 
    --&gt; Python Controller Module: viewer.pointsToText




viewer.py

import model
import bge

def pointsToText():
    getOwner().text = "{:d}".format(model.points)

def getOwner():
    return bge.logic.getCurrentController().owner


This should be enough to show the "0" somewhere at the screen.

Now we need operations that change the points in the model. Lets say you want to add 10 points after the user gives the right answer.

Sensor that evaluates true when points should be added
    --&gt; Python Controller Module: controller.addValueToPoints 
        --&gt; Property Actuator value: 10




Attention: The following code expects a single Property actuator that has the points to add in the Value field! The actuator will not be activated by the Python controller.

controller.py

import model
import bge

SUBJECT_POINTS_CHANGED = "points changed"    

def addValueToPoints():
    if not allSensorsPositive():
        return

    points = getPointsToAdd()
    model.points += points
    notifyPointsChanged()

def allSensorsPositive():
    for sensor in bge.logic.getCurrentController().sensors:
        if not sensor.positive:
            return False
    return True

def getPointsToAdd():
    actuator = bge.logic.getCurrentController().actuators[0]
    return int(actuator.value)

def notifyPointsChanged():
    bge.logic.sendMessage(SUBJECT_POINTS_CHANGED)


You might see that this code sends a notification message after changing the points in the model. While this is not necessary to update the model with the new value, it is an efficient way to tell all interesting objects that the points changed. This way any point viewing object can update itself and show the new values.  So lets do that and add the according logic to the above "Points.viewer":

Always sensor [no level trigger!] 
+
Message sensor [True Level Triggering] Subject "points changed"
    --&gt; Python Controller Module: viewer.pointsToText




These are the basics. 

Summary:


You can store the points in a model that is stored in an separate Python module.
You can retrieve the points from the model.
You can add points to the model.
You notify interested objects when the points change.


With the same approach you can store other model data and add more operations (such as saving to a file). 


Model: describes the game status (at least the important parts of it)
Viewer: presents the data of the model to the audience
Controller: processes input from outside and changes t


The model will exist until the game dies.

I hope it helps