함수 : argument와 parameter 키워드로 matching 하기

매개변수 유형

• 위치 매개변수 : 인수와 순서대로 대응
• *a : 가변 인수 위치를 나타냄, 이 매개 변수는 함수에 전달된 위치 인수를 튜플 형태로 수집합니다.
• sbs(1, 2, 3)을 호출하면, a는 1이 되고, tu는 (2, 3)이 됩니다.
• 기본값 매개변수 : 매개변수에 입력값이 없으면 기본값 사용
• 키워드 매개변수 : 인수와 매개변수를 동일 이름으로 대응
• 가변 매개변수 : 인수의 갯수가 동적인 경우, **di는 가변 키워드 인수를 나타냅니다. 이 매개 변수는 함수에 전달된 키워드 인수를 딕셔너리 형태로 수집합니다.
• sbs(1, b=2, c=3)을 호출하면, a는 1이 되고, tu는 ()이 되고, di는 {'b': 2, 'c': 3}이 됩니다.

1. def showGugu(start, end=5):
    for dan in range(start, end+1):
        print(str(dan)+'단 출력')
   

showGugu(2,3) print() showGugu(3) print() showGugu(start=2, end=3) print() showGugu(end=3, start=2) # 서로 바뀌어도 똑같이 출력, 이름따라 간다. print() showGugu(2, end=3) # 이렇게 써도 결과는 같다 print()

showGugu(start=2, 3) # 이건 에러가 발생한다.

print()

showGugu(end=3, start=2) # 이것도 에러가 발생 , @@2두번째 인수를 상수로 주면 에러가 발생한다.@@

2. 

print('\n가변인수 처리') def func1(*ar): #print(ar) for i in ar: print('밥 : '+i)

print() func1('비빔밥', '공기밥 하나요') func1('비빔밥', '공기밥 하나요','김치 더주세요')

def func2(a, ar): #def func2(ar, a): # 에러 발생, 패킹 연산자는 앞에다 적으면 에러발생, 뒤에다 적어야 한다. print(a) for i in ar: print('밥 : '+i)

print() func2('비빔밥', '공기밥 하나요') func2('비빔밥', '공기밥 하나요','김치 더주세요')

print() def calcProcess(op, *ar): if op == 'sum': re = 0 for i in ar: re += i

elif op == 'mul':
    re = 1
    for i in ar:
        re *= i
return re

print(calcProcess('sum', 1,2,3,4,5)) print(calcProcess('mul', 1,2,3,4,5))

3. 

def func3(w, h, *other): # * - db연동할때 많이 사용한다 기억해야 한다. print('w:{}, h:{}'.format(w, h)) print(other)

func3(55, 160) func3(55, 160, name='홍길동') # {} dict 로 넣으면 안된다.{name='홍길동'}-err func3(55, 160, name='홍길동', age=23)

print() def func4(a,b,c,*d): print(a,b) print(c) print(d) func4(1,2) func4(1,2,3) # 데이터하나 있을때 (3,) 튜플이고 콤마가 있다.(?) func4(1,2,3,4,5) func4(1,2,3,4,5, x=6,y=7) # **d -> {'x': 6, 'y': 7} 이런 모습으로 나옴....

*v1, v2, v3 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5} print(v1) print(v2) print(v3)

```

변수에 생존 범위, 생존 시간 (scope rule)

• 변수 접근 순서 : Local > Enclosing function > Global

player = '전국대표'   # 전역변수 

def funcSoccer():
    name='신기해'    # 지역변수
    print(name, player)

funcSoccer()
print(player)

print('-----------')
a=10; b=20; c=30; #전역변수
print('1) a:{}, b:{}, c:{}'.format(a,b,c)) # a=10; b=20; c=30;
def func1():
    a =40
    b =50
    c =100
    def func2():
        func2_local = 7
        global c # c는 전역변수로 바뀜 
        nonlocal b # b는 func1으로 올라감
        print('2) a:{}, b:{}, c:{}'.format(a,b,c)) # func1()- 기존값 a=40 ,b=50, c=30(global c로인하여 전역변수로 바뀜, 그래서 100이 아니라 30이다.) 
        c =60 # err : local variable 'c' referenced before assignment
              # global c-> c는 전역변수로 바뀌어서 기존 전역변수 c 값 30이 60바뀜.
        b =70 # nonlocal b -> b는 func1()의 b 값으로 되어서 기존 b의 값 50이 70으로 바뀜 
    func2()
    print('3) a:{}, b:{}, c:{}'.format(a,b,c)) # func1()- a=40, b=70, c=100
func1()
print('함수 수행 후) a:{}, b:{}, c:{}'.format(a,b,c)) # 글로벌 변수(전역변수)- a=10, b=20, c=60

function(함수)

• 여러 개의 수행문을 하나의 이름으로 묶은 실행단위(unit)
• 반복 소스의 재활용(단순화)
• 디버깅이 쉽다. -> 유지 보수비가 적게 든다.
• 내장함수, 사용자 정의함수

1. 내장함수 : maker가 제공

   a=3
   print(a)
   print(sum([3,5]))
   print(bin(8))
   print(int(1.6), float(3))
   

a = 10 b = eval('a+5') print(b)

2. 

print(round(1.2), round(1.6)) import math print(math.ceil(1.2), math.ceil(1.6)) # 정수 근사치 중 큰 수 print(math.floor(1.2), math.floor(1.6)) # 정수 근사치 중 작은 수

print() b_list =[True, 1, False] print(all(b_list)) # 모든 값이 참이면 참 print(any(b_list)) # 하나라도 참이면 참

b_list =[1,2,3,4,5,7,16] print(all(a<10 for a in b_list)) # b_list에서 하나씩 꺼내서 10보다 작은지 확인 print(any(a<10 for a in b_list))

print() x=[10,20,30] y=['a', 'b'] for i in zip(x,y): print(i)

3. 함수 만들기, def 함수명(매개변수, ....): ~~

print('뭔가를 하다가...')

def DoFunc1(): # 함수의 생성 print('DoFunc1 수행') # return None # 생략

print('뭔가를 하다가 2...')
DoFunc1() # 함수 호출 print('뭔가를 하다가 2...')
DoFunc1() # 함수 호출

print(DoFunc1) # 파이썬은 대,소문자 구애받지 않는다. DoFunc2 = DoFunc1 # 주소 치환 DoFunc2()

print(DoFunc1()) # 함수문을 수행하면 리턴값이 반드시 있다. 기본 None 리턴

4. 

def DoFunc3(para1, para2):

pass

result = para1 + para2

print(result)

return result

print(DoFunc3(10, 20)) aa = DoFunc3(10, 20)
print(aa) print(id(DoFunc3), DoFunc3, DoFunc3(1,2)) print('현재 파일(모듈)이 사용중인 객체 목록 : ', globals())

print(DoFunc3('대한', '민국'))

print(DoFunc3('대한', 2)) # Type Error - 타입이 안맞아서

print(DoFunc3(1)) # Missing Error - 1개만 써서

print(DoFunc3(1,2,3)) # Missing Error - 2개인데 3개 써서

5.

def DoFunc4(arg1, arg2): if (arg1 + arg2) % 2 == 1: return else: aa =DoFunc5(arg1, arg2) # 함수 내에서 다른 함수 호출 print(aa)

def DoFunc5(arg1, arg2): return arg1 + arg2

DoFunc4(5,6) DoFunc4(5,5)

print() def swapfunc(a,b): return b,a # 하나 리턴함, 두개처럼 보이지만 한개를 리턴한다 # tuple type 으로 묶여 하나의 값으로 반환 # return (b,a) # return [b,a]

6. 

a=10; b=20; print(swapfunc(a,b)) # 반환값 - tuple

print() def func1(): print('func1 함수 멤버') def func2(): print('func1의 내부 함수인 func2 멤버') func2() func1()

7. 

if 조건식 안에 함수 사용

def isOdd(para): return para % 2 == 1 print(isOdd(5)) print(isOdd(6)) print(isOdd(7))

mydict = {x:x*x for x in range(11) if isOdd(x)} print(mydict)

8. 함수 연습용 게임

print('함수 연습용 게임 --- ') import random import time

def gameStart(): print('보물을 찾아 여행을 떠나자. 동굴 문은 두개다') print('동굴 속에는 착한 용과 무서운 용이 있다.') print('랜덤하게 동굴을 선택해 용을 만나면 보물을 획득하고, 나쁜 용을 만나면 죽습니다.')

def chooseCave(): cave='' while cave!= '1' and cave != '2': print('동굴을 선택(1 또는 2)') cave = input() return cave def chkCave(selectNum): print('동굴에 도착했습니다') time.sleep(3) rndNum = random.randint(1, 2)

if selectNum ==str(rndNum):
    print('착한용을 만났지만 보물을 얻지 못했어요. 보물을 얻을 확률은 3%에요')
else:
    print('죽었습니다.')

playAgain='y' while playAgain == 'y': gameStart() caveNumber = chooseCave() chkCave(caveNumber) print('계속 할까요?(y or n)') playAgain = input() ```

