Вы можете уменьшить время для результата StreamTokenizer
, используя BufferedReader
:
Reader r = null;
try {
r = new BufferedReader(new FileReader(file));
final StreamTokenizer st = new StreamTokenizer(r);
...
} finally {
if (r != null)
r.close();
}
Кроме того, не забудьте закрыть ваши файлы, как я показал здесь.
Вы также можете сэкономить время, используя пользовательский токенизатор для ваших целей:
public class CustomTokenizer {
private final Reader r;
public CustomTokenizer(final Reader r) {
this.r = r;
}
public int nextInt() throws IOException {
int i = r.read();
if (i == -1)
throw new EOFException();
char c = (char) i;
// Skip any whitespace
while (c == ' ' || c == '\n' || c == '\r') {
i = r.read();
if (i == -1)
throw new EOFException();
c = (char) i;
}
int result = (c - '0');
while ((i = r.read()) >= 0) {
c = (char) i;
if (c == ' ' || c == '\n' || c == '\r')
break;
result = result * 10 + (c - '0');
}
return result;
}
}
Не забудьте использовать для этого BufferedReader
. Этот пользовательский токенизатор предполагает, что входные данные всегда полностью действительны и содержат только пробелы, новые строки и цифры.
Если вы много читаете эти результаты, и эти результаты мало меняются, вы, вероятно, должны сохранить массив и следить за последним измененным временем файла. Затем, если файл не изменился, просто используйте кешированную копию массива, и это значительно ускорит результаты. Например:
public class ArrayRetriever {
private File inputFile;
private long lastModified;
private int[] lastResult;
public ArrayRetriever(File file) {
this.inputFile = file;
}
public int[] getResult() {
if (lastResult != null && inputFile.lastModified() == lastModified)
return lastResult;
lastModified = inputFile.lastModified();
// do logic to actually read the file here
lastResult = array; // the array variable from your examples
return lastResult;
}
}
Не используйте его, лучше использовать loc
для согласованности:
df = pd.DataFrame({'A':[1,2,3]}, index=[0,1,2])
print (df.loc[0:2])
A
0 1
1 2
2 3
a = datetime.datetime(2000,1,1)
b = datetime.datetime(2000,1,2)
c = datetime.datetime(2000,1,3)
df = pd.DataFrame({'A':[1,2,3]}, index = [a,b,c])
print (df.loc[a:b])
A
2000-01-01 1
2000-01-02 2
Причина, по которой последняя строка опущена, возможна в документах :
С DataFrame, разрезание внутри [] разрезает строки. Это обеспечивается в основном для удобства, поскольку это такая распространенная операция.
blockquote>print (df[0:2]) A 0 1 1 2
Для выбора по дате и времени используется точное индексирование :
... Напротив, индексирование с помощью объектов Timestamp или datetime является точным, поскольку объекты имеют точное значение. Они также следуют семантике включения обеих конечных точек .
BLOCKQUOTE>
Хорошо, чтобы сначала это понять, давайте запустим эксперимент
import pandas as pd
import datetime as dt
a = dt.datetime(2000,1,1)
b = dt.datetime(2000,1,2)
c = dt.datetime(2000,1,3)
df = pd.DataFrame({'A':[4,5,6]}, index=[a,b,c])
Теперь давайте воспользуемся
df2[0:2]
, что дает нам
A
2000-01-01 1
2000-01-02 2
[1111 ] Теперь это поведение согласуется с Python и нарезкой списка, но если вы используете df[a:c]
Вы получите
A
2000-01-01 1
2000-01-02 2
2000-01-03 3
, это потому, что df[a:c]
переопределяет метод нарезки списка по умолчанию в качестве индексов не соответствуют целым числам, и в функции, написанной на Pandas, которая также включает в себя последний элемент, поэтому, если ваши индексы были целыми числами, pandas по умолчанию использует встроенную нарезку, тогда как если они не являются целыми числами, этот эффект наблюдается, как уже упоминалось в ответ от Jezrael, лучше использовать loc
, так как это имеет больше согласованности по всем направлениям.