전역변수와 지역변수

💡 변수는 자신이 생성된 범위(코드블럭)안에서만 유효하다.
함수 안에서 만든 변수는 함수 안에서 살아있다가 함수 코드의 실행이 종료되면 생명을 다한다. 이것을 지역변수 라고 합니다.

이와는 반대로 함수 외부에서 만든 변수는 프로그램이 살아있는 동안에 함께 살아있다가 프로그램이 종료되면 같이 소멸합니다. 이렇게 프로그램 전체를 유효범위로 가지는 변수를 전역변수라고 합니다.

문법예제1.

def StarBucks():
  mug_cup = 'Americano' # 지역변수
  return mug_cup
  
print(StarBucks())  
print(mug_cup) # ★ 이렇게 머그컵(지역변수)를 함수 밖으로 가져오면 에러가 난다. 

문법예제2. 전역변수

tumbler = 'water' # 만약 비어있는 상태로 두고싶다면 None을 할당. none할때는 쿼테이션마크 x

def StarBucks():
    global tumbler # 전역변수를 함수 내에서 사용하려면 global을 붙여준다.
    tumbler = 'Americano' 
    return tumbler

print(StarBucks())  # Americano
print(tumbler)      # Americano

블루보틀에 가보자

tumbler = 'water' 

def StarBucks():
    global tumbler 
    tumbler = 'Americano' 
    return tumbler

def BlueBottle():
    global tumbler
    tumbler = 'Cappuccino'
    return tumbler

print (StarBucks())   # Americano
print (BlueBottle())  # Cappuccino
print (tumbler)       # Cappuccino

🤔 지역변수는 함수내에서 사용하는 변수라서 필요한데, 전역변수를 사용해야하는 진짜이유가 무엇일까 ?

💡 변수에 담긴 값이 함수마다 공통적으로 사용되어야 하는 경우에 유용하다.

ex) 원의 넓이를 계산하는 다양한 함수들이 있다면 그 함수들이 전부 동일한 원주율을 사용해야 한다. 

문제 96. 원의 넓이를 구하는 함수를 생성하시오

def cycle_function(num1):
    pi = 3.14
    return pi * num1 * num1 # 원 넓이 공식 : 3.14 * 반지름 * 반지름
    
print(cycle_function(5))    # 78.5

문제 97. 부채꼴의 넓이를 구하는 함수를 생성하시오

def cycle_function2(num1):
    pi = 3.14159 # 여기 이렇게 일관성 없으면 결과값이 달라진다.
    return 1/4 * pi * num1 * num1 
    
print(cycle_function2(5))  # 19.6349375    

✅ 원의 넓이를 구할때는 pi가 3.14였고 부채꼴의 넓이를 구할 때는 pi가 3.1459면 결과적으로 같은 프로그램 내에서 동일한 pi를 사용하지 않은 결과가 됩니다.

문제 98. 위 두개의 함수가 같은 pi를 사용할 수 있도록 전역변수를 사용하시오

pi = 3.14
def cycle_function(num1):
    global pi
    return pi * num1 * num1 
    
def cycle_function2(num1):   
    global pi
    return 1/4 * pi * num1 * num1
    
print(cycle_function(5))
print(cycle_function2(5))

✅ 위와같이 pi값이 어느 함수에서 쓰이든 동일한 pi값을 사용하려면, 전역변수로 만들어서 함수내에서 global로 호출하여 사용!

이름없는 한줄짜리 함수 lambda 사용법

<문법>

def my_abs(x):
    if x < 0 :
        return x * -1
    else :
        return x
print (my_abs(-7))

위 my_abs 함수를 lambda식으로 변경

my_abs2 = lambda x : x * -1 if x < 0 else x
        # lambda 입력변수 : 출력을 위한 실행문
print(my_abs2(-7))


# 1. 원래 if문                    vs            # 한줄짜리 if문
# if x < 0:                                    # x * -1 if x < 0 else x
#     return x * -1
# else :
#     return x

문제 99. 아래의 함수를 lambda식으로 구현하시오

def add_func(a,b) :
 return a + b
