a = [1,2,3]
print a
#list
[1, 2, 3]
'yellow' + '_' + 'orange'
'yellow_orange'
b = 2/5
b
0
float(2)/float(5)
0.4
import datetime
tweet = {
'date': datetime.datetime(2014, 4, 1, 23, 14, 20),
'user': 899110,
'text': '<3 OMG BEST FRIENDS ARE THE BEST #bestiesforlife #oclove',
'location' : {
'lat': 27.0,
'lng': 114.9,
'hex': 'Efabe3'
}
}
#dictionary
#datetime
print tweet['text']
<3 OMG BEST FRIENDS ARE THE BEST #bestiesforlife #oclove
some_values = [100,107.7,92]
print sum(some_values)/len(some_values)
99.9
def mean(arg):
return sum(arg) / len(arg)
mean(some_values)
99.89999999999999
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[1, 2], [3, 4], [5,6]])
a*b
array([[ 1, 4, 9], [16, 25, 36]])
help(np.dot)
Help on built-in function dot in module numpy.core._dotblas: dot(...) dot(a, b, out=None) Dot product of two arrays. For 2-D arrays it is equivalent to matrix multiplication, and for 1-D arrays to inner product of vectors (without complex conjugation). For N dimensions it is a sum product over the last axis of `a` and the second-to-last of `b`:: dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) Parameters ---------- a : array_like First argument. b : array_like Second argument. out : ndarray, optional Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for `dot(a,b)`. This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible. Returns ------- output : ndarray Returns the dot product of `a` and `b`. If `a` and `b` are both scalars or both 1-D arrays then a scalar is returned; otherwise an array is returned. If `out` is given, then it is returned. Raises ------ ValueError If the last dimension of `a` is not the same size as the second-to-last dimension of `b`. See Also -------- vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. Examples -------- >>> np.dot(3, 4) 12 Neither argument is complex-conjugated: >>> np.dot([2j, 3j], [2j, 3j]) (-13+0j) For 2-D arrays it's the matrix product: >>> a = [[1, 0], [0, 1]] >>> b = [[4, 1], [2, 2]] >>> np.dot(a, b) array([[4, 1], [2, 2]]) >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) >>> np.dot(a, b)[2,3,2,1,2,2] 499128 >>> sum(a[2,3,2,:] * b[1,2,:,2]) 499128
a.dot(b)
#The number of columns in a must match the number of rows in b for matrix multiplication
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-4-9a1f5761fa9d> in <module>() ----> 1 a.dot(b) ValueError: objects are not aligned
np.dot(a,b)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-5-71281829ef00> in <module>() ----> 1 np.dot(a,b) ValueError: objects are not aligned
a.dot(c)
#The number of columns in a matches the number of rows in c for matrix multiplication
# = [[1*1 + 2*3 + 3*5 = 22, 1*2 + 2*4 + 3*6 = 28],
# [4*1, 5*3, 6*5 = 49, 4*2 + 5*4 + 6*6 = 64]]
array([[22, 28], [49, 64]])
np.dot(a,c)
#yes it's the same because a is the first matrix using either notation
array([[22, 28], [49, 64]])
np.dot(c,a)
#not the same because the result will have the same number of rows as the 1st matrix
#and the same number of columns as the 2nd matrix:
#above we are multiplying a 2x3 with 3x2 = 2x2
#and here is a 3x2 with 2x3 = 3x3
# = [[1*1 + 2*4 = 9, 1*2 + 2*5 = 12, 1*3 + 2*6 + 15],
# [3*1 + 4*4 = 19, 3*2 + 4*5 + 26, 3*3 + 4*6 + 33],
# [5*1 + 6*4 = 29, 5*2 + 6*5 = 40, 5*3 + 6*6 = 51]]
array([[ 9, 12, 15], [19, 26, 33], [29, 40, 51]])