리스트와 리스트 함수 - range, numpy, sum, len, append, remove, del, index, pop, sort, sorted, reverse

1. 순차적인 자료 구조. 0번부터 시작하는 인덱스 번호 순으로 저장

2. 대괄호 [ ] 안에 데이터를 저장한다.

3. 리스트의 원소들은 수정 가능하다.

4. 여러가지 자료형의 데이터를 혼용해서 저장할 수 있다.

 

 

 

 

리스트를 생성하는 방법은 

원소들을 직접 선언하는 방법이 있고, 

 

# 방법1.
a = []                            # 비어있는 리스트
b = [10, 20, 30]
c = ['파이썬','자바','오라클','JSP','Spring','tensorflow','keras']
d = [30, 3.14, True, False, 'java']
list1 = ['사과','포도','바나나','키위','복숭아']
print(type(list1))                # <class 'list'>
print(list1)                      # ['사과', '포도', '바나나', '키위', '복숭아']
print(list1[0])                   # 사과
print(list1[1])                   # 포도
list1[0] = 'apple'                # '사과'를 apple로 수정
print(list1[0])                   # apple

 

 

 

 

list 함수와 range 함수를 함께 사용하여 리스트를 만들 수도 있다.

 

# 방법2.
# list(), range() 함수를 이용해서 연속적인 데이터를 가진 리스트 생성
list2 = list(range(10))           # 0 ~ 9
list3 = list(range(1,11))         # 1 ~ 10
list4 = list(range(1,11,2))       # 1, 3, 5, 7, 9

print('list2:', list2)            # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print('list3:', list3)            # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('list4:', list4)            # [1, 3, 5, 7, 9]

 

 

 

 

리스트의 원소를 인덱싱 할 수 있다. (튜플에서 적용)

 

s = ['자바','파이썬','오라클','스프링','텐스플로우']

print(s)
print(s[0])                     # 자바
print(s[1])                     # 파이썬
print(s[2])                     # 오라클
print(s[3])                     # 스프링
print(s[4])                     # 텐스플로우
print(s[-1])                    # 가장 마지막 원소 인덱싱 : 텐스플로우
print(s[-2])                    # 끝에서 2번빼 원소를 인덱싱 : 스프링

 

 

중첩 리스트.

리스트 안에 또 다른 리스트가 들어가 있을 수도 있다.

 

# 중첩 리스트
listdata = [1, 2, 'a', 'b', 'c', [4, 5, 6]]
data1 = listdata[1]
data2 = listdata[3]
data3 = listdata[5]
data4 = listdata[5][1]
data5 = listdata[-1]		# 마지막 원소

print('data1:', data1)          # 2 출력
print('data2:', data2)          # b 출력
print('data3:', data3)          # [4, 5, 6] 출력
print('data4:', data4)          # 5 출력
print('data5:', data5)          # [4, 5, 6] 출력

 

 

삼중으로 중첩하는 삼중 리스트도 있다.

 

# 삼중 리스트
list = [1, 2, ['a', 'b', ['Life', 'is']]]
data = list[2][2][0]
print('data:', data)            # Life 출력

 

 

 

 

슬라이싱

리스트 [ 시작index : 끝index ]

 -> 시작 인덱스부터 끝인덱스-1 까지 슬라이싱

 

s = ['자바','파이썬','오라클','스프링','텐스플로우']

# 인덱스 0~1번 원소 슬라이싱
print(s[0:2])               # ['자바', '파이썬']

# 인덱스 1~2번 원소 슬라이싱
print(s[1:3])               # ['파이썬', '오라클']

# 처음부터 인덱스 2번 원소까지 슬라이싱
print(s[:3])                # ['자바', '파이썬', '오라클']

# 인덱스 2번부터 끝까지 슬라이싱
print(s[2:])                # ['오라클', '스프링', '텐스플로우']

 

 

 

 

중첩 리스트의 슬라이싱

 

# 중첩 리스트에서 슬라이싱
s1 = [1, 2, 3, ['a', 'b', 'c'], 4, 5]

# 인덱스 2~4번까지 원소를 슬라이싱
print(s1[2 : 5])            # [3, ['a', 'b', 'c'], 4]

print(s1[3][:2])            # ['a', 'b']

 

 

 

numpy

리스트를 숫자 형태의 배열 형태로 만든다.

리스트는 여러가지 자료형을 혼용하여 저장할 수 있지만,

