1. 리스트와 for 문

li1 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

for i in li1:
  print(i, end = " ")
더보기
푸바오 아이바오 러바오 루이바오 후이바오
# score 리스트에 저장된 점수가 60점 이상인 학생이 몇명인지 확인
score = [90, 30, 50, 60, 80, 70, 100, 40, 20, 10]
count = 0
for i in score:
  if i >= 60 :
    count = count + 1
    print(f'{i}점')
print(f'60점 이상인 학생의 수는 {count}명 입니다.')
더보기
90점
60점
80점
70점
100점
60점 이상인 학생의 수는 5명 입니다.

 

2. 딕셔너리와 for 문

dic1 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}

for i in dic1:
    print(i, end=' ') # 키만 가져옴
    
for i in dic1.keys():
    print(i, end=' ') # 키만 가져옴

for i in dic1.values():
    print(i, end=' ') # 값만 가져옴

for i in dic1:
    print(dic1[i], end=' ') # 값만 가져옴

for i in dic1:
    print(dic1.get(i), end=' ') # 값만 가져옴

 

'''
.items() 메서드는 딕셔너리에서 사용되는 메서드입니다.
이 메서드는 딕셔너리의 키와 값을 쌍으로 하는 튜플들을 반환합니다.
일반적으로 이 메서드는 딕셔너리의 키와 값을 동시에 반복(iterate)하고자 할 때 사용됩니다.

'''

person = {'name' : '푸바오', 'age' : 3, 'city' : '용인'}

for key, value in person.items():
  print(key, ':', value) #튜플을 key와 value로 나누었다고 할 수있음.
더보기
name : 푸바오
age : 3
city : 용인

 

 

 

3. 컴프리헨션(Comprehension)

컴프리헨션(Comprehension) 파이썬에서 리스트, 세트, 딕셔너리 등의 컬렉션을 간단하게 생성하거나 변형하는 방법  하나입니다. 컴프리헨션은 반복문과 조건문을 사용하여 간결하게 컬렉션을 생성하는 기법으로, 코드를  간단하고 가독성 좋게 작성할  있도록 도와줍니다.

 

 

 

3-1. 리스트 컴프리헨션

리스트 컴프리헨션은 새로운 리스트를 생성하는데 사용됩니다. 기존 리스트의  요소를 반복하면서 조건을 적용하여 새로운 리스트를 생성할  있습니다.

 

n = 10
result = [0 for i in range(n)]
print(result)

result = [i for i in range(n)]
print(result)
#arr 리스트에서 n을 뽑아 n을 출력
더보기
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = [n for n in arr]
print(result)

result = [n*n for n in arr]
print(result)
#arr 리스트에서 n을 뽑아 n 요소들끼리 서로 곱하여 출력
더보기
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

arr = ['푸바오', '아이바오', '러바오', '죽순']
result = [len(string) for string in arr]
print(result)
#arr 리스트에서 string을 뽑아 string의 len출력
더보기
[3, 4, 3, 2]
result = [n for n in range(10) if  n%2 == 0]
print(result)
# range(10) 에서 만약 2로 나누었을때 0으로 떨어지는 값을 n으로 뽑아 출력
# 조건식 n%2 ==0 가 앞으로 갈 경우 False일때 값을 내보낼 수가 없음.
더보기
[0, 2, 4, 6, 8]

 

# 양수는 리스트에 그대로 저장하고, 음수는 0으로 변환해서 저장하기
arr = [-1, 0, -4, 24, 5, -10, 2]
result = [n if n>0 else 0 for n in arr]
print(result)
더보기
[0, 0, 0, 24, 5, 0, 2]

 

arr = []
for i in range(1, 4):
  for j in range(1,3):
    arr.append(f'{i} * {j} = {i*j}')
print(arr)
더보기
['1 * 1 = 1', '1 * 2 = 2', '2 * 1 = 2', '2 * 2 = 4', '3 * 1 = 3', '3 * 2 = 6']
# 1.아래의 list에서 양수만 추출한 뒤 새로운 리스트에 담기
number_list = [10, 20, 30, -20, -3, 50, -70]
result_list = []
result_list = [number for number in number_list if number >0]
print(result_list)
# 
# number을 가져올건데 in number_list에서 가져올 것이다.
# 양수만 가져올 조건은 맨 뒤 입력 if 만약에 number>0보다 큰가?


#2. n개의 0으로만 채워진 list
message = '생성할 리스트의 칸 수 입력 : '
n = int(input(message))
zero_list = [0 for _ in range(n)]
print(zero_list)

# zero_list = [0] * n

#3. 제곱의 결과가 10보다 큰 결과만 담은 list
number_list = [1, -2, 3, -4, 5]
sq_list = [number for number in number_list if number**2> 10]
print(sq_list)
# number_list에서 number에 값을 하나하나 담고 number를 제곱했을때 10보다 크면 그때 number을 가져옴


#4.  0~9까지 중 3의 배수만 담은 list
number_list4 = [num for num in range(10) if num % 3 == 0]
print(number_list4)
# range(10)에서 num에 값을 담고 num을 3으로 나누었을때 0 이 나오는 값을 num에 담음
'''
arr = []
for i in range(1, 4):
  for j in range(1,3):
    arr.append(f'{i} * {j} = {i*j}')
print(arr)
'''

# 위의 식을 리스트 컴프리헨션으로 만들기
result = [i*j for i in range(1, 4) for j in range(1, 3)]
print(result)
더보기
[1, 2, 2, 4, 3, 6]

 

 

 

3-2. 세트 컴프리헨션

numbers = [1, 2, 3, 4, 5, 2, 3, 4]
unique_numbers = {x for x in numbers} #세트는 중복 제거
print(unique_numbers)
더보기
{1, 2, 3, 4, 5}

 

3-3 딕셔너리 컴프리헨션

names = ['푸바오', '아이바오', '러바오']
name_lengths = {name : len(name) for name in names} # 딕셔너리 키:값 처럼 출력 names에서 요소를 가져온 후 조건에 맞게 출력
print(name_lengths)
더보기
{'푸바오': 3, '아이바오': 4, '러바오': 3}

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

13. 변수의 범위  (1) 2023.12.11
12. 사용자 정의 함수  (1) 2023.12.10
10. 제어문 - 반복문  (1) 2023.12.10
9. 제어문 - 조건문  (2) 2023.12.08
8. 파이썬 연산자  (2) 2023.12.08

1. 반복문

반복문은 동일한 작업을 여러 번 실행하기 위해 사용되는 제어 구조입니다. 주로 for 문과 while 문이 사용되며, 각각의 반복문은 다른 상황에 적합한 방식으로 사용됩니다.

 

2. while 문

while 문은 특정 조건이 참인 동안 반복적으로 코드 블록을 실행하는 제어 구조입니다. while 문은 주어진 조건이 참인 동안 반복적으로 코드를 실행하며, 조건이 거짓이 되면 반복을 멈춥니다.

while 조건:
    # 조건이 참인 동안 실행될 코드

 

 

 

 

# while 문을 사용할 때 주의 사항

  • 무한 루프: 만약 while 문의 조건이 항상 참이라면 코드가 무한 루프에 빠질 수 있습니다. 프로그램이 의도대로 종료되지 않는 상황을 방지하기 위해 조건을 제대로 설정해야 합니다.
  • 조건 변경: while 문 내에서 조건을 변경해야 루프가 종료되는 경우도 있습니다. 그렇지 않으면 무한 루프에 빠질 수 있습니다.
  • 끝 조건: 반복이 더 이상 필요하지 않을 때 while 문을 종료하는 조건을 명확하게 설정해야 합니다.
  • 적절한 초기화: 반복 변수나 조건을 사용하기 전에 적절하게 초기화해야 합니다.
i = 1

while i <= 5:
  print('Hello Python')  # 무한 루프
i = 1

while i <= 5:
  print('Hello Python')
  i += 1
더보기
Hello Python
Hello Python
Hello Python
Hello Python
Hello Python

 

# 1부터 10까지 총합
i = 1
sum = 0
while i <= 10 :
  sum += i
  '''
  sum + i = sum
    0 += 1 -> 1
    1 += 2 -> 3
    3 += 3 -> 6
    6 += 4 -> 10
    10 += 5 -> 15
    15 += 6 -> 21
    21 += 7 -> 28
    28 += 8 -> 36
    36 += 9 -> 45
    45 += 10 -> 55
  '''
  i += 1
print(f'1부터 10까지의 합 : {sum}')
# 1부터 100까지 짝수의 합 #1
i = 0
sum = 0

while i <= 100:
  sum += i
  i = i + 2
print(f'1 부터 100까지의 짝수 합 : {sum}')



# 1부터 100까지 짝수의 합 #2
i = 1
sum = 0

while i <= 100:
  if  i % 2 == 0 :
    sum += i
  i += 1
print(f'1 부터 100까지의 짝수 합 : {sum}')
더보기
1 부터 100까지의 짝수 합 : 2550
1 부터 100까지의 짝수 합 : 2550
# 원하는 구구단을 입력받아 해당 단의 구구단을 출력
dan = int(input('원하는 단을 입력하세요 : '))
print(f'{dan} 단')

# 6 * 1 = 6
# 6 * 2 = 12
i = 1
while i <= 9:
  print(f'{dan} * {i} = {dan * i}')
  i += 1
