joeyajames/Python
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reorganizing files only

Browse Source
This commit is contained in:
Joe James
2018-06-24 20:08:27 -07:00
committed by GitHub
parent 031df3f3bd
commit 43a6f50f0a
8 changed files with 661 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
Numpy/Numpy commands.txt Normal file
View File

@@ -0,0 +1,60 @@
https://docs.scipy.org/doc/numpy-1.12.0/reference/
Numpy
install Numpy using pip
import numpy as np
ndarray - an N-dimensional array, which describes a collection of “items” of the same type
array(list) # constructor
asarray(a[, dtype, order]) # Convert the input to an array
Constants:
ndarray.shape tuple of array dimensions
ndarray.size number of elements in array
ndarray.itemsize size of one element
ndarray.dtype data type of elements
ndarray.flat 1D iterator over elements of array
Common Functions
np.tolist()
np.reshape(a, (3,2))
np.swapaxes(axis1, axis2)
np.copy()
arange()
Statistics Functions:
np.sum(a, axis)
np.prod
np.min
np.max
np.mean
np.std standard deviation
np.var
np.sort(axis)
Other Functions:
String operations
logical operations - AND, OR, XOR, NOT, >, <, =, ...
trig functions
complex numbers (real + imaginary)
polynomials
2D matrix operations
Fourier transforms
====================================================================================
import numpy as np
x = [0,1,2,3,4,5]
a = np.array(x)
index: a[2]
slice: a[start:stop:step]
a[1:4:2]
a[3:]
a[:3]
a.shape
a.size
a.itemsize
a.dtype
b = np.array([[1,2,3], [4,5,6]])
b.swapaxes(0,1)
a = np.arange(0,6)
a = np.arange(0,6).reshape(2,3)

BIN
Numpy/Numpy.pptx Normal file
View File

Binary file not shown.

7
Numpy/data.txt Normal file
View File

@@ -0,0 +1,7 @@
a, b, c, d, e, f, g, h, i, j
9, 3, 8, 7, 6, 1, 0, 4, 2, 5
1, 7, 4, 9, 2, 6, 8, 3, 5, 0
4, 8, 3, 9, 5, 7, 2, 6, 0, 1
1, 7, 4, 2, 5, 9, 6, 8, 0, 3
0, 7, 5, 2, 8, 6, 3, 4, 1, 9
5, 9, 1, 4, 7, 0, 3, 6, 8, 2

BIN
Pandas/Pandas.pptx Normal file
View File

Binary file not shown.

144
Trees/2-3_tree.py Normal file
View File

