Last Updated on December 9, 2021
The Python language syntax is quite powerful and expressive. Hence it is concise
By Nick Cotes
Last Updated on December 9, 2021
The Python language syntax is quite powerful and expressive. Hence it is concise to express an algorithm in Python. Maybe it is the reason it is popular in machine learning, as we need to experiment a lot in developing a machine learning model.
If you’re new to Python but with experience in another programming language, you will sometimes find Python syntax understandable but weird. If you used to write in C++ or Java and transitioning to Python, likely your program is not Pythonic.
In this tutorial, we will cover several common language features in Python that distinct itself from other programming languages.
Let’s get started.
Some Language Features in Python Photo by David Clode, some rights reserved.
This tutorial is divided into 2 parts; they are:
Built-in data structures
Most of the operators used in Python are same as the other languages. The precedence table is as follows, adopted from Chapter 6 of Python Language Reference (https://docs.python.org/3/reference/expressions.html):
Comparisons, including membership tests and identity tests
if – else
Some key differences to other languages:
boolean operators are spelled out, while bitwise operators are characters &, ^ and |
exponentiation uses 2**3
integer division uses // and division / always gives you floating point values
tertary operator: If you are familiar with the expression (x)?a:b in C, we write it as a if x else b in Python
compare if two things are equal can ether use == or is. The == operator is same as other languages for equality but is is stricter, reserved for whether the two variable points to the same object
In Python, we allows concatenation in comparison operators. For example, to test if a value is between -1 and +1, we can do
but we can also do
Built-in data structures
As in many other languages, we have integer and floating point data types in Python. But there are also complex number (e.g. 3+1j), boolean as constants (True and False), strings, as well as a dummy type None
But the power of Python as a language lies in the fact that there are container types built-in: Python arrays are called “list” and it will expand automatically and associative arrays (or hash tables) are called “dict”. We also have “tuple” as read-only list, and “set” as container for unique items. In C++ for example, you will need STL to give you these features.
The “dict” data structure is probably the most powerful one in Python and give us some convenience in writing code. For example, in the problem of image classification between dogs and cats, our machine learning model may give you only a value 0 or 1 and if you want to print the name, we can do:
value=0# This is obtained from a model
print("Result is %s"%value_to_name[value])
Result is cat
In this case, we make use of the dict value_to_name as a look up table. Similarly, we can also make use of the dict to build a counter:
sentence="Portez ce vieux whisky au juge blond qui fume"
and we can use + to concatenate lists. In the above, we use += to extend the list A.
Python list has slicing syntax. For example the above A, we can make A[1:3] to mean elements 1 and 2, i.e., [2, "fizz"] and A[1:1] is an empty list. Indeed we can assign something to a slice to insert or remove some elements. For example:
Tuple has a similar syntax as list, except it is defined using parenthesis:
Tuple is immutable. It means you cannot modify it once it is defined. In Python, if you put several things together with commas to separate each other, it is assumed to be a tuple. The significance of this is that, we can swap two variables in a very clean syntax:
print("a is %s; b is %s"%(a,b))
print("After swap, a is %s; b is %s"%(a,b))
a is 42; b is foo
After swap, a is foo; b is 42
Finally, as you have seen in the examples above, Python strings support substitution on the fly. With the similar template syntax as printf() function in C we can use %s to substitute a string or %d to substitute an integer. We can also use %.3f to substitute a floating point number with 3 decimal places. Below is an example:
template="Square root of %d is %.3f"
Square root of 10 is 3.162
But this is just one of the many ways to do it. The above can also be achieved using f-string and format() method.
Python has several “special variables” predefined. __name__ tells the current namespace and __file__ tells the filename of the script. More will be found inside objects but almost all of them are not supposed to be directly used normally. As a convention (i.e., just a habit but not anyone stopping you from doing that) we name internal variables with underscore or double underscore as prefix (by the way, double underscore are pronounced as “dunder” by some people). If you’re from C++ or Java, these are equivalent to the private members of a class, although they are not technically private.
One notable “special” variable that you may often see in Python code is _, just an underscore character. It is by convention to mean a variable that we do not care. Why do you need a variable if you don’t care? That’s because sometimes you hold a return value from a function. For example, in pandas we can scan each row of a dataframe:
In the above, we can see that the dataframe has three columns “x”, “y”, and “z” and the rows are indexed by 0 to 3. If we call A.iterrows() it will give us the index and the row one by one, but we don’t care about the index. We can just create a new variable to hold it but not use it. To make it clear that we are not going to use it, we use _ as the variable to hold the index while the row is stored into variable row.
In Python, a small number of functions are defined as built-in while other functionalities are delivered in other packages. The list of all built-in functions are available in Python Standard Library documentation (https://docs.python.org/3/library/functions.html) and below is those defined in Python 3.10:
Not all are used every day but some are particularly notable:
zip() allows you to combine multiple lists together. For example
('x', 3, 2.1)
('y', 5, 2.5)
('z', 7, 2.9)
and it is handy if you want to “pivot” a list of list, e.g.,
('x', 'y', 'z')
(3, 5, 7)
(2.1, 2.5, 2.9)
enumerate() is handy to let you number a list of items, for example:
print("item %d is %s"%(num,item))
item 0 is quick
item 1 is brown
item 2 is fox
item 3 is jumps
item 4 is over
This is equivalent to the following if you do not use enumerate:
print("item %d is %s"%(num,a[num]))
Compare to other languages, the for loop in Python is to iterate over a predefined range rather than computing the values in each iteration. In other words, there is not direct equivalence to the following C for loop:
and in Python we have to use range() to do the same:
In the similar sense, there are some functions that manipulated a list (or list-like data structures, which Python call it the “iterables”):
max(a): To find the maximum value in list a
min(a): To find the minimum value in list a
sum(a): To find the sum of values in list a
reverse(a): To iterate from list a from back
sorted(a): To return a copy of list a with elements in sorted order
We will cover more on these in the next post.
The above only highlighted some key features in Python. Surely there are no more authoritative documentation than the official documentation from Python.org; all beginners should start with the Python tutorial and check the Language Reference for syntax details and Standard Library for additional libraries that comes with the Python installation:
For books, Learning Python from Lutz is an old but good primer. After that, Fluent Python can help you understand better on the internal of the language. However, if you want something quick, the book by Al Sweigart can let you pick up the language fast with examples. Once you get familiar with Python, you may want to learn some quick tips for a particular task from the Python Cookbook.
Learning Python, 5th Edition by Mark Lutz, O’Reilly, 2013, https://www.amazon.com/dp/1449355730/
Fluent Python by Luciano Ramalho, O’Reilly, 2015, https://www.amazon.com/dp/1491946008/
Automate the Boring Stuff with Python, 2nd Edition by Al Sweigart, No Starch Press, 2019, https://www.amazon.com/dp/1593279922/
Python Cookbook, 3rd Edition by David Beazley and Brian K. Jones, O’Reilly, 2013, https://www.amazon.com/dp/1449340377/
In this tutorial, you discovered some distinctive features of Python. Specifically, you learned:
The operators provided by Python
Some use of the built-in data structure
Some frequently-used built-in functions and why they are useful