About

Contribute

Read It

Python Cheatsheet

Python Basics

Math Operators

>>> 2 + 3 * 620

>>> (2 + 3) * 630

>>> 2 ** 8256

>>> 23 // 73

>>> 23 % 72

>>> (5 - 1) * ((7 + 1) / (3 - 1))16.0

Data Types

String Concatenation and Replication

>>> 'Alice' 'Bob''AliceBob'

>>> 'Alice' * 5'AliceAliceAliceAliceAlice'

Variables

>>> spam = 'Hello'>>> spam'Hello'

>>> _spam = 'Hello'

Comments

# This is a comment

# This is a# multiline comment

a = 1  # initialization

def foo():    """    This is a function docstring    You can also use:    ''' Function Docstring '''    """

The print() Function

>>> print('Hello world!')Hello world!

>>> a = 1>>> print('Hello world!', a)Hello world! 1

The input() Function

>>> print('What is your name?')   # ask for their name>>> myName = input()>>> print('It is good to meet you, {}'.format(myName))What is your name?AlIt is good to meet you, Al

The len() Function

>>> len('hello')5

>>> a = [1, 2, 3]>>> if a:>>>     print("the list is not empty!")

The str(), int(), and float() Functions

>>> str(29)'29'

>>> print('I am {} years old.'.format(str(29)))I am 29 years old.

>>> str(-3.14)'-3.14'

>>> int(7.7)7

>>> int(7.7) + 18

Flow Control

Comparison Operators

>>> 42 == 42True

>>> 40 == 42False

>>> 'hello' == 'hello'True

>>> 'hello' == 'Hello'False

>>> 'dog' != 'cat'True

>>> 42 == 42.0True

>>> 42 == '42'False

Boolean evaluation

>>> True == TrueTrue

>>> True != FalseTrue

>>> True is TrueTrue

>>> True is not FalseTrue

>>> if a is True:>>>    pass>>> if a is not False:>>>    pass>>> if a:>>>    pass

>>> if a is False:>>>    pass>>> if a is not True:>>>    pass>>> if not a:>>>    pass

Boolean Operators

Mixing Boolean and Comparison Operators

>>> (4 < 5) and (5 < 6)True

>>> (4 < 5) and (9 < 6)False

>>> (1 == 2) or (2 == 2)True

>>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2True

if Statements

if name == 'Alice':    print('Hi, Alice.')

else Statements

name = 'Bob'if name == 'Alice':    print('Hi, Alice.')else:    print('Hello, stranger.')

elif Statements

name = 'Bob'age = 5if name == 'Alice':    print('Hi, Alice.')elif age < 12:    print('You are not Alice, kiddo.')

name = 'Bob'age = 30if name == 'Alice':    print('Hi, Alice.')elif age < 12:    print('You are not Alice, kiddo.')else:    print('You are neither Alice nor a little kid.')

while Loop Statements

spam = 0while spam < 5:    print('Hello, world.')    spam = spam + 1

break Statements

while True:    print('Please type your name.')    name = input()    if name == 'your name':        breakprint('Thank you!')

continue Statements

while True:    print('Who are you?')    name = input()    if name != 'Joe':        continue    print('Hello, Joe. What is the password? (It is a fish.)')    password = input()    if password == 'swordfish':        breakprint('Access granted.')

for Loops and the range() Function

>>> print('My name is')>>> for i in range(5):>>>     print('Jimmy Five Times ({})'.format(str(i)))My name isJimmy Five Times (0)Jimmy Five Times (1)Jimmy Five Times (2)Jimmy Five Times (3)Jimmy Five Times (4)

>>> for i in range(0, 10, 2):>>>    print(i)02468

>>> for i in range(5, -1, -1):>>>     print(i)543210

For else statement

>>> for i in [1, 2, 3, 4, 5]:>>>    if i == 3:>>>        break>>> else:>>>    print("only executed when no item of the list is equal to 3")

Importing Modules

import randomfor i in range(5):    print(random.randint(1, 10))

import random, sys, os, math

from random import *.

Ending a Program Early with sys.exit()

import syswhile True:    print('Type exit to exit.')    response = input()    if response == 'exit':        sys.exit()    print('You typed {}.'.format(response))

Functions

>>> def hello(name):>>>     print('Hello {}'.format(name))>>>>>> hello('Alice')>>> hello('Bob')Hello AliceHello Bob

Return Values and return Statements

import randomdef getAnswer(answerNumber):    if answerNumber == 1:        return 'It is certain'    elif answerNumber == 2:        return 'It is decidedly so'    elif answerNumber == 3:        return 'Yes'    elif answerNumber == 4:        return 'Reply hazy try again'    elif answerNumber == 5:        return 'Ask again later'    elif answerNumber == 6:        return 'Concentrate and ask again'    elif answerNumber == 7:        return 'My reply is no'    elif answerNumber == 8:        return 'Outlook not so good'    elif answerNumber == 9:        return 'Very doubtful'r = random.randint(1, 9)fortune = getAnswer(r)print(fortune)

The None Value

>>> spam = print('Hello!')Hello!

>>> spam is NoneTrue

Keyword Arguments and print()

>>> print('Hello', end='')>>> print('World')HelloWorld

>>> print('cats', 'dogs', 'mice')cats dogs mice

>>> print('cats', 'dogs', 'mice', sep=',')cats,dogs,mice

Local and Global Scope

The global Statement

>>> def spam():>>>     global eggs>>>     eggs = 'spam'>>>>>> eggs = 'global'>>> spam()>>> print(eggs)spam

Exception Handling

Basic exception handling

>>> def spam(divideBy):>>>     try:>>>         return 42 / divideBy>>>     except ZeroDivisionError as e:>>>         print('Error: Invalid argument: {}'.format(e))>>>>>> print(spam(2))>>> print(spam(12))>>> print(spam(0))>>> print(spam(1))21.03.5Error: Invalid argument: division by zeroNone42.0