print (add_func(3,5)) 
 
# lambda식으로
add_func = lambda a,b : a + b
print (add_func(3,5)) 

문제 100. db 자동화 함수에 4번코드의 버그를 수정하시오!

# 1. 오라클 연동 함수

def   oracle_table(table_name):
    import cx_Oracle
    import pandas as pd

    dsn = cx_Oracle.makedsn('localhost', 1521, 'xe')
    db = cx_Oracle.connect('c##scott', 'tiger', dsn)
    cursor = db.cursor()   
    
    query = f"SELECT * FROM {table_name}"
    
    cursor.execute(query )  

    row = cursor.fetchall()   

    colnames = cursor.description

    col = [ ] 
    for  i   in   colnames:
        col.append( i[0].lower()  )

    df = pd.DataFrame(row , columns = col )
    return ( df )

#2. dba 자동화 스크립트

def  easy_dba():

    while   True:
        print( """ ===  dba 작업을 편하게 수행하기 위한 스크립트 총모음 ====

            0.   프로그램을 종료하려면 0번을 누르세요.
            1.   테이블 스페이스  사용량을 확인하려면 1번을 누르세요
            2.  현재 데이터베이스 락(lock) 발생했는지 확인하려면 2번을 누르세요
            3.  오라클와 연동하게 싶으면 3번을 누르세요
            4.  alert log file 을 분석하고 싶다면 4번을 누르세요

            """)

        num =  int( input('원하는 번호를 입력하세요 ~' )  )
        
        if num == 0:
            break

        elif  num == 1:
            
            import  cx_Oracle 
            import  pandas  as  pd 
            dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe')  
            db = cx_Oracle.connect('c##scott','tiger', dsn) 

            cursor  = db.cursor()      

            cursor.execute(""" select  t.tablespace_name,
                                        round(((t.total_size - f.free_size) / t.total_size),2) * 100 usedspace
                             from (select tablespace_name, sum(bytes)/1024/1024 total_size
                                       from dba_data_files
                                       group by tablespace_name) t,
                                    (select  tablespace_name, sum(bytes)/1024/1024 free_size
                                       from dba_free_space
                                       group by tablespace_name) f
                       where t.tablespace_name = f.tablespace_name(+)   """)  

            row = cursor.fetchall()    
            col=[]
            for  i   in   colname:
                col.append( i[0].lower() )

            df = pd.DataFrame (list(row), columns=col)
            print(df)
            break
            
        elif  num == 2:
            continue
            
        elif  num ==3:
            import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
            import  pandas  as  pd
            dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
            db = cx_Oracle.connect('c##scott','tiger', dsn)
            cursor  = db.cursor()
            cursor.execute(""" select  * from  emp """)
            row = cursor.fetchall()
            colname = cursor.description
            col=[]
            for  i   in   colname:
                col.append( i[0].lower() )

            emp = pd.DataFrame (list(row), columns=col)

            print(' 잘 연동되었습니다')
            break

        elif num == 4:
            jobs = open("C:\\app\\ITWILL\\product\\18.0.0\\diag\\rdbms\\xe\\xe\\trace\\alert_xe.log",  encoding='cp949', errors='ignore')

            data = jobs.read()
            data2= data.split()
            k = [  ]                             
            for  i  in  data2:               
                if  'ora-' in  i.lower():     
                    k.append(i)       
                          
            import   pandas   as   pd       

            df = pd.DataFrame(  k,  columns=['col1'] ) 
            from   pandasql  import   sqldf    
         

            q = """  select  col1, count(*)
                            from  df
                            group by  col1
                            order by 2 desc;   """

            print(sqldf(q) )
            break

📖 8장 예외처리

개발자의 방어기제 예외처리란?

💡 예외처리란 이름 그대로 예외사항으로 처리하겠다! 라는 것. 파이썬 코드에 문제가 있어서 나는 오류가 아니고 입력되는 데이터가 잘못되어 나는 오류에 대한 예외처리이다.

문법예제1. 두개의 숫자를 물어보고 나누기를 하는 함수를 생성하기

