정보처리기사 실기 python

python ---------------------------------------- 예제 -----





-----


class Calc :
  result = 0
  def setdata(self, fir, sec) :
    self.fir = fir
    self.sec = sec
  def add(self) :
    Calc.result += 1
    self.result = self.fir + self.sec
  def getdata(self) :
    print(self.result, end= " ")
    #15
    print(Calc.result)
    #1
    
a = Calc()
b = Calc()
a.setdata(5, 10)
b.setdata(5, 10)
a.add()
a.getdata()
#15 1
b.add()
b.getdata()
#15 2
#Calc.result에 이미 += 1이 되어있어서 최종적으로 2가됨.


-----

def add(x, y) :
  return x + y
  
def sub(a, b) :
  return a - b
  
number1 = [1, 2, 3, 4]
number2 = [5, 6, 7, 8]
result1 = map(add, number1, number2)
#map()은 리스트나 튜플 같은 반복 가능한 데이터(Iterable)의 모든 요소에 특정 함수를 일괄적으로 적용해 주는 내장 함수입니다.
#6, 8, 10, 12
result2 = map(sub, number1, number2)
#-4, -4, -4, -4
print(list(result1))
print(list(result2))
#list()로 변환하지 않고 result1을 그대로 출력하면 데이터 값이 아닌 라는 메모리 주소(객체 형태)만 출력되기 때문입니다.
#[6, 8, 10, 12]
#[-4, -4, -4, -4]

-----

def calc(check ,*value) :
  #별하고 매개변수하면 가변 파라미터
  num = 0
  for i in value :
    num = num + i
    #13
    
  if check :
    return num, set(value), check
    #set()은 수학의 집합(Set) 개념을 구현한 자료형입니다. 중복을 허용하지 않고 순서가 없는 데이터의 모음이며
    #{1, 2, 3, 4}
  else :
    return set(value)
    
k = calc(1, 1, 2, 3, 4, 1, 2)
print(k)
#(13, {1, 2, 3, 4}, 1) 여러개의 값을 한번에 출력해서 ()가 나옴. 튜플 형태
#튜플(Tuple)은 여러 개의 값을 하나의 변수에 저장할 수 있는 순차적 자료형입니다. 리스트(List)와 비슷하지만, 한 번 생성된 값을 변경할 수 없는(Immutable) 불변성을 가지고 있습니다.



-----

test = [2, 5, 3 ,4]
test.sort()
#오름차순으로 정렬해주는거.
#.sort(reverse=True)은 내림차순
test.append(1)
#[2, 3, 4, 5, 1]
test.reverse()
#리스트를 역순으로 뒤집는 거.
#[1, 5, 4, 3, 2]
print(test)
#[1, 5, 4, 3, 2]
print(test.index(4))
#2

-----

class Tiger :
  def speak(self) :
    print("I am tiger")
    
class Lion :
  def speak(self) :
    print("I am Lion")
    
def speak(animal) :
  animal.speak()
  
def main() :
  tiger = Tiger()
  lion = Lion()
  speak(tiger)
  #speak(Tiger())
  speak(lion)
  #speak(Lion())
  
main()
"""
I am tiger
I am Lion
"""


-----


text = ['Seoul', 'Kyeonggi', 'incheon', 'Daejun', 'Daegu', 'Pusan']
str01 = "S"
for i in text :
  str01 = str01 + i[1]
print(str01)
#출력값은 Seynaau

-----

def func1 (num1, num2 = 10) :
  print('a=', num1, 'b=', num2)
  
def func2 (num1 = 10, num2 =10) :
  print('a=', num1, 'b=', num2)
  
func1(5)
#a= 5 b= 10
func2(5, 5)
#a= 5 b= 5
func2()
#a= 10 b= 10

-----

class parent :
  def __init__(self) :
    print("parent 생성자")
  def __del__(self) :
    print("parent 소멸자")
  def show(self) :
    print("sunny")

class child(parent) :
  def show(self) :
    print("snow")
    
a = child()
a.show()
del a