Final code in exception handling

>>> def spam(divideBy):>>>     try:>>>         return 42 / divideBy>>>     except ZeroDivisionError as e:>>>         print('Error: Invalid argument: {}'.format(e))>>>     finally:>>>         print("-- division finished --")>>> print(spam(12))>>> print(spam(0))21.0-- division finished --3.5-- division finished --Error: Invalid argument: division by zero-- division finished --None-- division finished --42.0-- division finished --

Lists

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam['cat', 'bat', 'rat', 'elephant']

Getting Individual Values in a List with Indexes

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam[0]'cat'

>>> spam[1]'bat'

>>> spam[2]'rat'

>>> spam[3]'elephant'

Negative Indexes

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam[-1]'elephant'

>>> spam[-3]'bat'

>>> 'The {} is afraid of the {}.'.format(spam[-1], spam[-3])'The elephant is afraid of the bat.'

Getting Sublists with Slices

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam[0:4]['cat', 'bat', 'rat', 'elephant']

>>> spam[1:3]['bat', 'rat']

>>> spam[0:-1]['cat', 'bat', 'rat']

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam[:2]['cat', 'bat']

>>> spam[1:]['bat', 'rat', 'elephant']

>>> spam[:]['cat', 'bat', 'rat', 'elephant']

Getting a List’s Length with len()

>>> spam = ['cat', 'dog', 'moose']>>> len(spam)3

Changing Values in a List with Indexes

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam[1] = 'aardvark'>>> spam['cat', 'aardvark', 'rat', 'elephant']>>> spam[2] = spam[1]>>> spam['cat', 'aardvark', 'aardvark', 'elephant']>>> spam[-1] = 12345>>> spam['cat', 'aardvark', 'aardvark', 12345]

List Concatenation and List Replication

>>> [1, 2, 3] + ['A', 'B', 'C'][1, 2, 3, 'A', 'B', 'C']>>> ['X', 'Y', 'Z'] * 3['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']>>> spam = [1, 2, 3]>>> spam = spam + ['A', 'B', 'C']>>> spam[1, 2, 3, 'A', 'B', 'C']

Removing Values from Lists with del Statements

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> del spam[2]>>> spam['cat', 'bat', 'elephant']

>>> del spam[2]>>> spam['cat', 'bat']

Using for Loops with Lists

>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']>>> for i, supply in enumerate(supplies):>>>     print('Index {} in supplies is: {}'.format(str(i), supply))Index 0 in supplies is: pensIndex 1 in supplies is: staplersIndex 2 in supplies is: flame-throwersIndex 3 in supplies is: binders

Looping Through Multiple Lists with zip()

>>> name = ['Pete', 'John', 'Elizabeth']>>> age = [6, 23, 44]>>> for n, a in zip(name, age):>>>     print('{} is {} years old'.format(n, a))Pete is 6 years oldJohn is 23 years oldAlice is 44 years old

The in and not in Operators

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']True

>>> spam = ['hello', 'hi', 'howdy', 'heyas']>>> 'cat' in spamFalse

>>> 'howdy' not in spamFalse

>>> 'cat' not in spamTrue

The Multiple Assignment Trick

>>> cat = ['fat', 'orange', 'loud']>>> size = cat[0]>>> color = cat[1]>>> disposition = cat[2]

>>> cat = ['fat', 'orange', 'loud']>>> size, color, disposition = cat

>>> a, b = 'Alice', 'Bob'>>> a, b = b, a>>> print(a)'Bob'

>>> print(b)'Alice'

Augmented Assignment Operators

>>> spam = 'Hello'>>> spam += ' world!'>>> spam'Hello world!'>>> bacon = ['Zophie']>>> bacon *= 3>>> bacon['Zophie', 'Zophie', 'Zophie']

Finding a Value in a List with the index() Method

>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']>>> spam.index('Pooka')1

Adding Values to Lists with the append() and insert() Methods

>>> spam = ['cat', 'dog', 'bat']>>> spam.append('moose')>>> spam['cat', 'dog', 'bat', 'moose']

>>> spam = ['cat', 'dog', 'bat']>>> spam.insert(1, 'chicken')>>> spam['cat', 'chicken', 'dog', 'bat']

Removing Values from Lists with remove()

>>> spam = ['cat', 'bat', 'rat', 'elephant']>>> spam.remove('bat')>>> spam['cat', 'rat', 'elephant']

Sorting the Values in a List with the sort() Method

>>> spam = [2, 5, 3.14, 1, -7]>>> spam.sort()>>> spam[-7, 1, 2, 3.14, 5]

>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']>>> spam.sort()>>> spam['ants', 'badgers', 'cats', 'dogs', 'elephants']

>>> spam.sort(reverse=True)>>> spam['elephants', 'dogs', 'cats', 'badgers', 'ants']

>>> spam = ['a', 'z', 'A', 'Z']>>> spam.sort(key=str.lower)>>> spam['a', 'A', 'z', 'Z']

>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']>>> sorted(spam)['ants', 'badgers', 'cats', 'dogs', 'elephants']

Tuple Data Type

>>> eggs = ('hello', 42, 0.5)>>> eggs[0]'hello'

>>> eggs[1:3](42, 0.5)

>>> len(eggs)3

Converting Types with the list() and tuple() Functions

>>> tuple(['cat', 'dog', 5])('cat', 'dog', 5)

>>> list(('cat', 'dog', 5))['cat', 'dog', 5]

>>> list('hello')['h', 'e', 'l', 'l', 'o']

Dictionaries and Structuring Data

myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}

The keys(), values(), and items() Methods

>>> spam = {'color': 'red', 'age': 42}>>> for v in spam.values():>>>     print(v)red42

>>> for k in spam.keys():>>>     print(k)colorage

>>> for i in spam.items():>>>     print(i)('color', 'red')('age', 42)

>>> spam = {'color': 'red', 'age': 42}>>>>>> for k, v in spam.items():>>>     print('Key: {} Value: {}'.format(k, str(v)))Key: age Value: 42Key: color Value: red

