입력, 문자열/행렬 뒤집기 (python)

juyeon·2022년 7월 8일

데이터 다루기

목록 보기

5/35

숫자를 분리하여 입력

1. str로

# 입력
123456

a = list(input())

# 출력
['1', '2', '3', '4', '5', '6']

문자열도 마찬가지 방법

2. int로

# 입력
123456

# 1. str로 input -> for문으로 원소 하나씩 int 변환
b = list(int(x) for x in input())

# 2. str로 input -> lambda로 원소 하나씩 int 변환
a = list(map(lambda x: int(x), input()))

# 출력
[1, 2, 3, 4, 5, 6]

: 두 방법 다 시간은 비슷

행렬 input 받기

n, m = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(n)]

: N x M 행렬을 바로 입력하기
: 입력이 1 2 3 이런식으로 띄어쓰기가 있을 때

n, m = map(int, input().split())
graph = [list(map(int, input())) for _ in range(n)]
print(graph)

: 입력이 123 이런식으로 띄어쓰기 없을 때

뒤집기

:: Extended Slices

a_list[a:b:c]
: a부터 b까지 c 간격으로.

A = [0, 1, 2, 3, 4]
A[::-1] #처음부터 끝까지 -1칸 간격으로(즉, 역순으로)
A[1::2] #1부터 끝까지 2칸 간격으로

[4, 3, 2, 1, 0]
[1, 3]

input시 ::을 사용한다면? -> 문자열 뒤집기!

#입력
2
123 456 789
abc def ghi

n = int(input())

result_1 = list(input()[::-1].split() for _ in range(n))

result_2 = list(input().split()[::-1] for _ in range(n))

result_3 = list(input()[::-1].split()[::-1] for _ in range(n))

result_4 = list(input()[::-1].split() for _ in range(n))[::-1]

print(result_1, result_2, result_3, result_4, sep = '\n')


#출력
#1: 행: 그대로, 열: 거꾸로, 문자열: 거꾸로 출력
#input 전체를 뒤집은 후, 띄어쓰기로 split
[['987', '654', '321'], ['ihg', 'fed', 'cba']]

#2: 행: 그대로, 열: 거꾸로, 문자열: 그대로 출력
#split 띄어쓰기 구분자로 거꾸로 해서, 열만 거꾸로 된듯
[['789', '456', '123'], ['ghi', 'def', 'abc']]

#3: 행: 그대로, 열: 그대로, 문자열: 거꾸로 출력
#input시 열/문자열 거꾸로 된 것을 split시 열을 거꾸로
#결국 열 거꾸로 -> 다시 원래 열로
[['321', '654', '987'], ['cba', 'fed', 'ihg']]

#4: 행: 거꾸로, 열: 거꾸로, 문자열: 거꾸로
#전부 거꾸로!
[['ihg', 'fed', 'cba'], ['987', '654', '321']]

numpy 없이 행렬 list 뒤집기

: 정리하면..

0도 90도 180도 270도
123 456 789 abc 123 ghi def abc 789 ghi
abc def ghi def 456 789 456 123 456 def
ghi 789 123 abc
0도
: arr = [['1,2,3', '4,5,6', '7,8,9'], ['a,b,c', 'd,e,f', 'g,h,i']]
90도
: result_4 = list(map(list, zip(*reversed(arr))))
: [['a,b,c', '1,2,3'], ['d,e,f', '4,5,6'], ['g,h,i', '7,8,9']]
180도
: result_4 = list(map(lambda x: list(reversed(x)), reversed(arr)))
: [['g,h,i', 'd,e,f', 'a,b,c'], ['7,8,9', '4,5,6', '1,2,3']]
270도(=왼쪽으로 90도)
: result_4 = list(reversed(list(map(list, zip(*arr)))))
: [['7,8,9', 'g,h,i'], ['4,5,6', 'd,e,f'], ['1,2,3', 'a,b,c']]

0도	90도	180도	270도
123 456 789	abc 123	ghi def abc	789 ghi
abc def ghi	def 456	789 456 123	456 def
	ghi 789		123 abc

A.reverse() vs reversed(A)

# 입력
arr = [[1, 2, 3], [4, 5, 6]]

result_1 = list(map(lambda x: x.reverse(), arr.reverse()))

result_2 = list(map(lambda x: x.reverse(), reversed(arr)))

result_3 = list(map(lambda x: reversed(x), reversed(arr)))

result_4 = list(map(lambda x: list(reversed(x)), reversed(arr)))

# 출력
# 1. reverse 둘다
TypeError: 'NoneType' object is not iterable

# 2. reversed 한 다음 reverse
[None, None]

# 3. reversed만
[<list_reverseiterator object at 0x7f673270b7b8>, <list_reverseiterator object at 0x7f673a1f4e48>]

# 4. reversed 한 후에 list 씌움
[[6, 5, 4], [3, 2, 1]]

A.reverse(): A list 자체를 reverse 한다. 값을 반환하지 않는다.
- # 1.에서 값을 반환하지 않는데 거기에다가 reverse(reversed를 해도 마찬가지)를 하려니까, None 어쩌구~ 하고 나온것!
reversed(A): A list를 reverse 한 값을 반환한다. list_reverseiterator 로 반환.
- 여기서 list를 씌워야 list 형태로 값이 나옴.

zip()한 후에 tuple이 아닌 list로 원소를 저장하고 싶으면?