배열은 한가지 자료형의 집합이므로 반드시 일정한 형태의 자료형만 들어갈 수 있다.

같은 숫자라도 정수와 실수를 함께 넣은 리스트를 변환할 경우

모든 정수가 조금 더 큰 자료형인 실수형으로 변환되어 배열로 처리된다.

 

import numpy as np

s3 = [[1,2,3],[4,5,6],[7,8,8]]		# 중첩 리스트
    
a1 = np.array(s3)			# 배열 형태로 변환 -> 2차원 형태
print(a1)

 

 

 

 

리스트의 연산 ( +, * (반복))

 

# 리스트의 연산 : +
data1 = ['a','b','c','d','e']
data2 = ['f','g','h','i','j']
result1 = data1 + data2
result2 = data2 + data1

print('result1:', result1)          # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
print('result2:', result2)          # ['f', 'g', 'h', 'i', 'j', 'a', 'b', 'c', 'd', 'e']

#  리스트의 연산 : *
listdata = list(range(3))           # [0, 1, 2]
print(listdata)

result = listdata * 3               # listdata를 3번 반복한 리스트
print('result:', result)            # [0, 1, 2, 0, 1, 2, 0, 1, 2]

 

 

 

 

sum

모든 원소들의 합을 구할 수 있다.

이 때, range 함수를 중첩 사용할 수 있다.

 

list1 = [2,2,1,3,8,5,7,6,3,6,2,3,9,4,4]
list2 = list(range(1,11))           # 1 ~ 10

result1 = sum(list1)
result2 = sum(list2)

print('result1:', result1)      # 65
print('result2:', result2)      # 55

 

 

 

 

len

문자의 길이를 구해주는 함수였지만, 리스트에서 사용하면 모든 원수의 개수를 구해준다.

 

listdata = [2,2,1,3,8,5,7,6,3,6,2,3,9,4,4]

length = len(listdata)
print('원소의 개수:', length)        # 15 개의 원소

 

 

insert, append

• insert : 리스트의 특정 위치에 원소를 삽입할 때 사용
• append : 리스트의 가장 마지막 자리에 새로운 원소가 추가된다

 

a = [1, 2, 3]
a.append(4)                 # 4 추가
print('a:', a)              # [1, 2, 3, 4]

a.append([5, 6])            # [5, 6] 추가
print('a:', a)              # [1, 2, 3, 4, [5, 6]]

 

# insert( 인덱스 번호, 데이터 )

a = [1, 2, 3]

# 인덱스 0번 위치에 4를 삽입
a.insert(0, 4)
print('a:', a)                  # [4, 1, 2, 3]

# 인덱스 3번 위치에 5를 삽입. 기존 원소는 순서가 한 칸 밀린다.
a.insert(3, 5)
print('a:', a)                  # [4, 1, 2, 5, 3]

 

 

 

 

remove, del

 

리스트의 원소를 삭제하는 원소는 두 가지가 있는데 그 중 하나이다.

특정 원소를 삭제하며, 사용 형식은 remove('삭제할 데이터') 이다.

중복된 데이터가 있을 경우 첫번째 값만 삭제한다.

 

a = [1, 2, 3, 1, 2, 3]
a.remove(3)                 # 첫번째로 나오는 3을 삭제
print('a:', a)              # [1, 2, 1, 2, 3]

a.remove(3)                 # 두번째로 나오는 3을 삭제
print('a:', a)              # [1, 2, 1, 2]

 

 

 

반면, del은 인덱스 번호를 이용해 삭제한다.

사용형식은 del 리스트이름[ 인덱스번호 ]

 

a = [1, 2, 3]
del a[1]                    # 인덱스 1번 원소 삭제
print('a:', a)              # [1, 3]

b = [1, 2, 3, 4, 5]
del b[2:]                   # 인덱스 2번 원소부터 끝까지 삭제
print('b:', b)              # [1, 2]

del b                       # 리스트 b를 메모리 상에서 삭제
print(b)                    # NameError: name 'b' is not defined

 

 

 

 

 

index

리스트에서 특정 원소의 인덱스 번호를 구해준다. (자바의 IndexOf)

 

solarsys = ['태양','수성','금성','지구','화성','목성','토성','천왕성','해왕성','지구']
planet = '지구'

# 가장 먼저 나오는 '지구'의 인덱스 번호를 구함
pos = solarsys.index(planet)                # 인덱스 번호 : 3
print('%s은(는) 태양계에서 %d번째 위치하고 있습니다.'%(planet, pos))

