Bir dize geçerli bir dosya adına dönüştürülsün mü?

Dosya adı olarak kullanmak istediğim bir dize var, bu yüzden Python kullanarak dosya adlarında izin verilmeyecek tüm karakterleri kaldırmak istiyorum.

Aksi halde katı olmayı tercih ederim, bu yüzden diyelim ki sadece harfleri, rakamları ve diğer küçük karakter kümelerini tutmak istiyorum "_-.() ". En zarif çözüm nedir?

Dosya adının birden çok işletim sisteminde geçerli olması gerekir (Windows, Linux ve Mac OS) - kütüphanemde şarkı adı dosya adı olan bir MP3 dosyasıdır ve 3 makine arasında paylaşılır ve yedeklenir.

Keyfi metinden nasıl bir "sülük" oluşturdukları için Django çerçevesine bakabilirsiniz . Bir bilgi URL ve dosya adı dostudur.

Django metin araçları bir işlevi tanımlar slugify(), bu muhtemelen bu tür şeyler için altın standarttır. Esasen, kodları aşağıdaki gibidir.

def slugify(value):
    """
    Normalizes string, converts to lowercase, removes non-alpha characters,
    and converts spaces to hyphens.
    """
    import unicodedata
    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
    value = unicode(re.sub('[^\w\s-]', '', value).strip().lower())
    value = unicode(re.sub('[-\s]+', '-', value))
    # ...
    return value

Dahası da var, ama slugifikasyona değil, kaçmaya karşı çıktığı için dışarıda bıraktım.

Bu beyaz liste yaklaşımı (yani yalnızca geçerli_karakterlerde mevcut olan karakterlere izin vermek), dosyaların biçimlendirilmesinde veya yasa dışı olan geçerli karakterlerin birleşiminde (".." gibi) sınırlar yoksa, örneğin söylediğiniz gibi çalışır Windows'ta geçerli olmadığını düşündüğüm ". txt" adlı bir dosya adına izin verir. Bu, boşluğu geçerli_karaklardan kaldırmaya çalıştığım ve hata durumunda bilinen bir geçerli dizginin başına eklediğim en basit yaklaşım olduğundan, diğer herhangi bir yaklaşımın Windows dosya adlandırma sınırlamaları ile nerede başa çıkabileceğine ve bu nedenle çok daha karmaşık.

>>> import string
>>> valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
>>> valid_chars
'-_.() abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
>>> filename = "This Is a (valid) - filename%$&$ .txt"
>>> ''.join(c for c in filename if c in valid_chars)
'This Is a (valid) - filename .txt'

Dize yöntemleriyle birlikte liste kavrayışını kullanabilirsiniz.

>>> s
'foo-bar#baz?qux@127/\\9]'
>>> "".join(x for x in s if x.isalnum())
'foobarbazqux1279'

Dizeleri dosya adı olarak kullanmanın nedeni nedir? İnsan okunabilirliği bir faktör değilse, dosya sistemi güvenli dizeleri üretebilen base64 modülü ile giderdim. Okunamayacak, ancak çarpışmalarla uğraşmanıza gerek kalmayacak ve tersine çevrilebilir.

import base64
file_name_string = base64.urlsafe_b64encode(your_string)

Güncelleme : Matthew yorumuna göre değişti.

Sadece işleri daha da karmaşık hale getirmek için, sadece geçersiz karakterleri kaldırarak geçerli bir dosya adı almanız garanti edilmez. İzin verilen karakterler farklı dosya adlarında farklılık gösterdiğinden, muhafazakar bir yaklaşım, geçerli bir adı geçersiz bir ada dönüştürür. Aşağıdaki durumlarda özel işlem eklemek isteyebilirsiniz:

• Dize tamamen geçersiz karakterler (size boş bir dize bırakarak)

• Sonunda özel bir anlamı olan bir dize ile karşılaşırsınız, örneğin "." veya ".."

• Pencerelerde belirli cihaz adları ayrılmıştır. Örneğin, "nul", "nul.txt" (veya aslında nul.anything) adında bir dosya oluşturamazsınız. Ayrılmış adlar:

  CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, ​​COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 ve LPT9

Büyük olasılıkla, bu durumlardan hiçbiriyle sonuçlanamayan dosya adlarına bir dizi dize ekleyerek ve geçersiz karakterleri çıkararak bu sorunları giderebilirsiniz.

Github'da python-slugify adında güzel bir proje var :

Yüklemek:

pip install python-slugify

