यदि पायथन में कोई फ़ाइल बाइनरी (गैर-पाठ) है तो मैं कैसे पता लगा सकता हूं?

Question

मैं कैसे बता सकता हूं कि अजगर में कोई फाइल बाइनरी (गैर-पाठ) है?

मैं अजगर में फाइलों के एक बड़े सेट के माध्यम से खोज कर रहा हूं, और बाइनरी फाइलों में मिलान करता रहा हूं। इससे आउटपुट अविश्वसनीय रूप से गड़बड़ हो जाता है।

मुझे पता है कि मैं उपयोग कर सकता हूं grep -I, लेकिन मैं उस डेटा के साथ अधिक काम कर रहा हूं जो grep अनुमति देता है।

अतीत में, मैंने सिर्फ वर्णों की तुलना में अधिक खोज की होगी 0x7f, लेकिन utf8आधुनिक प्रणालियों पर यह असंभव बना देता है। आदर्श रूप से समाधान तेज होगा, लेकिन कोई भी समाधान करेगा।

Comments

यदि "अतीत में" मैंने केवल 0x7f से अधिक वर्णों की खोज की होगी "तो क्या आप सादे ASCII पाठ के साथ काम करते थे तब भी कोई समस्या नहीं है क्योंकि ASCII पाठ को UTF-8 के रूप में इनकोड किया गया है क्योंकि ASCII रहता है (अर्थात कोई बाइट्स 127)।

— प्रात:

@,: सच है, लेकिन मुझे पता है कि मैं जिन फाइलों को निपटा रहा हूं उनमें से कुछ utf8 हैं। मेरा मतलब सामान्य अर्थों में था, इन फाइलों के विशिष्ट अर्थों में नहीं। :)

— शोक

केवल संभावना के साथ। आप जांच सकते हैं कि: 1) फ़ाइल में \ n 2 है \ n के बीच बाइट्स की मात्रा अपेक्षाकृत छोटी है (यह विश्वसनीय नहीं है) l 3) फ़ाइल ASCCI "स्पेस" वर्ण ('') के मान से कम मूल्य के साथ बाइट्स नहीं करता है ) - "\ n" "\ r" "\ t" और शून्य को बाहर निकालें।

— सिग्मर

grepबाइनरी फ़ाइलों की पहचान करने के लिए खुद को इस्तेमाल करने वाली रणनीति नीचे दिए गए जॉर्ज ऑर्पिनल द्वारा पोस्ट की गई है । जब तक आप -zविकल्प सेट नहीं करते हैं , यह "\000"फ़ाइल में एक अशक्त चरित्र ( ) के लिए स्कैन करेगा । इसके साथ -z, यह के लिए स्कैन करता है "\200"। उन इच्छुक और / या संदेहवादी 1126 की लाइन की जांच कर सकते हैं grep.c। क्षमा करें, मुझे स्रोत कोड वाला कोई वेबपृष्ठ नहीं मिला, लेकिन निश्चित रूप से आप इसे gnu.org या एक distro के माध्यम से प्राप्त कर सकते हैं ।

— intuited

PS जैसा कि जॉर्ज की पोस्ट के लिए टिप्पणी थ्रेड में उल्लेख किया गया है, यह रणनीति युक्त फ़ाइलों के लिए झूठी सकारात्मक जानकारी देगी, उदाहरण के लिए, UTF-16 पाठ। बहरहाल, दोनों git diffऔर GNU diffभी एक ही रणनीति का उपयोग करते हैं। मुझे यकीन नहीं है कि अगर यह इतना प्रचलित है क्योंकि यह विकल्प की तुलना में बहुत तेज और आसान है, या यदि यह सिस्टम पर UTF-16 फ़ाइलों की सापेक्ष दुर्लभता के कारण है, जो इन बर्तनों को स्थापित करते हैं।

— intuited

Answer 1

आप mimetypes मॉड्यूल का उपयोग भी कर सकते हैं :

