Notion에서 정리한 내용을 공유용으로 옮긴 내용입니다.
양식과 구성의 어색함이 있을 수 있습니다.

04/03(목) 학습내용을 바탕으로, 당일이 아닌 추후 업로드하였음

---

string

문자열, 날짜를 다루는 방법은 스스로 알아 보아야 함. 중요!

• 파이썬의 언어철학

  • 작성하기 쉽고, 읽기 쉬운 언어

• 에스케이프 문자
  \ 와 같이 작성하는 특별한 의미를 가진 문자
  \n : 줄바꿈
  \t : 탭
  \' : 작은 따옴표
  \" : 큰 따옴표
  \ : \

• raw string : 에스케이프 문자를 무시한다.

r'동해물과\n백두산이\t마르고\\닳도록'

동해물과\n백두산이\t마르고\\닳도록

• ''' ''' 나 """ """ 를 사용하면 에스케이프 문자를 사용하지 않아도 된다.

• f 문자열

a1 = '홍길동'
a2 = 20
a3 = 185
str4 = f'이름은 {a1}이고 나이는 {a2}살 입니다. {a1}의 키는 {a3}cm 입니다'
print(str4)

• 문자열 내의 문자 접근

str1 = 'abcdefg'

print(str1[0])

• 순서값

  • 순서값 2 부터 5-1 까지

    print(str1[2:5])
    

  • 처음 부터 5-1 까지

    print(str1[:5])
    

  • 순서값 2 부터 끝까지

    print(str1[2:])
    

• 문자열 + 문자열

  • 같은 타입끼리만 + 로 합칠 수 있음

  • 문자열+문자열, 정수+정수

  • 문자열 + 문자열 → 둘을 합친 새로운 문자열이 생성된다.

    str1 = '문자열1' + '문자열2'
    print(str1)

    → ‘문자열1문자열2’
    

• 문자열 * 숫자 → 숫자만큼 문자열을 반복한 문자열이 생성된다.

  • str1 = '문자열1' * 3
    print(str1)

    → ‘문자열1문자열1문자열1’
    

• 글자수

str1 = 'abcdefg'
str2 = '가나다라마바사'

a1 = len(str1)
a2 = len(str2)

print(a1)
print(a2)

→ 둘 다 7

• 어떤 새로운 언어를 배울 때 ‘글자 수’ 개념이 있다면
  한글/영어 테스트해보기 (한글은 2byte, 영어는 1byte)
  대부분의 언어는 좀 낭비하더라도 한 글자가 동일한 메모리를 사용하도록 프로그래밍되어 있음
  
• 첫글자를 대문자로 변경, 뒤는 소문자로 변경한다.

str1 = 'hello world'
str2 = str1.capitalize()
print(str2)

str3 = 'hELLO WORLD'
str4 = str3.capitalize()
print(str4)

• 대소문자 변경은 꼭 앞 글자만 바꿔주는지, 나머지도 소문자로 바꿔주는지 테스트

Hello world
Hello world

• 대문자/소문자로 각각 변경

str1 = 'ABcdEF'

# 대문자를 소문자로 변경
str2 = str1.lower()
print(str2)

# 소문자를 대문자로 변경
str3 = str1.upper()
print(str3)

abcdef
ABCDEF

• 문자열 채우기

str1 = 'python'

# 주어진 문자열을 주어진 크기로 늘려준다.
# 원본 문자열을 가운데 배치하고 나머지는 공백으로 채워준다.
# (만약 홀수면 왼쪽으로 쏠림)
str2 = str1.center(40)
print(f'[{str2}]')

# 원본 문자열을 좌측에 배치하고 나머지는 공백으로 채워준다.
str3 = str1.ljust(40)
print(f'[{str3}]')

# 원본 문자열을 우측에 배치하고 나머지는 공백으로 채워준다.
str4 = str1.rjust(40)
print(f'[{str4}]')

[                 python                 ]
[python                                  ]
[                                  python]

# 원본 문자열을 가운데 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str2 = str1.center(40, '_')
print(f'[{str2}]')