@@ -0,0 +1,144 @@
# 2-3 Tree
# balanced tree data structure with up to 2 data items per node
class Node:
def __init__(self, data, par = None):
#print ("Node __init__: " + str(data))
self.data = list([data])
self.parent = par
self.child = list()
def __str__(self):
if self.parent:
return str(self.parent.data) + ' : ' + str(self.data)
return 'Root : ' + str(self.data)
def __lt__(self, node):
return self.data[0] < node.data[0]
def _isLeaf(self):
return len(self.child) == 0
# merge new_node sub-tree into self node
def _add(self, new_node):
# print ("Node _add: " + str(new_node.data) + ' to ' + str(self.data))
for child in new_node.child:
child.parent = self
self.data.extend(new_node.data)
self.data.sort()
self.child.extend(new_node.child)
if len(self.child) > 1:
self.child.sort()
if len(self.data) > 2:
self._split()
# find correct node to insert new node into tree
def _insert(self, new_node):
# print ('Node _insert: ' + str(new_node.data) + ' into ' + str(self.data))
# leaf node - add data to leaf and rebalance tree
if self._isLeaf():
self._add(new_node)
# not leaf - find correct child to descend, and do recursive insert
elif new_node.data[0] > self.data[-1]:
self.child[-1]._insert(new_node)
else:
for i in range(0, len(self.data)):
if new_node.data[0] < self.data[i]:
self.child[i]._insert(new_node)
break
# 3 items in node, split into new sub-tree and add to parent
def _split(self):
# print("Node _split: " + str(self.data))
left_child = Node(self.data[0], self)
right_child = Node(self.data[2], self)
if self.child:
self.child[0].parent = left_child
self.child[1].parent = left_child
self.child[2].parent = right_child
self.child[3].parent = right_child
left_child.child = [self.child[0], self.child[1]]
right_child.child = [self.child[2], self.child[3]]
self.child = [left_child]
self.child.append(right_child)
self.data = [self.data[1]]
# now have new sub-tree, self. need to add self to its parent node
if self.parent:
if self in self.parent.child:
self.parent.child.remove(self)
self.parent._add(self)
else:
left_child.parent = self
right_child.parent = self
# find an item in the tree; return item, or False if not found
def _find(self, item):
# print ("Find " + str(item))
if item in self.data:
return item
elif self._isLeaf():
return False
elif item > self.data[-1]:
return self.child[-1]._find(item)
else:
for i in range(len(self.data)):
if item < self.data[i]:
return self.child[i]._find(item)
def _remove(self, item):
pass
# print preorder traversal
def _preorder(self):
print (self)
for child in self.child:
child._preorder()
class Tree:
def __init__(self):
print("Tree __init__")
self.root = None
def insert(self, item):
print("Tree insert: " + str(item))
if self.root is None:
self.root = Node(item)
else:
self.root._insert(Node(item))
while self.root.parent:
self.root = self.root.parent
return True
def find(self, item):
return self.root._find(item)
def remove(self, item):
self.root.remove(item)
def printTop2Tiers(self):
print ('----Top 2 Tiers----')
print (str(self.root.data))
for child in self.root.child:
print (str(child.data), end=' ')
print(' ')
def preorder(self):
print ('----Preorder----')
self.root._preorder()
tree = Tree()
lst = [13, 7, 24, 15, 4, 29, 20, 16, 19, 1, 5, 22, 17]
for item in lst:
tree.insert(item)
tree.printTop2Tiers()
# for i in range (25):
# tree.insert(i)
# tree.printTop2Tiers()
# tree.preorder()
# print (tree.find(16))

BIN
Trees/BST_Height_Size.pptx Normal file
View File

Binary file not shown.

214
Trees/BinarySearchTree.py Normal file
View File

