I’ve been learning Python for around 11 months. It’s been a wonderful journey! This post is a list of 11 things that I’ve learned along the way.
1 – Setup
The hardest thing about learning Python can be getting it setup in the first place! I recommend using the Anaconda distribution of Python.
Regarding Python 2 vs Python 3 – if you are starting out now it makes sense to learn Python 3. It’s worth knowing what the differences are between the two – once you’ve made some progress with Python 3.
The installation process is pretty straight forward – you can check that Anaconda installed correctly by typing ‘python’ into Terminal or Command Prompt. You should get something like the following:
2 – pip
pip is a way to manage packages in Python. pip is run from a Terminal. Below are the pip commands I use the most.
To install a package (Note that the -U argument forces pip to install the upgraded version of the package)
pip install pandas -U
To remove a package
pip remove pandas
To print all installed packages
3 – Virtual environments
Virtual environments are best practice for managing Python on your machine. Ideally you should have one virtual environment for each project you work on.
This gives you the ability to work with different versions of packages in different projects and to understand the package dependencies of your project.
There are two main packages for managing virtual environments. Personally I use conda (as I always use the Anaconda distribution of Python).
One cool trick is that once you activate your environment, you can start programs such as Atom or Jupyter and they will use your environment.
For example if you use a terminal plugin within Atom, starting Atom this way will mean the terminal uses your environment Python – not your system Python.
4 – Running Python scripts interactively
Running a script interactively can be very useful when you are learning Python – both for debugging and getting and understanding of what is going on!
python -i script_name.py
After the script has run you will be left with an interactive console. If Python encounters an error in the script then you will still end up in interactive mode (at the point where the script broke).
5 – enumerate
Often you want to loop over a list and keep information about the index of the current item in the list.
This can naively be done by
idx = 0 for item in a_list: other_list[idx] = item idx += idx
Python offers a cleaner way to implement this
for idx, item in enumerate(a_list): other_list[idx] = item
We can also start the index at a value other than zero
for idx, item in enumerate(a_list, 2): other_list[idx] = item
6 – zip
Often we want to iterate over two lists together. A naive approach would be to
for idx, item_1 in enumerate(first_list): item_2 = second_list[idx] result = item_1 * item_2
A better approach is to make use of zip – part of the Python standard library
for item_1, item_2 in zip(first_list, second_list): result = item_1 * item_2
We can even combine zip with enumerate
for idx, (item_1, item_2) in zip(first_list, second_list): other_list[idx] = item_1 * item_2
7 – List comprehensions
List comprehensions are baffling at first. They offer a much cleaner way to implement list creation.
A naive approach to making a list would be
new_list =  for item in old_list: new_list.append(2 * item)
List comprehensions offers a way to do this in a single line
new_list = [item * 2 for item in old_list]
You can also create other iterables such as tuples or dictionaries using similar notation.
8 – Default values for functions
Often we create a function with inputs that only need to be changed rarely. We can set a default value for a function by
def my_function(input_1, input_2=10): return input_1 * input_2
We can run this function using
result = my_function(input_1=5)
Which will return result = 50.
If we wanted to change the value of the second input we could
result_2 = my_function(input_1=5, input_2=5)
Which will return result = 25.
9 – git
Git is a fantastic tool that I highly recommend using. As with Python I’m no expert! A full write up of how to use git is outside the scope of this article – these commands are useful to get started. Note that all of these commands should be entered in a Terminal that is inside the git repo.
To check the status of the repo
To add files to a commit and push to your master branch
git add file_name
git commit -m 'commit message'
git push origin master
Note that you can do multiple commits in a single push.
We can also add multiple files at once. To add all files that are already tracked (i.e. part of the repo)
git add -u
To add all files (tracked & untracked)
git add *
Another useful command is
git reset HEAD~
What this command allows you to do is to undo local commits. Sometimes you will add files to your commit you didn’t mean to – this allows you to undo them one by one (ie commit by commit).
10 – Text editors
There are a range of text editors you can use to write Python
– sypder (comes with anaconda)
– Sublime Text
– notepad ++
All have their positives and negatives. When you are starting out I reccomend using whatever feels the most comfortable.
Personally I started out using notepad ++, then went to spyder, then to Atom and vim.
It’s important to not focus too much on what editor you are using – more important to just write code.
11 – Books & resources
Python 3 Object Oriented Programming
Effective Python: 59 Specific Ways to Write Better Python
Python for Data Analysis: Data Wrangling with Pandas, NumPy, and IPython
Python Machine Learning
Automate the Boring Stuf with Python
Thanks for reading!