"""
제시해주신 파이썬 코드는 클래스 상속, 메서드 오버라이딩, 객체 생명주기(생성자와 소멸자)의 원리로 작동합니다.실행 순서에 따른 구체적인 원리는 다음과 같습니다.1. 객체 생성 및 상속 (a = child())메모리 할당: child()가 호출되면 메모리에 child 클래스의 인스턴스(객체)가 만들어집니다.부모 생성자 호출: child 클래스 내부에는 생성자(__init__)가 정의되어 있지 않습니다. 파이썬은 상속 관계인 부모(parent) 클래스로 올라가 parent.__init__(self)를 대신 실행합니다.출력: "parent 생성자"가 화면에 출력됩니다.2. 메서드 오버라이딩 (a.show())메서드 탐색: a.show()를 호출하면 파이썬은 먼저 자식인 child 클래스에서 show 메서드를 찾습니다.재정의(Overriding) 적용: child 클래스에 show가 이미 정의되어 있으므로, 부모의 show는 무시하고 자식의 메서드를 실행합니다. 이를 메서드 오버라이딩이라고 합니다.출력: "snow"가 화면에 출력됩니다. ("sunny"는 출력되지 않음)3. 객체 소멸 (del a)참조 횟수 감소: del a는 변수 a와 메모리 상의 객체 사이의 연결(참조)을 끊습니다. 이 객체를 가리키는 다른 변수가 없으므로, 객체의 참조 횟수(Reference Count)가 0이 됩니다.부모 소멸자 호출: 파이썬 가비지 컬렉터가 객체를 메모리에서 제거하기 전 소멸자(__del__)를 실행합니다. child 클래스에 소멸자가 없으므로, 부모(parent)의 __del__을 찾아 실행합니다.출력: "parent 소멸자"가 화면에 출력됩니다.

__init__은 객체가 생성될 때 자동으로 실행되는 생성자(Constructor) 역할을 하는 메서드가 맞습니다.정확하게 표현하면 객체를 초기화하는 역할을 담당하며, 다음과 같은 특징을 가집니다.__init__의 핵심 역할초기화: 객체가 메모리에 만들어진 직후, 객체의 초기 상태(속성/변수)를 설정합니다.자동 호출: 사용자가 직접 이름을 불러 실행하지 않고, 인스턴스 = 클래스명()과 같이 객체를 만들 때 자동으로 실행됩니다.💡 파이썬의 엄밀한 개념 차이 (참고용)파이썬에는 사실 __init__ 외에 __new__라는 메서드가 하나 더 있습니다. 엄밀히 따지면 파이썬 내부에서의 진짜 생성과 초기화 단계는 다음과 같이 나뉩니다.__new__ (실제 생성자): 메모리에 객체를 실제로 공간을 잡아 생성하는 역할을 합니다.__init__ (초기화 메서드): 이미 생성된 객체에 변수 값을 넣는 등 초기화를 합니다.하지만 일반적인 프로그래밍을 할 때는 __new__를 직접 수정할 일이 거의 없기 때문에, 관례적으로 __init__을 파이썬의 생성자라고 부릅니다.혹시 이전에 작성하신 코드에서 __init__을 사용해 매개변수(인자)를 전달받아 객체 변수를 설정하는 방법이나, 자식 클래스에서 부모의 __init__을 호출하는 super() 사용법에 대해 더 알아보고 싶으신가요?

__del__은 객체가 메모리에서 완전히 소멸할 때 자동 실행되는 소멸자(Destructor) 역할을 하는 메서드가 맞습니다.주로 파일 닫기나 네트워크 연결 종료처럼 객체가 사라지기 전에 정리해야 하는 작업을 처리할 때 사용합니다.__del__의 작동 원리 (참조 횟수 계산)파이썬은 참조 횟수 계산(Reference Counting) 방식으로 메모리를 관리합니다. [가비지 컬렉션] 기술의 일종으로, 객체를 가리키는 변수의 수가 0이 되는 순간 __del__이 자동으로 호출되며 메모리에서 지워집니다.
"""



-----

a = [3, 4, 10, 5, 1]

