পাইথনে উদ্ধৃত সাবস্ট্রিংগুলি সংরক্ষণ করে - স্পেস দিয়ে একটি স্ট্রিং বিভক্ত করুন

Question

আমার কাছে একটি স্ট্রিং রয়েছে যা এই জাতীয়:

this is "a test"

উদ্ধৃতিগুলির মধ্যে ফাঁকা স্থানগুলি উপেক্ষা করার সময় আমি পাইথনে কিছু লেখার চেষ্টা করছিলাম এটি স্পেস দ্বারা বিভক্ত করার জন্য। আমি যে ফলাফলটি সন্ধান করছি তা হ'ল:

['this','is','a test']

পুনশ্চ. আমি জানি আপনি "জিজ্ঞাসা করতে যাচ্ছেন যদি আমার উক্তিগুলির মধ্যে উদ্ধৃতিগুলি থাকে তবে ভাল হয়, আমার আবেদনে, এটি কখনই ঘটবে না।

Comments

এই প্রশ্ন জিজ্ঞাসা করার জন্য ধন্যবাদ। পাইপার বিল্ড মডিউল ঠিক করার জন্য আমার ঠিক এটির প্রয়োজন ছিল।

— মার্টারলাক

Answer 1

আপনি splitবিল্ট ইন shlexমডিউল থেকে চান ।

>>> import shlex
>>> shlex.split('this is "a test"')
['this', 'is', 'a test']

এটি আপনার যা ইচ্ছা ঠিক তা করা উচিত।

Comments

উদ্ধৃতি সংরক্ষণ করতে "পিক্সিক্স = মিথ্যা" ব্যবহার করুন। shlex.split('this is "a test"', posix=False)রিটার্ন['this', 'is', '"a test"']

— বুন

@MatthewG। পাইথন ২.7.৩ এ "ফিক্স" এর অর্থ একটি ইউনিকোড স্ট্রিংটি পাস করার ব্যতিক্রম shlex.split()ঘটবে UnicodeEncodeError।

— রকালোলাইট

Answer 2

shlexবিশেষ করে মডিউলটি দেখুন shlex.split।

>>> import shlex
>>> shlex.split('This is "a test"')
['This', 'is', 'a test']

Answer 3

আমি এখানে রেইগেক্স পন্থাগুলি দেখতে পাচ্ছি যা জটিল এবং / অথবা ভুল দেখাচ্ছে। এটি আমাকে অবাক করে দেয়, কারণ রেজেক্সেক্স সিনট্যাক্স সহজেই "হোয়াইটস্পেস বা জিনিস-চারপাশে-দ্বারা-কোটস" -কে বর্ণনা করতে পারে এবং বেশিরভাগ রেইজেক্স ইঞ্জিন (পাইথন সহ) একটি রেজেক্সে বিভক্ত হতে পারে। সুতরাং আপনি যদি রেজিক্সগুলি ব্যবহার করতে যাচ্ছেন তবে কেন আপনি ঠিক তাই বলছেন না কেন ?:

test = 'this is "a test"'  # or "this is 'a test'"
# pieces = [p for p in re.split("( |[\\\"'].*[\\\"'])", test) if p.strip()]
# From comments, use this:
pieces = [p for p in re.split("( |\\\".*?\\\"|'.*?')", test) if p.strip()]

ব্যাখ্যা:

[\\\"'] = double-quote or single-quote
.* = anything
( |X) = space or X
.strip() = remove space and empty-string separators

যদিও শ্লেক্স সম্ভবত আরও বৈশিষ্ট্য সরবরাহ করে।

Comments

আমি অনেক একই চিন্তা করছিলাম, তবে এর পরিবর্তে [t.strip ('')) টি পুনঃফাইন্ডল (r '[^ \ s "] + +" "" ^ "] *"', 'এটি " একটি পরীক্ষা "')]

— দারিয়াস বেকন

+1 আমি এটি ব্যবহার করছি কারণ এটি শ্লেক্সের চেয়ে অনেক দ্রুত গতিযুক্ত।

— hanleyp