추상 클래스(추상 메소드) - 자식 클래스에서 부모의 메소드의 이름을 강요하도록 함

from abc import * 

class AbstractClass(metaclass = ABCMeta): # 추상 클래스가 됨.

    @abstractmethod
    def myMethod(self): # 추상 메소드가 됨
        pass

    def normalMethod(self):
        print('추상 클래스는 일반메소드를 가질 수 있다.')

# parent = AbstractClass() # err - Can't instantiate abstract class

class Child1(AbstractClass):
    name = '난 Child1'

    def myMethod(self):
        print('Child1에서 추상 메소드에 내용을 적용')

c1 = Child1()
print(c1.name)
c1.myMethod()
c1.normalMethod()



print()
class Child2(AbstractClass):
    def myMethod(self):
        print('Child2에서 추상의 마법을 풀다')
        print('이제는 자유다')

    def normalMethod(self):
        print('추상 클래스의 일반 메소드는 오버라이딩이 선택적이다.')

    def good(self):
        print('Child2 고유 메소드')

c2 = Child2()
c2.myMethod()
c2.normalMethod()
c2.good()

print('---------------------')

imsi = c1
imsi.myMethod()
print()
imsi = c2
imsi.myMethod()

print('----------------------------------------------')

from abc import *

class Employee(metaclass = ABCMeta):

    def __init__(self, irum, nai):
        self.irum = irum
        self.nai= nai

    @abstractmethod
    def pay(self): #추상 메소드가 됨
        pass

    @abstractmethod
    def data_print(self):
        pass

    def irumnai_print(self):
        pass

print(' Temporary ')

class Temporary(Employee):
    def __init__(self, irum, nai , ilsu, ildang):
        self.ilsu = ilsu
        self.ildang = ildang
        Employee.__init__(self, irum, nai)

    def pay(self):
        return self.ilsu*self.ildang

    def data_print(self):
        print('이름 : {}, 나이 : {}, 월급 : {}'.format(self.irum, self.nai, str(self.pay())))

class Regular(Employee):
    def __init__(self, irum, nai, salary):
        super().__init__(irum, nai)
        self.salary = salary

    def pay(self):
        return self.salary

    def data_print(self):
        print('이름 : {}, 나이 : {}, 급여 : {}'.format(self.irum, self.nai, str(self.pay())))


class Salesman(Regular):
    def __init__(self, irum, nai, salary, sales, comission):
        super().__init__(irum, nai, salary)
        self.sales = sales
        self.comission = comission
    def pay(self):
        return super().pay() + (self.sales*self.comission)

    def data_print(self):
        print('이름 : {}, 나이 : {}, 수령액 : {}'.format(self.irum,self.nai,str(self.pay())))


t = Temporary('홍길동', 25, 20, 150000)
r = Regular('한국인', 27,3500000)
s = Salesman('손오공', 29,1200000, 50000000, 0.25)

t.data_print() # 이름 : 홍길동, 나이 : 25, 월급 : 3000000
r.data_print() # 이름 : 한국인, 나이 : 27, 급여 : 3500000
s.data_print() # 이름 : 손오공, 나이 : 29, 수령액 : 13700000.0

method override(재정의)

class Parent:
    def printData(self):
        pass

class Child1(Parent):
    def printData(self):    # method override
        print('Child1에서 재정의')


class Child2(Parent):
    def printData(self):    # method override
        print('Child2에서 재정의')        
        print('오버라이드는 부모의 메소드를 자식이 재정의')

    def abc(self):
        print('Child2 고유 메소드')


c1 = Child1()
c1.printData()

print()

c2 = Child2()
c2.printData()

print('다형성 -----')
par = Parent()
par = c1
par.printData()
print()
par = c2
par.printData()
par.abc()

print()
plist =[c1,c2]
for i in plist:
    i.printData()

다중 상속 : 순서가 중요

class Tiger:
    data = '호랑이 세상'

    def cry(self):
        print('호랑이는 어흥')

    def eat(self):
        print('맹수는 고기를 좋아함.')

class Lion:
    def cry(self):
        print('사자는 으르렁')

    def hobby(self):
        print('백수의 왕은 낮잠을 즐김')

class Liger1(Tiger, Lion):  # 다중 상속
    pass

a1 = Liger1()
a1.cry()        
a1.eat()
a1.hobby()
print(a1.data)

print('----------')
class Liger2(Lion, Tiger):
    data = '라이거 만세'

    def hobby(self):
        print('라이거는 자바를 싫어해')
    def showData(self):
        print(self.data, ' ', super().data)
        self.hobby()
        super().hobby()



a2 = Liger2()
a2.cry()
a2.eat()
a2.hobby() # 우선순위가 있다.
a2.showData()

클래스의 상속 : 다형성을 구사 가능

1. class Animal: 
    def __init__(self):
        print('Animal 생성자')
   
    def move(self):
        print('움직이는 동물 고양이 - 단풍이')
   

class Dog(Animal): # 상속 def init(self): # 자식의 생성자가 있을때 부모생성자 호출 x, 자식 생성자만 호출 o print('Dog 생성자') # 부모 생성자는 따로 명시 해야한다.

def my(self):
    print('난 강아지~')

dog1 = Dog()
dog1.move() dog1.my()

print() class Horse(Animal): pass

horse1 = Horse() horse1.move()

2. 

class Person: say = '난 사람' age = '29' __kbs = '공영방송' # private 멤버변수 - person 클래스에서만 유효하다.

def __init__(self, age):
    print('Person 생성자')
    self.age = age      #

def printInfo(self):
    print('나이:{}, 이야기:{}'.format(self.age, self.say))

def hello(self):
    print('안녕', self.__kbs)

print(Person.say, Person.age)

Person.printInfo -> 이렇게는 쓸 수 없다.

p = Person('26') # -> def init(self, age) 일로 넘어옴 p.printInfo() p.hello()

print('**'10) ''' class Employee(Person): pass emp= Employee('27') # 부모 생성자가 실행되어서 - age 인자가 필요함 emp.printInfo() ''' class Employee(Person): say = '일하는 동물' subject = '근로자'

def __init__(self):  
    print('Employee 생성자')

def printInfo(self):
    print('Employee의 printInfo메소드')

def empPrintInfo(self):
    print(self.say, self.age, self.subject)    
    print(self.say, super().say, super().age) # super(). ->  바로 부모 생성자로 올라감
    self.printInfo() # -> 현재 클래스 부터 뒤짐
    super().printInfo() # -> 바로 부모 클래스로 올라가 뒤짐
    self.hello()
    # print(super().say, super().__kbs) -> 에러남, super().__kbs-> person 클래스에서만 유효