더보기
원하는 단을 입력하세요 : 9
9 단
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81

 

 

 

3. for 문

for 문은 시퀀스(리스트, 튜플, 문자열 등)의 각 항목에 대해 반복 작업을 수행하는 반복문입니다.

for 문은 주로 "지정된 범위 내에서 반복"할 때 사용됩니다. 이것은 반복할 요소들이 미리 정해져 있는 경우에 유용합니다.

 
for 요소 in 시퀀스:
    # 요소에 대한 작업 수행

 

 

 
list1 = [10, 20, 30, 40]

for li in list1 :
  print(li)
더보기
10
20
30
40

 

4. range() 함수

range() 함수는 파이썬에서 순차적인 정수의 시퀀스를 생성하는 데 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 일정한 범위 내에서 반복 작업을 수행할 때 유용하게 활용됩니다. range() 함수의 결과로 생성되는 순차적인 정수 시퀀스는 실제로 메모리에 저장되지 않고 필요할 때마다 생성되므로, 큰 범위의 반복문에도 효율적으로 사용할 수 있습니다.

 

range([start], stop, [step])

 

start (선택 사항): 순차적인 범위의 시작 값을 지정합니다. 기본값은 0입니다.
stop: 순차적인 범위의 끝 값을 지정합니다. 생성된 시퀀스는 stop 값 직전까지의 정수를 포함합니다.
step (선택 사항): 순차적인 값을 증가시키는 간격을 지정합니다. 기본값은 1입니다.

 

 

num = range(0, 10, 1)
print(num)

for i in num:
  print( i, end = ' ')
더보기
range(0, 10)
0 1 2 3 4 5 6 7 8 9
for i in range(0, 10, 1):
    print(i, end=' ')
    
for i in range(0, 10):
    print(i, end=' ')

for i in range(10):
    print(i, end=' ')
    
for i in range(1, 10, 2):
    print(i, end=' ')
더보기
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
2 4 6 8
# for문을 이용하여 1부터 100까지 짝수의 총합 구하기
sum = 0
for i in range(0,101,2):
  sum += i
print(f'1부터 100까지의 짝수의 총합 : {sum}')
더보기
1부터 100까지의 짝수의 총합 : 2550

 

 

5. enumerate() 함수

enumerate() 함수는 파이썬에서 반복문을 사용할 때 인덱스와 값을 함께 가져오기 위해 사용되는 내장 함수입니다. 주로 for 문과 함께 사용되며, 반복문 내에서 순서를 추적하면서 값과 해당 값의 인덱스를 함께 사용할 때 유용합니다. enumerate() 함수는 (인덱스, 값)의 튜플을 반환하는 이터레이터(iterator)를 생성합니다.

enumerate(iterable, start=0)

iterable: 반복 가능한 객체(리스트, 튜플, 문자열 등)를 지정합니다.
start (선택 사항): 인덱스의 시작 값을 지정합니다. 기본값은 0입니다.
enumerate() 함수는 (인덱스, 값) 형태의 튜플을 생성하여 이터레이터를 반환합니다. 이를 for 문과 함께 사용하여 인덱스와 값을 동시에 가져와 처리할 수 있습니다.

 

li1 = [10, 20, 30, 40, 50]
for e in enumerate(li1):
  print(e)
더보기
(0, 10)
(1, 20)
(2, 30)
(3, 40)
(4, 50)
li1 = [10, 20, 30, 40, 50]
for i, v in enumerate(li1):
  print(f'index:{i}, value:{v}')
더보기
index:0, value:10
index:1, value:20
index:2, value:30
index:3, value:40
index:4, value:50

 

6. zip() 함수

zip() 함수는 파이썬에서 여러 개의 반복 가능한(iterable) 객체를 병렬적으로 묶어주는 내장 함수입니다. 각 객체로부터 순서대로 하나의 요소씩 가져와 튜플로 묶어주는 이터레이터를 반환합니다. 주로 여러 개의 리스트나 튜플을 병렬적으로 처리하고자 할 때 사용됩니다.

zip(iterable1, iterable2, ...)

iterable1, iterable2, ...: 병렬적으로 묶을 반복 가능한 객체들을 지정합니다. 여러 개의 인자로 전달할  있습니다.

 

#len은 쌍 개수가 맞지 않을 경우 오류가 발생
li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for i in range(len(li1)):
    print(li1[i], li2[i])
더보기
10 apple
20 banana
30 orange

 

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for l1, l2 in zip(li1, li2):
  print(l1, l2)
더보기
10 apple
20 banana
30 orange

 

li1 = [10, 20, 30, 40] #4개
li2 = ['apple', 'banana', 'orange'] #3개

# 반복 3바퀴만 실행 : 돌 수 있는 만큼만 돔
for l1, l2 in zip(li1, li2):
    print(l1, l2)
더보기
10 apple
20 banana
30 orange

 

li1 = [10, 20, 30]
li2 = ['apple', 'banana', 'orange']

for li in zip(li1, li2):
    print(li)
더보기
(10, 'apple')
(20, 'banana')
(30, 'orange')

 

for n, A, a in zip('12345','ABCDE','abcde'):
  print(n,A,a)
더보기
1 A a
2 B b
3 C c
4 D d
5 E e

 

 

 

7. 중첩 반복문

파이썬에서 중첩된 반복문은 하나의 반복문 안에 다른 반복문이 포함된 구조를 의미합니다. 중첩 반복문은 외부 반복문의 각 반복마다 내부 반복문이 모두 실행되는 방식으로 작동합니다. 이를 통해 다차원의 데이터를 처리하거나 복잡한 작업을 수행할 수 있습니다.

for 외부_변수 in 외부_시퀀스:
    for 내부_변수 in 내부_시퀀스:
        # 내부 반복문 코드
    # 외부 반복문 코드
  • 외부_변수: 외부 반복문의 현재 요소를 나타내는 변수입니다.
  • 외부_시퀀스: 외부 반복문에서 순회할 반복 가능한 객체(리스트, 튜플 등)입니다.
  • 내부_변수: 내부 반복문의 현재 요소를 나타내는 변수입니다.
  • 내부_시퀀스: 내부 반복문에서 순회할 반복 가능한 객체입니다.

 

for i in range(1, 4):
  print(f'푸바오 i : {i}')
  for j in range(1, 4):
    print(f'🐼 j : {j}')
더보기
푸바오 i : 1
🐼 j : 1
🐼 j : 2
🐼 j : 3
푸바오 i : 2
🐼 j : 1
🐼 j : 2
🐼 j : 3
푸바오 i : 3
🐼 j : 1
🐼 j : 2
🐼 j : 3

 

for i in range(5):
  print('가')
  for j in range(i, 5): #step생략
    print('🐼', end = "")
  print()
더보기
# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
🐼🐼🐼🐼🐼
'''

for i in range(5):
  for j in range(5):
    print('🐼', end = '')
  print()
# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼🐼🐼🐼🐼
🐼🐼🐼🐼
🐼🐼🐼
🐼🐼
🐼
'''

for i in range(5):
  for j in range(i, 5): #i가 하나씩 커지므로 출력되는 🐼가 하나씩 줄어듬
    print('🐼', end = '')
  print()
# '🐼'를 이용하여 아래와 같은 도형을 만들어보자
'''
🐼
🐼🐼
🐼🐼🐼
🐼🐼🐼🐼
🐼🐼🐼🐼🐼
'''

for i in range(1,6):
  for j in range(i):
    print('🐼', end = '')
  print()
  
  
for i in range(5):
  for j in range(0, i+1):
    print('🐼', end = '')
  print()
### 문제
#* 2단부터 9단까지 구구단을 출력하는 프로그램을 작성
for i in range(1, 10):
  print(f'{i}단')
  for j in range(1, 10):
   print(f'{i} * {j} = {i*j}')
#while문
i = 2
j = 1

while i <= 9:
  print(f'{i} 단')
  while j <= 9:
    print(f'{i} * {j} = {i*j}')
    j += 1
  i += 1
  j = 1 # j = 1 이라는 세팅을 해주어야 반복문이 다시 돌때 j가 초기화 됨

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

12. 사용자 정의 함수  (1) 2023.12.10
11. 컬렉션과 반복문  (1) 2023.12.10
9. 제어문 - 조건문  (2) 2023.12.08
8. 파이썬 연산자  (2) 2023.12.08
7. 파이썬 컬렉션 타입 - 딕셔너리  (1) 2023.12.08

1. 조건문

조건문은 코드의 실행 흐름을 제어하기 위해 사용하는 구문입니다. 이 조건문은 주어진 조건이 참인지 거짓인지에 따라 다른 코드를 실행하게 합니다.

 

2. if 문

가장 기본적인 조건문입니다. 특정 조건이 참(True)일 경우에만 해당 블록 내의 코드가 실행됩니다.

if 조건:
    실행할 코드

 

bool1 = True

if bool1 :
    print('결과는 참입니다.')
print('프로그램을 종료합니다.')
더보기
결과는 참입니다.
프로그램을 종료합니다.

 

 

bool2 = False

if bool2:
    print('결과는 참입니다.')
print('프로그램을 종료합니다.')
더보기
프로그램을 종료합니다

 

