将字符串转换为有效的文件名?

这种白名单方法(即，只允许valid_chars中出现的字符)将在对文件格式或非法有效字符的组合(如“..”)没有限制的情况下工作，例如，您所说的将允许名为“”的文件名。我认为在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'

你可以使用re.sub()方法替换任何非“类文件”的东西。但实际上，每个字符都可以是有效的;所以没有预先构建的函数(我相信)来完成它。

import re


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

将导致/tmp/filename.txt的文件句柄。

使用字符串作为文件名的原因是什么?如果人类的可读性不是一个因素，我会使用base64模块，它可以产生文件系统安全字符串。它是不可读的，但你不需要处理碰撞，而且它是可逆的。

import base64
file_name_string = base64.urlsafe_b64encode(your_string)

更新:根据Matthew注释更改。

您可以将列表推导式与字符串方法一起使用。

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

更复杂的是，仅仅删除无效字符并不能保证获得有效的文件名。由于允许的字符在不同的文件名上不同，保守的方法可能最终会将一个有效的名称变成一个无效的名称。你可能想在以下情况下添加特殊处理:

• 字符串都是无效字符(留下一个空字符串)

• 你最终会得到一个具有特殊含义的字符串，例如"."或".."

• 在windows上，某些设备名称是保留的。例如，你不能创建一个名为“nul”，“null .txt”(或nul.txt)的文件。)保留的名字是:

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

您可能可以通过在文件名前添加一些字符串来解决这些问题，这些字符串永远不会导致这些情况之一，并剥离无效字符。

>>> 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'等)。

请记住，在Unix系统上实际上没有文件名限制

• 它可能不包含\0
• 它可能不包含/

其他一切都是公平的。