import mimetypes
...
mime = mimetypes.guess_type(file)

बाइनरी माइम प्रकारों की सूची संकलित करना काफी आसान है। उदाहरण के लिए अपाचे एक mime.types फ़ाइल के साथ वितरित करता है जिसे आप सूचियों, बाइनरी और टेक्स्ट के सेट में पार्स कर सकते हैं और फिर यह देखने के लिए जांचें कि क्या माइम आपके पाठ या बाइनरी सूची में है।

Comments

क्या mimetypesकिसी फ़ाइल की सामग्री का उपयोग करने के लिए सिर्फ उसके नाम के बजाय एक तरीका है ?

— intuited

@intuited नहीं, लेकिन libmagic ऐसा करता है। अजगर-जादू के माध्यम से इसका उपयोग करें ।

— Bengt

यहाँ कुछ अच्छे उत्तरों के साथ एक समान प्रश्न है: stackoverflow.com/questions/1446549/… एक सक्रिय नुस्खा के आधार पर उत्तर मुझे अच्छा लगता है, यह गैर-मुद्रण योग्य वर्णों का एक छोटा अनुपात (लेकिन नहीं 0), कुछ के लिए अनुमति देता है कारण)।

— सैम वाटकिंस

यह केवल एक महान जवाब नहीं है क्योंकि mimetypes मॉड्यूल सभी फाइलों के लिए अच्छा नहीं है। मैं अब एक फाइल देख रहा हूं, जो सिस्टम fileरिपोर्ट "UTF-8 यूनिकोड पाठ, बहुत लंबी लाइनों के साथ" लेकिन mimetypes.gest_type () वापस आ जाएगी (कोई नहीं, कोई नहीं)। इसके अलावा, अपाचे की mimetype सूची एक श्वेतसूची / सबसेट है। यह किसी भी तरह से mimetypes की पूरी सूची नहीं है। इसका उपयोग सभी फ़ाइलों को पाठ या गैर-पाठ के रूप में वर्गीकृत करने के लिए नहीं किया जा सकता है।

— प्यारेल

answer_types फ़ाइल नाम एक्सटेंशन पर आधारित है, न कि वास्तविक सामग्री जैसा कि यूनिक्स कमांड "फ़ाइल" करेगा।

— एरिक एच।

Answer 2

अभी तक फ़ाइल (1) व्यवहार पर आधारित एक और विधि :

>>> textchars = bytearray({7,8,9,10,12,13,27} | set(range(0x20, 0x100)) - {0x7f})
>>> is_binary_string = lambda bytes: bool(bytes.translate(None, textchars))

उदाहरण:

>>> is_binary_string(open('/usr/bin/python', 'rb').read(1024))
True
>>> is_binary_string(open('/usr/bin/dh_python3', 'rb').read(1024))
False

Comments

झूठी सकारात्मक और झूठी नकारात्मक दोनों प्राप्त कर सकते हैं, लेकिन अभी भी एक चतुर दृष्टिकोण है जो बड़ी संख्या में फाइलों के लिए काम करता है। +1।

— स्पेक्ट्रा

दिलचस्प रूप से पर्याप्त है, फ़ाइल (1) स्वयं भी 0x7f को विचार से बाहर रखती है, इसलिए तकनीकी रूप से बोलना आपको bytearray([7,8,9,10,12,13,27]) + bytearray(range(0x20, 0x7f)) + bytearray(range(0x80, 0x100))इसके बजाय उपयोग करना चाहिए । पायथन देखें , फ़ाइल (1) - पाठ बनाम बाइनरी फ़ाइल और github.com/file/file/

— मार्टिन पीटर्स

@MartijnPieters: धन्यवाद। मैंने उत्तर को बाहर करने के लिए अद्यतन किया है 0x7f( DEL)।

— 16

सेट का उपयोग कर अच्छा समाधान। :-)

— मार्टिन पीटर्स

