스터디노트(자료구조 1~4)

zoe·2023년 3월 17일
0

자료구조

  • 자료구조 : 여러 개의 데이터가 묶여있는 자료형을 컨테이너 자료형이라고 하고, 이러한 컨테이너 자료형의 데이터 구조를 자료구조라고 함
    - 리스트(List) ex) student = ['홍길동', '박찬호'...]
    - 튜플(Tupele) ex) jops = ('의사', '속기사'...)
    - 딕셔너리(Dic) ex) scores = {'kor':88, 'eng':91...}
    - 셋트(Set) allSales = {100, 150, 90...}

리스트(List)

  • 리스트 : 배열과 같이 여러 개의 데이터를 나열한 자료구조
    - '[]'를 이용해 선언, ','를 이용해 데이터를 구분
    - 숫자, 문자(열), 논리형 등 모든 기본 데이터를 같이 저장할 수 있음
    - 리스트에 또다른 컨테이너 자료형 데이터를 저장 가능
student = '홍길동'
print('student : {}' .format(student))
print(type(student))

students = ['홍길동','박찬호','이용규','박승철','김지은']
print('students : {}' .format(students))
print(type(students))

numbers = [10, 20, 30, 40, 50, 60, 70]
print('numbers : {}' .format(numbers))
print(type(numbers))

strs = [3.14, '십', 20, 'one', '3.141592']
print('strs : {}' .format(strs))
print(type(strs))

datas = [10, 20, 30, [40, 50, 60]]
print('datas : {}' .format(datas))
print(type(datas))

가족 이름을 리스트에 저장하고 출력

# 가족 이름을 리스트에 저장하고 출력

myFamilyNames = ['홍아빠','홍엄마','홍길동','홍동생']
print(myFamilyNames)

오늘 일정을 리스트에 저장하고 출력

# 오늘 일정을 리스트에 저장하고 출력

todaySchedule = ['10시 - 업무회의',
                 '12시 - 친구와 점심약속',
                 '3시 - 자료정리',
                 '6시 - 운동',
                 '9시 - TV시청']

print(todaySchedule)

리스트 아이템 조회

  • 인덱스 : 아이템에 자동으로 부여되는 번호표 (0번부터 시작)
  • 리스트 아이템은 인덱스를 이용해서 조회 가능
students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']

print('students[0] : {}' .format(students[0]))
print('students[1] : {}' .format(students[1]))
print('students[2] : {}' .format(students[2]))
print('students[3] : {}' .format(students[3]))
print('students[4] : {}' .format(students[4]))


numbers = [3.14, 20, 30, 40, 50, 60]

print(type(numbers))
print(type(numbers[0]))
print(type(numbers[1]))
print(type(numbers[2]))
print(type(numbers[3]))
print(type(numbers[4]))

5명의 학생 이름을 리스트에 저장하고 인덱스가 홀수인 학생과 짝수(0포함)인 학생을 구분해서 인덱스와 학생 이름을 출력

# 5명의 학생 이름을 리스트에 저장하고 인덱스가 홀수인 학생과 짝수(0포함)인
# 학생을 구분해서 인덱스와 학생 이름을 출력

students = ['김성예', '신경도', '박기준', '최승철', '황동석']

print()
print('--- 인덱스가 짝수인 학생 ---')
print('students[0] : {}' .format(students[0]))
print('students[2] : {}' .format(students[2]))
print('students[4] : {}' .format(students[4]))
print('--- 인덱스가 홀수인 학생 ---')
print('students[1] : {}' .format(students[1]))
print('students[3] : {}' .format(students[3]))


for i in range(5):
    if i % 2 == 0:
        print('인덱스 짝수 : students[{}] : {}'.format(i, students[i]))
    else:
        print('인덱스 홀수 : students[{}] : {}'.format(i, students[i]))

리스트 길이

  • 리스트 길이 : 리스트에 저장된 아이템 개수
    - len(), 반복문을 이용하면 리스트 아이템 조회가 가능
    • len() 함수는 리스트의 개수뿐만 아니라 문자열의 길이도 알 수 있다

💡 좋아하는 운동 종목을 리스트에 저장하고 반복문을 이용해서 출력

myFavoriteSports = ['수영', '배구', '야구', '조깅']

for i in range(len(myFavoriteSports)):
    print('myFavoriteSports[{}] : {}' .format(i, myFavoriteSports[i]))
print()

n = 0
while n < len(myFavoriteSports):
    print('myFavoriteSports[{}] : {}'.format(n, myFavoriteSports[n]))
    n += 1
print()


for item in myFavoriteSports:
    print(item) # ★★★★★

리스트와 for문

  • for문을 이용하면 리스트의 아이템을 자동으로 참고 가능
  • for문을 이용하면, 리스트 내부의 또 다른 리스트의 아이템 조회 가능
cars = ['그랜저', '소나타', '말리부', '카니발', '쏘렌토']

for i in range(len(cars)):
    print(cars[i])
print()


for car in cars:
    print(car)
studentCnts = [[1, 19], [2, 20], [3, 22], [4, 18], [5, 21]]

for i in range(len(studentCnts)):
    print('{}학급 학생 수 : {}'.format(studentCnts[i][0], studentCnts[i][1])) # ★
print()

for classNo, cnt in studentCnts: # ★
    print('{}학급 학생 수 : {}' .format(classNo, cnt))
print()

아래 표와 리스트를 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

studentCnts = [[1, 18], [2, 19], [3, 23], [4, 21], [5, 20], [6, 22], [7, 17]]

sum = 0
avg = 0

for classNo, cnt in studentCnts:
    print(f'{classNo}학급 학생 수 : {cnt}명')
    sum += cnt

print('전체 학생 수 : {}명' .format(sum))
print('평균 학생 수 : {}명' .format(sum/len(studentCnts)))

💡 for문과 if문을 이용해서 과락 과목 출력

minScore = 60
scores = [['국어',58], ['영어',77],['수학',89],['과학',99],['국사',50]]
# ['국어',58] -> 0, 1 번째 인덱스

for item in scores:
    if item[1] < minScore:
        print('과락 과목 : {}, 점수 : {}' .format(item[0], item[1])) # ★
print()

for subject, score in scores:
    if score < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(subject, score))  # ★
print()

for subject, score in scores:
    if score >= minScore: continue # ★ if조건을 만족시킬 경우에는 continue,
    print('과락 과목 : {}, 점수 : {}'.format(subject, score))

아래의 표와 리스트를 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

# 아래의 표와 리스트를 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

minScore = 60

korScore = int(input('국어 점수 : '))
engScore = int(input('영어 점수 : '))
matScore = int(input('수학 점수 : '))
sciScore = int(input('과학 점수 : '))
hisScore = int(input('국사 점수 : '))

scores = [['국어',korScore], ['영어',engScore],
          ['수학',matScore], ['과학',sciScore], ['국사',hisScore]]