def my_devide():
    x = input('분자의 숫자 입력')
    y = input('분모의 숫자 입력')
    return int(x) / int(y)
    
print (my_devide())    

✅ my_devide 함수를 실행할 때 사용자가 숫자를 넣지 않고 문자열인 'a'를 넣으면 에러가 난다. 이럴 때 예외처리를 해야함.

문법예제2. 잘못된 값을 입력했을 때 예외처리 하는코드 (try ~ except)

try:

   실행 될 주요 코드
 
except:
 
   try와 except사이의 코드에 문제가 생겼을 때 실행될 코드

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

def my_devide():
    try:
        x = input('분자의 숫자 입력')
        y = input('분모의 숫자 입력')
        return int(x) / int(y)
    except:
        return '잘못된 값을 입력해서 나누기를 할 수 없어요'
print (my_devide())  

문제 101. 다음의 gegop() 함수를 만들고 실행하세요

def gegop() :
    num = int(input('숫자를 입력하세요'))
    return num ** 2
    
print(gegop())    

문제 102. 위 예외처리

def gegop() :
    try:
        num = int(input('숫자를 입력하세요'))
        return num ** 2
    except:
        return '잘못된 값을 입력했습니다.'
    
print(gegop())   

try ~ except ~ else

<문법>

def gegop() :
    try:
        num = int(input('숫자를 입력하세요'))
        print( num ** 2 )
    except:
        print( '잘못된 값을 입력했습니다.' ) 
    else:
        print( '계산에 성공했습니다.' )
-------------------------------------------------------------------  
gegop() 

✅ return은 하나나오고 끝내버려서 print로 바꿔줌!

문제 103. my_devide() 함수를 수정해서 다음과같이 계산이 성공했습니다 라는 메세지가 출력되게 하고, 잘못된 값을 입력받으면 잘못된 값을 입력했다는 메세지 출력되게 하기

def my_devide():
    try:
        x = input('분자의 숫자 입력')
        y = input('분모의 숫자 입력')
        print (int(x) / int(y))
    except:
        print ('잘못된 값을 입력해서 나누기를 할 수 없어요')
    else:
        print ('계산 완료!')

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

my_devide()

문제가 생기기전에 문제를 만들지 않기! (raise Exception)

앞에서는 데이터 오류로 인해 프로그램이 종료되지 않도록 예외처리를 했다. 그런데 예외처리가 꼭 프로그램을 종료시키지 않기위해서만 사용하는것은 아니다. 프로그램을 일부러 종료시켜버리기 위해서도 사용한다.

<문법> 프로구램이 종료되기 전에 유서를 남기고 종료되게하는 예외처리 코드

def my_devide():
        x = input('분자의 숫자 입력')
        y = input('분모의 숫자 입력')
        if y == '0':
            raise Exception ('분모에 0을 입력하면 나누기를 할 수 없어요.')
        else:
            print (int(x) / int(y))
            print ('성공적으로 계산이 완료되었습니다.')

오라클 db에서 만든 프로시저

<문법>
1. 사원번호를 입력하고 프로시저를 수행하면 해당 사원의 월급이 출력되는 프로시저를 생성하시오

create or replace procedure find_sal
( p_empno   in     number,
  p_sal     out    number  )
is
begin 
 select sal into p_sal
    from emp
    where empno = p_empno;
end;
/

SQL> variable  v_result  number;
SQL>
SQL> exec  find_sal( 7788, :v_result );

PL/SQL 처리가 정상적으로 완료되었습니다.

SQL> print  v_result

  V_RESULT
----------
      3000
 

2. oracle에서 만든 find_sal프로시저를 파이썬에서 호출해서 사용

import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
db = cx_Oracle.connect('c##scott','tiger', dsn)
cursor  = db.cursor()

v_result = cursor.var(cx_Oracle.STRING)
cursor.callproc('find_sal',(7788,v_result))
             # 프로시저이름 / v_result에 값이 담길것이다 !
             
result = v_result.getvalue()
print(result)

문제 104. 사원번호를 입력하면 해당 사원의 직업이 출력되는 프로시저를 find_job이라는 이름으로 생성하기

