'''
변수(variable) : 데이터를 담는 그릇 (숫자로 시작 불가, 특수문자 _ , $ 허용됨)
- 예약어는 변수로 사용할 수 없다.

Python Built-In Types
- Numeric (int, float)
- Sequence (list , tuple)
- Text Sequence (str)
- Set (set)
- Mapping (dict)
- Bool

다양한 변수 선언 방식
- Camel  Case : numberOfColleageGraduates - 변수, 함수
- Pascal Case : NumberOfColleageGraduates - 클래스
- Snake  Case : number_of_colleage_graduates - 비추천
'''

# 예약어 확인

import keyword
keywordList = keyword.kwlist

print('키워드 = ' , keywordList)
print()
print('type - ' , type(keywordList))

키워드 =  ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

type -  <class 'list'>

# 기본 변수 바인딩

year = "2025"
month = 10

# 함수 호출
print(year, month)

# 변수타입 확인을 위한 함수 - type()
print('year type - ', type(year))

2025 10
year type -  <class 'str'>

# 문자열
name = "임정섭"
print(name, type(name))
print('010' , '1234' , '5678' , sep = "-")
print('jslim9413', 'naver.com' , sep="@")

임정섭 <class 'str'>
010-1234-5678
jslim9413@naver.com

# Sequence - List type
# [] - 순서가 있는 열거형 (파이썬에서는 Array가 아님, 파이썬에서는 배열이 존재하지 않음)
# indexing, slicing을 포함함

print('list     - ' , keywordList)
print()
print('indexing - ' , keywordList[0])
print()
print('slicing  - ' , keywordList[0:5])

list     -  ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

indexing -  False

slicing  -  ['False', 'None', 'True', 'and', 'as']

#text sequence

print(name)
print('indexing - ' , name[0] , type(name[0]))
print('indexing - ' , name[-1])
print('slicing  - ' , name[0:2])

임정섭
indexing -  임 <class 'str'>
indexing -  섭
slicing  -  임정

# Mapping(key, value)
# dict , {}
# 인덱싱이 불가하고 key를 통해 데이터에 접근
log = {
    "SQL Injection" : {
        "정의" : "사용자 입력을 적절히 검증하지않고 데이터베이스 쿼리에 직접 포함하는 것",
        "용어" : [
            "입력검증", "파라미터화", "블라인드", "에러기반"
        ],
        "취약코드 예시" : "query = select * from table",
        "공격예시" : "user = admin or 1=1",
        "탐지" : [
            "웹 취약점 스캐너 사용", "비정상적인 쿼리", "오류 모니터링"
        ]
    }
}
print(log)
print()
print('type - ' , type(log))
print()
print(log["SQL Injection"]["용어"], type(log["SQL Injection"]["용어"]))
print()

# --error
# print(log[0][1], type(log[0][1]))

{'SQL Injection': {'정의': '사용자 입력을 적절히 검증하지않고 데이터베이스 쿼리에 직접 포함하는 것', '용어': ['입력검증', '파라미터화', '블라인드', '에러기반'], '취약코드 예시': 'query = select * from table', '공격예시': 'user = admin or 1=1', '탐지': ['웹 취약점 스캐너 사용', '비정상적인 쿼리', '오류 모니터링']}}

type -  <class 'dict'>

['입력검증', '파라미터화', '블라인드', '에러기반'] <class 'list'>

# 집합 (tuple)
# () 소괄호 사용
# indexing, slicing 가능
# 불변성(immutable)을 가진다 

tupleTemp = (1)
print('type - ', type(tupleTemp)) #type -  <class 'int'> int가 나온다 요소가 한개여서 정수로 봄

tupleTemp = (1,)
print('type - ', type(tupleTemp)) # ,를 사용해서 집합으로 만들어줘야한다

tupleTemp = "a", "b", "c", "d", "e"
print('data - ', tupleTemp)
print('type - ', type(tupleTemp)) # 소괄호에 대한 생략도 가능하다 (packing)

a, b, c, *d = tupleTemp
print('unpacking - ', a, b, c)

print()
print('indexing - ', tupleTemp[0])
print('slicing - ', tupleTemp[0:]) # start index : end index : step
print('slicing - ', tupleTemp[0::2])

# --error
# 불변성으로 데이터를 변경할 수 없다
# tupleTemp[0] = 23

type -  <class 'int'>
type -  <class 'tuple'>
data -  ('a', 'b', 'c', 'd', 'e')
type -  <class 'tuple'>
unpacking -  a b c

