Having problems with strings and arrays

Question

I want to read a text file and copy text that is in between '~~~~~~~~~~~~~' into an array. However, I'm new in Python and this is as far as I got:

with open("textfile.txt", "r",encoding='utf8') as f:
    searchlines = f.readlines()

a=[0]
b=0
for i,line in enumerate(searchlines):
    if '~~~~~~~~~~~~~' in line:
        b=b+1
    if '~~~~~~~~~~~~~' not in line:
        if 's1mb4d' in line:
            break
        a.insert(b,line)

This is what I envisioned: First I read all the lines of the text file, then I declare 'a' as an array in which text should be added, then I declare 'b' because I need it as an index. The number of lines in between the '~~~~~~~~~~~~~' is not even, that's why I use 'b' so I can put lines of text into one array index until a new '~~~~~~~~~~~~~' was found.

I check for '~~~~~~~~~~~~~', if found I increase 'b' so I can start adding lines of text into a new array index. The text file ends with 's1mb4d', so once its found, the program ends. And if '~~~~~~~~~~~~~' is not found in the line, I add text to the array.

But things didn't go well. Only 1 line of the entire text between those '~~~~~~~~~~~~~' is being copied to the each array index.

Here is an example of the text file:

~~~~~~~~~~~~~

Text123asdasd asdasdjfjfjf

~~~~~~~~~~~~~

123abc 321bca gjjgfkk

~~~~~~~~~~~~~

Answer 1

If you're willing to impose/accept the constraint that the separator should be exactly 13 ~ characters (actually '\n%s\n' % ( '~' * 13) to be specific) ... then you could accomplish this for relatively normal sized files using just

#!/usr/bin/python
## (Should be #!/usr/bin/env python; but StackOverflow's syntax highlighter?)
separator = '\n%s\n' % ('~' * 13)
with open('somefile.txt') as f:
    results = f.read().split(separator)

# Use your results, a list of the strings separated by these separators.

Note that '~' * 13 is a way, in Python, of constructing a string by repeating some smaller string thirteen times. 'xx%sxx' % 'YY' is a way to "interpolate" one string into another. Of course you could just paste the thirteen ~ characters into your source code ... but I would consider constructing the string as shown to make it clear that the length is part of the string's specification --- that this is part of your file format requirements ... and that any other number of ~ characters won't be sufficient.

If you really want any line of any number of ~ characters to serve as a separator than you'll want to use the .split() method from the regular expressions module rather than the .split() method provided by the built-in string objects.

Note that this snippet of code will return all of the text between your separator lines, including any newlines they include. There are other snippets of code which can filter those out. For example given our previous results:

# ... refine results by filtering out newlines (replacing them with spaces)
results = [' '.join(each.split('\n')) for each in results]

(You could also use the .replace() string method; but I prefer the join/split combination). In this case we're using a list comprehension (a feature of Python) to iterate over each item in our results, which we're arbitrarily naming each), performing our transformation on it, and the resulting list is being boun back to the name results; I highly recommend learning and getting comfortable with list comprehension if you're going to learn Python. They're commonly used and can be a bit exotic compared to the syntax of many other programming and scripting languages).

This should work on MS Windows as well as Unix (and Unix-like) systems because of how Python handles "universal newlines." To use these examples under Python 3 you might have to work a little on the encodings and string types. (I didn't need to for my Python3.6 installed under MacOS X using Homebrew ... but just be forewarned).

Answer 2

In python the solution to a large part of problems is often to find the right function from the standard library that does the job. Here you should try using split instead, it should be way easier.

If I understand correctly your goal, you can do it like that :

joined_lines = ''.join(searchlines)
result = joined_lines.split('~~~~~~~~~~')

The first line joins your list of lines into a sinle string, and then the second one cut that big string every times it encounters the '~~' sequence.

Answer 3

You could use regex expression, give a try to this:

import re

input_text = ['Text123asdasd asdasdjfjfjf','~~~~~~~~~~~~~','123abc 321bca gjjgfkk','~~~~~~~~~~~~~']

a = []
for line in input_text:
    my_text = re.findall(r'[^\~]+', line)
    if len(my_text) != 0:
        a.append(my_text)

What it does is it reads line by line looks for all characters but '~' if line consists only of '~' it ignores it, every line with text is appended to your a list afterwards.

And just because we can, oneliner (excluding import and source ofc):

import re

lines = ['Text123asdasd asdasdjfjfjf','~~~~~~~~~~~~~','123abc 321bca gjjgfkk','~~~~~~~~~~~~~']
a = [re.findall(r'[^\~]+', line) for line in lines if len(re.findall(r'[^\~]+', line)) != 0]

Answer 4

s = ['']
with open('path\\to\\sample.txt') as f:
   for l in f:
      a = l.strip().split("\n")
      s += a

a = []
for line in s:
    my_text = re.findall(r'[^\~]+', line)
    if len(my_text) != 0:
        a.append(my_text)
print a
>>> [['Text123asdasd asdasdjfjfjf'], ['123abc 321bca gjjgfkk']]

Answer 5

I tried to clean it up to the best of my knowledge, try this and let me know if it works. We can work together on this!:)

with open("textfile.txt", "r",encoding='utf8') as f:
    searchlines = f.readlines()

a = []
currentline = ''

for i,line in enumerate(searchlines):
    currentline += line
    if '~~~~~~~~~~~~~' in line:
        a.append(currentline)
    elif 's1mb4d' in line:
        break

Some notes:

• You can use elif for your break function
• Append will automatically add the next iteration to the end of the array
• currentline will continue to add text on each line as long as it doesn't have 's1mb4d' or the ~~~ which I think is what you want