def day_rate(rowNum: int, colNum: int, sheet: xlrd.sheet.Sheet) -> list: """ 日收益率函数 :param rowNum: :param colNum: :param sheet: :return: """ # 账户日收益率 day_rate_list = [] # 股票数 stock_num = colNum - 3 for i in range(2, rowNum): cnt = 0 sum_x = 0.0 avg_x = 0.0 # colNum - 2 股票数读取控制 for j in range(1, colNum - 2): var_type = sheet.cell(i, j).ctype var = sheet.cell(i, j).value if var_type and var: sum_x = sum_x + sheet.cell(i, j).value avg_x = sum_x / stock_num day_rate_list.append(avg_x) return day_rate_list
def __LoadSheet( self, sheet: xlrd.sheet.Sheet ) -> Tuple[PaymentsData, PaymentsDataErrors]: payments_data = PaymentsData(self.config) payments_data_err = PaymentsDataErrors() # Get column indexes email_col_idx = self._ColumnToIndex( self.config.GetValue(BotConfigTypes.PAYMENT_EMAIL_COL)) user_col_idx = self._ColumnToIndex( self.config.GetValue(BotConfigTypes.PAYMENT_USER_COL)) expiration_col_idx = self._ColumnToIndex( self.config.GetValue(BotConfigTypes.PAYMENT_EXPIRATION_COL)) # Read each row for i in range(sheet.nrows): # Skip header (first row) if i > 0: # Get cell values email = str(sheet.cell_value(i, email_col_idx)).strip() user = User.FromString( self.config, str(sheet.cell_value(i, user_col_idx)).strip()) expiration = sheet.cell_value(i, expiration_col_idx) # Skip invalid users if user.IsValid(): self.__AddPayment(i + 1, payments_data, payments_data_err, email, user, expiration) return payments_data, payments_data_err
def _get_sheet_data(sh: xlrd.sheet.Sheet, datemode: int) -> pd.DataFrame: """Process a Microsoft Excel sheet, returning a Pandas DataFrame Args: sh: the sheet to be processed datemode: integer to pass as argument to _get_row_data() Returns: pd.DataFrame: all data in the given sheet with normalized names and types """ maturity = sh.cell_value(0, 1) if isinstance(maturity, float): maturity = datetime.datetime(*xlrd.xldate_as_tuple(maturity, datemode)) else: maturity = datetime.datetime.strptime(maturity, "%d/%m/%Y") bond, series = sh.name.rsplit(" ", maxsplit=1) bond = BONDS["aliases"][bond.replace("-", "").lower()] # Fix bonds names header = tuple(c.value for c in sh.row(1) if c.value != "") rows = (r for r in itertools.islice(sh.get_rows(), 2, None) if r[1].ctype != 0 and r[1].value != "") data = (_get_row_data(row, datemode) for row in rows) df = pd.DataFrame.from_records(data, columns=header) df = df.assign( MaturityDate=maturity, BondCode=sh.name, BondName=bond, BondSeries=series, ) return df
def _read_sheet(sheet: xlrd.sheet.Sheet, exercise_name: str) -> List[Record]: """ Return all candidate records in given sheet """ records = [] # 5 is the candidate count for candidate_index in range(5): row = 5 + candidate_index * 2 evaluator_name = sheet.cell_value(5, 1) candidate_name = sheet.cell_value(row, 4).strip() team_name = _sanitize_team(sheet.cell_value(5, 2)) if not candidate_name: continue if candidate_name and not team_name: raise Exception("Error: No team name") if team_name and not evaluator_name: raise Exception("Error: No evaluator name") evaluation = Evaluation(evaluator_name=evaluator_name, exercise_name=exercise_name, learning_ability=_read_attribute( sheet, row, 5), personal=_read_attribute(sheet, row, 10), interpersonal=_read_attribute(sheet, row, 15), leader=_read_attribute(sheet, row, 20), summary=_read_attribute(sheet, row, 25)) records.append(Record(candidate_name, team_name, evaluation)) return records
def _parse_oakland_sheet(sheet: xlrd.sheet.Sheet, datemode: int): """Parse a single sheet of the Oakland excel file into a dataframe. Parameters ---------- sheet The Sheet object from the Book of the Oakland container moves. datemode The Book's datemode value (usually 0 or 1). Returns ------- pandas.DataFrame The DataFrame containing all the sheets concatenated together. """ # Assume the first 6 rows are just header, and verify that the columns are in order # date, full imports, full exports, total full, empty imports, empty expots, total empty # grand total keys = _verify_oakland_sheet(sheet) nrow = len(sheet.col(0)) dates = [] data = {k: [] for k in keys} for irow in range(3, nrow): year = sheet.cell_value(irow, 0) month = sheet.cell_value(irow, 1) if isinstance(month, str) and month == 'Annual Total': continue this_date = pd.to_datetime('{} {:.0f}'.format(month, year)) if this_date < pd.Timestamp(1990, 1, 1) or this_date > pd.Timestamp.now(): # This may catch some bad date parsing. I haven't had a problem with this, but want to check (in case they # change the format unexpectedly). raise ExcelParsingError('Unexpected date parsed (pre-1990)') dates.append(this_date) for k, icol in keys.items(): val = sheet.cell_value(irow, icol) if isinstance(val, str) and len(val) == 0: data[k].append(np.nan) else: data[k].append(val) dates = pd.DatetimeIndex(dates) colname_mapping = { 'Import Full': 'Full Imports', 'Export Full': 'Full Exports', 'Import Empty': 'Empty Imports', 'Export Empty': 'Empty Exports', 'Grand Total': 'Total TEUs' } return pd.DataFrame(data, index=dates).drop( columns=['Total Full', 'Total Empty']).rename(columns=colname_mapping)
def _get_sheet_data(self, sheet: xlrd.sheet.Sheet, col: int) -> (str, str, str, str): proto_type = sheet.cell_value(0, col) define_type = sheet.cell_value(1, col) # 定义的类型 name = sheet.cell_value(2, col) # 字段名 comment = str(sheet.cell_value(4, col)).replace('\n', '').replace('\r', '') # 注释 if comment != '': comment = f' @{comment}' return proto_type, define_type, name, comment
def read_firm(firm_sheet: xlrd.sheet.Sheet): """ Note row & column is 0-index based :param firm_sheet: :return: """ # get firm name firm_name = firm_sheet.cell(7, 1).value # selected data column, 0 based index if firm_sheet.ncols == 10: # [存货编号, 存货全名, 采购数量, 价税合计] selected_columns = [1, 2, 3, 6] elif firm_sheet.ncols == 11: selected_columns = [1, 2, 3, 4, 7] else: print(firm_sheet.ncols, firm_sheet.name) raise Exception("Unsupported data sheet format") rows = [] for i in range(20, firm_sheet.nrows): row = [firm_name] for j in selected_columns: entry = firm_sheet.cell(i, j).value try: entry = float(entry) except Exception: pass row.append(entry) has_empty_data = False # check empty entry in data for k in [-2, -1]: if row[k] == '': has_empty_data = True break if has_empty_data: continue # print(row) row.append(round(row[-1] / row[-2], 2)) # 含税单价 = 价税合计 / 采购数量 rows.append(row) data_frame = pd.DataFrame(rows, columns=["公司名称"] + [firm_sheet.cell(19, i).value for i in selected_columns] + ["含税单价"]) print(data_frame) if "基本单位" not in data_frame.columns: data_frame.insert(3, "基本单位", np.nan, True) return data_frame
def get_head_line(sheet_data: xlrd.sheet.Sheet): """ 获取第一行cell数据列表 :param sheet_data: :return: """ return sheet_data.row_values(0, 0, sheet_data.ncols)
def _parse_target(self, sheet: xlrd.sheet.Sheet, key_col: dict, start_row: int, end_row: int, name: str): ''' :param sheet: sheet to be parsed :param key_col: map key_name to column order ex: {"ip": 1, "username": 2} :param start_row: set to 1 for single thread :param end_row: set to sheet.nrows for single thread :return: Flag: Bool, columns_processes: int or error msg ''' print( "thread parse target started. start_row: {}, end_row: {}, name: {}" .format(start_row, end_row, name)) try: thread_result = [] for row_no in range(start_row, end_row): row_dict = {} for key in key_col: row_dict[key] = sheet.cell_value(row_no, key_col[key]) thread_result.append(row_dict) self.result_lock.acquire() self.result += thread_result print("thread {} result:\n{}\n\n".format(name, thread_result)) self.result_lock.release() self.thread_state[name] = True return True, end_row - start_row except Exception as e: self.result_lock.acquire() self.thread_state[name] = True self.result_lock.release() return False, e
def build_choices(self, sheet: xlrd.sheet.Sheet, datemode: int) -> None: """Parse the tab of ODK choices. This function modifies the instance attributes `header` and `choices` if there is something stored in the tab of ODK chocies. Args: sheet: The xlrd sheet object for this sheet datemode: The xlrd datemode for the workbook """ _choices_dict = defaultdict(list) if sheet is not None: try: self.header = self.get_header(sheet, datemode) for i, row in enumerate(sheet.get_rows()): if i == 0: continue row_values = [ self.cell_to_value(cell, datemode) for cell in row ] row_dict = {k: v for k, v in zip(self.header, row_values)} row_list_name = row_dict['list_name'] row_name = row_dict['name'] if str(row_list_name) and str(row_name): choice_row = XlsFormRow(i, row_name, self.header, row_values, row_dict) _choices_dict[row_list_name].append(choice_row) except IndexError: # No header row found. Then no choices. pass for name, choices in _choices_dict.items(): choice_list = ChoiceList(name, choices, sheet.name) self.choices[name] = choice_list
def _init_data(self, sheet: xlrd.sheet.Sheet): flg_first_row = True for row in sheet.get_rows(): # skip the first row if flg_first_row: flg_first_row = False continue new_row = {} for i in range(len(self.fields)): # to prevent bug when there is an empty cell if i < len(row): if row[i].ctype == 3: c = Cell(datetime.datetime(*xlrd.xldate_as_tuple(row[i].value, sheet.book.datemode))) c.style.num_format = 'yyyy/mm/dd' new_row[self.fields[i]] = c else: if isinstance(row[i].value, str): if row[i].value.isnumeric(): print('Warning: Found a number stored in string format, converting...') new_row[self.fields[i]] = Cell(float(row[i].value)) new_row[self.fields[i]] = Cell(row[i].value) else: new_row[self.fields[i]] = '' self.data_rows.append(new_row)
def _verify_oakland_sheet(sheet: xlrd.sheet.Sheet): """Check that a sheet in the Oakland container workbook is laid out as expected. Raises `ExcelParsingError` if not. """ keys = dict() reasons = [] _cols = ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H') # row index, column index, expected contents, whether this column is a column name for the dataframe checks = [(2, 0, 'Year', False), (2, 1, 'Month', False), (2, 2, 'Import Full', True), (2, 3, 'Export Full', True), (2, 4, 'Total Full', True), (2, 5, 'Import Empty', True), (2, 6, 'Export Empty', True), (2, 7, 'Total Empty', True), (2, 8, 'Grand Total', True)] for r, c, val, is_key in checks: # Replace any whitespace with a single space (e.g. newlines) sheet_val = re.sub(r'\s+', ' ', sheet.cell_value(r, c)) if sheet_val != val: msg = '{}{} != {}'.format(_cols[c], r + 1, val) reasons.append(msg) elif is_key: keys[sheet_val] = c if len(reasons) > 0: msg = 'Unexpected sheet format ({})'.format(', '.join(reasons)) raise ExcelParsingError(msg) else: return keys
def find_in_sheet(val, sheet: xlrd.sheet.Sheet) -> Tuple[int, int]: """Return a tuple containing the (row, col) of first match searching row 0, then row 1, etc.""" for row in range(sheet.nrows): for col in range(sheet.ncols): if sheet.cell_value(row, col) == val: return row, col raise LookupError(f'Value {val} not found in sheet {sheet}')
def get_table_name(sheet_data: xlrd.sheet.Sheet): """ 直接获取table_name。表格的第一行第一列 :param sheet_data: :return: """ cell_content = sheet_data.cell_value(0, 0) return cell_content.splitlines()[0]
def _get_current_date_by_field(self, field: dict, sheet: xlrd.sheet.Sheet, row: int) -> str: date = sheet.name if re.search(NIGHT_PATTERN, date): date = date.split('-') time = sheet.cell(rowx=row, colx=field['column_number']).value if time == '': return '' time = self._get_correct_time(time) if datetime.datetime.strptime(time, TIME_PATTERN).time() >= NIGHT_SHIFT: if date[1].split( '.')[0] == '01' and date[1].split('.')[1] != '01': # TODO: make its better in the future date = date[0] + '.' + '.'.join( date[1].split('.')[1:]) + ' ' + time date = date[:3] + str(int(date[3:5]) - 1) + date[5:] else: date = date[0] + '.' + '.'.join( date[1].split('.')[1:]) + ' ' + time try: return datetime.datetime.strptime(date, '%d.%m.%y %H:%M') except ValueError: # in this case we resolve problem with mismatch of number of month and number of days self._logger.warning( 'There are conformity of month and days, check corrects of value' ) date = date[:3] + str(int(date[3:5]) - 1) + date[5:] return datetime.datetime.strptime(date, '%d.%m.%y %H:%M') else: date = date[1] + ' ' + time return datetime.datetime.strptime(date, '%d.%m.%y %H:%M') if re.search(DAY_PATTERN, date): time = sheet.cell(rowx=row, colx=field['column_number']).value if not time: return '' time = self._get_correct_time(time) date = date + ' ' + time return datetime.datetime.strptime(date, '%d.%m.%y %H:%M') raise TimePatternError( 'There is no such time pattern: {}'.format(date))
def _extract_data(sheet: xlrd.sheet.Sheet) -> DataTable: """ Helper function that extracts cell values from an xlrd sheet into a plain array """ cols = sheet.ncols rows = sheet.nrows return [[sheet.cell_value(row, col) for col in range(0, cols)] for row in range(0, rows)]
def get_tid_list(sheet_data: xlrd.sheet.Sheet): """ 获取tid列表 :param sheet_data: :return: """ value_list = sheet_data.col_values(0, 2, sheet_data.nrows) for i in range(0, len(value_list)): value_list[i] = int(value_list[i]) return value_list
def load_two_first_columns_preincrement(sheet: xlrd.sheet.Sheet): """Reads dataset with X from two first columns, skips first row :param sheet: xlrd.sheet.Sheet :return: X, y: [], [] """ line_number = 0 line = sheet.row(line_number) number_of_columns = len(line) X, y = np.zeros((sheet.nrows, 2)), np.zeros(sheet.nrows, dtype=np.int) while line_number < sheet.nrows - 1: line_number += 1 line = sheet.row(line_number) row = [] for i in range(2): # range(number_of_columns - 1): row.append(float(line[i].value)) X[line_number - 1, :] = row y[line_number - 1] = int(line[number_of_columns - 1].value) return X, y
def get_document_title(workbook: xlrd.book.Book, orderform_sheet: xlrd.sheet.Sheet) -> str: """Get the document title for the order form.""" if "information" in workbook.sheet_names(): information_sheet = workbook.sheet_by_name("information") document_title = information_sheet.row(0)[2].value return document_title document_title = orderform_sheet.row(0)[1].value return document_title
def get_row_values(sheet: xlrd.sheet.Sheet, rowx: int, datemode: int = DEFAULT_DATEMODE) -> tuple: """Get the values from a row in a sheet. Returns: A tuple of cell values. The cell values can be any of str, bool, int, or float. """ row = sheet.row(rowx) values = (Worksheet.cell_to_value(cell, datemode) for cell in row) return tuple(values)
def dataCheck(sheet1: xlrd.sheet.Sheet): checkCmd = True # 行数检查 if sheet1.nrows < 2: print("没数据啊哥") checkCmd = False # 每行数据检查 i = 1 while i < sheet1.nrows: # 第1列 操作类型检查 cmdType = sheet1.row(i)[0] if cmdType.ctype != 2 or int(cmdType.value) not in range(1, 8): # cmdType.value != 1.0 and cmdType.value != 2.0 and cmdType.value != 3.0 # and cmdType.value != 4.0 and cmdType.value != 5.0 and cmdType.value != 6.0): print('第', i + 1, "行,第1列数据有毛病") checkCmd = False # 第2列 内容检查 cmdValue = sheet1.row(i)[1] # 读图点击类型指令,内容必须为字符串类型 if cmdType.value == 1.0 or cmdType.value == 2.0 or cmdType.value == 3.0: if cmdValue.ctype != 1: print('第', i + 1, "行,第2列数据有毛病") checkCmd = False # 输入类型,内容不能为空 if cmdType.value == 4.0: if cmdValue.ctype == 0: print('第', i + 1, "行,第2列数据有毛病") checkCmd = False # 等待类型,内容必须为数字 if cmdType.value == 5.0: if cmdValue.ctype != 2: print('第', i + 1, "行,第2列数据有毛病") checkCmd = False # 滚轮事件,内容必须为数字 if cmdType.value == 6.0: if cmdValue.ctype != 2: print('第', i + 1, "行,第2列数据有毛病") checkCmd = False i += 1 return checkCmd
def transform_data(xlrd_sheet: xlrd.sheet.Sheet) -> io.StringIO: """ Function to transform the data into json and stores the json in a string buffer. The data is written as a list of rows from the excel sheet with the first row as headers. Returns the string buffer. Parameters ---------- data_frame: pd.DataFrame Dataframe object of the excel file. Outputted from the extract_data_from_excel function. Returns ------- string_buffer: StringIO Dataframe is converted into json string, writtern into a string buffer and returned. """ headers, col_idx = [], 0 while True: try: headers.append(xlrd_sheet.cell_value(0, col_idx)) col_idx += 1 except IndexError: break data, row_idx = [], 0 while True: try: data.append({ col: xlrd_sheet.cell_value(col_idx, row_idx) for col_idx, col in enumerate(headers) }) row_idx += 1 except IndexError: break return io.StringIO(json.dumps(data))
def _parse_sheet(self, sheet: xlrd.sheet.Sheet): result = [] index_key_map = {} for col in range(sheet.ncols): key = sheet.cell_value(0, col) if key in self.keys: index_key_map[key] = col if index_key_map: for row_no in range(1, sheet.nrows): row_dict = {} for key in index_key_map: if index_key_map.get(key, None) != None: row_dict[key] = sheet.cell_value( row_no, index_key_map[key]) else: row_dict[key] = None if row_dict: result.append(row_dict) return result else: return []
def parse_head(self, sheet: xlrd.sheet.Sheet): field_name = sheet.row(0) field_type = sheet.row(1) for i in range(0, len(field_name)): fname = field_name[i].value tname = i < len(field_type) and field_type[i].value or '' if tname == 'null' or fname == '': continue ftype = FieldTypeMgr.parse_type_by_name(tname) if ftype == FieldType.E_None: continue cell_head = SheetCellHead() cell_head.set_data(i, fname, ftype) self.sheet_heads.append(cell_head)
def _get_next(self, sheet: xlrd.sheet.Sheet, col: int, max: int = -1) -> int: col = col + 1 if max == -1: max = sheet.ncols if col >= max: return max proto_type = sheet.cell_value(0, col) while self._is_skip_col(proto_type): col = col + 1 if col >= max: break proto_type = sheet.cell_value(0, col) if col >= max: return max else: return col
def get_billing_lines(sheet: xlrd.sheet.Sheet) -> int: """Take an xl sheet with a Hydro One bill as input and return the number of billing lines (accounts)""" lines = 0 try: row, col = find_in_sheet("Line #", sheet) # this cell should be unique except LookupError: raise ValueError( f'{sheet} does not appear to be a Hydro One bill (no "Line #" cell)' ) # find number of lines in bill by walking down row += 1 while sheet.cell_type(row, col) == XLS_FLOAT_TYPE: row += 1 lines += 1 return lines
def get_name_to_tid_dic(sheet_data: xlrd.sheet.Sheet): """ 获取名称到tid的映射,如果没有名称则返回空字典 :param sheet_data: :return: """ head_values = get_head_line(sheet_data) ret_dic = {} tid_list = get_tid_list(sheet_data) for cell_value in head_values: type = get_prop_type(cell_value) if type is Enum_CellType.NAME: col = head_values.index(cell_value) name_list = sheet_data.col_values(col, 2, sheet_data.nrows) for i in range(0, len(name_list)): ret_dic[name_list[i]] = tid_list[i] return ret_dic
def _parse_sheet(self, sheet: xlrd.sheet.Sheet): index_key_map = {} for col in range(sheet.ncols): key = sheet.cell_value(0, col) if key in self.keys: index_key_map[key] = col if self.no_threads == 1: self._parse_target(sheet=sheet, key_col=index_key_map, start_row=1, end_row=sheet.nrows, name="main") return add_rows = (sheet.nrows - 1) % self.no_threads no_rows = sheet.nrows - 1 - add_rows step = int(no_rows / self.no_threads) for i in range(1, no_rows + 1, step): end_row = i + step t = Thread(target=self._parse_target, kwargs={ "sheet": sheet, "key_col": index_key_map, "start_row": i, "end_row": end_row, "name": str(i) }, daemon=True) t.start() self.threads[str(i)] = t if add_rows: print("---------------------add_rows-----------------") t_add = Thread(target=self._parse_target, kwargs={ "sheet": sheet, "key_col": index_key_map, "start_row": no_rows + 1, "end_row": sheet.nrows, "name": "add_rows" }, daemon=True) t_add.start() self.threads[str(sheet.nrows + 1)] = t_add
def get_data_from_worksheet(worksheet: xlrd.sheet.Sheet): """берем матрицу данных из листа таблицы""" num_rows = worksheet.nrows - 1 num_cells = worksheet.ncols - 1 curr_row = -1 data = [] while curr_row < num_rows: row = [] curr_row += 1 curr_cell = -1 while curr_cell < num_cells: curr_cell += 1 cell_value = worksheet.cell_value(curr_row, curr_cell) row.append(cell_value) data.append(row) # если в таблице нет этих элементов значит пользователь пытается использовать другую таблицу if data[0] != ['с', 'по', 'название', 'описание']: return [] return data[1:]
def write_cs(self, sheet: xlrd.sheet.Sheet, sheetname): """ """ output_filename = os.path.normpath('{0}/{1}.cs'.format(self.output_path, sheetname)) with open(output_filename, 'w', encoding='utf-8') as targetf: targetf.write('using System.Collections;\n') targetf.write('using System.Collections.Generic;\n\n') if len(self.namespace) > 0: targetf.write('namespace {0}{1}\n\n'.format(self.namespace, "{")) targetf.write(' public class {0}{1} \n'.format(sheetname, "{")) for r in range(0, sheet.nrows): # write class name for c in range(0, sheet.ncols): # print ("Cell:", sheet.cell_value(rowx=r, colx=c) ) data = sheet.cell_value(rowx=r, colx=c) parts = data.partition('.') data_type = parts[0] data_real = parts[2] # if c == sheet.ncols-1: # sep='\n' if data_type == Excel2Class.TYPE_IARRAY: data_type = 'List<int>' if data_type == Excel2Class.TYPE_FARRAY: data_type = 'List<float>' if data_type == Excel2Class.TYPE_DARRAY: data_type = 'List<double>' if data_type == Excel2Class.TYPE_SARRAY: data_type = 'List<string>' elif data_type == Excel2Class.TYPE_IDIC: data_type = 'Dictionary<int,int>' elif data_type == Excel2Class.TYPE_FDIC: data_type = 'Dictionary<int,float>' elif data_type == Excel2Class.TYPE_DDIC: data_type = 'Dictionary<int,double>' elif data_type == Excel2Class.TYPE_SDIC: data_type = 'Dictionary<int,string>' targetf.write(' public {0} {1};\n'.format(data_type, data_real)) break if len(self.namespace) > 0: targetf.write(' }') targetf.write('\n}')
def write_cs(self, sheet: xlrd.sheet.Sheet, sheetname: str): """ """ output_filename = os.path.normpath('{0}/{1}.cs'.format(self.output_path, sheetname)) with open(output_filename, 'w', encoding='utf-8') as targetf: targetf.write('using System.Collections;\n') targetf.write('using System.Collections.Generic;\n\n') if len(self.namespace) > 0: targetf.write('namespace {0}{1}\n\n'.format(self.namespace, "{")) targetf.write(' public class {0}{1} \n'.format(sheetname, "{")) for r in range(0, sheet.nrows): # write class name for c in range(0, sheet.ncols): # print ("Cell:", sheet.cell_value(rowx=r, colx=c) ) data = sheet.cell_value(rowx=r, colx=c) data.strip() data_type = '' # field type data_real = '' # field name if '.' in data: parts = data.partition('.') # old stype int.id data_type = parts[0] data_real = parts[2] elif ':' in data: parts = data.partition(':') # new stype id:int data_type = parts[2] data_real = parts[0] # print(data_type, data_real) # if c == sheet.ncols-1: # sep='\n' if data_type == Excel2Class.TYPE_INT32: data_type = 'int' if data_type == Excel2Class.TYPE_INT64: data_type = 'System.Int64' if data_type == Excel2Class.TYPE_FLOAT: data_type = 'float' if data_type == Excel2Class.TYPE_DOUBLE: data_type = 'double' if data_type == Excel2Class.TYPE_Bool: data_type = 'bool' if data_type == Excel2Class.TYPE_STRING: data_type = 'string' if data_type == Excel2Class.TYPE_IARRAY or data_type == 'arr': data_type = 'List<int>' if data_type == Excel2Class.TYPE_FARRAY or data_type == 'farr': data_type = 'List<float>' if data_type == Excel2Class.TYPE_DARRAY or data_type == 'darr': data_type = 'List<double>' if data_type == Excel2Class.TYPE_SARRAY or data_type == 'sarr': data_type = 'List<string>' elif data_type == Excel2Class.TYPE_IDIC: data_type = 'Dictionary<int,int>' elif data_type == Excel2Class.TYPE_FDIC: data_type = 'Dictionary<int,float>' elif data_type == Excel2Class.TYPE_DDIC: data_type = 'Dictionary<int,double>' elif data_type == Excel2Class.TYPE_SDIC: data_type = 'Dictionary<int,string>' targetf.write(' public {0} {1};\n'.format(data_type, data_real)) break # only scan the first row if len(self.namespace) > 0: targetf.write(' }') targetf.write('\n}') print('output game info:', output_filename)
def parse_rows(self, sheet: xlrd.sheet.Sheet): for i in range(3, sheet.nrows): row_data = SheetRowData(self.sheet_heads) row_data.parse_row(sheet.row(i)) self.sheet_rows.append(row_data)