File me Issues or star this repo.
See more CheatSheets from Denny: #denny-cheatsheets
| Name | Comment |
|---|
| Return if.. else | return val if i>0 else 0 |
| Multiple assignment | l, r = 2, 3 |
| Assign with check of none | a = b if b else 1 |
| Assignments | l[1]=l[0]=0 |
| Swap values | left, right = right, left |
| List Comprehensions | [x*x for x in range(1, 1001)] |
| List Comprehensions | l = [2, 3, 5]; [2*x for x in l if x>2] |
| Use zip | for a, b in zip(nums, nums[3:]) |
| Build a list | dp = [1] + [0]*3 |
| Change interger to string in binary | bin(num), f'{num:b}'=, ="{0:b}".format(num) |
| Sum a subarray | sum(nums[0:k]) |
| Sort list in descending order | sorted(nums, reverse=True) |
| Dictionary with defaults | m = collections.defaultdict(lambda: 1) |
| Loop with single statement | while p.left: p = p.left |
| Print multiple values | print(x, y) |
| Get both index and item | for i, ch in enumerate(["a", "b", "c"]): print(i, ch) |
| Mod negative | (-2)%5 |
| Compare values | if 0<=i<n and 0<=j<m and grid[i][j] |
| if … return | if k == 0: return False |
| if… continue | if index == icol: continue |
| List comprehensive | areas = [dfs(i, j) for i in range(m) for j in range(n) if grid[i][j]] |
| Python assertion | assert [1,2]==[1,2] |
| Name | Comment |
|---|
| Create a fixed size array | [None]*5 |
| Create a fixed size matrix/2D array | [[sys.maxsize for j in range(2)] for i in range(3)] |
| Flatten 2D array into 1D array | [a for r in matrix for a in r] |
| Iterate over a list | for v in l: |
| Iterate over a list with index+val | for i, v in enumerate(l): |
| zip two lists as one | l = sorted(zip(nums, range(len(nums)))) |
| Convert int array to a string | =’ ‘.join([str(v) for v in [1, 2,3,4]])= |
| Extact columns from multi-dimensional array | [row[1] for row in l] |
| Sort in descending | l=sorted([8, 2, 5], reverse=True) |
| Sort list by a lambda key | l=sorted([(‘ebb’,12),(‘abc’,14)], key=lambda x: x[1]) |
| Sort list by a function | sorted(logs, key=getKey), LeetCode: Reorder Data in Log Files |
| In-place sort | l.sort() |
| Find the index of one item | [1,2,5,3].index(2) |
| Return all but last | list[:-1] |
| The second last item | list[-2] or list[~1] |
| Generate a-z | map(chr, range(ord('a'), ord('z')+1)) |
| Convert from ascii to character | chr(ord('a')) |
| Reverse a list | ["ab", "cd", "ef"][::-1] |
| map | map(lambda x: str(x), [1, 2, 3]) |
| Copy a range to another range | nums1[:k+1] = nums2[:j+1] |
| append an element | array.append(var) |
| insert elements to head | array.insert(0,var) |
| delete element by index | del a[1] |
| list as stack | item = l.pop() |
| map/reduce | functools.reduce((lambda x, y: "%s %s" % (x, y)), l) |
| replace ith to jth | list[i:j] = otherlist |
| combine two list | list1 + list2 |
| get sum | sum(list) |
| unique list | set(["Blah", "foo", "foo", 1, 1, 2, 3]) |
| Insert to sorted list | bisect.insort(l, 3) |
| Reverse a list | l[::-1] |
| Print zip array | print(list(zip(l1, l2))) |
| Reference | Link: Lists and Tuples in Python |
| Name | Comment |
|---|
| Reverse string | ‘hello world’[::-1] |
| Array to string | ’ ‘.join([‘a’, ‘b’]) |
| Integer array to string | ’ ‘.join([str(v) for v in [1, 2, 3]]) |
| Split string to array | “hello, python”.split(“,”) |
| String to array | list('abc') |
| Format to 2 digits | print "%02d" % (13) |
| Capitalize string | ‘hello world’.capitalize() |
| Upper/lower string | ‘aBc’.upper(), ‘aBc’.lower() |
| Check if string represent integer | ‘123’.isdigit() |
| Check if string alphabetic | ‘aBc’.isalpha() |
| Check if string alphanumeric | ‘a1b’.isalnum() |
| Count substring | ‘2-5g-3-J’.count(‘-‘) |
| Remove tailing ‘0’ | ‘0023’.rstrip(‘0’) |
| Remove leading ‘0’ | ‘0023’.lstrip(‘0’) |
| Trip a string | ’ Hello ‘.strip() |
| Find location of substring | ‘abc’.find(‘d’)= (returns -1) |
| Find location of substring | ‘abc’.index(‘d’)= (raise exception) |
| Check whether substring | “el” in “hello world” |
| Replace string | ‘ab cd’.replace(‘=’,=”) |
| Padding leading zero | ‘101’.zfill(10) |
| Padding whitespace to the left | ‘a’.ljust(10,’=’) |
| Padding whitespace to the right | ‘a’.rjust(10,’=’) |
| Format string | “%s,%d,%s” % (“2012”, 12, “12”) |
| Name | Comment |
|---|
| Error: i++ | OK: i += 1 |
| Error: b=true | OK: b=True |
| Error: i<len(A) && j<len(B): | OK: i<len(A) and j<len(B): |
| Error: for i>=0 and j>=0: | OK: while i>=0 and j>=0: |
| Error: ! f | OK: not f |
| NameError: name ‘List’ is not defined | from typing import List |
| Python float with high resolution | |
| Name | Comment |
|---|
| Check on installed python package | pip show simplejson |
| Search a package | pip search simplejson |
| Install and uninstall a package | pip install simplejson, pip uninstall simplejon |
| Install package with a specific version | pip install flake8==2.0 |
| Show installation folder of a module | module.__file__, flask.__file__ |
| Check on-line help for a module | help(module) |
| pip install -U simplejon |
| pip install -i http://pypi.python.jp flask |
| Name | Comment |
|---|
| max, min | sys.maxsize, -sys.maxsize-1 |
| min, max | min(2, 3), max(5, 6, 2) |
| min with customized comparision | min(a, b, key=lambda x: x*x-2*x+1) |
| generate range | for num in range(10,20) |
| get ascii | ord('a'), chr(97) |
| print integer in binary | “{0:b}”.format(10) |
| Name | Comment |
|---|
| dict get first element | m[m.keys()[0]] |
| get by key with default value | m.get(x, -1) |
| Dictionary with defaults | m = collections.defaultdict(lambda: 1) |
| Dictionary with tuple defaults | d=collections.defaultdict(lambda: (0, 0))), d[0, 1]=(2, 3) |
| Use array as key in dictionary | Convert array to tuple: m[tuple(l)]=3 |
| Check whether key in hashmap | if k in m |
| Loop dictionary by keys | for k in m |
| Loop dictionary | for k,v in m.items(), not for k,v in enumerate(m) |
| Intersection of two sets | list(set(l1).intersection(set(l2))) |
| List to set | set(list1) |
| Remove from set | s.remove(2) |
| Deep copy dict | import copy; m2=copy.deepcopy(m1) |
| Remove the first from set | s.pop() |
| Sort dict by values | sorted(dict1, key=dict1.get) |
| Convert a str to a dict | eval("{\"createtime\":\"2013-07-16\"}") |
| Delete an element from a dict | del d[key] |
| Name | Comment |
|---|
| mod | x % 2 |
| shift left | x << 1; a << 2 |
| shift righ | x >> 2 |
| and | x & y |
| complement | ~x |
| xor | x ^ y |
| power | 2 ** 3 |
| bool complement | not x |
| binary format | bin(5) (get 101) |
| count 1 inside binary | bin(5).count('1') |
| Name | Comment |
|---|
| Append file | open("/tmp/test.txt", "ab").write("\ntest:") |
| Write file | open("/tmp/test.txt", "wab").write("\ntest:") |
| Read files | f.readlines() |
| Check file | os.path.exists("/tmp/test.txt") |
| Reference | Github: cheatsheet-python-A4/code/exampleFile.py |
| Name | Comment |
|---|
| sqrt | import math; math.sqrt(5) |
| power | import math; math.pow(2, 3) |
| log | import math; math.log(5, 2), log2(5) |
| random | random.randint(1, 10) 1 and 10 included |
| eval string | eval("2-11*2") |
| Name | Comment |
|---|
| Send http REST call | pip install requests; r = requests.get(‘https://XX/XX’, auth=(‘user’, ‘pass’)) |
| Start a simple HTTP server | python -m SimpleHTTPServer <port_number> |
| Name | Comment |
|---|
| Initialize min heap | heapq.heapify(q) |
| heappush a tuple | q=[]; heapq.heappush(q, (5, ‘ab’)) |
| pop | print (heapq.heappop(q)) |
| first item | q[0] |
| print heapq | print list(q) |
| create a queue | from collections import deque; queue = deque([1,5,8,9]) |
| append queue | queue.append(7) |
| pop queue from head | element = queue.popleft() |
| Reference | Link: Python Heapq |
import heapq
# initializing list
li = [5, 7, 9, 1, 3]
# using heapify to convert list into heap
heapq.heapify(li) # a minheap
heapq._heapify_max(li) # for a maxheap!
# printing created heap
print (list(li))
# using heappush() to push elements into heap
# pushes 4
heapq.heappush(li,4)
# printing modified heap
print (list(li))
# using heappop() to pop smallest element
print (heapq.heappop(li))
print (list(li))
- Initialize Linkedlist from array
def initListNodeFromArray(self, nums):
head = ListNode(None)
prev, p = head, head
for num in nums:
pre = p
p.val = num
q = ListNode(None)
p.next = q
p = p.next
pre.next = None
return headdef printListNode(self, head):
print("printListnode")
while head:
print("%d" % (head.val))
head = head.next
- Print Trie Tree in level order
def printTrieTreeLevelOrder(self, node):
print("printTrieTreeLevelOrder")
if node.is_word:
print("Node is a word")
queue = []
queue.append(node)
while len(queue) != 0:
s = ''
for i in range(len(queue)):
node = queue[0]
del queue[0]
for child_key in node.children:
s = '%s %s' % (s, child_key)
queue.append(node.children[child_key])
if s != '':
print 'print level children: %s' % (s)
- python sort with customized cmp function: -1 first
nums = [3, 2, 6]
def myCompare(v1, v2):
return -1
sorted_nums = sorted(nums, cmp=myCompare)
print nums # [3, 2, 6]
print sorted_nums # [6, 3, 2]col_count, row_count = 3, 2
matrix = [[None for j in range(col_count)] for i in range(row_count)]
print matrix
| Num | Category/Tag | Example |
|---|
| 1 | #bfs | Leetcode: Max Area of Island |
| 2 | #dfs | LeetCode: Surrounded Regions |
| 3 | #binarysearch | LeetCode: Search Insert Position |
| 4 | #interval, #mergelist | LeetCode: Interval List Intersections |
| 5 | #twopointer, #array | LeetCode: Reverse Words in a String II |
| 6 | #twopointer | LeetCode: Two Sum |
| 7 | #backtracking, #subset | LeetCode: Subsets II |
| 8 | #linkedlist, #presum | LeetCode: Remove Zero Sum Consecutive Nodes from Linked List |
| 9 | #unionfind | LeetCode: Accounts Merge |
| 10 | #trie | LeetCode: Longest Word in Dictionary |
| 11 | #stack | LeetCode: Valid Parentheses |
| 12 | #stack | LeetCode: Reverse Substrings Between Each Pair of Parentheses |
| 13 | #heap | LeetCode: Top K Frequent Elements |
| 14 | #baseconversion | LeetCode: Base 7, LeetCode: Convert to Base -2 |
| 15 | #interval | LeetCode: Meeting Rooms II, LeetCode: My Calendar I |
| 16 | #monotone | LeetCode: Daily Temperatures |
| 17 | #knapsack | LeetCode: Coin Change |
| 18 | #sortbyfunction | LeetCode: Relative Sort Array |
| 19 | #slidingwindow | LeetCode: Longest Substring Without Repeating Characters |
| 20 | #editdistance, #dynamicprogramming | LeetCode: Longest Common Subsequence |
| 21 | #twopointer, #mergetwolist | LeetCode: Merge Sorted Array |
| 22 | #topologicalsort | LeetCode: Course Schedule |
| 23 | #bfs, bidirectional bfs | LeetCode: Word Ladder |
| 24 | #monotonicfunc, #binarysearch | LeetCode: Kth Smallest Number in Multiplication Table |
| 25 | #divideconquer, #recursive | Leetcode: Count of Smaller Numbers After Self |
| 26 | python semaphore | LeetCode: Print Zero Even Odd |
License: Code is licensed under MIT License.
https://www.tutorialspoint.com/python_data_structure/index.htm
