AI 보안 데이터 리터러시_파이썬의 자료형(2)

딕셔너리

자주 사용하는 딕셔너리 함수

• Keys()
• Values()
• Del : 삭제

a = {0: 10, 1: 20, 2: 30} # 위치 정보 제공
a
> {0: 10, 1: 20, 2: 30}

type(a) # 딕셔너리는 {}
> dict

a[0]
> 10

b = { 'a': 10, 'b': 20, 'c': 30}
b
> {'a': 10, 'b': 20, 'c': 30}

b['a']
> 10

b['b']
> 20

b["c"]
> 30

▶ 리스트나 튜플에서 인덱스라고 불리는 부분을, 딕셔너리에서는 키라고 한다.

b.keys() # 딕셔너리에 어떤게 키로 사용되고 있는지 보여주는 함수
> dict_keys(['a', 'b', 'c'])

b.values() # 값을 꺼내줄 때 필요한 함수
> dict_values([10, 20, 30])

b['d'] = 40 # 딕셔너리 추가
b
> {'a': 10, 'b': 20, 'c': 30, 'd': 40}

b.keys()
> dict_keys(['a', 'b', 'c', 'd'])

b.values()
> dict_values([10, 20, 30, 40])

del b['c'] # 원소 삭제
b
> {'a': 10, 'b': 20, 'd': 40}

b['e'] = [50,60,70] # 딕셔너리 안에 리스트, 튜플, 딕셔너리 생성 가능
b
> {'a': 10, 'b': 20, 'd': 40, 'e': [50, 60, 70]}

b['f'] = (100,200)
b
> {'a': 10, 'b': 20, 'd': 40, 'e': [50, 60, 70], 'f': (100, 200)}

집합

집합은 어떤 특정 원소가 있는지 없는지를, 다른 자료형에 비해 매우 빠르게 찾아주는 특징을 가지고 있음.
원소가 몇개가 있는지가 아니라 있는지 없는지만 봄.

자주 사용하는 집합 함수

• Add() : 원소 추가
• Remove() : 원소 삭제

a = {1, 3, 5}
a
> {1, 3, 5}

type(a) # 집합
> set

a.add(7) # 원소 추가
a
> {1, 3, 5, 7}

a.add(5) # 이미 있는 원소를 추가하면 변화가 없음
a
> {1, 3, 5, 7}

a.remove(5)
a
> {1, 3, 7}

1 in a # a라는 집합에 1이 있는가?
> True

2 in a 
> False

2 not in a  # a라는 집합에 2라는게 없느냐?
> True

1 not in a
> False

b = {1, 2, 4, 6}
b
> {1, 2, 4, 6}

a | b # 합집합
> {1, 2, 3, 4, 6, 7}

a # a,b 자체에 영향을 주지 않음
> {1, 3, 7}

b
> {1, 2, 4, 6}

ab = a| b
ab
> {1, 2, 3, 4, 6, 7}

a & b # 교집합
> {1}

abc = a & b 
abc
> {1}

type(abc)
set

문자열

문자열에서의 연산

• '+' : 이어붙이기
• '*' : 반복하기

자주 사용하는 문자열 함수

• strip() : 앞/뒤 공백 제거
• split() : 문자열 분리
• join() : 문자열 병합
• lower() : 알파벳 대문자 → 소문자
• upper() : 알파벳 소문자 → 대문자
• count() : 카운트

a = '안녕'
b = '하세요'
a + b
> '안녕하세요'

a + a + b
> '안녕안녕하세요'

a * 2
> '안녕안녕'

a * 10
> '안녕안녕안녕안녕안녕안녕안녕안녕안녕안녕'

a * 2 + b
> '안녕안녕하세요'

c = a * 2 + b
c
> '안녕안녕하세요'

c[0]
> '안'

c[2:4]
> '안녕'

c[2:]
> '안녕하세요'

c[:4]
'안녕안녕'
for x in c :
    print(x)
> 안
  녕
  안
  녕
  하
  세
  요

d = 'Hello World!'
d
> 'Hello World!'

for x in d : # 띄어쓰기도 포함됨
    print(x)
> H
  e
  l
  l
  o

  W
  o
  r
  l
  d
  !

d.replace('Hello','Hi') # 교체, 하지만 자체를 바꾸는 건 아님
> 'Hi World!'

d
> 'Hello World!'

e = d.replace('Hello','Hi')
e
> 'Hi World!'

a ='   안녕   '
a
> '   안녕   '

b = '안녕'
a == b # 띄어쓰기로 다른 걸로 인식되어버림
> False

a.strip() # 양쪽 공백 모두 제거, 이것도 일시적으로 자체를 바꾸는 것이 아님
> '안녕'

a = a.strip()
a
> '안녕'

a == b
> True

b = '000-123-4567'
b.split('-') # 구분기호를 기준으로 끊어줌, 자체를 변하는 것은 아님
> ['000', '123', '4567']

b
> '000-123-4567'

c = b.split('-')
c
> ['000', '123', '4567']

c[0]
> '000'

c[2]
> '4567'

c[-1]
> '4567'

d = '빅데이터 머신러닝 인공지능'
d.split(" ") # == d.split()
> ['빅데이터', '머신러닝', '인공지능']

e = d.split(" ")
e
> ['빅데이터', '머신러닝', '인공지능']

''.join(e) # 끊어질걸 .앞에 부호로 이어주는 역할
> '빅데이터머신러닝인공지능'

'-'.join(e)
> '빅데이터-머신러닝-인공지능'