for i in range(0, 5) :
  for j in range(i + 1, 5) :
    if a[i] < a[j] :
      a[i], a[j] = a[j], a[i]
    #i == 0 -> j in range (1, 5) -> a[0] -> 3 a[j] -> 4, 10, 5, 1 -> 4, 3, 10, 5, 1 -> 10, 3, 4, 5, 1
    #i == 1 -> j in range (2, 5) -> a[1] -> 3 a[j] -> 4, 5, 1 -> 10, 4, 3, 5, 1 -> 10, 5, 3, 4, 1
    #i == 2 -> j in range (3, 5) -> a[2] -> 3 a[j] -> 4, 1 -> 10, 5, 4, 3, 1
    #i == 3 -> j in range (4, 5) -> a[3] -> 3 a[j] -> 1 ->최종값 10 5 4 3 1
for k in a :
  print(k, end = " ")


-----

class Groom :
  a = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
  
Na = Groom()
str = ' '
for k in Na.a :
  #Na.a는 Groom 클래스의 인스턴스인 Na를 통해 클래스 내부의 변수 a에 접근하는 것을 의미합니다.
  str = str + k[0]
  #MTWTTFSS
  
print(str)

-----

lst = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(lst[2])
#[6, 7, 8, 9]
print(lst[1][1])
#5
for sub in lst :
  for item in sub :
    print(item, end="")
    #123
    #45
    #6789
  print()


-----

mylist = [1, 2, 3, 4, 5]
mylist = list(map(lambda x: x * 2, mylist))
#list(map(함수, 리스트)) 형태는 원본 리스트의 모든 요소에 특정 함수를 일괄적으로 적용하여 새로운 값들로 구성된 리스트를 생성하는 문법입니다. 반복문을 사용하는 것보다 코드가 훨씬 간결해집니다.핵심 동작 원리map(함수, 리스트): 리스트의 각 요소(element)를 꺼내어 지정한 '함수'에 전달하고, 그 처리 결과를 반환합니다.
#lambda는 이름이 없는 '익명 함수(anonymous function)'를 만들 때 사용하는 키워드입니다. 일반적인 def 함수와 달리, 복잡한 정의 없이 즉석에서 한 줄로 작성하고 일회용으로 사용할 수 있다는 것이 핵심입니다.
print(mylist)
#출력값 2, 4, 6, 8, 10

-----

family = {'엄마', '아빠'}
#family = {'엄마', '아빠'}는 집합(Set) 자료형을 변수에 할당한 것입니다.이 문법의 핵심적인 특징과 의미는 다음과 같습니다.자료형: 중괄호 { }를 사용하여 생성하는 셋(Set) 입니다. 리스트와 달리 순서가 없고, 중복된 데이터를 허용하지 않습니다.데이터: 이 집합 안에는 '엄마'와 '아빠'라는 두 개의 문자열 요소가 포함되어 있습니다.
family.add('나')
family.update({'나', '동생', '댕댕이'})
family.remove('댕댕이')
print(family)
#출력값
#{'아빠', '동생', '엄마', '나'} 순서는 무작위 리스트가 아니라서, 세트 집합 자료형이라서

------

box = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for line in box :
  for col in line :
    print(col, end = "")
    #출력값 123456789


------
        
base = 10
bit = 3
result = 0
for i in range(1, 4) :
  #이 for문은 3회 반복하는거 자체가 의미 없음.
  result = base << bit
  10 * 2^3 == 80
  
print(result)
#결과값 80


------

a = "Merry Christmas"
b = "Happy new Year!"
c = a[:6] + b[6:9]
"""
a[:6]은 Merry 이고
b[6:9]은 new이다.
"""
d = "%s"%" Birthday"
#"%s"는 문자열 포맷팅을 할 때 사용되는 문자열 변환 서식 지정자입니다. %s는 "이 위치에 문자열(String)을 넣겠다"는 의미의 자리 표시자(Placeholder)입니다.라서 " Birthday"가 출력됨.
print(c + d)
#따라서 결과값은 Merry new Birthday

        

-----

class T :
  def __init__ (self, width, height) :
    self.width = width
    self.height = height
  def area(this) :
    a = this.width * this.height / 2
    return a
    
