Python Language
명부

Django Flask HTML GNU/Linux matplotlib MySQL opencv pandas Regular Expressions tensorflow
수색…


소개

Python List 는 Python 프로그램에서 널리 사용되는 일반적인 데이터 구조입니다. 그것들은 종종 동적 배열 이라고 불리는 다른 언어로 발견됩니다. 둘 다 변경할 수 있으며 색인화 및 조각화 할 수있는 시퀀스 데이터 형식입니다. 목록에는 다른 목록 개체를 비롯한 여러 유형의 개체가 포함될 수 있습니다.

통사론

  • [가치, 가치, ...]
  • 목록 ([iterable])

비고

list 는 반복 가능한 유형이지만 파이썬에 존재하는 것은 아닙니다. 때로는 set , tuple 또는 dictionary 를 사용하는 것이 더 낫습니다.

list 는 파이썬에서 동적 배열에 주어진 이름입니다 (C ++의 vector<void*> 또는 Java의 ArrayList<Object> 와 비슷 함). 연결된 목록이 아닙니다.

요소에 액세스하는 것은 일정 시간 내에 완료되며 매우 빠릅니다. 목록 끝에 요소를 추가하면 상각 시간이 상각됩니다.하지만 잠시 동안 전체 list 할당하고 복사하는 작업이 필요할 수 있습니다.

목록 수록은 목록 과 관련이 있습니다.

목록 값 액세스

파이썬리스트는 인덱스가 없으며 다른 언어의 배열처럼 작동합니다. 

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

목록의 경계를 벗어난 색인에 액세스하려고하면 IndexError 합니다. 

lst[4]  # IndexError: list index out of range

음수 인덱스는 목록의 끝 에서부터 세는 것으로 해석됩니다. 

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

이것은 기능적으로 

lst[len(lst)-1]  # 4

목록을 사용하면 슬라이스 표기법 을 lst[start:end:step] 있습니다. 슬라이스 표기법의 출력은 index start 에서 end-1 요소를 포함하는 새 목록입니다. 옵션을 생략하는 경우 start 목록의 시작 부분으로 기본값을, end 목록으로 종료하고하는 step 1 : 

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

이 점을 염두에두고 다음과 같이 목록의 반대 버전을 인쇄 할 수 있습니다. 

lst[::-1]    # [4, 3, 2, 1]

음수의 스텝 길이를 사용할 때 시작 인덱스는 끝 인덱스보다 커야하며, 그렇지 않으면 결과는 빈리스트가됩니다. 

lst[3:1:-1] # [4, 3]

음수 단계 인덱스를 사용하면 다음 코드와 같습니다. 

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

사용 된 인덱스는 음수 인덱싱에 사용 된 인덱스보다 1 작고 역순입니다.

고급 슬라이싱

목록이 슬라이스되면 목록 객체의 __getitem__() 메서드가 slice 객체와 함께 호출됩니다. 파이썬에는 슬라이스 객체를 생성하는 내장 슬라이스 메소드가 있습니다. 이것을 사용하여 슬라이스를 저장 하고 나중에 슬라이스를 재사용 할 수 있습니다. 

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

우리 클래스의 __getitem__ 을 오버라이드하여 객체에 슬라이싱 기능을 제공하면 큰 도움이 될 수 있습니다.

목록 메서드 및 지원 연산자

주어진 목록 a 시작 : 

a = [1, 2, 3, 4, 5]

  1. append(value) - 목록의 끝에 새 요소를 추가합니다. 

    # Append values 6, 7, and 7 to the list
a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Append another list
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]

# Append an element of a different type, as list elements do not need to have the same type
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]

    점을 유의 append() 메소드는리스트의 마지막에 하나 개의 새로운 요소를 추가한다. 목록을 다른 목록에 추가하면 추가하는 목록이 첫 번째 목록 끝에있는 단일 요소가됩니다. 

    # Appending a list to another list
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
a[8]
# Returns: [8,9]

  2. extend(enumerable) - 다른 열거 형의 요소를 추가하여 목록을 확장합니다. 

    a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]

