8.2.수요일

그동안 프로그래머스 풀면서, 메모 했던 것을 정리 했다.

 

 

a ="33    45    98    38    21    49    51    58    82    75"

이런 데이타 형태를  아래와 같이 리스트화 하려면

a =[33,    45,    98,    38,    21,    49,    51,    58,    82,    75]

 

a = "33 45 98 38 21 49 51 58 82 75"

a_list = [int(num) for num in a.split()]

print(a_list)

 

 

[33, 45, 98, 38, 21, 49, 51, 58, 82, 75]

 

.제공한 데이터 a는 공백으로 구분된 값이 있는 문자열입니다. 

정수 목록으로 변환하려면 split() 메서드를 사용하여 공백에서 문자열을 분할한 

다음 목록 내포를 사용하여 각 요소를 정수로 변환할 수 있습니다.

 

 

 most_common() 메서드는

 collections 모듈의 Counter 클래스와 함께 사용됩니다.

 가장 일반적인 요소 목록과 해당 개수를 튜플로 반환하며 개수를 기준으로 내림차순으로 정렬됩니다.

 

most_common()을 사용하는 방법은 다음과 같습니다.

from collections import Counter

 

# Example list

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

 

# Create a Counter object to count the occurrences of elements in the list

element_counts = Counter(a)

 

# Get the most common elements and their counts as a list of tuples

most_common_elements = element_counts.most_common()

 

print(most_common_elements)

 

Out put

[(2, 3), (1, 2), (3, 1)]

 

이 예에서 most_common_elements에는 튜플 목록이 포함됩니다.

 각 튜플은 원래 목록의 요소와 해당 개수를 나타냅니다. 목록은 개수를 기준으로 내림차순으로 정렬됩니다. 

즉, 가장 빈번한 요소가 목록의 시작 부분에 나타납니다.

k 가장 일반적인 요소(여기서 k는 정수임)를 얻으려면 k를 most_common()의 인수로 전달할 수 있습니다.

most_common_elements = element_counts.most_common(2)

print(most_common_elements)

 

[(2, 3), (1, 2)]

이 예에서 most_common_elements에는 두 개의 가장 일반적인 요소와 해당 개수가 포함됩니다.

이 방법을 사용하여 목록 또는 기타 반복 가능한 데이터 구조에서 가장 일반적인 요소와 해당 빈도를 빠르게 찾을 수 있습니다.

 

`most_common()` 메서드의 인자로 전달하는 숫자는 반환할 원소의 개수를 의미합니다. 따라서 `element_counts.most_common(1)`은 `a` 리스트에서 가장 빈도가 높은 원소 1개를 반환합니다. 이 반환된 결과는 리스트 형태로 반환되며, 첫 번째 원소를 선택하기 위해 `[0]`을 사용하게 됩니다. 따라서 `most_common_element, count = element_counts.most_common(1)[0]`은 `element_counts`에서 가장 빈도가 높은 원소와 그 빈도수를 변수 `most_common_element`와 `count`에 각각 할당하는 코드입니다.

 

고마워 그러니가 만약 1 대신 2를 넣으면 가장 빈도수가 많은 2개를 추출하는 것이구나?

 

네, 맞습니다! `most_common()` 메서드의 인자로 전달하는 숫자가 n이라면, 가장 빈도가 높은 n개의 원소를 리스트 형태로 반환합니다. 따라서 `element_counts.most_common(2)`는 `a` 리스트에서 가장 빈도가 높은 원소 2개를 반환합니다.

 

네, 맞습니다. 리스트 객체는 `most_common()` 메서드를 지원하지 않습니다. `most_common()` 메서드는 `collections` 모듈에 있는 `Counter` 클래스의 인스턴스에서만 사용할 수 있습니다. 따라서 `a` 리스트에서 가장 빈도가 높은 원소 2개를 추출하려면, 먼저 `a` 리스트를 `Counter` 객체로 변환해야 합니다. 이를 위해서는 `collections` 모듈에서 `Counter` 클래스를 import한 후, `Counter(a)`와 같이 리스트를 인자로 전달하여 `Counter` 객체를 생성합니다. 그리고 나서 `most_common()` 메서드를 사용하여 가장 빈도가 높은 원소를 추출할 수 있습니다. 예를 들어, 아래와 같이 코드를 작성할 수 있습니다.

 

 

