import numpy as np # standard module import

a = np.array([2, 3, 4]) # Creates a single numpy array. values must be passed as a list

b = np.array([1.2, 3.5, 5.1]) # Creates a numpy array

c = np.array([[1, 2, 3], [4, 5, 6]]) # Creates a 2 dimensional array

d = np.array([1, 2, 3], dtype = 'float64') # Creates numpy array indicating the data type

a0 = np.zeros((3,4)) # Creates an array of zeros with the specified shape

a1 = np.ones((3,4)) # Creates an array of ones with the specified shape

a0 = np.zeros((3,4), dtype = 'int16') # Creates an array of zeros with the specified shape and data type

a0 = np.zeros((3,4), dtype = np.int16) # Creates an array of zeros with the specified shape and data type

az = np.empty((3,4), dtype = np.int8) # Creates unitialized array of specified shape and data type

ar = np.arange(5) # Creates an 1 dimension array with the values in a rage: ar = [0, 1, 2, 3, 4]

ar = np.arange(5, dtype = np.int16) # As above but set the data type to int16

ar = np.random.random(4) # Creates a 1 dimension array of 4 random values (between 0-1)

ar = np.random.random((3,2)) # Creates a 2 dimension array of 3x2 random values (between 0-1)

ad = np.zeros ((3,4), dtype= np.int8) # Byte (-128 to 127)

ad = np.zeros ((3,4), dtype= np.int16) # Integer (-32768 to 32767)

ad = np.zeros ((3,4), dtype= np.int32) # Integer ((-2147483648 to 2147483647)

ad = np.zeros ((3,4), dtype= np.int64) # Integer (-9223372036854775808 to 9223372036854775807)

ad = np.zeros ((3,4), dtype= np.uint8) # Unsigned intger (0 to 255)

ad = np.zeros ((3,4), dtype= np.uint16) # Unsigned intger (0 to 65535)

ad = np.zeros ((3,4), dtype= np.uint32) # Unsigned intger (0 to 4294967295)

ad = np.zeros ((3,4), dtype= np.uint64) # Unsigned intger (0 to 18446744073709551615)

ad = np.zeros ((3,4), dtype= np.float_) # Shorthand for float64

ad = np.zeros ((3,4), dtype= np.float16) # Half precision float: sign bit, 5 bits exponent, 10 bits mantissa

ad = np.zeros ((3,4), dtype= np.float32) # Single precision float: sign bit, 8 bits exponent, 23 bits mantissa

ad = np.zeros ((3,4), dtype= np.float64) # Double precision float: sign bit, 11 bits exponent, 52 bits mantissa

ad = np.zeros ((3,4), dtype= np.complex_) # Shorthand for complex128

ad = np.zeros ((3,4), dtype= np.complex64) # Complex number, represented by two 32-bit floats

ad = np.zeros ((3,4), dtype= np.complex128) # Complex number, represented by two 64-bit floats

nd1 = np.array([[1, 2, 3, 4], [4, 5, 6, 7]], np.int32) # Creates a 2 dimensional array

nd1[0, 0] # Returns 1 (column 0, row 0)

nd1[1, 0] # Returns 4 (column 1, row 0)

nd1[-1, :] # Returns the last row and all the columns

nd1[:, 2] # Returns all the rows column 2

nd1[1, :] # Returns column 1 all the rows

array = np.asarray(list) # Convert list to array

list = array.tolist() # Convert array to list

array = array[::-1] # Reverses array

a.dtype # returns the array type: int32

b.dtype # returns the array type: float64

d.dtype # Returns float64

a.ndim # Returns array dimensions: 1

c.ndim # Returns array dimensions: 2

a.size # Returns the number of elements in the array

a.shape # Returns a tuple with the array shape: (3,)

c.shape # Returns a tuple with array shape: (2, 3)

c.shape[0] # Returns the number of rows in the array

c.shape[1] # Returns the number of columns in the array

a.sum() # Returns the sum of the elements of the array

a.sum(axis=0) # Returns the sum of the columns in the array

a.som(axis=1) # Returns the sum of the rows in the array

a.min() # Returns the minimun value in the array

a.min(axis=0) # Returns the minimum value of each column

a.min(axis=1) # Returns the minimun value of each row

a.max() # Returns the maximum value of the array

a.max(axis=0) # Returns the maximum value of each columna

a.max(axis=1) # Returns the maximum value of each row

a.argmax() # Returns the index of the maximum value

a.mean() # Returns the mean value of the array

a.mean(axis=0) # Returns the mean of each column

a.mean(axis=1) # Returns the mean of each row

np.pi # pi

np.e # e

from scipy import constants # Import constants

scipy.constants.pi # pi

scipy.constants.e # e

scipy.constants.Avogrado # Avogrado number

scipy.constants.kilo # Kilo 1e3

scipy.constants.mega # Mega 1e6

scipy.constants.nano # Nano 1e-9

sample = np.random.normal(center, std_deviation, size)

sample = np.random.normal(0, 2, 20) # Gaussian sample, center 0, standard deviation 2, 20 numbers