# Extend list by appending all elements from b
a.extend(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

# Extend list with elements from a non-list enumerable:
a.extend(range(3))
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]

    목록은 + 연산자로 연결할 수도 있습니다. 이 옵션은 원래 목록을 수정하지 않습니다. 

    a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

  3. index(value, [startIndex]) - 첫 번째 입력 값의 인덱스를 가져옵니다. 입력 값이 목록에 없으면 ValueError 예외가 발생합니다. 두 번째 인수가 제공되면 검색은 지정된 색인에서 시작됩니다. 

    a.index(7)
# Returns: 6

a.index(49) # ValueError, because 49 is not in a.

a.index(7, 7)
# Returns: 7

a.index(7, 8) # ValueError, because there is no 7 starting at index 8

  1. insert(index, value) - 지정된 index 바로 앞에 value 삽입 value . 따라서 삽입 후 새 요소는 위치 index 차지합니다. 

    a.insert(0, 0)  # insert 0 at position 0
a.insert(2, 5)  # insert 5 at position 2
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

  1. pop([index]) - index 있는 항목을 제거하고 반환합니다. 인수가 없으면 목록의 마지막 요소를 제거하고 반환합니다. 

    a.pop(2)
# Returns: 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8)
# Returns: 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# With no argument:
a.pop()
# Returns: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  2. remove(value) - 지정된 값의 첫 번째 항목을 제거합니다. 제공된 값을 찾을 수 없으면 ValueError 가 발생합니다. 

    a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]
a.remove(10)
# ValueError, because 10 is not in a

  3. reverse() - 목록을 그 자리에서 되돌리고 None 반환합니다. 

    a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]

    목록을 뒤집는 다른 방법 이 있습니다.

  4. count(value) - 목록에있는 값의 발생 횟수를 계산합니다. 

    a.count(7)
# Returns: 2

  5. sort() - 목록을 숫자 및 사전 식 순서로 정렬하고 None 반환합니다. 

    a.sort()
# a = [1, 2, 3, 4, 5, 6, 7, 8]
# Sorts the list in numerical order

    sort() 메서드에서 reverse=True 플래그를 사용하여 정렬 할 때 목록을 뒤집을 수도 있습니다. 

    a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

    당신이 항목의 특성으로 정렬 할 경우 사용할 수있는 key 키워드 인수를 : 

    import datetime

class Person(object):
    def __init__(self, name, birthday, height):
        self.name = name
        self.birthday = birthday
        self.height = height

    def __repr__(self):
        return self.name

l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
     Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
     Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]

l.sort(key=lambda item: item.name)
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item.birthday)
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item.height)
# l: [John Cena, Chuck Norris, Jon Skeet]

    dicts 목록의 경우 개념은 동일합니다. 

    import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]

l.sort(key=lambda item: item['name'])
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item['birthday'])
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

    하위 사전으로 정렬 : 

    import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]