# 원본 문자열을 좌측에 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str3 = str1.ljust(40, '_')
print(f'[{str3}]')

# 원본 문자열을 우측에 배치하고 나머지는 지정된 문자열(글자 1개짜리)로 채워 준다.
str4 = str1.rjust(40, '_')
print(f'[{str4}]')

[_________________python_________________]
[python__________________________________]
[__________________________________python]

논란 있을까봐 글자 2개 이상은 막았다고 함…
늘어나는 게 맞다 vs 칸 안에 채우는 게 맞다
ㅋㅋㅋ수학 문제 이의 생길 거 같으면 그냥 그 선지 제거해버리기 같네

• 문자열 찾기

# cde가 어디에 있는가
a1 = str1.find('cde')
a2 = str1.index('cde')

print(a1)
print(a2)

→ 둘 다 2

• 없는 문자열 찾기

a3 = str1.find('zzz') # -1
print(a3)
a4 = str1.index('zzz') # 오류!
print(a4)

• find : 문자열에 없으면 -1 반환
• index는 문자열에 없으면 오류
• find는 문자열에만 제공. 튜플 (10,20,30) 에서 find 하면 오류.
• index는 다른 언어에서도 나는 똑같은 오류. find를 새로 파이썬에서 제공함

# 지정된 문자열의 일부를 다른 문자열로 변경한다
# replace('이걸','이거로',개수만큼)

str1 = 'abcdefg'
# cde 를 zzzzz로 변경한다
str2 = str1.replace('cde', 'zzzzz')
print(str2)

str3 = 'abcdefcdekkk'
str4 = str3.replace('cde', 'zzzzz')
print(str4)

str5 = 'abcdefcdekkk'
# 3번째 숫자를 넣어주면 그 개수만큼 변경한다
str6 = str5.replace('cde', 'zzzzz', 1)
print(str6)

검증/검사

문자열 시작/끝 검사 (startwith, endwith)

str1 = 'abcdefg'

# 문자열이 abc로 시작하는가
a1 = str1.startswith('abc')
print(a1)

# 문자열이 zzz로 시작하는가
a2 = str1.startswith('zzz')
print(a2)

True
False

# 문자열이 efg로 끝나는가
a3 = str1.endswith('efg')
print(a3)

# 문자열이 zzz로 끝나는가
a4 = str1.endswith('zzz')
print(a4)

True
False

사용자 입력할 때 도메인 맞는지 검사할 때 사용하기 좋음

아니면 사용자가 ‘김’으로 시작하는가 등

→ pandas로 할 예정

형식 검사

# 숫자와 문자로 구성되어 있는가
str1 = 'abcd1234'
a1 = str1.isalnum()
print(a1) # T

str2 = 'abcd'
a2 = str2.isalnum()
print(a2) # T

str3 = '1234'
a3 = str3.isalnum()
print(a3) # T

str4 = 'abcd가나다라1234'
a4 = str4.isalnum()
print(a4) # T

str5 = 'abcd_1234'
a5 = str5.isalnum()
print(a5) # F

• alnum : 숫자/문자면 True, 특문이면 False

# 숫자로만 구성되어 있는가
str6 = '123456'
a6 = str6.isdigit()
print(a6) # T

# 문자로만 구성되어 있는가
str7 = 'abcdef'
a7 = str7.isalpha()
print(a7) # T

# 소문자로만 구성되어 있는가
str8 = 'abcdefg'
a8 = str8.islower()
print(a8) # T

# 대문자로만 구성되어 있는가
str9 = 'ABCDEFG'
a9 = str9.isupper()
print(a9) # T

---

자료 구조

자료구조란

• 정의
  • 데이터를 관리하는 기법
  • 실제로 겪는 것들을 기반으로 만들어짐
  • 보다 실생활의 것들을 쉽고 편하게 할 수 있도록
• 방식
  • 무엇인지, 어떻게 쓰는지
  • 구현해 보기
    위가 더 중요!
    
• 배우는 이유
  • 내부적인 동작원리 → 어떻게 쓸지 파악 쉬워짐
  • 프로그래밍 능력 키우기에 좋음
• 쉽게 공부하는 법 : 실생활에서 찾아보기
  • 카페 주문 무엇부터 주문받는가
  • 이불을 차례차례 쌓고, 무엇을 먼저 꺼내는가
    1,2,3번 순서로 넣었으면 3,2,1로 꺼내게 됨
    → Stack
    
• 변수는 스택 구조로 되어 있음
  • 선언을 계속 하다가, 만약 깜빡하고 선언하지 않은 게 있으면 그 근처에서 선언
    • 변수 정의는 많이 사용하는 근처에서 선언. 그래야 빠르게 꺼낼 수 있음
    • why? 변수는 스택이기 때문에 하나씩 하나씩 꺼내고 그 변수를 꺼내야 함.
  • 함수
    • 메인에서 함수로 따로 떨어져 나와서 무언가 처리하다가 메인으로 다시 돌아올 수 있는 개념
    • 함수 내에서 사용하는 변수 → 함수 내에서 선언
• 자료구조 공부방법
  • GPT와…

리스트, 튜플

• 0부터 1씩 증가하는 순서 값을 이용하여 데이터들을 관리하는 요소
• List [ ] : 변경 가능(mutable). 수정, 삭제, 삽입, 추가 가능
• Tuple ( ) : 변경 불가(immutable). 읽기만 가능

※ 사실 파이썬에서 문자열도 순서값을 가지고 데이터를 관리하는 요소이기 때문에 비슷한 점 많음

• 리스트는 추가가 가능하므로 [ ] 를 만드는 것 의미 O

• 수정이 없다면 튜플 사용 권장

  사용했을 때 나오는 값이 여러 개다 → 튜플
  

• 튜플은 추가가 안 되기 때문에 텅 빈 ( )를 만드는 것 의미 X

• 문자열의 +, *, 슬라이싱, len 지원

• max, min 지원

  • 통계값을 사용할 일이 있으면 Numpy, Pandas를 사용하는 것이 좋다.

• 튜플에 있는 값을 모두 추출하여 새로운 리스트를 생성한다.

tuple1 = 10, 20, 30, 40, 50
list1 = list(tuple1)
print(list1)

• 리스트에 있는 값을 모두 추출하여 새로운 튜플을 생성한다.

tuple2 = tuple(list1)
print(tuple2)

• 문자열을 리스트나 튜플로 생성 가능

tuple1 = tuple('안녕하세요')
list1 = list('안녕하세요')

print(tuple1)
print(list1)

('안', '녕', '하', '세', '요')
['안', '녕', '하', '세', '요']

• join : 문자열로 합치기

str1 = "_"
# join : 지정한 튜플이나 리스트 내의 값들을 모두 추출하여 하나의 문자열로 만들어 준다.
# 이때, join을 사용한 문자열이 구분자가 된다.
str2 = str1.join(tuple1)
str3 = str1.join(list1)

print(str2)
print(str3)

• 길이가 0인 문자열로 사용하면 그냥 하나의 문자열로 합칠 수 있다. ( str1 = ‘’)

• split : 문자열 나누어 리스트 만들기

# 구분자를 기분으로 문자열을 나눈다.
# 결과는 리스트로 나온다.
str1 = 'ab cd_ef gh'

tuple1 = str1.split()
tuple2 = str1.split('_')

print(tuple1)
print(tuple2)

• 위치 찾기

# 위치 찾기. 없는 것을 넣으면 오류 발생
list1 = [10, 20, 30, 40, 50]
a1 = list1.index(20)
print(a1)

1

enumerate

• 리스트, 튜플에서만 사용

list1 = [10, 20, 30, 40, 50]
tuple1 = 10, 20, 30, 40, 50

# 관리하고있는 값들과 순서값의 쌍으로 구성된 요소(튜플)를 생성한다.
e1 = enumerate(list1)
e2 = enumerate(tuple1)
print(list(e1))
print(list(e2))

[(0, 10), (1, 20), (2, 30), (3, 40), (4, 50)]
[(0, 10), (1, 20), (2, 30), (3, 40), (4, 50)]

• for문에서의 응용

  • 파이썬에서 몇 번째 반복인지 알기 어려울 때, enumerate를 사용할 수 있다.

    for idx, a1 in enumerate(list1) :
        print(f'{idx} : {a1}')

    0 : 10
    1 : 20
    2 : 30
    3 : 40
    4 : 50

list만 있는 기능 (mutable)

추가/수정/삽입/삭제

• tuple은 불가능

list1 = []
print(list1)

• 추가 : append (한 개만)

# 추가
list1.append(10)
list1.append(20)
list1.append(30)
print(list1)

[10, 20, 30]

• 추가 : extend (여러 개)

# 다수의 값을 한번에 추가한다
# 다른 리스트나 튜플이 가지고 있는 값을 추출하여 뒤에 추가해준다.
list1.extend([40, 50, 60])
print(list1)

[10, 20, 30, 40, 50, 60]

• 수정 : 순서값 이용

# 수정
# 순서값을 가지고 접근하여 값을 넣어준다.
list1[1] = 200
print(list1)

[10, 200, 30, 40, 50, 60]

• 삽입 : insert

# 삽입
# 순서값 1에 해당하는 곳에 지정된 값을 삽입한다.
list1.insert(1, 90)
print(list1)

# 삽입하는 수가 순서값 1이 되도록

[10, 90, 200, 30, 40, 50, 60]

• 제거 : remove

# 값을 지정하여 제거한다.
list1.remove(90)
print(list1)

# 처음 1개만 제거, 없는 값이면 오류

[10, 200, 30, 40, 50, 60]

• 제거 : del

# del 연산자 : 지정한 요소를 제거하는 연산자
del list1[1]
print(list1)

→ 순서값 1에 해당하는 값 제거

• 제거/추출 : pop

# 가장 마지막 것을 가져오고 리스트에서는 제거
a1 = list1.pop()
print(a1)
print(list1)

60
[10, 200, 30, 40, 50]

# 순서값을 지정하여 가져오고 리스트에서는 제거한다.
a2 = list1.pop(2)
print(a2)
print(list1)

30
[10, 200, 40, 50]

순서 변경

• 정렬 : sort

# 정렬
# 리스트내의 데이터를 직접 정렬 해준다.
# 오름차순 정렬
list1 = [40, 20, 10, 30, 50]
list1.sort()
print(list1)

[10, 20, 30, 40, 50]

• 반전 : reverse

# 반전
# 순서를 반전시킨다.
list1.reverse()
print(list1)

• 내림차순을 만들려면 list1.sort(reverse=True)123

• 문자도 정렬 가능. why? → 유니코드

아스키 코드와 유니코드

• 정수 → 이진수 정수
• 실수
  • 고정 소수점 : 반 잘라서 소수점 이하 자리, 소수점 왼쪽 자리
  • 유동 소수점
• 논리
  • True : 1
  • False : 0
• 문자
  • 알파벳, 특문에 8bit를 이용해서 붙임
    a = 64
    b = 65
    
• 전구 1개 → 1bit : 전구의 최소 용량 단위
  8bit → 1 byte : 사람 입장에서의 최소 용량 단위
  

• 유니코드
  • 글자마다 각각 숫자를 붙여 놓은 것
  • ASCII + 한글 + 한문 → 한국형 유니코드
    • 2 byte 단위
    • 한국어 100 → 가 였다면 중국어 100 → 人
    • 꿻뚫■쎝 같은 오류가 남
  • UTF-8
    • 이것들을 다 모아서 한 번에 표현할 수 있도록 해놓은 것
    • 가장 많이 쓰임
  • UTF-16
  • 학술형 유니코드 : 잘 안 쓰는 갑골 문자 등도 모아놓음

→ 따라서 숫자로 되어 있기 때문에 문자끼리 대소 비교 가능함

