python list create
이 Python List 자습서에서는 가장 유용한 데이터 유형 중 하나 인 Python 목록에 요소를 생성, 액세스, 슬라이스, 추가 / 삭제하는 방법을 살펴 봅니다.
Python에는 아래와 같이 4 가지 컬렉션 데이터 유형이 포함됩니다.
- 명부
- 세트
- 사전
- 튜플
이 자습서에서는 List 및 다양한 작업에 대해 자세히 설명합니다. 파이썬에서 목록은 데이터 구조이거나 한 번에 여러 데이터를 저장하는 데 사용되는 배열과 같습니다.
Java, C, C ++ 등과 같은 다른 프로그래밍 언어에 대한 경험이 있다면 배열 개념에 익숙 할 것입니다. 목록은 배열과 거의 동일합니다.
학습 내용 :
파이썬 목록이란?
Python에서 목록은 데이터 형식 , 대괄호 (()) 안에 다른 개체 (항목) 모음을 저장합니다. 목록의 각 항목은 첫 번째 항목이 인덱스 0에있는 쉼표 (,)로 구분됩니다.
노트 :앞으로이 자습서의 모든 예제는 달리 명시되지 않는 한 Python 셸에서 직접 실행됩니다.
다음은 5 개 항목이있는 목록의 예입니다.
>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how') 위의 예에서 목록에 문자열 객체 각 항목은 쉼표로 구분됩니다.
Python 목록의 특성
목록의 항목을 조작하는 방법을 살펴보기 전에 Python 목록을 선호하는 몇 가지 특성을 살펴 보겠습니다.
Python 목록은 컨테이너 시퀀스입니다.
플랫 시퀀스 ( 끈 , array.array , 메모 리뷰 등) 한 가지 유형의 항목 만 포함 할 수 있습니다. 목록은 컨테이너 순서 한 가지 유형과 다른 유형의 항목을 보관할 수 있습니다.
한 가지 유형의 항목이있는 예
파이썬 셸을 열고 숫자 목록을 정의 해 보겠습니다.
>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five') 위의 예는 동일한 유형 (이 경우 유형)의 항목 목록을 보여줍니다. 문자열 (str) .
유형이 다른 항목의 예
Python 셸을 열고 다른 버전의 숫자 목록을 정의 해 보겠습니다.
>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0) 위의 예는 다양한 유형의 항목 목록을 보여줍니다. 유형은 끈 , 정수, 과 흙손 .
// a sketch showing the list of items and their types as annotationPython 목록은 다음과 같은 모든 객체를 포함 할 수도 있습니다. 기능 , 클래스 , 모듈 , 기울기 , 튜플, 그리고 훨씬 더.
편집기를 열고 아래 코드를 붙여 넣으십시오.
def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list) 산출
파이썬 목록은 순서가있는 시퀀스입니다
Python 목록은 정렬 된 개체 모음입니다. 목록에서 각 항목의 위치는 매우 중요합니다. 실제로 항목이 배치되는 순서가 같지 않으면 항목이 동일한 두 목록이 동일하지 않습니다.
>>> ('a','b','c','d') == ('a','c','b','d') False 파이썬 목록의 이러한 특성은 색인과 슬라이싱을 통해 항목에 액세스 할 수있게합니다. (나중에 더 자세히 설명합니다).
파이썬 목록은 변경 가능한 시퀀스입니다
파이썬 목록은 변경 가능합니다. 하지만 가변 객체 란 무엇입니까? 생성 된 후 수정할 수있는 단순한 개체입니다. 예 다른 가변 시퀀스의 사전 , array.array , collections.deque .
왜 가변적입니까? 목록과 같은 시퀀스는 복잡한 작업에 사용되므로 다음을 수행 할 수 있어야합니다. 변화 , 자라다 , 수축 , 업데이트 등 . 이것은 가변성으로 만 가능합니다. 가변성은 또한 우리가 목록을 수정할 수있게합니다 (자세한 내용은 여기).
아래 예제를 통해 목록의 변경 가능성을 확인해 보겠습니다..
편집기를 열고 코드를 붙여 넣기 만하면됩니다.
def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability() 산출
위의 출력에서 수정 전후 목록이 다른 것을 알 수 있습니다. 그러나, 그 신분증 값은 동일합니다. 그만큼 신분증 여기서 값은 메모리에있는 객체의 주소를 나타냅니다.이 주소는 Python으로 획득됩니다. 신분증() .
이것은 목록 내용이 변경되었지만 여전히 동일한 객체임을 알려줍니다. 따라서 이것은 우리의 정의를 충족합니다.“ 생성 후 수정할 수있는 단순한 객체입니다. '
노트 :위의 예에서는 목록을 수정하기 위해 인덱싱 (자세한 내용)을 사용했습니다.
파이썬 목록 조작
Python 목록을 사용하면 한계가 없습니다. 목록으로 할 수있는 일은 무수히 많습니다. 첨가 , 삭제 , 인덱싱 , 슬라이스 , 회원 확인 , 그리고 훨씬 더. 또한 Python에는 목록을 더 흥미롭게 조작하는 데 도움이되는 내장 함수가 있습니다.
이 섹션에서는 일반적으로 사용되는 몇 가지 목록 작업을 살펴 보겠습니다.
목록 만들기
목록을 만들려면 여러 항목이나 표현식을 쉼표로 구분 된 대괄호 안에 넣으면됩니다.
(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False) 또한 Python에는 명부 () 목록을 만드는 데 사용할 수 있습니다.
list( sequence ) >>> l = list() # create an empty list >>> l () 파이썬 명부 ()는 시퀀스 유형을 가져 와서 목록으로 변환 할 수 있습니다. 이것은 튜플을 목록으로 변환하는 일반적인 방법입니다.
>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5) 위의 예에서는 데이터 유형을 사용했습니다. 튜플 . 목록과 유사하지만 목록과 달리 변경 불가능하며 항목은 괄호로 묶여 있습니다.
목록을 만들 수있는 또 다른 방법은 목록 이해 다음 구문이 있습니다.
(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9) Python 목록이 참조로 전달된다는 점은 주목할 가치가 있습니다. 즉, 목록을 할당하면 메모리 위치 ID가 제공됩니다. 많은 초보자들이하는 실수는 이런 식으로 목록을 만드는 것입니다.
>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3) 여기에서 우리는 두 개의 다른 목록을 만들었다 고 생각할 수 있지만 실제로는 하나를 만들었습니다. 변수 중 하나를 수정하여이를 시연 해 보겠습니다.
>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3) 하나의 변수를 수정하면 다른 변수도 변경됩니다. 이는 변수 l1과 l2가 동일한 메모리 위치 ID를 보유하므로 둘 다 동일한 객체를 가리 키기 때문입니다.
목록에 항목 추가
Python에는 목록에 요소를 추가하는 여러 가지 방법이 있습니다. 가장 일반적인 방법은 append () 방법. 다른 방법은 넓히다() 방법. 인덱싱 과 슬라이스 (나중에 자세히 설명) 목록의 항목을 대체하는 데 더 많이 사용됩니다.
# 1) append () 메서드 사용
이 메서드는 단일 항목을 가져와 목록 끝에 추가합니다. 새 목록을 반환하지 않고 목록을 제자리에서 수정합니다 (변경 가능성 덕분에).
>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, ) 위의 예에서 몇 가지 유의할 사항 :
- 여기에있는 항목은 표현식, 데이터 유형, 시퀀스 등이 될 수 있습니다.
- 그만큼 append () 방법의 시간 복잡도는 (0) 1입니다. 그것은 일정하다는 것을 의미합니다.
# 2) extend () 메서드 사용
이 메서드는 iterable을 인수로 받아들이고 모든 항목을 목록 끝에 추가합니다. 이 방법은 주로 시퀀스의 개별 항목을 목록에 추가하려는 경우에 사용됩니다.
기본적으로 넓히다() 메소드는 인수를 반복하고 각 항목을 목록에 추가합니다. append () 메서드와 마찬가지로 새 목록을 반환하지 않고 목록을 제자리에서 수정합니다.
>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o') 위의 예에서 몇 가지 유의할 사항 :
- 문자열은 반복 가능하므로 넓히다() 메소드는 문자를 반복합니다.
- 그만큼 넓히다() 방법의 시간 복잡도는 (0) K 여기서 K는 인수의 길이입니다.
목록에서 항목 액세스
인덱싱 과 슬라이스 목록에 액세스하는 데 사용되는 가장 일반적인 방법입니다. 또한 다음과 같은 루프를 사용하여 목록의 항목에 액세스 할 수 있습니다. for 루프 .
# 1) 인덱싱
Python 목록은 0부터 시작하는 번호 매기기 체계. 즉, 모든 항목은 0에서 n-1까지 시작하는 인덱스 번호로 고유하게 식별됩니다. 여기서 n은 목록의 길이입니다.
아래 목록을 고려하십시오.
>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5 아래 표는 0부터 시작하는 목록 번호 매기기.
| 안건 | 그물 | 푸른 | 초록 | 노랑 | 검정 |
|---|---|---|---|---|---|
| 팝 () | 목록의 마지막 요소에서 요소를 삭제 / 제거합니다. | ||||
| 인덱스 | 0 | 1 | 두 | 삼 | 4 |
위의 표에서 첫 번째 항목 ( 'red')은 인덱스 위치 0에 있고 마지막 항목 ( 'black')은 인덱스 위치 4 (n-1)에 있습니다. 여기서 n = 5 (객체의 길이 그림 물감).
위의 특성 섹션에서 보았 듯이 Python 목록은 순서가 지정된 시퀀스입니다. 이를 통해 인덱싱을 사용하여 항목에 쉽게 액세스하고 조작 할 수 있습니다.
인덱싱을 사용하여 위에서 만든 색상 개체의 특정 인덱스에있는 항목에 액세스 해 보겠습니다.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range 노트 :위의 마지막 문은 길이가 5 인 목록 객체에서 인덱스 위치 9에있는 항목에 액세스하려고합니다. Python 목록에서 존재하지 않는 인덱스에있는 항목에 액세스하면 IndexError 예외.
인덱싱의 중요한 개념은 네거티브 인덱싱을 사용할 수 있다는 것입니다. 즉, 마지막 항목에 대해 -1에서 시작하고 n이 목록 개체의 길이 인 마지막 항목에 대해 -n에서 끝나는 역순으로 목록 항목에 액세스 할 수 있습니다.
위의 표에서 음수 인덱싱을 사용하면 다음과 같이 표시됩니다.
| 안건 | 그물 | 푸른 | 초록 | 노랑 | 검정 |
|---|---|---|---|---|---|
| 인덱스 | -5 | -4 | -삼 | -두 | -1 |
위에서 만든 색상 개체의 일부 항목에 액세스하기 위해 음수 인덱싱을 사용하겠습니다.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red' # 2) 슬라이싱
하나의 항목 만 반환하는 인덱싱과 달리 슬라이스 반면에 다양한 항목을 반환 할 수 있습니다.
구문은 다음과 같습니다.
L(n:m)n이 슬라이스가 시작되는 인덱스 번호 (기본값은 0)이고 m은 슬라이스가 끝나는 배타적 인덱스 번호 (기본값은 길이 -1) 인 경우. 콜론 (:)으로 구분됩니다.
위에서 만든 색상 객체의 특정 인덱스에있는 항목에 액세스하기 위해 슬라이싱을 사용하는 아래 예제를 고려하십시오.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>> 구문 L (n : m)에서 n의 기본값은 0이고 m은 목록의 길이입니다. 그래서 예 1 과 삼 위에서 n과 m은 각각 colors (: 2)와 colors (2 :)로 생략 할 수 있습니다. 또는 (:)이 경우 전체 목록 개체의 얕은 복사본을 반환합니다.
목록을 분할하는 동안 음의 인덱스 번호를 사용할 수도 있습니다. 일반적으로 역순으로 목록에 액세스하려는 경우에 사용됩니다.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black') 또한 슬라이싱이 지원하는 세 번째 매개 변수가 있습니다. 단계 (에스). 목록에서 첫 번째 항목을 검색 한 후 앞으로 이동할 항목 수를 정의합니다. 기본값은 1입니다.
L(n:m:s)위에서 정의한 것과 동일한 색상 목록을 사용하여 슬라이스의 세 번째 매개 변수를 사용하여 2 단계를 이동합니다.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green') # 3) 루프 사용
루프는 주로 항목을 조작하기 위해 목록의 항목에 액세스하는 데 사용됩니다. 따라서 목록의 항목에 대해 작업하려는 경우 for 루프 항목에 액세스하고 작업 할 수 있도록 전달합니다.
각 항목의 글자 수를 세고 싶다고 가정 해 보겠습니다. 우리는 for 루프 그것을 달성하기 위해.
편집기를 열고 아래 코드를 붙여 넣으십시오.
def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors)) 산출
이 섹션을 끝내기 위해 슬라이싱으로 수행 할 수있는 두 가지 멋진 작업을 살펴 보겠습니다.
-
목록의 얕은 사본 만들기
사용하는 기본 방법입니다. 부() 목록 객체의 메소드 또는 내장 함수 copy.copy . 그러나 이것은 슬라이싱으로 달성 할 수 있습니다.
>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>> -
목록 반전
기본적인 방법은 역전 목록 객체의 메소드 또는 내장 함수 반전 () . 그러나 이것은 슬라이싱으로 달성 할 수 있습니다.
>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>> 목록에서 항목 제거
목록에 많은 항목을 추가 할 수 있으므로 목록에서 제거 할 수도 있습니다. 항목을 제거 할 수있는 세 가지 방법은 다음과 같습니다.
# 1) del 문 사용
구문은 다음과 같습니다.
del target_list대상 목록 ( target_list )는 전체 목록 (목록을 삭제하려는 경우) 또는 목록의 항목 (이 경우 인덱싱 또는 슬라이싱 사용) 일 수 있습니다.
아래 예를 고려하십시오. .
위에서 만든 색상 목록에서 일부 항목을 삭제하려고합니다.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>> 노트 :del 문은 제자리에 즉. , 새 목록 개체를 반환하는 대신 원래 목록 개체를 수정합니다.
# 2) list.remove (x) 사용
값이 다음과 같은 목록에서 첫 번째 항목을 제거합니다. 엑스 . 그러한 항목이 없으면 ValueError를 발생시킵니다.
이 방법은 인덱싱 및 슬라이싱을 사용하는 del 문과 달리 이름별로 목록에서 항목을 제거하는 데 주로 사용됩니다.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>> 노트 :목록 개체 없애다() 방법 삭제 제자리에 즉. , 새 목록 개체를 반환하는 대신 원래 목록 개체를 수정합니다.
# 3) list.pop ((i)) 사용
목록 개체의 지정된 위치에서 항목을 제거하고 반환합니다. i (index)가 제공되지 않으면 목록에서 마지막 항목을 제거하고 반환합니다.
노트 :위의 i 주위의 대괄호는 i 목록을 의미하는 것이 아니라 선택 사항임을 의미합니다.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>> 노트 : 목록. 팝 ((i)) 방법 삭제 제자리에 즉. , 새 목록 개체를 반환하는 대신 원래 목록 개체를 수정합니다. 또한 목록에서 제거 된 항목을 반환합니다.
목록에서 항목 바꾸기
항목 교체는 매우 간단합니다. 위 섹션 중 하나에서 인덱싱 및 슬라이싱을 보았습니다. 목록에서 항목에 액세스하고 제거하는 데 사용할 수 있습니다.
# 1) 인덱싱을 사용하여 바꾸기
L(index) = value >>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>> # 2) 슬라이싱으로 교체
L(n:m) = value노트 : 값 이어야합니다 반복 가능 또는 TypeError 예외가 발생합니다.
>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>> 자주 묻는 질문
Q # 1) Python의 목록 목록은 무엇입니까?
대답: Python의 목록 목록은 목록을 항목으로 포함하는 목록입니다.
예를 들면
(('a','b'),('c','d'))그것은 또한 중첩 된 목록 .
Q # 2) 파이썬에서 목록을 어떻게 선언합니까?
대답: Python에서 목록은 두 가지 방법으로 선언 할 수 있습니다. 내장 기능을 사용하여 명부() 또는 대괄호 표기법 ()을 사용합니다. 명부() iterable을 취하고 ()는 쉼표로 구분 된 모든 유형의 항목을 취합니다.
(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)Q # 3) 목록 Python에 목록을 넣을 수 있습니까?
대답: 예, 목록 안에 목록을 넣을 수 있습니다. 실제로 목록은 모든 데이터 유형의 항목을 가져 오는 컨테이너 시퀀스입니다.
Q # 4) 파이썬에서 list ()는 무엇을합니까?
답 : list ( )는 목록 객체를 생성하는 Python의 내장 함수입니다. iterable을 인수로받습니다.
>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>> Q # 5) Python 목록에 다른 유형이 포함될 수 있습니까?
대답: 목록은 모든 데이터 유형의 항목을받는 컨테이너 시퀀스입니다 ( 명부 , 튜플 , 정수 , 흙손 , 문자열 등)
Python의 목록에 대한 추가 정보
데이터 구조 란?
컴퓨터는 엄청난 수의 데이터를 저장하거나 엄청난 수의 데이터를 빠르고 정확하게 처리하는 데 사용됩니다. 따라서 빠른 액세스를 위해 데이터를 영구적으로 저장하는 것이 가장 좋습니다.
데이터 처리가 진행되는 동안 정확성을 잃지 않고 가능한 한 최단 시간 내에 이루어져야합니다. 우리는 데이터 구조를 사용하여 체계적인 방식으로 데이터를 처리하고 처리를 위해 데이터를 메모리에 저장합니다.
Python은 고수준의 해석 된 프로그래밍 언어이므로 Python의 데이터 구조를 사용하는 것이 매우 중요합니다.
목록이란 무엇입니까?
목록은 한 번에 여러 데이터를 저장하는 데 사용되는 데이터 구조입니다.
목록에 저장된 데이터는 동 질적이며 결과적으로 Python에서 목록의 가장 강력한 기능이됩니다. 문자열, 정수 및 객체와 같은 다양한 데이터 유형의 여러 데이터를 단일 목록에 저장할 수 있습니다.
목록은 Python에서 변경 가능하므로 데이터는 생성 후에도 언제든지 변경할 수 있습니다. 목록은 Python에서 스택과 큐를 구현하는 데 매우 강력합니다.
앞에서 설명한 것처럼 목록은 순서가 지정된 순서로 데이터를 저장하고 목록에 저장된 데이터는 해당 인덱스를 사용하여 액세스하며 목록의 경우 인덱스는 항상 0부터 시작합니다. 각 요소는 목록에서 특정 위치를 가지며 이러한 모든 데이터는 색인의 도움으로 액세스됩니다.
목록에서 동일한 값을 여러 번 저장할 수 있으며 각 데이터는 별도의 고유 한 요소로 간주됩니다. 목록은 데이터를 저장하고 나중에 반복하는 데 가장 적합합니다.
목록 만들기
목록의 데이터는 쉼표로 구분되고 대괄호 (())로 묶여 저장됩니다. 목록의 항목은 동일한 유형일 필요가 없습니다.
Syntax: List = (item1, item2, item3)예 1 :
List = ( )예 2 :
List = (2, 5, 6.7)예 3 :
List = (2, 5, 6.7, ‘Hi’)예 4 :
List = (‘Hi’, ‘Python’, ‘Hello’)위의 예에서 우리는 쉼표로 구분 된 다른 데이터 유형의 항목을 저장했음을 알 수 있습니다. 2와 5는 정수 유형, 6.7은 float 유형, 'Hi'는 문자열 유형입니다. 이러한 모든 항목은 목록이 목록이됩니다.
빈 목록도 선언 할 수 있습니다. 다른 목록 안에 목록을 선언 할 수도 있으며이를 중첩 목록이라고합니다.
예 5 :
List = (‘Hi’, (2, 4, 5), (‘Hello’))위의 예에서 목록이 다른 목록 안에 선언 된 것을 볼 수 있습니다.
목록의 값에 액세스
Python의 목록에있는 항목에 액세스 할 수있는 다양한 방법이 있습니다.
색인의 도움으로 목록의 요소에 액세스 할 수 있습니다. 인덱스는 0부터 시작하며 인덱스는 항상 정수 여야합니다. float와 같은 정수 이외의 인덱스를 사용하면 TypeError가 발생합니다.
예 1 :
List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)산출:
목록 : (2, 5, 6.7,‘안녕하세요’)
산출:
자바에서 객체 배열 만들기
위의 예에서 우리는 인쇄 기능을 사용하여 목록을 직접 인쇄하고 있으며 목록에서 개별 요소에 액세스하지 않습니다.
목록에서 개별 요소에 액세스 해 보겠습니다.
예 : 2
List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))산출:
목록의 두 번째 요소는 다음과 같습니다. 5
산출:
위의 예에서 목록의 두 번째 요소 인 5를 인쇄하고 있음을 알 수 있지만 인쇄 문에서 List (1)을 인쇄하는 이유에 대한 질문을받을 수 있습니다. 인덱스가 0에서 시작하기 때문에 List (1)은 목록의 두 번째 요소를 참조합니다.
예 : 3
List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))산출:
목록의 첫 번째 요소는 다음과 같습니다. 2
목록의 마지막 요소 : Hi
산출:
예 : 4
List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))산출:
목록의 첫 번째 요소는 다음과 같습니다. i
다른 목록에있는 요소는 다음과 같습니다. 5
산출:
위의 프로그램에서주의 깊게 관찰하면 중첩 된 목록의 요소에 액세스하고 있음을 알 수 있습니다.
내부적으로 데이터는 아래와 같이 매트릭스 형식으로 저장됩니다.
안녕
2 4 5
따라서 List (0) (1)에 액세스하려고하면 1을 가리 킵니다.성행 및 2nd열이므로 데이터는 'i'가됩니다.
마찬가지로 List (1) (2)에 액세스하려고하면 2를 가리 킵니다.nd행 및 3rd열, 따라서 데이터는 5가됩니다.
네거티브 인덱싱
음수 인덱스를 사용하여 데이터에 액세스 할 수도 있습니다. 음수 인덱스는 항상 -1에서 시작하고 -1은 마지막 요소를, -2는 마지막 두 번째 항목을 나타냅니다.
예 : 1
List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))산출:
목록의 마지막 요소 : 3
산출:
예 : 2
List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))산출:
목록의 두 번째 요소 : 5
산출:
목록 자르기
슬라이스 연산자 (:)를 사용하여 목록에서 다양한 요소에 액세스 할 수 있습니다.
예 : 1
List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))산출:
2에서 5까지의 요소는 (2, 3, 4, 5)입니다.
2 번째부터 시작하는 요소 : (1, 2, 3, 4)
네 번째에서 끝까지의 요소 : (4, 5, 6, 7)
시작부터 끝까지의 요소 : (1, 2, 3, 4, 5, 6, 7)
산출:
for 루프를 사용하여 목록에있는 요소에 액세스 할 수도 있습니다.
예 : 2
List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)산출:
1
두
삼
4
5
6
7
산출:
아래 색인 형식을 기억하세요.
| H | IS | 엘 | 엘 | 또는 | 5 | 7 | 9 | 4 |
| 0 | 1 | 두 | 삼 | 4 | 5 | 6 | 7 | 8 |
| -9 | -8 | -7 | -6 | -5 | -4 | -삼 | -두 | -1 |
앞에서 설명한 것처럼 List in python은 변경 가능합니다. 즉, Integer, String 또는 데이터 유형이더라도 요소를 변경할 수 있습니다.
할당 연산자를 사용하여 목록을 업데이트 할 수 있습니다.
예 : 3
List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)산출:
업데이트 된 목록 : (7, 4, 6, 9)
산출:
위의 예에서는 목록 '2'의 첫 번째 요소를 새 요소 '7'로 업데이트합니다.
예 : 4
List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)산출:
업데이트 된 목록 : (2, 5, 2, 4, 9, 0, 7)
위의 예에서는 데이터 목록을 목록으로 업데이트하고 있습니다.
산출:
목록에 요소 추가
목록에 요소를 추가하는 방법에는 여러 가지가 있으며 파이썬에는 append ()라는 내장 함수가 있습니다.
append ()를 사용하면 목록에 하나의 요소 만 추가 할 수 있습니다. 목록에 여러 요소를 추가하려면 다음을 사용해야합니다. for 루프 . append () 함수는 항상 목록 끝에 요소를 추가하고 append () 함수는 하나의 인수 만 사용합니다.
특정 위치에 요소를 추가하려면 insert () 메서드를 사용하면됩니다. insert ()는 두 개의 인수, 즉 위치와 값을 취하고, 위치는 색인을 참조하며, 여기서 요소는 추가되어야하고 값은 목록에 추가 될 요소를 참조합니다.
extend ()라는 메서드가 하나 더 있는데,이를 사용하여 목록에 요소를 추가 할 수 있습니다. extend () 메서드는 목록에 요소 목록을 추가하는 데 사용됩니다. append () 메서드 및 extend () 메서드와 유사하게 목록 끝에 요소를 추가합니다.
예 : 1
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)산출:
값을 추가하기 전 목록 : ( 'Hello', 'Good Morning')
값을 추가 한 후의 목록 : ( 'Hello', 'Good Morning', 'Python', 'Hi')
위의 예에서는 목록 끝에‘Python’및‘Hi’값을 추가합니다.
산출:
예 : 2
List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))산출:
값을 추가하기 전 목록 : ( 'Hello', 'Good Morning')
추가 전 목록 길이 : 2
값을 추가 한 후의 목록 : ( 'Hello', 'Good Morning', 'Python', 'Hi')
추가 후 목록 길이 : 4
위의 예와 같이 len () 함수를 사용하여 목록의 길이를 찾을 수 있습니다.
산출:
for 루프를 사용하여 목록에 여러 값을 추가 할 수도 있습니다.
예 : 3
List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))산출:
요소를 추가하기 전 목록 : (7, 9, 8)
요소를 추가하기 전 목록 길이 : 3
요소 추가 후 목록 : (7, 9, 8, 2, 3, 4, 5)
요소 추가 후 목록 길이 : 7
산출:
목록에 목록을 추가하면 어떻게됩니까? 아래 예에서 살펴 보겠습니다.
예 : 4
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)산출:
List2를 추가 한 후 List1은 다음과 같습니다. (“Hi”,“Python”, (1, 5, 7, 2))
메이크 파일 C ++를 만드는 방법
위의 예에서 List2를 List1에 추가하면 List1이 중첩 된 목록이됩니다.
산출:
목록을 추가 한 후 목록을 중첩 목록으로 만들지 않으려면 extend () 메서드를 사용하는 것이 좋습니다.
예 : 5
List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)산출:
List2를 추가 한 후의 List1은 다음과 같습니다. (“Hi”,“Python”, 1, 5, 7, 2)
extend () 메서드를 사용하면 List1의 요소가 List2의 요소로 확장됩니다. extend () 메소드를 사용할 때 목록을 추가하지 않습니다.
산출:
문자열로 목록을 확장하면 문자열이 반복 가능하므로 문자열의 각 문자를 목록에 추가합니다.
예 : 6
List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)산출:
문자열 확장 후 목록 : (1, 5, 7, 2,‘P’,‘y’,‘t’,‘h’,‘o’,‘n’)
산출:
목록 append () 대 extend ()
extend () 및 append ()에 대한 몇 가지 예를 살펴 보겠습니다.
예 : 1
def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()산출:
List의 요소는 다음과 같습니다. ( 'Hi', 1, 'Hello', 2, 5)
문자열을 추가 한 후의 목록은 다음과 같습니다. ( 'Hi', 1, 'Hello', 2, 5, 'Python')
목록을 추가 한 후의 목록은 다음과 같습니다. ( 'Hi', 1, 'Hello', 2, 5, 'Python', ( 'one', 'two', 3))
List2를 확장 한 후 List1은 다음과 같습니다. ( 'Hi', 1, 'Hello', 2, 5, 'Python', ( 'one', 'two', 3), 'Apple', 'Orange', 2, 8)
산출:
예 : 2
List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)산출:
삽입 전 목록 : ( 'Apple', 'Orange', 'Mango', 'Strawberry')
삽입 후 목록 : ( '사과', '오렌지', '수박', '망고', '딸기')
산출
앞에서 논의했듯이 insert () 메서드는 목록의 특정 인덱스에 값을 삽입하는 데 사용됩니다.
예 : 3
List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)산출:
요소를 추가 한 후 목록은 다음과 같습니다. (2, 4, 6, 8, 1, 3, 5, 7)
같은 요소를 반복해서 추가하면 (‘안녕’,‘안녕’,‘안녕’,‘안녕’,‘안녕’)
산출:
목록에서 요소 삭제 또는 제거
del 및 remove () 문을 사용하여 목록에서 요소를 삭제하거나 제거 할 수도 있습니다.
아래 예를 살펴 보겠습니다.
예 : 1
List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)산출:
세 번째 요소를 삭제하기 전 목록 : (1, 2, 3, 4, 5, 6, 7, 8, 9)
세 번째 요소 삭제 후 목록 : (1, 2, 3, 5, 6, 7, 8, 9)
여러 요소를 삭제 한 후 목록 : (1, 5, 6, 7, 8, 9)
위의 예에서 del 문을 사용하여 목록에서 요소 또는 여러 문을 삭제했음을 알 수 있습니다.
산출:
이제 remove () 메서드에 대해 살펴 보겠습니다.
예 : 2
List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)산출:
요소를 제거하기 전 목록 : (1, 2, 3, 4, 5, 6, 7)
요소 제거 후 목록 : (1, 2, 4, 5, 6, 7)
요소를 팝한 후의 목록은 다음과 같습니다. (1, 2, 4, 5, 6)
위의 예에서 remove () 메서드를 사용하여 목록에서 요소를 제거하고 있음을 확인할 수 있습니다. pop () 메서드는 목록에서 마지막 요소를 제거 / 삭제하는 데 사용됩니다.
산출:
방법 나열
| 행동 양식 | 기술 |
|---|---|
| 맑은() | 목록에서 모든 요소를 제거합니다. |
| append () | 목록 끝에 요소를 추가합니다. |
| 끼워 넣다() | 목록의 특정 색인에 요소를 삽입합니다. |
| 넓히다() | 목록 끝에 요소 목록을 추가합니다. |
| 카운트() | 특정 값을 가진 요소 수를 반환합니다. |
| 인덱스() | 첫 번째 요소의 인덱스를 반환합니다. |
| 역전() | 기존 목록을 되돌리려면. |
| 없애다() | 목록에서 요소를 제거합니다. |
결론
이 튜토리얼에서 우리는 파이썬 목록의 특징 다음과 같은 목록을 조작하는 다양한 방법과 함께 목록 생성 , 목록에서 항목에 액세스 , 및 목록에서 항목 교체.
Python 목록에 대한이 튜토리얼은 다음 포인터로 마무리 할 수 있습니다.
- List는 Python의 데이터 유형 중 하나이며 데이터 구조라고도합니다.
- List는 하나의 변수에 모든 데이터 유형의 많은 값을 저장하는 데 사용되므로 쉽게 액세스 할 수 있습니다.
- 목록의 색인은 다른 프로그래밍 언어와 마찬가지로 항상 0부터 시작합니다.
- 목록에서 작업하는 경우 일반적인 내장 기능을 모두 기억해야합니다.