පයිතන් හි ගොනු නාමයෙන් දිගුව උපුටා ගැනීම

ගොනු නාමයකින් දිගුව උපුටා ගැනීමට ශ්‍රිතයක් තිබේද?

ඔව්. භාවිතා කරන්න os.path.splitext( පයිතන් 2.X ප්‍රලේඛනය හෝ පයිතන් 3.X ප්‍රලේඛනය බලන්න ):

>>> import os
>>> filename, file_extension = os.path.splitext('/path/to/somefile.ext')
>>> filename
'/path/to/somefile'
>>> file_extension
'.ext'

බොහෝ අතින් නූල් බෙදීමේ උත්සාහයන් මෙන් නොව, දිගුවක් වෙනුවට දිගුවක් නොමැති os.path.splitextබව නිවැරදිව සලකනු /a/b.c/dඇති අතර .c/d, එය .bashrcදිගුවක් වෙනුවට දිගුවක් නොමැති බව සලකනු ඇත .bashrc:

>>> os.path.splitext('/a/b.c/d')
('/a/b.c/d', '')
>>> os.path.splitext('.bashrc')
('.bashrc', '')

import os.path
extension = os.path.splitext(filename)[1]

3.4 අනුවාදයේ නව.

import pathlib

print(pathlib.Path('yourPath.example').suffix) # '.example'

කිසිවෙකු pathlibතවමත් සඳහන් නොකිරීම ගැන මට පුදුමයි , pathlibනියමයි!

ඔබට සියලු උපසර්ගයන් අවශ්‍ය නම් (උදා: ඔබට අ .tar.gz) තිබේ නම් , .suffixesඒවා ලැයිස්තුවක් නැවත ලබා දෙනු ඇත!

import os.path
extension = os.path.splitext(filename)[1][1:]

තිතක් නොමැතිව දිගුවේ පෙළ පමණක් ලබා ගැනීමට.

සරල භාවිත අවස්ථා සඳහා එක් විකල්පයක් තිතෙන් බෙදිය හැකිය:

>>> filename = "example.jpeg"
>>> filename.split(".")[-1]
'jpeg'

ගොනුවට දිගුවක් නොමැති විට දෝෂයක් නොමැත:

>>> "filename".split(".")[-1]
'filename'

නමුත් ඔබ ප්‍රවේශම් විය යුතුයි:

>>> "png".split(".")[-1]
'png'    # But file doesn't have an extension

යුනික්ස් පද්ධතිවල සැඟවුණු ලිපිගොනු සමඟ ක්‍රියා නොකරනු ඇත:

>>> ".bashrc".split(".")[-1]
'bashrc'    # But this is not an extension

සාමාන්‍ය භාවිතය සඳහා, කැමති වන්න os.path.splitext

එහි පහළට එකතු කිරීම වටී, එබැවින් ඔබේ ලැයිස්තුවේ JPG නොපෙන්වන්නේ මන්දැයි ඔබ කල්පනා නොකරයි.

os.path.splitext(filename)[1][1:].strip().lower()

ඉහත සඳහන් ඕනෑම විසඳුමක් ක්‍රියාත්මක වේ, නමුත් ලිනක්ස් හි මම සොයාගෙන ඇත්තේ දිගු කිරීමේ නූල අවසානයේ නව රේඛාවක් ඇති අතර එමඟින් තරඟ සාර්ථක වීම වලක්වනු ඇත. strip()ක්රමය අවසානයට එකතු කරන්න . උදාහරණයක් වශයෙන්:

import os.path
extension = os.path.splitext(filename)[1][1:].strip() 

Splitext සමග ද්විත්ව දීර්ඝ ලිපි ගොනු සමඟ ගැටළු (උදා: ඇත file.tar.gz, file.tar.bz2ආදිය ..)

>>> fileName, fileExtension = os.path.splitext('/path/to/somefile.tar.gz')
>>> fileExtension 
'.gz'