tt = T(4, 4)
print(tt.area())
"""
__init__ 의 의미__init__은 파이썬 클래스의 생성자(Constructor) 메서드입니다.자동 실행: 클래스로 새로운 객체(인스턴스)를 만들 때 자동으로 호출됩니다.역할: 객체가 생성되자마자 변수(width, height)를 초기화하고 값을 할당합니다.코드 예시: tt = T(4, 4)를 실행하는 순간 __init__이 실행되어 가로 4, 세로 4의 값을 가진 객체가 만들어집니다.📌 this 의 의미this는 메서드가 호출된 객체 자신을 가리키는 변수입니다.관례와의 차이: 파이썬에서는 일반적으로 이 첫 번째 매개변수 이름으로 self를 사용합니다.동작 원리: 파이썬은 문법적으로 첫 번째 매개변수를 무조건 객체 자신으로 인식합니다. 따라서 this라고 적어도 self와 똑같이 작동합니다.역할: tt.area()를 호출하면 this는 tt 객체 자체가 되므로, tt가 가진 width(4)와 height(4)에 접근할 수 있게 됩니다.
"""
"""
객체의 변수(width, height)에 접근하려면 반드시 첫 번째 매개변수(여기서는 this)를 통해서만 접근할 수 있습니다. 이를 생략하면 변수를 찾지 못해 에러가 발생합니다.
"""

-----

        
a = [5, 10, 20]
b = 15.0
c = 0
for i in a :
  c += b // i
  #15.0 // 5 == 3.0
  #15.0 // 10 == 1.0
  #15.0 // 20 == 0.0
print(c)
#3.0 + 1.0 == 4.0


-----

a, b, c, d = 5, 10, 122, 11

target = [a, b, c, d]
ok = []
no = []
correct =[5, 'a', 123, 12, 11, c]
#correct == [a, 'a', 123, 12, d, c]

for a in target :
  if a in correct :
    ok.append(a)
    #ok == [5, 122, 11]
  else :
    no.append(a)
    #no == [10]
print(ok)
print(no)

-----

def test (*v, n = 2) :
  print(v)
  for i in range(n) :
    for j in v :
      print(j, end='')
      #Hi friend 3이 출력됨.
    print()
    #줄바꿈됨.
  
test("Hi ", "friend ", 3)

"""
('Hi ', 'friend ', 3)이 되는 이유는 *v라는 가변 인자(Asterisk) 문법이 전달된 모든 일반 매개변수를 하나의 튜플(Tuple)로 묶어주기 때문입니다.구체적인 동작 원리는 다음과 같습니다.1. *v (가변 인자)의 역할매개변수 이름 앞에 *을 붙이면, 함수를 호출할 때 입력된 인자들 중 위치 기반 인자(Positional Arguments)를 모두 모아 하나의 튜플로 만듭니다.test("Hi ", "friend ", 3) 호출 시, 3개의 값은 모두 위치 기반 인자로 *v에 전달됩니다.따라서 v라는 변수 내부에는 ('Hi ', 'friend ', 3)이라는 튜플이 저장됩니다.2. n = 2 (키워드 전용 인자)의 처리*v 뒤에 선언된 n = 2은 키워드 전용 인자(Keyword-only Argument)입니다.명시적으로 n = 5와 같이 이름을 지정해서 호출하지 않으면, 앞에 선언된 가변 인자(*v)가 모든 일반 값을 흡수합니다.이번 호출에서는 n을 따로 지정하지 않았으므로 n은 기본값인 2를 유지하고, *v만 3개의 값을 가져갔습니다.3. print(v)의 출력튜플 상태인 변수 v를 그대로 출력하므로 괄호와 쉼표가 포함된 ('Hi ', 'friend ', 3)이 화면에 나타납니다.
test(1)이나 test(1,)이면

*v에 의해 튜플 생성test(1)을 호출하면 인자 1이 가변 인자 *v로 전달됩니다.*v는 입력된 값들을 무조건 튜플로 묶기 때문에, 변수 v 안에는 숫자 1 하나만 담긴 튜플이 만들어집니다.2. 파이썬의 단일 요소 튜플 표기법 (1,)파이썬에서 단순히 (1)이라고 쓰면, 컴퓨터는 이를 튜플이 아니라 연산 순서를 지정하는 괄호(우선순위 괄호)로 인식하여 그냥 숫자 1로 처리합니다.예: (1 + 2) * 3에서 (3)이 그냥 숫자 3인 것과 같습니다.따라서 파이썬은 "이것은 숫자가 아니라 값이 1개 짜리인 '튜플'이다"라는 것을 명확히 구분하기 위해, 뒤에 쉼표를 붙인 (1,) 형태로 출력합니다.
"""