indexing -  a
slicing -  ('a', 'b', 'c', 'd', 'e')
slicing -  ('a', 'c', 'e')

# Text Sequence
# 문자열
# 인덱싱 슬라이싱 가능
strTemp = 'Talk is cheap. show me the code'
print(strTemp, type(strTemp))
print()
print('indexing - ', strTemp[0])

# --error
# strTemp[0] = 'L'

Talk is cheap. show me the code <class 'str'>

indexing -  T

print('Quiz - 마지막 문자열(code) 추출한다면 ?')
print(strTemp[-4:])

listTemp = strTemp.split() # 공백을 기준으로 나눔
print(listTemp)
print(type(listTemp))
print('result - ', listTemp[-1])

Quiz - 마지막 문자열(code) 추출한다면 ?
code
['Talk', 'is', 'cheap.', 'show', 'me', 'the', 'code']
<class 'list'>
result -  code

strEx = '홀짝홀짝홀짝홀짝홀짝홀짝홀짝홀짝홀짝홀짝'

print('Quiz - 주어진 변수에 홀 만 추출하여 출력하고 싶다면 ?')

print('result 홀 - ', strEx[::2])
print('result 짝 - ', strEx[1::2])

Quiz - 주어진 변수에 홀 만 추출하여 출력하고 싶다면 ?
result 홀 -  홀홀홀홀홀홀홀홀홀홀
result 짝 -  짝짝짝짝짝짝짝짝짝짝

# 집합(set) : 연산 (합집합, 교집합, 차집합, etc...)
# {}
# 순서가 보장되지 않는다.
# 중복을 보장하지 않는다.
# 인덱싱 슬라이싱 불가
# 변경가능
# {} 비어있는 중괄호는 dict로 인식 비어두고 싶다면 set()을 사용

userRoles = {"admin", "user", "user", "guest"}
print('data - ', userRoles)
print('type - ', type(userRoles))

data -  {'guest', 'admin', 'user'}
type -  <class 'set'>

empSet = {}
print('type - ', type(empSet))

empSet = set()
print(dir(empSet)) # magic method, 일반 method
print()
print('type - ', type(empSet))

# add method 데이터 추가
empSet.add("user")
empSet.add("admin")
empSet.add("guest")

print('data - ', empSet)

empSet.discard('guest')
print()
print('data - ', empSet)

type -  <class 'dict'>
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']

type -  <class 'set'>
data -  {'guest', 'admin', 'user'}

data -  {'admin', 'user'}

# 연산 (| , & , -, ^)
adminRoles = {"read", "write", "delete", "update"}
userRoles = {"read", "comment"}

print('type - ', type(adminRoles), type(userRoles))
print()
print('합집합 - ', adminRoles | userRoles)
print('교집합 - ', adminRoles & userRoles)
print('차집합 - ', adminRoles - userRoles)
print('대칭차집합 - ', adminRoles ^ userRoles)

type -  <class 'set'> <class 'set'>

합집합 -  {'comment', 'delete', 'update', 'write', 'read'}
교집합 -  {'read'}
차집합 -  {'write', 'delete', 'update'}
대칭차집합 -  {'comment', 'delete', 'update', 'write'}

# 보안관점에서 set() 활용 방안을 생각해 본다면?
# 중복로그인 감지 (토큰 또는 세션을 관리)

userTokens = set()

def login(token):
    if token in userTokens:
        raise ValueError(f"[보안경고] 이미 로그인 중 : {token}")
    userTokens.add(token)
    print(f"{token}로그인 성공")

login('jslim')
login('sk')
login('jslim')

jslim로그인 성공
sk로그인 성공

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[128], line 14
     12 login('jslim')
     13 login('sk')
---> 14 login('jslim')

Cell In[128], line 8, in login(token)
      6 def login(token):
      7     if token in userTokens:
----> 8         raise ValueError(f"[보안경고] 이미 로그인 중 : {token}")
      9     userTokens.add(token)
     10     print(f"{token}로그인 성공")

ValueError: [보안경고] 이미 로그인 중 : jslim

# 연산자(operator) : in , not in
fruits = ['apple', 'banana', 'durian', 'orange']
print('data - ', fruits)
print('type - ', type(fruits))
print('orange' in fruits)

data -  ['apple', 'banana', 'durian', 'orange']
type -  <class 'list'>
True

출력형식 정리

userInfo = {
    'name' : 'jslim',
    'age' : 20
}

print('name ', userInfo['name'])
print('age ', userInfo['age'])

name  jslim
age  20

