12/29 Python 4일차

빨강·2024년 1월 2일
KDT5python
0

기록 - Python

목록 보기
6/14
post-thumbnail

  • 09:00 숙제 확인

    work_12_28_name.py

    '''
1. 아래에 데이터를 저장하는 코드를 작성하세요:
'''

q1 = "kim1234@naver.com"
q2 = "http:www.naver.com"
q3 = "홍길동"
q4 = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRr"
q5 = "ABC1DEF2GHI3JKL4MNO5PQR6STU7VWX8YZ"
q6 = "881120-1068234"

print(f'1-1 : ', q1[:7])
print(f'1-2 : ', q2[9:])
print(f'1-3 : ', q3[1:])
print(f'1-4 : 대문자 -', q4[::2], ', 소문자 -', q4[1::2])
print(f'1-5 : ', q5[3::4])
print(f'1-6 : 생년월일 -', q6[:6], ', 숫자부분 -', q6[7:])

'''
2. 아래 조건에 만족하도록 코드 작성하세요.
'''

input_int = int(input('정수 입력 :'))
print(f'''10진수 {input_int}
16진수 : {hex(input_int)}
 8진수 : {oct(input_int)}
 2진수 : {bin(input_int)}''')

'''
3. 아래 조건에 만족하도록 코드 작성하세요.
'''

input1 = input('Happy를 입력하세요: ')
input2 = input('New를 입력하세요: ')
input3 = input('Zoo를 입력하세요: ')

print(f'''코드 값이 가장   큰 단어 : {max(input1,input2,input3)}
코드 값이 가장 작은 단어 : {min(input1,input2,input3)}''')

'''
4. 아래 조건에 만족하도록 코드 작성하세요.
# '''
sentence = "오늘은 행복한 Thursday입니다."
input4 = input('목요일을 입력하세요: ')
print(f"'{input4}' 단어 메시지 존재 여부 : {bool(input4 in sentence)}")

input5 = input('happy를 입력하세요: ')
print(f"'{input5}' 단어 메시지 존재 여부 : {bool(input5 in sentence)}")

'''
5. 아래 조건에 만족하도록 코드 작성하세요.
'''
input6 = input('Zoo를 입력하세요: ')
print(f'{input6} 코드값 : {bin(ord(input6[0]))[2:]} {bin(ord(input6[1]))[2:]} {bin(ord(input6[2]))[2:]}' )
    • 변수 이름이 좋지 못함. 내가 작성하면서도 ‘inputN’이라서 헷갈림.

  • 복습 데이터 타입 별 가능한 연산자

    • 수치 데이터 - int/float - 산술,비교, 논리

                      - complex

    • 문자 데이터 - 산술 - 덧셈str+str/곱셈str*int

                                             - 나머지 %

                            - 비교 - 코드값 >,<,≥,≤,=,≠

                            - 멤버 - in / not in

  • 함수 - 특징 기능의 코드 묶음

    • print(), input(), len(), id(), type(), ord(), chr(), hex(), oct(), bin(), str(), float(), int(), bool()

  • 특정 Data Type

    • int용 함수 = 메서드
    • float용 함수 = 메서드
    • str용 함수 메서드
    • 어떤 용도의 메서드인지 알아야하기 때문에 ‘변수명’뒤에 ’.’을 붙이면 해당 전용 메서드만 보임

  • 10:00

    • and 는 앞에 거짓일 가능성 높은 것을, or는 앞에 참일 가능성이 높은 것을 놓아서 빨리 시간에 따라 작성될 수 있도록 함

      ex_str_method.py

      # ----------------------------------------------------------
# str 데이터 타입 전용의 함수 즉 메서드(Method) 살펴 보기
# - 메서드(Method)
#   특정 데이터 타입에서만 사용 가능한 함수를 의미
#   사용 방법
#   변수명.메서드명() ==> msg="Good"
#                     msg. 으로 검색 후
#                     msg.메서드명()
#   데이터.메서드명() ==> "Good".메서드명()
# ----------------------------------------------------------
# str을 대문자로 변환 ==> upper() 메서드
print("Good".upper())

# str을 소문자로 변환 ==> lower() 메서드
print("Good".lower())

#str이 모두 대문자인지 검사 후 결과 변환 ==> isupper() 메서드
print("Good".isupper())