age = int(input('나이를 입력하세요 '))

if age > 19 :
  print("성인입니다")
print("입력한 나이 : ", age)
더보기
나이를 입력하세요 2
입력한 나이 :  2

 

 

age = int(input('나이를 입력하세요 '))

if age > 19 :
  print("성인입니다")
  print("성인 영화 감상 가능")
print("입력한 나이 : ", age)
더보기
나이를 입력하세요 20
성인입니다
성인 영화 감상 가능
입력한 나이 :  20

 

 

3. else 문

else는 파이썬의 조건문 구조에서 if와 elif 조건들이 모두 거짓으로 평가될 경우 실행되는 부분을 정의하는 데 사용됩니다. else는 선택적으로 사용될 수 있으며, 그 자체로는 어떤 조건을 갖지 않습니다. 다시 말해, else 블록은 위의 if와 elif 조건들이 모두 만족되지 않는 경우에만 실행됩니다.

if 조건1:
    코드 블록1
elif 조걸2:
    코드 블록2
else:
    코드 블록3

 

 

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인입니다.')
else:
    print('미성년입니다.')

print('입력한 나이: ', age)
더보기
나이를 입력하세요: 20
성인입니다.
입력한 나이:  20

 

age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인입니다.')
    print('성인영화 감상가능')
else:
    print('미성년입니다.')
    print("잠이나 자세영")

print('입력한 나이: ', age)
더보기
나이를 입력하세요: 20
성인입니다.
성인영화 감상가능
입력한 나이:  20

 

 

4. elif 문

elif는 if-else 구조에서 추가적인 조건을 검사하기 위해 사용되는 키워드입니다. elif는 "else if"의 줄임말이며, 주어진 여러 조건 중에서 하나만 참일 때 실행되는 코드 블록을 정의합니다.

if 조건1:
    코드 블록1
elif. 조건2:
    코드 블록2
elif. 조건3:
    코드 블록3
else:
    코드 블록4
  • elif는 if 없이 단독으로 사용될 수 없습니다.
  • elif는 필요에 따라 여러 번 사용될 수 있습니다.
  • else는 선택적입니다. 사용될 경우, 항상 if나 elif 뒤에 나타나야 합니다.
age = int(input('나이를 입력하세요: '))

if age > 19:
    print('성인')
elif age > 14:
    print('청소년')
elif age > 6:
    print('어린이')
elif age > 0:
    print('유아')
else:
    print('입력 확인')

print('입력한 나이: ', age)
더보기
나이를 입력하세요: 21
성인
입력한 나이:  21

 

 

5. 조건부 표현식(Conditional Expression)

조건부 표현식은 파이썬에서 삼항연산자라고도 불립니다. 간단한 if-else 구문을 더 간결하게 표현할 수 있는 방법을 제공합니다.

조건이 참인 경우 값 if condition else 조건이 거짓인 경우 값

 

num = int(input('숫자를 입력하세요: '))

if num % 2 == 0:
    print('짝수')
else:
    print('홀수')
더보기
숫자를 입력하세요 : 20
짝수

 

num = int(input('숫자를 입력하세요: '))

print('짝수') if num % 2 == 0 else print('홀수')
더보기
숫자를 입력하세요 : 20
짝수

 

 

# 로그인 프로그램 만들기

# 아이디 : admin, 비밀번호 : 1234

# 로그인 프로그램 만들기
# 아이디 : admin, 비밀번호 : 1234
userid = input('아이디를 입력하세요 : ')
userpw = input('비밀번호를 입력하세요 : ')

if userid == 'admin' and userpw == '1234':
    print('로그인 되었습니다.')
else:
    print('아이디 또는 비밀번호를 확인하세요.')

 

#  주민등록번호에 의한 성별을 판별하는 프로그램 만들기
# 0010113068518

# 주민등록번호에 의한 성별을 판별하는 프로그램 만들기
# 0010113068518
userid = input('주민등록번호를 입력하세요 :')

if userid[7] == '1' or  userid[7] == '3' or userid[7] == '5' or  userid[7] =='7' or  userid[7] =='9' :
  print('남자')
else:
  print('여자')

 

 

문제

  • 국어, 영어, 수학점수를 입력받아 총점, 평균, 학점을 구하는 프로그램을 작성해보자
  • 단, 학점은 평균 기준으로 90점 이상은 A, 80점 이상은B, 70점이상은 C, 60점 이상은 D, 나머지는 F
kor, eng, math = input('국어 영어 수학').split('/')
all = (f'총점: {int(kor) + int(eng) + int(math)}')
av = (int(kor) + int(eng) + int(math))/3

if av >= 90:
  grade = ('A')
elif av >= 80:
  grade = ('B')
elif av >= 70:
  grade = ('C')
elif av >= 60:
  grade = ('D')
else:
  grade = ('F')

print('총점 : ', all, '평균 : ', av, '학점 : ', grade)

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

11. 컬렉션과 반복문  (1) 2023.12.10
10. 제어문 - 반복문  (1) 2023.12.10
8. 파이썬 연산자  (2) 2023.12.08
7. 파이썬 컬렉션 타입 - 딕셔너리  (1) 2023.12.08
6. 파이썬 컬렉션 타입 - 세트  (0) 2023.12.07

1. 산술 연산자

산술 연산자는 주로 수치 데이터 유형에 대한 기본 산술 연산을 수행하기 위해 사용됩니다.

  • + : 더하기
  • - : 빼기
  • : 곱하기
  • / : 나누기
  • //: 몫 (정수 나누기)
  • % : 나머지
  • **: 지수 (거듭제곱)
print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(10 ** 3)
더보기
13
7
30
3.3333333333333335
3
1
1000

2. 비교 연산자

비교 연산자는 주로 두 값을 비교하는 데 사용되며, 그 결과는 항상 불리언(True 또는 False) 값입니다.

  • ==: 동등
  • !=: 동등하지 않음
  • < : 작다
  • <=: 작거나 같다
  • > : 크다
  • >=: 크거나 같다
print(10 > 5)
print(10 < 5)
print(10 >= 5)
print(10 <= 5)
print(10 == 5)
print(10 != 5)
더보기
True
False
True
False
False
True

 

3. 할당 연산자

변수에 값을 할당하는데 사용됩니다. 파이썬에서는 기본 할당 연산자 외에도 복합 할당 연산자를 제공하여 코드를 간결하게 작성할 수 있게 도와줍니다.

  • = : 할당
  • += : 더하기 후 할당
  • -= : 빼기 후 할당
  • *= : 곱하기 후 할당
  • /= : 나누기 후 할당
  • //=: 몫 후 할당
  • %= : 나머지 후 할당
  • **=: 지수  할당
num = 10

num += 1 #num = num + 1
print(num)

num -= 1
print(num) # num = num - 1

num *= 10
print(num)

num /= 10
print(num)

num %= 2
print(num)
더보기
11

10

100

10.0

0.0

 

4. 비트 연산자

비트 연산자는 정수를 이진 비트로 표현했을  사용하는 연산자들입니다.  연산자는 정수의 비트 단위로 동작합니다.

  • & : 비트 단위 AND
  • | : 비트 단위 OR
  • ^ : 비트 단위 XOR
  • ~ : 비트 단위 NOT
  • << : 왼쪽 시프트
  • >> : 오른쪽 시프트
a = 60  # 111100
b = 13  # 001101
print(a & b)  # 12, 즉 1100

print(a | b)  # 61, 즉 111101

print(a ^ b)  # 49, 즉 110001

print(~a)  # -61, 이 결과는 2의 보수 방식 때문입니다.

print(a << 2)  # 240, 즉 11110000

print(a >> 2)  # 15, 즉 1111
더보기
12
61
49
-61
240
15
print(a & b) # and)
print(a | b) # or
print(a ^ b) # XOR
더보기
12
61
49

 

5. 논리 연산자

파이썬에서의 논리 연산자는 주로 불린(Boolean) 값을 조작하기 위해 사용됩니다. 그러나 파이썬의 논리 연산자는 다른 언어와는 다르게, 연산의 결과로 항상 True 또는 False만을 반환하는 것은 아닙니다. 대신 마지막으로 평가된 피연산자의 값을 반환합니다.

  • and: 논리 AND
  • or : 논리 OR
  • not: 논리 NOT
# and
print(True and 3)       # 3
print(3 and 5)         # 5
print(0 and 5)         # 0

# or
print(False or 3)      # 3
print(3 or 5)          # 3
print(0 or 5)          # 5

# not
print(not True)        # False
print(not 0)           # True
print(not 3)           # False
더보기
3
5
0
3
3
5
False
True
False

 

 

6. 멤버 연산자

좌항이 우항에 포함되었다면 True 아니면 False

print("a" in "abc")	#True
print(2 in [1, 2, 3])	#True

 

 

좌항이 우항에 포함되어 있지 않다면 True 포함되면 False

print("a" not in "abc") #False
print(2 not in [1, 2, 3]) #False

 

7. 식별 연산자

 

두 객체 모두 같은 주소일 경우 True 아니면 False

#두 객체 모두 같은 주소일 경우 True 아니면 False
a = 10
b = a
print(a is b) #True

 

두 객체 모두 같은 주소일 경우 True 아니면 False