@@ -0,0 +1,214 @@
# Binary Search Tree in Python
class Node:
def __init__(self, val):
self.value = val
self.leftChild = None
self.rightChild = None
def insert(self, data):
if self.value == data:
return False
elif self.value > data:
if self.leftChild:
return self.leftChild.insert(data)
else:
self.leftChild = Node(data)
return True
else:
if self.rightChild:
return self.rightChild.insert(data)
else:
self.rightChild = Node(data)
return True
def find(self, data):
if(self.value == data):
return True
elif self.value > data:
if self.leftChild:
return self.leftChild.find(data)
else:
return False
else:
if self.rightChild:
return self.rightChild.find(data)
else:
return False
def getHeight(self):
if self.leftChild and self.rightChild:
return 1 + max(self.leftChild.getHeight(), self.rightChild.getHeight())
elif self.leftChild:
return 1 + self.leftChild.getHeight()
elif self.rightChild:
return 1 + self.rightChild.getHeight()
else:
return 1
def preorder(self):
if self:
print (str(self.value))
if self.leftChild:
self.leftChild.preorder()
if self.rightChild:
self.rightChild.preorder()
def postorder(self):
if self:
if self.leftChild:
self.leftChild.postorder()
if self.rightChild:
self.rightChild.postorder()
print (str(self.value))
def inorder(self):
if self:
if self.leftChild:
self.leftChild.inorder()
print (str(self.value))
if self.rightChild:
self.rightChild.inorder()
class Tree:
def __init__(self):
self.root = None
def insert(self, data):
if self.root:
return self.root.insert(data)
else:
self.root = Node(data)
return True
def find(self, data):
if self.root:
return self.root.find(data)
else:
return False
def getHeight(self):
if self.root:
return self.root.getHeight()
else:
return -1
def remove(self, data):
# empty tree
if self.root is None:
return False
# data is in root node
elif self.root.value == data:
if self.root.leftChild is None and self.root.rightChild is None:
self.root = None
elif self.root.leftChild and self.root.rightChild is None:
self.root = self.root.leftChild
elif self.root.leftChild is None and self.root.rightChild:
self.root = self.root.rightChild
elif self.root.leftChild and self.root.rightChild:
delNodeParent = self.root
delNode = self.root.rightChild
while delNode.leftChild:
delNodeParent = delNode
delNode = delNode.leftChild
self.root.value = delNode.value
if delNode.rightChild:
if delNodeParent.value > delNode.value:
delNodeParent.leftChild = delNode.rightChild
elif delNodeParent.value < delNode.value:
delNodeParent.rightChild = delNode.rightChild
else:
if delNode.value < delNodeParent.value:
delNodeParent.leftChild = None
else:
delNodeParent.rightChild = None
return True
parent = None
node = self.root
# find node to remove
while node and node.value != data:
parent = node
if data < node.value:
node = node.leftChild
elif data > node.value:
node = node.rightChild
# case 1: data not found
if node is None or node.value != data:
return False
# case 2: remove-node has no children
elif node.leftChild is None and node.rightChild is None:
if data < parent.value:
parent.leftChild = None
else:
parent.rightChild = None
return True
# case 3: remove-node has left child only
elif node.leftChild and node.rightChild is None:
if data < parent.value:
parent.leftChild = node.leftChild
else:
parent.rightChild = node.leftChild
return True
# case 4: remove-node has right child only
elif node.leftChild is None and node.rightChild:
if data < parent.value:
parent.leftChild = node.rightChild
else:
parent.rightChild = node.rightChild
return True
# case 5: remove-node has left and right children
else:
delNodeParent = node
delNode = node.rightChild
while delNode.leftChild:
delNodeParent = delNode
delNode = delNode.leftChild
node.value = delNode.value
if delNode.rightChild:
if delNodeParent.value > delNode.value:
delNodeParent.leftChild = delNode.rightChild
elif delNodeParent.value < delNode.value:
delNodeParent.rightChild = delNode.rightChild
else:
if delNode.value < delNodeParent.value:
delNodeParent.leftChild = None
else:
delNodeParent.rightChild = None
def preorder(self):
if self.root is not None:
print("PreOrder")
self.root.preorder()
def postorder(self):
if self.root is not None:
print("PostOrder")
self.root.postorder()
def inorder(self):
if self.root is not None:
print("InOrder")
self.root.inorder()
bst = Tree()
print(bst.insert(10))
#print(bst.insert(5))
bst.preorder()
print(bst.getHeight())
#bst.postorder()
#bst.inorder()
print(bst.remove(10))
bst.preorder()

236
Trees/bst.py Normal file
View File