#str이 모두 소문자인지 검사 후 결과 변환 ==> islower() 메서드
print("Good".islower())

#str이 0~9로 구성되어 있는지 검사 후 결과 변환 ==> isdecimal() 메서드
print("Good".isdecimal(), "012".isdecimal(), "-9".isdecimal()) #음수는 False

#str이 문자로만 구성되어있는지 검사 후 결과 변환 ==> isalpha() 메서드
print("Good".isalpha(), "Good2024".isalpha(), "한글".isalpha())

#str이 문자, 숫자로만 구성되어 있는지 검사 후 결과 변환 ==> isalnum() 메서드
print("Good".isalnum(), "Good2024".isalnum(), "한글".isalnum())

#str 문자에서 특정 문자/문자열로 시작하는지 검사 후 결과 변환 ==> startswith() 메서드
print("??Happy New".startswith("??"))
print("??Happy New".startswith("!"))

#str 문자에서 특정 문자/문자열로 끝나는지 검사 후 결과 변환 ==> endswith() 메서드
print("Happy New??".endswith("??"))
print("Happy New??".endswith("!"))

#str 문자에서 특정 문자/문자열로 끝나는지 검사 후 결과 반환 => jpg
print("flower.jpg??".endswith("jpg"))
print("flower.png??".endswith("jpg"))
print("flower.png??".endswith(("jpg","png","txt")))

# print("flower.txt"[-3:] == "jpg" or "flower.txt"[-3:] == "png" or "flower.txt"[-3:] == "txt")
# print("flower.txt" in ('jpg', 'png', 'txt'))

#str 특정 인덱스 문자를 변경해주는 메서드 => replace() 메서드
name = "HongGulDong"
#     01234567890
# => u ===> i로 변경
print(name[5])

# name[5]='i' ==> 인덱싱으로는 미지원 기능 ==> 메서드 제공
print(name.replace('o','*'))
print(name.replace('o','*',1))
name=name.replace('u','i')
  • 13:00

    • ex_text_01.py

      # ----------------------------------------------------------
# [실습1] 단어를 입력 받은 후 아래 코드를 작성하세요.
# - 입력 받은 단어가 알파벳만으로 구성되어 있는지 검사
# - 입력 받은 단어가 숫자만으로 구성되어 있는지 검사
# - 입력 받은 단어가 모두 대문자로만 구성되어 있는지 검사
# - 입력 받은 단어가 모두 소문자로만 구성되어 있는지 검사
# ----------------------------------------------------------

test = input("단어를 입력해주세요: ")
print(f"""단어가 알파벳만으로 구성되어 있습니다 : {test.isalpha()}
단어가 숫자만으로 구성되어 있습니다 : {test.isnumeric()}
단어가 모두 대문자로만 구성되어 있습니다 : {test.isupper()}
단어가 모두 소문자로만 구성되어 있습니다 : {test.islower()}""")

# ----------------------------------------------------------
# [실습2] 파일명을 입력 받은 후 아래 코드를 작성하세요.
# - 입력 받은 파일이 text 파일인지 검사
# - 입력 받은 파일이 jpg 파일인지 검사
# - 입력 받은 파일이 py 파일인지 검사
# ----------------------------------------------------------

test2 = input("파일명을 입력해주세요:")
print(f"""입력 받은 파일은 text 파일입니다 : {test2.endswith('txt')}
입력 받은 파일은 jpg 파일입니다 : {test2.endswith('jpg')}
입력 받은 파일은 py 파일입니다 : {test2.endswith('py')}
""")

# 이메일 검증?
test3 = "holicalday@naver.com"
print('@' and '.' in test3)

filename=input("파일명 입력 : ")

print(f'{filename} text 파일 여부 : {filename.endswith("txt")}')
print(f'{filename} jpg 파일 여부 : {filename.endswith("jpg")}')
print(f'{filename} py 파일 여부 : {filename.endswith("py")}')

    • ex_str_method_02.py

      # ----------------------------------------------------------
# str 데이터 타입 전용의 함수 즉 메서드(Method) 살펴 보기
# - 메서드(Method)
#   특정 데이터 타입에서만 사용 가능한 함수를 의미
#   사용 방법
#   변수명.메서드명() ==> msg="Good"
#                     msg. 으로 검색 후
#                     msg.메서드명()
#   데이터.메서드명() ==> "Good".메서드명()
# ----------------------------------------------------------
# str 데이터에서 특정 문자의 인덱스를 반환하는 메서드 => index()
# - 왼쪽 ----> 오른쪽, 제일 먼저 발견되는 문자의 인덱스를 반환
# - 존재하지 않는 str 인덱스 찾을려고 하면 Error 발생
# ----------------------------------------------------------