ট্রিপল ব্যাকস্ল্যাশ কেন? একটি সাধারণ ব্যাকস্ল্যাশ একই কাজ করবে না?

— ডপপেলঞ্জার

প্রকৃতপক্ষে, একটি জিনিস যা আমি পছন্দ করি না তা হ'ল উদ্ধৃতিগুলির আগে / পরে কিছু সঠিকভাবে বিভক্ত হয় না। আমার কাছে যদি এই 'পারমস ভাল 1 = "থিং" ভাল 2 = "থিং 2"' এর মতো স্ট্রিং থাকে। আমি স্ট্রিংটি তিন টুকরো হয়ে বিভক্ত হওয়ার প্রত্যাশা করছি, তবে এটি 5 টিতে বিভক্ত হয়ে গেছে যখন আমি রিজেক্স করেছি কিছুদিন হয়ে গেছে, তাই এখনই আপনার সমাধানটি ব্যবহার করে সমাধান করার চেষ্টা করার মতো মনে হচ্ছে না।

— leetNightshade

নিয়মিত এক্সপ্রেশন ব্যবহার করার সময় আপনার কাঁচা স্ট্রিং ব্যবহার করা উচিত।

— asmeurer

Answer 4

আপনার ব্যবহারের ক্ষেত্রে উপর নির্ভর করে আপনি মডিউলটিও দেখতে চাইতে পারেন csv:

import csv
lines = ['this is "a string"', 'and more "stuff"']
for row in csv.reader(lines, delimiter=" "):
    print(row)

আউটপুট:

['this', 'is', 'a string']
['and', 'more', 'stuff']

Comments

দরকারী, যখন শ্লেক্স কিছু প্রয়োজনীয় অক্ষর ফেলা করে

— স্ক্র্যাপলেশ

যে CSV এর ব্যবহার দুই পরপর উদ্ধৃতি চিহ্ন (সাইড-বাই-সাইড হিসাবে, "") এক ডাবল উদ্ধৃতি প্রতিনিধিত্ব করতে ", তাই একটি একক উদ্ধৃতি দুই উদ্ধৃতি চিহ্ন চালু হবে 'this is "a string""'এবং 'this is "a string"""'হবে উভয় মানচিত্রে['this', 'is', 'a string"']

— বরিস

Answer 5

আমি 70,000,000 লাইনের স্কুইড লগ প্রক্রিয়া করতে shlex.split ব্যবহার করি, এটি এত ধীর। তাই আমি রি ফিরে।

শ্লেক্সের সাথে পারফরম্যান্স সমস্যা থাকলে দয়া করে এটি চেষ্টা করুন।

import re

def line_split(line):
    return re.findall(r'[^"\s]\S*|".+?"', line)

Answer 6

যেহেতু এই প্রশ্নটি রেজেক্সের সাথে ট্যাগ করা হয়েছে, তাই আমি সিদ্ধান্ত নিয়েছি একটি রেজেক্স পদ্ধতির চেষ্টা করব। আমি প্রথমে উদ্ধৃতি অংশের সমস্ত স্পেসকে \ x00 দিয়ে প্রতিস্থাপন করব, তারপরে ফাঁক দিয়ে বিভক্ত করুন, তারপরে প্রতিটি অংশের ফাঁকে \ x00 প্রতিস্থাপন করুন।

উভয় সংস্করণ একই কাজ করে তবে স্প্লিটটারটি আরও বেশি পঠনযোগ্য তবে স্প্লিটটার 2।

import re

s = 'this is "a test" some text "another test"'

def splitter(s):
    def replacer(m):
        return m.group(0).replace(" ", "\x00")
    parts = re.sub('".+?"', replacer, s).split()
    parts = [p.replace("\x00", " ") for p in parts]
    return parts

def splitter2(s):
    return [p.replace("\x00", " ") for p in re.sub('".+?"', lambda m: m.group(0).replace(" ", "\x00"), s).split()]

print splitter2(s)

Comments