• 조합형, 완성형
  • 윈도우 : 완성형 (가,나,거)
  • 맥 : 조합형 (ㄱ,ㄴ,ㅏ,ㅓ)
  • 따라서 맥 → 윈도우로 파일 보내면 ㅈㅏㅁㅗㅂㅜㄴㄹㅣ가 일어남

# 컴프리헨션(comprehension)

무조건 익숙해지기!

• 컴프리헨션 기본

# list1이 가지고 있는 값에 10을 더해 list2에 담아준다.
list1 = [10, 20, 30, 40, 50]
list2 = []

for v1 in list1 :
    list2.append(v1 + 10)

print(list2)

[20, 30, 40, 50, 60]

# list1이 가지고 있는 값의 수만큼 반복한다. (in list1)
# list1이 가지고 있는 값을 v1 변수에 담아 준다.(for v1)
# 새로운 리스트에 v1 + 10을 담아 준다.(v1 + 10)

list2 = [v1 + 10 for v1 in list1]
print(list2)

[20, 30, 40, 50, 60]

list1 에 담기 때문에 5개를 가지고 → [ , , , , ]

list1에서 v1 에 하나씩 담아서 v1 으로 → 10

v1에 담긴 수를 v1 + 10 → 10 + 10 = 20

list2 = [ 20, , , , ]

이런 식으로 list1에서 10, 20, 30, 40, 50 차례대로 가져옴

• 구하는 값에 if - else

# list3의 있는 값이 2로 나눈 나머지가 0이면
# 10을 곱해서 담고 그렇지 않으면 그대로 담아준다.
list3 = [1, 2, 3, 4, 5]
list4 = []

for v1 in list3 :
    if v1 % 2 == 0 :
        list4.append(v1 * 10)
    else :
        list4.append(v1)
print(list4)

[1, 20, 3, 40, 5]

# list3이 가지고 있는 값의 개수 만큼 반복한다(in list3)
# list3이 가지고 있는 값을 v1 변수에 담아준다(for v1)
# 만약 v1을 2로 나눈 나머지가 0 이라면 (if v1 % 2 == 0) v1 * 10 을 리스트에 담아주고 (v1 * 10)
# 그게 아니면 v1을 그대로 담아준다(else v1)

list3 = [1, 2, 3, 4, 5]
list4 = [v1 * 10 if v1 % 2 == 0 else v1 for v1 in list3]
print(list4)

[1, 20, 3, 40, 5]

list3 에서 v1으로 하나씩

1 → if v1 % 2 == 0 이 False이므로 1

2 → if v1 % 2 == 0 이 True이므로 20

3 → False이므로 3

4 → True이므로 40

5 → False이므로 3

list4 = [1, 20, 3, 40, 5]

• 담는 조건에 if

list3 = [1, 2, 3, 4, 5]
list4 = []
# list3이 가지고 있는 값을 2로 나눈 나머지가 0이라면
# 10을 곱해 새로운 리스트에 담는다.
for v1 in list3 :
    if v1 % 2 == 0 :
        list4.append(v1 * 10)

print(list4)

# 그 외에는 건너뛰는 것

[20, 40]

list3 = [1, 2, 3, 4, 5]
# list3이 가지고 있는 값의 수만큼 반복한다.(in list3)
# list3이 가지고 있는 값을 v1 변수에 담아 준다.(for v1)
# 이 때, v1을 2로 나눈 나머지가 0일 경우에만(v1 % 2 == 0)
# 새로운 리스트에 v1 * 10을 해서 담아 준다.(v1 * 10)
# 만약 v1 % 2 == 0의 조건에 만족하지 않는 값이라면 리스트에 담지 않는다.
list4 = [v1 * 10 for v1 in list3 if v1 % 2 == 0 ]
print(list4)

[20, 40]

• 작성/읽기 팁
  • 역순으로!
  • 작성
  • 바꿀 거(list1) → 변수 설정(v1) → 새롭게 담을 거(v1+10)

---

과제

• 일반 / comprehension 두 가지 버전

문제1)