आप बाहर क्यों करते हैं 11या VT? तालिका 11 में सादा ASCII पाठ माना जाता है, और यह है vertical tab।

— डार्ककॉ जूल

Answer 3

यदि आप utf-8 के साथ python3 का उपयोग कर रहे हैं, तो यह सीधे आगे है, बस एक मोड में फाइल को खोलें और यदि आप प्राप्त करते हैं तो प्रोसेसिंग बंद कर दें UnicodeDecodeError। पाठ मोड में फ़ाइलों को संभालते समय (और बाइनरी मोड में बाईटियर) पायथन 3 यूनिकोड का उपयोग करेगा - यदि आपका एन्कोडिंग मनमाने ढंग से फ़ाइलों को डिकोड नहीं कर सकता है, तो इसकी संभावना है कि आपको मिलेगा UnicodeDecodeError।

उदाहरण:

try:
    with open(filename, "r") as f:
        for l in f:
             process_line(l)
except UnicodeDecodeError:
    pass # Fond non-text data

Comments

with open(filename, 'r', encoding='utf-8') as fसीधे उपयोग क्यों नहीं ?

— टेरी

Answer 4

यदि यह मदद करता है, तो कई कई बाइनरी प्रकार एक जादुई संख्या के साथ शुरू होते हैं। यहाँ फ़ाइल हस्ताक्षर की एक सूची है।

Comments

यह वही है जो कामवासना के लिए है। यह अजगर-जादू के माध्यम से अजगर में पहुँचा जा सकता है ।

— बेंगट

दुर्भाग्य से, "एक ज्ञात जादू नंबर से शुरू नहीं होता है" "एक पाठ फ़ाइल के बराबर नहीं है"।

— पुरेल

Answer 5

इसे इस्तेमाल करे:

def is_binary(filename):
    """Return true if the given filename is binary.
    @raise EnvironmentError: if the file does not exist or cannot be accessed.
    @attention: found @ http://bytes.com/topic/python/answers/21222-determine-file-type-binary-text on 6/08/2010
    @author: Trent Mick <[e-mail]>
    @author: Jorge Orpinel <[e-mail]>"""
    fin = open(filename, 'rb')
    try:
        CHUNKSIZE = 1024
        while 1:
            chunk = fin.read(CHUNKSIZE)
            if '\0' in chunk: # found null byte
                return True
            if len(chunk) < CHUNKSIZE:
                break # done
    # A-wooo! Mira, python no necesita el "except:". Achis... Que listo es.
    finally:
        fin.close()

    return False

Comments

-1 बायन बाइट वाले "बाइनरी" को परिभाषित करता है। UTF-16-एन्कोडेड पाठ फ़ाइलों को "बाइनरी" के रूप में वर्गीकृत करेगा।

— जॉन मैकिन

@ जॉन माचिन: ​​दिलचस्प रूप से, git diffवास्तव में इस तरह से काम करता है , और निश्चित रूप से पर्याप्त है, यह यूटीएफ -16 फाइलों को बाइनरी के रूप में पहचानता है।

— intuited

हं .. GNU diffभी इस तरह से काम करता है। इसमें UTF-16 फ़ाइलों के साथ समान समस्याएं हैं। fileUTF-16 पाठ के समान फ़ाइलों का सही पता लगाता है। मैंने grepकोड की जाँच नहीं की है , लेकिन यह भी बाइनरी के रूप में UTF-16 फ़ाइलों का पता लगाता है।

— intuited

+1 @ जॉनी माचिन: ​​यूटीएफ -16 एक चरित्र डेटा है जिसके अनुसार file(1)रूपांतरण के बिना प्रिंट करना सुरक्षित नहीं है इसलिए इस मामले में यह विधि उपयुक्त है।

— jfs

