Real Python Learning Notes

Video Tutorials

Text Based Tutorials

Interactive Quizzes

Using the REPL

Running a script from the command line

Interacting with Python through an IDE

Methods

a = 'hello there'
print(dir(a))

a = 'hello there'
print(a.upper())

HELLO THERE

print(dir(int))

Use The Help Command

help(int)

help(print)

pdb (the python debugger)

import random
import pdb
print ('Guess a number between 1 and 10')
number = random.randint(1, 10)
guess = int(input())
pdb.set_trace()                # pdb will take over from here
if guess == number:
    print(f'Correct - the number was {number}')
else:
    print(f'Sorry, the number was {number}, not {guess}')

• pdb commands
  
  • l list out the program and show what line you are on
  • You can type variable names directly to show their value and it will indicate whether it's a 'string' or an integer.
  • c continues the program

  You can move the trace command anywhere you'd like in the program.

Escape Sequences

a = 'This is line 1.\nThis is line 2.'
print(a)

This is line 1.
This is line 2.

Escape Characters

Raw Strings

a = "One Line\nTwo!"
b = r"One Line/nTwo!"
print(a)
print(b)

One Line
Two!
One Line/nTwo!

Triple Quoted Strings

print("""This is 'a' "triple-quoted" string""")

This is 'a' "triple-quoted" string

print('''Hey, we're going to try multiple lines here...
by doing this...
and this...
and this...''')

Hey, we're going to try multiple lines here...
by doing this...
and this...
and this...

def my_function(value):
    """Takes a value and prints it to the screen."""
    print(f"{value} is a nice value")
    return

my_function('hello')

hello is a nice value

Truthiness

a = 5
print(a == 5)

True

b = 1
if b:                      # this is the same as saying, "if b is True..."
    print('b is true')
else:
    print('b is false') 

b is true

Composite Data Types

• List
  
  • Lists are defined as a = [1, 2, 3, 4, 5]
  • Lists are 0 indexed meaning the first result is represented by 0.
  • You can also use negative indexing to get a value from the back of the list.

  a = [1, 2, 3, 4, 5, 6]
  print(a[0])
  print(a[-1])
  
  

  1
  6
  

  • You can also use slicing to include a range:

  a = [1, 2, 3, 4, 5]
  print(a[1:3])
  
  

  [2, 3]
  

  Note above that what was printed is in between the indexes given. The value of position 3 was not included.

  You can change a specific value in a list with a[2] = 6

• Tuple
  
  • A tuple is similar to a list but is defined using parens instead: a = (1, 2, 3, 4, 5)
  • Similarly, it is 0 indexed like lists.

  You cannot reassign values when using a tuple:

  a = (1, 2, 3, 4, 5)
  a[2] = 6   # This will not work and will result in the error 'tuple' object does not support item assigmnent
  
  

  Therefore, tuples are immutable.

• Set
  

  Sets are similar to lists but can only contain unique values:

  a = [1, 2, 3, 3, 3, 3, 4, 5]
  b = set(a)
  print(a)
  print(b)
  
  

  [1, 2, 3, 3, 3, 3, 4, 5]
  {1, 2, 3, 4, 5}
  

  You can create a list from a set so you can act upon it in the normal way:

  a = [1, 2, 3, 3, 3, 3, 4, 5]
  b = set(a)
  print(a)
  print(b)
  c = list(b)
  print(c)
  
  

  [1, 2, 3, 3, 3, 3, 4, 5]      # this is a list
  {1, 2, 3, 4, 5}               # this is a set
  [1, 2, 3, 4, 5]               # this is a list again
  

• Dict or Dictionary
  
  • Best thought of as a lookup table which allows you to store values in it with key/value pairs

  a = dict()                 # an empty dictionary is created
  
  # Key value pairs are assigned
  a['name'] = 'Aleks'
  a['age'] = '41'
  print(a)                   # print the entire contents of the dict
  print(a['age'])            # print only the value of 'age'
  print(a.get('country'))    # You can use the get method and it won't throw an error if a key isn'r present
  
  

  {'name': 'Aleks', 'age': '41'}
  41
  None
  

  In this case, both keys are strings, while the value for 'name' is a string and the value for 'age' is an int.

