What you want isn't directly possible in JSON, because it doesn't support "templating".

One solution would be to use a templating language such as Jinja to write a JSON template, then load this file without the json library and fill in the values using Jinja, and finally use json.loads to load a dictionary from your rendered string.

Your json-like file could look something like this:

Copy{"path_to_folder": "/Users/{{ user_name }}/my_folder/"}

Your Python code:

Copyimport json
from jinja2 import Environment, FileSystemLoader

env = Environment(
    FileSystemLoader("path/to/template")
)
template = env.get_template("template_filename.json")

def print_json(username):
    return json.loads(
        template.render(user_name=username)
    )
...

In fact, if this is a simple one-time thing, it might even be better to use Python's built-in templating. I would recommend old-style formatting in the case of JSON, because otherwise you'll have to escape a lot of braces:

JSON file:

Copy{"path_to_folder": "/Users/%(user_name)s/my_folder/"}

"Rendering":

Copywith open("path/to/json") as f:
    rendered = json.loads(f.read() % {"user_name": username})

This looks like a homework question - you should make that clear in your question.

I know it isn't possible to pass a JSON object directly to another function

There is no "JSON object" you have a python list that contains a python dictionary. json.dumps turns that list into a JSON string and json.loads(string) takes that string and returns a python list.

You can pass your userList to the function. Or if this is homework and you are required to pass a JSON string you use json.dumps to convert your list to a JSON string first:

import json

userList = [{"username": 'userName', "email": 'email'}]

listString = json.dumps(userList)

def foo(jsonstring):
  lst = json.loads(jsonstring)
  lst[0]["username"] = "Alex"
  return lst

newList = foo(listString)

print(newList)

The output is:

[{'username': 'Alex', 'email': 'email'}]

After your edit I see the problem in your code. Do you see what you did?

tl;dr: You're right that Python's semantics are essentially Java's semantics, without any primitive types.

"Passed by assignment" is actually making a different distinction than the one you're asking about.¹ The idea is that argument passing to functions (and other callables) works exactly the same way assignment works.

Consider:

def f(x):
    pass
a = 3
b = a
f(a)

b = a means that the target b, in this case a name in the global namespace, becomes a reference to whatever value a references.

f(a) means that the target x, in this case a name in the local namespace of the frame built to execute f, becomes a reference to whatever value a references.

The semantics are identical. Whenever a value gets assigned to a target (which isn't always a simple name—e.g., think lst[0] = a or spam.eggs = a), it follows the same set of assignment rules—whether it's an assignment statement, a function call, an as clause, or a loop iteration variable, there's just one set of rules.

But overall, your intuitive idea that Python is like Java but with only reference types is accurate: You always "pass a reference by value".

Arguing over whether that counts as "pass by reference" or "pass by value" is pointless. Trying to come up with a new unambiguous name for it that nobody will argue about is even more pointless. Liskov invented the term "call by object" three decades ago, and if that never caught on, anything someone comes up with today isn't likely to do any better.

You understand the actual semantics, and that's what matters.

And yes, this means there is no copying. In Java, only primitive values are copied, and Python doesn't have primitive values, so nothing is copied.

the only difference is that 'primitive types'(for example, numbers) are not copied, but simply taken as objects

It's much better to see this as "the only difference is that there are no 'primitive types' (not even simple numbers)", just as you said at the start.

It's also worth asking why Python has no primitive types—or why Java does.²

Making everything "boxed" can be very slow. Adding 2 + 3 in Python means dereferencing the 2 and 3 objects, getting the native values out of them, adding them together, and wrapping the result up in a new 5 object (or looking it up in a table because you already have an existing 5 object). That's a lot more work than just adding two ints.³

While a good JIT like Hotspot—or like PyPy for Python—can often automatically do those optimizations, sometimes "often" isn't good enough. That's why Java has native types: to let you manually optimize things in those cases.

Python, instead, relies on third-party libraries like Numpy, which let you pay the boxing costs just once for a whole array, instead of once per element. Which keeps the language simpler, but at the cost of needing Numpy.⁴

1. As far as I know, "passed by assignment" appears a couple times in the FAQs, but is not actually used in the reference docs or glossary. The reference docs already lean toward intuitive over rigorous, but the FAQ, like the tutorial, goes much further in that direction. So, asking what a term in the FAQ means, beyond the intuitive idea it's trying to get across, may not be a meaningful question in the first place.

2. I'm going to ignore the issue of Java's lack of operator overloading here. There's no reason they couldn't include special language rules for a handful of core classes, even if they didn't let you do the same thing with your own classes—e.g., Go does exactly that for things like range, and people rarely complain.

3. … or even than looping over two arrays of 30-bit digits, which is what Python actually does. The cost of working on unlimited-size "bigints" is tiny compared to the cost of boxing, so Python just always pays that extra, barely-noticeable cost. Python 2 did, like Java, have separate fixed and bigint types, but a couple decades of experience showed that it wasn't getting any performance benefits out of the extra complexity.

4. The implementation of Numpy is of course far from simple. But using it is pretty simple, and a lot more people need to use Numpy than need to write Numpy, so that turns out to be a pretty decent tradeoff.

Your issue is not with loading the json data into products variable. After loading, you are trying to retrieve values from products in an incorrect manner which leads to Key Error. Your products is basically a dictionary of list of dictionary

Here is the correct way to retrieve necessary values from products:

print(products['products'][0]['id'])
#632910392
print(products['products'][0]['title'])
#IPod Nano - 8GB
print(products['products'][0]['variants'][0]['product_id'])
#632910392

Try analysing the deep structure of your products variable so that you can learn to retrieve any value in it by yourself. Cheers!

This depends a lot on your security goals, and on what kind of user interface you want to offer to the author of these expressions.

Loading variables into the local scope does work, since Python is a very dynamic language. There's a risk though that the variables might re-define existing objects, thus breaking your code – what if there's a variable called len, for example?

Therefore, it's usually safer to avoid running the user input in a Python context. Instead:

• define a simple programming language for these expressions
• write an interpreter that executes the expressions

Python does have tools to help here. We can parse strings as Python code via the ast module. This returns a data structure that represents the syntax, and doesn't execute anything (though the parser isn't necessarily safe against malicious inputs). We can take the data structure, walk it, and execute it according to the rules we define – such as by resolving variables only from a dictionary. Example code for Python 3.10:

