목록 요소에서 \ n을 제거하는 방법은 무엇입니까?

목록 요소에서 \ n을 제거하는 방법은 무엇입니까?

---

txt 파일에서 Python을 읽은 줄로 가져오고 첫 번째 줄의 요소를 목록에 쓰려고합니다. 파일의 요소는 탭으로 구분되어 있으므로 split("\t")요소를 구분했습니다. .txt 파일에는 많은 요소가 있기 때문에 각 줄에있는 데이터를 별도의 목록에 저장했습니다.

현재 내가 가진 문제는 다음과 같이 각 목록을 표시한다는 것입니다.

['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']

\n목록의 마지막 요소에서 제거 하고 그냥 만들 수있는 방법은 '7.3'무엇입니까?

---

\n마지막 요소에서만 제거 하려면 다음을 사용하십시오.

t[-1] = t[-1].strip()

\n모든 요소에서 제거 하려면 다음을 사용하십시오.

t = map(lambda s: s.strip(), t)

줄을 분할 \n 하기 전에 제거하는 것을 고려할 수도 있습니다 .

line = line.strip()
# split line...

---

Python3부터

map더 이상을 반환 list하지만 mapObject, 이렇게 대답은 같을 것

>>> map(lambda x:x.strip(),l)
<map object at 0x7f00b1839fd0>

What 's New In Python 3.0 에서 자세한 내용을 읽을 수 있습니다 .

map()및 filter()반복자를 돌려줍니다. 정말 필요한 경우 list빠른 수정은 다음과 같습니다.list(map(...))

그럼 이제 이것을 구하는 방법은 무엇입니까?

---

케이스 - 1 list이상 전화 mapA를lambda

map반복자를 반환 합니다 . list반복자를 목록으로 변환 할 수있는 함수입니다. 따라서 list전화 를 래핑해야합니다 map. 이제 대답은

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> list(map(lambda x:x.strip(),l))
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

아주 좋아, 우리는 출력을 얻습니다. 이제이 코드가 실행되는 데 걸리는 시간을 확인합니다.

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];list(map(lambda x:x.strip(),l))"
100000 loops, best of 3: 2.22 usec per loop

2.22 마이크로 초. 그렇게 나쁘지 않습니다. 그러나 더 효율적인 방법이 있습니까?

---

케이스 - 2 list이상 전화 map없이lambda

lambda파이썬 커뮤니티 ( 귀도 포함 )의 많은 사람들이 눈살을 찌푸 립니다. 그 외에도 프로그램의 속도가 크게 감소합니다. 따라서 우리는 가능한 한 피해야합니다. 최상위 함수 str.strip. 여기에서 우리의 도움을 받으십시오.

는 map사용하지 않고 재 작성 할 수 있습니다 lambda사용 str.strip으로

>>> list(map(str.strip,l))
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

그리고 지금은 시간입니다.

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];list(map(str.strip,l))"
1000000 loops, best of 3: 1.38 usec per loop

환상적입니다. 두 가지 방법의 효율성 차이를 확인할 수 있습니다. 거의 60 % 더 빠릅니다. 따라서 a를 사용하지 않는 접근 방식 lambda이 여기에서 더 나은 선택입니다.

---

사례 3-지침에 따라, 규칙적인 방법

What 's New In Python 3.0의 또 다른 중요한 점은 map가능한 한 피하라는 조언 입니다.

map()기능의 부작용에 대해 특히 까다로운 문제가 발생합니다. 올바른 변환은 일반 for루프 를 사용하는 것입니다 (목록을 만드는 것은 낭비이기 때문입니다).

그래서 우리는 map정규 for루프 를 사용 하여이 문제를 해결할 수 있습니다 .

간단한 해결 방법 (무차별 대입)은 다음과 같습니다.

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> final_list = []
>>> for i in l:
...     final_list.append(i.strip())
... 
>>> final_list
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

타이밍 설정

def f():
    l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
    final_list = []
    for i in l:
         final_list.append(i.strip())
import timeit
print(min(timeit.repeat("f()","from __main__ import f")))

그리고 그 결과.

1.5322505849981098

보시다시피 brute-force는 여기에서 약간 느립니다. 그러나 이것은 map절 보다 일반 프로그래머가 더 쉽게 읽을 수 있습니다.

---

사례 4-목록 이해

지능형리스트 여기도 가능하며 Python2 동일하다.

>>> [i.strip() for i in l]
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

이제 타이밍 :

$ python3 -m timeit "l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n'];[i.strip() for i in l]"
1000000 loops, best of 3: 1.28 usec per loop

보시다시피 목록 이해가 map(가없는 경우에도 )보다 효과적 lambda입니다. 따라서 Python3의 엄지 규칙은 대신 목록 이해력을 사용하는 것입니다.map

---

사례 5-In-Place 메커니즘 및 공간 효율성 ( TMT )

마지막 방법은 목록 자체 내에서 변경하는 것입니다. 이것은 많은 메모리 공간을 절약합니다. 이 작업은 enumerate.

>>> l = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> for i,s in enumerate(l):
...     l[i] = s.strip()
... 
>>> l
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

타이밍 결과는입니다 1.4806894720022683. 그러나이 방법은 공간 효율적입니다.

---

결론

비교 타이밍 목록 (Python 3.4.3 및 Python 3.5.0 모두)

----------------------------------------------------
|Case| method          | Py3.4 |Place| Py3.5 |Place|
|----|-----------------|-------|-----|-------|-----|
| 1  | map with lambda | 2.22u | 5   | 2.85u | 5   |
| 2  | map w/o lambda  | 1.38u | 2   | 2.00u | 2   |
| 3  | brute-force     | 1.53u | 4   | 2.22u | 4   |
| 4  | list comp       | 1.28u | 1   | 1.25u | 1   |
| 5  | in-place        | 1.48u | 3   | 2.14u | 3   |
----------------------------------------------------