@@ -0,0 +1,236 @@
# Binary Search Tree in Python
class Node:
def __init__(self, val):
self.value = val
self.leftChild = None
self.rightChild = None
def insert(self, data):
if self.value == data:
return False
elif self.value > data:
if self.leftChild:
return self.leftChild.insert(data)
else:
self.leftChild = Node(data)
return True
else:
if self.rightChild:
return self.rightChild.insert(data)
else:
self.rightChild = Node(data)
return True
def find(self, data):
if(self.value == data):
return True
elif self.value > data:
if self.leftChild:
return self.leftChild.find(data)
else:
return False
else:
if self.rightChild:
return self.rightChild.find(data)
else:
return False
def getSize(self):
if self.leftChild and self.rightChild:
return 1 + self.leftChild.getSize() + self.rightChild.getSize()
elif self.leftChild:
return 1 + self.leftChild.getSize()
elif self.rightChild:
return 1 + self.rightChild.getSize()
else:
return 1
def getHeight(self):
if self.leftChild and self.rightChild:
return 1 + max(self.leftChild.getHeight(), self.rightChild.getHeight())
elif self.leftChild:
return 1 + self.leftChild.getHeight()
elif self.rightChild:
return 1 + self.rightChild.getHeight()
else:
return 1
def preorder(self):
if self:
print (str(self.value))
if self.leftChild:
self.leftChild.preorder()
if self.rightChild:
self.rightChild.preorder()
def postorder(self):
if self:
if self.leftChild:
self.leftChild.postorder()
if self.rightChild:
self.rightChild.postorder()
print (str(self.value))
def inorder(self):
if self:
if self.leftChild:
self.leftChild.inorder()
print (str(self.value))
if self.rightChild:
self.rightChild.inorder()
class Tree:
def __init__(self):
self.root = None
def insert(self, data):
if self.root:
return self.root.insert(data)
else:
self.root = Node(data)
return True
def find(self, data):
if self.root:
return self.root.find(data)
else:
return False
def getHeight(self):
if self.root:
return self.root.getHeight()
else:
return 0
def getSize(self):
if self.root:
return self.root.getSize()
else:
return 0
def remove(self, data):
# empty tree
if self.root is None:
return False
# data is in root node
elif self.root.value == data:
if self.root.leftChild is None and self.root.rightChild is None:
self.root = None
elif self.root.leftChild and self.root.rightChild is None:
self.root = self.root.leftChild
elif self.root.leftChild is None and self.root.rightChild:
self.root = self.root.rightChild
elif self.root.leftChild and self.root.rightChild:
delNodeParent = self.root
delNode = self.root.rightChild
while delNode.leftChild:
delNodeParent = delNode
delNode = delNode.leftChild
self.root.value = delNode.value
if delNode.rightChild:
if delNodeParent.value > delNode.value:
delNodeParent.leftChild = delNode.rightChild
elif delNodeParent.value < delNode.value:
delNodeParent.rightChild = delNode.rightChild
else:
if delNode.value < delNodeParent.value:
delNodeParent.leftChild = None
else:
delNodeParent.rightChild = None
return True
parent = None
node = self.root
# find node to remove
while node and node.value != data:
parent = node
if data < node.value:
node = node.leftChild
elif data > node.value:
node = node.rightChild
# case 1: data not found
if node is None or node.value != data:
return False
# case 2: remove-node has no children
elif node.leftChild is None and node.rightChild is None:
if data < parent.value:
parent.leftChild = None
else:
parent.rightChild = None
return True
# case 3: remove-node has left child only
elif node.leftChild and node.rightChild is None:
if data < parent.value:
parent.leftChild = node.leftChild
else:
parent.rightChild = node.leftChild
return True
# case 4: remove-node has right child only
elif node.leftChild is None and node.rightChild:
if data < parent.value:
parent.leftChild = node.rightChild
else:
parent.rightChild = node.rightChild
return True
# case 5: remove-node has left and right children
else:
delNodeParent = node
delNode = node.rightChild
while delNode.leftChild:
delNodeParent = delNode
delNode = delNode.leftChild
node.value = delNode.value
if delNode.rightChild:
if delNodeParent.value > delNode.value:
delNodeParent.leftChild = delNode.rightChild
elif delNodeParent.value < delNode.value:
delNodeParent.rightChild = delNode.rightChild
else:
if delNode.value < delNodeParent.value:
delNodeParent.leftChild = None
else:
delNodeParent.rightChild = None
def preorder(self):
if self.root is not None:
print("PreOrder")
self.root.preorder()
def postorder(self):
if self.root is not None:
print("PostOrder")
self.root.postorder()
def inorder(self):
if self.root is not None:
print("InOrder")
self.root.inorder()
def main():
bst = Tree()
print(bst.insert(10))
print(bst.insert(5))
bst.insert(2)
bst.insert(7)
bst.preorder()
print('Height = ', bst.getHeight())
print('Size = ', bst.getSize())
#bst.postorder()
#bst.inorder()
print(bst.remove(10))
bst.preorder()
main()