interval = np.linspace(start, stop, number, dtype=type)

interval = np.linspace(0, 10, 11, dtype=int) # Returns an interval of ints from 0 to 10 -> [0..10]

import pandas as pd # Standard module import

dataframe = pd.read_csv(file) # Imports a CSV file as dataframe

dataframe = pd.read_csv(file, delimiter=r"\s+") # Imports a <SPACE> separated file

dataframe = pd.read_csv(file, delimiter='|') # Imports a | separated file.

dataframe = pd.read_csv(file, delim_whitespace=True) # Imports a <SPACE> separated file

dataframe = pd.read_csv(file, header = None) # Imports a file that has no headers

dataframe = pd.read_csv(file, na_filter = False) # na_filter=False converts all nam into empty strings

dataframe = pd.read_csv(file, encoding = 'utf-8') # imports a CSV file setting the encoding to utf-8.

# other encoding options: utf-16, latin

dataframe.drop('feature', axis = 1) # Eliminates a column 'feature' from the dataframe

# axis = 0 indicates a row, axis = 1 indicates a column

dataframe.dropna() # Eliminate all NaN observations

dataframe.fillna(0) # Replace all NaN values with 0. A different value can be specified

datafrane.fillna(method='ffill') # NaN values forward filling

dataframe.fillna(method='backfill') # NaN values backward filling

dataframe = pd.read_csv(file).drop('feature', axis = 1) # Reads the dataframe and eliminates the column feature

dataframe = pd.DataFrame(list) # Convert an existing dictionary into a dataframe

dataFrame = pd.read_json(file.json) # Imports a JSON file as dataframe

dataframe = pd.DataFrame(data = np.nan, index = [0, 1, 2, 3, 4], columns = ['A', 'B'])

dataFrame.insert(loc=2, column='A', value=0) # Inserts a column named A on the after the 2nd column with value 0

dataFrame = dataFrame.rename(columns={'old name1':'new name1', 'old name2':'new name2'})

dataFrame = dataFrame.drop(['column'], axis=1)

dataFrame.columns.get_loc('column') # Returns the index of column

dataframe.iloc[::-1]

dataframe.reset_index(drop=True, inplace=True)

df1 = dataframe['feature'] # Creates a new dataframe (df1) with a copy of a feature from dataframe

dataframe = dataframe.replace(np.NaN, 0) # Replaces all NaN values with 0

dataframe.loc['index1'] # Returns the row/observation with label <index1>

dataframe.iloc[line] # Returns the row/observation of position <line>

dataFrame.iloc[r1:r2] # Returns the rows/observations within range <r1>:<r2>

dataFrame.iloc[-1] # Returns the last observation of the dataframe

dataframe['feature'].iloc[-1] # Returns the last observation of the specific feature

dataframe['feature'].unique() # Lists unique values in a dataframe column

len(dataframe.index) # Quick count of rows in a dataframe

dataframe.column_name = dataframe.column_name.astype(float) # Converts values of a column to type float

dataframe['feature'].tolist() # Converts the values of the feature to a list

df['new_col1'], df['new_col2'] = zip(*df['original_col'].apply(lambda x: x.split(',', 1)))

idx = dataframe.index[dataframe['feature']==value] # Returns the index where the value is found

value = dataframe[dataframe['feature']==value] # Returns a dataframe with the values where the condition is true

dataset = dataframe.values

len(dataframe.index)

len(dataFrame.columns)

for index, row in dataframe.iterrows():

print (row)

print (row['index1'], row['index2'])

dataframe.describe()

dataframe.count() # Count the number of non-null observations

dataframe.sum() # Sum of values

dataFrame.mean() # Mean of values

dataframe.mad() # Mean absolute deviation

dataframe.median() # Arithmetic median of values

dataframe.min() # Minimum

dataframe.max() # Maximum

dataframe.mode() # Mode

dataframe.abs() # Absolute value

dataframe.prod() # Product of values

dataframe.std() # Bessel-corrected sample standard deviation

dataframe.var() # Unbiased variance

dataframe.sem() # Standard error of the mean

dataframe.skew() # Sample skewness (3rd moment)

dataframe.kurt() # Sample kurtosis (4th moment)

dataframe.quantile() # Sample quantile (value at %)

dataframe.cumsum() # Cumulative sum

dataframe.cumprod() # Cumulative product

dataframe.cummax() # Cumulative maximum

dataframe.cummin() # Cumulative minimum

dataFrame['feature'].count() # Returns the count of non null-observation of 'feature'

dataframe['feature'].mean() # Returns the mean of values of 'feature'

dataFrame.plot() # Plots the content of the dataframe

dataFrame.plot(grid=True) # Plost the dataframe and adds a grid to the chart

ax = dataFrame.plot() # Creates a pyplot chart

ax.set(title='Title', xlabel='x axis label', ylabel='y axis label') # Set chart properties

ax = dataFrame.plot(title='Title', linewidth=2.5)

ax = dataFrame.hist() # Plots a histogram