마지막으로 목록을 이해하는 것이 가장 좋은 방법이고 map사용하는 lambda것이 최악 이라는 점에 유의하십시오 . 그러나 다시 --- PYTHON3에서만

---

Perl chomp()함수 와 같은 것을 원하는 것 같습니다 .

파이썬에서는 간단합니다.

def chomp(s):
    return s[:-1] if s.endswith('\n') else s

... Python 2.6 이상을 사용한다고 가정합니다. 그렇지 않으면 약간 더 자세한 정보를 사용하십시오.

def chomp(s):
    if s.endwith('\n'):
        return s[:-1]
    else:
        return s

문자열 끝에서 모든 새 줄을 제거하려는 경우 (어떤 이유로 후행 줄 바꿈이 여러 개있을 수있는 이상한 경우) :

def chomps(s):
    return s.rstrip('\n')

분명히 일반적인 파이썬 파일 객체 readline()나 readlines()메소드에 의해 반환 된 그러한 문자열은 절대 볼 수 없습니다 .

사람들 s[:-1]이 파일 readline()및 유사한 기능 의 결과에서 마지막 문자 ( 슬라이싱 사용 )를 맹목적으로 제거하는 것을 보았습니다 . 이것은 파일의 마지막 줄에 오류가 발생할 수 있기 때문에 나쁜 생각입니다 (파일이 줄 바꿈이 아닌 다른 것으로 끝나는 경우).

처음에는 읽은 줄에서 최종 문자를 맹목적으로 제거 할 때 잘못된 보안 감각에 빠져들 수 있습니다. 일반 텍스트 편집기를 사용하여 테스트 스위트 파일을 만드는 경우 대부분의 경우 마지막 줄 끝에 자동으로 줄 바꿈이 추가됩니다. 유효한 테스트 파일을 만들려면 다음과 같은 코드를 사용하십시오.

f = open('sometest.txt', 'w')
f.write('some text')
f.close()

... 그 파일을 다시 열고 readline()또는 readlines()파일 메서드를 사용 하면 후행 줄 바꿈없이 텍스트를 읽는 것을 알 수 있습니다.

This failure to account for text files ending in non-newline characters has plagued many UNIX utilities and scripting languages for many years. It's a stupid corner base bug that creeps into code just often enough to be a pest but not often enough for people to learn from it. We could argue that "text" files without the ultimate newline are "corrupt" or non-standard; and that may be valid for some programming specifications.

However, it's all too easy to ignore corner cases in our coding and have that ignorance bite people who are depending on your code later. As my wife says: when it comes to programming ... practice safe hex!

---

Using list comprehension:

myList = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']

[(el.strip()) for el in myList]

---

from this link:

you can use rstrip() method. Example

mystring = "hello\n"    
print(mystring.rstrip('\n'))

---

As an alternate method, if you know that there are no spaces in your data, which it seems is the case, you can use split() (with no arguments). This splits on white space and uses a more efficient algorithm than the other version of split. It also strips whitespace from both ends.

line = line.split()

And that's it.

---

You could do -

DELIMITER = '\t'
lines = list()
for line in open('file.txt'):
    lines.append(line.strip().split(DELIMITER))

The lines has got all the contents of your file.

One could also use list comprehensions to make this more compact.

lines = [ line.strip().split(DELIMITER) for line in open('file.txt')]

---

This will also work,

f=open('in.txt','r')

    for line in f:
            parline = line[:-1].split(',')

---

str.strip() removes the whitespace characters. you can also pass custom characters as argument to strip. The strip function removes the whitespace/custom characters on both ends of the string. lstrip() and rstrip() are left strip and right strip functions resp.

Eg:

test_str = "Vishaka\n" 
test_str = test_str.strip()

test_str's now Vishaka

---

You access the last element of the set and then store the value in a variable.

So you have:

fileName = '7.3\n'

then just do:

fileName.strip()

which will leave you with 7.3. Then store that value back in the last element of the set.

You can use lstrip() or rstrip() to remove just the left or right side.

---

Since the OP's question is about stripping the newline character from the last element, I would reset it with the_list[-1].rstrip():

>>> the_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
>>> the_list[-1] = ls[-1].rstrip()
>>> the_list
['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

It's O(1).

---

This works to take out the \n (new line) off a item in a list it just takes the first item in string off

def remove_end(s):
    templist=[]
    for i in s:
        templist.append(i)
    return(templist[0])

---

I had this issue and solved it using the chomp function described above:

def chomp(s):
    return s[:-1] if s.endswith('\n') else s

def trim_newlines(slist):
    for i in range(len(slist)):
        slist[i] = chomp(slist[i])
    return slist
.....
names = theFile.readlines()
names = trim_newlines(names)
....

---

To handle many newline delimiters, including character combinations like \r\n, use splitlines. Combine join and splitlines to remove/replace all newlines from a string s:

''.join(s.splitlines())

To remove exactly one trailing newline, pass True as the keepends argument to retain the delimiters, removing only the delimiters on the last line:

def chomp(s):
    if len(s):
        lines = s.splitlines(True)
        last = lines.pop()
        return ''.join(lines + last.splitlines())
    else:
        return ''

---

new_list = ['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3\n']
for i in range(len(new_list)):
    new_list[i]=new_list[i].replace('\n','')
print(new_list)

Output Will be like this

['Name1', '7.3', '6.9', '6.6', '6.6', '6.1', '6.4', '7.3']

참고URL : https://stackoverflow.com/questions/3849509/how-to-remove-n-from-a-list-element