-----

li = ["groom", "kim", "mnung"]
cnt = 0
str = ' '
for i in li :
    for j in i :
        str += j[0]
        cnt = cnt + 1        
        if cnt > 5 : 
            break 

print(str)
"""
g
gr
gro
groo
groom
groomk
groomkm
이런식으로 str에 쌓임. 

"""

-----
        
t = [1, 2, '1', '2', '3', '4']
t[2:] = 'abc'
#여기까지 했을 때, t = [1, 2, 'a', 'b', 'c']
t[0] = [1, 2]
#여기까지 했을 때, t = [[1, 2], 2, 'a', 'b', 'c']
t[1:2] = [5, 6]
#여기까지 했을 때, t = [[1, 2], 5, 6, 'a', 'b', 'c']
print(t)
#여기까지 했을 때, t = [[1, 2], 5, 6, 'a', 'b', 'c']
print(t.index(6))
# 2가 나옵니다.



-----

a = ["a", "b", "c", "d"]
a.extend(["김구름", "구름이"])
a.append(["김", "구", "름"])

print(a)
print(a.pop())
print(a.pop(2))

"""
출력값
pop() 함수는 리스트(List) 등에서 특정 위치의 요소를 제거하고 그 값을 반환(추출)하는 내장 메서드입니다

['a', 'b', 'c', 'd', '김구름', '구름이', ['김', '구', '름']]
['김', '구', '름']
c
"""

-----


gugu = ["kim", "goo", "rem", "mung"]
mungee = [1, 2, 3]
tupList = list(zip(gugu, mungee))
dicList = dict(zip(mungee, gugu))
print(tupList)
print(dicList)

"""
출력값
파이썬의 zip() 함수는 여러 개의 반복 가능한(iterable) 객체를 인자로 받아, 각 객체의 동일한 인덱스 요소를 튜플로 묶어 반환하는 내장 함수입니다.핵심 기능 및 사용법튜플 반환: 같은 위치의 값들을 (요소1, 요소2) 형태의 튜플로 묶어줍니다.짧은 객체 기준: 인자로 전달된 객체들의 길이가 다를 경우, 가장 짧은 객체를 기준으로 튜플을 생성하고 나머지는 무시합니다.반복자(Iterator) 반환: 메모리 효율을 위해 zip 객체를 반환하므로, 값을 바로 확인하려면 list()로 감싸야 합니다.
[('kim', 1), ('goo', 2), ('rem', 3)]
{1: 'kim', 2: 'goo', 3: 'rem'}
"""

-----


------------


다른거 예제 보고 만든거

a = [None] * 8
i, n = 0, 10
while n > 0 :
  a[i] = n % 2
  i += 1
  n //= 2
  
for j in range (7, -1, -1) :
  print(a[j])


-----

#c언어 예제 보고 만든거

i, c = 0, 0
while i < 10 :
  i += 1
  c *= i
  
print(c)
    

#자바 예제 보고 만든거
array = [[0] * 5 for _ in range(3)]

n = 1

for i in range(3) :
    for j in range(5) :
        array[i][j] = j * 3 + (i + 1)
        print(array[i][j], end = " ")
    print()


-------

array = [[j * 3 + (i + 1) for j in range(5)] for i in range(3)]

for row in array:
    print(*(row))
#*이 공백으로 구분되는 배열 모양으로 출력해주는거 애스터리스크이다.

위에꺼랑 같은데, 코드는 더 간략하게

------------

#c언어 예제 보고 만든거
def r1() :
    return 4

def r10() :
    return 30 + r1()

def r100() :
    return 200 + r10()

print(r100())

출력값 234

-----

#문제푼거
        
lol = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(lol[0])
print(lol[2][1])
for sub in lol:
  for item in sub:
    print(item, end=" ")
  print()
  
실행 결과

[1, 2, 3]
7
1 2 3 
4 5 
6 7 8 9 

-----

문제 푼거 -------------

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

result = {}

for index, lis in enumerate(data) :
  list_num = sum(lis)
  list_len = len(lis)
  
  result[index] = (list_num, list_len)