Math

• abs
  

  The absolute value function basically takes the sign away from the number.

  a = 5
  b = -5
  print(abs(a))
  print(abs(b))
  
  

  5
  5
  

• Modulo
  

  Modulo gives the remainder:

  a = 15 % 4
  print(a)
  
  

  3
  

• divmod
  

  Divmod will show us how many times a number goes into another, and the remainder as well:

  a = divmod(15, 4)
  print(a)
  
  

  (3, 3)
  

• max
  

  Max will provide the maximum of an iterable:

  print(max(1, 2, 3, 4, 5))
  
  

  5
  

• min
  

  Min will provide the minimum of an iterable.

• pow
  

  Can take 2 arguments or 3. When given 3, the third has something to do with the modulo.

  print(pow(3, 2))
  
  

  9
  

• round
  

  Rounds a number to the nearest integer.

  print(round(4.6))
  print(int(4.6))
  
  

  5
  4
  

  Note that 4.5 is rounded down. Int will always just take the decimal away - Not the same as rounding.

• sum
  

  Sums the iterables which are passed.

  print(sum([1, 2, 3, 4, 5]))
  print(sum([1, 2, 3, 4, 5], 10))     # In this case, an optional "start value" was provided
  

  15
  25
  

Type Conversion

• ascii
  

  Shows the ascii equiv of a string:

  print(ascii('hello'))
  print(ascii('はい'))     # In this case, unicode characters were used, so escape characters are shiws with the ascii equiv.
  
  

  'hello'
  '\u306f\u3044'
  

• chr
  

  Returns a unicode string of one character with ordinal. You can look up these values on an ascii able. There are 128 values in the ascii alphabet. Chr also works for unicode characters.

  print(chr(97))
  print(chr(34))
  print(chr(0x06a4))
  
  

  a
  "
  ڤ
  

  Note: - Ascii codes are the same as unicode below 128.

• ord
  

  Will give you the ascii or unicode code for a character:

  print(ord('a'))
  
  

  97
  

• type
  

  Will give the type of the object like string, int, float, bool, list, etc.

Iterables and Iterators

• len
  

  a = [1, 4, 6, 3, 5, 2]
  print(len(a))
  
  

  6
  

• any and all
  

  Returns a boolean showing if any of the values were true of all of the values were true.

  a = [True, True, True]
  b = [True, False, True]
  c = [False, False, False]
  print(any(a))
  print(any(b))
  print(any(c))
  print(all(a))
  print(all(b))
  print(all(c))
  
  

  True
  True
  False
  True
  False
  False
  

• reversed
  

  Gives an iterator object that represents the reverse of the object you're working with.

  a = [1, 4, 3, 4, 2, 5, 4, 3]
  print(reversed(a))
  print(list(reversed(a)))
  
  

  <list_reverseiterator object at 0x7f9857363f70>
  [3, 4, 5, 2, 4, 3, 4, 1]
  

  Note that we had to use the list function here to actually see the values. You won't always have to do this in your code because Python will often deal with the iterator.

• sorted
  

  Produces a sorted list

  a = [4, 2, 6, 1, 2, 9, 3]
  print(sorted(a))
  
  

  [1, 2, 2, 3, 4, 6, 9]
  

• range
  

  Gives us the range:

  • If a single number is provided, it will give the range between 0 and that number. The number itself will not be included.
  • If two numbers are provided, it will give the range between those numbers.
  • If a third argument is provided, it will use that as the stride.

  print(list(range(10, 50, 5)))
  
  

  [10, 15, 20, 25, 30, 35, 40, 45]
  

• enumerate
  

  Displays a counter in a loop (I think):

  players = ['Mike','Bob','Sarah','Charlie','Jo']
  
  for count, player in enumerate(players):
      print(count, player)
  
  

  0 Mike
  1 Bob
  2 Sarah
  3 Charlie
  4 Jo
  

  So, with enumerate, we don't have to increment a counter each time a loop is run.

