def select_index(self, compare, result='boolean'):
"""
Finds the elements in the index that match the compare parameter and returns either a list of the values that
match, of a boolean list the length of the index with True to each index that matches. If the indexes are
tuples then the compare is a tuple where None in any field of the tuple will be treated as "*" and match all
values.
:param compare: value to compare as a singleton or tuple
:param result: 'boolean' = returns a list of booleans, 'value' = returns a list of index values that match
:return: list of booleans or values
"""
if isinstance(compare, tuple):
# this crazy list comprehension will match all the tuples in the list with None being an * wildcard
booleans = [
all([(compare[i] == w if compare[i] is not None else True)
for i, w in enumerate(v)])
for x, v in enumerate(self._index)
]
else:
booleans = [False] * len(self._index)
if self._sort:
booleans[sorted_index(self._index, compare)] = True
else:
booleans[self._index.index(compare)] = True
if result == 'boolean':
return booleans
elif result == 'value':
return list(compress(self._index, booleans))
else:
raise ValueError(
'only valid values for result parameter are: boolean or value.'
)
def select_index(self, compare, result='boolean'):
"""
Finds the elements in the index that match the compare parameter and returns either a list of the values that
match, of a boolean list the length of the index with True to each index that matches. If the indexes are
tuples then the compare is a tuple where None in any field of the tuple will be treated as "*" and match all
values.
:param compare: value to compare as a singleton or tuple
:param result: 'boolean' = returns a list of booleans, 'value' = returns a list of index values that match
:return: list of booleans or values
"""
if isinstance(compare, tuple):
# this crazy list comprehension will match all the tuples in the list with None being an * wildcard
booleans = [all([(compare[i] == w if compare[i] is not None else True) for i, w in enumerate(v)])
for x, v in enumerate(self._index)]
else:
booleans = [False] * len(self._index)
if self._sort:
booleans[sorted_index(self._index, compare)] = True
else:
booleans[self._index.index(compare)] = True
if result == 'boolean':
return booleans
elif result == 'value':
return list(compress(self._index, booleans))
else:
raise ValueError('only valid values for result parameter are: boolean or value.')
def get_rows(self, indexes, as_list=False):
"""
For a list of indexes return the values of the indexes in that column.
:param indexes: either a list of index values or a list of booleans with same length as all indexes
:param as_list: if True return a list, if False return Series
:return: Series if as_list if False, a list if as_list is True
"""
if all([isinstance(i, bool) for i in indexes]): # boolean list
if len(indexes) != len(self._index):
raise ValueError(
'boolean index list must be same size of existing index')
if all(indexes): # the entire column
data = self._data
index = self._index
else:
data = list(compress(self._data, indexes))
index = list(compress(self._index, indexes))
else: # index values list
locations = [sorted_index(self._index, x) for x in indexes] if self._sort \
else [self._index.index(x) for x in indexes]
data = [self._data[i] for i in locations]
index = [self._index[i] for i in locations]
return data if as_list else Series(data=data,
index=index,
data_name=self._data_name,
index_name=self._index_name,
sort=self._sort,
dropin=self._dropin)
def get_cell(self, index):
"""
For a single index and return the value
:param index: index value
:return: value
"""
i = sorted_index(self._index, index) if self._sort else self._index.index(index)
return self._data[i]
def get_cell(self, index):
"""
For a single index and return the value
:param index: index value
:return: value
"""
i = sorted_index(self._index,
index) if self._sort else self._index.index(index)
return self._data[i]
def _slice_index(self, slicer):
try:
start_index = sorted_index(self._index, slicer.start) if self._sort else self._index.index(slicer.start)
except ValueError:
raise IndexError('start of slice not in the index')
try:
end_index = sorted_index(self._index, slicer.stop) if self._sort else self._index.index(slicer.stop)
except ValueError:
raise IndexError('end of slice not in the index')
if end_index < start_index:
raise IndexError('end of slice is before start of slice')
pre_list = [False] * start_index
mid_list = [True] * (end_index - start_index + 1)
post_list = [False] * (len(self._index) - 1 - end_index)
pre_list.extend(mid_list)
pre_list.extend(post_list)
return pre_list
def set_rows(self, index, values=None):
"""
Set rows to a single value or list of values. If any of the index values are not in the current indexes
then a new row will be created.
:param index: list of index values or list of booleans. If a list of booleans then the list must be the same\
length as the Series
:param values: either a single value or a list. The list must be the same length as the index list if the index\
list is values, or the length of the True values in the index list if the index list is booleans
:return: nothing
"""
if all([isinstance(i, bool) for i in index]): # boolean list
if not isinstance(
values, (list, blist)
): # single value provided, not a list, so turn values into list
values = [values for x in index if x]
if len(index) != len(self._index):
raise ValueError(
'boolean index list must be same size of existing index')
if len(values) != index.count(True):
raise ValueError(
'length of values list must equal number of True entries in index list'
)
indexes = [i for i, x in enumerate(index) if x]
for x, i in enumerate(indexes):
self._data[i] = values[x]
else: # list of index
if not isinstance(
values, (list, blist)
): # single value provided, not a list, so turn values into list
values = [values for _ in index]
if len(values) != len(index):
raise ValueError(
'length of values and index must be the same.')
# insert or append indexes as needed
if self._sort:
exists_tuples = list(
zip(*[sorted_exists(self._index, x) for x in index]))
exists = exists_tuples[0]
indexes = exists_tuples[1]
if not all(exists):
self._insert_missing_rows(index)
indexes = [sorted_index(self._index, x) for x in index]
else:
try: # all index in current index
indexes = [self._index.index(x) for x in index]
except ValueError: # new rows need to be added
self._add_missing_rows(index)
indexes = [self._index.index(x) for x in index]
for x, i in enumerate(indexes):
self._data[i] = values[x]
def _slice_index(self, slicer):
try:
start_index = sorted_index(
self._index,
slicer.start) if self._sort else self._index.index(
slicer.start)
except ValueError:
raise IndexError('start of slice not in the index')
try:
end_index = sorted_index(
self._index, slicer.stop) if self._sort else self._index.index(
slicer.stop)
except ValueError:
raise IndexError('end of slice not in the index')
if end_index < start_index:
raise IndexError('end of slice is before start of slice')
pre_list = [False] * start_index
mid_list = [True] * (end_index - start_index + 1)
post_list = [False] * (len(self._index) - 1 - end_index)
pre_list.extend(mid_list)
pre_list.extend(post_list)
return pre_list
def set_rows(self, index, values=None):
"""
Set rows to a single value or list of values. If any of the index values are not in the current indexes
then a new row will be created.
:param index: list of index values or list of booleans. If a list of booleans then the list must be the same\
length as the Series
:param values: either a single value or a list. The list must be the same length as the index list if the index\
list is values, or the length of the True values in the index list if the index list is booleans
:return: nothing
"""
if all([isinstance(i, bool) for i in index]): # boolean list
if not isinstance(values, (list, blist)): # single value provided, not a list, so turn values into list
values = [values for x in index if x]
if len(index) != len(self._index):
raise ValueError('boolean index list must be same size of existing index')
if len(values) != index.count(True):
raise ValueError('length of values list must equal number of True entries in index list')
indexes = [i for i, x in enumerate(index) if x]
for x, i in enumerate(indexes):
self._data[i] = values[x]
else: # list of index
if not isinstance(values, (list, blist)): # single value provided, not a list, so turn values into list
values = [values for _ in index]
if len(values) != len(index):
raise ValueError('length of values and index must be the same.')
# insert or append indexes as needed
if self._sort:
exists_tuples = list(zip(*[sorted_exists(self._index, x) for x in index]))
exists = exists_tuples[0]
indexes = exists_tuples[1]
if not all(exists):
self._insert_missing_rows(index)
indexes = [sorted_index(self._index, x) for x in index]
else:
try: # all index in current index
indexes = [self._index.index(x) for x in index]
except ValueError: # new rows need to be added
self._add_missing_rows(index)
indexes = [self._index.index(x) for x in index]
for x, i in enumerate(indexes):
self._data[i] = values[x]
def delete(self, indexes):
"""
Delete rows from the DataFrame
:param indexes: either a list of values or list of booleans for the rows to delete
:return: nothing
"""
indexes = [indexes] if not isinstance(indexes, (list, blist)) else indexes
if all([isinstance(i, bool) for i in indexes]): # boolean list
if len(indexes) != len(self._index):
raise ValueError('boolean indexes list must be same size of existing indexes')
indexes = [i for i, x in enumerate(indexes) if x]
else:
indexes = [sorted_index(self._index, x) for x in indexes] if self._sort \
else [self._index.index(x) for x in indexes]
indexes = sorted(indexes, reverse=True) # need to sort and reverse list so deleting works
for i in indexes:
del self._data[i]
# now remove from index
for i in indexes:
del self._index[i]
def get_rows(self, indexes, as_list=False):
"""
For a list of indexes return the values of the indexes in that column.
:param indexes: either a list of index values or a list of booleans with same length as all indexes
:param as_list: if True return a list, if False return Series
:return: Series if as_list if False, a list if as_list is True
"""
if all([isinstance(i, bool) for i in indexes]): # boolean list
if len(indexes) != len(self._index):
raise ValueError('boolean index list must be same size of existing index')
if all(indexes): # the entire column
data = self._data
index = self._index
else:
data = list(compress(self._data, indexes))
index = list(compress(self._index, indexes))
else: # index values list
locations = [sorted_index(self._index, x) for x in indexes] if self._sort \
else [self._index.index(x) for x in indexes]
data = [self._data[i] for i in locations]
index = [self._index[i] for i in locations]
return data if as_list else Series(data=data, index=index, data_name=self._data_name,
index_name=self._index_name, sort=self._sort)