print(result)


결과는 {0: (15, 5), 1: (10, 3), 2: (18, 5), 3: (9, 2)}
        

        -----
    

다차원 배열

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



    -----

딕셔너리

result = {}

    #이건 빈 딕셔너리


    기본 할당 ([]): my_dict['key'] = 'value'

    update() 메서드: my_dict.update({'key1': 'value1', 'key2': 'value2'})를 사용하여 여러 값을 한 번에 추가

    setdefault() 메서드: my_dict.setdefault('key', 'default_value')로 키가 없을 때만 값을 설정

    -----

집합 -----

여러 개의 자료를 하나의 변수로 관리할 때 사용하는 자료형으로 중복된 데이터를 가질 수 없고, 순서가 없다.

    asia = {'한국', '중국', '일본'}
    asia.add('베트남')
    asia.add('중국')
    asia.remove('일본')
    asia.update(['홍콩', '한국', '태국'])
    print(asia)

    답은 {'태국', '홍콩', '한국', '베트남', '중국'}

    https://www.youtube.com/watch?v=sTq9uMtz49g&list=PLz95GL3y9Hv0fbwTxWqc3dni3hCA7OXgj&index=5

    11분 38초 쯤 보기

    -----

for index, lis in enumerate(data):

는 파이썬에서 리스트(data)를 순회할 때 요소의 순서(index)와 값(lis)을 동시에 가져오는 방식입니다. index는 0부터 시작하는 자동 생성 인덱스를, lis는 해당 순서의
    데이터를 받으며,
    코드를 간결하고 가독성 있게 만들어 줍니다.



    예시



    bichons = ["groomi", "mungmungee", "bichonchon"]

    for index, bichonee in enumerate(bichons):
    print(f"{index}: {bichonee}")
    """
    0: groomi
    1: mungmungee
    2: bichonchon
    """



    동시 접근: enumerate()는 데이터를 하나씩 열거하며 (인덱스, 요소) 튜플 형태로 반환합니다.

    간결한 코드: range(len(data))를 사용하여 수동으로 인덱스를 관리할 필요가 없어 파이썬다운(Pythonic) 방식입니다.

    시작값 변경: enumerate(data, start=1)와 같이 사용하여 인덱스를 1부터 시작할 수 있습니다.



    https://0171-cloud.tistory.com/10


    [Python] `enumerate`로 간편하게 인덱스 추적하기: 인덱스와 값 모두 쉽게 관리하기

    Python enumerate로 간편하게 인덱스 추적하기: 인덱스와 값 모두 쉽게 관리하기Python에서 리스트나 튜플과 같은 시퀀스를 순회할 때 인덱스와 값을 동시에 다뤄야 하는 경우가 자주 있습니다. 이때
    e



    -----

sum

Python에서 sum()은 리스트, 튜플 등 반복 가능한(iterable) 객체 안에 있는 숫자 요소들의 총합을 계산하는 내장 함수입니다. sum(iterable, start=0) 형태로
    사용하며,
    기본적으로 0부터 시작하여 리스트 등의 모든 요소를 더한 결과를 반환합니다.1. 기본 사용법숫자로 구성된 리스트나 튜플의 합을 구할 때 가장 많이 사용됩니다.pythonnumbers = [1, 2, 3, 4,
    5]
    total = sum(numbers)
    print(total) # 출력: 15
    2. 주요 특징 및 기능시작 값 지정 (start): 합계를 구할 때 초기값을 설정할 수 있습니다. 기본값은 0입니다.pythonsum([1, 2, 3], 10) # 10 + 1 + 2 + 3 = 16
    데이터 타입: 숫자(integer, float) 데이터에만 사용할 수 있으며, 문자열 등 다른 타입이 포함되면 TypeError가 발생합니다.효율성: 수동으로 for 루프를 작성하는 것보다 빠르고 간결하게
    합계를 구할 수 있습니다.3. 응용 예시평균 계산: sum()과 len()을 함께 사용하여 평균을 구합니다.pythonscores = [80, 90, 100]
    average = sum(scores) / len(scores)
    2차원 리스트 펼치기: start 인자를 활용해 리스트를 합칠 수 있습니다.pythonnested = [[1, 2], [3, 4]]
    flattened = sum(nested, []) # [1, 2, 3, 4]



    -----

