data.csv
        
Programming language
Designed by
Appeared
Extension
Python
Guido van Rossum
1991
.py
Java
James Gosling
1995
.java
C++
Bjarne Stroustrup
1983
.cpp
import pandas as pd
data = pd.read_csv('data.csv')
print(data)

data.info()

print(data.columns)

# Use DataFrame.T to transpose a dataframe.
print(data.T)

# Use DataFrame.describe() to get summary statistics about data.
print(data.describe())

# Creating a Series by passing a list of values, letting pandas create a default integer index.

import numpy as np 
s = pd.Series([1, 3, 5, np.nan, 6, 8]); s

# Creating a DataFrame by passing a NumPy array, with a datetime index and labeled columns. 
dates = pd.date_range("20130101", periods=6); dates

df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list("ABCD")); df

# Creating a DataFrame by passing a dict of objects that can be converted to series-like.

df2 = pd.DataFrame(
     {
         "A": 1.0,
         "B": pd.Timestamp("20130102"),
         "C": pd.Series(1, index=list(range(4)), dtype="float32"),
         "D": np.array([3] * 4, dtype="int32"),
         "E": pd.Categorical(["test", "train", "test", "train"]),
         "F": "foo",
     }
)
df2

df2.dtypes

# If you’re using IPython, tab completion for column names (as well as public attributes) is automatically enabled. Here’s a subset of the 
# attributes that will be completed:

df2.B # noqa: E225, E999

# Here is how to view the top and bottom rows of the frame:
df.head()

df.tail(3)

# Display the index, columns
df.index

df.columns

# DataFrame.to_numpy() gives a NumPy representation of the underlying data. 
# Note that this can be an expensive operation when your DataFrame has columns with different data types, which comes down to a fundamental 
# difference between pandas and NumPy: NumPy arrays have one dtype for the entire array, while pandas DataFrames have one dtype per column. 
# When you call DataFrame.to_numpy(), pandas will find the NumPy dtype that can hold all of the dtypes in the DataFrame. This may end up being
# 'object', which requires casting every value to a Python object.

# For df, our DataFrame of all floating-point values, DataFrame.to_numpy() is fast and doesn’t require copying data.
df.to_numpy()

# For df2, the DataFrame with multiple dtypes, DataFrame.to_numpy() is relatively expensive.
df2.to_numpy()
# DataFrame.to_numpy() does not include the index or column labels in the output.

# describe() shows a quick statistic summary of your data.
df.describe()

df.T

# Sorting by an axis.

df.sort_index(axis=1, ascending=False)

df.sort_values(by="B")

# Selecting a single column, which yields a Series, equivalent to df.A:
df["A"]

# Selecting via [], which slices the rows:
df[0:3]

df["20130102":"20130104"]

# For getting a cross section using a label:

df.loc[dates[0]]

df.loc[dates[0:3], ["A", "B"]]

df.loc[:, ["A", "B"]]

df[:3]

 df[::2]

 df.loc["20130104":"20130106", ["A", "B"]]

# .loc is strict when you present slicers that are not compatible (or convertible) with the index type. For example using integers
# in a DatetimeIndex. These will raise a TypeError:

df.loc[:3, ["A", "B"]]

df.loc["20130102", ["A", "B"]]

# For getting a scalar value:

df.loc[dates[0], "A"]

# For getting fast access to a scalar (equivalent to the prior method):

df.at[dates[0], "A"]

# Select via the position of the passed integers:

df.iloc[3]

# By integer slices, acting similar to numpy/Python:
df.iloc[3:5, 0:2]

# By lists of integer position locations, similar to the NumPy/Python style:

df.iloc[[1, 2, 4], [0, 2]]

# For slicing rows explicitly:

df.iloc[1:3, :]

# For slicing columns explicitly:

df.iloc[:, 1:3]

df.iloc[:3, [1, 2]]

# For getting a value explicitly:

df.iloc[1, 1]

# For getting fast access to a scalar (equivalent to the prior method):

df.iat[1, 1]

# Boolean indexing
# Using a single column’s values to select data:

df[df["A"] > 0]

# Selecting values from a DataFrame where a boolean condition is met:
df[df > 0]

# Using the isin() method for filtering:

df2 = df.copy()
df2["E"] = ["one", "one", "two", "three", "four", "three"]; df2

df2[df2["E"].isin(["two", "four"])]

df2.isin(["two", "four"])

# Setting a new column automatically aligns the data by the indexes:

s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range("20130102", periods=6)); s1

df2["F"] = s1; df2

# Setting values by label:

df2.at[dates[0], "A"] = 0; df2

# Setting values by position:

df2.iat[0, 1] = 0; df2

# Setting by assigning with a NumPy array:

df2.loc[:, "D"] = np.array([5] * len(df2)); df2

type(df2.loc[dates[0], "D"])

import numpy as np

val = np.int64(0)
pyval = val.item()
print(type(pyval)) 