for subject, score in scores:
    if score < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(subject, sc

💡 아래의 표와 리스트를 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

# 아래의 표와 리스트를 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

studentCnts = [[1,18], [2,19], [3,23],
               [4,21], [5,20], [6,22], [7,17]]
maxClass = 0
minClass = 0
maxCnt = 0
minCnt = 0
for classNo, cnt in studentCnts: # ★
    if minClass == 0 or minCnt > cnt:
        minClass = classNo
        minCnt = cnt
    if maxClass == 0 or maxCnt < cnt: # ★
        maxClass = classNo
        maxCnt = cnt
print('학생 수가 가장 적은 학급(학생수) : {}학급({}명)'.format(minClass, minCnt))
print('학생 수가 가장 많은 학급(학생수) : {}학급({}명)'.format(maxClass, maxCnt))

리스트와 while문

  • while문을 이용하면 다양한 방법으로 아이템 조회 가능
cars = ['그랜저', '소나타', '말리부', '카니발', '쏘렌토']

n = 0
while n < len(cars):
    print(cars[n])
    n += 1
print()


n = 0
flag = True
while flag:
    print(cars[n])
    n += 1

    if n == len(cars): # ★
        flag = False
print()


n = 0
while True:
    print(cars[n])
    n += 1

    if n == len(cars):
        break
print()
studentCnts = [[1, 19], [2, 20], [3, 22], [4, 18], [5, 21]]

n = 0
while n < len(studentCnts):
    print('{}학급 학생 수 : {}' .format(studentCnts[n][0],studentCnts[n][1])) # ★
    n += 1
print()

아래 표와 리스트를 이용해서 학급별 학생 수와 전체 학생 수 그리고 평균 학생수를 출력

studentCnts = [[1, 18], [2, 19], [3, 23], [4, 21], [5, 20], [6, 22], [7, 17]]
n = 0
sum = 0
avg = 0

while n < len(studentCnts):
    classNo = studentCnts[n][0]
    cnt = studentCnts[n][1]
    print('{}학급 학생 수 : {}명' .format(classNo, cnt))
    sum += cnt
    n += 1

avg = sum / len(studentCnts)
print('전체 학생 수 : {}명' .format(sum))
print('평균 학생 수 : {}명' .format(avg))

while문을 이용해서 사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면 과락 과목와 점수를 출력하는 프로그램을 생성

# while문을 이용해서 사용자가 국어, 영어, 수학, 과학, 국사 점수를 입력하면
# 과락 과목와 점수를 출력하는 프로그램을 생성

minScore = 60
korScore = int(input('국어 점수 : '))
engScore = int(input('영어 점수 : '))
matScore = int(input('수학 점수 : '))
sciScore = int(input('과학 점수 : '))
hisScore = int(input('국사 점수 : '))

scores = [['국어', korScore], ['영어', engScore],
          ['수학', matScore], ['과학', matScore], ['국사', hisScore]]

n = 0
while n < len(scores):
    if scores[n][1] < minScore:
        print('과락 과목 : {}, 점수 : {}'.format(scores[n][0], scores[n][1]))

    n += 1

💡 while문을 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

# while문을 이용해서 학급 학생 수가 가장 작은 학급과 가장 많은 학급을 출력

studentCnt = [[1, 18],
              [2, 19],
              [3, 23],
              [4, 21],
              [5, 20],
              [6, 22],
              [7, 17]]

maxClass = 0
minClass = 0
maxCnt = 0
minCnt = 0

n = 0
while n < len(studentCnt):
    if minCnt == 0 or studentCnt[n][1] < minScore:
        minClass = studentCnt[n][0]
        minCnt = studentCnt[n][1]

    if maxCnt == 0 or studentCnt[n][1] > maxCnt:
        maxClass = studentCnt[n][0]
        maxCnt = studentCnt[n][1]
    n += 1

print('학생 수가 가장 적은 학급(학생수) : {}학급({}명)'.format(minClass, minCnt))
print('학생 수가 가장 많은 학급(학생수) : {}학급({}명)'.format(maxClass, maxCnt))

enumerate() 함수

  • enumerate() : 리스트 아이템 열거 가능, 문자열 적용 가능
sports = ['농구','수구','축구','마라톤', '테니스']

for i in range(len(sports)):
    print('{} : {}' .format(i, sports[i]))
print()

for idx, value in enumerate(sports):
    print('{} : {}'.format(idx, value))
print()
str = 'Hello python.'

for idx, value in enumerate(str):
    print('{} : {}'.format(idx, value))

가장 좋아하는 스포츠가 몇 번째에 있는지 출력하는 프로그램을 생성

# 가장 좋아하는 스포츠가 몇 번째에 있는지 출력하는 프로그램을 생성

sports = ['농구','수구','축구','마라톤', '테니스']
favoriteSport = input('내가 가장 좋아하는 스포츠 입력 : ')

bestSportIdx = 0
for idx, value in enumerate(sports):
    if value == favoriteSport:
        bestSportIdx = idx + 1

print('{}(은)는 {}번째에 있습니다.' .format(favoriteSport, bestSportIdx))

사용자가 입력한 문자열에서 공백의 개수를 출력

# 사용자가 입력한 문자열에서 공백의 개수를 출력

message = input('메시지 입력 : ')
cnt = 0 # ★

for idx, value in enumerate(message):
    if value == ' ':
        cnt += 1

print('공백 개수 : {}' .format(cnt))

리스트에 아이템 추가

  • append() : 리스트의 마지막 인덱스에 아이템 추가 가능
students = ['홍길동','박찬호','이용규','박승철','김지은']
print('students : {}' .format(students))
print('students의 길이 : {}' .format(len(students)))
print('students의 마지막 인덱스 : {}' .format(len(students)-1))

students.append('강호동')
print('students : {}' .format(students))
print('students의 길이 : {}' .format(len(students)))
print('students의 마지막 인덱스 : {}' .format(len(students)-1))
scores = [['국어',88], ['영어',91]]
scores.append(['수학',96])

print('scores : {}' .format(scores))
for subject, score in scores: # ★
    print('과목\t : {}, 점수 : {}' .format(subject, score))

가족 구성원의 나이가 아래와 같을 때 새로 태어난 동생을 리스트에 추가

myFamilyAge = [['아빠',40],['엄마',38], ['나',9]]
myFamilyAge.append(['동생',1])

for name, age in myFamilyAge:
    print('{}의 나이 : {}' .format(name, age))

리스트의 특정 위치에 아이템 추가

  • insert() : 리스트의 특정 위치(인덱스)에 아이템 추가 가능
students = ['홍길동', '박찬호', '이용규', '박승철', '김지은']
print('students : {}' .format(students))
print('students의 길이 : {}' .format(len(students)))
print('students의 마지막 인덱스 : {}' .format(len(students)-1))

students.insert(3, '강호동') # ★
print('students : {}' .format(students))
print('students의 길이 : {}' .format(len(students)))
print('students의 마지막 인덱스 : {}' .format(len(students)-1))
words = ['I', 'a', 'boy']
words.insert(1, 'am')

for word in words:
    print('{}' .format(word),end=' ')

오름차순으로 정렬되어 있는 숫자들에 사용자가 입력한 정수를 추가하는 프로그램을 생성
(단, 추가 후에도 오름차순 정렬이 유지되어야 한다.)

# 오름차순으로 정렬되어 있는 숫자들에 사용자가 입력한 정수를 추가하는 프로그램을 생성
# (단, 추가 후에도 오름차순 정렬이 유지되어야 한다.)

numbers = [1, 3, 6, 11, 45, 54, 62, 75, 85]

inputNumber = int(input('숫자 입력 : '))
insertIdx = 0

for idx, num in enumerate(numbers):
    print(idx, num)
    if insertIdx == 0 and inputNumber < num: # ★ 한번만 적용되게 하기 위해
        insertIdx = idx
numbers.insert(insertIdx,inputNumber)

print(numbers)

리스트의 아이템 삭제

  • pop() : 리스트의 마지막 인덱스에 해당하는 아이템 삭제
  • pop(n) : 리스트 내 n인덱스테 해당하는 아이템 삭제
students = ['홍길동', '박찬호', '이용규', '박승철', '김지은', '강호동']

print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students.pop()

print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students = ['홍길동', '박찬호', '이용규', '박승철', '김지은', '강호동']
print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students.pop(3)
print('students : {}' .format(students))
print('students length : {}' .format(len(students)))

rValue = students.pop()
print('rValue : {}' .format(rValue))

rValue = students.pop(3)
print('rValue : {}' .format(rValue))
print('students length : {}' .format(len(students)))

다음은 어떤 체조 선수의 점수표이다. 점수표에서 최고 및 최저 점수를 삭제하기

# 다음은 어떤 체조 선수의 점수표이다. 점수표에서 최고 및 최저 점수를 삭제하기

playerScore = [9.5, 8.9, 9.2, 9.8, 8.8, 9.0]

minScore = 0
maxScore = 0
minScoreIdx = 0
maxScoreIdx = 0

for idx,score in enumerate(playerScore):
    if idx == 0 or score < minScore:
        minScore = score
        minScoreIdx = idx
    if idx == 0 or score > maxScore:
        maxScore = score
        maxScoreIdx = idx

print(f'playerScore : {playerScore}')
print(f'minScore : {minScore}, minScoreIdx : {minScoreIdx}')
playerScore.pop(minScoreIdx)
print(f'playerScore : {playerScore}')
print(f'maxScore : {maxScore}, maxScoreIdx : {maxScoreIdx}')
playerScore.pop(maxScoreIdx)
print(f'playerScore : {playerScore}')

리스트의 특정 아이템 삭제

  • remove() : 리스트의 특정 아이템 한 개만 삭제
    - 2개 이상의 동일한 아이템을 remove()로 삭제할 경우 가장 앞의 아이템 하나가 삭제됨
  • 💡 itemA in AList : itemA가 AList에 있으면 True / 없으면 False 반환
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']

print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students.remove('강호동')
print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은', '강호동']
# 2개 이상의 동일한 아이템을 remove()로 삭제할 경우 가장 앞의 아이템 하나가 삭제됨
students.remove('강호동')
print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은', '강호동']

print('강호동' in students)
# students 리스트 안에 강호동이 있으면 True / 없으면 False

while '강호동' in students: 
#students 리스트에 강호동이 없을 때까지 반복실행 ★★★★★
    students.remove('강호동')
print('students : {}' .format(students))
print('students lenght : {}' .format(len(students)))

아래의 오늘 일정표에서 사용자가 입력한 일정을 삭제하는 프로그램을 생성

# 아래의 오늘 일정표에서 사용자가 입력한 일정을 삭제하는 프로그램을 생성

myList = ['마케팅 회의', '회의록 정리', '점심 약속',
          '월간 업무 보고', '치과 방문', '마트 장보기']

print(myList)
removeItem = input('삭제 대상 입력 : ')
myList.remove(removeItem)
print('일정 : {}' .format(myList))

아래 시험 과목표에서 사용자가 입력한 과목을 삭제하는 프로그램을 생성

# 아래 시험 과목표에서 사용자가 입력한 과목을 삭제하는 프로그램을 생성

subject = ['국어','영어','수학','과학','국사']
print('시험 과목표 : {}' .format(subject))

removeItem = input('삭제 과목명 입력 : ')
while removeItem in subject:
    subject.remove(removeItem)

print('시험 과목표 : {}' .format(subject))

💡 리스트 연결

  • extend() : 리스트에 또 다른 리스트 연결(확장)
    - A, B가 있을 때, extend(B)를 이용하면 A에 B가 연결(확장)
  • 덧셈 연산자(+)를 이용해서 리스트 연결 가능
    - A, B가 있을 때, +를 이용하면 새로운 C에 A와 B가 연결(확장)
group1 = ['홍길동', '박찬호', '이용규']
group2 = ['강호동', '박승철', '김지은']

print('group1 : {}' .format(group1))
print('group2 : {}' .format(group2))
print()

group1.extend(group2)
print('group1 : {}' .format(group1))
print('group2 : {}' .format(group2))
print()

group1 = ['홍길동', '박찬호', '이용규']
group2 = ['강호동', '박승철', '김지은']
result = group1 + group2
print('group1 : {}' .format(group1))
print('group2 : {}' .format(group2))
print('result : {}' .format(result))
print()

💡 나와 친구가 좋아는 번호를 합치되 번호가 중복되지 않게 하는 프로그램을 생성

# 나와 친구가 좋아는 번호를 합치되 번호가 중복되지 않게 하는 프로그램을 생성

myFavoritNumbers = [1, 3, 5, 6, 7]
friendFavoriteNumbers = [2, 3, 5, 8, 10]

print('myFavoritNumbers : {}' .format(myFavoritNumbers))
print('friendFavoriteNumbers : {}' .format(friendFavoriteNumbers))

addList = myFavoritNumbers + friendFavoriteNumbers
print('addList : {}' .format(addList))

result = [] # ★
for number in addList: # ★
    if number not in result: # ★
        result.append(number)
print('result : {}' .format(result))

리스트 아이템 정렬

  • sort() : 리스트의 아이템 정렬
    - 오름차순이 기본값(reverse = False), 생략 가능
    - sort(reverse = True) : 내림차순 정렬
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
print('students : {}' .format(students))

students.sort()
print('students sort() : {}' .format(students))
students.sort(reverse=True)
print('students sort() : {}' .format(students))
numbers = [2, 50, 0.12, 1, 9, 7, 17, 35, 100, 3.14]
print('numbers : {}' .format(numbers))

numbers.sort()
print('numbers : {}' .format(numbers))
numbers.sort(reverse=True)
print('numbers : {}' .format(numbers))
print()

💡 아래 점수표에서 최저 및 최고 점수를 삭제한 후 총점과 평균을 출력

# 아래 점수표에서 최저 및 최고 점수를 삭제한 후 총점과 평균을 출력

playerScore = [9.5, 8.9, 9.2, 9.8, 8.8, 9.0]
print(f'playerScore : {playerScore}')

playerScore.sort()
print(f'playerScore : {playerScore}')
playerScore.pop(0)
playerScore.pop(len(playerScore)-1)
print(f'playerScore : {playerScore}')

sum = 0
avg = 0
for score in playerScore:
    sum += score
avg = sum / len(playerScore)

print('총점 : {}' .format(round(sum,2)))
print('평균 : {}' .format(round(avg,2)))

리스트 아이템 순서 뒤집기

  • reverse() : 리스트의 아이템 순서 뒤집기 가능
  • 💡 문자열은 각 단어로 이루어진 리스트로 여겨짐(?) (관련 정보)
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
print(students)
students.reverse()
print(students)
numbers = [2, 50, 0.12, 1, 9, 7, 17, 35, 100, 3.14]
print(numbers)
numbers.reverse()
print(numbers)

💡 다음은 전쟁에서 사용되는 암호이다. 암호를 해독하는 프로그램을 생성

# 다음은 전쟁에서 사용되는 암호이다. 암호를 해독하는 프로그램을 생성

secret = '27156231'
print(secret)
#print(type(secret))

secretList = []
solvedList = ''

for cha in secret:
    # ★ https://wikidocs.net/21119 문자열은 각 단어로 이루어진 리스트로 여겨짐(?)
    secretList.append(int(cha))
print(secretList)
secretList.reverse()
print(secretList)

val = secretList[0] * secretList[1]
secretList.insert(2,val)
print(secretList)

val = secretList[3] * secretList[4]
secretList.insert(5, val)

val = secretList[6] * secretList[7]
secretList.insert(8, val)

val = secretList[9] * secretList[10]
secretList.insert(11, val)

print('secretList : {}' .format(secretList))

💡 리스트 슬라이싱

  • [n:m] : 리스트에서 원하는 아이템만(n <= item < m) 뽑기(슬라이싱)
    - 문자열도 슬라이싱 가능
    - [-n:-m] : -n → 앞에서부터 n개, -m → 뒤에서부터 n개
    - [n:m:o] → 0 : 아이템 간격
    - 슬라이싱을 이용해 아이템 변경 가능
  • slice() : 리스트에서 아이템 슬라이싱
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
print('students : {}' .format(students))
print('students[2:4] : {}' .format(students[2:4]))
str = 'abcdefghijklmnopqrxtuvwxyz'
print('str length : {}' .format(len(str)))
print('str : {}' .format(str))
print('str : {}' .format(str[2:4]))
print('str : {}' .format(str[:4]))
print('str : {}' .format(str[2:]))
print('str : {}' .format(str[2:-2])) # ★
print('str : {}' .format(str[-5:-2])) # ★
numbers = [2, 50, 0.12, 1, 9, 7, 17, 35, 100, 3.14]
print('number : {}' .format(numbers[2:-2]))
print('number : {}' .format(numbers[2:-2:2])) # [n:m:o] → 0 : 아이템 간격 ★
print('number : {}' .format(numbers[:-2:2])) # ★
print('number : {}' .format(numbers[::2])) # ★
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
print('students : {}' .format(students))

students[1:4] = ['park chanho', 'lee younggyu', 'gang hodong']
print('stdunts : {}' .format(students))
students = ['홍길동', '박찬호', '이용규','강호동', '박승철', '김지은']
print('students : {}' .format(students))

print('students : {}' .format(students[slice(2, 4)]))
print('students : {}' .format(students[slice(4)])) # slice(4) : ~ 4까지 ★
print('students : {}' .format(students[slice(2, len(students)-2)]))
print('students : {}' .format(students[slice(len(students)-5, len(students)-2)]))

💻 출처 : 제로베이스 데이터 취업 스쿨

0개의 댓글