유무디

Day 4까지 따라오셨다면, 이번 포스팅에서는 중간중간 헷갈리거나 차이정에 대한 의문이 생길법한 문법에 대하여 집고 넘어가 보도록 하겠습니다.

우선, 첫번째로는 값을 추가하는 append와 extend에 대하여 알아보도록 하겠습니다

append / extend 차이

☆ 한개의 값만 추가할 수 있는지 vs 합성되어 여러 개의 값으로 추가할 수 있는지의 차이입니다.

a = [1, 2, 3]
a.append(4)
print(a)

a = [1, 2, 3]
a.append([4, 5])                                    # append 는 한개만 추가시킨다 (list 도 한개)
print(a)

a = [1, 2, 3]
a.extend([4])                                       # append 와 같은 결과값
print(a)

a = [1, 2, 3]
a.extend([4, 5, 6])                                 # append 는 한개지만 extend 는 합성을 시킨다
print(a)

a = [1, 2, 3]
a = a + [4, 5, 6]                                   # + 연산자를 통해 extend 시키는것
print(a)

tuple / list 차이

a = ( )                                              # console 에선는 a 만처도 바로 나온다
b = [ ]
print(a, b, type(a), type(b))

a = 10,                                             # tuple type BUT 실제 사용 X, () 생략
print(type(a))

b = (10,)                                           # ( ,)를사용하여 tuple 을 만든다 <- best
print(type(b))

c = 10
d = (10)                                            # ,에따라 tuple type int type 이다
print(type(c), type(d))

e = (10, 20, 30,)
print(e, type(e))

f = 10, 20, 30                                      # () 생략된 tuple
print(f, type(f))

a = (10, 20, 30)
b, c, d = a                                         # a 가 가지고 있는 요소를 한개씩 집어넣은것
print(a, b, c, d)

a = [10, 20, 30]
b, c, d = a                                         # list 도 된다
print(a, b, c, d)

a = 10
b = 20
a, b = b, a                                         # data 교환
print(a, b)

a = [10, 20, 30]
tuple(a)                                 # list 자료형 -> tuple 자료형 (UD를 못하게끔)
b = tuple(a)                             # type 은 그대로기 때문에 return 값이 있다 (b라는 return 값을 만들어, b는 튜블 a 다 )
print(type(b))

a = (10,) + (20, 30)                                # tuple 항목 연결
print(a)
print((10,) + (20, 30))                             # 출력코드에 바로 대입 연결

a = (1, 2, 3)
b = (1, 2, 3, 4)
print(a == b)
print(a <= b)                                       # 대소비교 -> 갯수가 크냐 작냐

for i in a:
    print(i)

a = (10, 20, 30)
b = [10, 20, 30]
# print(a(0)) 					#tuple 일고 tuple 타입으로 data 을 찾을 수 없다

print(a[0])
b[0] = 20

# a[0] = 20 						#'tuple' object does not support item assignment

a = [10, '호랑이', [20, 30], (40, '코끼리', [50, 60], [70, 80])]                # list 안에 tuple 도 당연히 들어갈수 있다
print(a)

a = []
b = list()                                          # list 라는 함수를 call = list
print(type(a), type(b))

c = ()
d = tuple()                                         # tuple 함수
print(type(c), type(d))

e = [10, 20]
f = list('apple')                                   # int X
print(type(e), type(f))

a = []
b = tuple(a)                                        # list -> tuple
c = list(b)                                         # tuple -> list
print(type(a), type(b), type(c))

split

a = '호 랑 이'
print(a)
b = a.split(' ')                             # 문자열을 분리를 시켜서 (split 은 항상 return 값이 있다)저장되는 타입이 list
print(b)

[offset]

· 기준점으로부터 상대적으로 떨어진 거리 ← 배열 index

a = [10, 20, 30]
print(a[0], a[-1])                           # [-]역으로 돈다 BUT [-3]이하, [3]이상 은 out of bound

Dictionary

dictionary를 쉽게 예로 들자면 a = {k: v, k: v, k: v,...} 일 때, 
{k <- key v <- value } 색인 번호, key 값은 중복 X, 배열을 이용한 index 문법 X

a = {}
print(type(a))

a = {1: 10, 2: 20, 5: 40}
print(a)

a = {10: '호랑이', 20: '코끼리', 30: '독수리'}
print(a)