l.sort(key=lambda item: item['size']['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

attrgetter 및 itemgetter 사용하여 정렬하는 더 나은 방법

목록은 연산자 모듈에서 attrgetter 및 itemgetter 함수를 사용하여 정렬 할 수도 있습니다. 이는 가독성과 재사용 성을 향상시키는 데 도움이 될 수 있습니다. 여기 예시들이 있습니다, 

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetter 에는 인덱스를 지정할 수도 있습니다. 터플의 인덱스를 기준으로 정렬하려는 경우 유용합니다. 

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

객체의 속성별로 정렬하려면 attrgetter 사용하고, 

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

  1. clear() - 목록에서 모든 항목을 제거합니다. 

    a.clear()
# a = []

  2. 복제 - 기존 목록에 정수를 곱하면 원본의 많은 복사본으로 구성된 더 큰 목록이 생성됩니다. 예를 들어 목록 초기화에 유용 할 수 있습니다. 

    b = ["blah"] * 3
# b = ["blah", "blah", "blah"]
b = [1, 3, 5] * 5
# [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]

    목록에 객체에 대한 참조 (예 : 목록)가 있으면 일반적인 함정 - 곱셈 및 공통 참조 목록을 참조하십시오 .

  3. 요소 삭제 - del 키워드와 조각 표기법을 사용하여 목록의 여러 요소를 삭제할 수 있습니다. 

    a = list(range(10))
del a[::2]
# a = [1, 3, 5, 7, 9]
del a[-1]
# a = [1, 3, 5, 7]
del a[:]
# a = []

  4. 사자

    기본 할당 "="은 원래 목록의 참조를 새 이름에 할당합니다. 즉, 원래 이름과 새 이름은 모두 같은 목록 개체를 가리 킵니다. 그 중 하나를 통해 이루어진 변경 사항은 다른 것에 반영됩니다. 이것은 종종 당신이 의도 한 것이 아닙니다. 

    b = a
a.append(6)
# b: [1, 2, 3, 4, 5, 6]

    목록의 복사본을 만들려면 아래 옵션이 필요합니다.

    슬라이스 할 수 있습니다. 

    new_list = old_list[:]

    내장 된 list () 함수를 사용할 수 있습니다 : 

    new_list = list(old_list)

    일반적인 copy.copy ()를 사용할 수 있습니다 : 

    import copy
new_list = copy.copy(old_list) #inserts references to the objects found in the original.

    이것은 old_list의 데이터 유형을 먼저 찾아야하기 때문에 list ()보다 약간 느립니다.

    목록에 객체가 포함되어 있고이를 복사하려는 경우 일반 copy.deepcopy ()를 사용하십시오. 

    import copy
new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.

    분명히 가장 느리고 가장 기억을 필요로하는 방법이지만 때로는 피할 수없는 방법입니다.

Python 3.x 3.0

copy() -리스트의 얕은 복사본을 반환합니다. 

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

목록의 길이

len() 을 사용하여리스트의 1 차원 길이를 얻습니다. 

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len() 은 문자열, 사전 및 목록과 비슷한 기타 데이터 구조에서도 작동합니다.

len() 은 목록 개체의 메서드가 아니라 기본 제공 함수입니다.

또한 len() 의 비용은 O(1) . 즉, 길이에 관계없이 목록의 길이를 얻는 데 동일한 시간이 걸릴 것입니다.

리스트 반복하기

파이썬은 for 루프를리스트에 직접 사용하는 것을 지원합니다 : 

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

동시에 각 항목의 위치를 ​​가져올 수도 있습니다. 

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

인덱스 값을 기반으로 목록을 반복하는 다른 방법은 다음과 같습니다. 

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

반복되는 동안 목록의 항목을 변경하면 예기치 않은 결과가 발생할 수 있습니다. 

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

이 마지막 예에서는 첫 번째 항목에서 첫 번째 항목을 삭제했지만 bar 를 건너 뛰었습니다.

항목이 목록에 있는지 확인하기

파이썬은 항목이 목록에 있는지 여부를 확인하는 것을 매우 간단하게 만듭니다. in 연산자 만 사용하면 in . 

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

참고 : 세트의 in 연산자는리스트보다 점근 적으로 빠릅니다. 당신이 잠재적으로 큰 목록에 여러 번 사용해야하는 경우, 당신은 변환 할 수 있습니다 list A를 set 하고의 요소의 존재를 테스트 set . 

slst = set(lst)
'test' in slst
# Out: True

목록 요소 반전

반대로 된리스트에 반복자를 반환하는 reversed 함수를 사용할 수 있습니다 : 

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

"숫자"목록은이 작업으로 변경되지 않고 원래 순서와 동일하게 유지됩니다.

장소에 되돌리려면, 당신은 또한 사용할 수 있습니다 역 방법 .

슬라이싱 구문을 사용하여 세 번째 인수 (단계)를 -1로 설정하여 목록을 역순으로 (실제로 사본을 얻고 원래 목록은 영향을받지 않음) 

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

목록이 비어 있는지 확인하기

리스트의 빈 상태는 False 부울과 연관되어 있으므로 len(lst) == 0 은 아니지만 lst 또는 not lst 

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

목록 연결 및 병합

  1. list1 과 list2 를 연결하는 가장 간단한 방법은 다음 과 같습니다. 

    merged = list1 + list2

  2. zip 은 튜플의 목록을 반환하는데 , 여기서 i 번째 튜플은 각 인수 시퀀스 또는 iterables의 i 번째 요소를 포함합니다. 

    alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
    print(a, b)
 
# Output:
# a1 b1
# a2 b2
# a3 b3

    목록의 길이가 다른 경우 결과에는 가장 짧은 요소만큼의 요소 만 포함됩니다. 

    alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
    print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Output:
# 0

    길이가 같지 않은리스트를 None 채우는 가장 긴리스트를 채우기 위해 itertools.zip_longest ( itertools.izip_longest in Python 2)를 사용하십시오. 

    alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):
    print(a, b, c)

# Output: 
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4

  1. 특정 인덱스 값에 삽입 : 

     alist = [123, 'xyz', 'zara', 'abc']
 alist.insert(3, [2009])
 print("Final List :", alist)

    산출: 

     Final List : [123, 'xyz', 'zara', 2009, 'abc']

모두 및 모두

all() 을 사용하여 iterable의 모든 값이 True인지 평가할 수 있습니다 

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

마찬가지로, any() 는 iterable의 하나 이상의 값이 True인지 평가합니다 

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

이 예제에서는 목록을 사용하지만 이러한 내장 함수는 생성자를 비롯한 반복 가능한 모든 함수와 함께 사용할 수 있습니다. 

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

목록에서 중복 값 제거

리스트에서 중복 값을 제거하는 것은리스트를 set (별개의 오브젝트의 순서가 지정되지 않은 콜렉션)로 변환하여 수행 할 수 있습니다. list 데이터 구조가 필요하다면, list 는 함수 list() 사용하여리스트로 다시 변환 될 수 있습니다 : 

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

목록을 집합으로 변환하면 원래 순서가 손실됩니다.

목록의 순서를 유지하기 위해 OrderedDict 사용할 수 있습니다. 

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

중첩 목록의 값 액세스

3 차원 목록으로 시작하기 : 

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

목록의 항목에 액세스 : 

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

지원 작업 수행 : 

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

중첩 된 for 루프를 사용하여 목록 인쇄 : 

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

이 작업은 다음과 같이 목록 이해 또는 효율성을 내기위한 생성기로 사용될 수 있습니다. 

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

외부 목록의 모든 항목이 목록 자체가 아니어야합니다. 

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

중첩 된 for 루프를 사용하는 또 다른 방법입니다. 다른 방법은 더 좋지만 때때로 이것을 사용해야합니다. 

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

중첩 목록에 슬라이스 사용 : 

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

최종 목록 : 

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

목록 비교

비교 연산자를 사용하여리스트와 다른 시퀀스를 사 전적으로 비교할 수 있습니다. 두 피연산자는 모두 같은 유형이어야합니다. 

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

목록 중 하나가 다른 목록의 시작 부분에 포함되면 가장 짧은 목록이 우선합니다. 

[1, 10] < [1, 10, 100]
# True

고정 된 수의 요소로 목록 초기화

변경할 수없는 요소 (예 : None , 문자열 리터럴 등) : 

my_list = [None] * 10
my_list = ['test'] * 10

변경 가능한 요소의 경우 동일한 구문을 사용하면 목록의 모든 요소가 동일한 개체 (예 : 집합)를 참조합니다. 

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

대신 고정 된 수의 변경 가능한 객체로 목록을 초기화하려면 다음을 사용하십시오. 

my_list=[{1} for _ in range(10)]


Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow