integer_variable = 2
# Hexadecimal
integer_variable = 0x212
# Binary
integer_variable = 0b10101
float_variable = 5.0
string_variable = "Machine Learning"  # or 'Machine Learning'

integer_variable=0x12
integer_variable=0b10010
float_variable=0.1234
"{:.3f}".format(float_variable) # change precision of float
# "{:b}".format(integer_variable) # change integer to binary
# "{:x}".format(integer_variable) # change integer to hex
# "{:o}".format(integer_variable) # change integer to octal
# "{:d}".format(integer_variable) # change integer to decimal
# "{:c}".format(integer_variable) # change integer to ascii
# "{:e}".format(float_variable) # change float to scientific notation
# "{:E}".format(float_variable) # change float to scientific notation
# "{:f}".format(float_variable) # change float to decimal
# "{:.xf}".format(float_variable) # change float to x decimal places

x=10
y=20
x+y
print(x+y)
print(x-y)
print(x*y)
print(x/y)  #float division     
print(x//y) #integer division
print(x**y) #power
print(x%y)  #modulus

x=10
y=20
x+y
print(x>y) # greater
print(x<y) # less   
print(x==y) # equal
print(x!=y) # not equal
print(x>=y) # greater or equal

x=True 
y=False
x=0
y=1
x>y and y<x
x>y or y<x
not x>y
x=-10 # any number other than zero is True
print(not x)
x=-200 # check what happens
y=1000
print(x and y)

# bitwise operators
a=0b1010
b=0b1100
print("{:b}".format(a&b)) # bitwise and
print("{:b}".format(a|b)) # bitwise or
print("{:b}".format(a^b)) # bitwise xor
print("{:b}".format(~a)) # bitwise not
print("{:b}".format(a<<1)) # bitwise left shift
print("{:b}".format(a>>1)) # bitwise right shift
print("{:b}".format(a>>2)) # bitwise right shift
# observe output of below and try to do circular shift
a=0b1010
b=0b11000
print("{:b}".format(a&b)) # bitwise and

str1='machine learning'
str2=str3[::-1] # string reversal
print(str3)
str1+str2 # string concatenation
str1*3 # string multiplication
str1[0] # string indexing
str1[1:3] # string slicing
str1[-1] # string negative indexing
str1[-3:-1] # string negative slicing
str1[0:3:2] # string slicing with step
str1[::2] # string slicing with step
# illegal string operations
str1[0]='a' # string assignment
str1+1 # string addition

list_of_integers=[1,2,3,4,5,6,7,8,9,10]
list_of_integers_floats=[1.0,2.0,3.0,4.0,5,6.0,7.0,8.0,9,10]
list_of_strings_and_numbers=['1','two','3','four','5','six','7','eight','9','ten']
# indexing lists
print(list_of_integers[0])
print(list_of_integers[-1]) # last element
print(list_of_integers[0:3]) # first 3 elements
print(list_of_integers[3:]) # elements 3 to end
print(list_of_integers[::2]) # every other element
print(list_of_integers[::-1]) # reverse order
print(list_of_integers[1:8:2]) # every other element from 1 to 8
# list comprehensions
squares = [x**2 for x in list_of_integers]
# list comprehensions with conditionals
even_squares = [x**2 for x in list_of_integers if x%2==0]
# list comprehensions with conditionals and else
even_squares = [x**2 if x%2==0 else x**3 for x in list_of_integers]
# list comprehensions with nested loops
pairs = [[x,y] for x in list_of_integers for y in list_of_integers]
# list concatenation
list_of_integers = list_of_integers + list_of_integers
list_of_integers += list_of_integers

# dictionaries hold key value pairs, and ubiquitous in many programming languages, and data bases
# dictionaries are mutable, and can be changed
# key is immutable, value can be mutable
# keys are unique, values need not be unique
# keys are case sensitive, must be immutable, and can be strings, numbers, or tuples
dict = {'name': 'Zach', 'height': 1.8, 'weight': 80, 'BMI': 24.69, 'predicted_weight': 80.5}
# access the value of a key
dict['name']
type(dict['height'])
dict={1:'Zach', 2:'ML', 'third':80, (4,'fourth'):24.69, 5:80.5}
dict[(4,'fourth')]
dict[1]
dict['third']
# concatenate dictionaries
dict1 = {'name': 'Zach', 'height': 1.8, 'weight': 80, 'BMI': 24.69, 'predicted_weight': 80.5}
dict2 = {1:'Zach', 2:'ML', 'third':80, (4,'fourth'):24.69, 5:80.5}
dict1.update(dict2)

# tuples
tup = (1,2,3)
tup = (1,2,3,4,5,6,7,8,9,10)
tup = (1,2,3,'street', 'city', 'state', 'zip',1.11)
# tuples are similar to lists, but they are immutable
# indexing and slicing
tup[0]
tup[0:3]
tup[3:6]
# tuples are immutable
# tup[0] = 100 # this will throw an error

# for loop
list_of_integers_floats_strings = [1, 2.0, '3']
# simple for loop
for item in list_of_integers_floats_strings:
    print(item)
# for loop with enumerate
for index, item in enumerate(list_of_integers_floats_strings):
    print(index, item)
# enumerate returns a tuple of the index and the item
# list comprehension
[item for item in list_of_integers_floats_strings]
# list comprehension with enumerate
[index for index, item in enumerate(list_of_integers_floats_strings)]
# list comprehension with nested for loops
# helps in creating a list of lists
[[item for item in list_of_integers_floats_strings] for index, item in enumerate(list_of_integers_floats_strings)]

 conditional statements in python
# if, elif, else
# if condition:
#     do something
# elif condition:
#     do something
# else:
#     do something

# Syntax for function definition
def my_function():
        # write logic here
    print('Hello World')
# Syntax for function call
my_function()

# Syntax for function definition
# import numpy module
import numpy as <any_name, say np>
import numpy as np
# list of numpy functions
dir(np)
# help on a function
help(np.array)
# use a function
np.array([1,2,3]) # returns an array of 1,2,3
# data types in numpy
# int, float, bool, str, object, complex, bytes, unicode