-1 - मुझे नहीं लगता कि a एक शून्य बाइट शामिल है ’द्विआधारी बनाम पाठ के लिए एक पर्याप्त परीक्षण है, उदाहरण के लिए मैं सभी 0x01 बाइट्स वाली फ़ाइल बना सकता हूं या 0xDEADBEEF दोहरा सकता हूं, लेकिन यह एक पाठ फ़ाइल नहीं है। फ़ाइल (1) पर आधारित उत्तर बेहतर है।

— सैम वाटकिंस

Answer 6

यहां एक सुझाव दिया गया है जो यूनिक्स फाइल कमांड का उपयोग करता है :

import re
import subprocess

def istext(path):
    return (re.search(r':.* text',
                      subprocess.Popen(["file", '-L', path], 
                                       stdout=subprocess.PIPE).stdout.read())
            is not None)

उदाहरण का उपयोग:

>>> istext ('/ etc / motd') 
सच
>>> istext ('/ vmlinuz') 
असत्य
>>> खुला ('/ tmp / जापानी')। () पढ़ें
'\ XE3 \ x81 \ x93 \ XE3 \ x82 \ x8c \ XE3 \ x81 \ XAF \ XE3 \ x80 \ x81 \ XE3 \ x81 \ xbf \ XE3 \ x81 \ x9a \ XE3 \ x81 \ x8c \ XE3 \ x82 \ x81 \ xe5 \ xba \ xa7 \ XE3 \ x81 \ xAE \ XE6 \ x99 \ x82 \ XE4 \ xbb \ xa3 \ XE3 \ x81 \ xAE \ xe5 \ XB9 \ X95 \ xe9 \ x96 \ x8b \ XE3 \ x81 \ x91 \ XE3 \ x80 \ x82 \ n '
>>> istext ('/ tmp / Japanese') # UTF-8 पर काम करता है
सच

इसमें विंडोज के पोर्टेबल न होने (जब तक कि आपके पास fileवहां की कमांड जैसी कोई चीज नहीं है), और प्रत्येक फाइल के लिए एक बाहरी प्रक्रिया स्पॉन करने की डाउनसाइड है , जो कि संभव नहीं है।

Comments

