Rule
Untested code is wrong code.for i in range(1,15,1): # range(begin,end, step)
print(i**0.01, end=" ")1.0 1.0069555500567189 1.0110466919378536 1.013959479790029 1.0162245912673256 1.0180790778133073 1.0196496638564592 1.0210121257071934 1.022215413278477 1.023292992280754 1.0242687596005495 1.0251603778007359 1.025981272414434 1.0267418881337291 end=" " prints the whole output in a single line. We can also use end="\t" or end="\n"range function only works with integer step size!Lists are a container of elements. They are mutable.
xs = [1,2,3]
ys = xs
ys.append(10)
print(xs)[1, 2, 3, 10]import math
xs=[]
for i in range(20):
xs.append(math.sin(i*math.pi/10))
print(f"xs={xs}")xs=[0.0, 0.3090169943749474, 0.5877852522924731, 0.8090169943749475, 0.9510565162951535, 1.0, 0.9510565162951536, 0.8090169943749475, 0.5877852522924732, 0.3090169943749475, 1.2246467991473532e-16, -0.3090169943749469, -0.587785252292473, -0.8090169943749473, -0.9510565162951535, -1.0, -0.9510565162951536, -0.8090169943749476, -0.5877852522924734, -0.3090169943749476]Lists are mutable.
xs = [1,2,3]
xs[0]=100
print("xs[0]=100")
print(f"xs={xs}")xs[0]=100
xs=[100, 2, 3]To reverse a list we need to do some stuffs.
import math
# GENERATING A LIST
xs=[]
for i in range(20):
xs.append(math.sin(i*math.pi/10))
print(f"xs={xs}")
# REVERSING THE GENERATED LIST
for i in range(20):
temp = xs[::-1] # [start:stop:step]
xs = temp
print(f"Reversed xs={xs}")xs=[0.0, 0.3090169943749474, 0.5877852522924731, 0.8090169943749475, 0.9510565162951535, 1.0, 0.9510565162951536, 0.8090169943749475, 0.5877852522924732, 0.3090169943749475, 1.2246467991473532e-16, -0.3090169943749469, -0.587785252292473, -0.8090169943749473, -0.9510565162951535, -1.0, -0.9510565162951536, -0.8090169943749476, -0.5877852522924734, -0.3090169943749476]
Reversed xs=[-0.3090169943749476, -0.5877852522924734, -0.8090169943749476, -0.9510565162951536, -1.0, -0.9510565162951535, -0.8090169943749473, -0.587785252292473, -0.3090169943749469, 1.2246467991473532e-16, 0.3090169943749475, 0.5877852522924732, 0.8090169943749475, 0.9510565162951536, 1.0, 0.9510565162951535, 0.8090169943749475, 0.5877852522924731, 0.3090169943749474, 0.0]We can also add lists using the + operator
xs = 10*[0]
ys = 10*[math.pi]
zs = xs + ys
print(zs)[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793, 3.141592653589793]To get the length and sum of the list we use the len and sum function respectively
xs = [1,2,3]
print(len(xs))
sum((xs))36To get a new list from a old one you have to slice it. Caution: When you slice you get a copy of the original list That is, when you name a list something else then mutate it it will mutate the original list. But if you slice it then you get a copy of the original list.
xs = [1,2,4]
ys = xs[:]
print(ys)[1, 2, 4]: will get the entire listprint("Upto but not including 5")
xs[2:5]Upto but not including 5[4]Manipulating the steps in the list.
## Slicing with steps
xs[::2][1, 4]a = [1,3,4]
a[begin:end:step]a[1:3] will give elements [1,3).Note: The range() function works similarly to lists but uses commas , instead of colons :.
range(begin,end,step)Tuples can be thought of as immutable lists. tuple1 = (a,b,c) - They can be called like the array e.g., tuple1[0] will output a. - We can omit the parentheses for tuples
tuple1 = 1,2,3
print(tuple1)(1, 2, 3)x = 1; y =2; z = 3
x,y,z(1, 2, 3)Tuples can be used to return multiple values from a function
def foo(a, b):
z = a + b
return a,b,z
foo(1,2)(1, 2, 3)Strings can also be viewed as immutable lists. They are sequences of characters, e.g., name='Marry' - We can concatenate two strings using the + operator.
name = "Marry"
## Reversing strings
temp = ''
length = len(name)
for i in range(len(name)):
if i==0:
i = -1
else:
i = -i-1
temp = temp+(name[i])
print(name)
print(temp)Marry
yrraMformat() functionThe format() function converts other data types to strings.
x = 1
y = 2
"{0} {1}".format(x,y)'1 2'A = True; B = False
"{0} {1}".format(A,B)'True False'format function# Generate a list
import random as rd
xs = []
rd.seed(100)
for i in range(20):
xs.append(rd.randint(0, 100))
print(f"Generated list: {xs}")
# Converting a list to string
ys = ""
for i in range(len(xs)):
if i== len(xs)-1:
ys += str({i})
else:
ys += str({i})+', '
# print(ys)
ys = ys.format(xs[0],xs[1],xs[2],xs[3],xs[4],xs[5],xs[6],xs[7],xs[8],xs[9],xs[10],xs[11],xs[12],xs[13],xs[14],xs[15],xs[16],xs[17],xs[18],xs[19])
print(ys)Generated list: [18, 58, 58, 98, 22, 90, 50, 93, 44, 55, 64, 14, 68, 15, 10, 94, 58, 33, 6, 84]
18, 58, 58, 98, 22, 90, 50, 93, 44, 55, 64, 14, 68, 15, 10, 94, 58, 33, 6, 84A better way to format a list of numbers to strings.
format function 2# Generating a list of numbers
import random as rd
xs = []
rd.seed(100)
for i in range(20):
xs.append(rd.randint(0, 100))
print("Generated list: ", xs)
# Converting the list of numbers to strings
ys = ""
for i in range(len(xs)):
if i == len(xs)-1:
ys += str(xs[i])
else:
ys += str(xs[i])+','
print(ys)Generated list: [18, 58, 58, 98, 22, 90, 50, 93, 44, 55, 64, 14, 68, 15, 10, 94, 58, 33, 6, 84]
18,58,58,98,22,90,50,93,44,55,64,14,68,15,10,94,58,33,6,84We can control the precision of the decimals using the format() function as well.
x = 3.1; y = 4
"{0:1.15}{1}".format(x,y)'3.14'import math
π = math.pi
"π approximation to 15 digits: {0:1.15f}".format(π)'π approximation to 15 digits: 3.141592653589793'This will output the value of x with precision of 15 decimal places. - Note: We use the colon operator : to specify the number of decimal places.
The syntax for f strings,
a = 1; b = 2
print("a = {a}, b = {b}")a = {a}, b = {b}A dictionary is an associative array containing key value pairs.
myDic = {
'a': 1,
'b': 2,
'c': 3
}myDic['c']3Another way to create dict is through the following syntax
better_dic: dict = {'a':1,'b':2, 'c':3 }
print(better_dic){'a': 1, 'b': 2, 'c': 3}This is more powerful because we can make multi valued dictionaries with it.
com_dic: dict = {0:['a','b'], 1:['c', 'd']}
print(com_dic){0: ['a', 'b'], 1: ['c', 'd']}This is another way of declaring stuffs like dict list etc.
There are 11 methods that can be used in python dictionaries.
values()This outputs all the values of a key value paired dictionary.
myDic = {
'a': 1,
'b': 2,
'c': 3
}
print(myDic.values())dict_values([1, 2, 3])items()This prints the whole dictionary with all its key value pairs
dic = {'a':1, 'b':2, 'c':3}
print(dic.items())dict_items([('a', 1), ('b', 2), ('c', 3)])keys()keys() does the exact opposite of the values() method.
dic = {'a':1, 'b':2, 'c':3}
print(dic.keys())dict_keys(['a', 'b', 'c'])pop()pop() allows us to remove a specific entry by referencing its key.
dic = {'a':1, 'b':2, 'c':3}
dic.pop('a')
print(dic){'b': 2, 'c': 3}dic = {'a':1, 'b':2, 'c':3}
print(dic.pop('a'))1popitem()popitem() removes the last item from our dictionary
dic = {'a':1, 'b':2, 'c':3}
dic.popitem()
print(dic){'a': 1, 'b': 2}copy()Through copy() method we can create a copy of an existing dictionary
another_dic: dict = {0:['a','b'], 1:['c','d']}
my_copy = another_dic.copy()
print(my_copy){0: ['a', 'b'], 1: ['c', 'd']}We can use the id method to check the memory address of the lists to see they are indeed different.
print(id(another_dic),id(my_copy))140332286616768 140332286620288Warning: Python uses shallow copy like lists, changing the copy will change the source. #### Method 6: get() The get() function is used to get a particular value as output.
myDic = {
'a': 1,
'b': 2,
'c': 3
}
print(myDic.get('a'))1If the key is out of range we will get a None output as default. We can change it to a specific error message if we like.
myDic = {
'a': 1,
'b': 2,
'c': 3
}
print(myDic.get('z','Missing!'))Missing!setdefault()Similar to the get() method, it tries to grab a key value pair, but if that key value pair doesn’t exist setdefault() will create it.
myDic = {
'a': 1,
'b': 2,
'c': 3
}
print(myDic.setdefault('z', 100))
print(myDic)100
{'a': 1, 'b': 2, 'c': 3, 'z': 100}clear()This clears the dictionary making it empty
myDic = {
'a': 1,
'b': 2,
'c': 3
}
print(myDic.setdefault('z', 100))
print(myDic.clear())100
Nonefromkeys()Transforms a list to a dictionary
None as the placeholder for keyspeople: list[str] = ["John", "Jane", "Joe"]
users: dict = dict.fromkeys(people)
print(users){'John': None, 'Jane': None, 'Joe': None}people: list[str] = ["John", "Jane", "Joe"]
users: dict = dict.fromkeys(people,'Unknown')
print(users){'John': 'Unknown', 'Jane': 'Unknown', 'Joe': 'Unknown'}items()To get the keys and values of a dictionary.
users: dict ={0: "Mike", 1: "Bob", 2: "Alice"}
for k,v in users.items():
print(k,v)0 Mike
1 Bob
2 Aliceupdate()Using update() we can expand our dictionary.
users: dict ={0: "Mike", 1: "Bob", 2: "Alice"}
users.update({3: "John"})
print(users){0: 'Mike', 1: 'Bob', 2: 'Alice', 3: 'John'}output: {0: 'Mike', 1: 'Bob', 2: 'Alice', 3: 'John'}If you input a key value pair that already exists it will update to the most recent key value pair and the older one will be removed.
users: dict ={0: "Mike", 1: "Bob", 2: "Alice"}
users.update({1: "John"})
print(users){0: 'Mike', 1: 'John', 2: 'Alice'}output: {0: 'Mike', 1: 'John', 2: 'Alice'}We can also update our dictionary using a pipeline |.
users: dict ={0: "Mike", 1: "Bob", 2: "Alice"}
users.update({1: "John"})
print(users | {4: "Scar", 5: "Tom"}){0: 'Mike', 1: 'John', 2: 'Alice', 4: 'Scar', 5: 'Tom'}output: {0: 'Mike', 1: 'John', 2: 'Alice', 4: 'Scar', 5: 'Tom'}We can also do in place assignment using |= to assign values to our dictionary. This is the newer version of update()
users: dict ={0: "Mike", 1: "Bob", 2: "Alice"}
users |= {'name': 'John', 'age': 30, 'city': 'New York'}
print(users){0: 'Mike', 1: 'Bob', 2: 'Alice', 'name': 'John', 'age': 30, 'city': 'New York'}output: {0: 'Mike',
1: 'Bob',
2: 'Alice',
'name': 'John',
'age': 30,
'city': 'New York'}enumerate functionThe enumerate() function is used to create pairing.
import numpy as np
t = np.linspace(0, 10, 10)
y = np.sin(t)
for t, y in enumerate(y):
print(t, y)0 0.0
1 0.8961922010299563
2 0.7952200570230491
3 -0.19056796287548539
4 -0.9643171169287782
5 -0.6651015149788224
6 0.37415123057121996
7 0.9970978909438749
8 0.510605678474283
9 -0.5440211108893698names: list[str]= ["John", "Scar", "Michael","Jessica","Mary","David","Sarah","Emily","Daniel","Olivia"]
profile: dict[str,str] = {}
for i,names in enumerate(names):
profile |= {names:i}
print(profile){'John': 0, 'Scar': 1, 'Michael': 2, 'Jessica': 3, 'Mary': 4, 'David': 5, 'Sarah': 6, 'Emily': 7, 'Daniel': 8, 'Olivia': 9}output: {'John': 0, 'Scar': 1, 'Michael': 2, 'Jessica': 3, 'Mary': 4, 'David': 5, 'Sarah': 6, 'Emily': 7, 'Daniel': 8, 'Olivia': 9}reversed() functionxs = [1,2,3]
for i in reversed(xs):
print(i)3
2
1lambdaIn python we can create throw-away functions using the lambda.
f = lambda x: x + 4These are helpful for creating one time functions.
Suppose we wish to put the linear combination of fa(x) and fb(x) but we do not know the parameters a and b for the expression a*fa(x)+b*fb(x) and the der() function only accepts functions. Without modifying the function or creating a new function we can use the lambda function to get the job done.
# Problem: 1.4
## Defining a function that is creates a linear combination of two other functions
def fa(x):
return x+1
def fb(x):
return x+7
def fc(x,a,b):
return a*fa(x) + b*fb(x)
def der(f,x,h=0.01):
return (f(x+h)-f(x))/h
print(der(lambda x:fc(x,1,1),1))1.9999999999999574We now want to use a syntax that makes the code more concise and straightforward.
For one list:
[i**2 for i in range(30)]
For two lists use the zip() function
xs = np.random.random(100)
ys = np.random.random(100)
[x*y for x,y in zip(xs,ys)][np.float64(0.030632758654182596),
np.float64(0.08860528518745427),
np.float64(0.040347814228640935),
np.float64(0.1268483174627677),
np.float64(0.3256636739177829),
np.float64(0.2333783092896792),
np.float64(0.7712619266076728),
np.float64(0.5716187749489361),
np.float64(0.7390406423491416),
np.float64(0.10702484655476216),
np.float64(0.2696487455680809),
np.float64(0.302727059148923),
np.float64(0.20910297505484035),
np.float64(0.4218451567239563),
np.float64(0.5168000904880181),
np.float64(0.038892098102975926),
np.float64(0.18463291694776654),
np.float64(0.647572107539291),
np.float64(0.1716971632626683),
np.float64(0.5035971548825083),
np.float64(0.14752982021540276),
np.float64(0.02690852364391783),
np.float64(0.5412893191759814),
np.float64(0.04856053111663568),
np.float64(0.6530267108125083),
np.float64(0.2747796428132065),
np.float64(0.07955548375160942),
np.float64(0.2429459305787054),
np.float64(0.07450630469091749),
np.float64(0.0689181657259769),
np.float64(0.09215974081804586),
np.float64(0.16934816636990982),
np.float64(0.14122588337486103),
np.float64(0.04680945464090686),
np.float64(0.1472653761133547),
np.float64(0.19172229693692402),
np.float64(0.1578833300213795),
np.float64(0.04833971387167529),
np.float64(0.05452767127363731),
np.float64(0.17769006122147915),
np.float64(0.02163065582876842),
np.float64(0.5300740051246864),
np.float64(0.33171071832420257),
np.float64(0.12247396445055576),
np.float64(0.1793762332879205),
np.float64(0.08490773281667723),
np.float64(0.3290481659672818),
np.float64(0.2578265041113732),
np.float64(0.0036154961176312708),
np.float64(0.05555407093340941),
np.float64(0.21306128112371428),
np.float64(0.6915200154211338),
np.float64(0.13441439596028285),
np.float64(0.4250754961174702),
np.float64(0.004676583643229594),
np.float64(0.02799185149453212),
np.float64(0.27937760074756224),
np.float64(0.03205572721252944),
np.float64(0.04122299603268929),
np.float64(0.5482831889205254),
np.float64(0.657919406057139),
np.float64(0.14342484161151117),
np.float64(0.30882676036922974),
np.float64(0.05236485800519002),
np.float64(0.1345376632682942),
np.float64(0.03036410816999096),
np.float64(0.8493606911558966),
np.float64(0.19506605117551426),
np.float64(0.3063565617604729),
np.float64(0.2871815991959562),
np.float64(0.04834980499776785),
np.float64(0.5352764268645924),
np.float64(0.04578331529172105),
np.float64(0.09960816046292914),
np.float64(0.017251709725402527),
np.float64(0.6654391845492434),
np.float64(0.007455441606777555),
np.float64(0.4502092418698092),
np.float64(0.11893549703132252),
np.float64(0.17338051363231619),
np.float64(0.23410026282519114),
np.float64(0.5694201040713845),
np.float64(0.5844142260552838),
np.float64(0.07158000096020616),
np.float64(0.3875979109803691),
np.float64(0.29089690303335275),
np.float64(0.12289910595612623),
np.float64(0.005227038906899065),
np.float64(0.34792932507678775),
np.float64(0.3336101990258723),
np.float64(0.15415468603665936),
np.float64(0.0028331185526422826),
np.float64(0.701799468851816),
np.float64(0.08665734373084315),
np.float64(0.09943122115566062),
np.float64(0.16574684661893543),
np.float64(0.1082942513021894),
np.float64(0.11348252413631493),
np.float64(0.07854411708745214),
np.float64(0.0179232811314264)]a = [1,2,3,4,5]
b = ['a','b','c','d']
c = ['Scar', 'John']
list(zip(a,b,c))[(1, 'a', 'Scar'), (2, 'b', 'John')]output: [(1, 'a', 'Scar'), (2, 'b', 'John')]zip function creates an ordered pair onlyxs = [1,2,3,4,5]
ys = [4,3,6,0,9]
for i,j in zip(xs,ys):
if i==j:
print(True)
else:
print(False)False
False
False
False
Falseoutput: False
False
False
False
Falsexs = [1,2,3,4,5]
ys = [4,3,6,0,9]
list(zip(xs,ys))[(1, 4), (2, 3), (3, 6), (4, 0), (5, 9)]output: [(1, 4), (2, 3), (3, 6), (4, 0), (5, 9)](i,j) where i==j.Use the items() method.
names: dict[int,str] = {1:'Sarah', 2:'John', 3:'James', 4:'Mary'}
names_list = [(key,value) for key, value in names.items()]
names_tuple = tuple((key,value) for key, value in names.items())
print("names_list: ", names_list)
print("names_tuple: ", names_tuple)names_list: [(1, 'Sarah'), (2, 'John'), (3, 'James'), (4, 'Mary')]
names_tuple: ((1, 'Sarah'), (2, 'John'), (3, 'James'), (4, 'Mary'))assertassert keywordx = int(input("Enter a number: "))
y = int(input("Enter another number: "))
assert y != 0, "Cannot divide by zero"
print(x/y)It can also be used in if-else control flows.
breakWhen you want to exit out of a loop prematurely, you use the break keyword.
x = [i for i in range(5)]
y = [i+i for i in range(5,0,-1)]
for i in range(len(x)):
for j in range(len(y)):
if x[j] == 0:
print("Cannot divide by zero")
elif x[i]==x[j]:
print(f"{x[i]} is equal to {x[j]}")
break
elif x[i]==x[j]:
print(x[i]/0) # Division by zeroCannot divide by zero
Cannot divide by zero
1 is equal to 1
Cannot divide by zero
2 is equal to 2
Cannot divide by zero
3 is equal to 3
Cannot divide by zero
4 is equal to 4output: Cannot divide by zero
Cannot divide by zero
1 is equal to 1
Cannot divide by zero
2 is equal to 2
Cannot divide by zero
3 is equal to 3
Cannot divide by zero
4 is equal to 4break yet it doesn’t get there because the break keyword breaks the loop.import matplotlib.pyplot as plt
import numpy as np
def Plot(xs, ys, dxs, dys):
plt.xlabel("x", fontsize=14)
plt.ylabel("f(x)", fontsize=14)
plt.plot(xs, ys, 'r--', label="$f(x)$")
plt.plot(dxs, dys, 'b--^', label="$g(x)$")
plt.errorbar(dxs, dys, dyerrs, fmt='ko', label="With error")
plt.legend()
plt.grid(True)
plt.show()
xs = [0.1*i for i in range(60)]
ys = [x**2 for x in xs]
dxs = [i for i in range(7)]
dys = [x**1.8 -0.5 for x in dxs]
dyerrs = [0.1*np.abs(y) for y in dys]
Plot(xs, ys, dxs, dys)
plot() functionplt.plot(x_values, y_values, 'plotStyle', label='Function')plot() is a format string that specifies the style of the plot.| Character | Color |
|---|---|
| ‘b’ | blue |
| ‘g’ | green |
| ‘r’ | red |
| ‘c’ | cyan |
| ‘m’ | megenta |
| ‘y’ | yellow |
| ‘k’ | black |
| ‘w’ | white |
| Character | Description |
|---|---|
| ‘-’ | solid line style |
| ‘–’ | dashed line style |
| ‘-.’ | dash-dot line style |
| ‘:’ | dotted line style |
| ‘o’ | circle marker |
| ‘s’ | square markerq |
| ‘D’ | diamond marker |
| ‘^’ | triangle up marker |
The forth argument is also a format string that specifies the label of the function plotted. We can use the plt.legend() after this to get legends.
plt.errorbar(dxs, dys, dyerrs, fmt='ko', label="With error")
where dyerrs is specified outside the function in that example.
dyerrs = [0.1*np.abs(y) for y in dys]plt.plot(x,y,label="$x_i$")
xlim() and ylim().xscale() or yscale().We can use the built in zip function to step through lists in parallel.
def f(x):
return x**2 - 2
ws = [1,2,3,4,5,6,7,8,9,10]
xs = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0]
c = [w*f(x) for w,x in zip(ws,xs)]
print(c)[-1.99, -3.92, -5.7299999999999995, -7.359999999999999, -8.75, -9.84, -10.57, -10.879999999999999, -10.709999999999999, -10.0]Almost always python lists are of homogeneous type. So we can do the tasks more efficiently using a fixed-length homogeneous container.
This is where numpy comes in.
Numpy also allows us, for the most part, to avoid writing loops.
Numpy arrays are row major similar to C programming language.
One-dimensional arrays are direct replacements for lists. We can make an one-dimensional array using the array function in numpy.
some_list = [1,2,3,4,5,6]
A = np.array(some_list)or,
ys = np.array([1,2,3,4,5,6])The array() function creates an array object.
ys, use the size attribute.ys.size6dtype attributeys.dtypedtype('int64')ys = np.array([1,2,3,4,5], dtype=np.float32)shape attribute| Attribute | Description |
|---|---|
dtype |
Data type of array elements |
ndim |
Number of columns in the array |
shape |
Tuple with number of elements for each dimension |
size |
Total number of elements |
To create containers with predefined size we can use np.zeros() or np.ones(), e.g., np.zeros(5), np.zeros((5,5)).
We can work with float arguments using np.arange() unlike the built-in range() function. However, it is better to use the np.linspace() function.
# syntax for linspace
np.linspace(min_, max_,steps)There is also the np.logspace() function that creates logarithmically spaced grid points.
np.logspace(1, 10, 10)array([1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07, 1.e+08,
1.e+09, 1.e+10])output: array([1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07, 1.e+08,
1.e+09, 1.e+10])Python arrays as well as numpy arrays use shallow-copy
To do a deep-copy use np.copy() function.
A = np.random.random(10)
B = np.copy(A[::-1])
B[0] = 10
print(A)
print('------')
print(B)[0.65218771 0.27505955 0.76205406 0.52608458 0.85500303 0.20575955
0.98090739 0.4810088 0.05797666 0.44671703]
------
[10. 0.05797666 0.4810088 0.98090739 0.20575955 0.85500303
0.52608458 0.76205406 0.27505955 0.65218771]Arrays, unlike lists, can be used to broadcast numbers onto many slots.
List slicing in numpy cannot be used to copy arrays but it can be used to broadcast a slice or an element of the array to itself. This syntax is known as an everything slice.
A = np.random.random(10)
A*A[::-1]
print(A)[0.49798273 0.17793492 0.54310028 0.92102353 0.87562588 0.40271032
0.73302273 0.67423247 0.61685176 0.08417344]By default, numpy broadcasts all its arrays. This ability to carry out batch operations on all elements of an array is called vectorization.
A = np.random.random(10)
B = np.random.random(10)
np.sum(A*B) # Vectorizationnp.float64(3.0668776975271617)You can also carry out other operations with arrays that wouldn’t be possible with matrices or vectors like 1/np.array([1,2,3]) thanks to broadcasting.
np.where() helps you to find specific indices where a coordination is met, e.g., np.where(2==xs)
np.sum() sums all the elements of any N-dimensional array.
np.argmax() and np.argmin() returns the maximum and minimum value of an array respectively.
np.transpose() transposes the array A. We can also use the shorthand A.T to get the same result.
import numpy as np
np.random.seed(12)
A = np.random.random((3,3))
print(A.T)[[0.15416284 0.53373939 0.90071485]
[0.7400497 0.01457496 0.03342143]
[0.26331502 0.91874701 0.95694934]]The reshape() function in numpy reshapes the array to the specified dimension.
xs = np.array(([1,2],
[3,4],
[5,6]))
print(xs.reshape(6,1))[[1]
[2]
[3]
[4]
[5]
[6]]np.diag() outputs the diagonal matrixnp.tril() and np.triu() to get lower triangle and upper triangle of an array respectively.One of the most important function is the np.meshgrid() function which takes two vectors and returns a coordinate matrix.
np.fill_diagonal() is helpful to update an array that you already created.np.trace() is used to find the trace of a matrix.We can multiply matrices using the @ infix operator.
import numpy as np
np.random.seed(12)
A = np.random.random((3,3))
B = np.random.random((3,1))
print(A@B)[[0.39079047]
[0.63420792]
[0.71306332]]We can loop over rows and columns in numpy
import numpy as np
np.random.seed(12)
A = np.random.random((3,3))
B = np.random.random((3,1))
# Loop over the rows
print("Looping over the rows")
for row in A:
print(row)
# Looping over columns
print("Looping over columns")
for columns in B.T:
print(columns)Looping over the rows
[0.15416284 0.7400497 0.26331502]
[0.53373939 0.01457496 0.91874701]
[0.90071485 0.03342143 0.95694934]
Looping over columns
[0.13720932 0.28382835 0.60608318]For inner and outer product we use np.inner() and np.outer() function respectively.
import numpy as np
np.random.seed(12)
A = np.random.random((2,2))
B = np.random.random((2,2))
print(f"Matrix A is: \n {A}")
print('----------------------------------------')
print(f"Matrix B is: \n {B}")
print('----------------------------------------')
innerProduct = np.inner(A,B)
print(f"Inner product of A and B is:\n {innerProduct}")
print('----------------------------------------')
outerProduct = np.outer(A,B)
print(f"Outer product of A and B is: \n {outerProduct}")Matrix A is:
[[0.15416284 0.7400497 ]
[0.26331502 0.53373939]]
----------------------------------------
Matrix B is:
[[0.01457496 0.91874701]
[0.90071485 0.03342143]]
----------------------------------------
Inner product of A and B is:
[[0.68216536 0.16359028]
[0.49420928 0.25501008]]
----------------------------------------
Outer product of A and B is:
[[0.00224692 0.14163665 0.13885676 0.00515234]
[0.0107862 0.67991844 0.66657375 0.02473352]
[0.00383781 0.24191988 0.23717175 0.00880036]
[0.00777923 0.49037147 0.480747 0.01783833]]import numpy as np
np.random.seed(10)
A = np.random.random((3,1))
B = np.random.random((1,3))
C = np.outer(A,B)
print(C)[[0.57756789 0.38450875 0.17339029]
[0.01553914 0.01034499 0.00466497]
[0.47447826 0.31587809 0.142442 ]]Usually the np.dot() function and @ infix operator does the job of inner and outer product respectively.
We can specify whether we want a row-wise or column-wise operation by specifying an additional attribute axis to all the functions above.
axis=0, you operate across rows (column-wise).axis=1 you operate across columns (row-wise)import numpy as np
import matplotlib.pyplot as plt
# k value
k = 8.99e9
# For arbitrary r0
x0,y0 = 0,0
# Charge values
q1 = -5e-6
q2 = 6e-6
# Charge position
x1,y1 = -1,1
x2,y2 = 2,-3
# Grid
X,Y = np.meshgrid(np.linspace(-10,10,100),np.linspace(-10,10,100))
def electric_field(q, qx, qy, X,Y):
Rx = X - (qx - x0)
Ry = Y - (qy-y0)
R = np.sqrt(Rx**2 + Ry**2)
Ex = k * Rx * q / R**3
Ey = k * Ry * q / R**3
return Ex, Ey
Ex1, Ey1 = electric_field(q1,x1,y1,X,Y)
Ex2, Ey2 = electric_field(q2,x2,y2,X,Y)
Ex = Ex1 + Ex2; Ey = Ey1+Ey2
plt.streamplot(X,Y,Ex,Ey, color=np.sqrt(Ex**2+Ey**2), cmap='summer', density=1)
plt.scatter(x1 - x0, y1-y0,color='red',label=r'$q_{1}$')
plt.scatter(x2 - x0,y2-y0,color='blue',label=r'$q_{2}$')
plt.legend()
plt.xlabel(r'$E_{x}$')
plt.ylabel(r'$E_{y}$')
plt.grid()
plt.show()