পরিবর্তে আপনার পুনরায় স্ক্যানার ব্যবহার করা উচিত। এটি আরও নির্ভরযোগ্য (এবং আমি বাস্তবে পুনরায় স্ক্যানার ব্যবহার করে একটি চকচকে মত প্রয়োগ করেছি)।

— ডেভিন জিনপিয়ের

+1 এইচএম, এটি একটি দুর্দান্ত স্মার্ট ধারণা, সমস্যাটি একাধিক পদক্ষেপে ভেঙে দেয় যাতে উত্তর ভয়ঙ্কর জটিল নয়। শ্লেক্স আমার যা প্রয়োজন ঠিক তা করেনি, এমনকি এটি টুইট করার চেষ্টা করেও। এবং একক পাসের রেজেক্স সমাধানগুলি সত্যিই অদ্ভুত এবং জটিল হয়ে উঠছিল।

— leetNightshade

Answer 7

দেখে মনে হচ্ছে পারফরম্যান্সের কারণে reদ্রুত হয়। বাইরের উক্তিগুলি সংরক্ষণ করে ন্যূনতম লোভী অপারেটরটি ব্যবহার করে আমার সমাধানটি এখানে:

re.findall("(?:\".*?\"|\S)+", s)

ফলাফল:

['this', 'is', '"a test"']

এটি aaa"bla blub"bbbটোকেনগুলি স্পেস দ্বারা পৃথক করা হয় না বলে এটি একসাথে যেমন নির্মানগুলি ছেড়ে দেয় । যদি স্ট্রিংটিতে পালানো অক্ষর থাকে তবে আপনি এর মতো মেলেতে পারেন:

>>> a = "She said \"He said, \\\"My name is Mark.\\\"\""
>>> a
'She said "He said, \\"My name is Mark.\\""'
>>> for i in re.findall("(?:\".*?[^\\\\]\"|\S)+", a): print(i)
...
She
said
"He said, \"My name is Mark.\""

দয়া করে নোট করুন যে এটি প্যাটার্নের অংশের ""সাহায্যে খালি স্ট্রিংয়ের সাথেও মেলে \S।

Comments

এই সমাধানের আর একটি গুরুত্বপূর্ণ সুবিধা হ'ল সীমানা চরিত্রের (যেমন ,মাধ্যমে '(?:".*?"|[^,])+') সম্মানের সাথে এর বহুমুখিতা । একইটি উদ্ধৃতি (সংলগ্ন) অক্ষর (গুলি) এর ক্ষেত্রে প্রযোজ্য।

— a_guest

Answer 8

স্বীকৃত shlexপদ্ধতির সাথে প্রধান সমস্যাটি হ'ল এটি উদ্ধৃত সাবস্ট্রিংগুলির বাইরে পালানো অক্ষরগুলিকে উপেক্ষা করে না এবং কিছু কোণার ক্ষেত্রে কিছুটা অপ্রত্যাশিত ফলাফল দেয়।

আমার নীচের ব্যবহারের কেস রয়েছে, যেখানে আমার একটি বিভক্ত ফাংশন প্রয়োজন যা ইনপুট স্ট্রিংগুলিকে বিভক্ত করে যেগুলি সিঙ্গল-কোটড বা ডাবল-কোটড সাবস্ট্রিংগুলি সংরক্ষণ করা হয়, যেমন একটি স্ট্রিংয়ের মধ্যে উদ্ধৃতিগুলি এড়াতে সক্ষম হয়। অব্যক্ত স্ট্রিংয়ের মধ্যে উদ্ধৃতিগুলি অন্য কোনও চরিত্রের থেকে আলাদাভাবে আচরণ করা উচিত নয়। প্রত্যাশিত আউটপুট সহ কয়েকটি উদাহরণ পরীক্ষার কেস:

