How AI is Changing Coding and Education
FREE STANFORD WEBINAR

October 9, 2024 | 11:00-11:45 am PT

Registration

Less known features of C
https://jorenar.com/blog/less-known-c

Synchronizing Numba and NumPy RNG States for Consistent BehaviorThe Numba RNG state and NumPy RNG states are entirely separate. Therefore calling np.random.seed() will only impact the NumPy RNG seed and this explains the behaviour in the above. To make Numba's RNG state the same as NumPy's, the np.random.seed() function needs calling from within a JIT compiled region, for example:

```
python
import numpy as np
from numba import jit
from numba.extending import register_jitable

@register_jitable # This will run in JIT mode only if called from a JIT function
def set_seed_compat(x):
np.random.seed(x)

@jit(nopython=True)
def get_random():
set_seed_compat(42)
print(np.random.rand(3))

def get_radnom2():
print(np.random.rand(3))

get_random()
get_random.py_func()
get_radnom2()

#[0.37454012 0.95071431 0.73199394]
#[0.37454012 0.95071431 0.73199394]
#[0.59865848 0.15601864 0.15599452]

```
The third should be different, but still repeatable by re-execution of the script.

1. Tree (Binary Tree Example)

Python doesn't have built-in tree structures, but you can implement one using classes.

```
# Node class for a binary tree
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None

# Function to perform an in-order traversal (left, root, right)
def inorder(root):
if root:
inorder(root.left)
print(root.data, end=" ")
inorder(root.right)

# Example usage:
if __name__ == "__main__":
# Create the binary tree
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

```

1. Graph (Adjacency List Example)

You can use dictionaries or lists to represent graphs in Python.

graph = { 'A': ['B', 'C'], 'B': ['A', 'D', 'E'], 'C': ['A', 'F'], 'D': ['B'], 'E': ['B', 'F'], 'F': ['C', 'E'] }

1. Linked List

Python doesn't have a built-in linked list, but you can implement one using classes.

```
# Node class to represent a single node in the linked list
class Node:
def __init__(self, data):
self.data = data # Data held by the node
self.next = None # Pointer to the next node in the list

# LinkedList class to manage the linked list
class LinkedList:
def __init__(self):
self.head = None # Initialize the head of the list as None

# Example usage:
if __name__ == "__main__":
# Create a linked list
linked_list = LinkedList()

```

1. Heap (Priority Queue)

Python’s heapq module implements a binary heap.

import heapq heap = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] heapq.heapify(heap) smallest = heapq.heappop(heap)

# Python Data Structures

## 1. Primitive Data Types
- int: Integer values.

x = 10

float: Floating-point numbers.

y = 10.5

bool: Boolean values (True/False).

z = True

str: Strings (immutable sequences of Unicode characters).

s = "Hello, World!"

1. Sequence Types

a. List

A mutable, ordered collection of elements.

lst = [1, 2, 3, 4] lst.append(5)

b. Tuple

An immutable, ordered collection of elements.

tpl = (1, 2, 3)

c. Range

A sequence of numbers, often used in loops.

r = range(1, 10)

d. String

A sequence of characters, treated as a list of characters.

s = "Hello" first\_char = s[0]

e. Byte/Bytearray

Immutable (bytes) or mutable (bytearray) sequences of bytes.

b = bytes([65, 66, 67]) \# A, B, C ba = bytearray([65, 66, 67])

1. Set Types

a. Set

An unordered, mutable collection of unique elements.

s = {1, 2, 3, 4} s.add(5)

b. Frozen Set

An immutable version of a set.

fs = frozenset([1, 2, 3])

1. Mapping Type

Dictionary

An unordered, mutable collection of key-value pairs.

d = {'name': 'Alice', 'age': 25} d['location'] = 'Wonderland'

1. Specialized Data Structures

a. Deque (Double-Ended Queue)

A thread-safe, general-purpose, double-ended queue.

from collections import deque dq = deque([1, 2, 3]) dq.appendleft(0)

b. Defaultdict

A dictionary that provides a default value for non-existent keys.

from collections import defaultdict dd = defaultdict(int) dd['a'] += 1 \# If 'a' doesn't exist, its value will default to 0

c. OrderedDict

A dictionary that remembers the order of key insertions (introduced in Python 3.1).

from collections import OrderedDict od = OrderedDict() od['a'] = 1 od['b'] = 2

1. Stack and Queue

a. Stack (List-based)

A last-in, first-out (LIFO) structure.

stack = [] stack.append(10) stack.pop()

b. Queue (List or deque-based)

A first-in, first-out (FIFO) structure.

queue = deque() queue.append(10) queue.popleft()

Here are the Colored images:
https://t.me/QajarC

#seaborn
#visualization