emp= Employee() # def init(self) -> 인자를 하나 더 받으면 에러가 남.. emp.printInfo() emp.empPrintInfo()

print('**'10) class Worker(Person): def init(self, age): print('Worker 생성자') super().init(age) # 부모 생성자 호출 - 바운드 메소드 콜

def wprintInfo(self):
    self.printInfo()

wor = Worker('24') print(wor.say, wor.age) wor.wprintInfo()

print('**'10) class Programmer(Worker): def init(self, age): print('Programmer 생성자') # super().init(age) # Bound call Worker.init(self, age) # UnBound call

def ProShow(self):
    self.printInfo()

pr = Programmer('내년 30') print(pr.say, pr.age) pr.ProShow()

print('~') print(type(3)) print(type(pr)) print(type(wor)) print(Programmer.bases, Worker.bases, Person.bases)

자원의 재활용 : 클래스는 다른 클래스를 불러다 사용 가능

• 클래스의 포함관계(has a)

class Pohamhandle:  #핸들이 필요한 어떤 클래스에서든 호출될 수 있다.
    quantity= 0  # 회전량

    def LeftTurn(self, quantity):
        self.quantity = quantity
        return '좌회전'

    def RightTurn(self, quantity):
        self.quantity = quantity
        return '우회전'

    # ...

# 여러 자동차를 위한 여러 부품 별도의 클래스로 제작 : 생략

# 완성차 클래스 
class PohamCar:
    turnShowMessage = '정지'

    def __init__(self, ownerName):
        self.ownerName = ownerName
        self.handle = Pohamhandle() # 클래스의 포함

    def TurnHandle(self, q):
        if q > 0 :
            self.turnShowMessage = self.handle.RightTurn(q)
        elif q < 0 :
            self.turnShowMessage = self.handle.LeftTurn(q)
        elif q == 0 :
            self.turnShowMessage = '직진'
            self.handle.quantity= 0

if __name__ == '__main__':
    tom = PohamCar('톰')
    tom.TurnHandle(10)
    print(tom.ownerName + '의 회전량은 '+ tom.turnShowMessage + str(tom.handle.quantity))

    tom = PohamCar('톰')
    tom.TurnHandle(0)
    print(tom.ownerName + '의 회전량은 '+ tom.turnShowMessage + str(tom.handle.quantity))
    print()
    oscar = PohamCar('오스카')
    oscar.TurnHandle(-5)
    print(oscar.ownerName + '의 회전량은 '+ oscar.turnShowMessage + str(oscar.handle.quantity))

# 내장고에 음식 담기 - 클래스의 포함관계로 구현


class Fridge:
    isOpened = False
    foods = []

    def open(self):
        self.isOpened =True
        print('냉장고 문 열기')

    def put(self, thing):
        if self.isOpened:
            self.foods.append(thing) # 포함관계
            print('냉장고 안에 음식을 저장함.')
            self.food_list()
        else:
            print('냉장고 문이 닫쳐 있어 음식을 저장할 수 없다.')

    def close(self):
        self.isOpened = False
        print("냉장고 문 닫기")



    def food_list(self):
        for f in self.foods:
            print('-', f.name, f.expiry_date)
        print()

class FoodData:
    def __init__(self, name, expiry_date):
        self.name = name
        self.expiry_date = expiry_date

if __name__ == '__main__':
    f = Fridge()

    apple = FoodData('사과', '2022-10-25')
    f.put(apple)
    f.open()
    f.put(apple)
    f.close()
    print()
    minfe=FoodData('민철','2088-11-11')
    f.open()
    f.put(minfe)
    f.close()

클래스의 포함관계 : 로또번호 출력기

import random

class LottoBall:
    def __init__(self, num):
        self.num = num

class Lottomachine:
    def __init__(self):
        self.ballList =[]
        for i in range(1, 46):
            self.ballList.append(LottoBall(i)) #포함 관계

    def selectBalls(self):
        # 볼 섞기 전 출력하기
        for a in range(45):
            print(self.ballList[a].num, end=' ')
        random.shuffle(self.ballList)   # 랜덤하게 공을 섞기 
        print()
        for a in range(45):
            print(self.ballList[a].num, end=' ')
        return self.ballList[0:6]


print()
class LottoUi:
    def __init__(self):
        self.machine = Lottomachine() # 포함

    def playLotto(self):
        input('로또를 시작 하려면 엔터키를 누르세요!')
        selectedBalls = self.machine.selectBalls()
        print('당첨번호')
        for ball in selectedBalls:
            print('%d '%ball.num, end=' ')

if __name__ == '__main__':
    #lo = LottoUi()
    #lo.playLotto()
    LottoUi().playLotto()

# class : 새로운 타입을 생성
print('가수 관련 클래스')

class SingerType(): title_song = '화이팅 코리아'

def sing(self):
    msg = '노래는 '
    print(msg, self.title_song+ 'la la la')

2. import

가수 한 명을 탄생!

from pack02.class4 import SingerType

def process():

youngwoung = SingerType()
print('영웅의 타이틀 송 : ', youngwoung.title_song)
youngwoung.sing()

def process2(): bts = SingerType() bts.sing() bts.title_song = 'yet to come' bts.sing() bts.co = 'HIVE' print('소속사:', bts.co) print() blackPink = SingerType() blackPink.title_song='shut down' blackPink.sing() blackPink.co = 'YG' print('소속사:', blackPink.co)

process()

if name == 'main': process() print('------') process2()

3. 예제 - 카페 자판기 만들기

class CoinIn:

def insert(self):
    self.coin=int(input('동전을 넣어주세요'))
    return self.coin

class Machine:

def showData(self):

    print('커피는 한잔에 200원 입니다')
    self.coin=CoinIn().insert()
    self.count=int(input('몇잔을 원하세요?'))

    if 200*self.count > self.coin:
        print('요금이 부족합니다')
    elif 200*self.count <= self.coin:
        refund=self.coin-(200*self.count)
        print('커피 %d잔과'%self.count,'잔돈 %d원'%refund)

if name=='main': Machine().showData()

- 다른 코드

class CoinIn: def calc(self, cupCount): re = ""

    if self.coin < 200:
        re = "요금이 부족하네요"
    elif cupCount * 200 > self.coin:
        re = "요금이 부족하네요"
    else:
        self.change = self.coin - (200 * cupCount)  # 잔돈 계산
        re = "커피 {}잔과 잔돈 {}원".format(cupCount, self.change)

    return re

class Machine(): cupCount = 1 # 현재 코드에서는 의미 없음

def __init__(self):
    self.coinIn = CoinIn()  # 포함

def showData(self):
    self.coinIn.coin = int(input("동전을 입력하세요 :"))
    self.cupCount = int(input("몇 잔을 원하세요 :"))

    print(self.coinIn.calc(self.cupCount))