$ touch "
> even multiline
> haha
> ^[[31m red ^[[0m
> evil"
$ ls -la
-rw-r--r--       0 Nov 17 23:39 ?even multiline?haha??[31m red ?[0m?evil
$ ls -lab
-rw-r--r--       0 Nov 17 23:39 \neven\ multiline\nhaha\n\033[31m\ red\ \033[0m\nevil
$ perl -e 'for my $i ( glob(q{./*even*}) ){ print $i; } '
./
even multiline
haha
red
evil

是的，我只是将ANSI颜色代码存储在一个文件名中，并使它们生效。

为了娱乐，在目录名中放入一个BEL字符，并观看当您CD到其中时所产生的乐趣;)

为什么不直接用try/except来包装“osopen”，让底层操作系统来判断文件是否有效?

这看起来工作量少得多，而且无论您使用哪种操作系统都是有效的。

你可以看看Django框架，看看它们是如何创建一个“;slug"从任意文本。段代码是URL和文件名友好的。

Django文本utils定义了一个函数slugify()，这可能是这类事情的黄金标准。本质上，他们的代码如下。

import unicodedata
import re


def slugify(value, allow_unicode=False):
"""
Taken from https://github.com/django/django/blob/master/django/utils/text.py
Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
dashes to single dashes. Remove characters that aren't alphanumerics,
underscores, or hyphens. Convert to lowercase. Also strip leading and
trailing whitespace, dashes, and underscores.
"""
value = str(value)
if allow_unicode:
value = unicodedata.normalize('NFKC', value)
else:
value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii')
value = re.sub(r'[^\w\s-]', '', value.lower())
return re.sub(r'[-\s]+', '-', value).strip('-_')

旧版本是:

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

还有更多，但我把它省略了，因为它没有解决怠惰，而是逃避。

其他注释还没有解决的另一个问题是空字符串，这显然不是一个有效的文件名。你也可能因为剥离太多字符而得到一个空字符串。

对于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操作系统讨厌空格并使用'。'作为目录分隔符。

不过你得小心点。如果你只看拉丁语言，在你的介绍中没有清楚地说出来。如果您仅使用ascii字符对某些单词进行消毒，它们可能会变得毫无意义或具有其他含义。

假设你有“forêt poésie”(森林诗歌)，你的消毒可能会给“堡垒-posie”(强大+无意义的东西)

如果你必须处理汉字，那就更糟了。

“下北沢”您的系统可能最终会执行“——”，这注定会在一段时间后失败，而且没有多大帮助。因此，如果您只处理文件，我建议您将它们称为您控制的通用链，或者保持字符原样。对于uri，大致相同。

这是我最终使用的解决方案:

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调用将重音字符替换为同等的非重音字符，这比简单地将它们剥离要好。之后，所有不允许的字符都将被删除。

我的解决方案没有预先添加一个已知字符串，以避免可能的不允许文件名，因为我知道给定特定的文件名格式，它们不会出现。这需要一个更普遍的解决方案。

更新

在这个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可以进行编码和解码，因此可以再次检索原始文件名。

但是根据用例，最好生成一个随机文件名并将元数据存储在单独的文件或DB中。

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项目包含一个python模块。

它不是完全健壮的，看这个帖子和这个回复。

因此，如前所述:如果可读性不重要，base64编码可能是一个更好的主意。

• 文档https://svn.origo.ethz.ch/bobcat/src-doc/safefilename-module.html
• 源https://svn.origo.ethz.ch/bobcat/trunk/src/bobcatlib/safefilename.py

我相信这不是一个很好的答案，因为它修改了它循环的字符串，但它似乎工作得很好:

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

大多数解决方案都不起作用。

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

结果“有些”可读，至少从系统管理员的角度来看是这样。

在Github上有一个很好的项目，叫做python-slugify:

安装:

pip install python-slugify

然后使用:

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

一句话:

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

你也可以用“_”字符让它更具可读性(例如替换斜杠)

我喜欢这里的python-slugify方法，但它也剥离点，这是不希望的。所以我优化了上传一个干净的文件名到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)。

就像S.Lott回答的一样，你可以看看Django框架如何将字符串转换为有效的文件名。

最新和更新的版本在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)

我知道有很多答案，但它们大多依赖于正则表达式或外部模块，所以我想抛出我自己的答案。一个纯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以包含操作系统路径分隔符是很简单的。

为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)

从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

给，这应该涵盖了所有的基础。它为您处理所有类型的问题，包括(但不限于)字符替换。

适用于Windows、*nix和几乎所有其他文件系统。只允许打印字符。

def txt2filename(txt, chr_set='normal'):
"""Converts txt to a valid Windows/*nix filename with printable characters only.


args:
txt: The str to convert.
chr_set: 'normal', 'universal', or 'inclusive'.
'universal':    ' -.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
'normal':       Every printable character exept those disallowed on Windows/*nix.
'extended':     All 'normal' characters plus the extended character ASCII codes 128-255
"""


FILLER = '-'


# Step 1: Remove excluded characters.
if chr_set == 'universal':
# Lookups in a set are O(n) vs O(n * x) for a str.
printables = set(' -.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')
else:
if chr_set == 'normal':
max_chr = 127
elif chr_set == 'extended':
max_chr = 256
else:
raise ValueError(f'The chr_set argument may be normal, extended or universal; not {chr_set=}')
EXCLUDED_CHRS = set(r'<>:"/\|?*')               # Illegal characters in Windows filenames.
EXCLUDED_CHRS.update(chr(127))                  # DEL (non-printable).
printables = set(chr(x)
for x in range(32, max_chr)
if chr(x) not in EXCLUDED_CHRS)
result = ''.join(x if x in printables else FILLER   # Allow printable characters only.
for x in txt)


# Step 2: Device names, '.', and '..' are invalid filenames in Windows.
DEVICE_NAMES = 'CON,PRN,AUX,NUL,COM1,COM2,COM3,COM4,' \
'COM5,COM6,COM7,COM8,COM9,LPT1,LPT2,' \
'LPT3,LPT4,LPT5,LPT6,LPT7,LPT8,LPT9,' \
'CONIN$,CONOUT$,..,.'.split()        # This list is an O(n) operation.
if result in DEVICE_NAMES:
result = f'-{result}-'


# Step 3: Maximum length of filename is 255 bytes in Windows and Linux (other *nix flavors may allow longer names).
result = result[:255]


# Step 4: Windows does not allow filenames to end with '.' or ' ' or begin with ' '.
result = re.sub(r'^[. ]', FILLER, result)
result = re.sub(r' $', FILLER, result)


return result

这个解决方案不需要外部库。它也替代了不可打印的文件名，因为它们并不总是容易处理。

当遇到同样的问题时，我使用python-slugify。

Shoham也建议使用这种方法，但正如therealmarv指出的那样，默认情况下python-slugify也会转换圆点。

这种行为可以通过在regex_pattern参数中包含圆点来否决。

> filename = "This is a väryì' Strange File-Nömé.jpeg"
> pattern = re.compile(r'[^-a-zA-Z0-9.]+')
> slugify(filename,regex_pattern=pattern)
'this-is-a-varyi-strange-file-nome.jpeg'

方法复制的正则表达式模式

ALLOWED_CHARS_PATTERN_WITH_UPPERCASE

python-slugify包的slugify.py文件中的全局变量，并扩展为"

请记住，像.()这样的特殊字符必须用\进行转义。

如果你想保留大写字母，使用lowercase=False参数。

> filename = "This is a väryì' Strange File-Nömé.jpeg"
> pattern = re.compile(r'[^-a-zA-Z0-9.]+')
> slugify(filename,regex_pattern=pattern, lowercase=False)
'This-is-a-varyi-Strange-File-Nome.jpeg'

这是使用Python 3.8.4和Python -slugify 4.0.1实现的

这是Windows特定路径的另一个答案，使用简单的替换，没有时髦的模块:

import re


def check_for_illegal_char(input_str):
# remove illegal characters for Windows file names/paths
# (illegal filenames are a superset (41) of the illegal path names (36))
# this is according to windows blacklist obtained with Powershell
# from: https://stackoverflow.com/questions/1976007/what-characters-are-forbidden-in-windows-and-linux-directory-names/44750843#44750843
#
# PS> $enc = [system.Text.Encoding]::UTF8
# PS> $FileNameInvalidChars = [System.IO.Path]::GetInvalidFileNameChars()
# PS> $FileNameInvalidChars | foreach { $enc.GetBytes($_) } | Out-File -FilePath InvalidFileCharCodes.txt


illegal = '\u0022\u003c\u003e\u007c\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008' + \
'\u0009\u000a\u000b\u000c\u000d\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015' + \
'\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f\u003a\u002a\u003f\u005c\u002f'


output_str, _ = re.subn('['+illegal+']','_', input_str)
output_str = output_str.replace('\\','_')   # backslash cannot be handled by regex
output_str = output_str.replace('..','_')   # double dots are illegal too, or at least a bad idea
output_str = output_str[:-1] if output_str[-1] == '.' else output_str # can't have end of line '.'


if output_str != input_str:
print(f"The name '{input_str}' had invalid characters, "
f"name was modified to '{output_str}'")


return output_str

当用check_for_illegal_char('fas\u0003\u0004good\\..asd.')测试时，我得到:

The name 'fas♥♦good\..asd.' had invalid characters, name was modified to 'fas__good__asd'

仍然没有找到一个好的库来生成有效的文件名。注意，在德语、挪威语或法语等语言中，文件名中的特殊字符非常常见，完全可以接受。所以我最终有了自己的图书馆:

# util/files.py


CHAR_MAX_LEN = 31
CHAR_REPLACE = '_'


ILLEGAL_CHARS = [
'#',  # pound
'%',  # percent
'&',  # ampersand
'{',  # left curly bracket
'}',  # right curly bracket
'\\',  # back slash
'<',  # left angle bracket
'>',  # right angle bracket
'*',  # asterisk
'?',  # question mark
'/',  # forward slash
' ',  # blank spaces
'$',  # dollar sign
'!',  # exclamation point
"'",  # single quotes
'"',  # double quotes
':',  # colon
'@',  # at sign
'+',  # plus sign
'`',  # backtick
'|',  # pipe
'=',  # equal sign
]




def generate_filename(
name, char_replace=CHAR_REPLACE, length=CHAR_MAX_LEN,
illegal=ILLEGAL_CHARS, replace_dot=False):
''' return clean filename '''
# init
_elem = name.split('.')
extension = _elem[-1].strip()
_length = length - len(extension) - 1
label = '.'.join(_elem[:-1]).strip()[:_length]
filename = ''
    

# replace '.' ?
if replace_dot:
label = label.replace('.', char_replace)
    

# clean
for char in label + '.' + extension:
if char in illegal:
char = char_replace
filename += char
    

return filename

generate_filename('nucgae zutaäer..0.1.docx', replace_dot=False)

nucgae_zutaaer . . 0.1.docx

generate_filename('nucgae zutaäer..0.1.docx', replace_dot=True)

nucgae_zutaaer__0_1.docx