From cb6b0a17137bd7f637706fb3cb6f3535cfc2cb06 Mon Sep 17 00:00:00 2001 From: mandeepbhutani Date: Sat, 12 Mar 2016 21:58:38 -0600 Subject: [PATCH] CLN GH10559 Rename sheetname variable to sheet_name for consistency --- pandas/io/excel.py | 48 +++++++++++++++++------------------ pandas/io/tests/test_excel.py | 24 +++++++++--------- 2 files changed, 36 insertions(+), 36 deletions(-) diff --git a/pandas/io/excel.py b/pandas/io/excel.py index 5656c360b3990..6fd7b1c362975 100644 --- a/pandas/io/excel.py +++ b/pandas/io/excel.py @@ -72,7 +72,7 @@ def get_writer(engine_name): raise ValueError("No Excel writer '%s'" % engine_name) -def read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, +def read_excel(io, sheet_name=0, header=0, skiprows=None, skip_footer=0, index_col=None, names=None, parse_cols=None, parse_dates=False, date_parser=None, na_values=None, thousands=None, convert_float=True, has_index_names=None, converters=None, @@ -86,7 +86,7 @@ def read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, The string could be a URL. Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is expected. For instance, a local file could be file://localhost/path/to/workbook.xlsx - sheetname : string, int, mixed list of strings/ints, or None, default 0 + sheet_name : string, int, mixed list of strings/ints, or None, default 0 Strings are used for sheet names, Integers are used in zero-indexed sheet positions. @@ -162,14 +162,14 @@ def read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, Returns ------- parsed : DataFrame or Dict of DataFrames - DataFrame from the passed in Excel file. See notes in sheetname + DataFrame from the passed in Excel file. See notes in sheet_name argument for more information on when a Dict of Dataframes is returned. """ if not isinstance(io, ExcelFile): io = ExcelFile(io, engine=engine) return io._parse_excel( - sheetname=sheetname, header=header, skiprows=skiprows, + sheet_name=sheet_name, header=header, skiprows=skiprows, index_col=index_col, parse_cols=parse_cols, parse_dates=parse_dates, date_parser=date_parser, na_values=na_values, thousands=thousands, convert_float=convert_float, has_index_names=has_index_names, @@ -226,7 +226,7 @@ def __init__(self, io, **kwds): raise ValueError('Must explicitly set engine if not passing in' ' buffer or path for io.') - def parse(self, sheetname=0, header=0, skiprows=None, skip_footer=0, + def parse(self, sheet_name=0, header=0, skiprows=None, skip_footer=0, index_col=None, parse_cols=None, parse_dates=False, date_parser=None, na_values=None, thousands=None, convert_float=True, has_index_names=None, @@ -238,7 +238,7 @@ def parse(self, sheetname=0, header=0, skiprows=None, skip_footer=0, docstring for more info on accepted parameters """ - return self._parse_excel(sheetname=sheetname, header=header, + return self._parse_excel(sheet_name=sheet_name, header=header, skiprows=skiprows, index_col=index_col, has_index_names=has_index_names, @@ -285,7 +285,7 @@ def _excel2num(x): else: return i in parse_cols - def _parse_excel(self, sheetname=0, header=0, skiprows=None, skip_footer=0, + def _parse_excel(self, sheet_name=0, header=0, skiprows=None, skip_footer=0, index_col=None, has_index_names=None, parse_cols=None, parse_dates=False, date_parser=None, na_values=None, thousands=None, convert_float=True, @@ -370,29 +370,29 @@ def _parse_cell(cell_contents, cell_typ): ret_dict = False - # Keep sheetname to maintain backwards compatibility. - if isinstance(sheetname, list): - sheets = sheetname + # Keep sheet_name to maintain backwards compatibility. + if isinstance(sheet_name, list): + sheets = sheet_name ret_dict = True - elif sheetname is None: + elif sheet_name is None: sheets = self.sheet_names ret_dict = True else: - sheets = [sheetname] + sheets = [sheet_name] # handle same-type duplicates. sheets = list(set(sheets)) output = {} - for asheetname in sheets: + for a_sheet_name in sheets: if verbose: - print("Reading sheet %s" % asheetname) + print("Reading sheet %s" % a_sheet_name) - if isinstance(asheetname, compat.string_types): - sheet = self.book.sheet_by_name(asheetname) + if isinstance(a_sheet_name, compat.string_types): + sheet = self.book.sheet_by_name(a_sheet_name) else: # assume an integer if not a string - sheet = self.book.sheet_by_index(asheetname) + sheet = self.book.sheet_by_index(a_sheet_name) data = [] should_parse = {} @@ -409,7 +409,7 @@ def _parse_cell(cell_contents, cell_typ): data.append(row) if sheet.nrows == 0: - output[asheetname] = DataFrame() + output[a_sheet_name] = DataFrame() continue if com.is_list_like(header) and len(header) == 1: @@ -461,18 +461,18 @@ def _parse_cell(cell_contents, cell_typ): squeeze=squeeze, **kwds) - output[asheetname] = parser.read() - if not squeeze or isinstance(output[asheetname], DataFrame): - output[asheetname].columns = output[ - asheetname].columns.set_names(header_names) + output[a_sheet_name] = parser.read() + if not squeeze or isinstance(output[a_sheet_name], DataFrame): + output[a_sheet_name].columns = output[ + a_sheet_name].columns.set_names(header_names) except StopIteration: # No Data, return an empty DataFrame - output[asheetname] = DataFrame() + output[a_sheet_name] = DataFrame() if ret_dict: return output else: - return output[asheetname] + return output[a_sheet_name] @property def sheet_names(self): diff --git a/pandas/io/tests/test_excel.py b/pandas/io/tests/test_excel.py index b8d61047a7b6d..d109b0a20b698 100644 --- a/pandas/io/tests/test_excel.py +++ b/pandas/io/tests/test_excel.py @@ -360,16 +360,16 @@ def test_reader_converters(self): tm.assert_frame_equal(actual, expected) def test_reading_all_sheets(self): - # Test reading all sheetnames by setting sheetname to None, + # Test reading all sheet_names by setting sheet_name to None, # Ensure a dict is returned. # See PR #9450 basename = 'test_multisheet' - dfs = self.get_exceldf(basename, sheetname=None) + dfs = self.get_exceldf(basename, sheet_name=None) expected_keys = ['Alpha', 'Beta', 'Charlie'] tm.assert_contains_all(expected_keys, dfs.keys()) def test_reading_multiple_specific_sheets(self): - # Test reading specific sheetnames by specifying a mixed list + # Test reading specific sheet_names by specifying a mixed list # of integers and strings, and confirm that duplicated sheet # references (positions/names) are removed properly. # Ensure a dict is returned @@ -377,17 +377,17 @@ def test_reading_multiple_specific_sheets(self): basename = 'test_multisheet' # Explicitly request duplicates. Only the set should be returned. expected_keys = [2, 'Charlie', 'Charlie'] - dfs = self.get_exceldf(basename, sheetname=expected_keys) + dfs = self.get_exceldf(basename, sheet_name=expected_keys) expected_keys = list(set(expected_keys)) tm.assert_contains_all(expected_keys, dfs.keys()) assert len(expected_keys) == len(dfs.keys()) def test_reading_all_sheets_with_blank(self): - # Test reading all sheetnames by setting sheetname to None, + # Test reading all sheet_names by setting sheet_name to None, # In the case where some sheets are blank. # Issue #11711 basename = 'blank_with_header' - dfs = self.get_exceldf(basename, sheetname=None) + dfs = self.get_exceldf(basename, sheet_name=None) expected_keys = ['Sheet1', 'Sheet2', 'Sheet3'] tm.assert_contains_all(expected_keys, dfs.keys()) @@ -488,7 +488,7 @@ def test_read_xlrd_Book(self): result = read_excel(xl, "SheetA") tm.assert_frame_equal(df, result) - result = read_excel(book, sheetname="SheetA", engine="xlrd") + result = read_excel(book, sheet_name="SheetA", engine="xlrd") tm.assert_frame_equal(df, result) @tm.network @@ -546,9 +546,9 @@ def test_creating_and_reading_multiple_sheets(self): _skip_if_no_xlwt() _skip_if_no_openpyxl() - def tdf(sheetname): + def tdf(sheet_name): d, i = [11, 22, 33], [1, 2, 3] - return DataFrame(d, i, columns=[sheetname]) + return DataFrame(d, i, columns=[sheet_name]) sheets = ['AAA', 'BBB', 'CCC'] @@ -557,9 +557,9 @@ def tdf(sheetname): with ensure_clean(self.ext) as pth: with ExcelWriter(pth) as ew: - for sheetname, df in iteritems(dfs): - df.to_excel(ew, sheetname) - dfs_returned = read_excel(pth, sheetname=sheets) + for sheet_name, df in iteritems(dfs): + df.to_excel(ew, sheet_name) + dfs_returned = read_excel(pth, sheet_name=sheets) for s in sheets: tm.assert_frame_equal(dfs[s], dfs_returned[s])