if name == 'main': Machine().showData() ```

class : 새로운 타입을 생성. 객체 지향적(중심적)인 프로그래밍

• 형식 class 클래스명(): 멤버(필드, 메소드) ~
• 생성자, 소멸자가 있다, 접근지정자가 없다.
• 다중상속 가능, interface가 없다.

1. print('뭔가를 하다가 모듈의 멤버인 클래스를 선언하기')
   class TestClass:    # prototype , 원형클래스 객체 생성. 고유의 이름 공간을 확보
    aa =1 # 멤버변수(멤버필드), public
   
    def __init__(self): # 생성자
        print('생성자')
   
    def __del__(self):
        print('소멸자')
   
    def printMessage(self): # method
        name= '한국인'  # 지역변수
        print(name)
        print(self.aa)
   

print(TestClass, id(TestClass)) print(TestClass.aa)

test = TestClass() # 생성자를 호출한 후 TestClass type의 객체 생성 print(test.aa) # 멤버필드 호출

메소드 호출

TestClass.printMessage() => 에러뜸

test.printMessage() TestClass.printMessage(test) # UnBound method call print() test.printMessage() # Bound method call

2. 

class Car: handle = 0 # Car type의 객체에서 참조 가능 멤버 필드 speed = 0

def __init__(self, name, speed):
    self.name = name
    self.speed = speed

def showData(self): # Car type의 객체에서 참조 가능 멤버 메소드
    km = '킬로미터'
    msg = '속도:' + str(self.speed) + km + ', 핸들은 ' + str(self.handle)
    return msg

print(id(Car)) print(Car.handle) print(Car.speed) print('-------') car1 = Car('tom', 10) # 생성자 호출 후 객체 생성-> init 으로 print(car1.handle, car1.name, car1.speed) car1.color = '보라해' print('car1 color : %s'%car1.color)

print('-------') car2=Car('james', 20) print(car2.handle, car2.name, car2.speed)

print('car2 color : %s'%car2.color) # err ->'Car' object has no attribute 'color'

print('주소 : ', id(Car), id(car1), id(car2))

print(car1.showData()) print(car2.showData()) # 바운드 메소드 콜 print(Car.showData(car2)) # 언바운드 메소드 콜 print("------") car2.speed = 100 Car.handle = 1 car1.handle = 2 print('car1 : ', car1.showData()) # 10 print('car2 : ', car2.showData()) # 100 ''' Car의 설계도가 static에 있고 car1=Car('tom',10) 하면 car1이라는 변수가 stack 영역에 있는데 car1이 heap 영역에 있는 Car('tom',10) 의 주소를 참조 '''

3. class의 이해

kor = 100 # 전역변수

def abc(): # 함수 a = 10 # 지역 변수 print('함수')

class MyClass: # 클래스 kor =90 # 멤버변수

"""
def __init__(self): 되도록 안쓰는것이 좋음
    pass
"""
def abc(self):
    print('메소드')

def show(self):
    #kor = 80    # 지역변수
    print(self.kor)
    print(kor)  # 지역변수를 찾다가 없으면 전역변수 참조
    self.abc()  # 메소드 콜
    abc()       # 함수 콜

my = MyClass() my.show() ```

for 변수 in 집합형 자료:...

1.

#for i in [1,2,3,4,5]: # list
#for i in (1,2,3,4,5): # 튜플
for i in {1,2,3,4,5}: # set
    print(i, end=' ')    
print()
soft ={'java':'웹영언어', 'python':'만능언어', 'MariaDB':'데이터 처리'}
print(soft.items()) #dict_items([('java', '웹영언어'), ('python', '만능언어'), ('MariaDB', '데이터 처리')])

for i in soft.items():
    #print(i) # 튜플만 보임
    print(i[0] + '^^;' + i[1])

print()
for k in soft.keys():
    print(k, end=' ')

print()
for k in soft.values():
    print(k, end=' ')

2. print()
   li = ['a','b','c']
   for idx, data in enumerate(li): # enumerate() - index를 반환함
    print(idx, data)
   

print('\n평균, 분산, 표준편차 구하기') # 평균이란... 검색해보기 jum = [1,3,5,7,9] print(jum)

tot =0 for i in jum: tot +=i

avg =tot/len(jum) print('mean : ', avg)

tot= 0 for i in jum: tot += (i - avg) ** 2 # (i - avg)-편차

var = tot/len(jum) print('var : ', var) # 분산은 편차 제곱합의 평균 import math print('std : ', math.sqrt(var)) # 표준편차 # = print('std : ', var ** 0.5)

3. 다량의 문자열 데이터 중 단어 수 출력

import re ss = ''' 5일 코로나19 신규확진자 수가 3만4739명을 기록했다. 전일보다 1420명 줄었다. 위중증 환자와 사망자 등 방역 관련 모든 지표가 안정세다. 이제 방역 관건은 코로나19 자체보다 독감이라는 말이 의료계에서 나온다. 3년만에 독감 유행이 예고됐으며 독감과 코로나19가 동시 유행할 경우 환자 중증도가 크게 올라갈 우려가 있어서다. 게다가 올해 유행할 독감은 독감 바이러스 중에서도 가장 강한 'A형 H3N2'다. 적극적 독감백신 접종이 필요하다는 것이 방역당국과 의료계 공통된 의견이다. 중앙방역대책본부는 이날 0시 기준 신규확진자 수가 3만4739명을 기록했다고 밝혔다. 이 가운데 해외 유입사례 69명을 제외한 국내 확진자 수는3만4670명이었다. 수도권에서 전체 국내 확진의 56.5% 비중인 1만9587명이 확진됐다. 재원중 위중증 환자는 330명으로 전일대비 20명 감소했다. 사망자는 16명으로 전일보다 3명 줄었다. 누적 사망자는 2만8544명(치명률 0.11%)이다. ''' print(ss) print() ss2 = re.sub(r'[^가-힣\s]', '', ss) print(ss2) ss3 = ss2.split(' ') print(ss3)

cou={} # 단어의 발생 횟수를 dict 로 저장 for i in ss3: if i in cou: cou[i]+=1 else: cou[i]=1 print(cou)

4. 

for test_str in ['111-1234', '일이삼-사오육칠', '222-1234']: if re.match(r'^\d{3,4}-\d{4}$',test_str): print(test_str, '전화번호 맞아요') else: print(test_str, '음...')

5.

print('사전형 사료로 과일값 출력') price ={'사과':2000, '감':500, '배':1000} guest ={'사과':2, '감':3} bill = sum(price[f] * guest[f] for f in guest) print('고갱님이 구매한 과일 총액 : {}원'.format(bill))

고갱님이 구매한 과일 총액 : 5500원

6.

temp =[1,2,3] for i in temp : print(i, end=' ') print() print([i for i in temp]) print({i for i in temp})

temp2 = list() for i in temp: temp2.append(i + 10) print(temp2) temp2 =[i+10 for i in temp] print(temp2)

print() datas =[1,2,'a', True, 3] li =[i * i for i in datas if type(i) == int] print(li)

print() datas = {1,1,2,2,2,3} se = {i*i for i in datas} # set type 이라 중복을 제거 print(se)

print() id_name = {1:'tom', 2:'james'} name_id ={value:key for key, value in id_name.items()} print(name_id)

### for + range

1. 

print(list(range(1,6,1))) # 1부터 6사이에 숫자를 표시하고, 그 숫자들의 차이가 1이다. print(set(range(1,6))) print(tuple(range(1,6))) print(list(range(1,11,2))) # 1부터 11사이에 숫자를 표시하고, 그 숫자들의 차이가 2이다.

print(list(range(6))) print(list(range(0,6,1))) print(list(range(-10, -100, -20)))

2. _ : 반복만 해줘, 참조X

for _ in range(6): # _ : 반복만 해줘, 참조X print('hi', end=' ') # pass

3. 구구단 2단 만들때

for i in range(1,10): print('{0}{1}={2}'.format(2, i, 2i), end=' ')

4. 예제1

문1) 2~9 단 까지 출력

for n in range(2,10): print('---{}단---'.format(n)) for i in range(1,10): print('{}{}={}'.format(n, i, ni)) print()

5. 예제2

문2) 1~100 사이의 3의 배수이면서 5의 배수의 합 출력

a=0; for n in range(1,101): if n % 3 == 0 and n % 5 ==0: a += n print('합은', a) # 합은 315

6. 예제3

문3) 주사위를 두번 던져서 나온 숫자들의 합이 4의 배수가 되는 경우만 두 수 출력

출력 예) 1 3

2 2

...