data = "Merry Christmas"
#       012345678901234
#         23  6 8
print(f"data.index('C')) => {data.index('C')}")
print(f"data.index('r')) => {data.index('r')}")
print(f"data.index('r', 3)) => {data.index('r',3)}")
print(f"data.index('r', 4)) => {data.index('r',4)}")
print(f"data.index('r', {data.index('r')}+1) => {data.index('r')+1}")

first_r=data.index('r')                      # 0번 원소부터 하나씩 검사해서 'r'에 해당하는 인덱스 찾기
print(f"data.index('r', first_r+1) => {data.index('r'), first_r+1}")

second_r = data.index('r', first_r+1)  # 첫 번째 'r' 인덱스 이후 원소부터 하나씩 검사해서 'r'에 해당하는 인덱스 찾기
third_r = data.index('r', second_r+1)  # 두 번째 'r' 인덱스 이후 원소부터 하나씩 검사해서 'r'에 해당하는 인덱스 찾기

# 하지만 이렇게 하는 것이 재사용하지 않기 때문에
# 그냥 data.index('r')를 넣는 것이 메모리 상 나은 편이긴 하나
# 알아보기 용이한 장점이 있음

# ----------------------------------------------------------
# str 데이터에서 특정 문자의 인덱스를 반환하는 메서드 => find()
# - 왼쪽 ----> 오른쪽, 제일 먼저 발견되는 문자의 인덱스를 반환
# - 존재하지 않는 str 인덱스 찾을려고 하면 -1 발생 (0번부터는 이미 할당되어 있기 때문에)
# ----------------------------------------------------------

# !의 인덱스를 찾기
print(f"data.find('!')) => {data.find('!')}")

# ----------------------------------------------------------
# str 데이터에서 문자열 분리해주는 메서드 => split()
# - 기본값 : 스페이스 바, 공백 기준으로 1개의 str을 여러 개의 str로 분리
# ----------------------------------------------------------

data = "Happy New Year 1 2 3 4 5"

# str에서 공백을 기준으로 str 나누기
datas = data.split()
print(f"datas => {datas}")
print( type( datas ), datas)
# print(datas[2:][:4][1:]) 슬라이싱을 반복하면 왼쪽부터 슬라이싱 된 내용을 처리한 후 다시 리스트 상태에서 슬라이싱 함

# list에 저장된 원소/요소 하나씩 읽기 => 변수명[인덱스]
print( f" datas[0] => {datas[0]}")
print( f" datas[1] => {datas[1]}")
print( f" datas[-1] => {datas[-1]}")
print(f"datas => {data.split('e')}")

juminNo = '123456-1234567'
birth = juminNo[:juminNo.index('-')]
number = juminNo[juminNo.index('-')+2:]
juminNos = juminNo.split('-')
print(juminNos)
  • 15:00 ex_list_01.py
    # ----------------------------------------------------------
# 리스트(List) 데이터 타입
# - 여러 종류의 여러 개의 데이터를 저장하는 타입
# - 문법 : [ 데이터1, 데이터2, ..., 데이터N ]
# - 특징 : 데이터 하나 하나를 요소/원소 라고 함
#         하나 하나의 요소/원소를 식별하기 위해서 인덱싱(Indexing)
# - 순서가 있는 데이터 타입 => 시퀀스 데이터 타입 *str도 시퀀스 데이터 타입
# ----------------------------------------------------------

# 리스트 데이터 생성 -------------------------------------------
# 숫자 10개를 메모리에 저장
no1 = 10
no2 = 30
no3 = 100
no4 = 5
no5 = 12
no6 = 32
no7 = 102
no8 = 51
no9 = 11
no10 = 31

no = [10, 30, 100, 5, 12, 32, 102, 51, 11, 31]
#     0   1    2   3  4   5    6    7   8  9
#    -10  -9   -8  -7  -6  -5  -4  -3  -2  -1

print(f'id(no)     => {id(no)   }')
print(f'id(no[0])) => {id(no[0])}')
print(f'id(no[1])) => {id(no[1])}')