create   or   replace   procedure   find_job
(   p_empno    in     number,
    p_job     out     emp.job%type  )
is
begin 
 select   job   into   p_job
    from   emp
    where    empno = p_empno;
end;
/

SQL> variable  v_result  varchar2(20);
SQL>
SQL> exec  find_job( 7788, :v_result );
SQL> print  v_result

문제 105. 파이썬으로

import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
db = cx_Oracle.connect('c##scott','tiger', dsn)
cursor  = db.cursor()

v_result = cursor.var(cx_Oracle.STRING)
cursor.callproc('find_job',(7788,v_result))
             # 프로시저이름 / v_result에 값이 담길것이다 !
             
result = v_result.getvalue()
print(result)

문제 106. 위 코드를 함수로 만들어서 다음과 같이 수행될 수 있게 하기

oracle_find_job(7788)

def oracle_find_job(num):
    import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
    dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
    db = cx_Oracle.connect('c##scott','tiger', dsn)
    cursor  = db.cursor()
    
    v_result = cursor.var(cx_Oracle.STRING)
    cursor.callproc('find_job',(num,v_result))
                 # 프로시저이름 / v_result에 값이 담길것이다 !
                 
    result = v_result.getvalue()
    print(result)  
    
oracle_find_job(7788) # ANALYST    

문제 107. 위 함수를 수정해서 없는 사원번호를 넣고 실행하면 '해당 사원번호는 없는 사원번호입니다' 라고출력하기
oracle_find_job(9999)
'해당 사원번호는 없는 사원번호입니다'

def oracle_find_job(num):
    try:
        import  cx_Oracle  
        dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
        db = cx_Oracle.connect('c##scott','tiger', dsn)
        cursor  = db.cursor()

        v_result = cursor.var(cx_Oracle.STRING)
        cursor.callproc('find_job',(num,v_result))    

        result = v_result.getvalue()
        print(result)    
    except:
        print('없는 사원번호 입니다.') 
  
 --------------------------------------------------------------
 oracle_find_job(9999)

dba에게 유용한 프로그램 만들기 (lock waiting 세션 발견하기)

1. 명령 프롬프트 창을 2개 열고 각각 c##scott유저로 접속하여 lock이 발생되는 상황 연출하기
2. sql developer 창에서 lock holder, lock waiter 세션을 찾으시오!