Checking Whether a Key or Value Exists in a Dictionary

>>> spam = {'name': 'Zophie', 'age': 7}

>>> 'name' in spam.keys()True

>>> 'Zophie' in spam.values()True

>>> # You can omit the call to keys() when checking for a key>>> 'color' in spamFalse

>>> 'color' not in spamTrue

>>> 'color' in spamFalse

The get() Method

>>> picnic_items = {'apples': 5, 'cups': 2}>>> 'I am bringing {} cups.'.format(str(picnic_items.get('cups', 0)))'I am bringing 2 cups.'

>>> 'I am bringing {} eggs.'.format(str(picnic_items.get('eggs', 0)))'I am bringing 0 eggs.'

The setdefault() Method

spam = {'name': 'Pooka', 'age': 5}if 'color' not in spam:    spam['color'] = 'black'

>>> spam = {'name': 'Pooka', 'age': 5}>>> spam.setdefault('color', 'black')'black'

>>> spam{'color': 'black', 'age': 5, 'name': 'Pooka'}

>>> spam.setdefault('color', 'white')'black'

>>> spam{'color': 'black', 'age': 5, 'name': 'Pooka'}

Pretty Printing

>>> import pprint>>>>>> message = 'It was a bright cold day in April, and the clocks were striking>>> thirteen.'>>> count = {}>>>>>> for character in message:>>>     count.setdefault(character, 0)>>>     count[character] = count[character] + 1>>>>>> pprint.pprint(count){' ': 13, ',': 1, '.': 1, 'A': 1, 'I': 1, 'a': 4, 'b': 1, 'c': 3, 'd': 3, 'e': 5, 'g': 2, 'h': 3, 'i': 6, 'k': 2, 'l': 3, 'n': 4, 'o': 2, 'p': 1, 'r': 5, 's': 3, 't': 6, 'w': 2, 'y': 1}

itertools Module

accumulate()

itertools.accumulate(iterable[, func])

>>> data = [1, 2, 3, 4, 5]>>> result = itertools.accumulate(data, operator.mul)>>> for each in result:>>>    print(each)12624120

operator.mul(1, 2)2operator.mul(2, 3)6operator.mul(6, 4)24operator.mul(24, 5)120

>>> data = [5, 2, 6, 4, 5, 9, 1]>>> result = itertools.accumulate(data)>>> for each in result:>>>    print(each)571317223132

55 + 2 = 77 + 6 = 1313 + 4 = 1717 + 5 = 2222 + 9 = 3131 + 1 = 32

combinations()

itertools.combinations(iterable, r)

>>> shapes = ['circle', 'triangle', 'square',]>>> result = itertools.combinations(shapes, 2)>>> for each in result:>>>    print(each)('circle', 'triangle')('circle', 'square')('triangle', 'square')

combinations_with_replacement()

itertools.combinations_with_replacement(iterable, r)

>>> shapes = ['circle', 'triangle', 'square']>>> result = itertools.combinations_with_replacement(shapes, 2)>>> for each in result:>>>    print(each)('circle', 'circle')('circle', 'triangle')('circle', 'square')('triangle', 'triangle')('triangle', 'square')('square', 'square')

count()

itertools.count(start=0, step=1)

>>> for i in itertools.count(10,3):>>>    print(i)>>>    if i > 20:>>>        break1013161922

cycle()

itertools.cycle(iterable)

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue', 'violet']>>> for color in itertools.cycle(colors):>>>    print(color)redorangeyellowgreenbluevioletredorange

chain()

itertools.chain(*iterables)

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']>>> shapes = ['circle', 'triangle', 'square', 'pentagon']>>> result = itertools.chain(colors, shapes)>>> for each in result:>>>    print(each)redorangeyellowgreenbluecircletrianglesquarepentagon

compress()

itertools.compress(data, selectors)

>>> shapes = ['circle', 'triangle', 'square', 'pentagon']>>> selections = [True, False, True, False]>>> result = itertools.compress(shapes, selections)>>> for each in result:>>>    print(each)circlesquare

dropwhile()

itertools.dropwhile(predicate, iterable)

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]>>> result = itertools.dropwhile(lambda x: x<5, data)>>> for each in result:>>>    print(each)56789101

filterfalse()

itertools.filterfalse(predicate, iterable)

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> result = itertools.filterfalse(lambda x: x<5, data)>>> for each in result:>>>    print(each)5678910

groupby()

itertools.groupby(iterable, key=None)

>>> robots = [{    'name': 'blaster',    'faction': 'autobot'}, {    'name': 'galvatron',    'faction': 'decepticon'}, {    'name': 'jazz',    'faction': 'autobot'}, {    'name': 'metroplex',    'faction': 'autobot'}, {    'name': 'megatron',    'faction': 'decepticon'}, {    'name': 'starcream',    'faction': 'decepticon'}]>>> for key, group in itertools.groupby(robots, key=lambda x: x['faction']):>>>    print(key)>>>    print(list(group))autobot[{'name': 'blaster', 'faction': 'autobot'}]decepticon[{'name': 'galvatron', 'faction': 'decepticon'}]autobot[{'name': 'jazz', 'faction': 'autobot'}, {'name': 'metroplex', 'faction': 'autobot'}]decepticon[{'name': 'megatron', 'faction': 'decepticon'}, {'name': 'starcream', 'faction': 'decepticon'}]

islice()

itertools.islice(iterable, start, stop[, step])

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]>>> few_colors = itertools.islice(colors, 2)>>> for each in few_colors:>>>    print(each)redorange

permutations()

itertools.permutations(iterable, r=None)

>>> alpha_data = ['a', 'b', 'c']>>> result = itertools.permutations(alpha_data)>>> for each in result:>>>    print(each)('a', 'b', 'c')('a', 'c', 'b')('b', 'a', 'c')('b', 'c', 'a')('c', 'a', 'b')('c', 'b', 'a')