f = '-'.join(e)
f
> '빅데이터-머신러닝-인공지능'

a = 'Hello World!'
a # 대소문자를 구분해서 수를 세서, 통일을 해주면 좋음
> 'Hello World!'

a.lower()
> 'hello world!'

a.upper()
> 'HELLO WORLD!'

a # 원래의 값은 바뀌지 않음
> 'Hello World!'

c = 'HelLo'
c
> 'HelLo'

c.count('l') #대소문자 구별해서 수를 센다.
1

d = c.lower()
d.count('l')
> 2

기타

• Counter
• 복사
• Zip ()
• Enumerate()
  
  
  

Counter

.most_common()

from collections import Counter  #counter 쓰기 위해
a = 'a abc a ab abc a'
b = a.split()
b
> ['a', 'abc', 'a', 'ab', 'abc', 'a']

c = Counter(b)
c # 텍스트에 있는 단어의 개수를 세줌
> Counter({'a': 3, 'abc': 2, 'ab': 1})

c.most_common() # 가장 많이 나온 순으로 출력
> [('a', 3), ('abc', 2), ('ab', 1)]

c.most_common(1) # 가로 안에 숫자를 넣으면 가장 빈번하게 나온 n번째까지 나옴
> [('a', 3)]

c.most_common(2)
> [('a', 3), ('abc', 2)]

d = dict(c.most_common()) # 딕셔너리 형태로 저장
d
> {'a': 3, 'abc': 2, 'ab': 1}

type(d)
> dict

d['a'] # 딕셔너리 형태로 저장하면 좋은 점은 문자를 입력하면 몇번 나왔는지 바로 알 수 있음
> 3

d['ab']
> 1

복사

.copy()

a = [ 10,20,30]
b = a # a,b가 들어있는 내용물은 물론 타입도 같아짐
b 
> [10, 20, 30]

type(a)
> list

type(b)
> list

b[1] = 200
b
> [10, 200, 30]

a # 위에 b=a라고 해서 a와b가 연동이 된다.
> [10, 200, 30]

# 둘이 똑같이 연동돼서 복사하는게 아니라면,
from copy import copy

a = [10,20,30]
b = a.copy() # 한 곳을 같이 쓰는게 아니라, 새로운 것을 만들어서 쓰는 거라 개별적으로 활용 가능

b
> [10, 20, 30]

b[1] = 200
b
> [10, 200, 30]

a
> [10, 20, 30]

a == b
> False

c = {1:100, 2:200, 3:300}
d = c

del c[1]
c
> {2: 200, 3: 300}

d # 리스트가 아니라 딕셔너리 형태여도 결과는 동일
> {2: 200, 3: 300}

c == d
> True

c = {1:100, 2:200, 3:300}
d = c.copy()
d
> {1: 100, 2: 200, 3: 300}

del c[1]
c
> {2: 200, 3: 300}

d
> {1: 100, 2: 200, 3: 300}

c == d
> False

e = {1,3,5} # 집합에서도 마찬가지
f = e
e.remove(1)
e
> {3, 5}

f
> {3, 5}

e == f
> True

e = {1,3,5}
f = e.copy()

e.remove(1)
e
> {3, 5}

f
> {1, 3, 5}

e == f
> False

Zip

일대일로 매칭해서 하나씩 순서에 맞게 가져오고 싶을 때
반복문에서 많이 사용됨

a = 'abcd'
b = [1,2,3,4]

for x in a:
    print(x)
> a
  b
  c
  d

for x in b:
    print(x)
> 1
  2
  3
  4

for x,y in zip(a,b) :
    print(x,y)
> a 1
  b 2
  c 3
  d 4

ab = dict(zip(a,b))
ab
> {'a': 1, 'b': 2, 'c': 3, 'd': 4}

type(ab)
> dict

abc = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
abc
> {'a': 1, 'b': 2, 'c': 3, 'd': 4}

ab == abc # 하나씩하나씩 만든 것과 zip으로 만든거 둘다 결과가 같음
> True

a
> 'abcd'

b
> [1, 2, 3, 4]

c = [10,20,30,40]

for x, y, z in zip(a,b,c) :
    print(x,y,z)
> a 1 10
  b 2 20
  c 3 30
  d 4 40

Enumerate

위치정보가 필요할 때

a
> 'abcd'

for x in a :
    print(x)
> a
  b
  c
  d

for i, x in enumerate(a):  # i에는 위치정보가 입력됨
        print(i,x)
> 0 a
  1 b
  2 c
  3 d

for i, x in enumerate(a,10):  # 위치정보의 시작하는 인덱스의 값을 설정할 수 있음
print(i,x)
> 10 a
  11 b
  12 c
  13 d

for i, x in enumerate(a,1):
        print(i,x)
> 1 a
  2 b
  3 c
  4 d

d = dict(enumerate(a,1))
d
> {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

e = ['짱구', '맹구', '유리']

for i, x in enumerate(e,1):
            print(i,x)
> 1 짱구
  2 맹구
  3 유리

f = dict(enumerate(e,1))
f
> {1: '짱구', 2: '맹구', 3: '유리'}

g = '빅데이터 머신러닝 인공지능'
h = dict(enumerate(g,1))
h
> {1: '빅',
   2: '데',
   3: '이',
   4: '터',
   5: ' ',
   6: '머',
   7: '신',
   8: '러',
   9: '닝',
   10: ' ',
   11: '인',
   12: '공',
   13: '지',
   14: '능'}