Bagaimana Cara Memeriksa Ukuran File dan Folder dengan Python?

Diterbitkan: 2021-06-16

Dalam artikel ini, Anda akan belajar memeriksa ukuran file atau folder dengan Python

Python adalah salah satu bahasa pemrograman yang paling serbaguna. Dengannya, Anda akan dapat membangun dari program CLI (Command-line interface) kecil ke aplikasi web yang kompleks.

Namun, salah satu fitur yang paling diremehkan adalah kemampuan untuk berinteraksi dengan sistem operasi. Mengelola operasi OS dengan Python dapat menghemat banyak waktu Anda saat membuat proses otomatisasi.

Mari kita lihat bagaimana Python berinteraksi dengan OS.

Bagaimana Python berinteraksi dengan OS?

Python berinteraksi dengan Os dengan modul os, sys, path, dan subproses

Tidak ada yang bisa hidup terisolasi dari lingkungan mereka. Itu juga berlaku di Python, di mana terkadang sangat penting untuk berinteraksi dengan sistem operasi untuk menyelesaikan pekerjaan.

Python memiliki beberapa modul yang memungkinkan kita berinteraksi dengan OS. Yang paling banyak digunakan adalah os, sys, pathlib, dan subprocess.

Karena mereka adalah modul built-in, Anda tidak perlu menginstalnya dengan PIP. Anda dapat mengimpor semuanya dengan pernyataan berikut:

 import os import sys import pathlib import subprocess

Daftar di bawah ini menunjukkan fungsi utama dari masing-masing impor ini:

  • Os: Cara portabel menggunakan fungsionalitas khusus sistem (Tergantung pada OS Anda). Ini adalah pilihan yang tepat dalam banyak kasus kecuali Anda membutuhkan sesuatu yang lebih canggih
  • Sys: Parameter dan fungsi khusus sistem. Modul ini menyediakan akses ke variabel dan fungsi interpreter. Modul os berinteraksi dengan sistem operasi dan sys berinteraksi dengan juru bahasa Python
  • Pathlib: Penggunaan jalur lanjutan. Memungkinkan Anda merepresentasikan sistem file sebagai objek, dengan semantik terkait untuk setiap OS.
  • Subproses: Eksekusi dan manajemen subproses langsung dari Python. Itu melibatkan bekerja dengan stdin , stdout , dan kode pengembalian. Anda dapat mempelajarinya lebih lanjut dengan membaca panduan subproses Python kami.

Ada perpustakaan tingkat tinggi yang menyertakan fungsionalitas yang lebih spesifik tergantung pada kebutuhan Anda. Namun, sebagian besar waktu Anda baik-baik saja dengan modul-modul di atas.

Catatan: Sebagian besar fungsi yang disediakan oleh modul ini akan memiliki output yang berbeda tergantung pada OS Anda. Ingatlah bahwa biasanya, yang paling cocok adalah UNIX dan Python.

Sekarang Anda memiliki pemahaman cepat tentang bagaimana Python berinteraksi dengan OS, mari beralih ke metode memeriksa ukuran file dan folder. Semua solusi berikut tersedia dalam ukuran File dan folder di repositori Python GitHub

Menggunakan os.stat().st_size

Dalam metode ini, kita akan menggunakan fungsi stat() dari modul os. Ini mengembalikan banyak informasi tentang jalur tertentu.

Catatan: Fungsi os.path.getsize() juga menyelesaikan pekerjaan. Keuntungan menggunakan os.stat(). st_size adalah tidak mengikuti simlinks.

Sebelum melanjutkan, mari buat file pengujian bernama lorem.txt , di mana kita akan menempelkan beberapa teks bodoh . Kita dapat mengunjungi generator teks Lorem Ipsum dan menempelkan teks tersebut ke dalam file lorem.txt .

Di direktori yang sama, buat file dengan nama method1.py dan paste kode di bawah ini:

 import os size = os.stat('lorem.txt').st_size print(size)