product()

>>> num_data = [1, 2, 3]>>> alpha_data = ['a', 'b', 'c']>>> result = itertools.product(num_data, alpha_data)>>> for each in result:    print(each)(1, 'a')(1, 'b')(1, 'c')(2, 'a')(2, 'b')(2, 'c')(3, 'a')(3, 'b')(3, 'c')

repeat()

itertools.repeat(object[, times])

>>> for i in itertools.repeat("spam", 3):    print(i)spamspamspam

starmap()

itertools.starmap(function, iterable)

>>> data = [(2, 6), (8, 4), (7, 3)]>>> result = itertools.starmap(operator.mul, data)>>> for each in result:>>>    print(each)123221

takewhile()

itertools.takwwhile(predicate, iterable)

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]>>> result = itertools.takewhile(lambda x: x<5, data)>>> for each in result:>>>    print(each)1234

tee()

itertools.tee(iterable, n=2)

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']>>> alpha_colors, beta_colors = itertools.tee(colors)>>> for each in alpha_colors:>>>    print(each)redorangeyellowgreenblue

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']>>> alpha_colors, beta_colors = itertools.tee(colors)>>> for each in beta_colors:>>>    print(each)redorangeyellowgreenblue

zip_longest()

itertools.zip_longest(*iterables, fillvalue=None)

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,]>>> for each in itertools.zip_longest(colors, data, fillvalue=None):>>>    print(each)('red', 1)('orange', 2)('yellow', 3)('green', 4)('blue', 5)(None, 6)(None, 7)(None, 8)(None, 9)(None, 10)

Comprehensions

List comprehension

>>> a = [1, 3, 5, 7, 9, 11]>>> [i - 1 for i in a][0, 2, 4, 6, 8, 10]

Set comprehension

>>> b = {"abc", "def"}>>> {s.upper() for s in b}{"ABC", "DEF}

Dict comprehension

>>> c = {'name': 'Pooka', 'age': 5}>>> {v, k for k, v in c.items()}{'Pooka': 'name', 5: 'age'}

>>> c = {'name': 'Pooka', 'first_name': 'Oooka'}>>> ["{}:{}".format(k.upper(), v.upper()) for k, v in c.items()]['NAME:POOKA', 'FIRST_NAME:OOOKA']

Manipulating Strings

Escape Characters

>>> print("Hello there!\nHow are you?\nI\'m doing fine.")Hello there!How are you?I'm doing fine.

Raw Strings

>>> print(r'That is Carol\'s cat.')That is Carol\'s cat.

Multiline Strings with Triple Quotes

>>> print('''Dear Alice,>>>>>> Eve's cat has been arrested for catnapping, cat burglary, and extortion.>>>>>> Sincerely,>>> Bob''')Dear Alice,Eve's cat has been arrested for catnapping, cat burglary, and extortion.Sincerely,Bob

>>> from textwrap import dedent>>>>>> def my_function():>>>     print('''>>>         Dear Alice,>>>>>>         Eve's cat has been arrested for catnapping, cat burglary, and extortion.>>>>>>         Sincerely,>>>         Bob>>>         ''').strip()

Indexing and Slicing Strings

H   e   l   l   o       w   o   r   l   d    !0   1   2   3   4   5   6   7   8   9   10   11

>>> spam = 'Hello world!'>>> spam[0]'H'

>>> spam[4]'o'

>>> spam[-1]'!'

>>> spam[0:5]'Hello'

>>> spam[:5]'Hello'

>>> spam[6:]'world!'

>>> spam[6:-1]'world'

>>> spam[:-1]'Hello world'

>>> spam[::-1]'!dlrow olleH'

>>> spam = 'Hello world!'>>> fizz = spam[0:5]>>> fizz'Hello'

The in and not in Operators with Strings

>>> 'Hello' in 'Hello World'True

>>> 'Hello' in 'Hello'True

>>> 'HELLO' in 'Hello World'False

>>> '' in 'spam'True

>>> 'cats' not in 'cats and dogs'False

The in and not in Operators with list

>>> a = [1, 2, 3, 4]>>> 5 in aFalse

>>> 2 in aTrue

The upper(), lower(), isupper(), and islower() String Methods

>>> spam = 'Hello world!'>>> spam = spam.upper()>>> spam'HELLO WORLD!'

>>> spam = spam.lower()>>> spam'hello world!'

>>> spam = 'Hello world!'>>> spam.islower()False

>>> spam.isupper()False

>>> 'HELLO'.isupper()True

>>> 'abc12345'.islower()True

>>> '12345'.islower()False

>>> '12345'.isupper()False

The isX String Methods

The startswith() and endswith() String Methods

>>> 'Hello world!'.startswith('Hello')True

>>> 'Hello world!'.endswith('world!')True

>>> 'abc123'.startswith('abcdef')False

>>> 'abc123'.endswith('12')False

>>> 'Hello world!'.startswith('Hello world!')True

>>> 'Hello world!'.endswith('Hello world!')True

The join() and split() String Methods

>>> ', '.join(['cats', 'rats', 'bats'])'cats, rats, bats'

>>> ' '.join(['My', 'name', 'is', 'Simon'])'My name is Simon'

>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])'MyABCnameABCisABCSimon'

>>> 'My name is Simon'.split()['My', 'name', 'is', 'Simon']

>>> 'MyABCnameABCisABCSimon'.split('ABC')['My', 'name', 'is', 'Simon']

>>> 'My name is Simon'.split('m')['My na', 'e is Si', 'on']

Justifying Text with rjust(), ljust(), and center()

>>> 'Hello'.rjust(10)'     Hello'

>>> 'Hello'.rjust(20)'               Hello'

>>> 'Hello World'.rjust(20)'         Hello World'

>>> 'Hello'.ljust(10)'Hello     '

>>> 'Hello'.rjust(20, '*')'***************Hello'