Sonra kullan:

>>> from slugify import slugify
>>> txt = "This\ is/ a%#$ test ---"
>>> slugify(txt)
'this-is-a-test'

S.Lott'un yanıtladığı gibi , bir dizeyi geçerli bir dosya adına nasıl dönüştürdükleri için Django Framework'e bakabilirsiniz .

En yeni ve güncellenmiş sürüm utils / text.py dosyasında bulunur ve aşağıdaki gibi "get_valid_filename" ifadesini tanımlar:

def get_valid_filename(s):
    s = str(s).strip().replace(' ', '_')
    return re.sub(r'(?u)[^-\w.]', '', s)

(Bkz. Https://github.com/django/django/blob/master/django/utils/text.py )

Sonuçta kullandığım çözüm bu:

import unicodedata

validFilenameChars = "-_.() %s%s" % (string.ascii_letters, string.digits)

def removeDisallowedFilenameChars(filename):
    cleanedFilename = unicodedata.normalize('NFKD', filename).encode('ASCII', 'ignore')
    return ''.join(c for c in cleanedFilename if c in validFilenameChars)

Unicodedata.normalize çağrısı, aksanlı karakterleri aksanlı eşdeğeriyle değiştirir; bu, yalnızca bunları çıkarmaktan daha iyidir. Bundan sonra izin verilmeyen tüm karakterler kaldırılır.

Çözümüm, izin verilmeyen dosya adlarından kaçınmak için bilinen bir dizenin başına gelmiyor, çünkü belirli dosya adı biçimim göz önüne alındığında bunların gerçekleşemeyeceğini biliyorum. Bunu yapmak için daha genel bir çözüm gerekir.

Unix sistemlerinde dosya adlarında aslında herhangi bir kısıtlama olmadığını unutmayın.

• \ 0 içeremez
• İçeremez /

Diğer her şey adil bir oyundur.

$ touch "
> hatta çok satırlı
> haha
> ^ [[31m kırmızı ^ [[0m
> kötü "
$ ls -la 
-rw-r - r-- 0 Kas 17 23:39? hatta multiline? haha ​​?? [31m kırmızı? [0m? kötü
$ ls -lab
-rw-r - r-- 0 Kas 17 23:39 \ neven \ multiline \ nhaha \ n \ 033 [31m \ kırmızı \ \ 033 [0m \ nevil
$ perl -e 'için $ i (glob (q {./* hatta *})) {print $ i; } '
./
hatta çok satırlı
haha
 kırmızı 
kötülük

Evet, ANSI Renk Kodlarını bir dosya adında sakladım ve etkili olmalarını sağladım.

Eğlence için, bir dizin adına bir BEL karakteri koyun ve içine CD yazdığınızda ortaya çıkan eğlenceyi izleyin;)

Bir satırda:

valid_file_name = re.sub('[^\w_.)( -]', '', any_string)

daha okunabilir hale getirmek için '_' karakteri de ekleyebilirsiniz (örneğin, eğik çizgilerin değiştirilmesi durumunda)

"Filelike" olmayan bir şeyi değiştirmek için re.sub () yöntemini kullanabilirsiniz. Fakat aslında her karakter geçerli olabilir; bu yüzden bunu yapmak için önceden inşa edilmiş fonksiyonlar (inanıyorum) yoktur.

import re

str = "File!name?.txt"
f = open(os.path.join("/tmp", re.sub('[^-a-zA-Z0-9_.() ]+', '', str))

/Tmp/filename.txt dosyasının dosya tanıtıcısıyla sonuçlanır.

>>> import string
>>> safechars = bytearray(('_-.()' + string.digits + string.ascii_letters).encode())
>>> allchars = bytearray(range(0x100))
>>> deletechars = bytearray(set(allchars) - set(safechars))
>>> filename = u'#ab\xa0c.$%.txt'
>>> safe_filename = filename.encode('ascii', 'ignore').translate(None, deletechars).decode()
>>> safe_filename
'abc..txt'

Boş dizeleri, özel dosya adlarını ('nul', 'con', vb.) İşlemez.

Yine de dikkatli olmalısın. Sadece latine diline bakıyorsanız, girişinizde açıkça söylenmez. Bazı kelimeler anlamsız olabilir veya yalnızca ascii karakterlerle temizlenirseniz başka bir anlam kazanabilirsiniz.

"forêt poésie" (orman şiiri) olduğunu düşünün, sanitasyonunuz "fort-posie" verebilir (güçlü + anlamsız bir şey)

Çince karakterler ile uğraşmak zorunda daha kötü.

"下 北 沢" sisteminiz bir süre sonra başarısızlığa mahkum olan ve çok yardımcı olmayan "---" ile sonuçlanabilir. Sadece dosyalarla uğraşırsanız, onları kontrol ettiğiniz jenerik bir zincir olarak adlandırmanızı veya karakterleri olduğu gibi tutmanızı öneririm. URI'ler için, neredeyse aynı.

Neden "osopen" i bir dene / hariç ile sarmıyor ve temel işletim sisteminin dosyanın geçerli olup olmadığını belirlemesine izin vermiyorsunuz?

Bu çok daha az iş gibi görünüyor ve hangi işletim sistemini kullanırsanız kullanın geçerlidir.

Diğer yorumların henüz ele almadığı başka bir sorun, açık bir şekilde geçerli bir dosya adı olmayan boş dizedir. Ayrıca, çok fazla karakter çektirmekten boş bir dize ile sonuçlanabilir.

Windows ayrılmış dosya adları ve noktalarla ilgili sorunlarda, “geçerli bir dosya adını rasgele kullanıcı girdisinden nasıl normalleştirebilirim?” Sorusunun en güvenli yanıtı nedir? "denemeyi bile denemeyin": bundan kaçınmak için başka bir yol bulabilirseniz (örneğin, veritabanındaki tamsayı birincil anahtarlarını dosya adı olarak kullanmak), bunu yapın.

Gerekirse ve gerçekten boşluklara ve '.' adın bir parçası olan dosya uzantıları için aşağıdakine benzer bir şey deneyin:

import re
badchars= re.compile(r'[^A-Za-z0-9_. ]+|^\.|\.$|^ | $|^$')
badnames= re.compile(r'(aux|com[1-9]|con|lpt[1-9]|prn)(\.|$)')

def makeName(s):
    name= badchars.sub('_', s)
    if badnames.match(name):
        name= '_'+name
    return name

Bu bile özellikle beklenmedik işletim sistemlerinde garanti edilemez - örneğin RISC işletim sistemi boşluklardan nefret eder ve 'kullanır.' dizin ayırıcı olarak.

Burada python-slugify yaklaşımını sevdim ama aynı zamanda istenmeyen noktalar da sıyırıyordu. Bu yüzden s3'e temiz bir dosya adı yüklemek için optimize ettim:

pip install python-slugify

Örnek kod:

s = 'Very / Unsafe / file\nname hähä \n\r .txt'
clean_basename = slugify(os.path.splitext(s)[0])
clean_extension = slugify(os.path.splitext(s)[1][1:])
if clean_extension:
    clean_filename = '{}.{}'.format(clean_basename, clean_extension)
elif clean_basename:
    clean_filename = clean_basename
else:
    clean_filename = 'none' # only unclean characters

Çıktı:

>>> clean_filename
'very-unsafe-file-name-haha.txt'

Bu çok güvenli, uzantısız dosya adlarıyla çalışır ve hatta yalnızca güvensiz karakterler dosya adları için çalışır (sonuç noneburada).

Yanıt python 3.6 için değiştirildi

import string
import unicodedata

validFilenameChars = "-_.() %s%s" % (string.ascii_letters, string.digits)
def removeDisallowedFilenameChars(filename):
    cleanedFilename = unicodedata.normalize('NFKD', filename).encode('ASCII', 'ignore')
    return ''.join(chr(c) for c in cleanedFilename if chr(c) in validFilenameChars)

Birçok cevap olduğunu anlıyorum, ancak çoğunlukla düzenli ifadelere veya harici modüllere güveniyorlar, bu yüzden kendi cevabımı atmak istiyorum. Saf bir python işlevi, harici modüle gerek yok, normal ifade kullanılmıyor. Benim yaklaşımım geçersiz karakterleri temizlemek değil, sadece geçerli karakterlere izin vermektir.

def normalizefilename(fn):
    validchars = "-_.() "
    out = ""
    for c in fn:
      if str.isalpha(c) or str.isdigit(c) or (c in validchars):
        out += c
      else:
        out += "_"
    return out    

İsterseniz, kendi geçerli karakterlerinizi validchars İngilizce alfabede bulunmayan ulusal harfleriniz gibi değişkene başlangıçta . Bu, isteyebileceğiniz veya istemeyebileceğiniz bir şeydir: UTF-8 üzerinde çalışmayan bazı dosya sistemleri ASCII olmayan karakterlerle ilgili sorunlar yaşayabilir.

Bu işlev, tek bir dosya adı geçerliliğini sınamak içindir, bu nedenle yol ayırıcılarını _ yerine geçersiz karakterleri dikkate alarak _ ile değiştirir. Bunu eklemek istiyorsanız if, os yol ayırıcısını içerecek şekilde değiştirmek önemsizdir .

Bu çözümlerin çoğu işe yaramıyor.

'/ merhaba / dünya' -> 'helloworld'

'/ helloworld' / -> 'helloworld'

Genel olarak istediğiniz şey bu değildir, her bağlantı için html'yi kaydettiğinizi, farklı bir web sayfası için html'nin üzerine yazacağınızı varsayalım.

Ben böyle bir dikte turşu:

{'helloworld': 
    (
    {'/hello/world': 'helloworld', '/helloworld/': 'helloworld1'},
    2)
    }

2, bir sonraki dosya adına eklenmesi gereken sayıyı temsil eder.

Her seferinde dikteden dosya adına bakıyorum. Orada değilse, gerekirse maksimum sayıyı ekleyerek yeni bir tane oluştururum.

OP'nin tam olarak ne istediğini değil, benzersiz ve geri dönüşümlü dönüşümlere ihtiyacım olduğu için kullandığım şey bu:

# p3 code
def safePath (url):
    return ''.join(map(lambda ch: chr(ch) if ch in safePath.chars else '%%%02x' % ch, url.encode('utf-8')))
safePath.chars = set(map(lambda x: ord(x), '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-_ .'))

Sonuç, en azından sistem yöneticisi açısından "bir şekilde" okunabilir.

Bir paket kurmanın sakıncası yoksa, bunun yararlı olması gerekir: https://pypi.org/project/pathvalidate/

Gönderen https://pypi.org/project/pathvalidate/#sanitize-a-filename :

from pathvalidate import sanitize_filename

fname = "fi:l*e/p\"a?t>h|.t<xt"
print(f"{fname} -> {sanitize_filename(fname)}\n")
fname = "\0_a*b:c<d>e%f/(g)h+i_0.txt"
print(f"{fname} -> {sanitize_filename(fname)}\n")

Çıktı

fi:l*e/p"a?t>h|.t<xt -> filepath.txt
_a*b:c<d>e%f/(g)h+i_0.txt -> _abcde%f(g)h+i_0.txt

Eminim bu harika bir cevap değildir, çünkü döngü yaptığı dizeyi değiştirir, ancak iyi çalışıyor gibi görünüyor:

import string
for chr in your_string:
 if chr == ' ':
   your_string = your_string.replace(' ', '_')
 elif chr not in string.ascii_letters or chr not in string.digits:
    your_string = your_string.replace(chr, '')

GÜNCELLEME

Bu 6 yaşındaki cevapta tüm bağlantılar tamir edilemedi.

Ayrıca, artık bu şekilde yapmazdım, sadece base64güvensiz karakterleri kodlayın veya bırakın. Python 3 örneği:

import re
t = re.compile("[a-zA-Z0-9.,_-]")
unsafe = "abc∂éåß®∆˚˙©¬ñ√ƒµ©∆∫ø"
safe = [ch for ch in unsafe if t.match(ch)]
# => 'abc'

İle base64 kodlama ve kod çözme yapabilirsiniz, böylece tekrar orijinal dosya adını alabilir.

Ancak, kullanım durumuna bağlı olarak rastgele bir dosya adı oluşturmak ve meta verileri ayrı bir dosya veya DB'de depolamak daha iyi olabilir.

from random import choice
from string import ascii_lowercase, ascii_uppercase, digits
allowed_chr = ascii_lowercase + ascii_uppercase + digits

safe = ''.join([choice(allowed_chr) for _ in range(16)])
# => 'CYQ4JDKE9JfcRzAZ'

ORİJİNAL LINKROTTEN YANIT :

bobcatProje sadece bunu yapar bir piton modülü içeriyor.

Tamamen sağlam değil, bu gönderiye ve bu yanıta bakın .

Bu nedenle, belirtildiği gibi: base64okunabilirliğin önemi yoksa kodlama muhtemelen daha iyi bir fikirdir.

• Dokümanlar https://svn.origo.ethz.ch/bobcat/src-doc/safefilename-module.html
• Kaynak https://svn.origo.ethz.ch/bobcat/trunk/src/bobcatlib/safefilename.py