Zip functionChaining of comparison operatorsSlice notationThe help functionList comprehensionsSummaryResources and further reading

# 5 Handy Python Tips For Beginners

Today's post will cover five tips that have come in handy while learning Python.

## Zip function

A `zip` object yielding tuples until an input is exhausted. The definition for the `zip` function is `zip(*iterables)`.

``````1
2
3
4
5
6
7
8
9
10
11
``````# Zip function
a = [1,2,3,4]
b = [5,6,7,8]

for index, _ in enumerate(a):
print(a[index] + b[index]) # Prints out 6, 8, 10, 12 respectively

# Zip equivalent
for i, j in zip(a, b):
print(i + j) # Prints out 6, 8, 10, 12 respectively
``````

Zip also works with strings:

``````1
2
3
4
5
``````a = ['Hello']
b = ['World']

for i, j in zip(a, b):
print(f"{i}, {j}!") # Hello, World!
``````

## Chaining of comparison operators

Something cool that I came across from Python was the ability to chain comparison operators without the need to write separate conditionals.

For example, instead of writing a conditional `x >= 8 and x <= 10`, I could omit the `and` and simply check `8 <= x <= 10` to be true.

``````1
2
3
4
5
6
7
8
``````# Chaining of comparison operators
print(8 < 9 < 10) # True

# Follow lambda is equivalent to... lambda x: x >= 8 and x <= 10
is_between_eight_and_ten = lambda x: 8 <= x <= 10

print(is_between_eight_and_ten(4)) # False
print(is_between_eight_and_ten(9)) # True
``````

## Slice notation

Slice notation works like so `[start:stop:index]` where each value `start`, `stop` and `index` is an integer.

This can be incredibly useful when working with data where you need to reshape lists and tuples.

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
``````# Slice notation
# The notation looks like so [start:stop:step]
a = [1,2,3,4]
print(a[::]) # equivalent to a[0:len(a):1] -> [1,2,3,4]
print(a[1::]) # equivalent to a[1:len(a):1] -> [2, 3, 4]
print(a[:1:]) # equivalent to a[0:1:1] -> [1]
print(a[::2]) # equivalent to a[0:len(a):2] -> [1,3]

# Also works with strings
hello = 'hello'
print(hello[::]) # hello
print(hello[1::]) # ello
print(hello[:1:]) # h
print(hello[::2]) # hlo
``````

## The help function

This function is very useful when working with Python. It will print out the `docstring` for the function.

``````1
2
3
``````# `help` function
import os
help(os.path) # Prints out help information for function
``````

The above would print out the following:

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
``````Help on module posixpath:

NAME
posixpath - Common operations on Posix pathnames.

MODULE REFERENCE
https://docs.python.org/3.9/library/posixpath

The following documentation is automatically generated from the Python
source files.  It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations.  When in doubt, consult the module reference at the
location listed above.

DESCRIPTION
Instead of importing this module directly, import os and refer to
this module as os.path.  The "os.path" name is an alias for this
module on Posix systems; on other systems (e.g. Windows),
os.path provides the same operations in a manner specific to that
platform, and is an alias to another module (e.g. ntpath).

Some of this can actually be useful on non-Posix systems too, e.g.
for manipulation of the pathname component of URLs.

# ... rest ommited for brevity
``````

## List comprehensions

Finally, the last tip I want to mention is the use of list comprehensions. This has been useful for cutting down on the amount of code that I have to write.

Be careful not to make your code too unreadable, but it is a nice way to quickly create a conditional list of values from another list.

``````1
2
3
4
5
6
7
8
``````# List comprehensions
a = [1,2,3,4,5]
print([x for x in a if x % 2 == 0]) # Prints out [2, 4]
print([x ** 2 for x in a]) # Prints out [1, 4, 9, 16, 25]

# Creating lists
b = [x for x in range(10) if x < 5]
print(b) # Prints out [0, 1, 2, 3, 4]
``````

It also works well with string lists:

``````1
2
3
4
5
6
``````# Working with string lists
c = ['hey', 'world']
print([x.upper() for x in c if len(x) > 3]) # Prints out ['WORLD'])

# Working with enumerations
print([x for index, x in enumerate(c) if index < 1]) # Prints out ['hey']
``````

## Summary

Today was a recap on some of the cooler things I have come across with Python of the past 30 days. I hope you found this useful!

I will continue to iterate on this as I find Python syntax that are readily used in everyday projects.

1. Python `zip` function
2. `help` function in Python
3. Python List Comprehensions
4. Chaining of comparison operators
5. Slice notation in Python

Photo credit: `susangold`

## Dennis O'Keeffe

@dennisokeeffe92
• Melbourne, Australia

Hi, I am a professional Software Engineer. Formerly of Culture Amp, UsabilityHub, Present Company and NightGuru.
I am currently working on workingoutloud.dev, Den Dribbles and LandPad .