From 0b9d86e1a0b0c370090b64cccdd0a2ba65866396 Mon Sep 17 00:00:00 2001 From: Randy8080 Date: Fri, 25 Dec 2020 09:55:10 +0800 Subject: [PATCH] Added python cheatsheets --- python.md | 1139 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1139 insertions(+) create mode 100644 python.md diff --git a/python.md b/python.md new file mode 100644 index 0000000..b6e6bef --- /dev/null +++ b/python.md @@ -0,0 +1,1139 @@ +--- +title: Python +date: 2020-12-23 18:41:20 +icon: icon-python +background: bg-blue-600 +tags: + - python +categories: + - Programming +intro: | + The [Python](https://www.python.org/) cheat sheet is a one-page reference sheet for the Python 3 programming language. +--- + + + +Getting Started {.cols-3} +--------------- + + +### Introduction +- [Python](https://www.python.org/) _(python.org)_ +- [Learn X in Y minutes](https://learnxinyminutes.com/docs/python/) _(learnxinyminutes.com)_ +- [Regex in python](/regex#regex-in-python) _(quickref.me)_ + + + +### Hello World + +```python +>>> print("Hello, World!") +Hello, World! +``` + +The famous "Hello World" program in Python + + +### Variables +```python +x = 4 # x is of type int +x = "Sally" # x is now of type str +print(x) +``` + +Python has no command for declaring a variable. + + + +### Data Types {.row-span-2} +| | | +|--------------------------------|----------------| +| `str` | Text | +| `int`, `float`, `complex` | Numeric | +| `list`, `tuple`, `range` | Sequence | +| `dict` | Mapping | +| `set`, `frozenset` | Set | +| `bool` | Boolean | +| `bytes`, `bytearray`, `memoryview` | Binary | +See: [Data Types](#data-types-2) + + +### Slicing String + +```python +>>> b = "Hello, World!" +>>> print(b[2:5]) +llo +``` + +See: [Strings](#strings-3) + +### Lists +```python +mylist = [] +mylist.append(1) +mylist.append(2) +for x in mylist: + print(x) # prints out 1,2 +``` + +See: [Lists](#lists-3) + + +### If Else +```python +a = 200 +if a > 0: + print("a is greater than 0") +else: + print("a is not greater than 0") +``` +See: [Flow control](#flow-control) + +### Loops +```python +for x in range(6): + if x == 3: break + print(x) +else: + print("Finally finished!") +``` +See: [Loops](#loops-2) + + +### Functions +```python +>>> def my_function(): +... print("Hello from a function") +... +>>> my_function() +Hello from a function +``` + +See: [Functions](#functions-2) + + +### File Handling {.col-span-2} +```python +with open("myfile.txt", "r", encoding='utf8') as file: + for x in file: + print(x) +``` + +See: [File Handling](#file-handling-2) + + + +### Arithmetic +```python +result = 10 + 30 # => 40 +result = 40 - 10 # => 30 +result = 50 * 5 # => 150 +result = 16 / 4 # => 4 +result = 25 % 2 # => 1 +result = 5 ** 3 # => 125 +``` + +### Plus-Equals +```python +counter = 0 +counter += 10 # => 10 +counter = 0 +counter = counter + 10 # => 10 + +message = "Part 1." +# => Part 1.Part 2. +message += "Part 2." +``` + + + + +Data Types {.cols-3} +--------------- + + + +### Strings + +```python +s = "Hello World" +s = 'Hello World' + +a = """Multiline Strings +Lorem ipsum dolor sit amet, +consectetur adipiscing elit """ +``` +See: [Strings](#strings-2) + + + +### Numbers +```python +x = 1 # int +y = 2.8 # float +z = 1j # complex + +>>> print(type(x)) + +``` + + + +### Booleans +```python +a = True +b = False + +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)) +``` +See: [Lists](#lists-3) + + +### Tuple +```python +a = (1, 2, 3) +a = tuple((1, 2, 3)) +``` +Similar to List but immutable + + +### Set +```python +set1 = {"a", "b", "c"} +set2 = set(("a", "b", "c")) +``` +Set of unique items/objects + + + +### Dictionary +```python +>>> 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]) +>>> a.update({"four":4}) +>>> a.keys() +dict_keys(['brand', 'colors', 'four']) +>>> 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' +``` + + + +Strings {.cols-3} +------------ + +### Array-like + +```python +>>> a = "Hello, World" +>>> print(a[1]) +e +>>> print(a[len(a)-1]) +d +``` +Get the character at position 1 + +### Looping + +```python +>>> for x in "abc": +... print(x) +a +b +c +``` +Loop through the letters in the word "banana" + + + +### Slicing string {.row-span-4} +``` + +---+---+---+---+---+---+---+ + | m | y | b | a | c | o | n | + +---+---+---+---+---+---+---+ + 0 1 2 3 4 5 6 7 +-7 -6 -5 -4 -3 -2 -1 +``` + +--- + +``` +>>> 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 +>>> a = "Hello, World!" +>>> print(len(a)) +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 +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) +``` + +### Input +``` +>>> 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 +``` + + +Lists {.cols-3} +------------ + + + +### 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 "", line 1, in +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'] +``` + +Flow control {.cols-3} +------------ + +### Basic +```python +a = 5 +if a > 10: + print("a is totally bigger than 10.") +elif a < 10: + print("a is smaller than 10.") +else: + print("a is indeed 10.") +``` + +### 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: + print("Value is False") +elif value is None: + print("Value is None") +else: + print("Value is True") +``` + + + +Loops {.cols-3} +-------- + +### Basic + +```python +primes = [2, 3, 5, 7] +for prime in primes: + print(prime) +``` + + + +### With index + +```python +animals = ["dog", "cat", "mouse"] +for i, value in enumerate(animals): + print(i, value) +``` + + +### While +```python +x = 0 +while x < 4: + print(x) + x += 1 # Shorthand for x = x + 1 +``` + + + +### Break +```python +x = 0 +for index in range(10): + x = index * 10 + if index == 5: + break + print(x) +``` + + +### Continue + +```python +for index in range(3, 8): + x = index * 10 + if index == 5: + continue + print(x) +``` + + +### 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 +``` + + + + + + +Functions {.cols-3} +-------- + +### 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) + + # => 5 +(lambda x, y: x ** 2 + y ** 2)(2, 1) +``` + + + +Modules {.cols-3} +-------- + + +### 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) +``` + + + +File Handling {.cols-3} +---------- + + +### Read file +#### Line by line +```python +with open("myfile.txt") as file: + for line in file: + print(line) +``` +#### With line number +```python +input = open('myfile.txt', 'r') +for i,line in enumerate(input, start=1): + 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"): + os.remove("myfile.txt") +else: + print("The file does not exist") +``` + + +### Delete Folder + +```python +import os +os.rmdir("myfolder") +``` + + + + + +Classes & Inheritance {.cols-3} +-------- + + +### Defining + +```python +class MyNewClass: + '''This is a docstring.''' + pass + +# Class Instantiation +my = MyNewClass() +``` + + + +### Constructors + +```python +class Animal: + def __init__(self, voice): + self.voice = voice + +cat = Animal('Meow') +print(cat.voice) # => Meow + +dog = Animal('Woof') +print(dog.voice) # => Woof +``` + + + +### Method +```python +class Dog: + + # Method of the class + def bark(self): + print("Ham-Ham") + +charlie = Dog() +charlie.bark() # => "Ham-Ham" +``` + + + +### Class Variables {.row-span-2} + +```python +class my_class: + class_variable = "A class variable!" + +x = my_class() +y = my_class() + +# => A class variable! +print(x.class_variable) + +# => A class variable! +print(y.class_variable) +``` + + + +### Super() Function {.row-span-2} + +```python +class ParentClass: + def print_test(self): + print("Parent Method") + +class ChildClass(ParentClass): + def print_test(self): + print("Child Method") + # Calls the parent's print_test() + super().print_test() +``` +--- + +```python +>>> child_instance = ChildClass() +>>> child_instance.print_test() +Child Method +Parent Method +``` + + + + +### repr() method + +```python +class Employee: + def __init__(self, name): + self.name = name + + def __repr__(self): + return self.name + +john = Employee('John') +print(john) # => John +``` + + +### User-defined exceptions +```python +class CustomError(Exception): + pass +``` + + + +### Polymorphism + +```python +class ParentClass: + def print_self(self): + print('A') + +class ChildClass(ParentClass): + def print_self(self): + print('B') + +obj_A = ParentClass() +obj_B = ChildClass() + +obj_A.print_self() # A +obj_B.print_self() # B +``` + +### Overriding +```python +class ParentClass: + def print_self(self): + print("Parent") + +class ChildClass(ParentClass): + def print_self(self): + print("Child") + +child_instance = ChildClass() +child_instance.print_self() # => Child +``` + +### Inheritance +```python +class Animal: + def __init__(self, name, legs): + self.name = name + self.legs = legs + +class Dog(Animal): + def sound(self): + print("Woof!") + +Yoki = Dog("Yoki", 4) +print(Yoki.name) # YOKI +print(Yoki.legs) # 4 +Yoki.sound() # Woof! +``` + + + +Miscellaneous {.cols-3} +---------- + +### 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 +finally: # Execute under all circumstances + print("We can clean up resources here") +```