리스트에 [1, 2, 3, 4, 5, 6, 7, 8, 9] 까지 담겨져 있다.

이를 이용해 구구단을 출력해 보아라.

# 일반

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 2단부터 9단까지 반복한다.
for dan in list1[1:] : # (2부터 9까지 가져옴)
    # 1부터 9까지 반복한다.
    for number in list1 :
        # 현재 단수에 현재 숫자를 곱한다.
        result = dan * number
        # 출력한다.
        print(f'{dan} X {number} = {result}')
    print() # (단과 단 사이에 줄바꿈? enter? 출력)

# 컴프리헨션

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 결과를 담을 리스트
resultList = []
# 9단까지 반복한다.
for dan in list1[1:] :
    # 현재 단수의 구구단 결과값을 계산하여 담아준다.
    r1 = [dan * number1 for number1 in list1]
    # 결과를 담을 리스트에 담아준다.
    resultList.append(r1)
    # ([[2,4,6,8,10,12,14,16,18],[3,6,...],...,[...,81]] 이런 상태)

# 출력한다.
dan = 2
number1 = 1

# 결과의 수 만큼 반복한다.
for result in resultList :  # ([2,4...],[3,6,...] 이거 한 리스트씩 분리해서 가져오기)
    # 현재 단의 결과로 반복한다.
    for r1 in result : # ([2,4,...,18] 안에서 2, 4, 6, ... 하나씩 가져오기)
        # 출력한다
        print(f'{dan} X {number1} = {r1}')
        number1 = number1 + 1

    dan = dan + 1 # (2, 3, ..., 9까지 반복) 
    number1 = 1 # (number1 은 계속 1, 2, ..., 9여야 함)
    print()

→ 일반 방법으로 하는 게 편함

• 리스트를 만들기 위해 있는 것이 comprehension인데, 구구단은 출력 위주? 의 문제임

문제2)

1부터 1000까지의 숫자 중 3의 배수이거나 7의 배수에 해당하는 숫자들의 총합을 구하여라.

# 일반

# 숫자를 담을 변수
number1 = 1
# 총합을 담을 변수
total = 0
# 1부터 1000까지 반복한다.
while number1 <= 1000 :
    # 현재 숫자가 3의 배수인지 7의 배수인지 검사한다
    if number1 % 3 == 0 or number1 % 7 == 0 :
        # 3의 배수이거나 7의 배수라면 누적한다.
        total = total + number1

    number1 = number1 + 1
    
# 총합을 출력한다.
print(f'총합 : {total}')

# (내 답안_수정) 일반
list1 = []
num = 0
while num < 1000 : # 1부터 1000까지
    num = num + 1 # 맨 위로. 대신 num = 0부터로 변경
    if num % 3 == 0 or num % 7 == 0 : # 3의 배수나 7의 배수일 때만
        list1.append(num) # list에 담기
        
# print(list1) # gpt로 개수 정답과 같은 거 확인 완료
sum(list1)

# comprehension

# 1 ~ 1000까지의 숫자 중 3의 배수 이거나 7의 배수인 숫자를 리스트에 담아준다.
list1 = [v1 + 1 for v1 in range(1000) if (v1 + 1) % 3 == 0 or (v1 + 1) % 7 == 0]
# 리스트에 담긴 숫자들의 총합을 구한다
total = sum(list1)
# 총합을 출력한다.
print(f'총합 : {total}')

# range(a,b) 없이 구현

# (내 답안) comprehension
list1 = [v1 for v1 in range(1,1001) if v1 % 3 == 0 or v1 % 7 == 0 ]
print(sum(list1))

→ 컴프리헨션이 훨씬 간단

문제3)

1부터 1000까지의 숫자 중에 3의 배수만 담아준다.
이때 3의 배수가 짝수라면 '짝수'라고 담고 홀수면 '홀수'라고 담는다.