Mari kita uraikan apa yang kita lakukan dengan kode ini:

  • Di baris pertama, kami mengimpor modul os
  • Variabel size berisi ukuran file lorem.txt
    • Fungsi os.stat() mengembalikan banyak info yang terkait dengan file
    • Atribut st_size mewakili ukuran file
  • Kami mencetak variabel ukuran

Coba jalankan skrip Python. Anda akan mendapatkan hasil yang berbeda tergantung pada konten file lorem.txt Anda.

Keluaran:

 20064

Output direpresentasikan dalam byte. Ini tidak dapat dibaca sama sekali, jadi mari kita manusiakan sehingga kita dapat memiliki perspektif ukuran file yang lebih baik.

Pertama, instal paket humanize, dengan menjalankan perintah berikut di shell Anda:

 pip install humanize

Kemudian Anda dapat menggunakan fungsi naturalsize() yang mengonversi nilai dalam byte menjadi ukuran file yang dapat dibaca, misalnya, KB, MB, GB, atau TB.

 import os from humanize import naturalsize size = os.stat('lorem.txt').st_size print(size) print(naturalsize(size))

Pada awalnya, kode di atas mencetak ukuran file dalam byte kemudian mencetak hasilnya dalam ukuran yang dapat dibaca.

Keluaran:

 20064 20.1 kB

Menggunakan Pathlib

Meskipun pathlib dirancang untuk bekerja secara eksklusif dengan jalur, ia menggabungkan beberapa fungsi yang berguna dari modul lain sebagai metode objek Path (Instance dari kelas Path).

Buat file method2.py dan impor kelas Path.

 from pathlib import Path

Kemudian buat objek Path yang meneruskan path ke file lorem.txt sebagai argumen.

 file_ = Path('lorem.txt')

Sekarang, Anda dapat mengakses metode stat() dari kelas Path. Ini bekerja sama dengan fungsi os.stat() , oleh karena itu Anda dapat mencetak ukuran file.

 print(file_.stat().st_size)

Keluaran:

 20064

Seperti yang Anda lihat, kami mendapatkan hasil yang sama dengan metode pertama yang kami gunakan. Hasil di atas juga dicetak dalam format byte, sehingga kita dapat menggunakan modul humanize agar dapat dibaca.

 from pathlib import Path from humanize import naturalsize size = Path('lorem.txt').stat().st_size print(naturalsize(size))

Kode ini menghasilkan output berikut:

 20.1 kB

Menggunakan perintah Unix dengan Subproses:

Modul subproses, memungkinkan kita untuk memanggil dan mengelola subproses dari Python. Oleh karena itu, kita dapat menjalankan perintah apa pun dan memproses outputnya secara langsung dengan Python.

Catatan: Metode ini hanya berfungsi jika Anda menjalankan Unix OS (Linux, Mac)

Buka file method3.py dan paste kode di bawah ini:

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) print(process.stdout)

Menyelam ke dalam bagian kode ini:

  • Kami mengimpor fungsi run dari modul subproses
  • Proses variabel berisi hasil menjalankan perintah du lorem.txt
    • du adalah utilitas Linux yang memungkinkan kita untuk mendapatkan ruang disk dari sebuah file
    • capture_output memberi kita akses ke atribut (output standar) yang menonjol
    • teks berarti kami menyimpan output sebagai string, bukan byte
  • Kami mencetak output standar dari proses

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut:

 20 lorem.txt