ইনপুট স্ট্রিং | প্রত্যাশিত আউটপুট
===============================================
 'এবিসি ডিএফ' | ['এবিসি', 'ডিএফ']
 "abc \\ s Def" | ['এবিসি', '' এস ',' ডিএফ ']
 '"এবিএফ ডিএফ" ঘি' | ['এবিসি ডিএফ', 'জিআই]]
 "'abc Def' ghi" | ['এবিসি ডিএফ', 'জিআই]]
 '"abc \\" Def "ghi' | ['abc" Def', 'ghi']
 "'abc \\' Def 'ghi" | ["এবিসি 'ডিএফ",' জিআই ']
 "'abc \\ s Def' ghi" | ['abc \\ s Def', 'ghi']
 '"abc \\ s Def" ghi' | ['abc \\ s Def', 'ghi']
 '"" পরীক্ষা' | ['', 'পরীক্ষা']
 "'' পরীক্ষা" | ['', 'পরীক্ষা']
 "abc'def" | [ "Abc'def"]
 "abc'def '" | [ "Abc'def '"]
 "abc'def 'ghi" | ["abc'def '",' ghi ']
 "abc'def'ghi" | [ "Abc'def'ghi"]
 'abc "def' | ['abc" Def']
 'abc "def"' | [ 'ABC "Def"']
 'abc "def" ghi' | ['abc "def" ",' ghi ']
 'abc "def" ghi' | [ 'ABC "Def" GHI']
 "r'AA 'r'। * _ xyz $ '" | ["r'AA '", "আর'। * _ xyz $ '"]

আমি একটি স্ট্রিং বিভক্ত করতে নিম্নলিখিত ফাংশনটির সাথে শেষ করেছি যাতে সমস্ত ইনপুট স্ট্রিংয়ের জন্য প্রত্যাশিত আউটপুট ফলাফল হয়:

import re

def quoted_split(s):
    def strip_quotes(s):
        if s and (s[0] == '"' or s[0] == "'") and s[0] == s[-1]:
            return s[1:-1]
        return s
    return [strip_quotes(p).replace('\\"', '"').replace("\\'", "'") \
            for p in re.findall(r'"(?:\\.|[^"])*"|\'(?:\\.|[^\'])*\'|[^\s]+', s)]

নিম্নলিখিত পরীক্ষার অ্যাপ্লিকেশনটি অন্যান্য পদ্ধতির ফলাফলগুলি ( shlexএবং csvএখনই) এবং কাস্টম বিভাজন বাস্তবায়নের পরীক্ষা করে:

#!/bin/python2.7

import csv
import re
import shlex

from timeit import timeit

def test_case(fn, s, expected):
    try:
        if fn(s) == expected:
            print '[ OK ] %s -> %s' % (s, fn(s))
        else:
            print '[FAIL] %s -> %s' % (s, fn(s))
    except Exception as e:
        print '[FAIL] %s -> exception: %s' % (s, e)

def test_case_no_output(fn, s, expected):
    try:
        fn(s)
    except:
        pass

def test_split(fn, test_case_fn=test_case):
    test_case_fn(fn, 'abc def', ['abc', 'def'])
    test_case_fn(fn, "abc \\s def", ['abc', '\\s', 'def'])
    test_case_fn(fn, '"abc def" ghi', ['abc def', 'ghi'])
    test_case_fn(fn, "'abc def' ghi", ['abc def', 'ghi'])
    test_case_fn(fn, '"abc \\" def" ghi', ['abc " def', 'ghi'])
    test_case_fn(fn, "'abc \\' def' ghi", ["abc ' def", 'ghi'])
    test_case_fn(fn, "'abc \\s def' ghi", ['abc \\s def', 'ghi'])
    test_case_fn(fn, '"abc \\s def" ghi', ['abc \\s def', 'ghi'])
    test_case_fn(fn, '"" test', ['', 'test'])
    test_case_fn(fn, "'' test", ['', 'test'])
    test_case_fn(fn, "abc'def", ["abc'def"])
    test_case_fn(fn, "abc'def'", ["abc'def'"])
    test_case_fn(fn, "abc'def' ghi", ["abc'def'", 'ghi'])
    test_case_fn(fn, "abc'def'ghi", ["abc'def'ghi"])
    test_case_fn(fn, 'abc"def', ['abc"def'])
    test_case_fn(fn, 'abc"def"', ['abc"def"'])
    test_case_fn(fn, 'abc"def" ghi', ['abc"def"', 'ghi'])
    test_case_fn(fn, 'abc"def"ghi', ['abc"def"ghi'])
    test_case_fn(fn, "r'AA' r'.*_xyz$'", ["r'AA'", "r'.*_xyz$'"])

def csv_split(s):
    return list(csv.reader([s], delimiter=' '))[0]

def re_split(s):
    def strip_quotes(s):
        if s and (s[0] == '"' or s[0] == "'") and s[0] == s[-1]:
            return s[1:-1]
        return s
    return [strip_quotes(p).replace('\\"', '"').replace("\\'", "'") for p in re.findall(r'"(?:\\.|[^"])*"|\'(?:\\.|[^\'])*\'|[^\s]+', s)]

if __name__ == '__main__':
    print 'shlex\n'
    test_split(shlex.split)
    print

    print 'csv\n'
    test_split(csv_split)
    print

    print 're\n'
    test_split(re_split)
    print

    iterations = 100
    setup = 'from __main__ import test_split, test_case_no_output, csv_split, re_split\nimport shlex, re'
    def benchmark(method, code):
        print '%s: %.3fms per iteration' % (method, (1000 * timeit(code, setup=setup, number=iterations) / iterations))
    benchmark('shlex', 'test_split(shlex.split, test_case_no_output)')
    benchmark('csv', 'test_split(csv_split, test_case_no_output)')
    benchmark('re', 'test_split(re_split, test_case_no_output)')

আউটপুট:

shlex

[ঠিক আছে] এবি ডিএফ -> ['এবিসি', 'ডিএফ']
[ফেইল] আবসি ab গুলি ডিফ -> ['এবিসি', 'এস', 'ডিএফ']
[ঠিক আছে] "এবিসি ডিএফ" গি -> ['এবিসি ডিএফ', 'গি']
[ঠিক আছে] 'এবিসি ডিএফ' গি -> ['এবিসি ডিএফ', 'গি']
[ঠিক আছে] "abc \" Def "ghi -> ['abc" Def ",' ghi ']
[FAIL] 'abc \' Def 'ghi -> ব্যতিক্রম: কোনও সমাপ্ত উদ্ধৃতি নেই
[ঠিক আছে] 'এবি \ s ডিফ' গি -> ['এবি \\ সি ডিফ', 'গি']
[ঠিক আছে] "abc \ s Def" ghi -> ['abc \\ s Def', 'ghi']
[ঠিক আছে] "" পরীক্ষা -> ['', 'পরীক্ষা']
[ঠিক আছে] '' পরীক্ষা -> ['', 'পরীক্ষা']
[FAIL] abc'def -> ব্যতিক্রম: সমাপ্তির উদ্ধৃতি নেই
[FAIL] abc'def '-> [' abcdef ']
[FAIL] abc'def 'ghi -> [' abcdef ',' ghi ']
[FAIL] abc'def'ghi -> ['abcdefghi']
[FAIL] abc "def -> ব্যতিক্রম: কোনও সমাপ্ত উদ্ধৃতি নেই
[FAIL] abc "def" -> ['abcdef']
[FAIL] এবিসি "ডিফ" ঘি -> ['আবদাদেফ', 'গি']
[FAIL] abc "Def" ghi -> ['abcdefghi']
[FAIL] r'AA 'r'। * _ Xyz $ '-> [' rAA ',' r। * _ Xyz $ ']

CSV

[ঠিক আছে] এবি ডিএফ -> ['এবিসি', 'ডিএফ']
[ঠিক আছে] abc \ s Def -> ['এবিসি', '\\ s', 'ডিফ']
[ঠিক আছে] "এবিসি ডিএফ" গি -> ['এবিসি ডিএফ', 'গি']
[FAIL] 'abc Def' ghi -> ["'abc", "Def" ",' ghi ']
[FAIL] "abc \" Def "ghi -> ['abc \\', 'Def"', 'ghi']
[FAIL] 'abc \' Def 'ghi -> ["' abc", "\\" "," Def "", 'ghi']
[FAIL] 'abc \ s Def' ghi -> ["'abc",' \\ s ', "Def" ",' ghi ']
[ঠিক আছে] "abc \ s Def" ghi -> ['abc \\ s Def', 'ghi']
[ঠিক আছে] "" পরীক্ষা -> ['', 'পরীক্ষা']
[FAIL] '' পরীক্ষা -> ["'" ",' পরীক্ষা ']
[ঠিক আছে] abc'def -> ["abc'def"]
[ঠিক আছে] abc'def '-> ["abc'def'"]
[ঠিক আছে] abc'def 'ghi -> ["abc'def'", 'ghi']
[ঠিক আছে] আবদ'এফ'ঘি -> ["আবদ'দেফ'গি]]
[ঠিক আছে] abc "Def -> ['abc" Def']
[ঠিক আছে] abc "Def" -> ['abc "def"']
[ঠিক আছে] abc "Def" ghi -> ['abc "Def" ",' ghi ']
[ঠিক আছে] abc "Def" ghi -> ['abc "Def" ghi']
[ঠিক আছে] r'AA 'আর'। * _ Xyz $ '-> ["r'AA'", "আর '*

পুনরায়

[ঠিক আছে] এবি ডিএফ -> ['এবিসি', 'ডিএফ']
[ঠিক আছে] abc \ s Def -> ['এবিসি', '\\ s', 'ডিফ']
[ঠিক আছে] "এবিসি ডিএফ" গি -> ['এবিসি ডিএফ', 'গি']
[ঠিক আছে] 'এবিসি ডিএফ' গি -> ['এবিসি ডিএফ', 'গি']
[ঠিক আছে] "abc \" Def "ghi -> ['abc" Def ",' ghi ']
[ঠিক আছে] 'abc \' Def 'ghi -> ["abc' Def", 'ghi']
[ঠিক আছে] 'এবি \ s ডিফ' গি -> ['এবি \\ সি ডিফ', 'গি']
[ঠিক আছে] "abc \ s Def" ghi -> ['abc \\ s Def', 'ghi']
[ঠিক আছে] "" পরীক্ষা -> ['', 'পরীক্ষা']
[ঠিক আছে] '' পরীক্ষা -> ['', 'পরীক্ষা']
[ঠিক আছে] abc'def -> ["abc'def"]
[ঠিক আছে] abc'def '-> ["abc'def'"]
[ঠিক আছে] abc'def 'ghi -> ["abc'def'", 'ghi']
[ঠিক আছে] আবদ'এফ'ঘি -> ["আবদ'দেফ'গি]]
[ঠিক আছে] abc "Def -> ['abc" Def']
[ঠিক আছে] abc "Def" -> ['abc "def"']
[ঠিক আছে] abc "Def" ghi -> ['abc "Def" ",' ghi ']
[ঠিক আছে] abc "Def" ghi -> ['abc "Def" ghi']
[ঠিক আছে] r'AA 'আর'। * _ Xyz $ '-> ["r'AA'", "আর '*

শ্লেক্স: পুনরাবৃত্তি প্রতি 0.281 মিমি
csv: 0.030ms per iteration
পুনরায়: 0.04ms প্রতি পুনরাবৃত্তি

সুতরাং পারফরম্যান্স তুলনায় অনেক ভাল shlex, এবং নিয়মিত এক্সপ্রেশনকে পূর্ববর্তী করে আরও উন্নত করা যায়, এক্ষেত্রে এটি csvপদ্ধতির চেয়ে বেশি কার্যকর হবে।

Comments

আপনি কী সম্পর্কে কথা বলছেন তা নিশ্চিত নন: `` `>>> shlex.split ('এটি" একটি পরীক্ষা "") [' এটি ',' হয় ',' একটি পরীক্ষা '] >>> shlex.split (' এটি \\ "একটি পরীক্ষা \\" ") ['এটি', 'হ'ল', '' ক '', 'পরীক্ষা' '] >>> শ্লেক্স.স্প্লিট (' এটি" একটি test "পরীক্ষা \\" "') [' এটি ',' হ'ল ',' একটি" পরীক্ষা "]]` ``

— মুরসিক

@ মুরসিক, আপনার বক্তব্য কী? আপনার ব্যবহারের মামলাটি কি আমার সাথে মেলে না? আপনি যখন পরীক্ষার কেসগুলি দেখেন তখন আপনি এমন সমস্ত ক্ষেত্রে দেখতে পাবেন যেখানে shlexআমার ব্যবহারের ক্ষেত্রে প্রত্যাশা অনুযায়ী আচরণ করা হয় না।

— টন ভ্যান ডেন হিউভেল

Answer 9

উদ্ধৃতি সংরক্ষণ করতে এই ফাংশনটি ব্যবহার করুন:

def getArgs(s):
    args = []
    cur = ''
    inQuotes = 0
    for char in s.strip():
        if char == ' ' and not inQuotes:
            args.append(cur)
            cur = ''
        elif char == '"' and not inQuotes:
            inQuotes = 1
            cur += char
        elif char == '"' and inQuotes:
            inQuotes = 0
            cur += char
        else:
            cur += char
    args.append(cur)
    return args

Comments

বড় স্ট্রিংয়ের সাথে তুলনা করার সময়, আপনার ফাংশনটি এত ধীর

— Faran2007

Answer 10

বিভিন্ন উত্তরের গতি পরীক্ষা:

import re
import shlex
import csv

line = 'this is "a test"'

%timeit [p for p in re.split("( |\\\".*?\\\"|'.*?')", line) if p.strip()]
100000 loops, best of 3: 5.17 µs per loop

%timeit re.findall(r'[^"\s]\S*|".+?"', line)
100000 loops, best of 3: 2.88 µs per loop

%timeit list(csv.reader([line], delimiter=" "))
The slowest run took 9.62 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 2.4 µs per loop

%timeit shlex.split(line)
10000 loops, best of 3: 50.2 µs per loop

Answer 11

হুম, "রিপ্লাই" বোতামটি খুঁজে পাচ্ছে না ... যাইহোক, এই উত্তরটি কেটের পদ্ধতির উপর ভিত্তি করে, তবে সঠিকভাবে পালানো উদ্ধৃতি সম্বলিত সাবস্ট্রিংগুলির সাথে স্ট্রিংগুলি বিভক্ত করে এবং সাবস্ট্রিংগুলির শুরু এবং শেষের উদ্ধৃতিগুলিও সরিয়ে দেয়:

  [i.strip('"').strip("'") for i in re.split(r'(\s+|(?<!\\)".*?(?<!\\)"|(?<!\\)\'.*?(?<!\\)\')', string) if i.strip()]

এটি এর মতো স্ট্রিংগুলিতে কাজ করে 'This is " a \\\"test\\\"\\\'s substring"'(দুর্ভাগ্যক্রমে পাইথনকে পালিয়ে যাওয়া অপসারণ থেকে দূরে রাখতে পাগল মার্কআপটি প্রয়োজনীয়)।

যদি প্রত্যাশিত তালিকার মধ্যে স্ট্রিংগুলিতে পরিণতিগুলি অবতরণ না করা হয় তবে আপনি এই ফাংশনের সামান্য পরিবর্তিত সংস্করণটি ব্যবহার করতে পারেন:

[i.strip('"').strip("'").decode('string_escape') for i in re.split(r'(\s+|(?<!\\)".*?(?<!\\)"|(?<!\\)\'.*?(?<!\\)\')', string) if i.strip()]

Answer 12

কিছু পাইথন 2 সংস্করণে ইউনিকোড সংক্রান্ত সমস্যাগুলি পেতে, আমি পরামর্শ দিই:

from shlex import split as _split
split = lambda a: [b.decode('utf-8') for b in _split(a.encode('utf-8'))]

Comments

অজগর 2.7.5 এর জন্য এটি হওয়া উচিত: split = lambda a: [b.decode('utf-8') for b in _split(a)]অন্যথায় আপনি পাবেন:UnicodeDecodeError: 'ascii' codec can't decode byte ... in position ...: ordinal not in range(128)

— পিটার ভারো

Answer 13

বিকল্প হিসাবে tssplit চেষ্টা করুন:

In [1]: from tssplit import tssplit
In [2]: tssplit('this is "a test"', quote='"', delimiter='')
Out[2]: ['this', 'is', 'a test']

Answer 14

আমার পরামর্শ:

পরীক্ষার স্ট্রিং:

s = 'abc "ad" \'fg\' "kk\'rdt\'" zzz"34"zzz "" \'\''

"" এবং '' ক্যাপচার করতে:

import re
re.findall(r'"[^"]*"|\'[^\']*\'|[^"\'\s]+',s)

ফলাফল:

['abc', '"ad"', "'fg'", '"kk\'rdt\'"', 'zzz', '"34"', 'zzz', '""', "''"]

খালি "" এবং '' উপেক্ষা করুন:

import re
re.findall(r'"[^"]+"|\'[^\']+\'|[^"\'\s]+',s)

ফলাফল:

['abc', '"ad"', "'fg'", '"kk\'rdt\'"', 'zzz', '"34"', 'zzz']

Comments

re.findall("(?:\".*?\"|'.*?'|[^\s'\"]+)", s)পাশাপাশি লেখা যেতে পারে ।

— হচল

Answer 15

আপনি যদি কোনও সাধারণের চেয়ে সাব স্ট্রিং সম্পর্কে চিন্তা না করেন

>>> 'a short sized string with spaces '.split()

কর্মক্ষমতা:

>>> s = " ('a short sized string with spaces '*100).split() "
>>> t = timeit.Timer(stmt=s)
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
171.39 usec/pass

বা স্ট্রিং মডিউল

>>> from string import split as stringsplit; 
>>> stringsplit('a short sized string with spaces '*100)

পারফরম্যান্স: স্ট্রিং পদ্ধতির চেয়ে স্ট্রিং মডিউলটি আরও ভাল সম্পাদন করছে বলে মনে হচ্ছে

>>> s = "stringsplit('a short sized string with spaces '*100)"
>>> t = timeit.Timer(s, "from string import split as stringsplit")
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
154.88 usec/pass

অথবা আপনি আর ই ইঞ্জিন ব্যবহার করতে পারেন

>>> from re import split as resplit
>>> regex = '\s+'
>>> medstring = 'a short sized string with spaces '*100
>>> resplit(regex, medstring)

কর্মক্ষমতা

>>> s = "resplit(regex, medstring)"
>>> t = timeit.Timer(s, "from re import split as resplit; regex='\s+'; medstring='a short sized string with spaces '*100")
>>> print "%.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
540.21 usec/pass

খুব দীর্ঘ স্ট্রিংয়ের জন্য আপনার পুরো স্ট্রিংটি মেমরিতে লোড করা উচিত নয় এবং পরিবর্তে হয় লাইনগুলি বিভক্ত করুন বা পুনরাবৃত্ত লুপ ব্যবহার করা উচিত নয়

Comments

আপনি প্রশ্নের পুরো পয়েন্টটি মিস করেছেন বলে মনে হচ্ছে। স্ট্রিংয়ে উদ্ধৃত বিভাগগুলি রয়েছে যা বিভক্ত হওয়ার দরকার নেই।

— rjmunro

Answer 16

এটা চেষ্টা কর:

  def adamsplit(s):
    result = []
    inquotes = False
    for substring in s.split('"'):
      if not inquotes:
        result.extend(substring.split())
      else:
        result.append(substring)
      inquotes = not inquotes
    return result

কিছু পরীক্ষার স্ট্রিং:

'This is "a test"' -> ['This', 'is', 'a test']
'"This is \'a test\'"' -> ["This is 'a test'"]

Comments

আপনার মনে হয় যে স্ট্রিংটির ব্যর্থতা ব্যর্থ হবে তার পুনরায় সরবরাহ করুন।

— pjz

ভাবি ? adamsplit("This is 'a test'")→['This', 'is', "'a", "test'"]

— ম্যাথু শিনকেল

ওপি কেবল "কোটের মধ্যে" বলে এবং কেবল ডাবল-কোট সহ একটি উদাহরণ রয়েছে।

— pjz