DevOps
English

Appearance

On this page

Python ​

Basic Data Structures ​

Boolean ​

The Boolean data type is either True or False. Boolean operators are ordered by priority: not → and → or

python
## Evaluates to True:
1<2 and 0<=1 and 3>2 and 2>=2 and 1==1
and 1!=0
## Evaluates to False:
bool(None or 0 or 0.0 or '' or [] or
{} or set())

## Rule: None, 0, 0.0, empty strings, or empty container types evaluate to False

Integer, Float ​

An integer is a positive or negative number without decimal point such as 3. A float is a positive or negative number with floating point precision such as 3.1415926. Integer division rounds toward the smaller integer (example: 3//2==1).

python
## Arithmetic Operations
x, y = 3, 2
print(x + y) # = 5
print(x - y) # = 1
print(x * y) # = 6
print(x / y) # = 1.5
print(x // y) # = 1
print(x % y) # = 1
print(-x) # = -3
print(abs(-x)) # = 3
print(int(3.9)) # = 3
print(float(3)) # = 3.0
print(x ** y) # = 9

String ​

Python Strings are sequences of characters. String Creation Methods:

text
1. Single quotes
>>> 'Yes'
2. Double quotes
>>> "Yes"
3. Triple quotes (multi-line)
>>> """Yes
We Can"""
4. String method
>>> str(5) == '5'
True
5. Concatenation
>>> "Ma" + "hatma"
'Mahatma'
Whitespace chars:
Newline \n,
Space \s,
Tab \t
python
## Indexing and Slicing
s = "The youngest pope was 11 years"
s[0] # 'T'
s[1:3] # 'he'
s[-3:-1] # 'ar'
s[-3:] # 'ars'
x = s.split()
x[-2] + " " + x[2] + "s" # '11 popes'
## String Methods
y = " Hello world\t\n "
y.strip() # Remove Whitespace
"HI".lower() # Lowercase: 'hi'
"hi".upper() # Uppercase: 'HI'
"hello".startswith("he") # True
"hello".endswith("lo") # True
"hello".find("ll") # Match at 2
"cheat".replace("ch", "m") # 'meat'
''.join(["F", "B", "I"]) # 'FBI'
len("hello world") # Length: 15
"ear" in "earth" # True

Complex Data Structures ​

List ​

Stores a sequence of elements. Unlike strings, you can modify list objects (they're mutable).

python
l = [1, 2, 2]
print(len(l)) # 3

Adding elements ​

Add elements to a list with (i) append, (ii) insert, or (iii) list concatenation.

python
[1, 2].append(4) # [1, 2, 4]
[1, 4].insert(1,9) # [1, 9, 4]
[1, 2] + [4] # [1, 2, 4]

Removal ​

Slow for lists

python
[1, 2, 2, 4].remove(1) # [2, 2, 4]

Reversing ​

Reverses list order

python
[1, 2, 3].reverse() # [3, 2, 1]

Sorting ​

Sorts list using fast Timsort

python
[2, 4, 2].sort() # [2, 2, 4]

Indexing ​

Finds the first occurrence of an element & returns index. Slow worst case for whole list traversal.

python
[2, 2, 4].index(2)
# index of item 2 is 0
[2, 2, 4].index(2,1)
# index of item 2 after pos 1 is 1

Stack ​

Use Python lists via the list operations append() and pop()

python
stack = [3]
stack.append(42) # [3, 42]
stack.pop() # 42 (stack: [3])
stack.pop() # 3 (stack: [])

Set ​

An unordered collection of unique elements (at-mostonce) → fast membership O(1)

python
basket = {'apple', 'eggs',
'banana', 'orange'}
same = set(['apple', 'eggs',
'banana', 'orange'])

Dictionary ​

Useful data structure for storing (key, value) pairs

python
cal = {'apple' : 52, 'banana' : 89, 'choco' : 546} # calories

Reading and writing elements ​

Read and write elements by specifying the key within the brackets. Use the keys() and values() functions to access all keys and values of the dictionary

python
print(cal['apple'] < cal['choco'])
# True
cal['cappu'] = 74
print(cal['banana'] < cal['cappu'])
# False
print('apple' in cal.keys()) # True
print(52 in cal.values()) # True

Dictionary Iteration ​

You can access the (key, value) pairs of a dictionary with the items() method.

python
for k, v in cal.items():
print(k) if v > 500 else ''
# 'choco'

Membership operator ​

Check with the in keyword if set, list, or dictionary contains an element. Set membership is faster than list membership.

python
basket = {'apple', 'eggs',
'banana', 'orange'}
print('eggs' in basket) # True
print('mushroom' in basket) # False

List & set comprehension ​

List comprehension is the concise Python way to create lists. Use brackets plus an expression, followed by a for clause. Close with zero or more for or if clauses. Set comprehension works similar to list comprehension.

python
l = ['hi ' + x for x in ['Alice',
'Bob', 'Pete']]
# ['Hi Alice', 'Hi Bob', 'Hi Pete']
l2 = [x * y for x in range(3) for y
in range(3) if x>y] # [0, 0, 2]
squares = { x**2 for x in [0,2,4]
if x < 4 } # {0, 4}

Classes ​

Classes ​

A class encapsulates data and functionality: data as attributes, and functionality as methods. It is a blueprint for creating concrete instances in memory.

python
class Dog:
""" Blueprint of a dog """
# class variable shared by all instances
species = ["canis lupus"]
def __init__(self, name, color):
self.name = name
self.state = "sleeping"
self.color = color
def command(self, x):
	if x == self.name:
		self.bark(2)
	elif x == "sit":
		self.state = "sit"
	else:
		self.state = "wag tail"

def bark(self, freq):
	for i in range(freq):
		print("[" + self.name + "]: Woof!")

bello = Dog("bello", "black")
alice = Dog("alice", "white")
print(bello.color) # black
print(alice.color) # white
bello.bark(1) # [bello]: Woof!
alice.command("sit")
print("[alice]: " + alice.state)
# [alice]: sit
bello.command("no")
print("[bello]: " + bello.state)
# [bello]: wag tail
alice.command("alice")
# [alice]: Woof!
# [alice]: Woof!
bello.species += ["wulf"]
print(len(bello.species) == len(alice.species)) # True (!)

Instance ​

You are an instance of the class human. An instance is a concrete implementation of a class: all attributes of an instance have a fixed value. Your hair is blond, brown, or black--but never unspecified. Each instance has its own attributes independent of other instances. Yet, class variables are different. These are data values associated with the class, not the instances. Hence, all instance share the same class variable species in the example.

Self ​

The first argument when defining any method is always the self argument. This argument specifies the instance on which you call the method. self gives the Python interpreter the information about the concrete instance. To define a method, you use self to modify the instance attributes. But to call an instance method, you do not need to specify self.

Creation ​

You can create classes “on the fly” and use them as logical units to store complex data types.

python
class Employee():
pass
employee = Employee()
employee.salary = 122000
employee.firstname = "alice"
employee.lastname = "wonderland"
print(employee.firstname + " "
	+ employee.lastname + " "
	+ str(employee.salary) + "$")
# alice wonderland 122000$

Advanced Functions ​

map(func, iter)

Executes the function on all elements of the iterable

python
list(map(lambda x: x[0], ['red', 'green', 'blue']))

>  ['r', 'g', 'b']

map(func, i1, ..., ik)

Executes the function on all k elements of the k iterables

python
list(map(lambda x, y: str(x) + ' ' + y + 's' , [0, 2, 2], ['apple', 'orange', 'banana']))
> ['0 apples', '2 oranges', '2 bananas']

string.join(iter)

Concatenates iterable elements separated by string

python
' marries '.join(list(['Alice', 'Bob']))
> 'Alice marries Bob'

filter(func, iterable)

Filters out elements in iterable for which function returns False (or 0)

python
list(filter(lambda x: True if x>17
else False, [1, 15, 17, 18]))
> [18]

string.strip()

Removes leading and trailing whitespaces of string

python
print(" \n \t 42 \t ".strip())
> 42

sorted(iter)

Sorts iterable in ascending order

python
sorted([8, 3, 2, 42, 5])
> [2, 3, 5, 8, 42]

sorted(iter, key=key)

Sorts according to the key function in ascending order

python
sorted([8, 3, 2, 42, 5], key=lambda
x: 0 if x==42 else x)
> [42, 2, 3, 5, 8]

help(func)

Returns documentation of func

python
help(str.upper())
> '... to uppercase.'

zip(i1, i2, ...)

Groups the i-th elements of iterators i1, i2, ... together

python
list(zip(['Alice', 'Anna'], ['Bob', 'Jon', 'Frank']))
> [('Alice', 'Bob'), ('Anna', 'Jon')]

Unzip

Equal to: 1) unpack the zipped list, 2) zip the result

python
list(zip(*[('Alice', 'Bob'), ('Anna', 'Jon')]))
> [('Alice', 'Anna'), ('Bob', 'Jon')]

enumerate(iter)

Assigns a counter value to each element of the iterable

python
list(enumerate(['Alice', 'Bob', 'Jon']))
> [(0, 'Alice'), (1, 'Bob'), (2, 'Jon')]

Tricks ​

python -m http.server <P>

Want to share files between PC and phone? Run this command in PC’s shell. <P> is any port number 0–65535. Type < IP address of PC>:<P> in the phone’s browser. You can now browse the files in the PC directory.

Read comic

Open the comic series xkcd in your web browser

python
import antigravity

Zen of Python

python
import this

'...Beautiful is better than ugly. Explicit is ...'

Swapping numbers

Swapping variables is a breeze in Python. No offense, Java!

python
a, b = 'Jane', 'Alice'
a, b = b, a

a = 'Alice'
b = 'Jane'

Unpacking arguments

Use a sequence as function arguments via asterisk operator *. Use a dictionary (key, value) via double asterisk operator.

python
def f(x, y, z): return x + y * z
	f(*[1, 3, 4])
	f(**{'z' : 4, 'x' : 1, 'y' : 3})

>13
>13

Extended Unpacking

Use unpacking for multiple assignment feature in Python

python
a, *b = [1, 2, 3, 4, 5]

a = 1
b = [2, 3, 4, 5]

Merge two dictionaries

Use unpacking to merge two dictionaries into a single one

python
x={'Alice' : 18}
y={'Bob' : 27, 'Ann' : 22}
z = {**x,**y}

# z = {'Alice': 18, 'Bob': 27, 'Ann': 22}

Interview Questions ​

  • Check if list contains integer x
python
l = [3, 3, 4, 5, 2, 111, 5]
print(111 in l) # True
  • Get missing number in [1...100]
python
def get_missing_number(lst):
	return set(range(lst[len(lst)-1])[1:]) - set(l)

l = list(range(1,100))
l.remove(50)
print(get_missing_number(l)) # 50
  • Find duplicate number in integer list
python
def find_duplicates(elements):
	duplicates, seen = set(), set()
	for element in elements:
		if element in seen:
			duplicates.add(element)
		seen.add(element)
	return list(duplicates)
  • Compute the intersection of two lists
python
def intersect(lst1, lst2):
	res, lst2_copy = [], lst2[:]
	for el in lst1:
		if el in lst2_copy:
			res.append(el)
			lst2_copy.remove(el)
	return res
  • Check if two strings are anagrams
python
def is_anagram(s1, s2):
	return set(s1) == set(s2)
print(is_anagram("elvis", "lives")) # True
  • Find max and min in unsorted list
python
l = [4, 3, 6, 3, 4, 888, 1, -11, 22, 3]
print(max(l)) # 888
print(min(l)) # -11
  • Remove all duplicates from list
python
lst = list(range(10)) + list(range(10))
lst = list(set(lst))
print(lst)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • Reverse string using recursion
python
def reverse(string):
	if len(string)<=1: return string
	return reverse(string[1:])+string[0]
print(reverse("hello")) # olleh
  • Find pairs of integers in list so that their sum is equal to integer x
python
def find_pairs(l, x):
	pairs = []
	for (i, el_1) in enumerate(l):
		for (j, el_2) in enumerate(l[i+1:]):
			if el_1 + el_2 == x:
				pairs.append((el_1, el_2))
	return pairs
  • Compute the first n Fibonacci numbers
python
a, b = 0, 1
n = 10
for i in range(n):
print(b)
	a, b = b, a+b
	# 1, 1, 2, 3, 5, 8, ...
  • Check if a string is a palindrome
python
def qsort(L):
	if L == []: return []
	return qsort([x for x in L[1:] if x< L[0]]) + L[0:1] +

qsort([x for x in L[1:] if x>=L[0]])
lst = [44, 33, 22, 5, 77, 55, 999]
print(qsort(lst))
# [5, 22, 33, 44, 55, 77, 999]
  • Use list as stack, array, and queue
python
# as a list ...
l = [3, 4]
l += [5, 6] # l = [3, 4, 5, 6]
# ... as a stack ...
l.append(10) # l = [4, 5, 6, 10]
l.pop() # l = [4, 5, 6]
# ... and as a queue
l.insert(0, 5) # l = [5, 4, 5, 6]
l.pop() # l = [5, 4, 5]
  • Find all permutation s of string
python
def get_permutations(w):
	if len(w)<=1:
		return set(w)
	smaller = get_permutations(w[1:])
	perms = set()
	
	for x in smaller:
		for pos in range(0,len(x)+1):
			perm = x[:pos] + w[0] + x[pos:]
			perms.add(perm)
	return perms
print(get_permutations("nan"))
# {'nna', 'ann', 'nan'}