# 인덱스 5번 이후에 나오는 '지구'의 인덱스 번호를 구함
pos = solarsys.index(planet, 5)                # 인덱스 번호 : 9
print('%s은(는) 태양계에서 %d번째 위치하고 있습니다.'%(planet, pos))

 

파이썬에서 같은 기능을 하는

문자열의 인덱스를 구하는 find 함수의 경우 -1을 리턴하지만

index는 오류가 발생한다.

 

# 찾는 원소가 없는 경우에는 오류 발생
pos = solarsys.index('명왕성')
print(pos)

 

 

 

pop

리스트의 가장 마지막 원소를 삭제하고 리턴한다.

지정된 인덱스가 있다면 해당 원소를 삭제하고 리턴한다.

 

list = [10, 20, 30, 40, 50]
data1 = list.pop()              # 마지막 원소인 50을 삭제하고 50을 리턴
print('data1:', data1)          # 50
print('list:', list)            # [10, 20, 30, 40]

data2 = list.pop(2)             # 인덱스 2번 원소(30)를 삭제하고 리턴
print('data2:', data2)          # 30
print('list:', list)            # [10, 20, 40]

 

 

 

 

sort, sorted

• sort : 리스트를 정렬하지만 원본에 영향을 미친다.
• sorted : 리스트를 정렬하지만 원본에는 영향이 없다.

 

# ----------------------- sort ------------------------------
#        오름차순 정렬                내림차순 정렬
#------------------------------------------------------------
# 숫자    1, 2, 3, .....             10, 9, 8,.....
# 문자   사전순 정렬(a,b,c...)       사전 역순 정렬(z,y,x...)

# 오름차순 정렬 : 리스트.sort()
# 내림차순 정렬 : 리스트.sort( reverse = True)

namelist = ['Mary','Sams','Aimy','Tom','Michale','Bob','Kelly']

namelist.sort()               # 오름차순 정렬
print('namelist:', namelist)  # ['Aimy', 'Bob', 'Kelly', 'Mary', 'Michale', 'Sams', 'Tom']

namelist.sort(reverse=True)    # 내림차순 정렬
print('namelist:', namelist)  # ['Tom', 'Sams', 'Michale', 'Mary', 'Kelly', 'Bob', 'Aimy']

 

 

# 오름차순 정렬 : sorted( 리스트 )
# 내림차순 정렬 : sorted( 리스트, reverse = True )
# sorted() 함수를 이용해서 정렬을 하면 원본 리스트가 변경되지 않는다.

namelist = ['Mary','Sams','Aimy','Tom','Michale','Bob','Kelly']

result1 = sorted(namelist)                  # 오름차순 정렬
result2 = sorted(namelist, reverse= True)   # 내림차순 정렬
print(type(result1))                        # <class 'list'>
print(type(result2))

print('result1:', result1)  # ['Aimy', 'Bob', 'Kelly', 'Mary', 'Michale', 'Sams', 'Tom']
print('result2:', result2)  # ['Tom', 'Sams', 'Michale', 'Mary', 'Kelly', 'Bob', 'Aimy']

# sorted() 함수로 정렬하더라도 원래 namelist는 변경되지 않는다.
print('namelist:', namelist)

 

 

 

 

reverse

리스트의 원소의 순서를 역순으로 바꾸는 기능을 하고, 원본에 영향을 준다.

 

listdata = list(range(10))          # 0 ~ 9
print(listdata)                     # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

listdata.reverse()                  # listdata 역순으로 변경
print('listdata:', listdata)        # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

 

 

 

 

정렬하는 여러가지 방법

 

# [1, 3, 5, 4, 2] 라는 리스트를 [5, 4, 3, 2, 1]로 변경
list = [1, 3, 5, 4, 2]

# 방법1. sort()
list.sort(reverse=True)                 # 내림차순 정렬
print('list:', list)

# 방법2. sort(), reverse()
list.sort()                             # 오름차순 정렬
list.reverse()                          # 역순으로 정렬
print('list:', list)

# 방법3. sorted()
list2 = sorted(list, reverse=True)      # 내림차순 정렬
print('list2:', list2)

# 방법4. sorted(), reverse()
list3 = sorted(list)                    # 오름차순 정렬
list3.reverse()                         # 역순으로 정렬
print('list3:', list3)