for i in range(1,7): for j in range(1,7): su = i + j if su % 4 == 0: print(i, j) print()

7. 

n-gram : 문자열에서 N개의 연속된 요소를 추출하는 방법

text='hello'

for i in range(len(text)-1): print(text[i:i+2])

''' he el ll lo ''' ```

1. a=0
   while a < 10:
    a += 1
    if a ==3:continue
    if a ==5:break
    print(a)
   else: # while문이 정상적으로 수행되었는지 확인하기 위해 쓸 수 있다.
    print('while문 정상 수행')
   print('while 수행 후 %d'%a)

2. 난수 발생

   # 난수 발생 
   import random
   random.seed(2) # 랜덤한 값을 고정시키고 싶을때 사용, 
   num = random.randint(1, 10)
   #print(num)
   # while True: #무한루프
   #     print('1~`0 사이의 컴이 가진 예상 숫자 입력:')
   #     guess = int(input())
   #     if guess == num:
   #         print('성공'*10)
   #         break
   #     elif guess < num:
   #         print('더 큰 수 입력')
   #     elif guess > num:
   #         print('더 작은 수 입력')

3. 의사 난수(pseudo random)

   friend = ['tom', 'john', 'oscar']
   print(friend)
   print(random.choice(friend)) # 하나만 랜덤하게 선택
   print(random.sample(friend, 2)) # 표본 랜덤하게 2개만 뽑기
   random.shuffle(friend)
   print(friend)

while 조건 : ~ 참이면 수행

1. a =1
   while a <= 5:
    print(a, end=' ')
    a += 1
   

print('while 수행 후 %d'%a)

1 2 3 4 5 while 수행 후 6

print() i=1 while i<=3: j=1 while j<4: print('i:'+str(i) + ', j:' +str(j)) j =j+1 i += 1

2. 

print('1~100 사이의 정수 중 3의 배수의 합 출력') i=1; hap=0 while i<100: if i % 3 == 0: # print(i, end=' ') hap += i i += 1 # print(i, end=' ')

print('합은 {}'.format(hap)) # 합은 1683

3.

colors=['r', 'g', 'b'] print(colors[0]) a=0 while a<len(colors): print(colors[a], end=' ') a +=1

print()

while colors: print(colors.pop(0), end=' ') # print(len(colors))

''' r r g b r g b '''

4.

i=1 while i <= 10: j=1 re='' while j<=i: re =re + '' j += 1 print(re) i += 1 """ * *

"""

5. 폭탄 스위치 

import time #time.sleep(3) sw =input('폭탄 스위치를 누를까요?[y/n]') if sw == 'Y' or sw == 'y': count =5 while 1 <= count: print('%d 초 남았습니다.'%count) time.sleep(1) count -= 1 print('폭발합니다.') elif sw == 'N' or sw == 'n': print('작업 취소') else: print('y 또는 n을 누르세요')

print('end')

6. 예제1

문1) 1 ~ 100 사이의 숫자 중 3의 배수이나 2의 배수가 아닌 수를 출력하고, 합을 출력

i=0; hap=0 while i<=100: i += 1 if i % 3 == 0 and not i % 2 == 0: # i % 2 != 0 print(i, end=' ') hap += i

print('합은 {}'.format(hap))

3 9 15 21 27 33 39 45 51 57 63 69 75 81 87 93 99 합은 867

7. 예제2

#문2) 2 ~ 5 까지의 구구단 출력 i=1 while i < 5: i += 1 j = 1 while j <10: print(i, 'X', j, '=', i*j) j += 1

8. 예제3

#문3) -1, 3, -5, 7, -9, 11 ~ 99 까지의 모두에 대한 합을 출력 i=1 cnt=1 tot=0

while i<100: if cnt % 2 ==0: # 짝수 위치 숫자 처리 tot += i print(i, end =' ') else: # 홀수 위치 숫자 처리 k = i * -1 # 부호 변경 tot += k print(k, end=' ') cnt += 1 i += 2 # 증가치 2 print('\ntot : ', tot)

tot : 50

9. 예제4

문4) 1 ~ 1000 사이의 소수(1보다 크며 1과 자신의 수 이외에는 나눌 수 없는 수)와 그 갯수를 출력

aa=2 count=0

while aa<=1000: imsi =False bb=2;

while bb<= aa -1:
    if aa % bb == 0:
        imsi = True
    bb += 1

if imsi == False:
    print(aa, end=' ')
    count += 1
aa += 1

print('\ncount : ', count)

count : 168

### while / if 연습문제

1. 

문1) 1 ~ 100 사이의 숫자 중 3의 배수이나 2의 배수가 아닌 수를 출력하고, 합을 출력

i = hap = 0

while i <= 100: i += 1 if i % 3 == 0 and i % 2 != 0: print(i, end = ' ') hap += i

print('합은 {}'.format(hap))

3 9 15 21 27 33 39 45 51 57 63 69 75 81 87 93 99 합은 867

2. 

문2) 2 ~ 5 까지의 구구단 출력

print() i = 2 while i < 6: j = 1 while j < 10: print(i, '*' , j, '=', i * j, end = ' ') j += 1 print() i += 1

import re

ss ="12_1234 abc가나다abc_nbc_ABC_1234555_6한국Python is fun." print(ss) print(re.findall(r'123', ss)) # r을 쓰는게 좋다. print(re.findall(r'가나다', ss)) print(re.findall(r'1', ss)) print(re.findall(r'[1-2]', ss)) print(re.findall(r'[0-9]', ss)) #정규표현식에선 띄어쓰기 하면안됨. print(re.findall(r'[0-9]+', ss)) print(re.findall(r'[0-9]{2}', ss)) # {} - 횟수 반복(?) print(re.findall(r'[0-9]{2,3}', ss))#2개짜리~ 3개짜리 print(re.findall(r'[a-z]+', ss)) print(re.findall(r'[A-Za-z]+', ss)) # + - 한개 이상, * - 0개 이상, ? - 0 또는 1 print(re.findall(r'[가-힣]+', ss)) print(re.findall(r'[^가-힣]+', ss)) # ^ - 부정 print(re.findall(r'12|34', ss)) print(re.findall(r'.bc', ss)) # . - 아무거나 print(re.findall(r'...', ss)) # ... - 세글자 아무거나 print(re.findall(r'[^1]+', ss)) # 부정 print(re.findall(r'^1+', ss)) # 첫글자 1 print(re.findall(r'fun.$', ss)) # $ 끝나는거

print(re.findall(r'\d', ss)) # 숫자만 나옴 print(re.findall(r'\d+', ss))# 그룹이 된다. print(re.findall(r'\s', ss)) print(re.findall(r'\S', ss)) print(re.findall(r'\d{1,3}', ss)) # 1~3 까지

print() p=re.compile('the', re.IGNORECASE) print(p) print(p.findall('The do the dog')) print()

ss='''My name is tom. I am happy''' print(ss) p=re.compile('^.+',re.MULTILINE) print(p.findall(ss))

['My name is tom.', 'I am happy']

#### 조건 판단문 if
#### if 조건 : 실행문 elif 조건 ~ else : ~

var =1 if var >= 3: #java : {}, py : 들여쓰기 print('크구나') print('참일 때') # pass 아무것도 수행 하지 않음. else: print('거짓일 때')

print('end1')

print() money= 1000 age= 35

if money >= 500: item ='사과' if age <= 30: msg ='청춘이다' else: msg ='라떼는 말야...' else: item ='포도' if age >= 30: msg ='성인이다' else: msg ='잼민이다' print(item, msg)

jumsu = 85 if jumsu >= 90: print('우수') else: if jumsu >= 70: print('보통') else: print('망')

print() if jumsu >= 90: print('우수') elif jumsu >= 70: print('보통') else: print('망')

print() print(int('5')+5) # 형변환 : int(), str() print(str(5)+'5')