# 두 객체 모두 같은 주소일 경우 True 아니면 False
a = [1, 2, 3]
b = [1, 2, 3]
print(a is not b) #True

# a와 b는 주소가 다르다.
# is not을 사용하여 True가 발생

 

 

 

데이터의 크기를 나타내는 용량 단위

  • Bit: 가장 기본적인 데이터 단위로, 0 또는 1 값을 가질  있습니다.
  • Byte (B): 8 bits 동일합니다.
  • Kilobyte (KB): 1 KB = 1,024 Bytes
  • Megabyte (MB): 1 MB = 1,024 KB 
  • Gigabyte (GB): 1 GB = 1,024 MB
  • Terabyte (TB): 1 TB = 1,024 GB

※ 파이썬에서 불린(Boolean)으로 평가되는 주요 값

1. True로 평가되는 주요 값

  • Boolean: True
  • 모든 음이 아닌 숫자: 예를 들어, -1, 1, 3.5 등 (단, 0 제외)
  • 문자열과 바이트 문자열: 예를 들어, 'hello', "world", b'hello' (단, 빈 문자열 '' 및 b'' 제외)
  • 모든 리스트, 튜플, 세트, 딕셔너리: 예를 들어, [1, 2], {'key': 'value'} 등 (단, 빈 컨테이너 제외)

2. False로 평가되는 주요 값

  • Boolean: False
  • 숫자: 0 (정수, 부동 소수점, 복소수 포함)
  • 문자열: 빈 문자열 '' 및 빈 바이트 문자열 b''
  • 리스트, 튜플, 세트: 빈 리스트 [], 빈 튜플 (), 빈 세트 set()
  • 딕셔너리: 빈 딕셔너리 {}
  • None: 파이썬의 None 객체도 False 평가됩니다.

1. 딕셔너리

파이썬의 딕셔너리는 - 쌍을 저장하는 변경 가능한(mutable) 컬렉션입니다.

 

요약

dict(딕셔너리)
        한 쌍으로 저장되어 관리한다.
        len()를 사용하면 한 쌍을 1로 카운트한다.
        * 키 -  중복 불가능
        * 값 - 중복 가능
        키 값을 주면 그 키의 값을 가지고 온다.

        # 키  해시테이블 값
        # 키로 정보를 요청하면 해시테이블이 값을 찾아와준다.

dict 선언
        dict명{키: 값, 키: 값, 키: 값, ...}

dict 사용
        -추가, 수정
            : 추가와 수정이 동일한 코드이다.
            dict명[키] = 값
            키 값이 기존에 있으면 수정이고, 기존에 없으면 추가이다.
        -삭제
            del dict명[키]

        -검사
            키 in dict명 : 키가 있으면 참
            키 not in dict명 : 키가 없으면 참

 


 

1. 생성

딕셔너리는 중괄호 {} 사용하여 생성하고, - 쌍들은 쉼표 , 구분됩니다.  - 쌍은 콜론 :으로 구분됩니다.

  • 키는 중복 불가능 (set)와 비슷
  • 값은 중복 가능 (dict)과 비슷
dict 선언
        dict명{키: 값, 키: 값, 키: 값, ...}
dic1 = {}
print(dic1)
print(type(dic1))

dic2 = {1: '푸바오', 2: '아이바오', 3: '러바오', 4: '루이바오'}
print(dic2)
print(dic2[2]) # 딕셔너리에서는 대괄호 안에는 키가 들어가야함 => 값(value) 출력
print(dic2[3])

dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'} # 키는 중복x 문자 및 숫자도 가능
print(dic3)
print(dic3['no'])
print(dic3['name'])
더보기

{}

<class 'dict'>

 

{1: '푸바오', 2: '아이바오', 3: '러바오', 4: '루이바오'}

아이바오

러바오

 