# 리스트의 원소/요소 한 개씩 접근하는 방법 ==> 변수명[인덱스]
# - 왼쪽 => 오른쪽 : 0 ~
# - 오른쪽 => 왼쪽 : -1 ~
# => 슬라이싱 가능
# ----------------------------------------------------------
# 마지막 3개의 점수만 출력해주세요
print(no[-3:])

# 짝 수번째 인덱스 요소만 출력해주세요
print(f'짝수 요소만 출력 : {no[::2]}')
print(f'홀수 요소만 출력 : {no[1::2]}')

ex_list_02.py

# ----------------------------------------------------------
# 다양한 리스트 생성
# ----------------------------------------------------------
# 실수 데이터로 구성된 리스트 생성
floatNums = [4., 3.1, 6.3, 5.01]

# str 데이터로 구성된 리스트 생성
strNums = ['44', '56', '98']

# bool 데이터로 구성된 리스트 생성
boolNums = [False, False, True, True, True]

# 다양한 데이터 타입으로 구성된 리스트 생성
nums = ['100', 98, False, 7.12, 'Apple', True, 7>6]

print(floatNums, strNums, boolNums, nums)
# [4.0, 3.1, 6.3, 5.01] ['44', '56', '98'] [False, False, True, True, True] ['100', 98, False, 7.12, 'Apple', True, True]
# 빈 리스트 생성
nums = []
print(nums) #[]

# 리스트 안에 리스트로 구성된 리스트 생성
nums = [10, 20, "한글", ['A', 'B'], boolNums, 200, 10.0]
#        0   1   2       3          4       5    6
print(nums) # [10, 20, 30, ['A', 'B'], [False, False, True, True, True], 200, 100]

# 리스트의 요소 출력
print(f'nums[0] => {nums[0]}, {type(nums[0])}')
print(f'nums[1] => {nums[1]}, {type(nums[1])}')
print(f'nums[2] => {nums[2]}, {type(nums[2])}')
print(f'nums[3] => {nums[3]}, {type(nums[3])}')
print(f'nums[4] => {nums[4]}, {type(nums[4])}')
print(f'nums[5] => {nums[5]}, {type(nums[5])}')
print(f'nums[6] => {nums[6]}, {type(nums[6])}')

# B만 가져오려면?(3번의 1번)
print(f'nums[3][1] => {nums[3][1]}, {type(nums[3][1])}')

data = [1, [ [1,2,3], 'A']]
# 라고 했을 때 1차원은 [1, [ [1,2,3], 'A']]
#           2차원은 [ [1,2,3], 'A']
#           3차원은 [1,2,3]
  • 16:00 ex_test_02.py
    # ------------------------------------------------------------
# range() 내장함수
# - 숫자의 범위를 생상해주는 함수
# - 반환값/결과값/리턴값 : range 타입
# - 범위에 포함되는 숫자 데이터는 원소/요소라고 함 => 인덱싱으로 접근
# ------------------------------------------------------------

# 1 ~ 20으로 구성된 정수 데이터 생성
nums = range(20)
print(f'nums => {nums}, {type(nums)}')
print(f'nums => {nums[0]}, {type(nums[0])}')
print(f'nums => {nums[-1]}, {type(nums[-1])}')

print(f'nums => {len(nums)}개')

# 앞부분 5개 원소까지만 추출 => 슬라이싱
print(f'nums => {nums[:5]}, {type(nums[0:5])}')

# range => list 형 변환하기 => list(데이터)
print(f'list(nums) => {list(nums)}')

# 0~100으로 구성된 정수 리스트 생성해주세요.
numsList=list(range(101))
numsList2=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,20]
print(numsList)
print(numsList2)

# ------------------------------------------------------------
# range(시작값, 끝값)
# - 시작값 => 기본 : 0       range(10) =>  0 <= ~ < 10
# - 시작값 => 기본 : 1       range(1,10) =>  1 <= ~ <    10 1,2,3,4,5,6,7,8,9
# - 시작값 => 기본 : 5       range(5,10) =>  5 <= ~ <    10 5,6,7,8,9
# ------------------------------------------------------------

# 1~30 범위에서 3의 배수만으로 구성된 리스트 생성
# 3,6,9,12,15,18,21,24,27,30

threes = [3,6,9,12,15,18,21,24,27,...,999]