>>> 'Hello'.ljust(20, '-')'Hello---------------'

>>> 'Hello'.center(20)'       Hello       '

>>> 'Hello'.center(20, '=')'=======Hello========'

Removing Whitespace with strip(), rstrip(), and lstrip()

>>> spam = '    Hello World     '>>> spam.strip()'Hello World'

>>> spam.lstrip()'Hello World '

>>> spam.rstrip()'    Hello World'

>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'>>> spam.strip('ampS')'BaconSpamEggs'

Copying and Pasting Strings with the pyperclip Module (need pip install)

>>> import pyperclip>>> pyperclip.copy('Hello world!')>>> pyperclip.paste()'Hello world!'

String Formatting

% operator

>>> name = 'Pete'>>> 'Hello %s' % name"Hello Pete"

>>> num = 5>>> 'I have %x apples' % num"I have 5 apples"

String Formatting (str.format)

>>> name = 'John'>>> age = 20'>>> "Hello I'm {}, my age is {}".format(name, age)"Hello I'm John, my age is 20"

>>> "Hello I'm {0}, my age is {1}".format(name, age)"Hello I'm John, my age is 20"

Lazy string formatting

>>> name = "alice">>> logging.debug("User name: %s", name)

>>> logging.debug("User name: {}".format(name))

>>> logging.debug("User name: " + name)

Formatted String Literals or f-strings (Python 3.6+)

>>> name = 'Elizabeth'>>> f'Hello {name}!''Hello Elizabeth!

>>> a = 5>>> b = 10>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.''Five plus ten is 15 and not 30.'

Template Strings

>>> from string import Template>>> name = 'Elizabeth'>>> t = Template('Hey $name!')>>> t.substitute(name=name)'Hey Elizabeth!'

Regular Expressions

>>> import re

Matching Regex Objects

>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')>>> mo = phone_num_regex.search('My number is 415-555-4242.')>>> print('Phone number found: {}'.format(mo.group()))Phone number found: 415-555-4242

Grouping with Parentheses

>>> phone_num_regex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')>>> mo = phone_num_regex.search('My number is 415-555-4242.')>>> mo.group(1)'415'>>> mo.group(2)'555-4242'>>> mo.group(0)'415-555-4242'>>> mo.group()'415-555-4242'

>>> mo.groups()('415', '555-4242')>>> area_code, main_number = mo.groups()>>> print(area_code)415>>> print(main_number)555-4242

Matching Multiple Groups with the Pipe

>>> hero_regex = re.compile (r'Batman|Tina Fey')>>> mo1 = hero_regex.search('Batman and Tina Fey.')>>> mo1.group()'Batman'>>> mo2 = hero_regex.search('Tina Fey and Batman.')>>> mo2.group()'Tina Fey'

>>> bat_regex = re.compile(r'Bat(man|mobile|copter|bat)')>>> mo = bat_regex.search('Batmobile lost a wheel')>>> mo.group()'Batmobile'>>> mo.group(1)'mobile'

Optional Matching with the Question Mark

>>> bat_regex = re.compile(r'Bat(wo)?man')>>> mo1 = bat_regex.search('The Adventures of Batman')>>> mo1.group()'Batman'>>> mo2 = bat_regex.search('The Adventures of Batwoman')>>> mo2.group()'Batwoman'

Matching Zero or More with the Star

>>> bat_regex = re.compile(r'Bat(wo)*man')>>> mo1 = bat_regex.search('The Adventures of Batman')>>> mo1.group()'Batman'>>> mo2 = bat_regex.search('The Adventures of Batwoman')>>> mo2.group()'Batwoman'>>> mo3 = bat_regex.search('The Adventures of Batwowowowoman')>>> mo3.group()'Batwowowowoman'

Matching One or More with the Plus

>>> bat_regex = re.compile(r'Bat(wo)+man')>>> mo1 = bat_regex.search('The Adventures of Batwoman')>>> mo1.group()'Batwoman'

>>> mo2 = bat_regex.search('The Adventures of Batwowowowoman')>>> mo2.group()'Batwowowowoman'

>>> mo3 = bat_regex.search('The Adventures of Batman')>>> mo3 is NoneTrue

Matching Specific Repetitions with Curly Brackets

>>> ha_regex = re.compile(r'(Ha){3}')>>> mo1 = ha_regex.search('HaHaHa')>>> mo1.group()'HaHaHa'

>>> mo2 = ha_regex.search('Ha')>>> mo2 is NoneTrue

Greedy and Nongreedy Matching

>>> greedy_ha_regex = re.compile(r'(Ha){3,5}')>>> mo1 = greedy_ha_regex.search('HaHaHaHaHa')>>> mo1.group()'HaHaHaHaHa'

>>> nongreedy_ha_regex = re.compile(r'(Ha){3,5}?')>>> mo2 = nongreedy_ha_regex.search('HaHaHaHaHa')>>> mo2.group()'HaHaHa'

The findall() Method

>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups>>> phone_num_regex.findall('Cell: 415-555-9999 Work: 212-555-0000')['415-555-9999', '212-555-0000']

Making Your Own Character Classes

>>> vowel_regex = re.compile(r'[aeiouAEIOU]')>>> vowel_regex.findall('Robocop eats baby food. BABY FOOD.')['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']