# and similar...
# type(np.float64(0).item()) # <class 'float'>
# type(np.uint32(0).item())  # <class 'int'>
# type(np.int16(0).item())   # <class 'int'>
# type(np.cfloat(0).item())  # <class 'complex'>
# type(np.datetime64(0, 'D').item())  # <class 'datetime.date'>
# type(np.datetime64('2001-01-01 00:00:00').item())  # <class 'datetime.datetime'>
# type(np.timedelta64(0, 'D').item()) # <class 'datetime.timedelta'>
...

g = df2.loc[dates[0], "D"]
pynum = g.item()
type(pynum)

df2 = df3; df2

df3 = df2.copy()
df3[df3 > 0] = -df3
df3

# Missing data:
# pandas primarily uses the value np.nan to represent missing data. It is by default not included in computations. See the 
# Missing Data section.
# Reindexing allows you to change/add/delete the index on a specified axis. This returns a copy of the data.

df3 = df2.reindex(index=dates[0:4], columns=list(df2.columns) + ["E"])
df3.loc[dates[0] : dates[1], "E"] = 1
df3

# To drop any rows that have missing data:

df3.dropna(how="any")

# Filling missing data:

df3.fillna(value=5)

# To get the boolean mask where values are nan:

pd.isna(df3)

# stats:

df3.mean()

# Same operation on the other axis:

df3.mean(1)

# Operating with objects that have different dimensionality and need alignment. In addition, pandas automatically broadcasts 
# along the specified dimension.

s = pd.Series([1, 3, 5, np.nan, 6, 8], index=dates).shift(2); s

df3.sub(s, axis="index")

dfx = pd.DataFrame({'angles': [0, 3, 4], 'degrees': [360, 180, 360]}, index=['circle', 'triangle', 'rectangle']); dfx

dfx + 1

dfx.add(1)

dfx.div(10)

dfx.rdiv(10)

dfx - [1, 2]

dfx.sub([1, 2], axis='columns')

dfx.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), axis='index')

# Multiply a DataFrame of different shape with operator version:

other = pd.DataFrame({'angles': [0, 3, 4]}, index=['circle', 'triangle', 'rectangle']);other

dfx * other

another = pd.DataFrame({'degrees': [0, 3, 4]}, index=['circle', 'triangle', 'rectangle']);another

dfx * other

dfx.mul(other, fill_value=0)

# Divide by a MultiIndex by level:

dfx_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], 'degrees': [360, 180, 360, 360, 540, 720]}, index=[['A', 'A', 'A', 'B', 'B', 'B'], ['circle', 'triangle', 'rectangle',
'square', 'pentagon', 'hexagon']]); dfx_multindex

dfx.div(dfx_multindex, level=1, fill_value=0)

# Apply: applying functions to the data.

dfx.apply(np.cumsum)

dfx.apply(lambda x: x.max() - x.min())

s = pd.Series(np.random.randint(0, 7, size=10)); s

s.value_counts()

# String Methods
# Series is equipped with a set of string processing methods in the str attribute that make it easy to operate on each element of
# the array, as in the code snippet below. 
# Note that pattern-matching in str generally uses regular expressions by default (and in some cases always uses them). 
# See more at Vectorized String Methods.

s = pd.Series(["A", "B", "C", "Aaba", "Baca", np.nan, "CABA", "dog", "cat"])
s.str.lower()

# Merge
# Concat: pandas provides various facilities for easily combining together Series and DataFrame objects with various kinds of set
# logic for the indexes and relational algebra functionality in the case of join / merge-type operations. See the Merging section.

# Concatenating pandas objects together with concat():

dfr = pd.DataFrame(np.random.randn(10, 4)); dfr

pieces = [dfr[:3], dfr[3:7], dfr[7:]]
pd.concat(pieces)

# Adding a column to a DataFrame is relatively fast. However, adding a row requires a copy, and may be expensive. We recommend 
# passing a pre-built list of records to the DataFrame constructor instead of building a DataFrame by iteratively appending 
# records to it. See Appending to dataframe for more.

 result = dfx.append(dfr); result

result2 = pd.concat([dfx, dfr], ignore_index=True, sort=False); result2

# Join: SQL style merges. See the Database style joining section.

left = pd.DataFrame({"key": ["foo", "foo"], "lval": [1, 2]})
right = pd.DataFrame({"key": ["foo", "foo"], "rval": [4, 5]})
left

right

pd.merge(left, right, on="key")

hrdata.csv
Name
Hire Date
Salary
Sick Days remaining
Graham Chapman
03/15/14
50000
10
John Cleese
06/01/15
65000
8
Eric Idle
05/12/14
45000
10
Terry Jones
11/01/13
70000
3
Terry Gilliam
08/12/14
48000
7
Michael Palin
05/23/13
66000
8
import pandas
dfh = pandas.read_csv('hrdata.csv')
print(df)

# pandas.read_csv() opens, analyzes, and reads the CSV file provided, and stores the data in a DataFrame.