role = "admin"
print('문자열 연결(+)', "Hello "+role+" !!")

문자열 연결(+) Hello admin !!

# f-string(3.6~)
# {} 안에 변수나 표현식을 넣을 수 있음
name = "sk"
score = 95.1234
print('data - ', score)
print('type - ', type(score))
print(f" name : {name} , score : {score:.2f}")

data -  95.1234
type -  <class 'float'>
 name : sk , score : 95.12

# str.format()
lang = 'python'
version = 3.13

print("language : {} , version : {} ".format(lang, version))
print("language : {0} , version : {1} ".format(lang, version))
print("language : {a} , version : {b} ".format(a=lang, b=version))

language : python , version : 3.13 
language : python , version : 3.13 
language : python , version : 3.13 

# 서식 지정 연산자
# c 스타일 포맷 : %s, %d, %f, %.2f

# %.2fcm 단위 붙이기도 가능

print('language : %s , version : %.2fcm' % (lang, version))

language : python , version : 3.13cm

data = "Hello\nPython"
print(data)
print()
print(str(data))
print()
print(repr(data))

Hello
Python

Hello
Python

'Hello\nPython'

# 형변환 함수

strTemp = '100'
print('type - ', type(int(strTemp)))

type -  <class 'int'>

# 다중라인 출력

query = f"""select * 
        from table 
        where id = admin or 1 = 1"""
print(query)

msg = f"""
[user login Report]
===================
ID : sk
Time : 2025-10-27
STATUS : success
"""

print(msg)

select * 
        from table 
        where id = admin or 1 = 1

[user login Report]
===================
ID : sk
Time : 2025-10-27
STATUS : success

# 숫자 포맷
num = 1234567.8912

# Quiz : 천단위로 구분하고 싶다면
print(f"{num:,}")

# Quiz : 정렬
print(f"{num:>20.2f}") #오른쪽 정력 -> 20은 길이의 폭
print(f"{num:<20.2f}") #왼쪽 정렬
print(f"{num:020.2f}") #앞을 0으로 채워라

1,234,567.8912
          1234567.89
1234567.89          
00000000001234567.89

# 보안 관점에서 로그를 적용
# 이벤트로 수집된 데이터의 파싱을 용이하게 하기 위해서
# 탐지를 위한 규칙을 생성
# 변조된 데이터 식별을 쉽게하기 위함

loginUser = {
    'type' : 'guest',
    'ip'   : '192.168.0.10',
    'event': 'LOGIN_SUCCESS'
}

logMsg = f"[ALTER] User={loginUser["type"]} , IP = {loginUser["ip"]} , event = {loginUser["event"]}"
print(logMsg)

[ALTER] User=guest , IP = 192.168.0.10 , event = LOGIN_SUCCESS

logLst = []
print('type - ', type(logLst))
print()
print('dir - ', dir(logLst))
logLst.append(loginUser)
logLst.append(loginUser)
print()
print(logLst) 

type -  <class 'list'>

dir -  ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

[{'type': 'guest', 'ip': '192.168.0.10', 'event': 'LOGIN_SUCCESS'}, {'type': 'guest', 'ip': '192.168.0.10', 'event': 'LOGIN_SUCCESS'}]

logMsg = f"[ALTER] User={logLst[0]["type"]} , IP = {logLst[0]["ip"]} , event = {logLst[0]["event"]}"
print(logMsg)
logMsg = f"[ALTER] User={logLst[1]["type"]} , IP = {logLst[1]["ip"]} , event = {logLst[1]["event"]}"
print(logMsg)

[ALTER] User=guest , IP = 192.168.0.10 , event = LOGIN_SUCCESS
[ALTER] User=guest , IP = 192.168.0.10 , event = LOGIN_SUCCESS

# bool : 참(True) / 거짓(False)
# 조건문, 비교, 논리 연산자에서 사용됨
# semi bool : 1 / 0

isLoggedIn = True
hasPermission = False

print('castring - ', int(isLoggedIn), type(isLoggedIn))
print('castring - ', int(hasPermission))

print('Trusy, Falsy')
print('castring - ', bool(1))
print('castring - ', bool(0))
print('castring - ', bool('')) # '' 비어있으면 False
print('castring - ', bool('a')) # '' 들어있으면 True
print('castring - ', bool([]))
print('castring - ', bool([1,2,3]))

castring -  1 <class 'bool'>
castring -  0
Trusy, Falsy
castring -  True
castring -  False
castring -  False
castring -  True
castring -  False
castring -  True