"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:178: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n",
"/var/folders/9r/fngx7sv11bl1k4rvtyflv1pw0000gn/T/ipykernel_65183/953859291.py:168: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`\n",
" df[str(totalcars)] = \"\" # membuat kolom baru untuk mobil baru yang tercatat\n"
"Cell \u001b[0;32mIn[18], line 123\u001b[0m\n\u001b[1;32m 120\u001b[0m oldcxcy \u001b[38;5;241m=\u001b[39m df\u001b[38;5;241m.\u001b[39miloc[\u001b[38;5;28mint\u001b[39m(framenumber \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)][\u001b[38;5;28mstr\u001b[39m(carids[j])]\n\u001b[1;32m 122\u001b[0m \u001b[38;5;66;03m# mengambil centroid dari frame sekarang yang tidak selalu sesuai dengan centroid dari frame sebelumnya\u001b[39;00m\n\u001b[0;32m--> 123\u001b[0m curcxcy \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mcxx\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcyy\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m oldcxcy: \u001b[38;5;66;03m# jika centroid dari frame sebelumnya kosong karena mobil keluar layar\u001b[39;00m\n\u001b[1;32m 127\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m \u001b[38;5;66;03m# lanjutkan ke id mobil selanjutnya\u001b[39;00m\n",