Превратить строку в правильное имя файла?

У меня есть строка, которую я хочу использовать в качестве имени файла, поэтому я хочу удалить все символы, которые не допускаются в именах файлов, используя Python.

Я предпочел бы быть строгим, чем иначе, поэтому допустим, что я хочу сохранить только буквы, цифры и небольшой набор других символов, таких как "_-.() ". Какое самое элегантное решение?

Имя файла должно быть действительным в нескольких операционных системах (Windows, Linux и Mac OS) - это файл MP3 в моей библиотеке с названием песни в качестве имени файла, который разделяется и резервируется между 3 компьютерами.

Вы можете посмотреть на структуру Django, как они создают «слаг» из произвольного текста. Слаг - это 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)

Обновление : изменено на основе комментария Мэтью.

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

• Строка содержит все недопустимые символы (оставляя вас с пустой строкой)

• Вы получите строку со специальным значением, например, "." или ".."

• На окнах определенные имена устройств зарезервированы. Например, вы не можете создать файл с именем "nul", "nul.txt" (или фактически nul.anything). Зарезервированные имена:

  CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, ​​COM5, COM6, COM7, 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 -lab
-rw-r - r-- 0 17 ноября 23:39 \ neven \ multiline \ nhaha \ n \ 033 [31m \ red \ \ 033 [0m \ nevil
$ perl -e 'для моего $ i (glob (q {./* even *})) {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» (сильный + что-то бессмысленное)

Хуже, если вам приходится иметь дело с китайскими иероглифами.

«下 北 沢» ваша система может выполнить «---», что через некоторое время обречено на неудачу и не очень полезно. Поэтому, если вы имеете дело только с файлами, я бы посоветовал назвать их общей цепочкой, которой вы управляете, или оставить символы такими, какие они есть. Для URI примерно то же самое.

Почему бы просто не обернуть «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 ненавидит пробелы и использует '.' в качестве разделителя каталогов.

Мне здесь понравился подход, связанный с питоном, но он также удалял точки, что было нежелательно. Поэтому я оптимизировал его для загрузки чистого имени файла в 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)

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

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 представляет число, которое должно быть добавлено к следующему имени файла.

Я смотрю имя файла каждый раз из диктата. Если его там нет, я создаю новый, добавляя максимальное количество, если это необходимо.

Не совсем то, о чем просил OP, но это то, что я использую, потому что мне нужны уникальные и обратимые преобразования:

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

ОРИГИНАЛЬНЫЙ LINKROTTEN ОТВЕТ :

bobcatПроект содержит модуль питона , который делает именно это.

Это не совсем надежно, см. Этот пост и этот ответ .

Итак, как отмечалось: base64кодирование, вероятно, является лучшей идеей, если читаемость не имеет значения.

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