select decode(status,'INACTIVE',username || ' ' || sid || ',' || serial#,'lock') as Holder,
       decode(status,'ACTIVE',  username || ' ' || sid || ',' || serial#,'lock') as waiter, sid, serial#, status
    from( select level as le, NVL(s.username,'(oracle)') AS username,
    s.osuser,   
    s.sid,
    s.serial#,
    s.lockwait,
    s.module,
    s.machine,
    s.status,
    s.program,
    to_char(s.logon_TIME, 'DD-MON-YYYY HH24:MI:SS') as logon_time
       from v$session s
      where level>1
                or EXISTS( select 1
    from v$session
    where blocking_session = s.sid)
      CONNECT by PRIOR s.sid = s.blocking_session
  START WITH s.blocking_session is null);

✅ 위 결과에서 status가 액티브로 나오는 세션이 바로 waiting하고있는 세션입니다.

3. 위 SQL을 수정해서 다음과 같이 결과가 출력되게하시오.
   출력결과 : 2

select  count(*)
  from( select level as le, NVL(s.username,'(oracle)') AS username,
    s.osuser,   
    s.sid,
    s.serial#,
    s.lockwait,
    s.module,
    s.machine,
    s.status,
    s.program,
    to_char(s.logon_TIME, 'DD-MON-YYYY HH24:MI:SS') as logon_time
       from v$session s
      where level>1
                or EXISTS( select 1
    from v$session
    where blocking_session = s.sid) 
      CONNECT by PRIOR s.sid = s.blocking_session
      START WITH s.blocking_session is null)
      where status = 'ACTIVE';

4. 위의 쿼리의 결과를 출력하는 프로시저를 생성하시오 !

create or replace procedure lock_find
( p_cnt out number )
is 
  begin
     select  count(*) into p_cnt
       from (select level as le, NVL(s.username,'(oracle)') AS username,
            s.osuser,   
            s.sid,
            s.serial#,
            s.lockwait,
            s.module,
            s.machine,
            s.status,
            s.program,
            to_char(s.logon_TIME, 'DD-MON-YYYY HH24:MI:SS') as logon_time
               from v$session s
              where level>1
                        or EXISTS( select 1
            from v$session
            where blocking_session = s.sid) 
              CONNECT by PRIOR s.sid = s.blocking_session
              START WITH s.blocking_session is null)
              where status = 'ACTIVE';
end;
/

v$session를 못본다.

alter system set 07_DICTIONARY_ACCESSIBILIY = true

이렇게 해봤는데, 지정된 초기화 매개변수를 수정할 수 없다는 에러메세지가 난다. DB내렸다 올려야함 !!

// sys유저에서 B내리기
alter system set 07_DICTIONARY_ACCESSIBILIY = true
scope = spfile;
-------------------------------------
shutdown immediate
// 올리기
startup

⭐ 프로시저 생성을 위한 사전 작업 수행!
✔️ 먼저 sys유저로 접속합니다.

connect / as sysdba

✔️ 오라클 설정 파라미터 파일을 백업 받습니다.

// 내 위치확인
show parameter spfile 
// 이 경로에 있는 파일을 바탕화면에 복사
C:\APP\ITWILL\PRODUCT\18.0.0\DBHOMEXE\DATABASE\SPFILEXE.ORA 

✔️ select any table권한을 c##scott유저에게 부여합니다.

// 데이터베이터에 있는 어떤 테이블이던 다 읽을 수 있는 권한을 준다. 
grant select any table to c##scott;

✔️ O7_DICTIONARY_ACCESSIBILITY를 true로 변경합니다. 이 파라미터는 프로시저 안에서 v$session과 같은 dba테이블을 셀렉트 할 수 있게 해주는 파라미터 입니다.

show parameter o7

alter system set O7_DICTIONARY_ACCESSIBILITY=true
  scope=spfile;

// 시스템이 변경되었습니다.  

✔️ db 내렸다 올립니다.

shutdown immediate // 내리기

startup // 올리기

✔️ c##scott 유저로 접속해서 아래의 프로시저 생성하기! (위 코드와 같음)

connect c##scott/tiger

create or replace procedure lock_find
( p_cnt out number )
is 
  begin
     select  count(*) into p_cnt
       from (select level as le, NVL(s.username,'(oracle)') AS username,
            s.osuser,   
            s.sid,
            s.serial#,
            s.lockwait,
            s.module,
            s.machine,
            s.status,
            s.program,
            to_char(s.logon_TIME, 'DD-MON-YYYY HH24:MI:SS') as logon_time
               from v$session s
              where level>1
                        or EXISTS( select 1
            from v$session
            where blocking_session = s.sid) 
              CONNECT by PRIOR s.sid = s.blocking_session
              START WITH s.blocking_session is null)
              where status = 'ACTIVE';
end;
/

✔️ 프로시저를 실행해서 숫자 0이 출력되는지 확인하시오 (지금 lock된게 없는상태임)

SQL> variable v_result number;
SQL> exec lock_find(:v_result);

PL/SQL 처리가 정상적으로 완료되었습니다.

SQL> print v_result

  V_RESULT
----------
         0

✔️ 파이썬에서 lock_find 프로시저 호출하기

import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
db = cx_Oracle.connect('c##scott','tiger', dsn)
cursor  = db.cursor()

v_result = cursor.var(cx_Oracle.STRING)
cursor.callproc('lock_find',[v_result]) # [v_result] 이렇게 리스트로 바꾸니까 됨      
           
result = v_result.getvalue()
print(result)  

문제 108. 위의 코드를 함수로 생성하고 실행하기! 함수이름은 find_lock

def find_lock ():              
    import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
    dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
    db = cx_Oracle.connect('c##scott','tiger', dsn)
    cursor  = db.cursor()

    v_result = cursor.var(cx_Oracle.STRING)
    cursor.callproc('lock_find',[v_result])            
           
    result = v_result.getvalue()
    print(result ,'개의 락 waiting 세션이 발견되었습니다.')      
-------------------------------------------------------------------------
find_lock ()        

문제 109. dba 자동화 스크립트 2번에 이 함수를 실행하는 코드를 추가하고 잘 되는지 확인

# 1. 오라클 연동 함수

def   oracle_table(table_name):
    import cx_Oracle
    import pandas as pd

    dsn = cx_Oracle.makedsn('localhost', 1521, 'xe')
    db = cx_Oracle.connect('c##scott', 'tiger', dsn)
    cursor = db.cursor()   
    
    query = f"SELECT * FROM {table_name}"
    
    cursor.execute(query )  

    row = cursor.fetchall()   

    colnames = cursor.description

    col = [ ] 
    for  i   in   colnames:
        col.append( i[0].lower()  )

    df = pd.DataFrame(row , columns = col )
    return ( df )



#2. dba 자동화 스크립트


def  find_lock():
    import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
    dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
    db = cx_Oracle.connect('c##scott','tiger', dsn)
    cursor  = db.cursor()

    v_result =  cursor.var( cx_Oracle.STRING )
    cursor.callproc( 'lock_find',  [v_result]   )

    result = v_result.getvalue()
    return  str(result) + '개의 락 waiting 세션이 발견되었습니다.'


def  easy_dba():

    while   True:
        print( """ ===  dba 작업을 편하게 수행하기 위한 스크립트 총모음 ====

            0.  프로그램을 종료하려면 0번을 누르세요.
            1.  테이블 스페이스  사용량을 확인하려면 1번을 누르세요
            2.  현재 데이터베이스 락(lock) 발생했는지 확인하려면 2번을 누르세요
            3.  오라클와 연동하게 싶으면 3번을 누르세요
            4.  alert log file 을 분석하고 싶다면 4번을 누르세요

            """)

        num =  int( input('원하는 번호를 입력하세요 ~' )  )
        
        if num == 0:
            print('종료되었습니다.')
            break

        elif  num == 1:
            
            import  cx_Oracle 
            import  pandas  as  pd 
            dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe')  
            db = cx_Oracle.connect('c##scott','tiger', dsn) 

            cursor  = db.cursor()      

            cursor.execute(""" select  t.tablespace_name,
                                        round(((t.total_size - f.free_size) / t.total_size),2) * 100 usedspace
                             from (select tablespace_name, sum(bytes)/1024/1024 total_size
                                       from dba_data_files
                                       group by tablespace_name) t,
                                    (select  tablespace_name, sum(bytes)/1024/1024 free_size
                                       from dba_free_space
                                       group by tablespace_name) f
                       where t.tablespace_name = f.tablespace_name(+)   """)  

            row = cursor.fetchall()    
            col=[]
            for  i   in   colname:
                col.append( i[0].lower() )

            df = pd.DataFrame (list(row), columns=col)
            print(df)
            break
            
        elif  num == 2:
            message = find_lock()
            print(message) 
            break
            
        elif  num ==3:
            import  cx_Oracle  # 오라클과 파이썬을 연동하기 위한 모듈
            import  pandas  as  pd
            dsn = cx_Oracle.makedsn( 'localhost' , 1521, 'xe') 
            db = cx_Oracle.connect('c##scott','tiger', dsn)
            cursor  = db.cursor()
            cursor.execute(""" select  * from  emp """)
            row = cursor.fetchall()
            colname = cursor.description
            col=[]
            for  i   in   colname:
                col.append( i[0].lower() )

            emp = pd.DataFrame (list(row), columns=col)

            print(' 잘 연동되었습니다')
            break

        elif num == 4:
            jobs = open("C:\\app\\ITWILL\\product\\18.0.0\\diag\\rdbms\\xe\\xe\\trace\\alert_xe.log",  encoding='cp949', errors='ignore')

            data = jobs.read()
            data2= data.split()
            k = [  ]                             
            for  i  in  data2:               
                if  'ora-' in  i.lower():     
                    k.append(i)       
                          
            import   pandas   as   pd       

            df = pd.DataFrame(  k,  columns=['col1'] ) 
            from   pandasql  import   sqldf    
         

            q = """  select  col1, count(*)
                            from  df
                            group by  col1
                            order by 2 desc;   """

            print(sqldf(q) )
            break

클래스가 왜 필요한가?

import dba_auto as a
a.easy_dba()

위 dba_auto.py 안에 아래와같이 3개의 함수가 있다.
1. orcle_table
2. find_lock
3. easy_dba
이 함수들이 서로 데이터를 주고받는 관곌면 이 함수들을 묶어서 클래스로 만들어 관리해야한다. 그런데 그렇지 않다면 클래스로 만들 필요는 없다. (위는 클래스로 만들 필요가 없는 함수들!)

문법예제1.
총 클래스를 생성하겠습니다. 콩의 기능은 함수로 만들면 2가지가 있습니다.
1. 총을 쏘는 기능 (shoot)
2. 총알을 충전하는 기능 (charge)

1. 총알을 충전하는 함수 생성

def charge(num):
    bullet = num
    print(bullet,'발이 장전되었습니다.')
    
charge(3)    

2. 총알을 쏘는 함수 생성

def shoot(num):
    for i in range (1,num+1):
        print('탕!')
shoot(3)        

3. 위에서 만든 charge함수, shoot함수를 각각 실행하는데 다음과 같이 총알을 2발 장전하고 총알을 3발 쏴지는지 실행

charge(2)
shoot(3)

✅ 2발 장전했는데, 3발이 쏴진다. 그래서 장전한 만큼 총알이 쏴지게 하려면 class로 이 함수들을 구성해주어야 한다.

4. 클래스로 만들어서 충전한 만큼만 쏴지게 하시오

# 총 클래스 생성
class Gun(): # class이름은 카멜케이스로 앞글자 대문자 !
    def charge(self,num):
        self.bullet = num
        print(self.bullet, '발이 장전되었습니다.')
        
    def shoot(self,num):
        for i in range(1, num + 1):
            if self.bullet > 0: # 충전한 총알이 있다면 
                print('탕!')    # 탕탕!
                self.bullet = self.bullet -1 # 총알 하나 깎고
            elif  self.bullet == 0: # 총알이 0개면(다썼으면)
                print('총알이 없습니다!')
                break
                
# 총 클래스(설계도)를 가지고 총(제품)을 만듭니다. 
gun1 = Gun() # 제품이름 = 설계도

# gun1 제품에 총알을 10발 충전합니다.
gun1.charge(10) # 10 발이 장전되었습니다.

# gun1 총을 한발씩 쏴보기
gun1.shoot(1)

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ
✅ 클래스로 만들어서 총을 생산해보니 충전한 만큼만 총알을 쏠 수 있게 되었다 !

5. Gun() 클래스로 다른 제품도 만들 수 있다. 만들어보기!

gun2 = Gun()
gun2.charge(5)

✅ 셀프가 하는 역할. 이렇게 Gun() 클래스로 다른 제품을 만들었을 때 두개가 구분되도록 해준다. 아까 gun1은 총알 다썼고 gun2에 충전해놓은 상태에서 gun1로 쏴보면 아까처럼 총알이 없다고 나온다. 같은 클래스로 두개를 만들었지만 두개가 다르다.

문제 110. 고릴라 클래스를 다음과 같이 생성하시오! (클래스명 : Gorilla)
1. 바나나를 먹는 기능 (함수명 : eat)
2. 소리지르는 기능 (함수명 : shaut)

class Gorilla(): 
    def eat(self,num):
        self.bullet = num
        print('바나나', self.bullet,'개를 먹었습니다.')
      
    def shaut(self,num):
        for i in range(1, num + 1):
            if self.bullet > 0: # 충전한 총알이 있다면 
                print('우와~')    # 탕탕!
                self.bullet = self.bullet -1 # 총알 하나 깎고
            elif  self.bullet == 0: # 총알이 0개면(다썼으면)
                print('바나나를 다먹으면 소리를 지를 수 없어요!')
                break
               
#총 클래스(설계도)를 가지고 총(제품)을 만듭니다. 

gorilla1 = Gorilla() # 제품이름 = 설계도

#gun1 제품에 총알을 10발 충전합니다.
gorilla1.eat(10) # 10 발이 장전되었습니다.

#gun1 총을 한발씩 쏴보기
gorilla1.shaut(1)                

문제 110. (마지막 문제)아래와 같이 테이블 스페이스 이름과 테이블 스페이스 사용량을 출력하는 프로시저를 생성하시오
exec ts_space;

set serveroutput on

create or replace procedure ts_space
is
      cursor ts_cursor is
        select  t.tablespace_name tablespaceName,
                round(((t.total_size - f.free_size) / t.total_size),2) * 100 usedspace
           from (select tablespace_name, sum(bytes)/1024/1024 total_size
                   from dba_data_files
                   group by tablespace_name) t,
                                            (select  tablespace_name, sum(bytes)/1024/1024 free_size
                                               from dba_free_space
                                               group by tablespace_name) f
                   where t.tablespace_name = f.tablespace_name(+);
    begin
      for ts_recode in ts_cursor loop
          dbms_output.put_line(ts_recode.tablespaceName || chr(9) || ts_recode.usedspace);
        end loop;
    end;
    /
 
 exec ts_space;

✅ 익명블럭이 아닐때는 declare를 쓰지 않는다 ! -> 프로시저 만들때는 안쓴다.
✅ for ts_recode in ts_cursor loop 로 이미 선언이 되었다.
✅ declare사용하는 때!

---

💡 익명블록이 아닌것들

💡 익명블록이란?

익명 블록(Anonymous Block)은 데이터베이스에서 실행되는 PL/SQL 코드 덩어리를 말합니다. PL/SQL(Procedural Language/Structured Query Language)은 Oracle 데이터베이스에서 사용되는 프로그래밍 언어로, SQL 문을 포함하여 프로그래밍 로직을 작성하고 실행할 수 있는 기능을 제공합니다. 익명 블록은 이름 없이 실행되는 PL/SQL 코드 블록을 의미합니다.

익명 블록은 주로 다음과 같은 목적으로 사용됩니다:

일시적인 작업: 특정 작업을 수행하기 위해 임시로 PL/SQL 코드를 실행해야 할 때 익명 블록을 사용할 수 있습니다. 예를 들어, 데이터 조작, 처리, 계산 등을 일회성으로 수행할 때 사용됩니다.

테스트: 코드 블록을 사용하여 어떤 코드가 예상대로 동작하는지 테스트할 수 있습니다. SQL 문과 프로그래밍 로직을 테스트하고 디버깅할 때 유용합니다.

스크립트 작성: 데이터베이스 객체를 생성, 수정, 삭제하는 스크립트를 작성할 때 익명 블록을 사용하여 복잡한 작업을 수행하거나 조건에 따라 작업을 다르게 수행할 수 있습니다.

익명 블록은 다음과 같은 형태로 작성됩니다:

DECLARE
  -- 변수나 상수 선언
BEGIN
  -- PL/SQL 코드 작성
  -- SQL 문 실행
  -- 변수 사용
  -- 예외 처리 등
END;
/

익명 블록은 DECLARE 섹션과 BEGIN ~ END; 사이에 PL/SQL 코드를 작성합니다. DECLARE 섹션은 선택적이며, 변수나 상수를 선언할 때 사용됩니다. BEGIN에서는 실제 PL/SQL 코드를 작성하고 SQL 문을 실행하며, 필요한 경우 예외 처리를 할 수 있습니다. 블록의 끝에는 / 기호가 위치하여 실행을 시작합니다.

익명 블록은 프로시저나 함수와 달리 이름이 없기 때문에 단순한 작업을 처리하거나 테스트를 위해 간단하게 사용할 수 있는 장점이 있습니다.