#jum = int(input('점수 입력:')) jum =80

print(jum, type(jum))

#if jum >= 90 and jum <=100:

if 90 <= jum <= 100: grade='우수학생' elif 70 <= jum <90: grade ='보통학생' else: grade ='저조학생' print(grade)

print() names =['홍길동', '신기해', '이기자'] if '홍길동' in names: # not in - 부정, 부정문 좋지 않음 -속도가 떨어짐 print('친구 이름') else: print('누구니?')

print()

jumsu = 85 if jumsu >= 90: print('우수') else: if jumsu >= 70: print('보통') else: print('망')

print() if jumsu >= 90: print('우수') elif jumsu >= 70: print('보통') else: print('망')

print() print(int('5')+5) # 형변환 : int(), str() print(str(5)+'5')

#jum = int(input('점수 입력:')) jum =80

print(jum, type(jum))

#if jum >= 90 and jum <=100:

if 90 <= jum <= 100: grade='우수학생' elif 70 <= jum <90: grade ='보통학생' else: grade ='저조학생' print(grade)

print() print(int('5')+5) # 형변환 : int(), str() print(str(5)+'5')

#jum = int(input('점수 입력:')) jum =80

print(jum, type(jum))

#if jum >= 90 and jum <=100:

if 90 <= jum <= 100: grade='우수학생' elif 70 <= jum <90: grade ='보통학생' else: grade ='저조학생' print(grade)

print() names =['홍길동', '신기해', '이기자'] if '홍길동' in names: # not in - 부정, 부정문 좋지 않음 -속도가 떨어짐 print('친구 이름') else: print('누구니?')

print() a = 'kbs' b = 9 if a == 'kbs' else 11 # 이런식으로 많이 사용한다. print(b)

a = 11 b = 'mbc' if a == 9 else 'kbs' print(b)

print() a = 3 if a <5: print(0) elif a<10: print(1) else: print(2)

print(0 if a < 5 else 1 if a <10 else 2)

print(a * 2 if a > 5 else a + 2 )

print((a+2, a2)[a >5]) # [a >5] -> false 라서 a+2 실행, true면 a2 실행

```

1. 문자열 : str - 순서 o: 인덱싱(하나의 값만 참조), 슬라이싱(여러값 참조)이 가능 , 수정 x

   s="sequence"
   print(s, type(s), len(s))
   print(s.count('e'))
   print(s.find('e'), '', s.find('e',3), s.rfind('e'))# rfind- 뒤에서부터

   # 수정 불가
   ss='mbc'
   print(ss, id(ss))
   ss='abc'
   print(ss, id(ss))

2. 인덱싱, 슬라이싱 대상[start:stop:step]

   s='sequence'
   print(s[0], s[3]) # s[8] err남
   print(s[-1], s[-3])
   

print(s[0:3], s[3:], s[:3], s[:], s[1:5:2], s[::2]) #0 이상 3 미만, 3자리 이후로, 3자리 까지, 몽땅 다, 1이상 5미만 증가치2, 모든 글자에서 2번째는 빼고 print(s[-4:-1], s[-3:]) print('fre' + s[2:]) # 일부의 값만 참조 print()

s2='kbs mbc' s2=' ' + s2[:4] + 'sbs ' + s2[4:] + ' ' print(s2, len(s2)) print(s2.strip()) # strip() -> 인자를 전달하지 않으면 String에서 공백을 제거한다. # lstrip() -> 인자로 전달된 문자를 왼쪽에서부터 제거한다. # rstrip() -> 인자로 전달된 문자를 오른쪽에서부터 제거한다.

s3=s2.split(sep=' ') #split() -> 문자열을 일정한 규칙으로 잘라서 리스트로 만들어 주는 함수이다. print(s3) print(':'.join(s3)) #join -> ':'(매개변수로 들어온)를 넣어서 문자열을 합쳐서 반환해주는 함수

a='life is too long' b=a.replace('life', 'Your leg') print(b)

3. 묶음형(집힙형) 자료형 : list - 순서 o, 수정 가능

a= [1,2,3]; b=[10, a, 12.5, True, '금쪽이'] print(a, type(a), id(a)) print(b, type(b), id(b)) aa =[] bb= list() print(type(aa), type(bb))

family=['엄마','아빠','나','형'] print(family[2]) # 인덱싱 print(family[0:2])# 슬라이싱- 0~1번까지 family.append('단풍이') # append() - 추가 - 맨뒤에 붙음 family.insert(0, '할아버지') # 삽입 - 0번째에 넣어라 family.extend(['외삼촌', '큰누나']) #추가 family += ['작은이모', '큰이모'] family.remove('단풍이') # remove는 밸류를 삭제 del family[2] # del은 순서에 의한 삭제, 아빠 지워짐 - 2번째 지워짐 print(family, len(family)) print(family.index('나')) print('엄마' in family, '할머니' in family) # 있는지 확인하는거 del family # 변수를 삭제

- 중첩 list

aa =[1,2,3,['a', 'kbs', 'c'],4,5] #중첩 list print(aa) print(aa[0]) print(aa[3]) print(aa[3][1]) # 3번째 꺼에서 1번째 꺼 - kbs만 나옴

print(id(aa)) aa[0] = 333 # 요소값 수정 가능 print(aa, id(aa))

print() aa2=['123', '34', '234'] print(aa2) aa2.sort() # 사전형식으로 정렬 print(aa2) aa2.sort(key=int, reverse=True) # 문자를 숫자처럼 하고 가장 큰수부터 나열 print(aa2)

name=['소현', '금쪽이', '다정'] print(name) name2 = name # 얕은 복사 : 주소 치환 / 자바 와 파이썬은 소멸자가 없다 (일정시간이 지나면 메모리가 자동 소멸) print(id(name), id(name2))

import copy name3 =copy.deepcopy(name) # 깊은 복사. 새로운 객체로 생성

print(id(name), id(name2), id(name3)) name[0] = '용환' print(name) print(name2) print(name3)

- 참고

print("stack, queue") #stack : LiFO(last), queue : FiFO(first) sbs=[1,2,3] sbs.append(4) print(sbs) sbs.pop() print(sbs) sbs.pop() print(sbs) #뒤에서 부터 빠져나감.

print() sbs=[1,2,3] sbs.append(4) sbs.pop(0) print(sbs) sbs.pop(0) print(sbs) #앞에서 부터 빠져나감.

4. tuple - list와 유사하나 읽기 전용. 순서O, 수정 불가

t = ('a', 'b', 'c', 'a') #t = 'a', 'b', 'c', 'a' print(t, type(t),len(t), t.count('a'), t.index('b'))

print(t[0]) #t[0] = 'k' # 'tuple' object does not support item assignment - 수정 불가

imsi =list(t) print(imsi, type(imsi)) imsi[0] = 'k' t = tuple(imsi) print(t)

print() print((1), type((1))) print((1,), type((1,))) # ,를 찍어야 튜플로 인정된다(반드시).

print() t1=(10,20) a, b = t1 b, a = a, b t2 =a,b print(t2)

5. set - 순서가 없다, 중복이 불가하다! (순서X, 중복X)

print('----------set-----------')

set - 순서가 없다, 중복이 불가하다! (순서X, 중복X)

a={1,2,3,1} print(a, type(a), len(a))

b={3,4}

print(a.union(b)) # 합집합 print(a.intersection(b)) # 교집합 print(a-b) # 차집합 print(a | b) # 합집합 print(a & b) # 교집합

print() print(a) #print(a[0]) -> err 순서가 없기 때문에 에러발생 #a[0]=100 -> 'set' object does not support item assignment - set은 순서가 없다

a.update({4,5}) # .update함수를 통해 수정이(추가) 가능함. a.update([6,7,8]) a.update((9,)) print(a)

a.discard(3) # 값에 의한 삭제(순서에 의한 삭제는 없다) a.remove(5) # 값에 의한 삭제 a.discard(3) # 값에 의한 삭제 - 해당 값이 없으면 통과한다. #a.remove(5) # 값에 의한 삭제 - 해당 값이 없으면 에러가 발생한다. print(a)

c=set() c=a print(c) a.clear() # 날리는거 print(a) print(c)

print() li=[1,2,3,1,2,3] print(li) imsi=set(li) # 중복 배제 li=list(imsi) print(li)

6. dict : {'key':'value'} - 순서X, key를 이용해 value를 참조, JSON과 잘맞음

print('----------dict-----------')

사전형 : {'key':'value'} - 순서X, key를 이용해 value를 참조, JSON과 잘맞음

my = dict(k1=1,k2='mbc', k3=3.4) print(my, type(my))

dic={'파이썬':'뱀', '자바':'커피', '스프링':'용수철', '점수':[60,70,80]} print(dic, type(dic), len(dic)) print(dic['자바']) #print(dic[0]) -> 순서가 없어서 err발생

dic['오라클']='예언자' # 추가 가능함 print(dic)

del dic['오라클'] # 삭제 dic.pop('파이썬') print(dic)

dic['자바']='웹용언어' # 수정이 가능 print(dic)

print(dic.keys()) print(dic.values()) print('파이썬' in dic)

- 정리

''' str : 순서O, 수정X list: 순서O, 수정O [] tuple:순서O, 수정X () set : 순서X, 수정X, 중복X {} dict: 순서X, 키에 의한 value 참조 {:} ''' ```