{'no': 1, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111'}

1

푸바오

 

 

 

2. 추가 및 수정 (변경가능)

  • 딕셔너리는 변경 가능합니다. 
  • 따라서, 딕셔너리에 키-값 쌍을 추가하거나 제거하거나, 기존의 키의 값을 변경할 수 있습니다.
dict 사용
-추가, 수정
** 추가와 수정이 동일한 코드이다.
            
            dict명[키] = 값 
            키 값이 기존에 있으면 수정이고, 기존에 없으면 추가이다.

 

# 데이터에 없는 키 값을 대괄호에 넣고 값을 입력하면 데이터가 추가된다. (데이터에 순서가 없다)

# 데이터에 없는 키 값을 대괄호에 넣고 값을 입력하면 데이터가 추가된다. (데이터에 순서가 없다)
dic4 = {1:'apple'}
print(dic4)

dic4[100] = 'banana'
print(dic4)

dic4[50] = 'orange'
print(dic4)

del dic4[100]
print(dic4)
더보기

{1: 'apple'}

{1: 'apple', 100: 'banana'}

{1: 'apple', 100: 'banana', 50: 'orange'}

{1: 'apple', 50: 'orange'}

 

# 존재하는 키 값에 새로운 값을 넣어주면 값이 대체된다.(수정된다)

# 존재하는 키 값에 새로운 값을 넣어주면 값이 대체된다.(수정된다)
dic5 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
dic5['no'] = 2
print(dic5)
더보기

{'no': 2, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111'}

 

 

3. 키, 값의 제약

  • 딕셔너리의 키는 변경 불가능한(immutable) 타입이어야 합니다.
  • 예를 들어, 문자열, 정수, 튜플은 딕셔너리의 키로 사용할 수 있지만, 리스트는 딕셔너리의 키로 사용할 수 없습니다. 하지만 딕셔너리의 값은 어떤 타입이든 상관없습니다.
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'} # 키는 중복x 문자 및 숫자도 가능
dic5['no'] = 2
print(dic5)

dic3['점수'] = [90, 100, 50] # 값에 리스트 추가
print(dic3)

dic3[(1,2,3)] = ('가','나','다') # 키(튜플) : 값(튜플 추가)
print(dic3)

#dic3[[1, 2, 3]] = ['라', '마', '바'] #키는 변경 불가능한(immutable) 타입. 리스트가 될 수 없다
#print(dic3)

dic3['과일'] = {'사과':'🍎', '딸기':'🍓', '앵두':'🍒'} # '과일' 키에 값:딕셔너리도 추가 가능
print(dic3)
더보기

{'no': 2, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111'}

{'no': 1, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111', '점수': [90, 100, 50]}

{'no': 1, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111', '점수': [90, 100, 50], (1, 2, 3): ('가', '나', '다')}

{'no': 1, 'userid': 'apple', 'name': '푸바오', 'hp': '010-1111-1111', '점수': [90, 100, 50], (1, 2, 3): ('가', '나', '다'), '과일': {'사과': '🍎', '딸기': '🍓', '앵두': '🍒'}}

 

4. 함수와 메서드

딕셔너리는 여러 함수와 메소드를 가지고 있습니다.

 

# len(): 딕셔너리의 길이(키-값 쌍의 개수)를 구할 수 있는 함수

# len(): 딕셔너리의 길이(키-값 쌍의 개수)를 구할 수 있는 함수
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(len(dic3)) # 키와 값이 하나의 쌍

 

# keys(): 딕셔너리의 모든 키를 반환하는 메서드

# keys(): 딕셔너리의 모든 키를 반환하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.keys()) # 키만 뽑아서 리스트로 출력
더보기

dict_keys(['no', 'userid', 'name', 'hp'])

 

# values(): 딕셔너리의 모든 값을 반환하는 메서드

# values(): 딕셔너리의 모든 값을 반환하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.values())
더보기

dict_values([1, 'apple', '푸바오', '010-1111-1111'])

 

# items(): 딕셔너리의 모든 키-값 쌍을 반환하는 메서드 (튜플로 반환)

# items(): 딕셔너리의 모든 키-값 쌍을 반환하는 메서드 (튜플로 반환)
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.items())
더보기

dict_items([('no', 1), ('userid', 'apple'), ('name', '푸바오'), ('hp', '010-1111-1111')])

 

# get(): 특정 키의 값을 반환. 만약 그 키가 딕셔너리에 없으면, None을 반환하는 메서드

# get(): 특정 키의 값을 반환. 만약 그 키가 딕셔너리에 없으면, None을 반환하는 메서드
print(dic3.get('userid'))
print(dic3.get('age'))
print(dic3.get('userid', '알 수 없음'))
print(dic3.get('age', '알 수 없음')) # get 사용시 존재하지 않는 키에 값을 입력하면 입력한 값이 출력


dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3['userid'])
#print(dic3['age']) # 딕셔너리에 존재하지 않는 키를 입력하면 에러 KeyError: 'age'
더보기

apple

None

apple

알 수 없음

 

apple

 

# pop(): 특정 키의 값을 제거하고 반환. 만약 그 키가 딕셔너리에 없으면, KeyError가 발생하는 메서드

# pop(): 특정 키의 값을 제거하고 반환. 만약 그 키가 딕셔너리에 없으면, KeyError가 발생하는 메서드
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print(dic3.pop('hp'))
print(dic3)
더보기

010-1111-1111

{'no': 1, 'userid': 'apple', 'name': '푸바오'}

 

 

5. 멤버십 테스트

in 연산자를 사용하여 딕셔너리 특정 키가 있는지 확인할  있습니다.

# in : 딕셔너리 안에 키 존재 여부 확인
dic3 = {'no':1, 'userid':'apple', 'name':'푸바오', 'hp':'010-1111-1111'}
print('hp' in dic3)
print('age' in dic3)
더보기

True

False

1. 세트

  • 세트(set)는 중복되지 않는 항목들의 컬렉션입니다.
  • 순서가 없다
  • 세트는 중괄호 {}를 사용 or set() 생성자를 사용
  • 중복을 제거할 때 효과적이다.
# 중복이 없고, 순서가 없다.
# 값이 있는지 없는지 검사
world_set = {'korea', 'america', 'japan', 'china'} # 중괄호에 값이 하나씩 연결되어 있으면 set

print(type(world_set)) # <class 'set'>
print(len(world_set)) # 4

#print(world_set[1]) # 오류 -> 순서가 없기때문에 데이터를 가져올 수 없다.

world_set.add('korea') # 중복된 값은 데이터에 추가되지 않는다.
print(world_set)    #{'china', 'korea', 'japan', 'america'}

# set의 데이터를 가져오는 방법
# 다른 구조로 형변환을 시킴
# print로 출력했을때 나오는 데이터 값은 set을 다른 자료구조로 가져온 다음 {}로 닫아준 것.

 

대부분 set은 중복제거 할 때 사용한다.

data = [1, 2, 3, 1, 1, 4, 4, 5]
print(list(set(data))) #[1, 2, 3, 4, 5]

 


 

1. 생성

세트는 중괄호 {} 사용하여 생성하거나 set() 생성자를 사용할  있습니다.

s1 = {} #빈 괄호를 넣으면 딕셔너리로 인식 따라서 값을 넣어야함 => 딕셔너리는 {키 : 값} 값을 쌍으로 저장
print(s1)
print(type(s1))
더보기

{}

<class 'dict'>

s1 = {1, 3, 5, 7} # 딕셔너리와 달리 값을 하나만 넣으면 세트
print(s1)
print(type(s1))
더보기

{1, 3, 5, 7}

<class 'set'>

li1 = [1, 3, 5, 7]
s2 = set(li1)
print(s2)
type(s2)
더보기
{1, 3, 5, 7}
set
s3 = {1, 3, 5, 3, 7, 9, 1}
print(s3) # 세트는 중복된 데이터가 제거된 채로 출력
더보기

{1, 3, 5, 7, 9}

 

 

2. 메소드

세트는 여러 메소드를 가지고 있습니다.

 

 

# add(): 세트에 항목을 추가하는 메서드

# add(): 세트에 항목을 추가하는 메서드
s1 = {100, 200}
s1.add(150) # set에 데이터 추가
print(s1)

s1.add(50) # set는 패턴생각 x 순서가 마음대로 지정됨
print(s1) # set는 순서가 없는 집합
더보기

{200, 100, 150}

{200, 50, 100, 150}

 

# update(): 세트에 여러 항목을 한번에 추가하는 메서드

# update(): 세트에 여러 항목을 한번에 추가하는 메서드
s1 = {100, 200}
s1.update([40,50,60,20])
print(s1) # 순서에 관계없이 데이터가 들어감
더보기

{100, 200, 40, 50, 20, 60}

 

# remove():  세트의 항목을 제거. 만약 그 항목이 세트에 없으면, KeyError가 발생

# remove():  세트의 항목을 제거. 만약 그 항목이 세트에 없으면, KeyError가 발생
s1 = {10, 20, 30}
s1.remove(20)
print(s1)
#s1.remove(20) #없는 데이터를 지우면 KeyEroor: 20
더보기

{10, 30}

 

# discard(): 세트의 항목을 제거. 제거할 항목이 없어도 에러가 발생하지 않음

# discard(): 세트의 항목을 제거. 제거할 항목이 없어도 에러가 발생하지 않음
s1 = {10, 20, 30}
print(s1)
s1.discard(30)
print(s1)
더보기

{10, 20, 30}

{10, 20}

 

# copy(): 세트를 복사
# s1과 s2의 메모리 주소는 다름

# copy(): 세트를 복사
# s1과 s2의 메모리 주소는 다름
s1 = {10, 20, 30}
s2 = s1.copy() # s2 = s1(X)
print(s1)
print(s2)
print(id(s1))
print(id(s2))
더보기

{10, 20, 30}

{10, 20, 30}

135381086399712

135381086400832

 

# union(): 두 세트의 합집합을 반환

# s1|s2 

# union(): 두 세트의 합집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}

#result1 = s1.union(s2) # s1 | s2
result1 = s1 | s2
print(result1)
더보기

{70, 40, 10, 50, 20, 60, 30}

 

# intersection(): 두 세트의 교집합을 반환

# s1 & s2

# intersection(): 두 세트의 교집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result2 = s1.intersection(s2)
result2 = s1 & s2
print(result2)
더보기

{40, 50, 30}

 

# difference(): 두 세트의 차집합을 반환

# s1 - s2

# difference(): 두 세트의 차집합을 반환
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result3 = s1.difference(s2)
result3 = s1 - s2
print(result3)
더보기

{10, 20}

 

# 대칭차집합 (합집합 - 교집합)

# s1 ^ s2

# 대칭차집합 (합집합 - 교집합)
s1 = {10, 20, 30, 40, 50}
s2 = {30, 40, 50, 60, 70}
#result4 = s1.symmetric_difference(s2)
result4 = s1 ^ s2
print(result4)
더보기

{20, 70, 10, 60}

1. 튜플

여러 가지 데이터 타입의 값을 저장할 수 있는, 변경 불가능(immutable)한 순서가 있는 컬렉션입니다.

(값을 바꿀 수 없음)

 

 

1. 생성

tu1 = (1,) # 요소를 튜플로 하나만 저장할 때는 끝에, 컴마를 넣어줌
print(tu1)
print(type(tu1)) #데이터에 컴마를 찍지 않고 숫자 하나만 입력할 경우 튜플이 아닌 숫자에 괄호를 입힌걸로 인식
더보기

(1,)

<class 'tuple'>

# 데이터 변경 불가
tu1[0] = 100 #TypeError: 'tuple' object does not support item assignment

 

 

tu2 = (1, 3, 5, 7)
print(tu2)
더보기

(1, 3, 5, 7)

tu3 = 1, 3, 5, 7
print(tu3)
print(type(tu3))
더보기

(1, 3, 5, 7)

<class 'tuple'>

tu4 = ('푸바오', '아이바오',('가','나','다'))
print(tu4)
print(tu4[0])
print(tu4[2][0])
print(type(tu4))
print(type(tu4[2]))
print(type(tu4[2][0]))
더보기

('푸바오', '아이바오', ('가', '나', '다'))

푸바오

<class 'tuple'>

<class 'tuple'>

<class 'str'>

tu5 = ('푸바오', '아이바오',['가','나','다'])
print(tu5)
print(tu5[2][0])
print(type(tu5))
print(type(tu5[2]))
print(type(tu5[2][0]))

#tu5[0] = '러바오' #튜플은 값 변경 불가 TypeError: 'tuple' object does not support item assignment
tu5[2][0] = '후이바오'
print(tu5)
더보기

('푸바오', '아이바오', ['가', '나', '다'])

<class 'tuple'>

<class 'list'>

<class 'str'>

('푸바오', '아이바오', ['후이바오', '나', '다'])

 

2. 인덱싱

tu1 = (1, 2, '푸바오', '러바오')
print(tu1[0])
print(tu1[-1])
더보기

1

러바오

 

3. 슬라이싱

tu1 = ( 1, 2,'푸바오', '러바오')
print(tu1[1:])
print(tu1[1:3])
더보기

(2, '푸바오', '러바오')

(2, '푸바오')

 

4. 연산

#튜플 간의 + 연산으로 리스트를 결합할 수 있고, * 연산으로 리스트를 반복할 수 있습니다.

tu1 = (10, 20, 30)
tu2 = (40, 50, 60)

print(tu1 + tu2)
print(tu2 + tu1)

tu1 = tu1 + (40, 50)
print(tu1)

print(tu1 * 3)
더보기

(10, 20, 30, 40, 50, 60)

(40, 50, 60, 10, 20, 30)

(10, 20, 30, 40, 50)

(10, 20, 30, 40, 50, 10, 20, 30, 40, 50, 10, 20, 30, 40, 50)

 

5. 언패킹

튜플의 항목들은 변수들에 할당될  있습니다. (리스트도 가능)

Lebao, Aibao = ('Fubao', 'Luibao')
print(Lebao)
print(Aibao)
더보기

Fubao

Luibao

 

6. 멤버십 테스트

in 연산자를 사용하여 튜플에 특정 값이 있는지 확인할  있습니다. (리스트도 가능)

print(2 in (2, 4, 6, 8, 10)) # 데이터 안에 2가 있다면 True 없다면 False
print(9 in (2, 4, 6, 8, 10))
더보기

True

False

 

7. 튜플의 정렬

튜플은 sort() 메서드를 제공하지 않습니다. sorted() 함수를 사용합니다.

tu1 = (1, 3, 2, 0)
tu1 = sorted(tu1) # sorted의 반환형은 리스트
print(tu1) #리스트로 출력
더보기

[0, 1, 2, 3]

 

8. 변환

튜플을 리스트로, 리스트를 튜플로 변환할 수 있습니다.

tu1 = (1, 2, 3, 4)
print(type(tu1))

# 튜플 -> 리스트 변환
li1 = list(tu1)
print(type(li1))

#리스트 -> 튜플 변환
tu2 = tuple(li1)
print(type(tu2))
더보기

<class 'tuple'>

<class 'list'>

<class 'tuple'>

 

 

2. input 함수

  • 사용자(개발자)에게 데이터를 입력받을 수 있는 함수
  • 데이터는 항상 문자형으로 입력됩니다.

 

 

# prompt: 선택 사항입니다. 사용자에게 입력을 유도하기 위한 메시지 또는 프롬프트를 나타내는 문자열입니다.

input([prompt])
name = input()
print(name)
더보기

류바옹

류바옹

 

name = input('이름 입력')
print(f'{name}님 안녕하세요')
더보기

이름 입력류딩

류딩님 안녕하세요

 

name, age, weight = '푸바오', 3, 100
print(name)
print(age)
print(weight)
더보기

푸바오

3

100

name, age, weight = input('이름, 나이, 체중을 차례대로 입력해주세요.').split(',') #푸바오,3,100 이런식으로 입력
print(name)
print(age)
print(weight)
더보기

이름, 나이, 체중을 차례대로 입력해주세요.

푸바오,3,100

푸바오

3

100

name = input('이름 입력 : ')
age = input('나이 입력 : ')
weight = input('무게 입력 : ')

print(name)
print(age)
print(weight)
더보기

이름 입력 : 푸바오

나이 입력 : 3

무게 입력 : 100

푸바오

3

100

 

num1 = input('첫번째 숫자를 입력하세요')
num2 = input('두번째 숫자를 입력하세요')
print('결과: ', num1 + num2) # str타입이므로 숫자가 이어서 나옴
더보기

첫번째 숫자를 입력하세요88

두번째 숫자를 입력하세요88

결과: 8888

 

# int(): 문자열을 숫자(정수)타입으로 변환

num1 = input('첫번째 숫자를 입력하세요 : ')
num2 = input('두번째 숫자를 입력하세요 : ')
print('결과: ', int(num1) + int(num2))
더보기

첫번째 숫자를 입력하세요 : 100

두번째 숫자를 입력하세요 : 100

결과: 200

 

 

문제

# 국어 영어 수학 점수를 한꺼번에 입력받아 총점과 평균을 구하는 프로그램을 작성

# 입력방법 : 100/80/85

 

 

# EX1

kor, eng, math = input('점수를 입력하세요 : ').split('/')
print('국어 : ',kor)
print('영어 : ',eng)
print('수학 : ',math)

all = (int(kor) + int(eng) +int(math))
av = all//3

print('총점 :' ,all)
print('평균 : ', av)
더보기

점수를 입력하세요 : 60/50/40

국어 : 60

영어 : 50

수학 : 40

총점 : 150

평균 : 50

 

# EX2

kor, eng, math = input('국어, 영어, 수학점수를 차례대로 입력하세요 ').split('/')
print(f'총점: {int(kor) + int(eng) + int(math)}')
print(f'평균: {(int(kor) + int(eng) + int(math))/3}')
print('평균: %.2f' % ((int(kor) + int(eng) + int(math))/3))
더보기

국어, 영어, 수학점수를 차례대로 입력하세요 50/60/40

총점: 150

평균: 50.0

평균: 50.00

1. 컬렉션 타입

여러 개의 데이터 항목을 하나의 단위로 관리할 수 있게 해주는 데이터 구조를 의미합니다. 이것은 여러 개의 데이터를 하나의 변수에 저장하고, 관리할 수 있게 해줍니다. 파이썬에서는 리스트, 튜플, 세트, 딕셔너리 등이 기본적인 컬렉션 타입에 속합니다.

 

 

2. 리스트

여러 값들을 하나의 변수에 저장하고 관리할 수 있게 해주는 순차적인 자료구조입니다.

(여러개의 저장공간이 나열되어 있는 것)

 

리스트의 사용 목적

1. 여러 번 선언하지 않고, 한번만 선언하기 위해 사용

2. 규칙성이 없는 값에 규칙성을 부여하기 위해 사용 (순서가 필요하면 리스트에 담는다.)

 

 

 

 

1. 생성

리스트는 대괄호 [ ] 사용하여 생성하며, 내부에 포함된  항목들은 쉼표로 구분됩니다.

list 선언
       list명 = [값, 값2, ...]                   # 어떤 값을 넣을 지 알 때
       list명 = [값] * 칸수                       # 값은 모르지만, 칸 수는 알 때
       list명 = []                              # 어떤 값인지도 모르고, 칸 수도 모를때
       list명 = list(range(start, end, step))

 

 

li1 =[1, 3, 5, 7, 9]
print(li1)
print(type(li1))
더보기

[1, 3, 5, 7, 9]

<class 'list'>

 

li2 = list([1, 3, 5, 7, 9])
print(li2)
print(type(li2))
더보기

[1, 3, 5, 7, 9]

<class 'list'>

 

li3 = ['푸바오', '아이바오', '러바오']
print(li3)
더보기

['푸바오', '아이바오', '러바오']

 

li4 = [1, 50.5, '푸바오', True]
print(li4)

print('=====리스트 안에 있는 개체들 타입 알기======')
print(type(li4[0]))
print(type(li4[1]))
print(type(li4[2]))
print(type(li4[3]))
더보기

[1, 50.5, '푸바오', True]

=====리스트 안에 있는 개체들 타입 알기======

<class 'int'>

<class 'float'>

<class 'str'>

<class 'bool'>

 

li1 = [1, 3, 5, 7, 9]
print(li1)
print(li1[0])
print(li1[-1])
print(li1[0] + li1[-1])
더보기

[1, 3, 5, 7, 9]

1

9

10

 

2. 인덱싱

리스트의  항목은 위치(인덱스) 가지고 있으며, 인덱스를 사용하여 접근할  있습니다. 인덱스는 0부터 시작합니다.

li2 = [1, 2, '파이썬', ['푸바오', '아이바오']] # 리스트 안에 리스트 : 2차원
print(li2)

print("======인덱싱=======")
print(li2[0])
print(li2[3])
print(li2[3][0])
더보기
[1, 2, '파이썬', ['푸바오', '아이바오']]
======인덱싱=======
1
['푸바오', '아이바오']
푸바오

 

li3 = ['푸바오', '아이바오', '러바오', ['🐼','🍎','⚽️','☕️']]
print(li3)
print(li3[-1])
print(li3[-1][2])
더보기

['푸바오', '아이바오', '러바오', ['🐼', '🍎', '⚽️', '☕️']]

['🐼', '🍎', '⚽️', '☕️']

⚽️

 

li4 = [1,2,3,['푸바오', '아이바오', '러바오', ['🐼','🍎','⚽️','☕️']]]
print(li4)
print("=======인덱싱=====")
print(li4[2])
print(li4[-2])
print(li4[-1][-2])
print(li4[-1][-1][-1])
더보기

[1, 2, 3, ['푸바오', '아이바오', '러바오', ['🐼', '🍎', '⚽️', '☕️']]]

=======인덱싱=====

3

3 러바오

☕️

 

3. 슬라이싱

리스트의 일부분만을 추출할  있습니다.

li1 = [10, 20, 30, 40 ,50]
print(li1)
print(li1[0:3]) # 인덱스 [0]부터 [2]까지 출력
더보기

[10, 20, 30, 40, 50]

[10, 20, 30]

 

 

인덱싱과 슬라이싱 주의점

  1. 인덱싱하면 차원 하나 벗겨짐
  2. 슬라이싱하면 차원 유지

 

 

4. 변경 가능

리스트의 항목들은 변경할  있습니다. , 리스트의 항목들을 수정, 추가, 삭제할  있습니다.

li2 = li1
print(li2)
li2[0] = 100 # [0]의 요소를 100으로 변경
print(li1)
print(li2)
더보기

[10, 20, 30, 40, 50]

[100, 20, 30, 40, 50]

[100, 20, 30, 40, 50]

 

li3 = [10, 20, 30,['푸바오', '아이바오', '러바오'], 40, ['🐼','🍎','⚽️','☕️']]
print(li3[2:6])

print(li3[5][:1])
더보기

[30, ['푸바오', '아이바오', '러바오'], 40, ['🐼', '🍎', '⚽️', '☕️']]

['🐼']

 

 

# 슬라이싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함

# 차원 유지

# 슬라이싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함
li4 = [10, 20, 30, 40, 50]
li4[1:2] = ['★','●','▲']
print(li4)
#차원 유지
더보기

[10, '★', '●', '▲', 30, 40, 50]

 

 

# 인덱싱을 이용하여 리스트 데이터를 추가한 경우 리스트에 데이터만 포함

# 차원 증가

# 인덱싱을 이용하여 리스트 데이터를 추가한 경우 리스트 안에 리스트를 포함
li4 = [10, 20, 30, 40, 50]
li4[1] = ['★','●','▲']
print(li4)
#차원 증가
더보기

[10, ['★', '●', '▲'], 30, 40, 50]

 

li5 = [10, 20, 30, 40, 50]
print(li5[1:3])
li5[1:3] = [] # 빈 리스트를 저장하면 요소가 삭제됨
print(li5)
del li5[2] # 변수 지우기 del
print(li5)
더보기

[20, 30]

[10, 40, 50]

[10, 40]

 

 

5. 연산

리스트 간의 + 연산으로 리스트를 결합할  있고, * 연산으로 리스트를 반복할  있습니다.

# 리스트 병합

#리스트 병합
li6 = [10, 20, 30]
li7 = [40, 50, 60]
print(li6 + li7)
print(li6[2] + li7[1])
더보기

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

80

 

li6 = [10, 20, 30]

# inplace 연산
# li6 = li6 + [100,200] # li6 += [40, 50]
li6 += [500,600]
print(li6)
더보기

[10, 20, 30, 500, 600]

 

li6 = [10, 20, 30]
print(li6 * 3)
print(li6[0] + li6[2])

li6[1] = '푸바오'
print(li6)
#print(li6[0] + li6[1]) # 같은 타입이 아니면 연산이 안됨 
#TypeError: unsupported operand type(s) for +: 'int' and 'str'
더보기

[10, 20, 30, 10, 20, 30, 10, 20, 30]

40

[10, '푸바오', 30]

 

 

 

6. 함수와 메서드

리스트를 다루기 위한 여러 함수와 메소드들이 있습니다.

# len(): 객체의 길이(항목의 개수)를 반한하는 내장 함수

# len(): 객체의 길이(항목의 개수)를 반한하는 내장 함수
print(len(li6))

 

# append(): 리스트에 사용되며, 리스트의 끝에 새로운 항목을 하나만 추가하는 메서드

# append(): 리스트에 사용되며, 리스트의 끝에 새로운 항목을 하나만 추가하는 메서드
li6= [10, 20, 30]
print(li6)

li6.append(40)
print(li6)
li6.append([200,300])
print(li6)
더보기

[10, 20, 30]

[10, 20, 30, 40]

[10, 20, 30, 40, [200, 300]]

 

# extend(): 리스트에 iterable(반복 가능한 객체 : 순서를 부여받는 객체)의 모든 항목을 추가하는 메서드

# extend(): 리스트에 iterable(반복 가능한 객체 : 순서를 부여받는 객체)의 모든 항목을 추가하는 메서드
li6 = [10, 20 ,30]
print(li6)
li6.extend([50])
print(li6)
li6.extend([1000,2000]) # 여러 개 추가
print(li6)
더보기

[10, 20, 30]

[10, 20, 30, 50]

[10, 20, 30, 50, 1000, 2000]

 

# pop(): 리스트에서 항목을 삭제하고, 삭제된 항목을 반환하는 메서드

# pop(): 리스트에서 항목을 삭제하고, 삭제된 항목을 반환하는 메서드
li6 = [10, 20, 30]
print(li6)
print(li6.pop()) #인플레이스 연산
print(li6)
더보기

[10, 20, 30]

30

[10, 20]

 

li6 = [10, 20, 30]
result = li6.pop()
print(result)

 

# insert(): 리스트의 특정 인덱스에 항목을 추가하는 메서드

# insert(): 리스트의 특정 인덱스에 항목을 추가하는 메서드
li6 = [10, 20, 30]
li6.insert(1, 100) # 인덱스 1에 100추가 원래 인덱스1에 있던 요소는 2로 밀림
print(li6)
더보기

[10, 100, 20, 30]

li6.insert(1,[1000,2000])
print(li6)
더보기

[10, [1000, 2000], 100, 20, 30]

 

# index(): 리스트에서 특정 값의 인덱스를 반환하는 메서드. 특정 값의 인덱스가 없다면 에러발생

# index(): 리스트에서 특정 값의 인덱스를 반환하는 메서드. 특정 값의 인덱스가 없다면 에러발생
li6 = [10, 20, 30]
print(li6.index(20))  # 괄호요소의 인덱스 위치를 알려줌
#print(li6.index(40)) #없는 값은 에러 ValueError : 40 is not i list

 

# reverse(): 리스트의 항목들의 순서를 뒤집는 메서드

# reverse(): 리스트의 항목들의 순서를 뒤집는 메서드
li7 = [10, 13, 20, 30, 5]
li7.reverse()
print(li7)
더보기

[5, 30, 20, 13, 10]

li7 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
li7.reverse()
print(li7)
더보기

['후이바오', '루이바오', '러바오', '아이바오', '푸바오']

 

- 값 삭제
            list명.remove(값)             # 중복 시 먼저 나온 값(낮은 인덱스 값)이 삭제

            del(list명[인덱스])            # 인덱스로 삭제
            del list명[인덱스]

            list명.clear()               # 모든 값 삭제

※ 슬라이싱을 사용하여 리스트의 순서를 뒤집는 방법

슬라이싱(slicing) 파이썬에서 시퀀스 타입의 객체(: 리스트, 문자열, 튜플 ) 일부를 추출하는 방법입니다. 슬라이싱의 기본 구조는 [start:stop:step]입니다.

 

1. start: 슬라이스의 시작 인덱스입니다.  인덱스의 요소는 슬라이스에 포함됩니다. start 생략하면, step 양수이면 0, step 음수이면 -1 간주됩니다.

 

2. stop: 슬라이스의  인덱스입니다.  인덱스의 요소는 슬라이스에 포함되지 않습니다. stop 생략하면, step 양수이면 시퀀스의 , step 음수이면 시퀀스의 시작으로 간주됩니다.

 

3. step: 슬라이스의 스텝(증감) 값입니다. step 생략하면 1 간주됩니다.

li8 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
print(li8[::]) # 데이터 그대로 출력
print(li8[::-1]) # start와 stop을 생략하고 step을 -1로 설정한 슬라이싱

#[start : stop : step]
# start를 생략하면 -1로 간주. 즉, 시퀀스의 마지막 요소부터 시작
# stop을 생략하면 0으로 간주. 즉, 시퀀스의 시작까지 진행
# step이 -1이므로, 시퀀스의 요소를 뒤에서부터 앞으로 하나씩 건너뛰어서 슬라이싱
더보기

['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

['후이바오', '루이바오', '러바오', '아이바오', '푸바오']

 

# sort(): 리스트의 항목들을 정렬하는 메서드.

# inplace 연산을 수행 변수에 담지 않아도 오름차순으로 저장이 됨

# sort(): 리스트의 항목들을 정렬하는 메서드. inplace 연산을 수행
li7 = [10, 13, 20, 30, 5]
li7.sort() # 오름차순
print(li7) # inplace연산이므로 재저장 오름차순대로 저장이됨
더보기

[5, 10, 13, 20, 30]

 

# sort(reverse=True) #내림차순

#sort(reverse=True) #내림차순
li7 = [10, 13, 20, 30, 5]
li7.sort(reverse=True)
print(li7)
더보기

[30, 20, 13, 10, 5]

 

li2 = ['Apple', 'apple', 'orange', 'banana', 'melon']
li2.sort() #아스키코드에 따라 오름차순
print(li2)
더보기

['Apple', 'apple', 'banana', 'melon', 'orange']

li8 = ['푸바오', '아이바오', '러바오', '루이바오', '후이바오']
li8.sort() #유니코드에 따라 오름차순
print(li8)
더보기

['러바오', '루이바오', '아이바오', '푸바오', '후이바오']

 

# sorted():  iterable(반복 가능한 객체)의 모든 항목들을 정렬한 후, 그 결과를 새로운 리스트에 담아 반환하는 함수

# inplace연산이 아니기 때문에 변화된 모습으로 남지않음, 따라서 변환값을 변수에 담아야함

# ✔ 비교
# sorted():  iterable(반복 가능한 객체)의 모든 항목들을 정렬한 후, 그 결과를 새로운 리스트에 담아 반환하는 함수
li10 = [ 10, 40, 30, 100, 90, 50]
print(sorted(li10)) #오름차순
print(sorted(li10, reverse=True)) #거꾸로
print(li10) #inplace연산이 아니기 때문에 변화된 모습으로 남지않음, 따라서 변환값을 변수에 담아야함

li10 = sorted(li10) # 반환값 변수에 담음
print(li10)
더보기

[10, 30, 40, 50, 90, 100]

[100, 90, 50, 40, 30, 10]

[10, 40, 30, 100, 90, 50]

[10, 30, 40, 50, 90, 100]

 

# count(): 리스트에서 특정 값의 개수를 반환하는 메서드

# count(): 리스트에서 특정 값의 개수를 반환하는 메서드
li11 = [10, 20, 30, 50, 20, 40, 30, 20]
print(li11.count(20)) #데이터 안에 똑같은 데이터가 몇개가 있는지 개수를 세줌
print(li11.count(16))

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

6. 파이썬 컬렉션 타입 - 세트  (0) 2023.12.07
5. 파이썬 컬렉션 타입 - 튜플  (2) 2023.12.07
3. 문자열 다루기  (1) 2023.12.07
2. 파이썬의 변수  (1) 2023.12.07
1. 파이썬의 출력  (1) 2023.12.07

1. 문자열

  • 파이썬에서 문자열은 텍스트 데이터를 다루는 데 사용되는 중요한 데이터 타입입니다. 문자열은 작은 따옴표(')나 큰 따옴표("), 세 개의 따옴표(''', """)로 둘러싸인 텍스트로 표현됩니다.
str1 = '오늘도 즐거운 파이썬 수업'
print(str1)
str2 = "오늘도 즐거운 파이썬 수업"
print(str2)
str3 = '''푸바오:
오늘도 맛있는
    1 2 죽순
'''
print(str3)
더보기

오늘도 즐거운 파이썬 수업

오늘도 즐거운 파이썬 수업

푸바오:

오늘도 맛있는

        1 2 죽순

a = 'hello'
b = 'hello'
c = 'hello'
print(a is b)
print(a is c)
더보기

True

True

 

 

2. 문자열 재할당

  • 파이썬에서 문자열은 불변(immutable)한 데이터 타입이므로 같은 변수에 문자열을 재할당하는 경우, 새로운 문자열 객체가 생성되고 변수는 새로운 문자열 객체를 참조하게 됩니다. 이전 문자열 객체는 변경되지 않습니다.
# id() : 객체의 고유한 메모리 주소를 반환
text = 'Hello'
print(id(text))

text = 'Python' #재할당
print(id(text)) # 새로운 문자열 객체의 메모리 주소 출력
 
더보기

136649128347376

136649555358960

 

 

3. 문자열 함수와 연산자

3-1. len 함수

문자열의 길이를 반환

text = 'Hello, Fubao!'
print(len(text)) # 띄워쓰기 포함 합

 

3-2. 문자열 합치기(+)

두 문자열을 합쳐 새로운 문자열을 생성

name = '푸바오'
age = '3살'
msg = name + '는 ' + age
print(msg)
더보기

푸바오는 3살

 

3-3. 문자열 반복하기(*)

문자열을 여러 번 반복하여 새로운 문자열을 생성

apple = '🍎' * 10
print(apple)

Panda = '🐼' * 2
print(Panda)
더보기

🍎🍎🍎🍎🍎🍎🍎🍎🍎🍎

🐼🐼

 

3-4. 문자열 인덱싱과 슬라이싱

문자열 내부와 문자 인덱스를 사용하여 접근하거나 슬라이스함

str1 = '문자열 내부의 문자 인덱스를 사용하여 접근하거나 슬라이스함'
print(str1)
더보기

문자열 내부의 문자 인덱스를 사용하여 접근하거나 슬라이스함

# 인덱싱
print(str1[0])
print(str1[1])
print(str1[3])
print(str1[-12])
print(str1[-11])
print(str1[12])
더보기

 

 

# 슬라이싱
print(str1[0:6]) # 인덱스 0부터 6직전까지
print(str1[:15]) # 인덱스 0부터 15직전까지
print(str1[8:])  # 인덱스 8부터 끝까지
print(str1[:])   # 처음부터 끝까지

print("============================================")
print(str1[3:-7])
print(str1[3:-8])
print(str1[3:-9])
더보기

문자열 내부

문자열 내부의 문자 인덱스를

문자 인덱스를 사용하여 접근하거나 슬라이스함

문자열 내부의 문자 인덱스를 사용하여 접근하거나 슬라이스함 ============================================

내부의 문자 인덱스를 사용하여 접근하거

내부의 문자 인덱스를 사용하여 접근하

내부의 문자 인덱스를 사용하여 접근

 

 

4. 문자열 메서드

  • 문자열 메서드는 문자열 객체에 적용되는 함수로, 문자열을 조작하거나 변환하는 다양한 작업을 수행할 수 있게 해줍니다.

4-1. upper메서드와 lower 메서드

대문자 또는 소문자로 변환

text = "Fubao"
print(text.upper())
print(text.lower())
더보기

FUBAO

fubao

 

4-2. count메서드

특정 문자열의 등장 횟수 확인

text = 'Fubao Aibao Lebao'
print(text.count('o'))
print(text.count('ba'))
print(text.count('fu')) # 대소문자 구분, 찾지 못하면 0
더보기

3

3

0

 

4-3. find 메서드

특정 부분 문자열의 첫 번째 등장 위치(인덱스)를 확인

text = 'Fubao Aibao Lebao'
print(text.find('b'))
print(text.find('Ai'))
print(text.find('!')) # 찾지 못하면 -1
print(text.rfind('L')) #뒤에서 부터 찾기 (뒤에서 부터 먼저나오는 텍스트의 인덱스 출력)
print(text.find('o',5)) #인덱스 번호 5이후 부터 찾기
더보기

2

6

-1

12

10

 

4-4. replace메서드

문자열 대체

text = 'Fubao Aibao Lebao'
new_text = text.replace('Fubao', 'Panda')
print(new_text)
더보기

Panda Aibao Lebao

 

4-5. strip메서드

문자열의 양쪽 공백 제거

text = '     Hello, Fubao!       '
print(text)
print(text.strip())
더보기

                 Hello, Fubao!                        

Hello, Fubao!

 

4-6. split메서드

문자열을 분리

text = '푸바오 아이바오 러바오 루이바오 후이바오'
names = text.split()
print(names) # 리스트
더보기

['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

text = '푸바오,아이바오,러바오,루이바오,후이바오'
names = text.split(',') # ','을 기분으로 분리
print(names)
더보기

['푸바오', '아이바오', '러바오', '루이바오', '후이바오']

 

4-7. join메서드

특정 문자와의 결합

text = 'Fubao'
print('🐼'.join(text))
더보기

F🐼u🐼b🐼a🐼o

 

4-8. startswith()와 endswith() 

접두사와 접미사 확인

text = 'Hello, Python!'
starts_with_hello = text.startswith('Hello')
ends_with_world = text.endswith("World!")

print(starts_with_hello)
print(ends_with_world)
더보기

True

False

 

 

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

6. 파이썬 컬렉션 타입 - 세트  (0) 2023.12.07
5. 파이썬 컬렉션 타입 - 튜플  (2) 2023.12.07
4. 파이썬 컬렉션 타입 - 리스트  (2) 2023.12.07
2. 파이썬의 변수  (1) 2023.12.07
1. 파이썬의 출력  (1) 2023.12.07

1. 변수

  • 변수는 프로그래밍에서 데이터를 저장하고 관리하는 데 사용되는 중요한 개념입니다. 변수는 이름이 붙은 메모리 공간으로, 값을 저장하거나 참조할 때 사용됩니다.
name = '푸바오'
age = 3
weight = 100

print('%s 의 나이는 %d살 체중은 %dkg' %(name, age, weight))
더보기

푸바오 의 나이는 3살 체중은 100kg

name = '러바오'
print('%s의 나이는 %d살 체중은 %dkg' %(name, age, weight))
더보기

러바오의 나이는 3살 체중은 100kg

name = input(str("이름 :"))
age = input(str("나이 :"))
print('%s의 나이는 %s살' %(name, age))
더보기

이름 :푸바오

나이 :3

푸바오의 나이는 3살

 

 

2.변수 이름 작성하는 방법

  • 파이썬 변수는 대소문자를 구분하며, 예약어 (예: if, while, for 등)는 변수 이름으로 사용할 수 없습니다. 변수 이름은 알파벳으로 시작해야 하며, 숫자나 특수문자는 첫 글자로 올 수 없습니다. 변수 이름은 의미있고 알아보기 쉬운 이름으로 지정하는 것이 좋습니다.
num1 = 10
num2 = 3
print('%d/%d = %4.2f' %(num1,num2, num1/num2))
더보기

10/3 = 3.33

 

 

3. 변수의 자료형

  • 파이썬은 동적 타이핑(dynamic typing) 언어로, 변수의 타입을 선언할 필요 없이 값을 할당할 때 자동으로 타입을 추론합니다. 이는 프로그래머가 변수의 타입을 직접 명시할 필요 없이 더 유연하게 코드를 작성할 수 있는 장점을 제공합니다. 그렇지만 이로 인해 잘못된 타입의 값이 변수에 할당되는 상황도 발생할 수 있습니다.
name = '푸바오'
print(type(name))

age = 3
print(type(age))

weight = 50.5
print(type(weight))

isLover = True #False
print(type(isLover))
더보기

<class 'str'>

<class 'int'>

<class 'float'>

<class 'bool'>

 

4. 변수 삭제

  • 변수를 삭제하기 위해 del 문을 사용할 수 있습니다. del 문은 지정된 변수를 제거하고 해당 메모리 공간을 해제합니다. 변수가 삭제되면 해당 이름으로 변수에 더 이상 접근할 수 없습니다.
isLober = False
print(isLover)
del isLover
print(isLover)
더보기
True
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-10-c7ba738eede6> in <cell line: 4>()
      2 print(isLover)
      3 del isLover
----> 4 print(isLover)

NameError: name 'isLover' is not defined

 

변수가 삭제되어 변수를 불러올수 없어 NameError 발생

name1 = '푸바오'
name2 = name1

del name1
print(name2)
더보기

푸바오

 

'컴퓨터 비전 > 파이썬 기초' 카테고리의 다른 글

6. 파이썬 컬렉션 타입 - 세트  (0) 2023.12.07
5. 파이썬 컬렉션 타입 - 튜플  (2) 2023.12.07
4. 파이썬 컬렉션 타입 - 리스트  (2) 2023.12.07
3. 문자열 다루기  (1) 2023.12.07
1. 파이썬의 출력  (1) 2023.12.07