2020-12-25 09:55:10 +08:00
---
title: Python
date: 2020-12-23 18:41:20
2021-12-15 10:48:31 +08:00
background: bg-[#436b97 ]
2020-12-25 09:55:10 +08:00
tags:
2021-07-12 19:21:35 +08:00
- script
2021-07-13 14:50:07 +08:00
- interpret
2020-12-25 09:55:10 +08:00
categories:
2021-07-12 19:21:35 +08:00
- Programming
2020-12-25 09:55:10 +08:00
intro: |
The [Python ](https://www.python.org/ ) cheat sheet is a one-page reference sheet for the Python 3 programming language.
2023-03-06 16:19:19 +08:00
plugins:
- copyCode
2020-12-25 09:55:10 +08:00
---
2022-11-20 15:30:55 +08:00
Getting Started
2020-12-25 09:55:10 +08:00
---------------
### Introduction
- [Python ](https://www.python.org/ ) _ (python.org) _
- [Learn X in Y minutes ](https://learnxinyminutes.com/docs/python/ ) _ (learnxinyminutes.com) _
2023-06-15 10:44:51 +08:00
- [Regex in python ](/regex#regex-in-python ) _ (cheatsheets.zip) _
2020-12-25 09:55:10 +08:00
### Hello World
``` python
>> > print ( " Hello, World! " )
Hello , World !
```
The famous "Hello World" program in Python
### Variables
``` python
2021-12-15 20:07:49 +08:00
age = 18 # age is of type int
name = " John " # name is now of type str
print ( name )
2020-12-25 09:55:10 +08:00
```
2021-12-15 19:59:59 +08:00
Python can't declare a variable without assignment.
2020-12-25 09:55:10 +08:00
### Data Types {.row-span-2}
2021-09-14 13:03:55 +08:00
| | |
|------------------------------------|----------|
| `str` | Text |
| `int` , `float` , `complex` | Numeric |
2020-12-25 09:55:10 +08:00
| `list` , `tuple` , `range` | Sequence |
2021-09-14 13:03:55 +08:00
| `dict` | Mapping |
| `set` , `frozenset` | Set |
| `bool` | Boolean |
| `bytes` , `bytearray` , `memoryview` | Binary |
2021-12-15 20:16:34 +08:00
See: [Data Types ](#python-data-types )
2020-12-25 09:55:10 +08:00
### Slicing String
``` python
2021-12-15 20:07:49 +08:00
>> > msg = " Hello, World! "
>> > print ( msg [ 2 : 5 ] )
2020-12-25 09:55:10 +08:00
llo
```
2021-12-15 20:16:34 +08:00
See: [Strings ](#python-strings )
2020-12-25 09:55:10 +08:00
### Lists
``` python
mylist = [ ]
mylist . append ( 1 )
mylist . append ( 2 )
2021-12-15 20:07:49 +08:00
for item in mylist :
print ( item ) # prints out 1,2
2020-12-25 09:55:10 +08:00
```
2021-12-15 20:16:34 +08:00
See: [Lists ](#python-lists )
2020-12-25 09:55:10 +08:00
### If Else
``` python
2021-12-15 20:07:49 +08:00
num = 200
if num > 0 :
print ( " num is greater than 0 " )
2020-12-25 09:55:10 +08:00
else :
2021-12-15 20:07:49 +08:00
print ( " num is not greater than 0 " )
2020-12-25 09:55:10 +08:00
```
2021-12-15 20:16:34 +08:00
See: [Flow control ](#python-flow-control )
2020-12-25 09:55:10 +08:00
### Loops
``` python
2021-12-15 20:07:49 +08:00
for item in range ( 6 ) :
if item == 3 : break
print ( item )
2020-12-25 09:55:10 +08:00
else :
2021-02-10 10:03:06 +08:00
print ( " Finally finished! " )
2020-12-25 09:55:10 +08:00
```
2021-12-15 20:16:34 +08:00
See: [Loops ](#python-loops )
2020-12-25 09:55:10 +08:00
### Functions
``` python
>> > def my_function ( ) :
2021-02-10 10:07:39 +08:00
. . . print ( " Hello from a function " )
2020-12-25 09:55:10 +08:00
. . .
>> > my_function ( )
Hello from a function
```
2021-12-15 20:16:34 +08:00
See: [Functions ](#python-functions )
2020-12-25 09:55:10 +08:00
### File Handling {.col-span-2}
``` python
with open ( " myfile.txt " , " r " , encoding = ' utf8 ' ) as file :
2021-12-15 20:07:49 +08:00
for line in file :
print ( line )
2020-12-25 09:55:10 +08:00
```
2021-12-15 20:16:34 +08:00
See: [File Handling ](#python-file-handling )
2020-12-25 09:55:10 +08:00
### Arithmetic
``` python
2021-12-15 18:56:08 +08:00
result = 10 + 30 # => 40
result = 40 - 10 # => 30
result = 50 * 5 # => 250
result = 16 / 4 # => 4.0 (Float Division)
result = 16 / / 4 # => 4 (Integer Division)
result = 25 % 2 # => 1
result = 5 * * 3 # => 125
2020-12-25 09:55:10 +08:00
` ` `
2021-12-15 18:56:08 +08:00
The ` / ` means quotient of x and y , and the ` / / ` means floored quotient of x and y , also see [ StackOverflow ] ( https : / / stackoverflow . com / a / 183870 / 13192320 )
2020-12-25 09:55:10 +08:00
### Plus-Equals
` ` ` python
counter = 0
counter + = 10 # => 10
counter = 0
counter = counter + 10 # => 10
message = " Part 1. "
2021-12-15 19:55:02 +08:00
2020-12-25 09:55:10 +08:00
# => Part 1.Part 2.
message + = " Part 2. "
```
2021-12-15 19:55:02 +08:00
### f-Strings (Python 3.6+)
``` python
>> > website = ' Quickref.ME '
>> > f " Hello, { website } "
" Hello, Quickref.ME "
2022-02-06 17:28:17 -03:00
>> > num = 10
2021-12-15 19:55:02 +08:00
>> > f ' { num } + 10 = { num + 10 } '
' 10 + 10 = 20 '
```
2022-11-22 15:41:06 +08:00
See: [Python F-Strings ](#python-f-strings-since-python-3-6 )
2020-12-25 09:55:10 +08:00
2022-02-06 17:28:17 -03:00
2022-11-21 18:11:14 -06:00
Python Built-in Data Types
2020-12-25 09:55:10 +08:00
---------------
### Strings
``` python
2021-12-15 20:07:49 +08:00
hello = " Hello World "
hello = ' Hello World '
2020-12-25 09:55:10 +08:00
2021-12-15 20:07:49 +08:00
multi_string = """ Multiline Strings
2020-12-25 09:55:10 +08:00
Lorem ipsum dolor sit amet,
consectetur adipiscing elit """
```
2021-12-19 15:22:40 +08:00
See: [Strings ](#python-strings )
2020-12-25 09:55:10 +08:00
### Numbers
``` python
x = 1 # int
y = 2.8 # float
z = 1 j # complex
>> > print ( type ( x ) )
< class ' int ' >
```
### Booleans
``` python
2021-12-15 20:07:49 +08:00
my_bool = True
my_bool = False
2020-12-25 09:55:10 +08:00
bool ( 0 ) # => False
bool ( 1 ) # => True
```
### Lists
``` python
list1 = [ " apple " , " banana " , " cherry " ]
list2 = [ True , False , False ]
list3 = [ 1 , 5 , 7 , 9 , 3 ]
list4 = list ( ( 1 , 5 , 7 , 9 , 3 ) )
```
2021-12-19 15:22:40 +08:00
See: [Lists ](#python-lists )
2020-12-25 09:55:10 +08:00
### Tuple
``` python
2021-12-15 20:07:49 +08:00
my_tuple = ( 1 , 2 , 3 )
my_tuple = tuple ( ( 1 , 2 , 3 ) )
2020-12-25 09:55:10 +08:00
```
Similar to List but immutable
### Set
``` python
set1 = { " a " , " b " , " c " }
set2 = set ( ( " a " , " b " , " c " ) )
```
Set of unique items/objects
### Dictionary
2021-02-10 10:03:06 +08:00
```python {.wrap}
2020-12-25 09:55:10 +08:00
>>> empty_dict = {}
>>> a = {"one": 1, "two": 2, "three": 3}
>>> a["one"]
1
>>> a.keys()
dict_keys(['one', 'two', 'three'])
>>> a.values()
dict_values([1, 2, 3])
2021-02-10 10:03:06 +08:00
>>> a.update({"four": 4})
2020-12-25 09:55:10 +08:00
>>> a.keys()
2021-02-10 10:03:06 +08:00
dict_keys(['one', 'two', 'three', 'four'])
2020-12-25 09:55:10 +08:00
>>> a['four']
4
` ``
Key: Value pair, JSON like object
### Casting
#### Integers
` ``python
x = int(1) # x will be 1
y = int(2.8) # y will be 2
z = int("3") # z will be 3
` ``
#### Floats
` ``python
x = float(1) # x will be 1.0
y = float(2.8) # y will be 2.8
z = float("3") # z will be 3.0
w = float("4.2") # w will be 4.2
` ``
#### Strings
` ``python
x = str("s1") # x will be 's1'
y = str(2) # y will be '2'
z = str(3.0) # z will be '3.0'
` ``
2022-11-21 18:11:14 -06:00
Python Advanced Data Types
2022-11-21 18:05:03 -06:00
-----------------------
### Heaps {.col-span-2 .row-span-3}
` ``python
import heapq
myList = [9, 5, 4, 1, 3, 2]
heapq.heapify(myList) # turn myList into a Min Heap
2022-11-22 11:35:10 +08:00
print(myList) # => [1, 3, 2, 5, 9, 4]
2022-11-21 18:05:03 -06:00
print(myList[0]) # first value is always the smallest in the heap
heapq.heappush(myList, 10) # insert 10
2022-11-22 11:35:10 +08:00
x = heapq.heappop(myList) # pop and return smallest item
print(x) # => 1
2022-11-21 18:05:03 -06:00
` ``
#### Negate all values to use Min Heap as Max Heap
` ``python
myList = [9, 5, 4, 1, 3, 2]
myList = [-val for val in myList] # multiply by -1 to negate
heapq.heapify(myList)
x = heapq.heappop(myList)
print(-x) # => 9 (making sure to multiply by -1 again)
` ``
2022-11-21 18:13:49 -06:00
Heaps are binary trees for which every parent node has a value less than or equal to any of its children. Useful for accessing min/max value quickly. Time complexity: O(n) for heapify, O(log n) push and pop. See: [Heapq](https://docs.python.org/3/library/heapq.html)
2022-11-21 18:05:03 -06:00
### Stacks and Queues {.row-span-3}
` ``python
from collections import deque
2022-11-22 11:35:10 +08:00
q = deque() # empty
2022-11-21 18:05:03 -06:00
q = deque([1, 2, 3]) # with values
2022-11-22 11:35:10 +08:00
q.append(4) # append to right side
2022-11-21 18:05:03 -06:00
q.appendleft(0) # append to left side
2022-11-22 11:35:10 +08:00
print(q) # => deque([0, 1, 2, 3, 4])
2022-11-21 18:05:03 -06:00
x = q.pop() # remove & return from right
y = q.popleft() # remove & return from left
2022-11-22 11:35:10 +08:00
print(x) # => 4
print(y) # => 0
print(q) # => deque([1, 2, 3])
2022-11-21 18:05:03 -06:00
q.rotate(1) # rotate 1 step to the right
2022-11-22 11:35:10 +08:00
print(q) # => deque([3, 1, 2])
2022-11-21 18:05:03 -06:00
` ``
Deque is a double-ended queue with O(1) time for append/pop operations from both sides. Used as stacks and queues. See: [Deque](https://docs.python.org/3/library/collections.html#collections.deque)
2020-12-25 09:55:10 +08:00
2022-11-20 15:30:55 +08:00
Python Strings
2020-12-25 09:55:10 +08:00
------------
### Array-like
` ``python
2021-12-15 20:07:49 +08:00
>>> hello = "Hello, World"
>>> print(hello[1])
2020-12-25 09:55:10 +08:00
e
2021-12-15 20:16:34 +08:00
>>> print(hello[-1])
2020-12-25 09:55:10 +08:00
d
` ``
2021-12-15 20:16:34 +08:00
Get the character at position 1 or last
2020-12-25 09:55:10 +08:00
### Looping
` ``python
2021-12-15 20:16:34 +08:00
>>> for char in "foo":
2021-12-15 20:07:49 +08:00
... print(char)
2021-12-15 20:16:34 +08:00
f
o
o
2020-12-25 09:55:10 +08:00
` ``
2021-12-15 20:16:34 +08:00
Loop through the letters in the word "foo"
2020-12-25 09:55:10 +08:00
### Slicing string {.row-span-4}
2021-04-20 17:44:59 +08:00
` ``java
2021-04-20 17:43:03 +08:00
┌───┬───┬───┬───┬───┬───┬───┐
2020-12-25 09:55:10 +08:00
| m | y | b | a | c | o | n |
2021-04-20 17:43:03 +08:00
└───┴───┴───┴───┴───┴───┴───┘
2020-12-25 09:55:10 +08:00
0 1 2 3 4 5 6 7
-7 -6 -5 -4 -3 -2 -1
` ``
---
2021-02-18 11:25:39 +08:00
` ``python
2020-12-25 09:55:10 +08:00
>>> s = 'mybacon'
>>> s[2:5]
'bac'
>>> s[0:2]
'my'
` ``
` ``python
>>> s = 'mybacon'
>>> s[:2]
'my'
>>> s[2:]
'bacon'
>>> s[:2] + s[2:]
'mybacon'
>>> s[:]
'mybacon'
` ``
` ``python
>>> s = 'mybacon'
>>> s[-5:-1]
'baco'
>>> s[2:6]
'baco'
` ``
#### With a stride
` ``python
>>> s = '12345' * 5
>>> s
'1234512345123451234512345'
>>> s[::5]
'11111'
>>> s[4::5]
'55555'
>>> s[::-5]
'55555'
>>> s[::-1]
'5432154321543215432154321'
` ``
### String Length
` ``python
2021-12-15 20:07:49 +08:00
>>> hello = "Hello, World!"
>>> print(len(hello))
2020-12-25 09:55:10 +08:00
13
` ``
The len() function returns the length of a string
### Multiple copies
` ``python
>>> s = '===+'
>>> n = 8
>>> s * n
'===+===+===+===+===+===+===+===+'
` ``
### Check String
` ``python
>>> s = 'spam'
>>> s in 'I saw spamalot!'
True
>>> s not in 'I saw The Holy Grail!'
True
` ``
### Concatenates
` ``python
>>> s = 'spam'
>>> t = 'egg'
>>> s + t
'spamegg'
>>> 'spam' 'egg'
'spamegg'
` ``
### Formatting {.col-span-2}
` ``python
name = "John"
print("Hello, %s!" % name)
` ``
` ``python
name = "John"
age = 23
print("%s is %d years old." % (name, age))
` ``
#### format() Method
` ``python
2022-02-06 17:35:45 -03:00
txt1 = "My name is {fname}, I'm {age}".format(fname="John", age=36)
txt2 = "My name is {0}, I'm {1}".format("John", 36)
txt3 = "My name is {}, I'm {}".format("John", 36)
2020-12-25 09:55:10 +08:00
` ``
### Input
2021-02-18 11:25:39 +08:00
` ``python
2020-12-25 09:55:10 +08:00
>>> name = input("Enter your name: ")
Enter your name: Tom
>>> name
'Tom'
` ``
Get input data from console
### Join
` ``python
>>> "#".join(["John", "Peter", "Vicky"])
'John#Peter#Vicky'
` ``
### Endswith
` ``python
>>> "Hello, world!".endswith("!")
True
` ``
2022-11-20 15:30:55 +08:00
Python F-Strings (Since Python 3.6+)
2021-12-15 19:55:02 +08:00
----------------
### f-Strings usage
` ``python
>>> website = 'Quickref.ME'
>>> f"Hello, {website}"
"Hello, Quickref.ME"
2022-02-06 17:41:24 -03:00
>>> num = 10
2021-12-15 19:55:02 +08:00
>>> f'{num} + 10 = {num + 10}'
'10 + 10 = 20'
>>> f"""He said {"I'm John"}"""
"He said I'm John"
>>> f'5 {"{stars}"}'
'5 {stars}'
>>> f'{{5}} {"stars"}'
'{5} stars'
>>> name = 'Eric'
>>> age = 27
>>> f"""Hello!
... I'm {name}.
... I'm {age}."""
"Hello!\n I'm Eric.\n I'm 27."
` ``
it is available since Python 3.6, also see: [Formatted string literals](https://docs.python.org/3/reference/lexical_analysis.html#f-strings)
### f-Strings Fill Align
` ``python
>>> f'{"text":10}' # [width]
'text '
>>> f'{"test":*>10}' # fill left
'******test'
>>> f'{"test":*<10}' # fill right
'test******'
>>> f'{"test":*^10}' # fill center
'***test***'
>>> f'{12345:0>10}' # fill with numbers
'0000012345'
` ``
### f-Strings Type
` ``python
>>> f'{10:b}' # binary type
'1010'
>>> f'{10:o}' # octal type
'12'
>>> f'{200:x}' # hexadecimal type
'c8'
>>> f'{200:X}'
'C8'
>>> f'{345600000000:e}' # scientific notation
'3.456000e+11'
>>> f'{65:c}' # character type
'A'
>>> f'{10:#b}' # [type] with notation (base)
'0b1010'
>>> f'{10:#o}'
'0o12'
>>> f'{10:#x}'
'0xa'
` ``
### F-Strings Others
` ``python
>>> f'{-12345:0=10}' # negative numbers
'-000012345'
>>> f'{12345:010}' # [0] shortcut (no align)
'0000012345'
>>> f'{-12345:010}'
'-000012345'
>>> import math # [.precision]
>>> math.pi
3.141592653589793
>>> f'{math.pi:.2f}'
'3.14'
>>> f'{1000000:,.2f}' # [grouping_option]
'1,000,000.00'
>>> f'{1000000:_.2f}'
'1_000_000.00'
>>> f'{0.25:0%}' # percentage
'25.000000%'
>>> f'{0.25:.0%}'
'25%'
` ``
### F-Strings Sign
` ``python
>>> f'{12345:+}' # [sign] (+/-)
'+12345'
>>> f'{-12345:+}'
'-12345'
>>> f'{-12345:+10}'
' -12345'
>>> f'{-12345:+010}'
'-000012345'
` ``
2020-12-25 09:55:10 +08:00
2022-11-20 15:30:55 +08:00
Python Lists
2020-12-25 09:55:10 +08:00
------------
### Defining
` ``python
>>> li1 = []
>>> li1
[]
>>> li2 = [4, 5, 6]
>>> li2
[4, 5, 6]
>>> li3 = list((1, 2, 3))
>>> li3
[1, 2, 3]
>>> li4 = list(range(1, 11))
>>> li4
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
` ``
### Generate {.col-span-2}
` ``python
>>> list(filter(lambda x : x % 2 == 1, range(1, 20)))
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> [x ** 2 for x in range (1, 11) if x % 2 == 1]
[1, 9, 25, 49, 81]
>>> [x for x in [3, 4, 5, 6, 7] if x > 5]
[6, 7]
>>> list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))
[6, 7]
` ``
### Append
` ``python
>>> li = []
>>> li.append(1)
>>> li
[1]
>>> li.append(2)
>>> li
[1, 2]
>>> li.append(4)
>>> li
[1, 2, 4]
>>> li.append(3)
>>> li
[1, 2, 4, 3]
` ``
### List Slicing {.col-span-2 .row-span-3}
Syntax of list slicing:
` ``python
a_list[start:end]
a_list[start:end:step]
` ``
#### Slicing
` ``python
>>> a = ['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[2:5]
['bacon', 'tomato', 'ham']
>>> a[-5:-2]
['egg', 'bacon', 'tomato']
>>> a[1:4]
['egg', 'bacon', 'tomato']
` ``
#### Omitting index
` ``python
>>> a[:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[0:4]
['spam', 'egg', 'bacon', 'tomato']
>>> a[2:]
['bacon', 'tomato', 'ham', 'lobster']
>>> a[2:len(a)]
['bacon', 'tomato', 'ham', 'lobster']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[:]
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
` ``
#### With a stride
` ``python
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[0:6:2]
['spam', 'bacon', 'ham']
>>> a[1:6:2]
['egg', 'tomato', 'lobster']
>>> a[6:0:-2]
['lobster', 'tomato', 'egg']
>>> a
['spam', 'egg', 'bacon', 'tomato', 'ham', 'lobster']
>>> a[::-1]
['lobster', 'ham', 'tomato', 'bacon', 'egg', 'spam']
` ``
### Remove
` ``python
>>> li = ['bread', 'butter', 'milk']
>>> li.pop()
'milk'
>>> li
['bread', 'butter']
>>> del li[0]
>>> li
['butter']
` ``
### Access
` ``python
>>> li = ['a', 'b', 'c', 'd']
>>> li[0]
'a'
>>> li[-1]
'd'
>>> li[4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
` ``
### Concatenating {.row-span-2}
` ``python
>>> odd = [1, 3, 5]
>>> odd.extend([9, 11, 13])
>>> odd
[1, 3, 5, 9, 11, 13]
>>> odd = [1, 3, 5]
>>> odd + [9, 11, 13]
[1, 3, 5, 9, 11, 13]
` ``
### Sort & Reverse {.row-span-2}
` ``python
>>> li = [3, 1, 3, 2, 5]
>>> li.sort()
>>> li
[1, 2, 3, 3, 5]
>>> li.reverse()
>>> li
[5, 3, 3, 2, 1]
` ``
### Count
` ``python
>>> li = [3, 1, 3, 2, 5]
>>> li.count(3)
2
` ``
### Repeating
` ``python
>>> li = ["re"] * 3
>>> li
['re', 're', 're']
` ``
2022-11-20 15:30:55 +08:00
Python Flow control
2020-12-25 09:55:10 +08:00
------------
### Basic
` ``python
2021-12-15 20:07:49 +08:00
num = 5
if num > 10:
print("num is totally bigger than 10.")
elif num < 10:
print("num is smaller than 10.")
2020-12-25 09:55:10 +08:00
else:
2021-12-15 20:07:49 +08:00
print("num is indeed 10.")
2020-12-25 09:55:10 +08:00
` ``
### One line
` ``python
>>> a = 330
>>> b = 200
>>> r = "a" if a > b else "b"
>>> print(r)
a
` ``
### else if
` ``python
value = True
if not value:
2021-02-10 10:03:06 +08:00
print("Value is False")
2020-12-25 09:55:10 +08:00
elif value is None:
2021-02-10 10:03:06 +08:00
print("Value is None")
2020-12-25 09:55:10 +08:00
else:
2021-02-10 10:03:06 +08:00
print("Value is True")
2020-12-25 09:55:10 +08:00
` ``
2022-11-22 11:35:10 +08:00
2022-11-20 15:30:55 +08:00
Python Loops
2020-12-25 09:55:10 +08:00
--------
### Basic
` ``python
primes = [2, 3, 5, 7]
for prime in primes:
print(prime)
` ``
2022-11-22 11:35:10 +08:00
Prints: 2 3 5 7
2020-12-25 09:55:10 +08:00
### With index
` ``python
animals = ["dog", "cat", "mouse"]
2022-11-22 11:35:10 +08:00
# enumerate() adds counter to an iterable
2020-12-25 09:55:10 +08:00
for i, value in enumerate(animals):
print(i, value)
` ``
2022-11-22 11:35:10 +08:00
Prints: 0 dog 1 cat 2 mouse
2020-12-25 09:55:10 +08:00
### While
` ``python
x = 0
while x < 4:
print(x)
x += 1 # Shorthand for x = x + 1
` ``
2022-11-22 11:35:10 +08:00
Prints: 0 1 2 3
2020-12-25 09:55:10 +08:00
2022-11-22 11:35:10 +08:00
### Break
2020-12-25 09:55:10 +08:00
` ``python
x = 0
for index in range(10):
x = index * 10
if index == 5:
break
print(x)
` ``
2022-11-22 11:35:10 +08:00
Prints: 0 10 20 30 40
2020-12-25 09:55:10 +08:00
### Continue
` ``python
for index in range(3, 8):
x = index * 10
if index == 5:
continue
print(x)
` ``
2022-11-22 11:35:10 +08:00
Prints: 30 40 60 70
2020-12-25 09:55:10 +08:00
### Range
` ``python
for i in range(4):
print(i) # Prints: 0 1 2 3
for i in range(4, 8):
print(i) # Prints: 4 5 6 7
for i in range(4, 10, 2):
print(i) # Prints: 4 6 8
` ``
2022-11-22 11:35:10 +08:00
2020-12-25 11:59:54 +08:00
### With zip()
` ``python
2022-11-22 11:35:10 +08:00
words = ['Mon', 'Tue', 'Wed']
nums = [1, 2, 3]
# Use zip to pack into a tuple list
for w, n in zip(words, nums):
print('%d:%s, ' %(n, w))
2020-12-25 11:59:54 +08:00
` ``
2022-11-22 11:35:10 +08:00
Prints: 1:Mon, 2:Tue, 3:Wed,
2020-12-25 11:59:54 +08:00
2022-11-22 11:35:10 +08:00
### for/else
2020-12-25 11:59:54 +08:00
` ``python
2022-11-22 11:35:10 +08:00
nums = [60, 70, 30, 110, 90]
for n in nums:
if n > 100:
print("%d is bigger than 100" %n)
break
else:
print("Not found!")
2020-12-25 11:59:54 +08:00
` ``
2022-11-22 11:35:10 +08:00
Also see: [Python Tips](https://book.pythontips.com/en/latest/for_-_else.html)
2020-12-25 09:55:10 +08:00
2022-11-20 15:30:55 +08:00
Python Functions
2020-12-25 09:55:10 +08:00
--------
### Basic
` ``python
def hello_world():
print('Hello, World!')
` ``
### Return
` ``python
def add(x, y):
print("x is %s, y is %s" %(x, y))
return x + y
add(5, 6) # => 11
` ``
### Positional arguments
` ``python
def varargs(*args):
return args
varargs(1, 2, 3) # => (1, 2, 3)
` ``
### Keyword arguments
` ``python
def keyword_args(**kwargs):
return kwargs
# => {"big": "foot", "loch": "ness"}
keyword_args(big="foot", loch="ness")
` ``
### Returning multiple
` ``python
def swap(x, y):
return y, x
x = 1
y = 2
x, y = swap(x, y) # => x = 2, y = 1
` ``
### Default Value
` ``python
def add(x, y=10):
return x + y
add(5) # => 15
add(5, 20) # => 25
` ``
### Anonymous functions
` ``python
# => True
(lambda x: x > 2)(3)
2021-02-10 10:03:06 +08:00
# => 5
2020-12-25 09:55:10 +08:00
(lambda x, y: x ** 2 + y ** 2)(2, 1)
` ``
2022-11-20 15:30:55 +08:00
Python Modules
2020-12-25 09:55:10 +08:00
--------
### Import modules
` ``python
import math
print(math.sqrt(16)) # => 4.0
` ``
### From a module
` ``python
from math import ceil, floor
print(ceil(3.7)) # => 4.0
print(floor(3.7)) # => 3.0
` ``
### Import all
` ``python
from math import *
` ``
### Shorten module
` ``python
import math as m
# => True
math.sqrt(16) == m.sqrt(16)
` ``
### Functions and attributes
` ``python
import math
dir(math)
` ``
2022-11-20 15:30:55 +08:00
Python File Handling
2020-12-25 09:55:10 +08:00
----------
### Read file
#### Line by line
` ``python
with open("myfile.txt") as file:
for line in file:
print(line)
` ``
#### With line number
` ``python
2022-02-06 18:01:33 -03:00
file = open('myfile.txt', 'r')
for i, line in enumerate(file, start=1):
2020-12-25 09:55:10 +08:00
print("Number %s: %s" % (i, line))
` ``
### String
#### Write a string
` ``python
contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w+") as file:
file.write(str(contents))
` ``
#### Read a string
` ``python
with open('myfile1.txt', "r+") as file:
contents = file.read()
print(contents)
` ``
### Object
#### Write an object
` ``python
contents = {"aa": 12, "bb": 21}
with open("myfile2.txt", "w+") as file:
file.write(json.dumps(contents))
` ``
#### Read an object
` ``python
with open('myfile2.txt', "r+") as file:
contents = json.load(file)
print(contents)
` ``
### Delete a File
` ``python
import os
os.remove("myfile.txt")
` ``
### Check and Delete
` ``python
import os
if os.path.exists("myfile.txt"):
2021-02-10 10:03:06 +08:00
os.remove("myfile.txt")
2020-12-25 09:55:10 +08:00
else:
2021-02-10 10:03:06 +08:00
print("The file does not exist")
2020-12-25 09:55:10 +08:00
` ``
### Delete Folder
` ``python
import os
os.rmdir("myfolder")
` ``
2022-11-20 15:30:55 +08:00
Python Classes & Inheritance
2020-12-25 09:55:10 +08:00
--------
### Defining
` ``python
class MyNewClass:
pass
# Class Instantiation
my = MyNewClass()
` ``
### Constructors
` ``python
class Animal:
2021-02-10 10:03:06 +08:00
def __init__(self, voice):
2022-02-06 18:41:22 -03:00
self.voice = voice
2020-12-25 09:55:10 +08:00
cat = Animal('Meow')
print(cat.voice) # => Meow
dog = Animal('Woof')
print(dog.voice) # => Woof
` ``
### Method
` ``python
class Dog:
2021-02-10 10:03:06 +08:00
# Method of the class
def bark(self):
2022-02-06 18:41:22 -03:00
print("Ham-Ham")
2020-12-25 09:55:10 +08:00
charlie = Dog()
charlie.bark() # => "Ham-Ham"
` ``
### Class Variables {.row-span-2}
` ``python
2022-02-06 18:41:22 -03:00
class MyClass:
2021-02-10 10:03:06 +08:00
class_variable = "A class variable!"
2022-02-06 18:41:22 -03:00
2020-12-25 09:55:10 +08:00
# => A class variable!
2022-02-06 18:41:22 -03:00
print(MyClass.class_variable)
2020-12-25 09:55:10 +08:00
2022-02-06 18:41:22 -03:00
x = MyClass()
2020-12-25 09:55:10 +08:00
# => A class variable!
2022-02-06 18:41:22 -03:00
print(x.class_variable)
2020-12-25 09:55:10 +08:00
` ``
### Super() Function {.row-span-2}
` ``python
class ParentClass:
2021-02-10 10:03:06 +08:00
def print_test(self):
print("Parent Method")
2020-12-25 09:55:10 +08:00
class ChildClass(ParentClass):
2021-02-10 10:03:06 +08:00
def print_test(self):
print("Child Method")
# Calls the parent's print_test()
super().print_test()
2020-12-25 09:55:10 +08:00
` ``
---
` ``python
>>> child_instance = ChildClass()
>>> child_instance.print_test()
Child Method
Parent Method
` ``
### repr() method
` ``python
class Employee:
2021-02-10 10:03:06 +08:00
def __init__(self, name):
self.name = name
2020-12-25 09:55:10 +08:00
2021-02-10 10:03:06 +08:00
def __repr__(self):
return self.name
2020-12-25 09:55:10 +08:00
john = Employee('John')
print(john) # => John
` ``
### User-defined exceptions
` ``python
class CustomError(Exception):
2021-02-10 10:03:06 +08:00
pass
2020-12-25 09:55:10 +08:00
` ``
### Polymorphism
` ``python
class ParentClass:
2021-02-10 10:03:06 +08:00
def print_self(self):
print('A')
2020-12-25 09:55:10 +08:00
class ChildClass(ParentClass):
2021-02-10 10:03:06 +08:00
def print_self(self):
print('B')
2020-12-25 09:55:10 +08:00
obj_A = ParentClass()
obj_B = ChildClass()
2021-06-04 17:20:40 +08:00
obj_A.print_self() # => A
obj_B.print_self() # => B
2020-12-25 09:55:10 +08:00
` ``
### Overriding
` ``python
class ParentClass:
2021-02-10 10:03:06 +08:00
def print_self(self):
print("Parent")
2020-12-25 09:55:10 +08:00
class ChildClass(ParentClass):
2021-02-10 10:03:06 +08:00
def print_self(self):
print("Child")
2020-12-25 09:55:10 +08:00
child_instance = ChildClass()
child_instance.print_self() # => Child
` ``
### Inheritance
` ``python
class Animal:
2021-02-10 10:03:06 +08:00
def __init__(self, name, legs):
self.name = name
self.legs = legs
2020-12-25 09:55:10 +08:00
class Dog(Animal):
2021-02-10 10:03:06 +08:00
def sound(self):
print("Woof!")
2020-12-25 09:55:10 +08:00
Yoki = Dog("Yoki", 4)
2021-06-04 17:20:40 +08:00
print(Yoki.name) # => YOKI
print(Yoki.legs) # => 4
Yoki.sound() # => Woof!
2020-12-25 09:55:10 +08:00
` ``
2022-11-20 15:30:55 +08:00
Miscellaneous
2020-12-25 09:55:10 +08:00
----------
### Comments
` ``python
# This is a single line comments.
` ``
` ``python
""" Multiline strings can be written
using three "s, and are often used
as documentation.
"""
` ``
` ``python
''' Multiline strings can be written
using three 's, and are often used
as documentation.
'''
` ``
### Generators
` ``python
def double_numbers(iterable):
for i in iterable:
yield i + i
` ``
Generators help you make lazy code.
### Generator to list
` ``python
values = (-x for x in [1,2,3,4,5])
gen_to_list = list(values)
# => [-1, -2, -3, -4, -5]
print(gen_to_list)
` ``
### Handle exceptions {.col-span-3}
` ``python
try:
# Use "raise" to raise an error
raise IndexError("This is an index error")
except IndexError as e:
pass # Pass is just a no-op. Usually you would do recovery here.
except (TypeError, NameError):
pass # Multiple exceptions can be handled together, if required.
else: # Optional clause to the try/except block. Must follow all except blocks
print("All good!") # Runs only if the code in try raises no exceptions
2021-06-04 17:20:40 +08:00
finally: # Execute under all circumstances
2020-12-25 09:55:10 +08:00
print("We can clean up resources here")
` ``