Seperti yang Anda lihat, ini memberi kami ukuran dan nama file. Jika Anda hanya ingin mendapatkan ukuran file, Anda harus membagi output (ingat ini adalah string) dan mencetak elemen pertama.

 from subprocess import run process = run(['du', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Keluaran:

 20

Output ini tidak dapat dibaca sama sekali. Kita dapat menyimpulkan bahwa satuan pengukuran yang digunakan adalah KB (karena metode sebelumnya), tetapi tidak ada orang lain yang bisa menebak ukuran file.

Untuk mengatasi masalah ini, kita dapat menggunakan flag -h (dapat dibaca manusia).

Catatan: Anda bisa mendapatkan manual dari perintah ini dengan menjalankan man du , atau du –help .

 from subprocess import run process = run(['du', '-h', 'lorem.txt'], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Sekarang output dari skrip ini akan jauh lebih mudah dibaca:

 20K

Jika Anda ingin tahu lebih banyak tentang modul subproses dan kemungkinan aplikasi, lihat panduan subproses Python kami.

Dapatkan Ukuran Folder Secara Rekursif

Jika Anda ingin mendapatkan ukuran folder, Anda harus mengulangi setiap file yang ada di direktori dan sub-direktorinya. Kami akan melakukannya dengan dua metode:

  • Iterasi melalui Path dengan pathlib
  • Menggunakan perintah du dengan subproses

Kode berikut akan menggunakan jalur ke direktori pengujian di dalam folder rumah saya. Anda harus mengganti jalur file itu untuk direktori yang ingin Anda dapatkan ukurannya.

Iterasi melalui Path dengan pathlib

Mari kita lihat bagaimana Anda bisa mendapatkan ukuran direktori dengan mengulangi ukuran file.

 from pathlib import Path from humanize import naturalsize def get_size(path = '.'): size = 0 for file_ in Path(path).rglob('*'): size += file_.stat().st_size return naturalsize(size) test_path = Path.home() / 'Documents/tests/' print(get_size(test_path))

Sepotong kode ini tampaknya sedikit menakutkan, mari kita uraikan apa yang dilakukan setiap bagian.

  • Impor kelas Path dan fungsi naturalsize()
  • Tentukan fungsi get_size() dengan jalur parameter , yang menunjuk ke direktori saat ini secara default.
  • Variabel ukuran hanyalah pengganti di mana kami akan menambahkan ukuran setiap file
  • Ulangi setiap file jalur
    • Metode rglob() secara rekursif mengembalikan file yang cocok dengan polanya
    • rglob('*') , berarti kita mendapatkan semua file di dalam direktori
  • Dapatkan ukuran setiap file dan tambahkan ke variabel ukuran
  • Mengembalikan variabel ukuran dengan cara yang dapat dibaca manusia

Tentu saja, saya sedang menguji fungsi dengan direktori yang hanya tersedia di mesin saya. Jangan lupa untuk mengubah path ke folder yang ada di komputer Anda.

Dalam kasus saya, saya mendapatkan output berikut:

 403.4 MB

Menggunakan perintah du dengan Subproses

Pendekatan ini memiliki beberapa keuntungan:

  • Hasilnya sedikit lebih akurat
  • Ini jauh lebih cepat
 from subprocess import run from pathlib import Path test_path = Path.home() / 'Documents/tests/' process = run(['du', '-sh', test_path], capture_output=True, text=True) size = process.stdout.split()[0] print(size)

Kami menggunakan pendekatan yang sama seperti metode 3, tetapi kali ini kami mendapatkan ukuran direktori, bukan file.

Keluaran:

 481M

Seperti yang Anda lihat, dua cara untuk mendapatkan ukuran folder ini, mengembalikan hasil yang sedikit berbeda. Semakin besar direktori, semakin banyak perbedaan yang akan Anda dapatkan.

Terserah Anda untuk memilih antara pathlib atau pendekatan subproses . Jika Anda tahu Anda akan menggunakan Linux setiap kali menggunakan subprocess , jika tidak, Anda dapat menggunakan solusi pathlib.

Untuk menyimpulkan

Hasil Python sangat berguna saat berinteraksi dengan OS. Anda dapat mengotomatiskan proses dan menghemat banyak waktu dengan Python. Modul utama untuk berinteraksi dengan os adalah os, sys, path, dan subprocess.

Dalam tutorial ini Anda belajar:

  • Bagaimana Python berinteraksi dengan OS
  • Penggunaan modul built-in untuk membuat operasi OS
  • Cara menggunakan modul humanize untuk mencetak yang dapat dibaca manusia
  • Untuk menghitung ukuran file dengan 3 pendekatan
  • Untuk menghitung ukuran direktori secara rekursif atau dengan perintah du
TAG:
  • Python