var1= '안녕'
print(var1)
var1=5
print(var1)

A=1; a=2; # 변수는 대소문자 구별함
print('A+a',A + a, id(A), id(a))
# A+a 3 2039314475312 2039314475344

변수 선언시 type은 선언하지 않는다.

2. 값의 주소비교

print()
a=10
b=12.5
c=b 
print(a, '', b, '', c)
# 10  12.5  12.5

print('주소출력 :', id(a), '', id(b),'', id(c))
# 주소출력 : 2039314475600  2039324178608  2039324178608
# b와 c 는 같은 주소를 가지고 있다. 절대 주소는 아니다.

print(a is b, a==b) # False False - 주소 비교, 값 비교
print(c is b, c==b) # True True - is는 결과를 true, false로 답한다.

aa = [1000]
bb = [1000]
print(aa == bb, aa is bb) # True False
print(id(aa), '' , id(bb))
# 2039324349312  2039324347328
# aa 와 bb의 값이 같지만 주소는 같지 않다.

3. 주석 표기

# 한줄 주석
'''
여러줄 주석
''' 
"""
여러줄 주석
""" 

4. keyword

import keyword
# 키워드(Keyword)는 파이썬에서 이미 예약되어있는 문자열로 다른 용도로 사용이 불가능하여 변수로 설정 안된다 오류난다.
print('키워드(예약어)목록 : ', keyword.kwlist)
# 키워드의 리스트 목록

5. 자료형

print(3, type(3)) # int(정수) 타입
print(3.4, type(3.4)) # float(실수) 타입
print(3 + 4j, type(3+4j)) # complex(복소수) 타입
print(True, type(True)) # boolean 타입
print("good", type('good')) # string 타입

print((1,), type((1,)))# (1,) 튜플 타입
print([1], type([1])) # [1] 리스트
print({1}, type({1})) # {1} set 타입
print({'k':1}, type({'k':1})) # {'k': 1} 딕셔너리

print(isinstance(1, int)) #type을 확인하는 연산자. True
print(isinstance(1.2, float))
# True

6. 치환

v1=2 #치환
v1=v2=v3=v4=5
print(v1,v2,v3,v4) # 5 5 5 5

v1=1,2,3
print(v1) # (1, 2, 3)

v1,v2=10,20
print(v1,v2) # 10 20
v2,v1=v1,v2
print(v1, v2) # 20 10

7. 값 할당 packing

*v1,v2 = 1,2,3,4,5
v1,*v2 = 1,2,3,4,5
#*v1,*v2 = 1,2,3,4,5 - 에러가 발생한다.
print(v1) # 1
print(v2) # [2, 3, 4, 5]

*v1,v2,v3=1,2,3,4,5
print(v1,v2,v3) # [1, 2, 3] 4 5

packing은 여러개의 변수를 하나에 담는것이다.

8. 연산자

print(5+3,5-3,5*3,5/3) # 8 2 15 1.6666666666666667
print(5 // 3, 5%3, divmod(5,3)) # 몫 과 나누기 1 2 (1, 2)

연산자 우선순위

print('연산자 우선순위', 3+4*5, (3+4)*5) # 23 35
# 소괄호 () > 산술 연산자(**거듭제곱 > *,/ > +, -) > 관리연산자 > 논리연산자 > 치환(=)

관계연산자(== 값이 같은지, != 값이 다른지)

print(5>3, 5==3, 5 != 3)
# True False True

논리연산자

• and : 모두 true어야 true반환
• or : 둘 중 하나만 true여도 true 반환
• not : 반대로 해석, 만약 a가 true면 false, b가 false면 true를 반환

  print(5>3 and 4<3, 5>3 or 4<3, not(5>=3))
  # False True False

  
  

# 문자열 더하기 연산자
print('파이썬'+'만'+'세') # 파이썬만세
print('파이썬'*10)
# 파이썬파이썬파이썬파이썬파이썬파이썬파이썬파이썬파이썬파이썬

# 누적
a=10
a= a+1
a += 1
#a++ 파이썬은 증감연산자 없다.
print('a:', a) # a: 12

print(a, a* -1, -a, --a)
# 12 -12 -12 12

9. 출력 서식

print(format(123.45678, '10.3f')) #전체 10자리 확보하고 앞에 3자리 공백, 4번째 자리에서 반올림 하기
#   123.457
print(format(123.45678, '10.3'))
#  1.23e+02
print(format(123, '10d')) 
#       123
print ('{0:.3f}'.format(1.0/3)) # 소수 세번째자리 까지
#0.333
print ('{0:_^11}'.format('hello'))
# ___hello___
print ('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))
# Swaroop wrote A Byte of Python

많이 사용하는것

print('이름:{0}, 가격:{1}'.format('마우스', 5000))
# 이름:마우스, 가격:5000
print('이름:{0}, 가격:{1}'.format('마우스', 5000))
# 인덱스를 쓰지않아도 순서대로 들어옴, 이름:마우스, 가격:5000
print('이름:{1}, 가격:{0}'.format('마우스', 5000))
# 이름:5000, 가격:마우스
print('이름:{1}, 가격:{0}, 가격:{0} '.format('마우스', 5000))
# 이름:5000, 가격:마우스, 가격:마우스

print('나는 나이가 %d 이다.'%28) 
# 나는 나이가 28 이다.
print('나는 나이가 %s 이다.'%'스물여덟')# 문자
# 나는 나이가 스물여덟 이다.
print('나는 나이가 %d 이고 이름은 %s이다.'%(23, '홍길동'))
# 나는 나이가 23 이고 이름은 홍길동이다.
print('나는 나이가 %s 이고 이름은 %s이다.'%(23, '홍길동'))
# 나는 나이가 23 이고 이름은 홍길동이다.
print('나는 키가 %f이고, 에너지가 %d%%.'%(177.7, 100)) 
#실수 ,%f - 소수6자리 정해짐.
#나는 키가 177.700000이고, 에너지가 100%.

• %s : 문자열 치환, 그러나 어떤 자료도 다 치환된다.
• %d : 정수 치환
• %f : 소수점 치환, 소수점 6자리까지 정해진다.
• %10(s,d,f) : 왼쪽으로부터 공백 10자리
• %-10(s,d,f) : 오른쪽으로부터 공백 10자리
• %% : % 표시
  ``` print('aa\tbb') # \t - tab키 # aa bb print(r'aa\tbb')# 앞에 raw string(r)을 선행하면 이스케이프(\) 기능 해제 # aa\tbb

print("c:\aa\abc\nbc.txt") print(r"c:\aa\abc\nbc.txt")# 앞에 raw string(r)을 선행하면 이스케이프() 기능 해제

bc.txt

print('aa', end=', ')

print 는 기본적으로 라인스킵이 있다. end='' 를 사용하면 라인스킵이 안됨.

print('bb')

aa, bb

```

1. 인코딩 설정

• 이클립스 상단에 window 클릭 후 Preferences 눌러서 encoding 검색.
• workspace, css files, html files, jsp files, xml files 눌러서 encoding부분 utf-8로 설정하기.

2. font 설정

• 이클립스 상단에 window 클릭 후 Preferences 눌러서 font 검색.
• Appearance - color and fonts - Basic - Text Font 클릭하면 글꼴, 글꼴크기를 설정할 수 있는 창이 나온다.

3. 주석 색 바꾸기

• 이번 python 공부는 eclipse를 사용하기 때문에 PyDev가 설치 되어있는 전제로 설명하겠다.
• PyDev 설치 방법은 검색하면 자세하게 알려주기 때문에 여기서는 생략 하겠다.
• 이클립스 상단에 window 클릭 후 Preferences 눌러서 editor 검색.
• PyDev - Editor 를 클릭하면 색을 바꿀 수 있으므로 자신이 원하는 색으로 변경하면 된다.

3. React에서 css 사용하는 법
   1) inline css 사용하기

   • css파일을 따로작성할 필요없이 html태그에 적는 것이다.

   • 하지만, 특별한 경우가 아니고서는 잘 사용하지 않는다.

     2) App.css, index.css 활용하기

   • index.css는 전체 프로젝트에 영향을 미친다.

   • App.css app 관련된것만 영향을 미칠거 같지만 전체에 영향을 미친다.

     3) css module 사용하기

   • 파일명을 적고 .module.css 라고 적는다.

   • 가장 많이 사용하는 방법이고, 동일한 name으로 작성되어도 중복될 일이 없다.

   • 글로벌단위로 관리되는것이 아니라 component 단위로 관리 되기때문에 관리하기가 편리하다.