यह मेरी स्क्रिप्ट तोड़ दिया :( जांच करते हुए, मुझे पता चला है कि कुछ conffiles द्वारा वर्णित हैं fileके रूप में। - स्ट्रिंग "पाठ" के अभाव -notice "सेंडमेल जमे हुए विन्यास संस्करण मीटर" शायद का उपयोग file -i?

— melissa_boiko

TypeError: बाइट्स जैसी ऑब्जेक्ट पर एक स्ट्रिंग पैटर्न का उपयोग नहीं कर सकते हैं

— abg

Answer 7

बाइनरीहॉट लाइब्रेरी ( GitHub ) का उपयोग करें ।

यह बहुत सरल है और इस स्टैकओवरफ्लो प्रश्न में पाए गए कोड पर आधारित है।

आप इसे वास्तव में कोड की 2 लाइनों में लिख सकते हैं, हालांकि यह पैकेज आपको लिखने और कोड के उन 2 लाइनों को सभी प्रकार की अजीब फ़ाइल प्रकारों, क्रॉस-प्लेटफ़ॉर्म के साथ अच्छी तरह से परीक्षण करने से बचाता है।

Answer 8

आमतौर पर आपको अनुमान लगाना होगा।

आप एक्सटेंशन को एक सुराग के रूप में देख सकते हैं, अगर फाइलें उनके पास हैं।

आप द्विआधारी स्वरूपों को भी पहचान सकते हैं, और उन पर ध्यान नहीं दे सकते।

अन्यथा देखें कि आपके पास गैर-मुद्रण योग्य एएससीआईआई बाइट्स का क्या अनुपात है और इससे एक अनुमान लगता है।

आप UTF-8 से डिकोडिंग का भी प्रयास कर सकते हैं और देख सकते हैं कि क्या समझदार आउटपुट पैदा करता है।

Answer 9

UTF-16 चेतावनी के साथ एक छोटा समाधान:

def is_binary(filename):
    """ 
    Return true if the given filename appears to be binary.
    File is considered to be binary if it contains a NULL byte.
    FIXME: This approach incorrectly reports UTF-16 as binary.
    """
    with open(filename, 'rb') as f:
        for block in f:
            if b'\0' in block:
                return True
    return False

Comments

ध्यान दें: for line in fileअसीमित मात्रा में मेमोरी का उपभोग तब तक किया b'\n'जा सकता है जब तक कि

— jfs

@Community रहे हैं: ".read()"रिटर्न यहां bytestring कि है iterable (यह अलग-अलग बाइट्स पैदावार)।

— jfs 3

Answer 10

यदि फ़ाइल बाइनरी है, तो हम जाँच करने के लिए अजगर का उपयोग कर सकते हैं, क्योंकि यदि हम पाठ मोड में बाइनरी फ़ाइल खोलने का प्रयास करते हैं तो यह विफल हो जाता है

def is_binary(file_name):
    try:
        with open(file_name, 'tr') as check_file:  # try open file in text mode
            check_file.read()
            return False
    except:  # if fail then file is non-text (binary)
        return True

Comments

यह बहुत सारी '.avi' (वीडियो) फ़ाइलों के लिए विफल रहता है।

— अनमोल सिंह जग्गी

Answer 11

यदि आप विंडोज पर नहीं हैं, तो आप फिलाटाइप को निर्धारित करने के लिए पायथन मैजिक का उपयोग कर सकते हैं । फिर आप जांच सकते हैं कि यह एक पाठ / माइम प्रकार है।

Answer 12

यहां एक फ़ंक्शन है जो पहले जांचता है कि क्या फ़ाइल BOM से शुरू होती है और यदि प्रारंभिक 8192 बाइट के भीतर शून्य बाइट के लिए नहीं दिखता है:

import codecs


#: BOMs to indicate that a file is a text file even if it contains zero bytes.
_TEXT_BOMS = (
    codecs.BOM_UTF16_BE,
    codecs.BOM_UTF16_LE,
    codecs.BOM_UTF32_BE,
    codecs.BOM_UTF32_LE,
    codecs.BOM_UTF8,
)


def is_binary_file(source_path):
    with open(source_path, 'rb') as source_file:
        initial_bytes = source_file.read(8192)
    return not any(initial_bytes.startswith(bom) for bom in _TEXT_BOMS) \
           and b'\0' in initial_bytes

तकनीकी रूप से UTF-8 BOM के लिए चेक अनावश्यक है क्योंकि इसमें सभी व्यावहारिक उद्देश्य के लिए शून्य बाइट्स नहीं होना चाहिए। लेकिन जैसा कि यह एक बहुत ही सामान्य एन्कोडिंग है, यह 0 के लिए सभी 8192 बाइट्स को स्कैन करने के बजाय शुरुआत में बीओएम के लिए जांचना तेज है।

Answer 13

वर्तमान में बनाए गए अजगर-जादू का उपयोग करने का प्रयास करें जो @Kami Kisiel के उत्तर में समान मॉड्यूल नहीं है। यह विंडोज सहित सभी प्लेटफार्मों का समर्थन करता है, हालांकि आपको इसकी आवश्यकता होगीlibmagic बाइनरी फ़ाइलों की । यह README में समझाया गया है।

Mimetypes मॉड्यूल के विपरीत , यह फ़ाइल के एक्सटेंशन का उपयोग नहीं करता है और इसके बजाय फ़ाइल की सामग्री का निरीक्षण करता है।

>>> import magic
>>> magic.from_file("testdata/test.pdf", mime=True)
'application/pdf'
>>> magic.from_file("testdata/test.pdf")
'PDF document, version 1.2'
>>> magic.from_buffer(open("testdata/test.pdf").read(1024))
'PDF document, version 1.2'

Answer 14

मैं यहां बिल्कुल उसी चीज की तलाश में आया था - जो बाइनरी या टेक्स्ट का पता लगाने के लिए मानक पुस्तकालय द्वारा प्रदान किया गया एक व्यापक समाधान है। लोगों द्वारा सुझाए गए विकल्पों की समीक्षा करने के बाद, निक्स फ़ाइल कमांड सबसे अच्छा विकल्प लगता है (मैं केवल लिनक्स बॉक्सन के लिए विकसित कर रहा हूं)। कुछ अन्य लोगों ने फ़ाइल का उपयोग करके समाधान पोस्ट किया, लेकिन वे मेरी राय में अनावश्यक रूप से जटिल हैं, इसलिए यहां मैं क्या कर रहा हूं:

def test_file_isbinary(filename):
    cmd = shlex.split("file -b -e soft '{}'".format(filename))
    if subprocess.check_output(cmd)[:4] in {'ASCI', 'UTF-'}:
        return False
    return True

इसे बिना कहे जाना चाहिए, लेकिन इस फ़ंक्शन को कॉल करने वाले आपके कोड को यह सुनिश्चित करना चाहिए कि आप परीक्षण करने से पहले किसी फ़ाइल को पढ़ सकते हैं, अन्यथा यह गलती से फ़ाइल को बाइनरी के रूप में पहचान लेगा।

Answer 15

मुझे लगता है कि सबसे अच्छा समाधान है कि answer_type फ़ंक्शन का उपयोग किया जाए। यह कई mimetypes के साथ एक सूची रखता है और आप अपने प्रकार भी शामिल कर सकते हैं। यहाँ वह स्क्रिप्ट आती है जो मैंने अपनी समस्या को हल करने के लिए की थी:

from mimetypes import guess_type
from mimetypes import add_type

def __init__(self):
        self.__addMimeTypes()

def __addMimeTypes(self):
        add_type("text/plain",".properties")

def __listDir(self,path):
        try:
            return listdir(path)
        except IOError:
            print ("The directory {0} could not be accessed".format(path))

def getTextFiles(self, path):
        asciiFiles = []
        for files in self.__listDir(path):
            if guess_type(files)[0].split("/")[0] == "text":
                asciiFiles.append(files)
        try:
            return asciiFiles
        except NameError:
            print ("No text files in directory: {0}".format(path))
        finally:
            del asciiFiles

यह एक कक्षा के अंदर है, जैसा कि आप कोड के ustructure के आधार पर देख सकते हैं। लेकिन आप उन चीजों को बहुत बदल सकते हैं जिन्हें आप अपने आवेदन के अंदर लागू करना चाहते हैं। यह उपयोग करने के लिए काफी सरल है। विधि getTextFiles सभी पाठ फ़ाइलों के साथ एक सूची ऑब्जेक्ट देता है जो उस निर्देशिका पर रहता है जिसे आप पथ चर में पास करते हैं।

Answer 16

पर * NIX:

यदि आपके पास fileशेल-कमांड तक पहुंच है , तो श्लेक्स सबप्रोसेस मॉड्यूल को अधिक उपयोगी बनाने में मदद कर सकता है:

from os.path import realpath
from subprocess import check_output
from shlex import split

filepath = realpath('rel/or/abs/path/to/file')
assert 'ascii' in check_output(split('file {}'.format(filepth).lower()))

या, आप यह भी उपयोग कर सकते हैं कि एक चालू लूप में वर्तमान dir में सभी फ़ाइलों के लिए आउटपुट प्राप्त करने के लिए:

import os
for afile in [x for x in os.listdir('.') if os.path.isfile(x)]:
    assert 'ascii' in check_output(split('file {}'.format(afile).lower()))

या सभी उपखंडों के लिए:

for curdir, filelist in zip(os.walk('.')[0], os.walk('.')[2]):
     for afile in filelist:
         assert 'ascii' in check_output(split('file {}'.format(afile).lower()))

Answer 17

अधिकांश प्रोग्राम फ़ाइल को बाइनरी मानते हैं (जो कि कोई भी फाइल है जो "लाइन-ओरिएंटेड" नहीं है) यदि इसमें NULL वर्ण है ।

यहाँ पायल का संस्करण pp_fttext()( pp_sys.c) पायथन में लागू किया गया है:

import sys
PY3 = sys.version_info[0] == 3

# A function that takes an integer in the 8-bit range and returns
# a single-character byte object in py3 / a single-character string
# in py2.
#
int2byte = (lambda x: bytes((x,))) if PY3 else chr

_text_characters = (
        b''.join(int2byte(i) for i in range(32, 127)) +
        b'\n\r\t\f\b')

def istextfile(fileobj, blocksize=512):
    """ Uses heuristics to guess whether the given file is text or binary,
        by reading a single block of bytes from the file.
        If more than 30% of the chars in the block are non-text, or there
        are NUL ('\x00') bytes in the block, assume this is a binary file.
    """
    block = fileobj.read(blocksize)
    if b'\x00' in block:
        # Files with null bytes are binary
        return False
    elif not block:
        # An empty file is considered a valid text file
        return True

    # Use translate's 'deletechars' argument to efficiently remove all
    # occurrences of _text_characters from the block
    nontext = block.translate(None, _text_characters)
    return float(len(nontext)) / len(block) <= 0.30

यह भी ध्यान दें कि यह कोड पाइथन 2 और पाइथन 3 दोनों पर बिना किसी बदलाव के चलाने के लिए लिखा गया था।

स्रोत: पायल के "अनुमान यदि फ़ाइल पाठ या बाइनरी है" पायथन में लागू किया गया है

Answer 18

क्या आप यूनिक्स में हैं? यदि ऐसा है, तो प्रयास करें:

isBinary = os.system("file -b" + name + " | grep text > /dev/null")

शेल रिटर्न मान उलटा है (0 ठीक है, इसलिए यदि यह "पाठ" पाता है तो यह 0 लौटाएगा, और पायथन में जो कि एक गलत अभिव्यक्ति है)।

Comments

संदर्भ के लिए, फ़ाइल कमांड फ़ाइल की सामग्री के आधार पर एक प्रकार का अनुमान लगाती है। मुझे यकीन नहीं है कि यह फ़ाइल एक्सटेंशन पर कोई ध्यान देता है या नहीं।

— डेविड जेड

मुझे यकीन है कि यह सामग्री और विस्तार दोनों में दिखता है।

— फोरट्रान

यह टूट जाता है यदि पथ में "पाठ" हो, तो। अंतिम ':' पर ​​rsplit करना सुनिश्चित करें (बशर्ते फ़ाइल प्रकार विवरण में कोई कोलन न हो)।

— एलन प्लम

उपयोग file-bस्विच के साथ ; यह पथ के बिना केवल फ़ाइल प्रकार मुद्रित करेगा।

— डबेक

थोड़ा सा अच्छा संस्करण: is_binary_file = lambda filename: "text" in subprocess.check_output(["file", "-b", filename])

— jfs

Answer 19

उदाहरण के लिए, ऑपरेटर \x00का उपयोग करके फ़ाइल में NULL वर्ण ( ) शामिल है या नहीं, इसका सरल तरीका है in:

b'\x00' in open("foo.bar", 'rb').read()

नीचे देखें पूरा उदाहरण:

#!/usr/bin/env python3
import argparse
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('file', nargs=1)
    args = parser.parse_args()
    with open(args.file[0], 'rb') as f:
        if b'\x00' in f.read():
            print('The file is binary!')
        else:
            print('The file is not binary!')

नमूना उपयोग:

$ ./is_binary.py /etc/hosts
The file is not binary!
$ ./is_binary.py `which which`
The file is binary!

Answer 20

from binaryornot.check import is_binary
is_binary('filename')

प्रलेखन