Перетворити рядок у дійсне ім'я файлу?

У мене є рядок, який я хочу використовувати як ім'я файлу, тому я хочу видалити всі символи, які не були дозволені у іменах, використовуючи Python.

Я вважаю за краще бути суворим, ніж інакше, тому скажімо, що я хочу зберігати лише букви, цифри та невеликий набір подібних символів "_-.() ". Яке найелегантніше рішення?

Ім’я файлу має бути дійсним у кількох операційних системах (Windows, Linux та Mac OS) - це MP3-файл у моїй бібліотеці із назвою пісні як ім'я файлу, і його можна спільно використовувати та створити резервну копію між 3-ма машинами.

Ви можете подивитися на рамку Джанго, як вони створюють "кулі" з довільного тексту. Слизька є URL-адресою та ім'ям файлів.

Текстові утилі Django визначають функцію, slugify()це, мабуть, золотий стандарт для подібних речей. По суті, їх код наступний.

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

Є ще більше, але я це залишив, оскільки це не стосується слугіфікації, а втечі.

Цей підхід із білого списку (тобто, дозволяючи лише символи, наявні у valid_chars), буде працювати, якщо немає обмежень щодо форматування файлів або комбінації дійсних символів, які є незаконними (наприклад, ".."), наприклад, що ви говорите дозволить назву файлу з назвою ". txt", який, на мою думку, не є дійсним для Windows. Оскільки це найпростіший підхід, я б спробував видалити пробіл з valid_chars і додав до відомих дійсних рядків у разі помилки, будь-який інший підхід повинен знати про те, що дозволено, де можна впоратися з обмеженнями іменування файлів Windows, і таким чином бути набагато складніше.

>>> 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'

Ви можете використовувати розуміння списку разом із рядковими методами.

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

Яка причина використовувати рядки як імена файлів? Якщо читабельність людини не є фактором, я б працював з модулем base64, який може створювати безпечні рядки для файлової системи. Він не буде читабельним, але вам не доведеться боротися зі зіткненнями, він є оборотним.

import base64
file_name_string = base64.urlsafe_b64encode(your_string)

Оновлення : Змінено на основі коментаря Метью.

Для того, щоб ще більше ускладнити речі, ви не гарантуєтеся, що отримаєте дійсне ім’я файлу, просто видаливши недійсні символи. Оскільки дозволені символи відрізняються в різних іменах, консервативний підхід може перетворити дійсне ім'я в недійсне. Ви можете додати спеціальне поводження для випадків, коли:

• Рядок - це всі недійсні символи (залишаючи порожній рядок)

• Ви закінчуєте рядок зі спеціальним значенням, наприклад "." або ".."

• У Windows певні назви пристроїв зарезервовані. Наприклад, ви не можете створити файл з назвою "nul", "nul.txt" (або nul. Усе, що насправді) Зарезервовані імена:

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

Ви, ймовірно, можете подолати ці проблеми, попередньо додавши до рядків імена файлів, які ніколи не можуть призвести до жодного з цих випадків, і знявши недійсні символи.

Є хороший проект на Github під назвою python-slugify :

Встановити:

pip install python-slugify

Потім використовуйте:

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

Так само, як відповів С.Лотт , ви можете подивитися на Django Framework, як вони перетворюють рядок у допустиме ім'я файлу.

Найновіша та оновлена ​​версія міститься в utils / text.py і визначає "get_valid_filename", яка полягає в наступному:

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

