How to update a initial var (balance) with a new one created in a function (newBalance?)

#pylint:disable=W0312
#python 3.6
from random import randint
import math

# Static Variables
START_BALANCE = 100
BAD_GUESS = "The guess must be a number between 1 and 6. Please try again."
BAD_BET = "The bet must be a number between 1 and {}."


#######
#
# Function: get_guess()
#
# Parameters: (none)
#
# Returns: an integer between 1 and 6
#
# This is where you ask the user for their guess on the result of the dice roll.
# Inside an infinite while loop, ask the user for a value from 1 to 6.
# If the user inputs a bad value (either something that isn't a number, or isn't 
# from 1 to 6, catch the error and print BAD_GUESS and continue to the next iteration 
# of the while loop, which will repeat the request for input and evaluate that.
# Once there is valid input (a number from 1 to 6), break out of the while loop
# and return that value.
#
#######

# Uncomment the definition when you're ready to work on building the function.
# def get_guess():
    # TODO: Build function per description above.


#######
#
# Function: get_bet(balance)
#
# Parameters: balance - an integer representing the user's current balance.
#
# Returns: an integer between 1 and the balance
#
# This is where you ask the user for their bet for this round.
# The structure is quite similar to get_guess(), except that the max number (balance)
# can change, so it needs that as a parameter.
# Inside an infinite while loop, ask the user for a value from 1 to the given balance.
# If the user inputs a bad value (either something that isn't a number, or isn't 
# from 1 to the balance, catch the error and print BAD_BET. Continue to the next iteration 
# of the while loop, which will repeat the request for input and evaluate that.
# Once there is valid input (a number from 1 to current balance), break out of the while loop
# and return that value.
#
#######

# Uncomment the definition when you're ready to work on building the function.
# def get_bet(balance):
    # TODO: Build function per description above.

#######
#
# Function: diceRoll(balance)
#
# Parameters: balance - an integer with the current balance
#
# Returns: a list of two items: 
#               [boolean - True if user wants to play again, False if not,
#                balance - integer with the new balance based on outcome of this round.]
#          The format of this list matches the variable game_state defined
#          outside of this function. 
#
# This is where you actually roll the dice and compare that to what the user guessed.
# If they lose the bet, they don't get their bet money back.
# If they win the bet, the get the bet * 1.75 back.
# Then the user is asked if they want to play again.
# This function returns a list indicating if the player wants another round (True if yes, 
# False if no), and the latest balance after this round.
#
#######

#### FUNC START ####
# Pass the current balance to diceRoll so it doesn't reset every time you run it,
# which was the original problem with your code.
def diceRoll(balance): 

    # TODO: Use the get_guess function to get a guess from the user, and assign it 
    # to a variable called guess.

    # TODO: Use the get_bet function to get a bet from the user, and assign it 
    # to a variable called bet.

    # TODO: Subtract the bet from the balance for this round, i.e., reduce the balance
    # by the amount of the bet.


### Roll the dice
    roll = randint(1,6)

# LSG Comment: You don't need variables to track whether the game was won or not
# so I took all that out. Below is what's left of your original code, with some commenting
# on what you need to add. 

### IF PLAYER WINS ###
    if (roll == guess):
        prize = bet * 1.75
        balance += prize
        #
        print("\nYOU WIN {}$!".format(prize))
        print("You guessed: {} - The roll was {}!\n".format(guess, roll))
        print("-- Your balance is now {}$ -- \n".format(balance))


### IF PLAYER LOSES ###
    elif (roll != guess): # This can be just else: but I guess it doesn't really matter.
        #
        print("\nYOU LOSE {}$".format(bet))
        print("The roll was: {} - You guessed: {}.".format(roll,guess))
        print("-- Your balance is now {}$ --\n".format(balance))
        # LSG: No need to subtract from the balance again, so that code was removed. The bet was
        # already removed from the balance earlier.

### ASK PLAYER TO PLAY AGAIN ###
    # This is mostly your old code, but with some tweaks, e.g., switch to upper() rather than title()
    choice = input("Would you like to try again?  Y/N   ").upper()
    if (choice == "YES" or choice == "Y"):
        print("New round! Your balance is {}$".format(balance))

        # TODO: return a list where the first item is the bool True, and the second item is the balance.
        # This is the updated info that will go into the game_state variable outside this function.


    else: # You originally had an elif, but basically anything other than "YES" or "Y" means no, and simplifies error checking.
        print("GAME OVER !")

        # TODO: return a list where the first item is the bool False, and the second item is the balance.
        # This is the updated info that will go into the game_state variable outside this function.


### CALL FUNCTION ###

# Initialize game_state, which is a variable that keeps track of your rounds and balance.
game_state = [True, START_BALANCE]

# TODO: Build a while loop that executes any time the first item in game_state is True (i.e., while the
# user still wants to play a new round. Note that I initialized game_state[0] to True, assuming that 
# if they started the program, they want to play the first round.

    # TODO: Inside the while loop, call diceRoll with the balance, which is the second list item in game_state.
    # Note that diceRoll is going to return an updated list for you to plug into game_state, so make sure you grab
    # that, i.e., don't just call diceRoll(balance) without assigning it to game_state.