class arr:
a = ["Seoul", "Kyeonggi", "Incheon", "Daejeon", "Daegu", "Pusan"]

str01 = ' '
for i in arr.a:
str01 = str01 + i[0]
print(str01)

출력값 SKIDDP

------
    

print(17 / 3)
#으로하면 실수로 나옴.
17 // 3으로 해야지 정수 몫만 나옴.

print(5 ** 2)
#거듭제곱

print("\"구름이\"")

print(r"C:\some\name")
#C:\some\name 이렇게 출력됨 \ 무시하게 해주는 r

print("dfsdkfjsdkjfksdjfksdfsdfdf" "dfsdjkfjsdkfjsdkfjksdjfsdkjfskdfjdksl")
#이렇게 하면 두 문자열이 붙어서 나옴.

arr = "groom"
print(arr[-1])
#배열 음수 순서는 뒤에서 부터

arr = "groom"
print(arr[4:43])
#이렇게 슬라이스 끝이 초과되는건 작동함.

arr = "groom"
groom[0] = "k"
print(groom)
#이런식으로 문자열에 대입을 해버리면 오류뜸.

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
letters[1:3] = ['B', "C"]
letters[5:7] = []
print(letters)
#위와 같은 방식으로 대입 및 삭제 가능

#####

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

#####
enumerate() 

while True :
  pass
#pass는 최소한의 class나 def를 만들 때 사용하기도 함.

arr = list(range(4))
print(arr)
#이런식으로 [0, 1, 2, 3] 리스트 만들기도 가능함.


def groom(n) :
  n += 1
  print(n)
  
groom(3)
#함수 정의

-----

def groom(n) :
  n += 1
  return n
  
n2 = groom(2)
print(n2)
#이런식으로 함수 return

-----

#####
def ask_ok(prompt, retries=4, reminder='Please try again!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise ValueError('invalid user response')
        print(reminder)

-----

groom = 5

def groo(gu = groom) :
  print(gu)
  
groom = 6

groo()

#값 5

---------

def f(a, L = []) :
  L.append(a)
  return L
  
print(f(1))
print(f(2))
print(f(3))

"""
출력값
[1]
[1, 2]
[1, 2, 3]
"""

-----

#####
def f(a, L=None) :
  if L is None :
    L = []
    L.append(a)
    return L
    
print(f(1))
print(f(2))
print(f(3))

출력값
[1]
[2]
[3]

-----

def groom(groo, statt = "kim", action = "goo", type = "rem", roo = "rem") :
  print("구름이는", action, end = " ")
  print("구름", statt, action, type, roo)
  print(groo)
  
groom("gu", "rem", "ii")
groom(groo = 10)

#키워드 인자를 이용해서 함수를 정의 가능함.
#1개의 필수 인자와 선택적 인자 statt = "kim", action = "goo", type = "rem", roo = "rem"로 가능.
#출력값은 
"""
구름이는 ii 구름 rem ii rem rem
gu
구름이는 goo 구름 kim goo rem rem
10
"""


------

**name 형식의 마지막 형식 매개변수가 존재하면, 형식 매개변수들에 대응하지 않는 모든 키워드 인자들을 담은 딕셔너리 (매핑 형 — dict 를 보세요) 를 받습니다. 이것은 *name (다음 서브섹션에서 설명합니다) 형식의 형식 매개변수와 조합될 수 있는데, 형식 매개변수 목록 밖의 위치 인자들을 담은 튜플을 받습니다. (*name은 **name 앞에 나와야 합니다.) 예를 들어, 이런 함수를 정의하면: 부터 보기.

https://docs.python.org/ko/3.8/tutorial/controlflow.html

끝값은 만들어지는 수열에 포함되지 않습니다; range(10) 은 10개의 값을 만드는데, 길이 10인 시퀀스의 항목들을 가리키는 올바른 인덱스들입니다. 범위가 다른 숫자로 시작하거나, 다른 증가분을 (음수조차 가능합니다; 때로 이것을 ‘스텝(step)’이라고 부릅니다) 지정하는 것도 가능합니다: 부터