# ------------------------------------------------------------
# range(시작값, 끝값)
# - 시작값 => 기본 : 0, 증감 : 1   range(10)     =>  0 <= ~ < 10    0,1,2,3,4,5,6,7,8,9
# - 시작값 => 기본 : 1, 증감 : 1   range(1,10)   =>  1 <= ~ < 10    1,2,3,4,5,6,7,8,9
# - 시작값 => 기본 : 1, 증감 : 2   range(1,10,2) =>  1 <= ~ < 10    1,3,5,67,9
# ------------------------------------------------------------

# 1~100 범위에서 3의 배수만으로 구성된 리스트 생성
threes1 = list(range(3,101,3))
print(threes1)

17:20

ex_list_op.py

# ------------------------------------------------------------
# List 자료형의 연산 살펴보기
# - 산술연산
# - 비교연산
# - 멤버연산자
# ------------------------------------------------------------
#
# 1~50 범위의 2의 배수로 구성된 리스트 생성

twoNums = list(range(2,51,2))
print(twoNums)

# 산술연산 => 덧셈(+), 곱셈(*)-------------------------------------
datas = twoNums + ["A", "B"] #뒤에 추가됨, List끼리만 가능
print(datas)

# list + str => list + list(str)
# datas = (twoNums + "ABC") #List끼리만 가능
datas = (twoNums + list("ABC")) # 마지막에 A, B, C로 추가됨
print(list("ABC"))
print(datas)

# list + str => str(list) + str
print(str(twoNums) + "ABC") #[~]ABC 가 됨
aa=str(twoNums)
print(aa[0]) # [ 나옴

# list * int => int만큼 원소를 반복해서 하나의 List로 만듦
print(twoNums * 3)

# list + int => list + list(int)
# datas = (twoNums + 11) #List끼리만 가능
# datas = (twoNums + list(11)) #List끼리만 가능
# print(list(11))
# print(datas)

# 멤버 연산 => in / not in ----------------------------------------
#         => 결과 : True / False
print(datas)
print("C" in datas)
print(2 in datas)

ex_list_03.py

# ------------------------------------------------------------
# List의 원소/요소 데이터 변경 및 삭제
# ------------------------------------------------------------
# "Merry Christmas"의 문자 1개 1개를 원소로 가지는 리스트로 생성하기

MC = list("Merry Christmas")
print(f'MC => {MC}')

# => ' ' 데이터를 '***'로 변경하기
# MC_space = MC[5]
print(f'MC[5] => {MC[5]}')
MC[5] = '***'
print(f'MC[5] => {MC[5]}')
print(f'MC => {MC}')        #list는 각 문자마다 코드값이 있기 때문에 부분 할당이 가능함

# 삭제(명령어임, 함수X) ==> del 데이터 또는 del(데이터)--------------------
del MC[5]
print(f'MC[5] => {MC[5]}')
print(f'MC => {MC}')

del (MC[5])
print(f'MC[5] => {MC[5]}')
print(f'MC => {MC}')

del MC
# print(MC)

오늘의 질문

  1. 파이썬에서 빌트인함수와 클래스의 역할은 아직 체감이 안되는데 왜 함수와 클래스를 구분하는지

    • 함수는 전체에서 이용가능하고, 클래스는 “.”이 있어야 실행가능한 차이가 있음
    • 파이썬은 전부 클래스화 되어있어서 그런것

  2. endswith()에서 (””)와 ((””))의 차이

print("flower.png??".endswith(("jpg","png","txt"))

튜플로 ("jpg","png","txt")를 하나로 묶어준 것, 튜플은 다음에
  1. nums[3][1]과 (nums[3])[1]의 차이
    • nums[3][1]과 (nums[3])[1]는 같은 방식으로 표기되지만 앞이 알아보기 쉽기 때문에 전자를 사용하지만 후자는 nums[3]를 새로운 변수로 지정하고 사용할 일이 많을 경우는 후자를 새로운 변수로 사용

연습만이 살 길이다!

  • 주말에 10강까지 전체 복습하기

화요일에 튜플, 딕셔너리, 셋까지 자료형 마무리할 예정

profile
빨강
갈림길인 줄 알았는데 알고보니 직진
이전 포스트

12/28 Python 3일차

다음 포스트

01/02 Python 5일차

0개의 댓글