import ast

def interpret(code: str, variables: dict) -> dict:
  module: ast.Module = ast.parse(code, mode='exec')
  for statement in module.body:
    _interpret_statement(statement, variables)
  return variables

def _interpret_statement(statement: ast.stmt, variables: dict) -> None:
  match statement:
    case ast.Assign(targets=[ast.Name(id=name)], value=value):
      variables[name] = _interpret_expr(value, variables)
      return

    case other:
      raise InterpreterError("Syntax not supported", other)

def _interpret_expr(expr: ast.expr, variables: dict) -> Any:
  match expr:
    case ast.BinOp(left=left_ast, op=op, right=right_ast):
      left = _interpret_expr(left_ast, variables)
      right = _interpret_expr(right_ast, variables)
      return _interpret_binop(left, op, right)

    case ast.Name(id=name):
      return variables[name]

    case ast.Constant(value=(int(value) | float(value))):
      return value

    case other:
      raise InterpreterError("Syntax not supported", other)
    

def _interpret_binop(left: Any, op: ast.operator, right: Any) -> Any:
  match op:
    case ast.Add(): return left + right
    case ast.Sub(): return left - right
    case ast.Mult(): return left * right
    case ast.Div(): return left / right
    case ast.Pow(): return left**right
    case other:
      raise InterpreterError(
        "Operator not supported",
        ast.BinOp(ast.Name("_"), other, ast.Name("_")))

class InterpreterError(Exception):
  def __init__(self, msg: str, code: Optional[ast.AST] = None) -> None:
    super().__init__(msg, code)
    self._msg = msg
    self._code = code

  def __str__(self):
    if self._code:
      return f"{self._msg}: {ast.unparse(self._code)}"
    return self._msg

This can then be used to interpret commands, returning a dictionary with all the variables:

>>> interpret("z = x**2+y**2", {"x": 3, "y": 2})
{'x': 3, 'y': 2, 'z': 13}

While this allows you to interpret the Python code however you want (you control the semantics), you are still limited to Python's syntax. For example, you should use the ** operator for exponentiation, not Python's ^ xor-operator.

If you want your own syntax, then you'll probably have to write your own parser. There are a variety of parsing algorithms and parser generators, but I'm partial to hand-written “recursive descent”. This generally involves writing recursive functions of the form parse(Position) -> Optional[tuple[Position, Value]] that gradually consume the input. I have written an example parser and interpreter using that strategy, and have previously contrasted different parsing approaches in an answer about implementing query languages in a Python program.

You have to pass each key as a separate argument (or as a list of separate arguments).

def my_function(obj, *fields):
    for f in fields:
        try:
            obj = obj[f]
        except KeyError:
            logging.exception("Exceptoin: ")
            return
    return obj

my_function(my_json, "DataChangedEntry", "CurrentValue", ...)