නමුත් විය යුත්තේ: .tar.gz

හැකි විසඳුම් මෙහි ඇත

පාත්ලිබ් මොඩියුලයේ ඔබට විශාල දේවල් සොයාගත හැකිය (පයිතන් 3.x හි ඇත).

import pathlib
x = pathlib.PurePosixPath("C:\\Path\\To\\File\\myfile.txt").suffix
print(x)

# Output 
'.txt'

හුදෙක් joinසියලු pathlib suffixes.

>>> x = 'file/path/archive.tar.gz'
>>> y = 'file/path/text.txt'
>>> ''.join(pathlib.Path(x).suffixes)
'.tar.gz'
>>> ''.join(pathlib.Path(y).suffixes)
'.txt'

එය පැරණි මාතෘකාවක් වුවද, මෙම නඩුවේ rpartition නමින් ඉතා සරල පයිතන් වර්ගයක් සඳහන් නොකිරීමට හේතුව කුමක්දැයි මම කල්පනා කරමි.

දී ඇති ගොනුවේ නිරපේක්ෂ මාර්ගය දීර් extension කිරීම සඳහා, ඔබට සරලව ටයිප් කළ හැකිය:

filepath.rpartition('.')[-1]

උදාහරණයක්:

path = '/home/jersey/remote/data/test.csv'
print path.rpartition('.')[-1]

ඔබට ලබා දෙනු ඇත: 'csv'

පුදුමයට කරුණක් නම් මෙය තවම සඳහන් නොවීමයි:

import os
fn = '/some/path/a.tar.gz'

basename = os.path.basename(fn)  # os independent
Out[] a.tar.gz

base = basename.split('.')[0]
Out[] a

ext = '.'.join(basename.split('.')[1:])   # <-- main part

# if you want a leading '.', and if no result `None`:
ext = '.' + ext if ext else None
Out[] .tar.gz

ප්‍රතිලාභ:

• මට සිතිය හැකි ඕනෑම දෙයක් සඳහා අපේක්ෂිත පරිදි ක්‍රියා කරයි
• මොඩියුල නොමැත
• රීජෙක්ස් නැත
• හරස් වේදිකාව
• පහසුවෙන් විස්තාරණය කළ හැකිය (උදා: දිගුව සඳහා ප්‍රමුඛ තිත් නැත, දිගුවේ අවසාන කොටස පමණි)

ශ්‍රිතය ලෙස:

def get_extension(filename):
    basename = os.path.basename(filename)  # os independent
    ext = '.'.join(basename.split('.')[1:])
    return '.' + ext if ext else None

ඔබ භාවිතා කළ හැකිය splitමත filename:

f_extns = filename.split(".")
print ("The extension of the file is : " + repr(f_extns[-1]))

මේ සඳහා අමතර පුස්තකාලයක් අවශ්‍ය නොවේ

filename='ext.tar.gz'
extension = filename[filename.rfind('.'):]

මෙය string ජු නූල් නිරූපණ ක්‍රමයකි: සඳහන් කර ඇති විසඳුම් රාශියක් මා දකින නමුත් බොහෝ දෙනා භේදය දෙස බලයි. කෙසේ වෙතත් බෙදීම එය "සෑම අවස්ථාවකම" කරයි. . ඔබ සොයන්නේ බෙදීමයි.

string = "folder/to_path/filename.ext"
extension = string.rpartition(".")[-1]

නිවැරදි භේදය සහිත තවත් විසඳුමක්:

# to get extension only

s = 'test.ext'

if '.' in s: ext = s.rsplit('.', 1)[1]

# or, to get file name and extension

def split_filepath(s):
    """
    get filename and extension from filepath 
    filepath -> (filename, extension)
    """
    if not '.' in s: return (s, '')
    r = s.rsplit('.', 1)
    return (r[0], r[1])