• zip
  

  countries = ['France','Tanzania','Cabada']
  continents = ['Europe','Africa','North America']
  
  merged = []
  for i in range(len(countries)):
      merged.append((countries[i], continents[i]))
  
  print(merged)
  
  # There's a much simpler way to do this using zip:
  
  merged_2 = zip(countries, continents)
  print(list(merged_2))
  
  

  [('France', 'Europe'), ('Tanzania', 'Africa'), ('Cabada', 'North America')]
  [('France', 'Europe'), ('Tanzania', 'Africa'), ('Cabada', 'North America')]
  

• iter and next
  

  It's possible to create an iterator using any iterable. next is a method which pops the next value off that iterator until it's exhausted.

  a = iter([1, 2, 3, 4, 5, 6])
  print(next(a))
  print(next(a))
  print(next(a))
  print(next(a))
  print(next(a))
  print(next(a))
  
  

  1
  2
  3
  4
  5
  6
  

  If I were to have run next again, you'd get a StopIteration exception.

Input/Output

• print
  
  • end defaults to the new line character \n

  In the code below, we're changing end to a space instead so each number is not printed on a new line. We add another print statement at the end just to get the prompt back to the next line.

  for i in range(100):
      print(i, end=' ')
  print()
  
  

  0 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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 
  

• open
  

  Here, we open a file and write to it:

  file = open('test.txt, 'w')    # opens test.txt in write mode
  file.write('Hello World!\n')
  file.close()
  
  

  Here, we read from a file:

  file = open('test.txt'. 'r')     # opens test.txt in read mode
  print(file.readlines())          # print contents of file as list
  file.close()
  
  

Variables, References and Scope

• dir
  
  • Allows you to see all of the attributes and methods that any Python has.
  • Allows you to see what you can do with any object basically.

  a = 'hello'
  print(dir(a))
  
  

  ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
  

  The double underscores are dunder methods. We won't have to worry about them for now.

• vars and globals
  

  So below, we've set the value of variables, defined a function which re-defines those variables, and then we're printing directly, and via the function to illustrate the difference between global and local scopes.

  a = 1
  b = 'global'
  c = 'another global'
  
  def function():
      a = 2
      b = 'local'
      print(a, b)
      print(vars()) # prints all the variables available within the scope in a dict.
      print(c) # prints the value of c from the global scope since it can't find it from the local scope.
  
  print(a, b)
  function()
  print(a ,b)
  
  

  1 global
  2 local
  {'a': 2, 'b': 'local'}
  another global
  1 global
  

  print(globals()) will give the list of global vars within any scope.

Misc

• exec
  
  • Allows you to execute any Python code.

  import os     # gives you access to info about the computer/os
  
  job = input('Tell me a task to do: ')
  exec(job)
  
  

  The program above will prompt you for input and allow you to execute any Python command.

  The problem here is that, because we've imported the os module, you can run any code on the computer and fry it - os.system('rm -rf *.*')

• eval
  
  • Allows you to evaluate the value of a Python function.

  calc = input('Give me some maths to do: ')
  print(eval(calc))     # work out calc, and then give me the value of it.
  
  

  Again, if you've imported os, you'll have access to the system in this case.

  Using print(eval(calc, {})) instead, means no named functions will be accepted and the exploit above won't be available.

  You can specify a function explicitly to allow, print(eval(calc, {'pow': pow})) for intance.

• hash
  
  • One way function that gives a summary of the function it has been passed.

  The hash of any int will be the value of that int

  print(hash(123))
  
  

  123
  

  The story is somewhat different for text:

  print(hash('Hello World'))
  
  

  1465864162751722754
  

  If you have two pieces of text that are somewhat similar, you'll be able to tell them apart better by comparing the hashes instead.

  You can compare an entire book that differs in one character easily using hashes.

Standard Variable Assignment

Chained Variable Assignment

• Multiple Assignment
  
  • a, b = 300, 400
  • Use commas to separate
• Variable Types
  
  • int, string, etc.
  • You can check the type with type(n)
  • Variables are simply references to objects. Everything in Python is an object.

Object Value vs. Object Identity

n = 300
print(n)
print(id(n))

300
140396967598928

n = 300
m = 300
print(id(n))
print(id(m))

Small Integer Caching

a = 30
b = 30
print(a == b)
print(id(a) == id(b))

True
True

Naming Conventions

PEP-8