def test_np_info(self):
output = io.StringIO()
with contextlib.closing(output):
np.info(ibm2float32, output=output)
self.assertIn("Examples", output.getvalue())
output = io.StringIO()
with contextlib.closing(output):
np.info(ibm2float64, output=output)
self.assertIn("Examples", output.getvalue())
def debug(self,pts,scales,orientations,scale_maps,heatmaps):
print('orientations:',orientations)
print('scales:',scales)
print('heatmaps info:')
np.info(heatmaps)
print('scalemaps info:')
np.info(scale_maps)
heatmaps_img = img_from_floats(heatmaps)
cv2.imshow('heatmap',heatmaps_img)
scalemaps_img = img_from_floats(scale_maps)
cv2.imshow('scale maps',scalemaps_img)
cv2.waitKey(1)
def test_py3_compat(self):
# gh-2561
# Test if the oldstyle class test is bypassed in python3
class C():
"""Old-style class in python2, normal class in python3"""
pass
out = open(os.devnull, 'w')
try:
np.info(C(), output=out)
except AttributeError:
raise AssertionError()
finally:
out.close()
def test_py3_compat(self):
# gh-2561
# Test if the oldstyle class test is bypassed in python3
class C():
"""Old-style class in python2, normal class in python3"""
pass
out = open(os.devnull, 'w')
try:
np.info(C(), output=out)
except AttributeError:
raise AssertionError()
finally:
out.close()
def reduce_mem_usage(df, verbose=True):
numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
start_mem = df.memory_usage().sum() / 1024**2
for col in df.columns:
col_type = df[col].dtypes
if col_type in numerics:
c_min = df[col].min()
c_max = df[col].max()
if str(col_type)[:3] == 'int':
if c_min > np.info(np.int8).min and c_max < np.iinfo(
np.int8).max:
df[col] = df[col].astype(np.int8)
elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(
np.int16).max:
df[col] = df[col].astype(np.int16)
elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(
np.int32).max:
df[col] = df[col].astype(np.int32)
elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(
np.int64).max:
df[col] = df[col].astype(np.int64)
else:
if c_min > np.finfo(np.float16).min and c_max < np.finfo(
np.float16).max:
df[col] = df[col].astype(np.float16)
elif c_min > np.finfo(np.float32).min and c_max < np.finfo(
np.float32).max:
df[col] = df[col].astype(np.float32)
else:
df[col] = df[col].astype(np.float64)
end_mem = df.memory_usage().sum() / 1024**2
if verbose:
print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(
end_mem, 100 * (start_mem - end_mem) / start_mem))
return df
def demo_numpy_describe():
with LogicalFile.LogicalIndex(path_in) as logical_index:
for logical_file in logical_index.logical_files:
if logical_file.has_log_pass:
for frame_array in logical_file.log_pass:
print(frame_array)
frame_count = logical_file.populate_frame_array(
frame_array)
print(
f'Loaded {frame_count} frames and {len(frame_array)} channels'
f' from {frame_array.ident} using {frame_array.sizeof_array} bytes.'
)
for channel in frame_array.channels:
print(channel)
# channel.array is a numpy array
np.info(channel.array)
print()
def demo_numpy_describe_test_data():
fobj = io.BytesIO(test_data.BASIC_FILE)
with LogicalFile.LogicalIndex(fobj) as logical_index:
for logical_file in logical_index.logical_files:
if logical_file.has_log_pass:
for frame_array in logical_file.log_pass:
print(frame_array)
frame_count = logical_file.populate_frame_array(
frame_array)
print(
f'Loaded {frame_count} frames and {len(frame_array)} channels'
f' from {frame_array.ident} using {frame_array.sizeof_array} bytes.'
)
for channel in frame_array.channels:
print(f'Channel: {channel}')
# channel.array is a numpy array
np.info(channel.array)
print()
def np_info(a: np.ndarray) -> str:
"""Emulates np.info() but as a sting rather than to stdout.
Example::
class: ndarray
shape: (1024, 4096)
strides: (32768, 8)
itemsize: 8
aligned: True
contiguous: True
fortran: False
data pointer: 0x10dd6b000
byteorder: little
byteswap: False
type: float64
"""
with io.StringIO() as file:
np.info(a, output=file)
return file.getvalue().rstrip()
def analyse(self, picture_url, picture_mediaID, picture_msgID,
picture_createtime):
parameters_pic_raw = {
"requests": [{
"image": {
"source": {
"imageUri": '%s' % picture_url
}
},
"features": [{
"type": "FACE_DETECTION",
"maxResults": "10"
}, {
"type": "LABEL_DETECTION",
"maxResults": "10"
}, {
"type": "TEXT_DETECTION",
"maxResults": "10"
}, {
"type": "LANDMARK_DETECTION",
"maxResults": "10"
}, {
"type": "WEB_DETECTION",
"maxResults": "10"
}]
}]
}
output_filename = 'vision_parameters.json' #%picture_mediaID
with open(output_filename, 'w') as output_file:
json.dump(parameters_pic_raw, output_file, indent=4)
print('Pmid: ' + picture_msgID)
print('Pct: ' + picture_createtime)
print(output_filename)
print(parameters_pic_raw)
parameters_pic = open(output_filename, 'rb').read()
#print ('parameters_pic: ' + parameters_pic)
print('google key: ' + self.key)
print('google url: ' + self.url)
response_pic = requests.post(url=self.url + '?key=' + self.key,
data=parameters_pic)
print('response_pic_info: ' + str(np.info(response_pic)))
vision_results = response_pic.json()
print('vision_results: ' + str(vision_results))
return vision_results
integralPrimeira = np.polyint(f3grau)
integralSegunda = np.polyint(f3grau, 2)
integralTerceira = np.polyint(f3grau, 3)
#Tratamento de sinais - convolucao
#%%
sinalConvoluido = np.convolve([1, 2, 3], [0, 1, 0.5])
plt.hist(sinalConvoluido, bins=3, density=100) #altere os bins
plt.show()
#Pesquisa
print(np.info(np.polyval))
print(np.lookfor('binary representation'))
print(np.source(np.interp))#funcao Valida apenas para objetos escritos em python
'''Scipy
É uma biblioteca de computação científica, que junto ao Numpy é capaz
de realizar operações poderosas, tanto para o processamento de dados
quanto para a prototipagem de sistemas.'''
#%%
import scipy as sp
print(np.tan(a*np.pi/180))
print(np.tan(a*np.pi/180))
a=np.arange(9,dtype=np.float).reshape(3,3)
print(np.ptp(a,axis=1))
print(np.average((1,2,3,4)))
print(numpy.matlib.zeros((2,2)))
a=np.array([[1,2],[3,4]])
print(np.dot(a,b))
np.save('outfile.npy',a)
print(np.__version__)
np.show_config()
Z=np.zeros(10)
print(Z)
Z=np.zeros((10,10))
print(Z.size * Z.itemsize)
np.info(np.add)
Z=np.zeros(10)
Z[4]=1
print(Z)
Z=np.arange(10,50)
print(Z)
Z=np.arange(50)
z=Z[::-1]
print(z)
Z=np.arange(9).reshape(3,3)
print(Z)
nz=np.nonzero([1,2,0,0,4,0])
print(nz)
Z=np.eye(3)
print(z)
Z=np.random.random((3,3,3))
import scipy as sp from scipy import integrate from scipy import cluster from scipy import fftpack import numpy as np #Help/doc help(integrate) np.info(fftpack) #Source code of subpackages np.source(cluster)
np.histogram_bin_edges np.histogram2d np.histogramdd np.hsplit np.hstack np.hypot np.i0 np.identity np.iinfo np.imag np.in1d np.index_exp np.indices np.inexact np.inf | Inf | Infinity | PINF | infty np.info(object=None|'', maxwidth=76, output=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>, toplevel='numpy') np.inner np.insert(arr=∂, obj=0|[0,..], values=∂, axis=None|0) np.int np.int_ np.int0 np.int16 np.int32 np.int64 np.int8 np.intc np.integer np.interp np.intersect1d np.intp np.invert
def backgroundSubtractionWeaver(img, bgStack, test=False):
"""
background subtraction using C++ code works on non-fortran style
background stacks, is less efficient than
backgroundSubtractionWeaverF
Args:
img (nd array):
input image
bgStack (background image stack):
- for computation see :func:`calculateBackgroundStack`
- *needs to generated with fortranStyle=False*
Returns:
difference image
.. seealso::
:func:`backgroundSubstractionStack`
:func:`backgroundSubstractionWeaver`
:func:`backgroundSubstractionWeaverF`
"""
im0 = img[:, :, 0].flatten()
im1 = img[:, :, 1].flatten()
im2 = img[:, :, 2].flatten()
bg0 = bgStack[0]
bg1 = bgStack[1]
bg2 = bgStack[2]
# (very wide string)
subtractionCode = \
"""
// subtraction on all color layers
short val = 0;
for (int i = 0; i < bgn; ++i){
for (int k = 0; k < bgx; k += 16){
diff[k] = ((im0[k] - bg0[k + i * imLen]) + (im1[k] - bg1[k + i * imLen]) + (im2[k] - bg2[k + i * imLen]) > diff[k]) ? (im0[k] - bg0[k + i * imLen]) + (im1[k] - bg1[k + i * imLen]) + (im2[k] - bg2[k + i * imLen]) : diff[k];
diff[k + 1] = ((im0[k + 1] - bg0[k + 1 + i * imLen]) + (im1[k + 1] - bg1[k + 1 + i * imLen]) + (im2[k + 1] - bg2[k + 1 + i * imLen]) > diff[k + 1]) ? (im0[k + 1] - bg0[k + 1 + i * imLen]) + (im1[k + 1] - bg1[k + 1 + i * imLen]) + (im2[k + 1] - bg2[k + 1 + i * imLen]) : diff[k + 1];
diff[k +2] = ((im0[k +2] - bg0[k +2 + i * imLen]) + (im1[k +2] - bg1[k +2 + i * imLen]) + (im2[k +2] - bg2[k +2 + i * imLen]) > diff[k +2]) ? (im0[k +2] - bg0[k +2 + i * imLen]) + (im1[k +2] - bg1[k +2 + i * imLen]) + (im2[k +2] - bg2[k +2 + i * imLen]) : diff[k +2];
diff[k + 3] = ((im0[k + 3] - bg0[k + 3 + i * imLen]) + (im1[k + 3] - bg1[k + 3 + i * imLen]) + (im2[k + 3] - bg2[k + 3 + i * imLen]) > diff[k + 3]) ? (im0[k + 3] - bg0[k + 3 + i * imLen]) + (im1[k + 3] - bg1[k + 3 + i * imLen]) + (im2[k + 3] - bg2[k + 3 + i * imLen]) : diff[k + 3];
diff[k + 4] = ((im0[k + 4] - bg0[k + 4 + i * imLen]) + (im1[k + 4] - bg1[k + 4 + i * imLen]) + (im2[k + 4] - bg2[k + 4 + i * imLen]) > diff[k + 4]) ? (im0[k + 4] - bg0[k + 4 + i * imLen]) + (im1[k + 4] - bg1[k + 4 + i * imLen]) + (im2[k + 4] - bg2[k + 4 + i * imLen]) : diff[k + 4];
diff[k + 5] = ((im0[k + 5] - bg0[k + 5 + i * imLen]) + (im1[k + 5] - bg1[k + 5 + i * imLen]) + (im2[k + 5] - bg2[k + 5 + i * imLen]) > diff[k + 5]) ? (im0[k + 5] - bg0[k + 5 + i * imLen]) + (im1[k + 5] - bg1[k + 5 + i * imLen]) + (im2[k + 5] - bg2[k + 5 + i * imLen]) : diff[k + 5];
diff[k + 6] = ((im0[k + 6] - bg0[k + 6 + i * imLen]) + (im1[k + 6] - bg1[k + 6 + i * imLen]) + (im2[k + 6] - bg2[k + 6 + i * imLen]) > diff[k + 6]) ? (im0[k + 6] - bg0[k + 6 + i * imLen]) + (im1[k + 6] - bg1[k + 6 + i * imLen]) + (im2[k + 6] - bg2[k + 6 + i * imLen]) : diff[k + 6];
diff[k + 7] = ((im0[k + 7] - bg0[k + 7 + i * imLen]) + (im1[k + 7] - bg1[k + 7 + i * imLen]) + (im2[k + 7] - bg2[k + 7 + i * imLen]) > diff[k + 7]) ? (im0[k + 7] - bg0[k + 7 + i * imLen]) + (im1[k + 7] - bg1[k + 7 + i * imLen]) + (im2[k + 7] - bg2[k + 7 + i * imLen]) : diff[k + 7];
diff[k + 8] = ((im0[k + 8] - bg0[k + 8 + i * imLen]) + (im1[k + 8] - bg1[k + 8 + i * imLen]) + (im2[k + 8] - bg2[k + 8 + i * imLen]) > diff[k + 8]) ? (im0[k + 8] - bg0[k + 8 + i * imLen]) + (im1[k + 8] - bg1[k + 8 + i * imLen]) + (im2[k + 8] - bg2[k + 8 + i * imLen]) : diff[k + 8];
diff[k + 9] = ((im0[k + 9] - bg0[k + 9 + i * imLen]) + (im1[k + 9] - bg1[k + 9 + i * imLen]) + (im2[k + 9] - bg2[k + 9 + i * imLen]) > diff[k + 9]) ? (im0[k + 9] - bg0[k + 9 + i * imLen]) + (im1[k + 9] - bg1[k + 9 + i * imLen]) + (im2[k + 9] - bg2[k + 9 + i * imLen]) : diff[k + 9];
diff[k + 10] = ((im0[k + 10] - bg0[k + 10 + i * imLen]) + (im1[k + 10] - bg1[k + 10 + i * imLen]) + (im2[k + 10] - bg2[k + 10 + i * imLen]) > diff[k + 10]) ? (im0[k + 10] - bg0[k + 10 + i * imLen]) + (im1[k + 10] - bg1[k + 10 + i * imLen]) + (im2[k + 10] - bg2[k + 10 + i * imLen]) : diff[k + 10];
diff[k + 11] = ((im0[k + 11] - bg0[k + 11 + i * imLen]) + (im1[k + 11] - bg1[k + 11 + i * imLen]) + (im2[k + 11] - bg2[k + 11 + i * imLen]) > diff[k + 11]) ? (im0[k + 11] - bg0[k + 11 + i * imLen]) + (im1[k + 11] - bg1[k + 11 + i * imLen]) + (im2[k + 11] - bg2[k + 11 + i * imLen]) : diff[k + 11];
diff[k + 12] = ((im0[k + 12] - bg0[k + 12 + i * imLen]) + (im1[k + 12] - bg1[k + 12 + i * imLen]) + (im2[k + 12] - bg2[k + 12 + i * imLen]) > diff[k + 12]) ? (im0[k + 12] - bg0[k + 12 + i * imLen]) + (im1[k + 12] - bg1[k + 12 + i * imLen]) + (im2[k + 12] - bg2[k + 12 + i * imLen]) : diff[k + 12];
diff[k + 13] = ((im0[k + 13] - bg0[k + 13 + i * imLen]) + (im1[k + 13] - bg1[k + 13 + i * imLen]) + (im2[k + 13] - bg2[k + 13 + i * imLen]) > diff[k + 13]) ? (im0[k + 13] - bg0[k + 13 + i * imLen]) + (im1[k + 13] - bg1[k + 13 + i * imLen]) + (im2[k + 13] - bg2[k + 13 + i * imLen]) : diff[k + 13];
diff[k + 14] = ((im0[k + 14] - bg0[k + 14 + i * imLen]) + (im1[k + 14] - bg1[k + 14 + i * imLen]) + (im2[k + 14] - bg2[k + 14 + i * imLen]) > diff[k + 14]) ? (im0[k + 14] - bg0[k + 14 + i * imLen]) + (im1[k + 14] - bg1[k + 14 + i * imLen]) + (im2[k + 14] - bg2[k + 14 + i * imLen]) : diff[k + 14];
diff[k + 15] = ((im0[k + 15] - bg0[k + 15 + i * imLen]) + (im1[k + 15] - bg1[k + 15 + i * imLen]) + (im2[k + 15] - bg2[k + 15 + i * imLen]) > diff[k + 15]) ? (im0[k + 15] - bg0[k + 15 + i * imLen]) + (im1[k + 15] - bg1[k + 15 + i * imLen]) + (im2[k + 15] - bg2[k + 15 + i * imLen]) : diff[k + 15];
}
}
"""
diff = np.ones((img.shape[0], img.shape[1]), dtype=bgStack[0].dtype) * \
np.info(bgStack[0].dtype).min
imLen = img.shape[0] * img.shape[1]
bgn = bg0.shape[0]
bgx = bg1.shape[1]
# weave.inline(subtractionCode,
# ['diff', 'bg0', 'bg1', 'bg2', 'im0',
# 'im1', 'im2', 'imLen', 'bgn', 'bgx'],
# extra_compile_args=['-march=corei7',
# '-O3', '-fopenmp'],
# headers=['<omp.h>'],
# extra_link_args=['-lgomp'],
# compiler='gcc')
weave.inline(subtractionCode, [
'diff', 'bg0', 'bg1', 'bg2', 'im0', 'im1', 'im2', 'imLen', 'bgn',
'bgx'
],
extra_compile_args=['-O3'],
compiler='gcc')
if test:
print 'Difference: ', np.sum(
np.abs(self.backgroundSubstractionStack(img, bgStack) -
diff).flatten())
return diff
gpas_as_list.append(4.0)
#can have multiple datatypes in it.
gpas_as_list.insert(1, "whatevs")
gpas_as_list.pop(1)
gpas_as_list
gpas = np.array(gpas_as_list)
study_minutes = np.zeros(100, np.uint16)
study_minutes
#%whos
study_minutes[0] = 150
first_day_minutes = study_minutes[0]
study_minutes[1] = 60
study_minutes[2:6] = [80, 60, 30, 90]
print("{}".format(study_minutes))
students_gpas = np.array(
[[4.0, 3.286, 3.5, 4.0], [3.2, 3.8, 4.0, 4.0], [3.96, 3.92, 4.0, 3.6]],
np.float16)
print("{}", format(students_gpas))
students_gpas.ndim
students_gpas.shape
students_gpas.size
print("{}".format(np.info(students_gpas)))
print("{}".format(students_gpas[1][2]))
print(('time for convert:\t%2.3f' % (t2-t1)))
if args.dump:
for x in data:
val = convert(x)
off = val - base
print(('off = %d (0x%06x)' % (off, val)))
# Display just the status flags, if results aren't wanted.
if args.noresults:
print("\nStatus flags:")
tart.read_status(True)
# Or else display the acquistion-unit's test-results.
else:
# Check the returned data.
print('generate 24bit integer')
resp_dec = (np.array(data[:,0],dtype='uint32')<<16) + (np.array(data[:,1], dtype='uint32')<<8) + (np.array(data[:,2],dtype='uint32'))
print((np.info(resp_dec)))
print('done')
print(('first 10: ', resp_dec[:10]))
print(('last 10: ', resp_dec[-10:]))
diffs = (resp_dec[1:]-resp_dec[:-1])
diffssum = diffs.__ne__(1).sum()
print(diffs)
print(('yo,', resp_dec[diffs.__ne__(1)]))
print(('sum_of_errors: ', diffssum))
index = np.arange(len(diffs))
print((diffs[diffs.__ne__(1)]))
print((index[diffs.__ne__(1)]))
np.int64
np.float32
np.complex
np.bool
np.object
np.string_
np.unicode_
#inspecting your array
b.shape
len(b)
b.ndim
b.dtype
b.dtype.name
b.astype(int)
#asking for help
np.info(np.ndarray.dtype)
#Arithmetic operations
a =np.array([(2,4,6),(8,10,12)])
b = np.array([(1,3,5),(7,9,11)])
a+b
c = np.add(a,b)
print('result of addition ',c)
d = np.subtract(a,b)
print('result of subtraction ',d)
e=np.multiply(a,b)
print('result of multiplication ',e)
x = np.array([(10,4,12),(13,4,1)])
print(x)
y = x.sort()
from io import StringIO
from typing import Any, Dict
import numpy as np
AR: np.ndarray[Any, np.dtype[np.float64]]
AR_DICT: Dict[str, np.ndarray[Any, np.dtype[np.float64]]]
FILE: StringIO
def func(a: int) -> bool: ...
reveal_type(np.deprecate(func)) # E: def (a: builtins.int) -> builtins.bool
reveal_type(np.deprecate()) # E: _Deprecate
reveal_type(np.deprecate_with_doc("test")) # E: _Deprecate
reveal_type(np.deprecate_with_doc(None)) # E: _Deprecate
reveal_type(np.byte_bounds(AR)) # E: Tuple[builtins.int, builtins.int]
reveal_type(np.byte_bounds(np.float64())) # E: Tuple[builtins.int, builtins.int]
reveal_type(np.who(None)) # E: None
reveal_type(np.who(AR_DICT)) # E: None
reveal_type(np.info(1, output=FILE)) # E: None
reveal_type(np.source(np.interp, output=FILE)) # E: None
reveal_type(np.lookfor("binary representation", output=FILE)) # E: None
reveal_type(np.safe_eval("1 + 1")) # E: Any
def backgroundSubtractionWeaver(img, bgStack, test=False):
"""
background subtraction using C++ code works on non-fortran style
background stacks, is less efficient than
backgroundSubtractionWeaverF
Args:
img (nd array):
input image
bgStack (background image stack):
- for computation see :func:`calculateBackgroundStack`
- *needs to generated with fortranStyle=False*
Returns:
difference image
.. seealso::
:func:`backgroundSubstractionStack`
:func:`backgroundSubstractionWeaver`
:func:`backgroundSubstractionWeaverF`
"""
im0 = img[:,:,0].flatten()
im1 = img[:,:,1].flatten()
im2 = img[:,:,2].flatten()
bg0 = bgStack[0]
bg1 = bgStack[1]
bg2 = bgStack[2]
# (very wide string)
subtractionCode = \
"""
// subtraction on all color layers
short val = 0;
for (int i = 0; i < bgn; ++i){
for (int k = 0; k < bgx; k += 16){
diff[k] = ((im0[k] - bg0[k + i * imLen]) + (im1[k] - bg1[k + i * imLen]) + (im2[k] - bg2[k + i * imLen]) > diff[k]) ? (im0[k] - bg0[k + i * imLen]) + (im1[k] - bg1[k + i * imLen]) + (im2[k] - bg2[k + i * imLen]) : diff[k];
diff[k + 1] = ((im0[k + 1] - bg0[k + 1 + i * imLen]) + (im1[k + 1] - bg1[k + 1 + i * imLen]) + (im2[k + 1] - bg2[k + 1 + i * imLen]) > diff[k + 1]) ? (im0[k + 1] - bg0[k + 1 + i * imLen]) + (im1[k + 1] - bg1[k + 1 + i * imLen]) + (im2[k + 1] - bg2[k + 1 + i * imLen]) : diff[k + 1];
diff[k +2] = ((im0[k +2] - bg0[k +2 + i * imLen]) + (im1[k +2] - bg1[k +2 + i * imLen]) + (im2[k +2] - bg2[k +2 + i * imLen]) > diff[k +2]) ? (im0[k +2] - bg0[k +2 + i * imLen]) + (im1[k +2] - bg1[k +2 + i * imLen]) + (im2[k +2] - bg2[k +2 + i * imLen]) : diff[k +2];
diff[k + 3] = ((im0[k + 3] - bg0[k + 3 + i * imLen]) + (im1[k + 3] - bg1[k + 3 + i * imLen]) + (im2[k + 3] - bg2[k + 3 + i * imLen]) > diff[k + 3]) ? (im0[k + 3] - bg0[k + 3 + i * imLen]) + (im1[k + 3] - bg1[k + 3 + i * imLen]) + (im2[k + 3] - bg2[k + 3 + i * imLen]) : diff[k + 3];
diff[k + 4] = ((im0[k + 4] - bg0[k + 4 + i * imLen]) + (im1[k + 4] - bg1[k + 4 + i * imLen]) + (im2[k + 4] - bg2[k + 4 + i * imLen]) > diff[k + 4]) ? (im0[k + 4] - bg0[k + 4 + i * imLen]) + (im1[k + 4] - bg1[k + 4 + i * imLen]) + (im2[k + 4] - bg2[k + 4 + i * imLen]) : diff[k + 4];
diff[k + 5] = ((im0[k + 5] - bg0[k + 5 + i * imLen]) + (im1[k + 5] - bg1[k + 5 + i * imLen]) + (im2[k + 5] - bg2[k + 5 + i * imLen]) > diff[k + 5]) ? (im0[k + 5] - bg0[k + 5 + i * imLen]) + (im1[k + 5] - bg1[k + 5 + i * imLen]) + (im2[k + 5] - bg2[k + 5 + i * imLen]) : diff[k + 5];
diff[k + 6] = ((im0[k + 6] - bg0[k + 6 + i * imLen]) + (im1[k + 6] - bg1[k + 6 + i * imLen]) + (im2[k + 6] - bg2[k + 6 + i * imLen]) > diff[k + 6]) ? (im0[k + 6] - bg0[k + 6 + i * imLen]) + (im1[k + 6] - bg1[k + 6 + i * imLen]) + (im2[k + 6] - bg2[k + 6 + i * imLen]) : diff[k + 6];
diff[k + 7] = ((im0[k + 7] - bg0[k + 7 + i * imLen]) + (im1[k + 7] - bg1[k + 7 + i * imLen]) + (im2[k + 7] - bg2[k + 7 + i * imLen]) > diff[k + 7]) ? (im0[k + 7] - bg0[k + 7 + i * imLen]) + (im1[k + 7] - bg1[k + 7 + i * imLen]) + (im2[k + 7] - bg2[k + 7 + i * imLen]) : diff[k + 7];
diff[k + 8] = ((im0[k + 8] - bg0[k + 8 + i * imLen]) + (im1[k + 8] - bg1[k + 8 + i * imLen]) + (im2[k + 8] - bg2[k + 8 + i * imLen]) > diff[k + 8]) ? (im0[k + 8] - bg0[k + 8 + i * imLen]) + (im1[k + 8] - bg1[k + 8 + i * imLen]) + (im2[k + 8] - bg2[k + 8 + i * imLen]) : diff[k + 8];
diff[k + 9] = ((im0[k + 9] - bg0[k + 9 + i * imLen]) + (im1[k + 9] - bg1[k + 9 + i * imLen]) + (im2[k + 9] - bg2[k + 9 + i * imLen]) > diff[k + 9]) ? (im0[k + 9] - bg0[k + 9 + i * imLen]) + (im1[k + 9] - bg1[k + 9 + i * imLen]) + (im2[k + 9] - bg2[k + 9 + i * imLen]) : diff[k + 9];
diff[k + 10] = ((im0[k + 10] - bg0[k + 10 + i * imLen]) + (im1[k + 10] - bg1[k + 10 + i * imLen]) + (im2[k + 10] - bg2[k + 10 + i * imLen]) > diff[k + 10]) ? (im0[k + 10] - bg0[k + 10 + i * imLen]) + (im1[k + 10] - bg1[k + 10 + i * imLen]) + (im2[k + 10] - bg2[k + 10 + i * imLen]) : diff[k + 10];
diff[k + 11] = ((im0[k + 11] - bg0[k + 11 + i * imLen]) + (im1[k + 11] - bg1[k + 11 + i * imLen]) + (im2[k + 11] - bg2[k + 11 + i * imLen]) > diff[k + 11]) ? (im0[k + 11] - bg0[k + 11 + i * imLen]) + (im1[k + 11] - bg1[k + 11 + i * imLen]) + (im2[k + 11] - bg2[k + 11 + i * imLen]) : diff[k + 11];
diff[k + 12] = ((im0[k + 12] - bg0[k + 12 + i * imLen]) + (im1[k + 12] - bg1[k + 12 + i * imLen]) + (im2[k + 12] - bg2[k + 12 + i * imLen]) > diff[k + 12]) ? (im0[k + 12] - bg0[k + 12 + i * imLen]) + (im1[k + 12] - bg1[k + 12 + i * imLen]) + (im2[k + 12] - bg2[k + 12 + i * imLen]) : diff[k + 12];
diff[k + 13] = ((im0[k + 13] - bg0[k + 13 + i * imLen]) + (im1[k + 13] - bg1[k + 13 + i * imLen]) + (im2[k + 13] - bg2[k + 13 + i * imLen]) > diff[k + 13]) ? (im0[k + 13] - bg0[k + 13 + i * imLen]) + (im1[k + 13] - bg1[k + 13 + i * imLen]) + (im2[k + 13] - bg2[k + 13 + i * imLen]) : diff[k + 13];
diff[k + 14] = ((im0[k + 14] - bg0[k + 14 + i * imLen]) + (im1[k + 14] - bg1[k + 14 + i * imLen]) + (im2[k + 14] - bg2[k + 14 + i * imLen]) > diff[k + 14]) ? (im0[k + 14] - bg0[k + 14 + i * imLen]) + (im1[k + 14] - bg1[k + 14 + i * imLen]) + (im2[k + 14] - bg2[k + 14 + i * imLen]) : diff[k + 14];
diff[k + 15] = ((im0[k + 15] - bg0[k + 15 + i * imLen]) + (im1[k + 15] - bg1[k + 15 + i * imLen]) + (im2[k + 15] - bg2[k + 15 + i * imLen]) > diff[k + 15]) ? (im0[k + 15] - bg0[k + 15 + i * imLen]) + (im1[k + 15] - bg1[k + 15 + i * imLen]) + (im2[k + 15] - bg2[k + 15 + i * imLen]) : diff[k + 15];
}
}
"""
diff = np.ones((img.shape[0], img.shape[1]), dtype=bgStack[0].dtype) * \
np.info(bgStack[0].dtype).min
imLen = img.shape[0] * img.shape[1]
bgn = bg0.shape[0]
bgx = bg1.shape[1]
# weave.inline(subtractionCode,
# ['diff', 'bg0', 'bg1', 'bg2', 'im0',
# 'im1', 'im2', 'imLen', 'bgn', 'bgx'],
# extra_compile_args=['-march=corei7',
# '-O3', '-fopenmp'],
# headers=['<omp.h>'],
# extra_link_args=['-lgomp'],
# compiler='gcc')
weave.inline(subtractionCode,
['diff', 'bg0', 'bg1', 'bg2', 'im0',
'im1', 'im2', 'imLen', 'bgn', 'bgx'],
extra_compile_args=['-O3'],
compiler='gcc')
if test:
print 'Difference: ', np.sum(np.abs(self.backgroundSubstractionStack(img,bgStack) - diff).flatten())
return diff
matrix.dot(matrix2) #Скалярное произведение.
""" Axis """
# axis 0 - ось строк (направление)
# axis 1 - ось столбцов (направление)
np.hstack((arr3, arr7)) #Соединение массивов как строки
np.vstack((arr3, arr9)) #Соединение массивов как столбцы
matrix4 = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)])
matrix4 = matrix4.T # Транспонирование - стобцы и строки меняются местами
matrix4.flatten() # "Сжатие" в 1D массив
np.linalg.inv(matrix4) # Обратная матрица
np.linalg.det(matrix4) # Определитель
np.linalg.matrix_rank(matrix4) # Ранк матрицы
np.linalg.eig(matrix4) # Находит собственные числа и векторы матрицы
""" Доп.функции """
np.info(np.eye) # Справка. Как работает та или иная функция
np.loadtxt('')
np.genfromtxt()
np.savetxt('.txt')
np.savetxt('.csv')
# How to get the documentation of the numpy add function from the command line ? (★☆☆) import numpy as np np.info(np.add)
print("Convert the array into different type: ", my_array.astype(int))
# TRANSPOSING ARRAY
# Transpose `x`
print("Array using transpose : \n", np.transpose(x))
# Or use `T` to transpose `my_2d_array`
print("Array using .T option to transpose :\n ", x.T)
# Use lookfor() to do a keyword search on docstrings.
# Look up info on `mean` with `np.lookfor()`
print(np.lookfor("mean"))
# Get info on data types with `np.info()`
print(np.info(np.x.dtype))
# Initialize your array
my_3d_array = np.array(
[[[1, 2, 3, 4], [5, 6, 7, 8]], [[1, 2, 3, 4], [9, 10, 11, 12]]],
dtype=np.int64)
# Pass the array to `np.histogram()`
# histogram computes the occurrences of the array that fall within each
# bin which determines the area that each bar of your histogram takes up
print(np.histogram(my_3d_array))
# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0, 13)))
e = np.full((2, 2), 7)
e
f = np.eye(2)
f
np.eye(3, 4)
np.random.random((2, 2))
np.empty((3, 2)) #!!!!! ?????
z = np.empty((3, 2)) #!!!!! ?????
z
np.empty((8, 9)) # WHAT THE HELL IT IS ????
#%%
np.info(np.ndarray) # ???
#%%
#%% SAVING AND LOADING
#%% BINARY
#%%
np.save('arr1', a)
# ls
del(a)
np.load('arr1.npy')
a
a = np.load('arr1.npy')
a
def wx_proc_msg(self, body):
try:
wechat.parse_data(body)
except ParseError:
print('[ERROR] Parse message failed.')
return
id = wechat.message.id # MsgId
target = wechat.message.target # ToUserName
source = wechat.message.source # FromUserName
time = wechat.message.time # CreateTime
type = wechat.message.type # MsgType
raw = wechat.message.raw # raw text
if isinstance(wechat.message, TextMessage):
content = wechat.message.content
if len(content.replace(' ', '')) == 0:
return wechat.response_none()
reply = auto_reply.reply(content)
if reply is not None:
return wechat.response_text(content=reply)
else:
return wechat.response_none()
# if isinstance(wechat.message, ImageMessage):
# picurl = wechat.message.picurl # PicUrl
# media_id = wechat.message.media_id # MediaId
# msg_id = wechat.message.msg_id # MsgId
# create_time = wechat.message.create_time # CreateTime
## wechat.response_text(content=u'%s'%picurl)
# return wechat.response_text(content=u'尝试做下图片分析~')
if isinstance(wechat.message, ImageMessage):
picurl = wechat.message.picurl # PicUrl
media_id = wechat.message.media_id # MediaId
msg_id = wechat.message.msg_id # MsgId
create_time = wechat.message.create_time # CreateTime
# wechat.response_text(content=u'%s'%picurl)
# wechat.response_text(content=u'尝试做下图片分析~')
vision_results = google_vision_analysis.analyse(
picture_url=picurl,
picture_mediaID=media_id,
picture_msgID=msg_id,
picture_createtime=create_time)
print('vis_results_info: ' + str(np.info(vision_results)))
if vision_results is not None:
vision_results_text = 'text: '
vision_results_label = 'label: '
vision_results_simurl = 'weburl: '
vision_results_face = 'face: '
vision_results_landmark = 'landmark: '
try:
vision_results_text = (
'Albert Mozart：\n 图片文字：' + vision_results['responses']
[0]['textAnnotations'][0]['description'])
print(vision_results_text)
# wechat.response_text(content=vision_results_text)
except:
pass
try:
vision_results_label = ('Albert Mozart：\n 图片内容分析：' + str([
vision_results['responses'][0]['labelAnnotations']
[index]['description'] for index in range(
len(vision_results['responses'][0]
['labelAnnotations']))
])[1:-1])
print(vision_results_label)
#vision_results_label = ('Albert Mozart：\n 图片内容分析：' + str([(vision_results['responses'][0]['labelAnnotations'][index]['description'], vision_results['responses'][0]['labelAnnotations'][index]['description']) for index in range(len(vision_results['responses'][0]['labelAnnotations']))])[1:-1])
except:
pass
try:
vision_results_simurl = ('Albert Mozart：\n 联想图片：' + str(
vision_results['responses'][0]['webDetection']
['bestGuessLabels'][0]['label']) + ', ' + str([
vision_results['responses'][0]['webDetection']
['visuallySimilarImages'][ind]['url']
for ind in range(
len(vision_results['responses'][0]
['webDetection']['visuallySimilarImages']))
])[1:-1])
print(vision_results_simurl)
except:
pass
try:
vision_results_face_raw = vision_results['responses'][0][
'faceAnnotations'][0]
vision_results_face = dict(vision_results_face_raw)
del vision_results_face['landmarks']
del vision_results_face['boundingPoly']
del vision_results_face['fdBoundingPoly']
vision_results_face = ('Albert Mozart：\n 人脸分析：' +
str(vision_results_face)[1:-1])
print(vision_results_face)
except:
pass
try:
vision_results_landmark = ('Albert Mozart：\n 地标分析：' + str(
[(vision_results['responses'][0]['landmarkAnnotations']
[index]['description'], vision_results['responses']
[0]['landmarkAnnotations'][index]['locations'])
for index in range(
len(vision_results['responses'][0]
['landmarkAnnotations']))])[1:-1])
print(vision_results_landmark)
except:
pass
return wechat.response_text(
content=(vision_results_text + '\n' +
vision_results_label + '\n\n' +
vision_results_simurl + '\n\n' +
vision_results_face + '\n\n' +
vision_results_landmark + '\n\n')
) #, wechat.response_text(content=vision_results_label), wechat.response_text(content=vision_results_simurl), wechat.response_text(content=vistion_results_face), wechat.response_text(content=vision_results_landmark)
# except:
# return wechat.response_text(content=u'突然有事儿，下次吧...')
else:
return wechat.response_text(content=u'这次不大行了，下次吧...')
if isinstance(wechat.message, VoiceMessage):
media_id = wechat.message.media_id # MediaId
format = wechat.message.format # Format
recognition = wechat.message.recognition # Recognition
if isinstance(wechat.message, VideoMessage) or isinstance(
wechat.message, ShortVideoMessage):
media_id = wechat.message.media_id # MediaId
thumb_media_id = wechat.message.thumb_media_id # ThumbMediaId
if isinstance(wechat.message, LocationMessage):
location = wechat.message.location # Tuple(X, Y)，(Location_X, Location_Y)
scale = wechat.message.scale # Scale
label = wechat.message.label # Label
if isinstance(wechat.message, LinkMessage):
title = wechat.message.title # Title
description = wechat.message.description # Description
url = wechat.message.url # Url
if isinstance(wechat.message, EventMessage):
if wechat.message.type == 'subscribe': # subscribe
key = wechat.message.key # EventKey
ticket = wechat.message.ticket # Ticket
mongo.upsert_user(source)
return wechat.response_text(content=u'''欢迎关注''')
elif wechat.message.type == 'unsubscribe': # unsubscribe
mongo.delete_user(source)
return None
elif wechat.message.type == 'scan': # scan
key = wechat.message.key # EventKey
ticket = wechat.message.ticket # Ticket
elif wechat.message.type == 'location': # location
latitude = wechat.message.latitude # Latitude
longitude = wechat.message.longitude # Longitude
precision = wechat.message.precision # Precision
elif wechat.message.type == 'click': # menu click
key = wechat.message.key # EventKey
if key == 'HOST_ADD':
host_count = mongo.host_count(source)
if host_count >= max_host_count:
return wechat.response_text(
content=u'添加主机失败，已达到最大主机数目')
host_id = mongo.insert_host(source)
return wechat.response_text(content=u'添加主机成功，主机ID：' +
host_id)
elif key == 'HOST_DELETE':
hosts = mongo.query_hosts(source)
if hosts is None or len(hosts) == 0:
return wechat.response_text(content=u'您还尚未添加任何主机')
resp = u'选择需要删除的主机:\n'
for i in range(len(hosts)):
resp += u'''<a href="http://lwons.com/fw/host_delete?id=%s">%s</a>\n''' % (
hosts[i]['id'], hosts[i]['id'])
return wechat.response_text(content=resp)
elif key == 'HOST_STATUS':
return wechat.response_text(
content=
u'''<a href="http://lwons.com/fw/host_status?id=%s">点击查看主机状态</a>'''
% source)
elif key == 'HOST_COMMAND':
return wechat.response_text(
content=
u'''<a href="http://lwons.com/fw/host_cmmd?id=%s">进入命令页</a>'''
% source)
elif key == 'MINE_PROFILE':
return wechat.response_text(content=u'个人信息')
elif key == 'MINE_HOSTS':
hosts = mongo.query_hosts(source)
if hosts is None or len(hosts) == 0:
return wechat.response_text(content=u'您还尚未添加任何主机')
resp = u'您的所有主机：\n'
for i in range(len(hosts)):
resp += u'%s %s\n' % (hosts[i]['id'],
hosts[i]['time'])
return wechat.response_text(content=resp)
elif wechat.message.type == 'view': # menu link view
key = wechat.message.key # EventKey
return wechat.response_text(key, escape=True)
elif wechat.message.type == 'templatesendjobfinish': # template
status = wechat.message.status # Status
elif wechat.message.type in [
'scancode_push', 'scancode_waitmsg', 'pic_sysphoto',
'pic_photo_or_album', 'pic_weixin', 'location_select'
]: # others
key = wechat.message.key # EventKey
return wechat.response_text(content=u'知道了')
print(xmean, xmean - 2.576 * sigma / scipy.sqrt(n),
xmean + 2.576 * sigma / scipy.sqrt(n))
plt.stem(scores)
plt.show()
result = scipy.stats.bayes_mvs(scores)
help(scipy.stats.bayes_mvs)
print(result[0])
print('#', 50 * "-")
# -----------------------
import scipy.stats
help(scipy.stats)
help(scipy.stats.bayes_mvs)
help(scipy.stats.kurtosis)
numpy.info('random')
print('#', 50 * "-")
# -----------------------
import scipy.misc
img = scipy.misc.ascent()
plt.imshow(img)
plt.show()
print(img[0:3, 0:7])
print(img)
img = scipy.misc.face()
plt.imshow(img)
plt.show()
print(img[0:3, 0:7])
print(img)
print('#', 50 * "-")
# -----------------------
Time=np.linspace(0, len(signal)/rate, num=len(signal))
plt.figure(1)
plt.title('Signal Wave of test file (with filter)')
plt.xlabel('Time (s)')
plt.ylabel('frequency')
plt.plot(Time,signal)
plt.show()
rate, signal = wavfile.read("data/recording-0.wav")
#mask = envelope(signal, rate, 100)#this works at filtering out silence but thats actually not what I want because then I cant tell when events start and when they end
#signal = signal[mask]
print(rate)
print(np.info(signal))
plot_signals()
data_size = len(signal)
#focus_size = int(0.15 * rate)
length = int(4 * rate) #rate is how many samples per seccond, so for 5 seconds we will need the number of samples x 5 ahead of the peak
min_val = 1000
#noise_thresh = 500
focuses = []
#distances = []
sub_signals = []
idx = 0
while idx < data_size:
if( abs(signal[idx]) > min_val):
point = {
np.zeros(3)#：创建长度为3的一维数组且数组元素均为0，返回ndarray对象 np.ones((3,4))#：创建3×4的二维数组且数组元素均为1，返回ndarray对象 np.eye(5)#：创建一个5×5的二维数组且对角线元素均为1，其他元素均为0，返回ndarray对象 np.linspace(0,100,6)#：创建一维数组且其元素为0到100之间的6等分数字，返回ndarray对象 np.arange(0,10,3)#：创建一维数组且其元素为以0为起点，步长为3，直到小于10的所有数值，返回ndarray对象 np.full((2,3),8)#：创建2×3二维数组且其所有元素均为8，返回ndarray对象 np.random.rand(4,5)#：创建4×5二维数组且其所有元素为0-1之间的随机小数，返回ndarray对象 np.random.rand(6,7)*100#：创建6×7二维数组且其所有元素为0-100之间的随机小数，返回ndarray对象 np.random.randint(5,size=(2,3))#：创建2×3二维数组且其所有元素为0-4之间的随机整数，返回ndarray对象 #3）获取数组属性 arr.size#：返回数组arr中元素的个数 arr.shape#：返回数组arr的维数（行数和列数） arr.dtype#：返回数组arr中元素的类型 arr.astype(dtype)#：强制转换数组arr中元素的类型为dtype arr.tolist()#：将数组arr强制转换为Python列表 np.info(np.eye)#：查看关于np.eye的文档 #4）复制、排序和调整数组 np.copy(arr)#：复制数组arr，返回ndarray对象 arr.view(dtype)#：以指定dtype类型为数组arr每个元素建立视图 arr.sort()#：排序数组，返回ndarray对象 arr.sort(axis=0)#：按指定的轴排序数组，返回ndarray对象 two_d_arr.flatten()#：将二维数组two_d_arr转换为一维数组，返回ndarray对象 arr.T#：返回数组arr的转置（行与列互换） arr.reshape(3,4)#：将数组arr调整为3行4列，并不改变数据，返回ndarray对象 arr.resize((5,6))#：将数组arr调整为5行6列，空值用0填充，返回ndarray对象 #5）增加、删除元素 np.append(arr,values)#：为数组arr增加元素values，返回ndarray对象 np.insert(arr,2,values)#：为数组arr在索引为2的元素之前插入元素values，返回ndarray对象 np.delete(arr,3,axis=0)#：删除数组arr第3行所有的元素，返回ndarray对象 np.delete(arr,4,axis=1)#：删除数组arr第4列所有的元素，返回ndarray对象 #6）组合与拆分
def task2(self):
np.info(np.add)
from __future__ import annotations
from io import StringIO
from typing import Any
import numpy as np
FILE = StringIO()
AR: np.ndarray[Any, np.dtype[np.float64]] = np.arange(10).astype(np.float64)
def func(a: int) -> bool:
...
np.deprecate(func)
np.deprecate()
np.deprecate_with_doc("test")
np.deprecate_with_doc(None)
np.byte_bounds(AR)
np.byte_bounds(np.float64())
np.info(1, output=FILE)
np.source(np.interp, output=FILE)
np.lookfor("binary representation", output=FILE)
import numpy as np import scipy import scipy.spatial print(np.__version__) np.show_config() Z = np.zeros(10) print(Z) print(np.info(np.add)) Z = np.arange(10, 50) print(Z) Z=Z[::-1] #reverse the array print(Z) Z = np.arange(0,9) Z=Z.reshape(3,3) print(Z) Z = np.array([1,2,0,0,4,0]) Z = np.nonzero(Z) print(Z) #index of the nonzero Z = np.eye(3,3) print(Z) Z = np.random.random((3,3,3))
import numpy as np
# NumPy Version
np.__version__
# NumPy build config
np.show_config()
\begin{exercise}
Write a NumPy program to get help on the add function.
\end{exercise}
# get help from NumPy
np.info(np.add)
\begin{exercise}
Write a NumPy program to test whether none of the elements of a given array is zero.
\end{exercise}
# Solution: if zero not exist
A1 = np.array([2, 3, 4, 5 , 6])
np.all(A1)
# Solution: if zero exist in array
A2 = np.array([0, 0, 2, 3, 4, 5 , 6])
np.all(A2)
\begin{exercise}
Write a NumPy program to test whether any of the elements of a given array is non-zero.
print(np.__version__) n = int(input()) Z = np.zeros(n) print(Z) params = input().split() t = 'float64' if params[-1].isdigit() else params.pop() Z = np.zeros(tuple(map(int, params)), dtype=t) print(Z) Z = np.zeros((10, 10)) print(Z.size * Z.itemsize) np.info(np.add) np.info(np.array) Z = np.zeros(int(input())) Z[int(input())] = 1 print(Z) Z = np.arange(int(input()), int(input()) + 1) Z = np.arange(50) Z = Z[::-1] print(Z) Z = np.arange(int(input())).reshape(list(map(int, input().split()))) print(Z)
#C# Numpy arrays
#C# - Array data types
#C# - Array operations
#C# Functions
#C# - Array creation
#C# - Random number generation
#C# - Arithmetic
#C# - Trigonometry
#T# Beginning of content
# |-------------------------------------------------------------
#T# numpy has an specific function to get help for names in the namespace of numpy, it's the numpy.info function which is used as the builtin help function from Python, this is important because numpy ufuncs are written in C, an so the help function can't show their help
import numpy as np
np.info(np.array) #| shows the numpy help for np.array
# |-------------------------------------------------------------
#C# Numpy arrays
# |-------------------------------------------------------------
#T# arrays are one of the main aspects of the numpy package, numpy does not support jagged arrays for its operations
#T# numpy arrays are multidimensional, the rank of an array is the amount of dimensions of the array, the size of an array is the total amount of individual elements in the array
#T# several numpy operations and functions can handle operand arrays of different sizes and with different number of dimensions, this is called broadcasting, in it, the smaller array is broadcasted (repeated) over the larger array, e.g. a 3 element vector can be broadcasted over a 4x3 matrix, by repeating it in each of the 4 rows and then operating element-wise
#T# numpy arrays can be created with the array function
import numpy as np
arr1 = np.array(('a', 'b', 'c')) # array(['a', 'b', 'c'], dtype='<U1')
arr1 = np.array([1, 2, 3]) # array([1, 2, 3])
t.debug(on=1) t.debug(on=0) t.debug(on=0) t.reset() t.reset() t.reset() t.debug(args.internal) t.start_acquisition(sleeptime=3) data = t.read_data(num_bytes=num_bytes, blocksize=1024) print 'generate 24bit integer' resp_dec = (np.array(data[:,0],dtype='uint32')<<16) + (np.array(data[:,1], dtype='uint32')<<8) + (np.array(data[:,2],dtype='uint32')) print np.info(resp_dec) print 'done' print 'first 10: ', resp_dec[:10] print 'last 10: ', resp_dec[-10:] diffs = (resp_dec[1:]-resp_dec[:-1]) diffssum = diffs.__ne__(1).sum() print diffs print 'yo,', resp_dec[diffs.__ne__(1)] print 'sum_of_errors: ', diffssum index = np.arange(len(diffs)) print diffs[diffs.__ne__(1)] print index[diffs.__ne__(1)]
# -*- coding: utf-8 -*- """ Write a NumPy program to get help on the add function. @author: dreamy """ import numpy as np print(np.info(np.add))
# coding: utf-8
# In[1]:
import numpy as np
# In[2]:
np.__version__
# Q1. Search for docstrings of the numpy functions on linear algebra.
# In[4]:
np.lookfor('linear algebra')
# Q2. Get help information for numpy dot function.
# In[9]:
np.info(np.dot)