මෙම ප්‍රශ්නයට දැනටමත් පිළිතුරු ලැබී ඇති අතර මම විසඳුම රෙජෙක්ස් හි එක් කරමි.

>>> import re
>>> file_suffix = ".*(\..*)"
>>> result = re.search(file_suffix, "somefile.ext")
>>> result.group(1)
'.ext'

සැබෑ එක් ලයිනර්, ඔබ රීජෙක්ස් වලට කැමති නම්. ඔබට අතිරේක "" තිබුණත් කමක් නැත. අතරමැද දී

import re

file_ext = re.search(r"\.([^.]+)$", filename).group(1)

ප්රති result ලය සඳහා මෙහි බලන්න: මෙතැන ක්ලික් කරන්න

මේ සරලම ක්රමය හුදෙක් දී ගොනු සහ ව්යාප්ති දෙකම ලබා ගැනීමට තනි මාර්ගය .

fName, ext = 'C:/folder name/Flower.jpeg'.split('/')[-1].split('.')

>>> print(fName)
Flower
>>> print(ext)
jpeg

වෙනත් විසඳුම් මෙන් නොව, මේ සඳහා ඔබට කිසිදු පැකේජයක් ආනයනය කිරීමට අවශ්‍ය නොවේ.

විනෝදය සඳහා ... දිගුව ඩෙක්ට් එකකින් එකතු කර ඒවා සියල්ලම ෆෝල්ඩරයක ලුහුබඳින්න. ඉන්පසු ඔබට අවශ්‍ය දිගු අදින්න.

import os

search = {}

for f in os.listdir(os.getcwd()):
    fn, fe = os.path.splitext(f)
    try:
        search[fe].append(f)
    except:
        search[fe]=[f,]

extensions = ('.png','.jpg')
for ex in extensions:
    found = search.get(ex,'')
    if found:
        print(found)

මේක උත්සාහ කරන්න:

files = ['file.jpeg','file.tar.gz','file.png','file.foo.bar','file.etc']
pen_ext = ['foo', 'tar', 'bar', 'etc']

for file in files: #1
    if (file.split(".")[-2] in pen_ext): #2
        ext =  file.split(".")[-2]+"."+file.split(".")[-1]#3
    else:
        ext = file.split(".")[-1] #4
    print (ext) #5

1. සියලුම ගොනු නාමයන් ලැයිස්තුව තුළ ලබා ගන්න
2. ගොනුවේ නම බෙදීම සහ අවසාන දිගුව පරීක්ෂා කරන්න, එය pen_ext ලැයිස්තුවේ තිබේද නැද්ද?
3. ඔව් නම් එය අවසන් දිගුව සමඟ සම්බන්ධ කර එය ගොනුවේ දිගුව ලෙස සකසන්න
4. එසේ නොවේ නම් අවසාන දිගුව ගොනුවේ දිගුව ලෙස තබන්න
5. ඉන්පසු එය පරීක්ෂා කරන්න

# try this, it works for anything, any length of extension
# e.g www.google.com/downloads/file1.gz.rs -> .gz.rs

import os.path

class LinkChecker:

    @staticmethod
    def get_link_extension(link: str)->str:
        if link is None or link == "":
            return ""
        else:
            paths = os.path.splitext(link)
            ext = paths[1]
            new_link = paths[0]
            if ext != "":
                return LinkChecker.get_link_extension(new_link) + ext
            else:
                return ""

def NewFileName(fichier):
    cpt = 0
    fic , *ext =  fichier.split('.')
    ext = '.'.join(ext)
    while os.path.isfile(fichier):
        cpt += 1
        fichier = '{0}-({1}).{2}'.format(fic, cpt, ext)
    return fichier

name_only=file_name[:filename.index(".")

එමඟින් ඔබට ගොනුවේ නම පළමු "." දක්වා ලබා දෙනු ඇත, එය වඩාත් සුලභ වනු ඇත.