ax = dataFrame.hist(bins=20) # Plots a histogram with 20 bins

import matplotlib.pyplot as plt

from matplotlib.ticker import FuncFormatter # Module support configurable tick locating and formatting

fig, ax = plt.subplots() # Create figure

ax.plot(xdata, ydata) # plot data

ax.set(xlabel='x label', ylabel='y label', title='Chart Title')

ax.grid() # Diplay chart grid standard parameters

ax.grid(color='r') # Red color grid

print(plt.style.available) # Print the available formatting styles

plt.style.use('fivethirtyeight') # Apply formatting style

lables = ax.get_xticklabels() # Get x axis labels attributes

plt.setp(labels, rotation=45) # Set xlabels rotation to 45 degrees

plt.xlabel ('xlabel', fontsize=10) # Method 1

plt.setp(labels, fontsize=10) # Method 2

ax.axvline(xvalue) # Draw a vertical line at xvalue

ax.axhline(yvalue) # Draw a horizontal line at yvalue

import re # import the regular expressions module

re.search(patterns, text) # Searchs for a pattern in a text. returs True or False

re.search('ab?', 'ac') # Returns True. Means 'a' followed by zero or one 'b'

re.search('ab?', 'abc') # Returns True. Means 'a' followed by zero or one 'b'

re.search('ab?', 'abbc') # Returns True. Means 'a' followed by zero or one 'b'

re.search('ab*', 'ac') # Returns True. Means 'a' followed by zero or more 'b'

re.search('ab*', 'abc') # Returns True. Means 'a' followed by zero or more 'b'

re.search('ab*', 'abbc') # Returns True. Means 'a' followed by zero or more 'b'

re.search('ab+', 'ac') # Returns False. Means 'a' followed by one or more 'b'

re.search('ab+', 'abc') # Returns True. Means 'a' followed by one or more 'b'

re.search('ab+', 'abbc') # Returns True. Means 'a' followed by one or more 'b'

re.search('ab{2}', 'ac') # Returns False. ab{2} means 'a' followed exactly by 2 'b'

re.search('ab{2}', 'abc') # Returns False. ab{2} means 'a' followed exactly by 2 'b'

re.search('ab{2}', 'abbc') # Returns True. ab{2} means 'a' followed exactly by 2 'b'

re.search('^a.*c$', 'abbc') # Returns true

re.search('^\w+', 'abbc') # Returns True

re.search('\w+\S*?$', 'Loli eats peas') # Returns True

print (text_match('Tuffy eats pie, Loli eats peas!', '\Bu\B')) # Returns True

text = 'Diwali is a festival of lights, holi is a festival of colors!'

pattern = 'festival'

for match in re.finditer(pattern, text):

s = match.start()

e = match.end()

print ('Found {} at {}:{}'.format(text[s:e], s, e))

street = '21 Ramakrishna Road'

print (re.sub('Road', 'Rd', street)) # Returns 21 Ramakrishna Rd

CREATE TABLE comments (

post_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,

name TEXT NOT NULL,

email TEXT NOT NULL,

website TEXT NOT NULL,

comment TEXT NOT NULL);

ALTER TABLE comments ADD COLUMN username text;

DROP TABLE comments;

CREATE VIEW [IF NOT EXISTS] view_name (column-name-list)

AS

select-statement;

CREATE VIEW IF NOT EXISTS v_coins as

SELECT

name as country,

value,

year,

currency

FROM

coins;

DROP VIEW [IF EXISTS] view_name;

DROP VIEW v_coins;

INSERT INTO comments (name, email, website, comment)

VALUES ('test_name', 'test@email.com', 'test website', 'test comment');

UPDATE comments set email = 'new@mail.com' WHERE name = 'test_name';

UPDATE comments set email = 'new@mail.com' WHERE post_id = 1;

DELETE FROM comments WHERE post_id = 1;

DELETE FROM comments WHERE name = 'test_name';

name as country,

value,

year,

currency

coins

INNER JOIN country on country.iso = coins.country

ORDER BY year;

SELECT post_id, name, email, website, comment FROM comments;

SELECT * FROM comments;

import sqlite3

conn = sqlite3.connect('mydatabase.db') # Opens the specified file

conn = sqlite3.connect(:memory:) # Creates de database in RAM

conn = sqlite3.connect('file:mydatabase.db?mode=ro', uri=True)

cursor = conn.cursor()

cursor.execute('''CREATE TABLE albums

media_type TEXT)''')

cursor.execute('''INSERT INTO albums VALUES(

'MP3')''')

album = [('Exodous', 'Andy Hunter', '7/9/2002', 'Sparrow Records', 'CD')]

cursor.execute('INSERT INTO albums VALUES (?, ?, ?, ?, ?)', album)

import pandas as pd

print (pd.read_sql_query('SELECT * FROM table;', conn))

df = pd.read_sql_query('SELECT * FROM table', conn)

import io

with io.open(filename, 'r', encoding='utf-8') as f:

text = f.read()

f.close()