(Дивіться https://github.com/django/django/blob/master/django/utils/text.py )

Це рішення, яке я в кінцевому підсумку використав:

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 замінює наголошені символи нееквівалентним еквівалентом, що краще, ніж просто викреслити їх. Після цього всі заборонені символи видаляються.

Моє рішення не передбачає відомий рядок, щоб уникнути можливих заборонених імен файлів, тому що я знаю, що вони не можуть відбутися з урахуванням мого конкретного формату імені файлу. Для цього потрібно було б отримати більш загальне рішення.

Майте на увазі, що насправді немає жодних обмежень для файлових файлів у системах Unix, крім

• Він може не містити \ 0
• Він може не містити /

Все інше - чесна гра.

$ touch "
> навіть багаторядковий
> ха-ха
> ^ [[31м червоний ^ [[0м
> злий "
$ ls -la 
-rw-r - r-- 0 17 листопада 23:39 "навіть багаторядковий" ха-ха ?? [31м червоний? [0м? зло
$ ls -лаб
-rw-r - r-- 0 17 листопада 23:39 \ neven \ multiline \ nhaha \ n \ 033 [31m \ red \ \ 033 [0m \ nevil
$ perl -e 'для мого $ i (glob (q {./* навіть *})) {print $ i; } '
./
навіть багаторядковий
ха-ха
 червоний 
зло

Так, я просто зберігав ANSI кольорові коди у назві файлу, і вони набули чинності.

Для розваги введіть символ BEL у назву каталогу та спостерігайте за задоволенням, що настає, коли ви на них CD;)

В одному рядку:

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

ви також можете поставити символ "_", щоб зробити його більш зрозумілим (наприклад, у випадку заміни косої риски)

Ви можете використовувати метод re.sub (), щоб замінити все, що не "схоже на файл". Але насправді кожен персонаж міг бути дійсним; тому немає попередньо вбудованих функцій (я вважаю), щоб це зробити.

import re

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

Це призведе до файлового файлу до /tmp/filename.txt.

>>> 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'

Він не обробляє порожні рядки, спеціальні назви файлів ('nul', 'con' тощо).

Хоча треба бути обережним. Це не чітко сказано у вашому вступі, якщо ви дивитесь лише на латинську мову. Деякі слова можуть набути безглуздого або іншого значення, якщо ви їх санітуєте лише символами ascii.

уявіть, що у вас є "forêt poésie" (лісова поезія), ваша санітарія може дати "fort-posie" (сильний + щось безглузде)

Гірше, якщо вам доведеться мати справу з китайськими символами.

"下 北 沢" ваша система може зробити "---", що приречене через деякий час вийти з ладу і не дуже корисно. Тож якщо ви маєте справу лише з файлами, я б закликав їх називати загальним ланцюгом, яким ви керуєте, або зберігати символи такими, якими вони є. Для URIs приблизно те саме.

Чому б просто не обернути "osopen" спробуйте / за винятком і дозволити базовій ОС розібратися, чи дійсний файл?

Це здається набагато меншою роботою і дійсне незалежно від того, яку ОС ви використовуєте.

Ще одне питання, до якого інші коментарі не зверталися, - це порожня рядок, яка, очевидно, не є дійсною назвою файлу. Ви також можете заповнити порожній рядок, не забираючи занадто багато символів.

Що з зарезервованими іменами Windows і проблемами з крапками, найбезпечніша відповідь на питання "як я нормалізую дійсне ім'я файлу з довільного введення користувача?" - це "навіть не турбуйся": якщо ти можеш знайти будь-який інший спосіб уникнути цього (наприклад, використовуючи цілі первинні ключі від бази даних як імена файлів), зроби це.

Якщо потрібно, і вам потрібно дозволити пробіли та "." для розширень файлів як частини імені спробуйте щось на кшталт:

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

Навіть це не може бути гарантовано правильно, особливо на несподіваних ОС - наприклад, RISC OS ненавидить місця та використання '.' як роздільник каталогів.

Мені тут сподобався слуховий підхід пітона, але він також знімав крапки, які не бажали. Тому я оптимізував це для завантаження чистого імені файлу в s3 таким чином:

pip install python-slugify

Приклад коду:

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

Вихід:

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

Це настільки небезпечно, він працює з іменами файлів без розширення і працює навіть лише для небезпечних імен файлів символів (результат noneтут).

Відповідь змінена для python 3.6

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)

Я розумію, що відповідей багато, але вони в основному покладаються на регулярні вирази або зовнішні модулі, тому я хотів би дати свою відповідь. Чиста функція пітона, не потрібен зовнішній модуль, не використовується регулярний вираз. Мій підхід полягає не в тому, щоб очистити недійсні символи, а дозволити лише дійсні.

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    

якщо вам подобається, ви можете додати свої власні дійсні символи до validcharsзмінної на початку, наприклад, ваші національні літери, які відсутні в англійському алфавіті. Це те, що ви можете або не хочете: деякі файлові системи, які не працюють на UTF-8, все ще можуть мати проблеми з символами, що не належать до ASCII.

Ця функція полягає в тестуванні дійсності одного імені файлу, тому він замінить роздільники шляхів _, вважаючи їх недійсними символами. Якщо ви хочете додати це, тривіально змінити, ifщоб включити роздільник шляху os.

Більшість цих рішень не працюють.

'/ hello / world' -> 'helloworld'

'/ helloworld' / -> 'helloworld'

Це, як правило, не те, що ви хочете, скажімо, ви зберігаєте HTML для кожного посилання, ви збираєтеся замінити HTML на іншу веб-сторінку.

Я підбираю диктант, такий як:

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

2 представляє число, яке слід додати до наступного імені файлу.

Я шукаю ім'я файлу кожного разу з диктату. Якщо його немає, я створюю новий, додаючи при необхідності максимальне число.

Не зовсім те, що просила ОП, але це те, що я використовую, тому що мені потрібні унікальні та оборотні перетворення:

# 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+-_ .'))

Результат "дещо" читабельний, принаймні з точки зору систематичного управління.

Якщо ви не проти встановити пакет, це повинно бути корисно: https://pypi.org/project/pathvalidate/

З 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")

Вихідні дані

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

Я впевнений, що це не чудова відповідь, оскільки це змінює рядок, який він перекидає, але, здається, працює добре:

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, '')

ОНОВЛЕННЯ

У цьому 6-річному відповіді всі ланки, які не виправлені, не виправлені.

Крім того, я б більше не робив це таким чином, просто base64кодував або відкидав небезпечні символи. Приклад Python 3:

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

З base64ви можете кодувати і декодувати, так що ви можете отримати вихідне ім'я файлу знову.

Але залежно від випадку використання вам може бути краще генерувати випадкове ім’я файлу та зберігати метадані в окремому файлі чи БД.

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'

ОРИГІНАЛЬНА ВІДПОВІДЬ :

bobcatПроект містить модуль пітона , який робить саме це.

Це не зовсім надійно, дивіться цю публікацію та цю відповідь .

Отже, як зазначалося: base64кодування, мабуть, краща ідея, якщо читабельність не має значення.

• Документи https://svn.origo.ethz.ch/bobcat/src-doc/safefilename-module.html
• Джерело https://svn.origo.ethz.ch/bobcat/trunk/src/bobcatlib/safefilename.py