Python – Confusion regarding def function within Python

coding-stylefunctionslanguage-featurespythonsyntax

I've been learning Python for about 2 months now (Started with Learn Python The Hard Way, now reading Dive Into Python), and within both books, I still seem to be confused over this one bit of code.

Lets just take the default code that Dive Into Python uses as an example:

def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.


    Returns string."""
    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

if __name__ == "__main__":
    myParams = {"server":"mpilgrim",
                "database":"master",
                "uid":"sa",
                "pwd":"secret"
               }

print buildConnectionString(myParams)

How does the function buildConnectionString with the argument (params) know to get its data from the variable myParams? Or params.items(), too within the return line? Wouldn't the argument in buildConnectionString need to be set as buildConnectionString(myParams) in order for it to read properly? How can you set the variable of your data to myParams, but have the argument of your function be params and have it read? How does it know to read myParams as params?

And is there a reason behind not naming your variable params, or vice versa naming your argument in your function myParams? It's just been extremely confusing seeing the argument set as one word, and then having the variable named something completely different, but having the function still be able to read your code, even when the argument name is different from your variable with the data you're printing from.

Best Answer

It's not about Python.

But nevertheless, to answer you straightly. Lets say you have a function:

def doSomethingWithParmas(params):
    params.doSomething()

Now you can call it later on with:

print doSomethingWithParams(myParams)

or/and

print doSomethingWithParams(yourParams)

It's how functions work, you can call it with whatever params you like, all that function cares, is that they are some kind of params that it can handle.

EDIT: A remark: I have never coded a line of Python in my life.

Related Solutions

Django – How Does It Turn Field Name Strings to Variables?

Python has numerous ways to turn strings into objects. The most important are:

Attribute access with getattr(), allowing you to translate foo.bar into getattr(foo, 'bar').
Dictionary access, mapping[key]. Almost anything in Python can be reduced to dictionaries; by default class instances store information in a mapping called __dict__ for example, so instance.__dict__[key] works in many cases. Module namespaces use a mapping like that too.

The built-in functions vars(), locals() and globals() all return a namespace mapping.

If you are interested in Python introspection, you may want to study the Python datamodel, and take a look at the inspect library as well.

Python Coding Style – Using Null/None/Nil vs Empty Data Types

There's a conceptual difference between

an empty value
a default value
the absence of a value

Python's None object is generally used to indicate the absence of a value, and is similar to a null pointer in other languages. This isn't 100% perfect, but it's a good fit most of the time.

You can then check whether you have a value if something is not None: .... It is a common error to check a possibly-empty value for truthiness as in if something: ..., because a present value could also be falsey. Consider:

                   value = True    value = False   value = None
bool(value)        True            False           False
value is not None  True            True            False
                                   ^^^^^^^^^^^^^

So a simple truthiness check would not find present values such as False, 0, ''. Furthermore, many empty values are true-ish, especially most user-defined objects. User-defined objects can override truthiness checks via the __bool__ dunder-method, adding to the possible confusion. The something is None/something is not None check suffers from no such problems because it checks for object identity.

Python function arguments can take a default value. However, this default is evaluated at function definition time, which makes these defaults unsuitable for expensive objects or mutable objects. Then, setting the default to None and supplying the default within the function can be better:

def append_items(items=None):
  """Append some items to the list, defaulting to a new list."""
  if items is None:
    items = []

  items.append(1)
  items.append(2)
  return items

As an added benefit, callers can now explicitly request the default value, without having to know exactly what it is.

In some scenarios this can be problematic: when None is an allowed value! Then, you can create your own singleton that stands in for the default value. I sometimes write code like this:

_default = []  # some private object that has an identity

def my_function(argument=_default):
  if argument is _default:
    argument = "the default was chosen"
  return str(argument)

assert my_function() == "the default was chosen", "Argument is optional"
assert my_function(123) == "123", "Can take values"
assert my_function(None) == "None", "None is not the default value"

Best Answer

Related Solutions

Django – How Does It Turn Field Name Strings to Variables?

Python Coding Style – Using Null/None/Nil vs Empty Data Types

Related Topic