Upang hawakan ang kaugnay na data, ginagamit ang mga file, na may label na mga lokasyon sa disc. Ang mga ito ay nagsisilbing permanenteng data storage device sa non-volatile memory.
Ang function na 'readable()' sa Python ay ginagamit upang matukoy kung ang ibinigay na file ay nababasa o hindi. Nagbabalik ito ng totoo kung mababasa ang tinukoy na file; kung hindi, ito ay nagbabalik ng false. Ang isang file ay maaaring basahin kung ito ay binuksan sa read 'r' mode lamang.
Ang syntax para sa paggamit ng paraang ito sa isang Python program ay ibinibigay sa ibaba:
Sa artikulong ito, matututunan mo ang tungkol sa pagbubukas ng isang file at pagkatapos ay i-verify kung ito ay nababasa o hindi gamit ang praktikal na pagpapatupad ng mga programang Python sa tool na Spyder.
Halimbawa # 1: Paggamit ng readable() na Paraan Upang Suriin Kung Mababasa ang Ibinigay na File
Para sa unang pagkakataon, gagawa kami ng isang simpleng Python program para ipatupad ang paraang ito.
Para sa pagbabasa ng isang text file, kailangan muna nating magkaroon ng file na umiiral sa kasalukuyang gumaganang direktoryo ng ating programa. Upang mahanap ang kasalukuyang gumaganang direktoryo sa Python, kailangan nating isagawa ang sumusunod na bloke ng code:
Dadalhin nito sa amin ang kasalukuyang gumaganang direktoryo. Sa sumusunod na larawan, makikita natin na kasalukuyang tumatakbo tayo sa direktoryong ito.
Dapat tayong lumikha ng isang text file at i-save ito sa direktoryong nabanggit sa itaas.
Upang gawin ang text file, inilunsad namin ang 'Notepad', at sinulatan ito ng ilang text string bilang 'Ito ay isang demo file'.
Pagkatapos ay nai-save namin ang file na ito sa parehong direktoryo na may pamagat na 'sample.txt'.
Kung hindi mo ilalagay ang kinakailangang file sa parehong direktoryo, ipapakita ng programa ang 'FileNotFoundError'.
Ngayon na naitakda na natin ang lahat ng mga kinakailangan para sa pagpapatupad ng program na ito, lumipat tayo sa pangunahing code ng Python.
Sa unang linya ng programa, tinawag namin ang Python na 'open()' na pamamaraan. Ang pamamaraang ito ay nagbubukas ng isang file. Nangangailangan ito ng pangalan ng file at ang mode kung saan kailangan namin ang file na mabuksan bilang dalawang input. Ang pamamaraang ito ay may ganitong mga mode; “r” para sa Basahin, “w” para sa Isulat, at “a” para sa Idugtong. Dito, ibinigay namin ang pangalan ng file bilang 'sample.txt', na inilipat na sa aming kasalukuyang gumaganang direktoryo, at pagkatapos ay tinukoy namin ang mode bilang 'r,' na tumutukoy sa pagbubukas ng file sa read mode.
Upang iimbak ang nakuhang output file, lumikha kami ng isang file object, 'doc'. Ang na-extract na file ay nasa read mode at nasa 'doc' variable. Upang suriin kung nababasa ang file na ito, binibigyan kami ng Python ng built-in na 'readable()' na pamamaraan. Kung nababasa ang ibinigay na file, bubuo ito ng string value na 'True' sa output window; kung hindi, ito ay magpi-print ng 'False'. Ginamit namin ang 'readable()' na paraan na may file object na 'doc', sa loob ng 'print()' na paraan upang ipakita ang resulta sa terminal na nabuo mula sa function na 'doc.readable()' kasama ng string statement na 'Checking kung ang file ay nababasa:”.
Habang ang file ay binuksan sa isang read mode, kaya ang pagpapatupad ng 'readable()' na paraan ay nagbibigay sa amin ng 'TRUE' string value na nangangahulugang ang file ay nababasa.
Suriin natin ang 'nababasa()' na paraan habang binubuksan ang file sa 'w' at 'a' na mga mode.
Ginamit namin ang naunang ginawang script, maliban kung ang mode para sa pagbubukas ng file ay binago dito. Tinukoy namin ang mode bilang 'w', na nangangahulugang buksan ang file sa 'write' mode.
Kapag isinagawa namin ito, bubuo ito ng 'False' string value sa output window, na nagpapahiwatig na ang file ay hindi nababasa.
Ngayon, susuriin namin ito para sa 'a' mode.
Ang parehong code ay ginamit muli, ngunit ang pambungad na mode ay binago sa oras na ito. Sa pagkakataong ito, tinukoy namin ang mode bilang 'a' ay tumutukoy sa 'idagdag'. Pagkatapos ay ang 'nababasa ()' na pamamaraan ay hinihingi lamang sa file object na 'doc'. Ngayon, patakbuhin namin ang programa upang makita ang output.
Ang nakuha na resulta ay nagpapahiwatig din na ang file ay hindi nababasa sa mode na ito.
Kaya, napagpasyahan namin na ang mga file ay mababasa lamang kapag binubuksan sa 'r' mode; para sa lahat ng iba pang mga mode, hindi ito nababasa.
Halimbawa # 3: Pagkuha ng File Input Mula sa User Upang I-verify Kung Ito ay Nababasa Gamit ang Readable() Method With if/else
Para sa demonstrasyon na ito, kukuha kami ng input file mula sa user na dapat na umiiral sa kasalukuyang gumaganang direktoryo ng programa. Pagkatapos kunin ang pangalan ng input file, bubuksan ang file, at susuriin ng program kung mababasa ito. Gumawa kami ng isang halimbawa ng programang Python kung saan ipinatupad ang pamamaraang ito. Ang snapshot ng code snippet ay ibinigay sa ibaba:
Ang program na ito ay nagsisimula sa pamamagitan ng unang pagpapakita ng isang pahayag na 'Pakisulat ang pangalan ng file:' sa terminal sa pamamagitan ng paggamit ng 'print()' na paraan ng Python. Upang kunin ang input mula sa user, ang built-in na paraan ng Python na 'input()' ay na-invoke, at isang variable na 'pro_file' ang mag-iimbak ng resulta na nabuo mula sa 'input()' function. Ang pamamaraang 'print()' ay ginamit sa sumusunod na linya ng code upang magpakita ng string na text bilang '\nAng pangalan ng file na ibinigay ng user ay:' at ang value na na-store sa variable na 'pro_file'. Dito, ang '\n' ay tumutukoy sa paglipat sa susunod na linya. Kaya, ang pahayag na ito ay ipi-print pagkatapos laktawan ang isang blangkong linya sa terminal.
Ang karagdagang pagpapatuloy sa code, ang 'open()' na paraan ay tinawag upang buksan ang file na tinukoy ng user. Sa pagitan ng mga panaklong ng function na 'open()', ibinigay namin ang variable na humahawak sa file, at ang mode para buksan ang file ay tinukoy bilang 'r'. Kaya, ang file ay mabubuksan sa read mode. Ang file object na 'data' ay nilikha upang iimbak ang nakuhang file.
Ngayon upang suriin kung ang file ay nababasa o hindi, ginamit namin ang 'readable()' na pamamaraan na may file object na 'data', bilang kondisyon para sa 'if-statement'. Kaya, kung ang file ay lumabas na nababasa, ang kontrol ay lilipat sa susunod na linya kung saan ang isang 'print()' na function ay may hawak na isang pahayag na '\nAng ibinigay na file ay nababasa.' At ipakita ito sa terminal. Kung ang file ay hindi nababasa, ang 'iba' na bahagi ay isasagawa. Naglalaman din ang seksyong ito ng function na 'print()', na mayroong text string na ipapakita bilang '\nAng ibinigay na file ay hindi nababasa.'
Kapag nag-execute ang program, may ipapakitang statement na humihiling sa user na ipasok ang pangalan ng file, at lilipat ang cursor sa susunod na linya, kung saan kailangang isulat ng user ang partikular na pangalan ng file na may extension na '.txt'.
Sa snapshot na ito, makikita natin na nagpasok ang user ng file na pinangalanang 'sample.txt'. Kapag na-key in ang 'Enter', ipapatupad ng programa ang lahat ng iba pang operasyon. Dito, ipinakita ang pangalan ng file sa input ng user. At pagkatapos, isang pahayag ay naka-print na nagsasabing, 'Ang ibinigay na file ay nababasa'.
Konklusyon
Ang built-in na pamamaraan ng Python, 'readable(),' ay nagbibigay-daan sa amin na suriin kung ang isang file ay nababasa o hindi. Ang gabay na ito ay nagtrabaho sa pag-aaral ng pagpapatupad ng partikular na pamamaraang ito. Nagsagawa kami ng dalawang halimbawa upang maunawaan ang proseso ng pagpapatupad. Sa unang pagkakataon, unang binuksan ng program ang isang file gamit ang 'open()' na paraan na may iba't ibang mga opening mode at pagkatapos ay sinuri kung ang file ay mababasa o hindi. Kinukuha ng pangalawang ilustrasyon ang filename bilang input mula sa user, at pagkatapos itong buksan sa 'r' mode, ang if/else na statement ay ginagamit upang isagawa ang 'readable()' na paraan. Ang parehong mga pamamaraan na ito ay ganap na maipapatupad depende sa mga kinakailangan sa gawain.