How to pass arguments by value in Python?

This problem reported in the question does not exist, the code only fails because the condition is wrong.

There are other problems later in the code that is not the focus of this question.

def somentenumeros(entrada):
    try:
        int(entrada)
        return True
    except:
        return False

while True:
    cpf = input('Digite seu CPF ou digite os nove primeiros digitos ')
    if not somentenumeros(cpf) or (len(cpf)!= 9 and len(cpf) != 11):
        print('Erro. O valor digitado era inválido.')
    else:
        break
print(cpf)

See running on ideone . And Coding Ground . Also put it on GitHub for future reference .

In theory:

A basic search on the internet, I found this response :

  

Python passes references-to-objects by value (like Java), and everything in Python is an object. This sounds simple, but then you will notice that some data types seem to exhibit pass-by-value characteristics, while others seem to act like pass-by-reference ... what's the deal?

     

It is important to understand mutable and immutable objects. Some objects, like strings, tuples, and numbers, are immutable. Altering them inside a function / method will create a new instance and the original instance outside the function / method is not changed. Other objects, like lists and dictionaries are mutable, which means you can change the object in-place. Therefore, altering an object inside a function / method will also change the original object outside.

Free translation:

  

Python passes reference to objects by value (as Java) and everything in Python is an object. This seems simple, but then you'll notice that some data types seem to have been passed by value while others seem to be passed by reference.

     

It is important to understand what are mutable and immutable objects. Some objects, such as strings, tuples, and numbers are immutable. Changing them within a function will create a new instance of the referenced type, keeping the original instance unchanged. Other objects such as lists and dictionaries are changeable, which means that you change the object within the function will be reflected to the external object.

In practice:

Consider the following code:

value = 1

def function (value):

  # Exibe as informações da variável antes da mutação
  print("Dentro da função, antes da mutação:", type(value), id(value), value)

  # Mutação da variável
  value = 0

  # Exibe as informações da variável depois da mutação
  print("Dentro da função, depois da mutação:", type(value), id(value), value)


# Exibe as informações da variável antes da função
print("Fora da função, antes da mutação:", type(value), id(value), value)

# Chama a função
function(value)

# Exibe as informações da variável depois da função
print("Fora da função, depois da mutação:", type(value), id(value), value)

Its output is:

Fora da função, antes da mutação:    <type 'int'> 17355096 1
Dentro da função, antes da mutação:  <type 'int'> 17355096 1
Dentro da função, depois da mutação: <type 'int'> 17355120 0
Fora da função, depois da mutação:   <type 'int'> 17355096 1

Note that the value of the third column, the result of the id function, is the memory address of the variable. Before the function, the variable is at 17355096; when passed by parameter to the function, the address is retained, since a reference to the object is actually passed; after the mutation, the address becomes 17355120, because the type int is immutable and changing it generates a new instance; finally, out of function, the address remained the original, as well as its value 1.

Running the same code for a list:

value = [1]

def function (value):

  # Exibe as informações da variável antes da mutação
  print("Dentro da função, antes da mutação:", type(value), id(value), value)

  # Mutação da variável
  value.append(2)

  # Exibe as informações da variável depois da mutação
  print("Dentro da função, depois da mutação:", type(value), id(value), value)


# Exibe as informações da variável antes da função
print("Fora da função, antes da mutação:", type(value), id(value), value)

# Chama a função
function(value)

# Exibe as informações da variável depois da função
print("Fora da função, depois da mutação:", type(value), id(value), value)

You have the output:

Fora da função, antes da mutação:    <type 'list'> 140643613447880 [1]
Dentro da função, antes da mutação:  <type 'list'> 140643613447880 [1]
Dentro da função, depois da mutação: <type 'list'> 140643613447880 [1, 2]
Fora da função, depois da mutação:   <type 'list'> 140643613447880 [1, 2]

Notice that the memory address remained the same at all steps, and the changed value inside the function was reflected out of it. This happened because the type list is changeable and changes in the object do not generate new instances.