Can't read excell file .xlsx (TypeError: read_excel() got an unexpected keyword argument `parse_cols`)
#### Code Sample, a copy-pastable example if possible

```python
# Your code here
import numpy as np  
# Pandas is useful to read in Excel-files. 
import pandas as pd
# matplotlib.pyplot as plotting tool
import matplotlib.pyplot as plt
# import sympy for functions and monte-carlo analysis.
from sympy import *
# Import sys and os to manipulate directories and file-names.
import sys, os
# Mathematical functions
import math
import cmath

"""
Following convention is used in the program:
    - Names with small-letters without extentions is used for sympy-variables
    - Capital letters are used for panda-dataframes.
    - Smalle-letters followed by "_np" are used for numpy-arrays.

Next functions are used within the program.
The target of using functions:
    - when parts of the program are used several times
    - to keep the main program simpler
    - to use the same function within different versions of the program
Folowing functions are used:
    - read_data(): makes use of pandas to read excel-files
    - plot_results(): plot the results in x-y diagram + required formatting
    - plot_results_lin(): plot the results of linear regressing + required formatting
    - tacho_sync(): function to calibrate tacho

#########################
# Functions             #
#########################
"""

def read_data(full_path, sheet_name, rows, cols):
    """
    Function to read part of the excel-file and to convert sheet in to dataframe.
    ---
    full_path = name of the excel_file that contains the measurements
    sheet_name = name of the excel_sheet in the excel_file
    ---
    Column 0 contains headers
    cols = nummer of columns
    ---
    Row 0 contains names for the rows
    rows = nummer of rows
    The information about this function can be called through the command help(read_data)
    """
    with open(full_path) as f:
        Data = pd.read_excel(full_path, sheet_name, header = 0, index_col = 0, parse_cols = cols)[0:rows]
        f.closed
    return Data

def plot_results(x, y, Label="nolabel", xlabel="x", ylabel="y", title="Title"):
    """
    Function to plot data and to format the plot
    ---
    x = x-coordinates
    y = y-coordinates
    Label = legend of the plot
    xlabel = label for x-coordinates
    ylabel = label for x-coordinates
    title = title for the plot
    """
    plt.figure(1)
    plt.plot(x, y, "ro-", linewidth = 2, markersize = 12, label= Label)
    # Format plot
    plt.legend(loc = "upper left")
    #plt.axis([15, 40, 0.9, 1])   #plt.axis([xmin, xmax, ymin, ymax])
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.title(title)
    plt.grid()
    plt.savefig(date + " Resistor-to-temp" + ".pdf")
    plt.show()
    
def plot_results_lin(x, y, y_reg, y_min, y_max, xlabel="x", ylabel="y", title="Title"):
    """
    Function to plot the results of linear regression
    ----
    x = x-coordinates
    y = y-coordinates of original data
    y_reg = y-coordinates of fitted data
    y_min = y-coordinates of minimum values for fitted data
    y_max = y-coordinates of maximum values for fitted data
    xlabel = label for x-coordinates
    ylabel = label for x-coordinates
    title = title for the plot
    """
    plt.figure(2)
    plt.plot(x, y, 'o-', label='Original data', markersize=10)
    plt.plot(x, y_reg, 'r', label='Fitted line')
    plt.plot(x, y_max,'b-', label='max')
    plt.plot(x, y_min,'b-', label='min')
    # Format plot
    plt.legend(loc = "upper left")
    #plt.axis([15, 40, 0.9, 1])   #plt.axis([xmin, xmax, ymin, ymax])
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.title(title)
    plt.grid()
    plt.savefig(date + " Linear regression" + ".pdf")
    plt.show()
    
def tacho_sync():
    """
    Line regression for pmech i.f.v. slip
    Ijking van tacho zodat slip = 0 voor pmech = 0
    Results in IPython console shows the optimal value
    """
    for x in np.linspace(53.6,53.7,10):
        ut_syn = x
        slip_bp = (ut_syn - ut_np)/ut_syn
        pjr_bp = plu_bp_np*slip_bp
        # Mechanisch vermogen
        pmech_bp = (1-slip_bp)*plu_bp_np
        # Linear regression pmech_bp in function of slip_bp 
        # return z contains slope and intercept
        z = np.polyfit(slip_bp, pmech_bp, deg=1)
        intercept = z[1]
        # intercept should be 0 "no pmech at slip = 0"
        # print result
        print(ut_syn, intercept)
        
def plot_losses(p_bp_np, pwv_np, pfe_np, pjs_np, psu_np, pjr_np):
    """
    Plot of losses of induction motor
    """
    # plot results
    plt.figure(3)
    plt.plot(p_bp_np, pwv_np, "ro-", label = "wrijvings en ventilatie")
    plt.plot(p_bp_np, pfe_np, "bo-", label = "ijzerverliezen")
    plt.plot(p_bp_np, pjs_np, "go-", label = "joule-verliezen stator")
    plt.plot(p_bp_np, psu_np, "cs-", label = "supplementaire-verliezen")
    plt.plot(p_bp_np, pjr_np, "m^-", label = "joule-verliezen rotor")
    plt.legend(loc = "upper left")
    plt.savefig(date + " Verliezen_absoluut" + ".pdf")
    plt.grid()
    plt.show()
    
    # Plot bar-chart with losses
    
    tot_loss = pjs_np + pfe_np + psu_np + pjr_np + pwv_np
    p_tot_loss = tot_loss/p_bp_np
    p_pjs = pjs_np/tot_loss
    p_pfe = pfe_np/tot_loss
    p_psu = psu_np/tot_loss
    p_pjr = pjr_np/tot_loss
    p_pwv = pwv_np/tot_loss
    
    
    ylabel = "procent loss"
    title = "Loss measured for different loads"
    
    
    #for x in range(5):
    #    plt.bar(range(5),y[:,x], 1/1.5, color="blue")
    #    plt.show()
    
    ind = np.arange(rows)    # the x locations for the measurements
    width = 0.35       # the width of the bars: can also be len(x) sequence
    
    plt.figure(4)
    p1 = plt.bar(ind, p_pjs, width, color='r')
    p2 = plt.bar(ind, p_pfe, width, color='m', bottom = p_pjs)
    p3 = plt.bar(ind, p_psu, width, color='g', bottom = p_pjs+p_pfe)
    p4 = plt.bar(ind, p_pjr, width, color='c', bottom = p_pjs+p_pfe+p_psu)
    p5 = plt.bar(ind, p_pwv, width, color='b', bottom = p_pjs+p_pfe+p_psu+p_pjr)
    
    plt.ylabel("procent loss")
    plt.title("Loss measured for different loads")
    plt.xticks(ind, ('M1', 'M2', 'M3', 'M4', 'M5', 'M6'))
    plt.yticks(np.arange(0, 1.1, 0.1))
    plt.legend((p1[0], p2[0], p3[0], p4[0], p5[0]), ('pjs','pfe', 'psu', 'pjr', 'pwv'), loc = 'center left')
    plt.savefig(date + " Verliezen_procentueel_bar_chart" + ".pdf")
    plt.grid()
    plt.show()
    
    plt.figure(5)
    p1 = plt.bar(ind, pjs_np, width, color='r')
    p2 = plt.bar(ind, pfe_np, width, color='m', bottom = pjs_np)
    p3 = plt.bar(ind, psu_np, width, color='g', bottom = pjs_np+pfe_np)
    p4 = plt.bar(ind, pjr_np, width, color='c', bottom = pjs_np+pfe_np+psu_np)
    p5 = plt.bar(ind, pwv_np, width, color='b', bottom = pjs_np+pfe_np+psu_np+pjr_np)
    
    plt.ylabel("Loss in Watt")
    plt.title("Loss measured for different loads")
    plt.xticks(ind, ('M1', 'M2', 'M3', 'M4', 'M5', 'M6'))
    plt.yticks(np.arange(0, 1000, 100))
    plt.legend((p1[0], p2[0], p3[0], p4[0], p5[0]), ('pjs','pfe', 'psu', 'pjr', 'pwv'), loc = 'upper left')
    plt.savefig(date + " Verliezen_absoluut_bar_chart" + ".pdf")
    plt.grid()
    plt.show()
"""        
#################
# Main program  #
#################
    
#############################################################
# 1.0 Calculation of temperature based on resistor measurements
#############################################################

# 1.1 Read data from excel-file
#--------------------------
"""
# folder path of current script
# Function to determine the working_directory
folder = os.path.dirname(sys.argv[0])    
# Filename of excel file with the measured data
file_name = r"/Rendementsmeting.xls" 
# Full path of excel file
full_path = folder + file_name
# Date for output files
date = "8-sept-2019"
# Excel-sheet with resistor-values
sheet_name = "Stator R"
rows = 5
cols = 3

# R_ST is a panda-Dataframe
R_ST = read_data(full_path, sheet_name, rows, cols)

# Extract the numpy-arrays from the panda dataframe
# ur_np numpy variable
ur_np = R_ST["U"].values  
# ir_np numpy variable
ir_np = R_ST["I"].values  
"""
# 1.2 Calculate the stator resistor: 3 resistors are measured in serie
#----------------------------------------------------------
"""
r_DR_np = ur_np/ir_np/3  # r_DR_np is resistor in triangle-connection
# Triangle to star transformation
rst_np = r_DR_np/3  # rst_np is resistor in star-connection

# Calculate temperature
#-----------------------------
# First measurment "t1" is at 20°C (room-temperature)
# Other measurements are performed at t2 = Rt2/Rt1*(t1+k) - k
# k for copper = 234,5 °C

t_20 = 20
k = 234.5
rst_20 = rst_np[0] # First measurment is at 20 °C

# calculate temperature corresponding with different resistor values
temp_np = rst_np / rst_20 * (t_20 + k) - k
"""
# 1.3 Plot temp
#-----------
"""
xlabel = "Temp [°C]"
ylabel = "rst [Ohm]"
title = "Measurement of stator resistor"
Label = R_ST.comment   # Column of the Excel-file
plot_results(temp_np, rst_np, Label, xlabel, ylabel, title)
"""
# 1.4 Define function for rst (temp)
# ----------------------------------
"""
# Function to calculate the stator-resistor at other temperature then 
# the temperature used in the measurements.
# Define the function in sympy for the sympy-variable temp
temp = symbols("temp")
rst = rst_20 * (temp + k)/(20 + k)
# convert the function for numpy-arrays
f_rst = lambdify(temp, rst, "numpy") # function for numpy-calculations
"""
##############################
# 2.0 Zero-load condition    #
##############################
# 2.1 Read excel-file
#--------------------
"""
sheet_name = "Zero-load"
rows = 6
cols = 4
NL = read_data(full_path, sheet_name, rows, cols)
# Read data from dataframe
# Line-voltage
ul_nl_np=np.array(NL["U"].values,dtype=np.float32)
#ul_nl_np = NL["U"].values  
# Phase-voltage (Star connection)
up_nl_np = ul_nl_np / 3**0.5
# Line current
i_nl_np = np.array(NL["I"].values,dtype=np.float32) 
wnl1_np = np.array(NL["W1"].values,dtype=np.float32)
wnl2_np = np.array(NL["W2"].values,dtype=np.float32)  
pel_nl_np = wnl1_np + wnl2_np

"""
# 2.2 Calculate losses for zero-load conditions
# ---------------------------------------------
"""
# Joule-verliezen in stator_weerstand
pjs_nl_np = 3 * f_rst(36) * i_nl_np**2
# Verliezen = gemeten vermogen - Joule-verliezen
pve_nl_np = pel_nl_np - pjs_nl_np

"""
# 2.3 Linear regression verliezen in functie van U**2
#------------------------------------------------
"""
# Voltage at de air-gap is smaller then the applied voltage
cosp_nl_np = (pel_nl_np / 3) / (up_nl_np * i_nl_np)
phi_nl_np = np.arccos(cosp_nl_np)  # Angle is given in radians
phi_deg_nl_np = phi_nl_np / math.pi * 180  # in degrees
e1_nl_np = up_nl_np - f_rst(36) * i_nl_np * cosp_nl_np
x = e1_nl_np**2
y = pve_nl_np
z = np.polyfit(x,y,deg=1)
# z contains the slope and the intercept  
slope_lg = z[0]
pwv_lg = z[1]  
# intercept at zero volt is the friction loss and ventilation loss
"""
Remark the value of pwv_lg must be devided by 2
The measured value is due to the motor and the load on the same shaft.
"""
# Helft van verliezen te wijten aan DC-motor
pwv_cst = pwv_lg/2       

"""
# 2.4 Plot results of linear regression
#--------------------------------------
"""
# Define function based on the result of the linear regression stored in z
# pverlies = slope * x + intercept
p_verlies = np.poly1d(z)

err_lg_np = pve_nl_np - p_verlies(e1_nl_np**2)
mean_err_nl = np.mean(err_lg_np) # should be very small 
print("Mean of Error of linear regression = ", mean_err_nl)
std_err_nl = np.std(err_lg_np) # should be very small 
print("Standard deviation of Error of linear regression = ", std_err_nl)
reg_line_np = p_verlies(e1_nl_np**2)
max_line_np = p_verlies(e1_nl_np**2) + 3 * std_err_nl     # array in numpy
min_line_np = p_verlies(e1_nl_np**2) - 3 * std_err_nl     # array in numpy

xlabel = "sqrt U [V**2]"
ylabel = "nullast verlies [W]"
title = "Nullast verlies"
plot_results_lin(x, y, reg_line_np, max_line_np, min_line_np, xlabel, ylabel, title)

"""
# 2.5 Components of equivalent schematic
#-------------------------------------------
"""
r_mag_np = e1_nl_np**2 / (pve_nl_np / 3)
sve_nl_np = 3 * e1_nl_np * i_nl_np # Apparant power
qve_nl_np = (sve_nl_np**2 - pve_nl_np**2)**0.5 # Reactive power
x_mag_np = e1_nl_np**2 / qve_nl_np

# Components of equivalent schematic based on complex numbers
# cos-phi at the input
# complex current referred to the voltage
i_nl_cn = i_nl_np * np.cos(phi_nl_np) - i_nl_np * np.sin(phi_nl_np) * 1j
# complex voltage after the stator resistor
e1_nl_cn = up_nl_np - f_rst(36) * i_nl_cn
# Admitance
y_cn = i_nl_cn / e1_nl_cn
rm_np = 1 / np.real(y_cn) 
# Resistor includes friction and ventilation losses.
xm_np = - 1 / np.imag(y_cn)
# Inductance includes leakage inductance of the stator
"""
# 2.6 Sympy functions for the Monte-Carlo analyses
#-------------------------------------------------
We will build some functions in sympy for the Monte-Carlo analysis.
Following steps:
    a. Define the basic variables = measurements variables.
    b. Define functions in Sympy to calculate the losses.
    (Sympy will determin a global function out of the different sub-functions.)
    c. Convert the global function to numpy with the command lambdify.
    d. Define a numpy array (random errors) for all basic variables.
    e. Monte-Carlo: Apply the functions on all numpy arrays.
   
"""
"""
# a. Define the basic variables = measurements variables.
"""
ul_nl, i_nl, wnl1, wnl2 = symbols("ul_nl i_nl wnl1 wnl2")
"""
# b. Define functions in Sympy to calculate the losses.
"""
pel_nl = wnl1 + wnl2
# Function for rst is defined under resistor measuremnts
# rst = rst_20 * (temp + k)/(20 + k) with temp as variable
pve_nl = pel_nl - 3 * i_nl**2 * rst
# Sympy-function for pwv_nl
up_nl = ul_nl / 3**0.5
cosp_nl = (pel_nl / 3) / (up_nl * i_nl)
e1_nl = up_nl - rst * i_nl * cosp_nl
pwv_nl = pve_nl - slope_lg * e1_nl**2  
# Sympy-function for pfe_nl 
pfe_nl = pve_nl - pwv_nl  
"""
# c. Convert the global function to numpy with the command lambdify.
"""
f_pwv = lambdify((ul_nl, i_nl, wnl1, wnl2, temp), pwv_nl, "numpy")
f_pfe = lambdify((ul_nl, i_nl, wnl1, wnl2, temp), pfe_nl, "numpy")
"""
# d. Define a numpy array (random errors) for all basic variables.
"""
N = 1000  # Defines the size of the numpy-arrays used for MC.

m_ul_nl = ul_nl_np[-1]  # Mean value = Last voltage of the numpy-array ul_nl_np
st_ul_nl = 0.005 * m_ul_nl  # Standard deviation = total-accuracy = 2.6 * 0.01
ul_nl_mc = np.random.normal(loc = m_ul_nl, scale = st_ul_nl, size = N)

m_i_nl = i_nl_np[-1]  # Mean value = Last voltage of the numpy-array i_nl_np
st_i_nl = 0.005 * m_i_nl  # Standard deviation = total-accuracy = 2.6 * 0.01
i_nl_mc = np.random.normal(loc = m_i_nl, scale = st_i_nl, size = N)

m_wnl1 = wnl1_np[-1]  # Mean value = Last voltage of the numpy-array i_nl_np
st_wnl1 = 0.01 * m_wnl1  # Standard deviation = total-accuracy = 2.6 * 0.01
wnl1_mc = np.random.normal(loc = m_wnl1, scale = st_wnl1, size = N)

m_wnl2 = wnl2_np[-1]  # Mean value = Last voltage of the numpy-array i_nl_np
st_wnl2 = 0.01 * abs(m_wnl2)  # Standard deviation = total-accuracy = 2.6 * 0.01
wnl2_mc = np.random.normal(loc = m_wnl2, scale = st_wnl2, size = N)

d_temp = (temp_np[1] - temp_np[2]) / 2  # Half of the delta_t between zero load and warm
m_temp = temp_np[1] + d_temp # Mean value = temperature measured after the zero load.
temp_mc = np.random.uniform(low = m_temp - d_temp, high = m_temp + d_temp, size = N)
"""
# e. Apply the function on all numpy arrays.
"""
pwv_mc = f_pwv(ul_nl_mc, i_nl_mc, wnl1_mc, wnl2_mc, temp_mc)
pfe_mc = f_pfe(ul_nl_mc, i_nl_mc, wnl1_mc, wnl2_mc, temp_mc)
"""
# 2.6 Plot the normal distribution and calculate mean and standard deviation.
#----------------------------------------------------------------------------
"""
m_pwv = np.mean(pwv_mc)
st_pwv = np.std(pwv_mc)

plt.figure(6)
n, bins, _ = plt.hist(pwv_mc, 
                      bins = np.linspace(m_pwv-3*st_pwv, m_pwv+3*st_pwv, int(N/10)),
                      normed=True, histtype=u'step')
plt.savefig(date + "monte_carlo pwv" + ".pdf")
plt.grid()
plt.show()
print("Mean value for pwv = ", m_pwv)
print("Standard deviation for pmv = ", st_pwv)

m_pfe = np.mean(pfe_mc)
st_pfe = np.std(pfe_mc)

plt.figure(7)
n, bins, _ = plt.hist(pfe_mc, 
                      bins = np.linspace(m_pfe-3*st_pfe, m_pfe+3*st_pfe, int(N/10)),
                      normed=True, histtype=u'step')
plt.savefig(date + " monte_carlo pfe" + ".pdf")
plt.grid()
plt.show()
print("Mean value for pfe = ", m_pfe)
print("Standard deviation for pfe = ", st_pfe)
"""
#### Problem description

It should create pdf files with graphs but it returns an error 


#### Expected Output
graph output of monte carlo analysis 

#### Output of ``pd.show_versions()``



  File "C:\Users\User\Anaconda3\lib\site-packages\pandas\io\excel\_base.py", line 306, in read_excel
    "read_excel() got an unexpected keyword argument " "`{}`".format(arg)

TypeError: read_excel() got an unexpected keyword argument `parse_cols`
[paste the output of ``pd.show_versions()`` here below this line]