# 숫자를 담을 리스트
list1 = []
# 1부터 1000까지 반복한다.
for v1 in range(1000) :
    # 3의 배수인지 검사한다.
    if (v1 + 1) % 3 == 0 :
        # 3의 배수가 짝수라면 짝수라는 문자열을 담아준다.
        if (v1 + 1) % 2 == 0 :
            list1.append('짝수')
        # 3의 배수가 홀수라면 홀수라는 문자열을 담아준다.
        else :
            list1.append('홀수')
# 출력한다.
print(list1)

# list1 = [in range(1000)]
# list1 = [for v1 in range(1000)]
# list1 = [for v1 in range(1000) if (v1 + 1) % 3 == 0]
list1 = ['짝수' if (v1 + 1) % 2 == 0 else '홀수' for v1 in range(1000) if (v1 + 1) % 3 == 0]
print(list1)

→ comprehension이 더 간단

• 뭔가를 더해서 누적시키겠다 → 초기값 0
• 뭔가를 곱해서 누적시키겠다 → 초기값 1

---

random

• 값 하나를 랜덤하게 추출
• 리스트, 튜플 전부 가능

list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# 값 하나를 랜덤하게 추출한다.
a1 = random.choice(list1)
a2 = random.choice(list1)
a3 = random.choice(list1)

print(a1, a2, a3)

30 70 30

# 리스트가 가지고 있는 값들을 랜덤하게 섞어 준다. (리스트 자체를 바꾸는 것)
random.shuffle(list1)
print(list1)

[70, 80, 100, 60, 50, 30, 90, 10, 40, 20]

# 0 ~ 99 사이의 정수값 하나를 랜덤하게 추출한다.
a1 = random.randrange(100)
-> 34

# a ~ b 사이의 정수값 하나를 랜덤하게 추출한다.
a2 = random.randrange(-11,-1)
-> -10

# 5 ~ 30 사이이고 2씩 증가된 숫자 중에 하나를 랜덤하게 추출한다.
a3 = random.randrange(5, 31, 2)
-> 15

# 0 ~ 1 보다 작은 실수 중에 랜덤하게 뽑아낸다.
a1 = random.random()
-> 0.14888979525742851

seed

• 항상 같은 패턴 : 고정값

• 변화되는 패턴 : 현재 시간

• 데이터 명세서

  • 데이터 분석을 위해서는 데이터분석/통계 + 도메인 지식 필요
  • 이 배경 지식을 쌓기 위해 그 산업/분야의 전문가 초빙해서 데이터 명세서 제작

unpack (분해)

• a1, a2, a3 = 10, 20, 30 10, 20, 30 → (10, 20, 30) (튜플) 이고 좌우 개수가 같으면 튜플의 각 값을 변수마다 일대일 대응해줌
  

Range

# 0 ~ 20-1 까지 1씩 증가하는 값을 관리하는 요소
r1 = range(20)

print(f'시작값 : {r1.start}')
print(f'종료값 : {r1.stop}')
print(f'증감값 : {r1.step}')
print(r1)

시작값 : 0
종료값 : 20
증감값 : 1
range(0, 20)

• 실제로 관리하는 값을 확인해보고 싶다면 리스트나 튜플로 다시 생성하여 출력

  • print(list(r1))
  • [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

• 3 ~ 27-1 까지 1씩 증가하는 값을 가진 range 생성

  • range(3, 27)
  • [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

• 3 ~ 27-1 까지 2씩 증가하는 값을 가진 range 생성

  • range(3, 27, 2)
  • [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25]

• 30 ~ 8 + 1 까지 1씩 감소

  • print(list(r4))
  • [30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9]

---

후기

분량 많다...
컴프리헨션은 그 전에 딱히 익힌 적이 없어서 어색 그 자체였다 진짜
자주 쓰나요 질문도 슬쩍 했는데 엄청 많이 쓴다고 강조 강조 강조를 하셔서 울면서 익히려고 함
확실히 슬슬 내용이 어려워짐 따라가기 조금씩 버겁
그래도 아직 평타 이상은 가는 거 같긴 한데 이게 내가 미리 배워놨으니 따라가는 거지
새로 배우는 건 뒤쳐질 수도 있겠단 생각이 들어...