>>> consonant_regex = re.compile(r'[^aeiouAEIOU]')>>> consonant_regex.findall('Robocop eats baby food. BABY FOOD.')['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', '', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

The Caret and Dollar Sign Characters

>>> begins_with_hello = re.compile(r'^Hello')>>> begins_with_hello.search('Hello world!')<_sre.SRE_Match object; span=(0, 5), match='Hello'>>>> begins_with_hello.search('He said hello.') is NoneTrue

>>> whole_string_is_num = re.compile(r'^\d+$')>>> whole_string_is_num.search('1234567890')<_sre.SRE_Match object; span=(0, 10), match='1234567890'>>>> whole_string_is_num.search('12345xyz67890') is NoneTrue>>> whole_string_is_num.search('12 34567890') is NoneTrue

The Wildcard Character

>>> at_regex = re.compile(r'.at')>>> at_regex.findall('The cat in the hat sat on the flat mat.')['cat', 'hat', 'sat', 'lat', 'mat']

Matching Everything with Dot-Star

>>> name_regex = re.compile(r'First Name: (.*) Last Name: (.*)')>>> mo = name_regex.search('First Name: Al Last Name: Sweigart')>>> mo.group(1)'Al'

>>> mo.group(2)'Sweigart'

>>> nongreedy_regex = re.compile(r'<.*?>')>>> mo = nongreedy_regex.search('<To serve man> for dinner.>')>>> mo.group()'<To serve man>'

>>> greedy_regex = re.compile(r'<.*>')>>> mo = greedy_regex.search('<To serve man> for dinner.>')>>> mo.group()'<To serve man> for dinner.>'

Matching Newlines with the Dot Character

>>> no_newline_regex = re.compile('.*')>>> no_newline_regex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()'Serve the public trust.'

>>> newline_regex = re.compile('.*', re.DOTALL)>>> newline_regex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group()'Serve the public trust.\nProtect the innocent.\nUphold the law.'

Review of Regex Symbols

Case-Insensitive Matching

>>> robocop = re.compile(r'robocop', re.I)>>> robocop.search('Robocop is part man, part machine, all cop.').group()'Robocop'

>>> robocop.search('ROBOCOP protects the innocent.').group()'ROBOCOP'

>>> robocop.search('Al, why does your programming book talk about robocop so much?').group()'robocop'

Substituting Strings with the sub() Method

>>> names_regex = re.compile(r'Agent \w+')>>> names_regex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')'CENSORED gave the secret documents to CENSORED.'

>>> agent_names_regex = re.compile(r'Agent (\w)\w*')>>> agent_names_regex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')A**** told C**** that E**** knew B**** was a double agent.'

Managing Complex Regexes

phone_regex = re.compile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')

phone_regex = re.compile(r'''(    (\d{3}|\(\d{3}\))?            # area code    (\s|-|\.)?                    # separator    \d{3}                         # first 3 digits    (\s|-|\.)                     # separator    \d{4}                         # last 4 digits    (\s*(ext|x|ext.)\s*\d{2,5})?  # extension    )''', re.VERBOSE)

Handling File and Directory Paths

Backslash on Windows and Forward Slash on OS X and Linux

>>> import os>>> os.path.join('usr', 'bin', 'spam')'usr\\bin\\spam'

>>> from pathlib import Path>>> print(Path('usr').joinpath('bin').joinpath('spam')usr/bin/spam

>>> from pathlib import Path>>> print(Path('usr') / 'bin' / 'spam')usr/bin/spam

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']>>> for filename in my_files:>>>     print(os.path.join('C:\\Users\\asweigart', filename))C:\Users\asweigart\accounts.txtC:\Users\asweigart\details.csvC:\Users\asweigart\invite.docx

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']>>> home = Path.home()>>> for filename in my_files:>>>     print(home / filename)/home/asweigart/accounts.txt/home/asweigart/details.csv/home/asweigart/invite.docx

The Current Working Directory

>>> import os>>> os.getcwd()'C:\\Python34'>>> os.chdir('C:\\Windows\\System32')>>> os.getcwd()'C:\\Windows\\System32'

>>> from pathlib import Path>>> from os import chdir>>> print(Path.cwd())/home/asweigart>>> chdir('/usr/lib/python3.6')>>> print(Path.cwd())/usr/lib/python3.6

Creating New Folders

>>> import os>>> os.makedirs('C:\\delicious\\walnut\\waffles')

>>> from pathlib import Path>>> cwd = Path.cwd()>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir()Traceback (most recent call last):  File "<stdin>", line 1, in <module>  File "/usr/lib/python3.6/pathlib.py", line 1226, in mkdir    self._accessor.mkdir(self, mode)  File "/usr/lib/python3.6/pathlib.py", line 387, in wrapped    return strfunc(str(pathobj), *args)FileNotFoundError: [Errno 2] No such file or directory: '/home/asweigart/delicious/walnut/waffles'

>>> from pathlib import Path>>> cwd = Path.cwd()>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir(parents=True)

Absolute vs. Relative Paths

Handling Absolute and Relative Paths

>>> import os>>> os.path.isabs('/')True>>> os.path.isabs('..')False

>>> from pathlib import Path>>> Path('/').is_absolute()True>>> Path('..').is_absolute()False

>>> import os>>> os.getcwd()'/home/asweigart'>>> os.path.abspath('..')'/home'

from pathlib import Pathprint(Path.cwd())/home/asweigartprint(Path('..').resolve())/home

>>> import os>>> os.path.relpath('/etc/passwd', '/')'etc/passwd'

>>> from pathlib import Path>>> print(Path('/etc/passwd').relative_to('/'))etc/passwd

Checking Path Validity

import os>>> os.path.exists('.')True>>> os.path.exists('setup.py')True>>> os.path.exists('/etc')True>>> os.path.exists('nonexistentfile')False

from pathlib import Path>>> Path('.').exists()True>>> Path('setup.py').exists()True>>> Path('/etc').exists()True>>> Path('nonexistentfile').exists()False

>>> import os>>> os.path.isfile('setup.py')True>>> os.path.isfile('/home')False>>> os.path.isfile('nonexistentfile')False

>>> from pathlib import Path>>> Path('setup.py').is_file()True>>> Path('/home').is_file()False>>> Path('nonexistentfile').is_file()False

>>> import os>>> os.path.isdir('/')True>>> os.path.isdir('setup.py')False>>> os.path.isdir('/spam')False

>>> from pathlib import Path>>> Path('/').is_dir()True>>> Path('setup.py').is_dir()False>>> Path('/spam').is_dir()False

Finding File Sizes and Folder Contents

>>> import os>>> os.path.getsize('C:\\Windows\\System32\\calc.exe')776192

>>> from pathlib import Path>>> stat = Path('/bin/python3.6').stat()>>> print(stat) # stat contains some other information about the file as wellos.stat_result(st_mode=33261, st_ino=141087, st_dev=2051, st_nlink=2, st_uid=0,--snip--st_gid=0, st_size=10024, st_atime=1517725562, st_mtime=1515119809, st_ctime=1517261276)>>> print(stat.st_size) # size in bytes10024

>>> import os>>> os.listdir('C:\\Windows\\System32')['0409', '12520437.cpx', '12520850.cpx', '5U877.ax', 'aaclient.dll',--snip--'xwtpdui.dll', 'xwtpw32.dll', 'zh-CN', 'zh-HK', 'zh-TW', 'zipfldr.dll']

>>> from pathlib import Path>>> for f in Path('/usr/bin').iterdir():>>>     print(f).../usr/bin/tiff2rgba/usr/bin/iconv/usr/bin/ldd/usr/bin/cache_restore/usr/bin/udiskie/usr/bin/unix2dos/usr/bin/t1reencode/usr/bin/epstopdf/usr/bin/idle3...

>>> import os>>> total_size = 0>>> for filename in os.listdir('C:\\Windows\\System32'):      total_size = total_size + os.path.getsize(os.path.join('C:\\Windows\\System32', filename))>>> print(total_size)1117846456

>>> from pathlib import Path>>> total_size = 0>>> for sub_path in Path('/usr/bin').iterdir():...     total_size += sub_path.stat().st_size>>>>>> print(total_size)1903178911

Copying Files and Folders

>>> import shutil, os>>> os.chdir('C:\\')>>> shutil.copy('C:\\spam.txt', 'C:\\delicious')   'C:\\delicious\\spam.txt'>>> shutil.copy('eggs.txt', 'C:\\delicious\\eggs2.txt')   'C:\\delicious\\eggs2.txt'

>>> import shutil, os>>> os.chdir('C:\\')>>> shutil.copytree('C:\\bacon', 'C:\\bacon_backup')'C:\\bacon_backup'

Moving and Renaming Files and Folders

>>> import shutil>>> shutil.move('C:\\bacon.txt', 'C:\\eggs')'C:\\eggs\\bacon.txt'

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs\\new_bacon.txt')'C:\\eggs\\new_bacon.txt'

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs')'C:\\eggs'

Permanently Deleting Files and Folders

Safe Deletes with the send2trash Module

>>> import send2trash>>> with open('bacon.txt', 'a') as bacon_file: # creates the file...     bacon_file.write('Bacon is not a vegetable.')25>>> send2trash.send2trash('bacon.txt')

Walking a Directory Tree

>>> import os>>>>>> for folder_name, subfolders, filenames in os.walk('C:\\delicious'):>>>     print('The current folder is {}'.format(folder_name))>>>>>>     for subfolder in subfolders:>>>         print('SUBFOLDER OF {}: {}'.format(folder_name, subfolder))>>>     for filename in filenames:>>>         print('FILE INSIDE {}: {}'.format(folder_name, filename))>>>>>>     print('')The current folder is C:\deliciousSUBFOLDER OF C:\delicious: catsSUBFOLDER OF C:\delicious: walnutFILE INSIDE C:\delicious: spam.txtThe current folder is C:\delicious\catsFILE INSIDE C:\delicious\cats: catnames.txtFILE INSIDE C:\delicious\cats: zophie.jpgThe current folder is C:\delicious\walnutSUBFOLDER OF C:\delicious\walnut: wafflesThe current folder is C:\delicious\walnut\wafflesFILE INSIDE C:\delicious\walnut\waffles: butter.txt

Reading and Writing Files

The File Reading/Writing Process

Opening and reading files with the open() function

>>> with open('C:\\Users\\your_home_folder\\hello.txt') as hello_file:...     hello_content = hello_file.read()>>> hello_content'Hello World!'>>> # Alternatively, you can use the *readlines()* method to get a list of string values from the file, one string for each line of text:>>> with open('sonnet29.txt') as sonnet_file:...     sonnet_file.readlines()[When, in disgrace with fortune and men's eyes,\n', ' I all alone beweep myoutcast state,\n', And trouble deaf heaven with my bootless cries,\n', Andlook upon myself and curse my fate,']>>> # You can also iterate through the file line by line:>>> with open('sonnet29.txt') as sonnet_file:...     for line in sonnet_file: # note the new line character will be included in the line...         print(line, end='')When, in disgrace with fortune and men's eyes,I all alone beweep my outcast state,And trouble deaf heaven with my bootless cries,And look upon myself and curse my fate,

Writing to Files

>>> with open('bacon.txt', 'w') as bacon_file:...     bacon_file.write('Hello world!\n')13>>> with open('bacon.txt', 'a') as bacon_file:...     bacon_file.write('Bacon is not a vegetable.')25>>> with open('bacon.txt') as bacon_file:...     content = bacon_file.read()>>> print(content)Hello world!Bacon is not a vegetable.

Saving Variables with the shelve Module

>>> import shelve>>> cats = ['Zophie', 'Pooka', 'Simon']>>> with shelve.open('mydata') as shelf_file:...     shelf_file['cats'] = cats

>>> with shelve.open('mydata') as shelf_file:...     print(type(shelf_file))...     print(shelf_file['cats'])<class 'shelve.DbfilenameShelf'>['Zophie', 'Pooka', 'Simon']

>>> with shelve.open('mydata') as shelf_file:...     print(list(shelf_file.keys()))...     print(list(shelf_file.values()))['cats'][['Zophie', 'Pooka', 'Simon']]

Saving Variables with the pprint.pformat() Function

>>> import pprint>>> cats = [{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}]>>> pprint.pformat(cats)"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]">>> with open('myCats.py', 'w') as file_obj:...     file_obj.write('cats = {}\n'.format(pprint.pformat(cats)))83

Reading ZIP Files

>>> import zipfile, os>>> os.chdir('C:\\')    # move to the folder with example.zip>>> with zipfile.ZipFile('example.zip') as example_zip:...     print(example_zip.namelist())...     spam_info = example_zip.getinfo('spam.txt')...     print(spam_info.file_size)...     print(spam_info.compress_size)...     print('Compressed file is %sx smaller!' % (round(spam_info.file_size / spam_info.compress_size, 2)))['spam.txt', 'cats/', 'cats/catnames.txt', 'cats/zophie.jpg']139083828'Compressed file is 3.63x smaller!'

Extracting from ZIP Files

>>> import zipfile, os>>> os.chdir('C:\\')    # move to the folder with example.zip>>> with zipfile.ZipFile('example.zip') as example_zip:...     example_zip.extractall()

>>> with zipfile.ZipFile('example.zip') as example_zip:...     print(example_zip.extract('spam.txt'))...     print(example_zip.extract('spam.txt', 'C:\\some\\new\\folders'))'C:\\spam.txt''C:\\some\\new\\folders\\spam.txt'

Creating and Adding to ZIP Files

>>> import zipfile>>> with zipfile.ZipFile('new.zip', 'w') as new_zip:...     new_zip.write('spam.txt', compress_type=zipfile.ZIP_DEFLATED)

JSON, YAML and configuration files

JSON

import jsonwith open("filename.json", "r") as f:    content = json.loads(f.read())

import jsoncontent = {"name": "Joe", "age": 20}with open("filename.json", "w") as f:    f.write(json.dumps(content, indent=2))

YAML

from ruamel.yaml import YAMLwith open("filename.yaml") as f:    yaml=YAML()    yaml.load(f)

Anyconfig

pip install anyconfig

import anyconfigconf1 = anyconfig.load("/path/to/foo/conf.d/a.yml")

Debugging

Raising Exceptions

>>> raise Exception('This is the error message.')Traceback (most recent call last):  File "<pyshell#191>", line 1, in <module>    raise Exception('This is the error message.')Exception: This is the error message.

def box_print(symbol, width, height):    if len(symbol) != 1:      raise Exception('Symbol must be a single character string.')    if width <= 2:      raise Exception('Width must be greater than 2.')    if height <= 2:      raise Exception('Height must be greater than 2.')    print(symbol * width)    for i in range(height - 2):        print(symbol + (' ' * (width - 2)) + symbol)    print(symbol * width)for sym, w, h in (('*', 4, 4), ('O', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):    try:        box_print(sym, w, h)  except Exception as err:      print('An exception happened: ' + str(err))

Getting the Traceback as a String

>>> import traceback>>> try:>>>      raise Exception('This is the error message.')>>> except:>>>      with open('errorInfo.txt', 'w') as error_file:>>>          error_file.write(traceback.format_exc())>>>      print('The traceback info was written to errorInfo.txt.')116The traceback info was written to errorInfo.txt.

Traceback (most recent call last):  File "<pyshell#28>", line 2, in <module>Exception: This is the error message.

Assertions

>>> pod_bay_door_status = 'open'>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'>>> pod_bay_door_status = 'I\'m sorry, Dave. I\'m afraid I can\'t do that.'>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'Traceback (most recent call last):  File "<pyshell#10>", line 1, in <module>    assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'AssertionError: The pod bay doors need to be "open".

Logging

import logginglogging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')

>>> import logging>>>>>> logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')>>>>>> logging.debug('Start of program')>>>>>> def factorial(n):>>>>>>     logging.debug('Start of factorial(%s)' % (n))>>>     total = 1>>>>>>     for i in range(1, n + 1):>>>         total *= i>>>         logging.debug('i is ' + str(i) + ', total is ' + str(total))>>>>>>     logging.debug('End of factorial(%s)' % (n))>>>>>>     return total>>>>>> print(factorial(5))>>> logging.debug('End of program')2015-05-23 16:20:12,664 - DEBUG - Start of program2015-05-23 16:20:12,664 - DEBUG - Start of factorial(5)2015-05-23 16:20:12,665 - DEBUG - i is 0, total is 02015-05-23 16:20:12,668 - DEBUG - i is 1, total is 02015-05-23 16:20:12,670 - DEBUG - i is 2, total is 02015-05-23 16:20:12,673 - DEBUG - i is 3, total is 02015-05-23 16:20:12,675 - DEBUG - i is 4, total is 02015-05-23 16:20:12,678 - DEBUG - i is 5, total is 02015-05-23 16:20:12,680 - DEBUG - End of factorial(5)02015-05-23 16:20:12,684 - DEBUG - End of program

Logging Levels

Disabling Logging

>>> import logging>>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s -%(levelname)s - %(message)s')>>> logging.critical('Critical error! Critical error!')2015-05-22 11:10:48,054 - CRITICAL - Critical error! Critical error!>>> logging.disable(logging.CRITICAL)>>> logging.critical('Critical error! Critical error!')>>> logging.error('Error! Error!')

Logging to a File

import logginglogging.basicConfig(filename='myProgramLog.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

Lambda Functions

>>> def add(x, y):        return x + y>>> add(5, 3)8

>>> add = lambda x, y: x + y>>> add(5, 3)8

>>> (lambda x, y: x + y)(5, 3)8

>>> def make_adder(n):        return lambda x: x + n>>> plus_3 = make_adder(3)>>> plus_5 = make_adder(5)>>> plus_3(4)7>>> plus_5(4)9

Ternary Conditional Operator

<expression1> if <condition> else <expression2>

>>> age = 15>>> print('kid' if age < 18 else 'adult')kid

>>> age = 15>>> print('kid' if age < 13 else 'teenager' if age < 18 else 'adult')teenager

if age < 18:    if age < 12:        print('kid')    else:        print('teenager')else:    print('adult')

Virtual Environment

virtualenv

pipenv