4. 이벤트 처리 방법

• 미리 함수를 하나 만들어서 사용하기.

  export default function Hello(){
    function ShowName(){
        console.log("mike");
    }
    return (
        <div>   
            <h1>Hello</h1>
            <World />
            <button onClick={ShowName}>Show name</button>
        </div>
    );
  }

• -function ShowName(){} 이라는 함수를 만들어서 onClick={} 안에 ShowName(함수명)을 적어주면 된다. 이러면 콘솔창에 mike가 뜨는걸 확인할 수 있다.

• 내부에 직접 함수를 작성하기.

  export default function Hello(){
    return (
        <div>   
            <h1>Hello</h1>
            <World />
            <button onClick={()=>{
                console.log("mike")
            }}>Show name</button>
        </div>
    );
  }

-- <button onClick={()=>{ console.log("mike") }}>Show name</button>안에 직접 함수를 작성하여 불러오는 방법이다. 이렇게 만들어도 버튼을 클릭하면 console 창에 mike가 표시된다. --> 이 방법의 장점은 매개변수를 전달하기 편하다는 것이다.

출처 : 유뷰브 코딩앙마

1. 작업할 폴더 및 경로설정

• 작업할 경로를 설정했다면 그 경로를 복사하고 cmd를 열어 cd 복사한 경로 입력.

• npx create-react-app voca 를 입력하면 설치가 진행되면서 프로젝트가 하나 생성이 된다.

• create-react-app 은 쉽고 빠르게 모든것을 구현시켜준다.

• vs code를 실행시켜 확인해보면 잘 설치가 되어있는지 확인할 수 있다.

• 터미널을 열어서 npm start 를 입력하여 리액트 창이 하나 열리면 잘 설치가 된것이다.

2. 살펴보기

• node_modules - 이 프로젝를 실행할때 사용하는 dependencies 가 모두 모여있는 곳으로, package.json파일을 통해 볼 수 있다. 이 폴더를 지우면 프로젝트를 띄울 수 없다. 또한 , node_modules는 용량이 크기 때문에 깃에 올릴때 같이 올리지 않는다. 나중에 사용자가 필요시 npm install를 통해 다시 설치가 가능하다.

• index.html - public 폴더 안에있는 index.html을 보면<div id="root"></div> 를 통해 react코드가 실행이 되어 만들어진 돔이 구현이 된다.

• App.js - src 폴더안에 있고, 여기서 코드를 작성하면 리액트 화면에 바로 표시가 된다.

• package.json - "start": "react-scripts start" - 개발모드로 프로그램을 실행한다. "build": "react-scripts build" - 실제 배포모드로 만들어 준다. "test": "react-scripts test" - test "eject": "react-scripts eject" - 내부 설정파일을 꺼내는 역할

출처 : 유뷰브 코딩앙마

Node.js는 확장성 있는 네트워크 애플리케이션(특히 서버 사이드) 개발에 사용되는 소프트웨어 플랫폼이다. 작성 언어로 자바스크립트를 활용하며 논블로킹(Non-blocking) I/O와 단일 스레드 이벤트 루프를 통한 높은 처리 성능을 가지고 있다. 내장 HTTP 서버 라이브러리를 포함하고 있어 웹 서버에서 아파치 등의 별도의 소프트웨어 없이 동작하는 것이 가능하며 이를 통해 웹 서버의 동작에 있어 더 많은 통제를 가능케 한다.

📖Node.js 설치하기

• 링크를 클릭해서 Node.js설치하기

  Node.js

• 여기서 LTS 나 Current버전 둘 중 아무거나 다운받아도 상관없다.
  • LTS 버전이 신뢰도와 안정성이 높고, 기업에서 많이 사용한다고 한다.
    • Current 버전은 개발자들 학습용으로 쓰인다고 한다. 둘 중 아무거나 상관없으니 클릭해서 설치!

• 다운받고 실행시키면 이러한 화면이 나오고 Next 클릭
• 이부분은 파이썬이나 비주얼 스튜디오 에서 필요한 도구를 자동 설치 여부를 묻는것이다.
• 이런 화면이 뜨고 엔터키를 누르면 창이 없어진다.

📖Node.js 설치확인 하기

• 명령 프롬프트 (cmd)나 Node.js 명령 프롬프트를 실행시켜서 npm -v 나 node -v 를 입력하면 현재버전과 설치가 되어있는것을 확인할 수 있다.

출처 : https://ko.wikipedia.org/wiki/Node.js

• 먼저 경로를 설정해준다.
• 상단 탭 Tools에 가서 Global Options... 클릭
• Browse를 클릭하여 사용하고자 하는 폴더를 선택하면 경로설정 끝.
• 경로 설정을 하였다면 표시된 부분에 경로가 설정된 것을 확인할 수 있다.

2. 폰트 및 인코딩 설정

🖋 폰트 설정

• 상단 탭 Tools에 가서 Global Options... 클릭
• • RStudio theme : R Studio 테마 선택
  • Zoom : 확대, 축소
  • Editor font : 폰트 설정
  • Editor font size : 폰트 사이즈 설정
  • Editor theme : 코드 테마설정(미리보기가 있어 보고 선택할 수 있다.)

📃 인코딩 설정

• 상단 탭 Tools에 가서 Global Options... 클릭
• code - saving - Default text encoding 에서 Change 클릭
• UTF-8 선택하고 ok 클릭 후 다시 ok 클릭하면 인코딩 설정 완료!