# 입력
arr = [['1,2,3', '4,5,6', '7,8,9'], ['a,b,c', 'd,e,f', 'g,h,i']]

result = list(map(list, zip(*arr)))

print(result)

# 출력
[['1,2,3', 'a,b,c'], ['4,5,6', 'd,e,f'], ['7,8,9', 'g,h,i']]

map(lambda x: 함수(x), list)

map(함수, 리스트)
: list로부터 원소를 하나씩 꺼내 함수를 적용한 후, 그 결과를 새로운 list에 담음

예시

# 입력
arr = [['1,2,3', '4,5,6', '7,8,9'], ['a,b,c', 'd,e,f', 'g,h,i']]

result = list(map(lambda x: list(reversed(x)), arr))

print(result)

# 출력: 행은 reversed 안하고, 각 행 안의 원소(즉 열)만 reversed 함
[['7,8,9', '4,5,6', '1,2,3'], ['g,h,i', 'd,e,f', 'a,b,c']]

예시

# 입력
arr = [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
result= list(map(lambda x: x[1:4], arr))

print(result)

# 출력
[[2, 3, 4], [7, 8, 9]]

1. 행렬 90도 회전

# 입력
# 2행 x 3열 list
arr = [['1,2,3', '4,5,6', '7,8,9'], ['a,b,c', 'd,e,f', 'g,h,i']]

result_1 = zip(*reversed(arr))

result_2 = list(zip(reversed(arr)))

result_3 = list(zip(*reversed(arr)))

result_4 = list(map(list, zip(*reversed(arr))))

print(result_1, result_2, result_3, sep = '\n')

# 출력

# 1: zip instance
<zip object at 0x7f5b8a6d5cc8>

# 2: 2행 x 3열.
[(['a,b,c', 'd,e,f', 'g,h,i'],), (['1,2,3', '4,5,6', '7,8,9'],)]

# 3: 3행 x 2열 list(tuple)로 변환
# 하나의 list로 묶여 있던거를 풀어야만 zip으로 제대로 다시 묶을 수 있음
[('a,b,c', '1,2,3'), ('d,e,f', '4,5,6'), ('g,h,i', '7,8,9')]

# 4: 3행 x 2열 list(list)로 변환
[['a,b,c', '1,2,3'], ['d,e,f', '4,5,6'], ['g,h,i', '7,8,9']]

행렬을 90도 회전하고 싶으면
: result_4 = list(map(list, zip(*reversed(arr))))
zip(): 각 행의 동일 열의 원소를 묶어줌
-> 우선 뒤집어줌: reversed
-> 근데 원 list가 list로 묶여있으므로, 이를 풀어줘야함: *
-> 근데 zip()은 튜플로 나타냄
-> map()을 이용해서 zip() 할때마다 각 원소를 list()로 변환하게끔 해야함

2. 행렬 180도 회전

# 입력
arr = [[1, 2, 3], [4, 5, 6]]

result_1 = map(lambda x: reversed(x), reversed(arr))

result_2 = list(map(lambda x: reversed(x), reversed(arr)))

result_3 = map(lambda x: list(reversed(x)), reversed(arr))

result_4 = list(map(lambda x: list(reversed(x)), reversed(arr)))

print(result_1, result_2, result_3, result_4, sep = '\n')

# 출력
# 1: map instance
<map object at 0x7f393f481898>

# 2: reversed(): list_reverseiterator instance를 반환
[<list_reverseiterator object at 0x7f39470d2cc0>, <list_reverseiterator object at 0x7f39470d2f98>]

# 3: map instance
<map object at 0x7f3947152a90>

# 4: 행: 거꾸로, 열: 거꾸로, 문자열: 그대로 출력
[['g,h,i', 'd,e,f', 'a,b,c'], ['7,8,9', '4,5,6', '1,2,3']]

행렬을 180도 회전시키고 싶으면
: result_4 = list(map(lambda x: list(reversed(x)), reversed(arr)))

2. 행렬 270도 회전

1) 비효율적인 방법
: 90도 회전한 것을 다시 180도 회전하거나,
아니면 180도 회전한 것을 추가로 90도 더 회전하면 됨

2) 0도에서 바로 270도로 회전

# 입력
result_1 = list(map(lambda e:list(reversed(e)), reversed(list(zip(*reversed(arr))))))

result_2 = list(zip(*reversed(list(map(lambda e:list(reversed(e)), reversed(arr))))))

result_3 = reversed(list(map(list, zip(*arr))))

result_4 = list(reversed(list(map(list, zip(*arr)))))

print(result_1, result_2, result_3, result_4, sep = '\n')

# 출력
# 1: 90도 회전 후 180도 회전 -> 잘 나옴
[['7,8,9', 'g,h,i'], ['4,5,6', 'd,e,f'], ['1,2,3', 'a,b,c']]

# 2: 180도 회전 후 90도 회전 -> 원소가 튜플로 나옴.. 왜..?
[('7,8,9', 'g,h,i'), ('4,5,6', 'd,e,f'), ('1,2,3', 'a,b,c')]

# 3: list_reverseiterator instance
<list_reverseiterator object at 0x7f5b6bd7e7b8>

# 4:  
[['7,8,9', 'g,h,i'], ['4,5,6', 'd,e,f'], ['1,2,3', 'a,b,c']]