from collections import Counter

 

# Example list

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

 

# Convert the list to a Counter object

element_counts = Counter(a)

 

# Get the two most frequent elements and their counts as a list of tuples

most_common_elements = element_counts.most_common(2)

 

print("Most frequent elements:", most_common_elements)

```

 

 

from collections import Counter

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

e_c = Counter(a)

print(a)

print(e_c)

ls1 = list(e_c)

print(ls1)

most_best_num, that_big_count =e_c.most_common(1)[0]

print(most_best_num, that_big_count)

print(e_c.most_common(2))

 

[1, 2, 1, 3, 2, 2, 1, 2, 1, 3, 1, 2, 2, 2, 2, 2, 2, 2, 1, 3]

Counter({2: 11, 1: 6, 3: 3})

[1, 2, 3]

2 11

[(2, 11), (1, 6)]

위 코드에서 `most_common_elements` 변수에는 `(2, 3)`과 `(1, 2)` 두 개의 튜플이 저장됩니다. 각 튜플의 첫 번째 원소가 리스트에서 가장 빈도가 높은 원소이며, 두 번째 원소가 그 빈도수입니다.

?a = [1, 2, 1, 3, 2,2] 에서 가장 많이 있는 원소를 골라내는 방법과 그 원소의 갯수를  출력하는 방법은?

 

이 코드에서는 먼저 Counter(lst)를 사용하여 a 목록에 있는 각 요소의 발생 횟수를 계산합니다. Counter 클래스의 most_common(1) 메서드는 가장 일반적인 요소를 튜플 목록으로 반환합니다. 우리는 가장 풍부한 요소와 그 개수만 원하기 때문에 이 목록의 첫 번째 요소를 추출합니다. 이 요소는 가장 일반적인 요소와 그 개수를 포함하는 튜플입니다. 마지막으로 결과를 인쇄합니다.

 

코드를 단계별로 자세한 설명

• from collections import Counter: 우선 Python의 내장 모듈인 collections에서 Counter를 가져옵니다. Counter는 리스트나 다른 iterable에서 원소들의 개수를 세기 위해 사용되는 유용한 클래스입니다.
• def most_abundant_element_count(lst): 함수 most_abundant_element_count를 정의합니다. 이 함수는 리스트 lst를 인자로 받아 가장 빈번하게 등장하는 원소와 그 원소의 개수를 찾습니다.
• ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
• element_counts = Counter(lst): Counter(lst)를 사용하여 리스트 lst의 각 원소들의 개수를 세어 element_counts 변수에 저장합니다. 이 때, element_counts는 Counter 클래스의 객체가 됩니다. 이 객체는 각 원소를 키(key)로 가지고, 해당 원소의 개수를 값(value)로 가지는 사전(dictionary)과 비슷한 자료구조입니다.
• ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
• most_common_element, count = element_counts.most_common(1)[0]: element_counts.most_common(1)은 가장 빈번하게 등장하는 원소와 그 원소의 개수를 튜플로 묶은 리스트를 반환합니다. [0]을 이용하여 이 리스트에서 첫 번째 원소인 튜플을 가져와서 most_common_element와 count 변수에 각각 할당합니다. most_common_element는 가장 빈번하게 등장하는 원소, count는 해당 원소의 개수가 됩니다.
• return most_common_element, count: 함수는 most_common_element와 count를 튜플로 묶어서 반환합니다.
• a = [1, 2, 1, 3, 2, 2]: 예제 리스트 a를 정의합니다.
• most_abundant_element, count = most_abundant_element_count(a): most_abundant_element_count(a) 함수를 호출하여 리스트 a에서 가장 빈번하게 등장하는 원소와 그 원소의 개수를 찾습니다. 반환되는 튜플을 most_abundant_element와 count 변수에 할당합니다.

 

print("Most abundant element:", most_abundant_element): 가장 빈번하게 등장하는 원소를 출력합니다.

print("Number of occurrences:", count): 해당 원소의 개수를 출력합니다.

출력 결과는 다음과 같을 것입니다:

 

Copy code

Most abundant element: 2 Number of occurrences: 3

이로써 코드의 동작과정에 대한 자세한 설명이 마무리되었습니다. 코드에서 사용한 Counter 클래스를 이용하면 원소의 개수를 쉽게 세고, 가장 빈번하게 등장하는 원소를 간단하게 찾을 수 있습니다.

 

 

 

element_counts = Counter(a)는 주어진 리스트 a의 각 원소들의 개수를 세어서 Counter 객체를 생성하는 부분입니다.

자세한 설명은 다음과 같습니다:

• from collections import Counter: 우선, collections 모듈에서 Counter 클래스를 가져옵니다.
• a = [1, 2, 1, 3, 2, 2]: 예제 리스트 a를 정의합니다.
• element_counts = Counter(a): Counter(a)를 사용하여 리스트 a의 각 원소들의 개수를 세어서 element_counts라는 변수에 Counter 객체로 저장합니다. Counter 객체는 각 원소를 키(key)로 가지고, 해당 원소의 개수를 값(value)로 가지는 사전(dictionary)과 비슷한 자료구조입니다. element_counts 객체는 다음과 같이 생겼을 것입니다:

 

Counter({2: 3, 1: 2, 3: 1})

위 결과에서 {} 안에 있는 숫자들은 리스트 a에서 각 원소가 몇 번 나타났는지를 나타냅니다. 예를 들어, 2는 리스트 a에서 3번, 1은 2번, 그리고 3은 1번 나타났음을 의미합니다.

이렇게 생성된 Counter 객체를 이용하면 리스트 a에서 각 원소들의 개수를 쉽게 확인할 수 있습니다. 이후에 most_common() 메서드를 사용하여 가장 빈번하게 등장하는 원소와 그 원소의 개수를 얻을 수 있었습니다.

따라서 코드를 실행하면 다음과 같이 출력될 것입니다:

css

 

 

[(2, 3), (1, 2), (3, 1)]

위 결과에서 (2, 3)은 원소 2가 리스트 a에서 3번 나타남을 의미하며, (1, 2)는 원소 1이 2번, 그리고 (3, 1)은 원소 3이 1번 나타남을 나타냅니다.

 

 

 

 

 

 

 

 

 

 

 

pop() 함수는 

많은 프로그래밍 언어 및 데이터 구조, 특히 목록, 배열 또는 스택을 구현하는 언어에서 일반적인 방법입니다. 그 목적은 목록이나 배열(또는 지정된 인덱스의 요소)에서 마지막 요소를 제거하고 반환하여 데이터 구조에서 효과적으로 "팝핑"하는 것입니다. 그런 다음 팝된 요소 없이 목록 또는 배열이 업데이트됩니다.

파이썬에서 pop() 함수는 목록과 함께 사용됩니다. 구문은 다음과 같습니다

 

list_name.pop([index])

여기:

• list_name: 요소를 제거하려는 목록의 이름입니다.
• index (선택 사항): 제거하려는 요소의 인덱스입니다. 인덱스를 지정하지 않으면 목록의 마지막 요소를 제거하고 반환합니다.

 

 

pop() 함수는 다음 작업을 수행합니다.

 

1. 인덱스가 제공되면(예: list_name.pop(index)) 해당 인덱스에 있는 요소를 목록에서 제거하고 제거된 요소의 값을 반환합니다.

예 1:

fruits = ['apple', 'banana', 'orange', 'grape']

removed_fruit = fruits.pop(1)

print(fruits)          # Output: ['apple', 'orange', 'grape']

print(removed_fruit)   # Output: 'banana'

 

 

1. 인덱스가 제공되지 않으면(예: list_name.pop()) 목록에서 마지막 요소를 제거하고 반환합니다.

예 2:

fruits = ['apple', 'banana', 'orange', 'grape']

removed_fruit = fruits.pop()

print(fruits)          # Output: ['apple', 'banana', 'orange']

print(removed_fruit)   # Output: 'grape'

 

제거할 요소가 없기 때문에 빈 목록에서 pop()을 사용하면 IndexError가 발생한다는 점에 유의해야 합니다.

pop() 함수는 제거된 값에 계속 액세스하면서 목록에서 요소를 제거해야 할 때 유용합니다. 

제거된 요소의 값이 필요하지 않은 경우 del 문을 사용하여 반환하지 않고 목록에서 요소를 제거할 수도 있습니다.

 

python

 

fruits = ['apple', 'banana', 'orange', 'grape']

del fruits[1]

print(fruits)  # Output: ['apple', 'orange', 'grape']

 

 

zip() 함수는

zip() 함수는 여러 이터러블(예: 목록, 튜플)을 요소별로 결합하고 튜플의 이터레이터를 반환하는 내장 Python 함수입니다. 각 튜플은 입력 iterables의 해당 위치에 있는 요소를 포함합니다.

다음은 zip() 함수의 기본 구문입니다.

zip(iterable1, iterable2, ...)

 

iterable1, iterable2, ...: 조합하려는 입력 iterable입니다. 쉼표로 구분된 여러 iterable을 전달할 수 있습니다.

zip() 함수는 전달된 각 iterable의 첫 번째 요소가 함께 쌍을 이루고 각 iterable의 두 번째 요소가 함께 쌍을 이루는 튜플을 생성하여 작동합니다. 입력 iterable의 길이가 다른 경우 zip()은 가장 짧은 iterable에서 중지합니다.

fruits = ['apple', 'banana', 'orange']

prices = [1.0, 0.8, 1.2]

quantities = [5, 3, 4]

 

# Combine the three lists element-wise using zip()

combined_data = zip(fruits, prices, quantities)

 

# Convert the zip object to a list to see the result

combined_list = list(combined_data)

print(combined_list)

# Output: [('apple', 1.0, 5), ('banana', 0.8, 3), ('orange', 1.2, 4)]

 

 

이 예에는 일부 과일의 이름, 가격 및 수량을 나타내는 세 개의 목록 'fruits', 'prices' 및 'quantities'가 있습니다. zip() 함수를 사용하여 이러한 목록을 요소별로 결합하고 결과는 튜플 목록이며 각 튜플에는 세 목록의 해당 요소가 포함됩니다. zip() 함수는 '사과'를 1.0과 5, '바나나'를 0.8과 3, '오렌지'를 1.2와 4로 짝지어줍니다.

zip()의 결과는 반복자이므로 결합된 데이터를 사람이 읽을 수 있는 형식으로 보기 위해 list()를 사용하여 목록으로 변환했습니다.

 

 

index() 함수는 

index() 함수는 목록에서 주어진 요소의 인덱스를 찾을 수 있도록 하는 Python의 내장 메서드입니다. 목록에서 지정된 요소가 처음 나타나는 인덱스를 반환합니다. 목록에서 요소를 찾을 수 없으면 ValueError가 발생합니다.

다음은 index() 함수의 기본 구문입니다.

list.index(element, start, end)

• list: 요소를 검색하려는 목록입니다.
• element: 인덱스를 찾으려는 요소입니다.
• start(선택 사항): 검색이 시작되는 시작 인덱스입니다. 기본값은 0(목록의 시작 부분)입니다.
• end(선택 사항): 검색이 중지되는 종료 인덱스(제외). 기본값은 목록의 끝입니다.

fruits = ['apple', 'banana', 'orange', 'banana']

 

# Find the index of 'banana' in the list

index = fruits.index('banana')

print(index)  # Output: 1

 

# Find the index of 'banana' starting from index 2

index = fruits.index('banana', 2)

print(index)  # Output: 3

 

# Find the index of 'orange' between index 1 and 3 (exclusive)

index = fruits.index('orange', 1, 3)

print(index)  # Output: 2

위의 예에는 다양한 과일을 포함하는 'fruits' 목록이 있습니다. index() 함수를 사용하여 'banana' 요소의 인덱스를 찾고 인덱스 1에 있는 첫 번째 항목을 반환합니다. 선택적 인수 start 및 end를 지정하여 범위를 좁힐 수도 있습니다. 검색 범위. 요소를 찾을 수 없으면 index() 함수는 ValueError를 발생시킵니다. 따라서 try-except 블록을 사용하여 요소가 목록에 없을 가능성을 처리하는 것이 좋습니다.

Python의 index() 함수는 목록, 튜플 또는 문자열과 같은 시퀀스 내에서 지정된 값의 인덱스(위치)를 찾을 수 있는 내장 메서드입니다. 일반적으로 시퀀스에서 요소의 첫 번째 항목을 찾는 데 사용됩니다.

다음은 index() 함수의 구문입니다.

sequence.index(value, start, end)

 

• 시퀀스: 값의 인덱스를 찾으려는 시퀀스(목록, 튜플 또는 문자열)입니다.
• value: 인덱스를 찾으려는 요소입니다.
• start(선택 사항): 검색을 시작할 인덱스(포함). 제공되지 않으면 처음부터(인덱스 0) 검색이 시작됩니다.
• end(선택 사항): 검색을 중지할 인덱스(독점). 제공되지 않으면 시퀀스가 ​​끝날 때까지 검색이 진행됩니다
• .

index() 함수는 시퀀스에서 지정된 값이 처음 나타나는 인덱스를 반환합니다. 

값을 찾을 수 없으면 ValueError 예외가 발생합니다.

 

목록이 있는 예:

my_list = [10, 20, 30, 40, 50]

index_30 = my_list.index(30)

print(index_30)  # Output: 2

이 예에서 index() 함수는 인덱스 2에 있는 목록 my_list에서 값 30의 첫 번째 항목을 찾습니다.

 

문자열이 있는 예:

my_string = "hello world"

index_o = my_string.index('o')

print(index_o)  # Output: 4

 

이 예에서 index() 함수는 문자열 my_string에서 색인 4에 있는 'o' 문자의 첫 번째 항목을 찾습니다.

 

검색 중인 값이 시퀀스에서 여러 번 나타나는 경우 index() 함수는 처음 나타나는 인덱스만 반환한다는 점을 명심하세요. 값의 모든 항목을 찾아야 하는 경우 루프 또는 목록 내포를 사용하여 모든 인덱스를 수집할 수 있습니다.

 

 

 

def solution(n):# 합성수의 갯수를 알려주는 함수

    def is_composite(num): # 합성수 임을 알려주는 함수 = 약수 3개 이상인 수 so i am making the function  to inform if num is composite.

      count = 0

      for i in range(1,num+1):

        if num%i == 0:

          count += 1

      return count >= 3 # 이것이 결정적인 key ? why ? 3개 이상이 약수면 --> 합성수 return  a ==> a 조건에 맞다면 참 즉 True를 출력

                        # 고로 합성수인지 아닌지 구별하는 함수는 만들었다 

                        # 그럼 이제 그 내가 정의한 함수를 쓸 함수를 만들어야 한다.

    count = 0 

    for i in range(4,n+1): #n 까지의 즉 n 포함 하고 그것보다 작은 수 중에서 홥성수의 갯수 를 구하는 함수

          if is_composite(i):

            count += 1

    return count

 

 

map() 함수

def solution(order):

    return sum(map(lambda x :str(order).count(str(x)),[3,6,9])) - 외울거

 

 

Python의 map() 함수는 주어진 함수를 iterable의 각 항목(예: 목록, 튜플 또는 문자열)에 적용하고 결과를 포함하는 새로운 iterable을 반환하는 데 사용되는 내장 함수입니다.

 

map() 함수의 일반 구문은 다음과 같습니다.

map(function, iterable)

각 부분의 의미는 다음과 같습니다.

• function: iterable의 각 항목에 적용하려는 함수입니다. def를 사용하여 정의된 일반 함수, lambda를 사용하여 만든 람다 함수 또는 내장 함수(예: str, int, len 등)일 수 있습니다.
• iterable: 함수를 적용하려는 항목(예: 목록, 튜플, 문자열)의 모음입니다.

그런 다음 map() 함수는 iterable을 반복하고 각 항목에 function을 적용하고 결과를 포함하는 반복자를 반환합니다.

 원하는 형식(예: 목록 또는 튜플)으로 최종 출력을 얻으려면 list(), tuple() 또는

 기타 적절한 함수를 사용하여 반복자를 필요한 데이터 유형으로 변환할 수 있습니다.

 

다음은 map()을 사용하여 목록의 각 요소를 두 배로 늘리는 예입니다.

 

# Define a list of numbers

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

 

# Define a function to double a number

def double(x):

    return x * 2

 

# Use map() to apply the double function to each item in the numbers list

result = map(double, numbers)

 

# Convert the map iterator to a list to see the final output

doubled_numbers = list(result)

print(doubled_numbers)  # Output: [2, 4, 6, 8, 10]

 

이 예에서 map() 함수는 double() 함수를 numbers 목록의 각 항목에 적용하고 결과는 result 반복자에 저장됩니다. 

그런 다음 list()를 사용하여 반복자를 목록으로 변환하고 두 배가 된 숫자 목록인 최종 출력을 인쇄합니다.

 

map()을 사용하는 것은 한 줄에 iterable의 여러 요소에 함수를 적용하는 간결하고 강력한 방법이며 

이러한 작업에 대한 명시적인 루프를 작성하지 않아도 됩니다.

 

 

 

 

# Split the data into individual lines

lines = data.strip().split('\n')

 

# Concatenate the lines into a single string with spaces to separate each time

times_str = ' '.join(lines)

 

# Use a for loop to print the concatenated times horizontally

for char in times_str:

    if char == '@':

        print()  # Print a newline when encountering the '@' character

    else:

        print(char, end='')

 

try-except 블록은

try-except 블록은 Python에서 오류 처리에 사용됩니다. 특정 코드 블록을 실행하는 동안 발생할 수 있는 예외(오류)를 포착하고 처리할 수 있습니다. try-except 블록의 일반적인 구조는 다음과 같습니다.

 

try:

    # Code block where an exception might occur

    # ...

except SomeException:

    # Code to handle the exception

    # ...

다음은 try-except 블록이 일반적으로 사용되는 방법.

1. try 블록 내부의 코드는 예외가 발생할 수 있는 코드입니다. 귀하의 예에서 주어진 idx 이후에 1이 발견되지 않으면 ValueError를 발생시킬 수 있는 answer = arr.index(1, idx) 행입니다.
2. try 블록 내에서 예외가 발생하면 실행은 즉시 해당 except 블록으로 점프합니다.
3. except 블록은 포착하려는 예외 유형을 지정합니다. 귀하의 예에서 except 키워드 뒤에 지정된 특정 예외가 없습니다. 즉, try 블록 내에서 발생하는 모든 예외를 포착합니다.
4. 예외가 발생하고 except 블록에 지정된 유형과 일치하는 경우(또는 예에서와 같이 예외 유형이 지정되지 않은 경우) except 블록 내부의 코드가 실행됩니다. 귀하의 예에서 except 블록은 비어 있으므로 예외를 처리하지 않습니다. 그것은 단순히 아무것도하지 않습니다.

try:

    answer = arr.index(1, idx)

except:

    answer

index() 메서드가 ValueError를 만나면 except 블록에 의해 포착되지만 except 블록은 예외를 처리하는 코드를 제공하지 않습니다. 결과적으로 예외가 억제되고 프로그램은 아무 일도 일어나지 않은 것처럼 try-except 블록 이후의 코드를 계속 실행합니다.

그러나 예외를 처리하고 예외가 발생할 때 실행할 일부 코드를 제공하려면 except 블록을 다음과 같이 수정해야 합니다.

try:

    answer = arr.index(1, idx)

except ValueError:

    # Code to handle the ValueError exception

    # For example, you could set answer to -1 or raise a custom error message

    answer = -1

이 수정된 버전에서는 ValueError가 발생하면 except 블록 내부의 코드가 실행되고 answer 변수가 -1로 설정됩니다. 이렇게 하면 예외를 정상적으로 처리하고 오류 발생 시 적절한 조치를 취할 수 있습니다.

if 1 in arr[idx:]:

    answer = arr.index(1, idx)

else:

    answer = -1

try:

    answer = arr.index(1, idx)

except:

 

 

Find & index 비교

  find()는 문자열과 함께 사용되며 더 큰 문자열 내에서 하위 문자열(문자열의 일부)의 인덱스를 찾습니다. 하위 문자열이 있는 경우 첫 번째 항목의 인덱스를 반환하고 하위 문자열이 없으면 -1을 반환합니다.

• index()는 목록과 함께 사용되며 목록 내 특정 요소의 색인을 찾습니다. 목록에 요소가 있으면 첫 번째로 나타나는 요소의 인덱스를 반환하고 요소를 찾을 수 없으면 ValueError를 발생시킵니다.

따라서 find()는 문자열에서 인덱스를 찾는 것으로, index()는 목록에서 인덱스를 찾는 것으로 생각할 수 있습니다. 주요 차이점은 작업하는 데이터 구조의 유형(문자열 대 목록)과 항목을 찾을 수 없는 경우를 처리하는 방식입니다(find()에 대해 -1을 반환하고 index(에 대해 ValueError 발생) )).

 

 

arr = [0, 0, 1, 0, 1, 1, 0]

idx = 2

 

i = ''.join(map(str, arr[idx:])).find('1')  # i = 0 (index of '1' in the substring)

result = i if i == -1 else idx + i         # result = 2 (index of '1' in the original list)

 

 return 문 return i if i == -1 else idx + i를 단계별로 분석해 봅시다.

find('1') 메서드는 문자열에서 하위 문자열 '1'이 처음 나타나는 인덱스를 반환합니다. '1'을 찾지 못하면 -1을 반환합니다. 문자열(하위 문자열)에서 '1'의 인덱스가 i라고 가정해 봅시다.

1. i if i == -1: 명령문의 이 부분은 변수 i가 -1과 같은지 확인합니다. 그렇다면 하위 문자열 '1'이 문자열에서 발견되지 않았음을 의미하며 i를 직접 반환합니다. 이 경우 i는 -1이므로 전체 명령문은 -1로 평가됩니다. 이것은 "i가 -1과 같으면 -1을 반환합니다."라고 말하는 것과 유사합니다.
2. else idx + i: 하위 문자열 '1'이 문자열에서 발견되면 i는 하위 문자열에서 해당 인덱스를 나타냅니다. 그러나 하위 문자열뿐만 아니라 원래 목록 arr에서 인덱스를 찾고자 합니다. 원래 목록에서 올바른 인덱스를 얻으려면 시작 인덱스 idx를 i에 추가해야 합니다. 명령문의 이 부분은 idx + i로 평가되며, 이는 원래 목록에서 발견된 '1'의 인덱스를 반환함을 의미합니다.

요약하면 return 문은 idx부터 시작하는 문자열(하위 문자열)에 '1'이 있는지 확인합니다. '1'이 발견되면 문자열에서 찾은 색인에 idx를 추가하여 원래 목록 arr에서 '1'의 색인을 반환합니다. '1'이 발견되지 않으면 단순히 -1을 반환하여 arr 목록에서 주어진 인덱스 idx 다음에 '1'이 발생하지 않음을 나타냅니다.