a = {1: 10, 2: 20, 2: 30, 5: 40}                                    # key 가 중복일 경우 가장 최근의 값을로 갱신된다
print(a)

a = {1: [10, 20], 2: [30, 40], 3: [50, 60]}                         # key 값은 증첩해서 넣을 수 있다 list or tuple etc...
print(a)

a = {1: (10, 20), 2: (20, 30), 5: (40, 50)}
print(a)

a = {1: 10, 2: '호랑이', 3: [10, 20], 4: (30, 40), 5: {1: 100}}      # key 값안에 key 중첩 사용 가능 (이중 중첩)
print(a)

a = {'호랑이': 10, '코끼리': 20, '독수리': 30}                          # key 값은 문자열도 가능
print(a)

a = {10: 1, 'apple': 2}                                            # key 값이 문자 숫자 가능하지만 가급적 같은 타입으로 통일
print(a)

a = {'name': '홍길동', 'age': 20, 'salary': 300}                    # key 값 = JSON 문법
print(a)

Dictionary의 활용 - CRUD

CRUD의 의미는 앞서 설명해서 아시죠~?

2021.04.28 - [Programming/Python 기초] - [Python 기초]파이썬 시작하기_Day 4(숫자/문자 변형, list 관리(CRUD)/활용)

a = {'name': '홍길동', 'age': 20, 'salary': 300}                     # key 값 = JSON 문법
print(a)

a['name'] = '이순신'                                               # data 갱신 방법
print(a)

print(a['name'], a['age'], a['salary'])                           # 배열의 틀을 이용하여 key 값 출력

a['height'] = 180                                                 # 찾는 key 값이 없을 경우, 속성이 자동으로 추가된다
print(a)

dictionary에서도 CRUD의 의미는 유용하게 사용됩니다.

1. Create

a = {}
a['name'] = '이순신'                                               # C)create
a['age'] = 20
print(a)

2. Reading

b = a['name']                                                     # R)reading
print(b, a['name'], a)                                            # 출력에서 바로 읽을수도 있고 함수로 지정해줄수도 있다

3. Update

a['name'] = '독수리'                                               # U)update
a['age'] = 100
print(a)

4. Delete

del(a['name'])                                                    # D)delete 1. del () <- 함수 사용
print(a)

del a['name']                                                     # 2. () 생략 가능 <- 예약어 사용
print(a)

Dictionary의 활용 - [], get(), key() 함수를 이용한 select

a = {'name': '홍길동', 'age': 20, 'salary': 300}
print(a)
b = a['name']
c = a.get('name')                                               # dict.get('key')
print(b, c)
print(a.keys())                                                 # 모든 key 출력

# a = range(0, 10)
print(a)
for i in a.keys():                                              # range 와 비슷하게 key 값을 돌릴수 있다
    print(i)

for items in a.items():
    # print('호랑이')
    print(items)                                                # ('name', '홍길동') <- 형식의 출력
# print(type(items))                                         # tuple type
print(items[0], items[1])                                   # name 홍길동 <- 형식의 출력

for values in a.values():
    print(values)                                                # items 과는 다르게 values 는 key 값 X, 값만 출력

Dictionary의 활용 - copy()

여기서 copy는 얕은 복사로 볼 수 있습니다.

a 복사를 20으로 갱신하면 a = 20 ← 메모리의 공유

deepcopy() 깊은 복사 ← 새로운 것을 갱신

a = [1, 2, 3]
b = a                                                # 대입 <- 얕은복사 ; 메모리 공유
print(id(a))
print(id(b))

a[0] = 4
b[2] = 5
print(a)
print(b)                                            # a를 변경시켜도 b를 변경시켜도 메모리를 공휴해서 같은 값
a.append(99)
print(a, b)                                         # 얕은 복사 결과값은 a b 둘다 같다

a = [1, 2, 3]
b = a[:]                                            # 슬라이스[0:3]전체 복사 <- 깊은 복사
print(id(a))
print(id(b))

a[0] = 4
b[2] = 5
print(a)
print(b)

a.append(99)
print(a, b)                                          # a와 b는 영향을 받지 않는다

a = {1: 100, 2: 200, 3: 300}
b = a
a[4] = 400
print(b) # b가 a를 포함해서 나타남 -> 얕은 복사

다음 포스팅에서는 함수 12가지 형태(function)에 대하여 인수 전달, return, break, 가변 인수 등 자세하게 알아보도록 하겠습니다.