레이블이 python_basic인 게시물을 표시합니다. 모든 게시물 표시
레이블이 python_basic인 게시물을 표시합니다. 모든 게시물 표시

2023년 7월 2일 일요일

python argument(인자)를 가변으로 전달하는 방법

인자를 전달할때 인자가 가변으로 전달하고 싶을때가 있습니다.

고전 언어들은 없던 기능이라 새로운 개념일 수 있는데 예를 들어보겠습니다.

complex()라는 함수가 있습니다. 여기에는 2개의 인자를 요구하는데 실수와 허수른 넘겨주면 복소수를 표현해주는 함수가 있습니다.


아래와 같은 형태가 됩니다.

print(complex(real=1, imag=2))
# (1+2j)

print(complex(imag=2))
# 2j

print(complex(real=1))
# (1+0j)

만약 데이터가 많아서 반복문을 쓰고 싶을때는 아래와 같이 표현하게 될것입니다.

com_data = [[1, 2], [0, 2], [1, 0]]
for one in com_data:
print(complex(one[0], one[1]))

[1, 2] 이런식으로 표현하면서 약속을 하게 되는 것이죠.


다시 해보면 아래와 같은 dictionary 형태로 표현이 가능합니다.

com_data = [{"real": 1, "imag": 2}, {"real": 0, "imag": 2}, {"real": 1, "imag": 0}]
for one in com_data:
print(complex(one.get("real"), one.get("imag")))


여기에는 치명적인 단점이 있습니다.

최초 예에서는 real 인자나 imag 인자가 없는 경우가 있었습니다. 그러나 여기에서는 0이라고 가정하고 모두 값을 넘겼습니다. complex() 라는 함수인 경우는 이러한 방법이 통했지만 항상 이런 함수만 있는것이 아닙니다.

그럼 어떻게 하면 될까요? 

해답은 dict 타입을 인자 그대로 전달하는 python argument 전달 규칙이 있습니다.

이것을 키워드 인자라고 표현을 하고 아래와 같이 '**' 로 표현 가능합니다.

  • 키워드 인자 (keyword argument): 함수 호출 때 식별자가 앞에 붙은 인자 (예를 들어, name=) 또는 ** 를 앞에 붙인 딕셔너리로 전달되는 인자. 예를 들어, 다음과 같은 complex() 호출에서 3 과 5 는 모두 키워드 인자입니다:

    complex(real=3, imag=5)
    complex(**{'real': 3, 'imag': 5})

https://docs.python.org/ko/3/glossary.html#term-argument

최종적으로 구현한 예제입니다.

com_data = [{"real": 1, "imag": 2}, {"imag": 2}, {"real": 1}]
for one in com_data:
print(complex(**one))





2023년 5월 14일 일요일

python isdigit() 예제

 

str의 멤버 함수인 isdigit() 라는 함수에 대해서 알아보겠습니다.

문자열이 숫자로 구성되어 있으면 True를 넘겨 주는 함수 입니다.

이때 숫자에 대한 부분이 모호해서 정리해봤습니다.

def isdigit(str_):
    print(str_, str_.isdigit())
    return str_.isdigit()


if __name__ == "__main__":
    isdigit("1200")
    isdigit(" 1200")
    isdigit(" 1200 ")
    isdigit("+1200")
    isdigit("-1200")
    isdigit("12.3")
    isdigit("a12")
    isdigit("12A")
    isdigit("12e1")
    isdigit("120000000000000000000000000000000000000000000000000000000000")
    isdigit("000000000000000000000000000000000000000000000000000000000012")

결과

1200 True
 1200 False
 1200  False
+1200 False
-1200 False
12.3 False
a12 False
12A False
12e1 False
120000000000000000000000000000000000000000000000000000000000 True
000000000000000000000000000000000000000000000000000000000012 True

정리해보면 주어진 문자열 안에 문자가 하나라도 있으면 False가 됩니다.


2023년 5월 1일 월요일

집합의 조합 product in python

 

일반적으로 조합이라고 단순하게 생각해 보면 1개의 집합 데이터가 있는 순열과 조합이 있는데 이것에 대해서는 앞에서 순열과 조합에 대해서 알아보았습니다.

이번에는 집합이 2개 이상일때 조합하는 방법 입니다.

예를 들어 보겠습니다. 아래와 같은 2개의 집합이 있습니다.

A={1,2,3}

B={4,5}

두개의 집합을 조합할때 아래와 같습니다.

{1,4},{1,5},{2,4},{2,5},{3,4},{3,5} 

물론 순서가 없는 경우이기 때문에 조합이라고 할 수 있습니다.

이것을 나타내는 수학적인 용어가 Product 라고 하는데 이미 존재합니다.

이번 시간에는 두개의 집합에 대해서 Product 를 계산하고, 집합이 세개 이상일때 어떻게 하면 될지도 고민해보겠습니다.


집합이 2개인 경우

import itertools

A = [1, 2, 3]
B = [4, 5]

sets = itertools.product(A, B)
for s in sets:
    print(s)

'''
(1, 4)
(1, 5)
(2, 4)
(2, 5)
(3, 4)
(3, 5)
'''

itertools.product 함수를 사용하면 단순합니다.


집합이 3개인 경우

import itertools

A = [1, 2, 3]
B = [4, 5]
C = [6, 7]

sets = itertools.product(A, B, C)
for s in sets:
    print(s)

'''
(1, 4, 6)
(1, 4, 7)
(1, 5, 6)
(1, 5, 7)
(2, 4, 6)
(2, 4, 7)
(2, 5, 6)
(2, 5, 7)
(3, 4, 6)
(3, 4, 7)
(3, 5, 6)
(3, 5, 7)
'''

3개인 경우도 인자를 늘리면 단순합니다.


집합 3개 이상 가변인 경우

import itertools

SET = [[1, 2, 3], [4, 5], [6, 7], [8, 9]]


def product_2(A ,B = []):
    if len(B) == 0:
        return A
    if len(A) == 0:
        return B
    sets = itertools.product(A, B)
    r = []
    for s in sets:
        r.append(s)
    return r

def list_extend(list_of_lists):
    result = []
    for item in list_of_lists:
        if type(item)==tuple or type(item)==list:
            result.extend(item)
        else:
            result.append(item)
    return result

def product_multi(set_list):
    result = []
    for i in range(len(set_list)):
        result = product_2(result, set_list[i])
        if i<=1: continue
        result2 = []
        for rone in result:
            result2.append(list_extend(rone))
        result = result2
    return result

print(product_2([],[1, 2]))
# [1, 2]
print(product_2([1,2],[3]))
# [(1, 3), (2, 3)]
print(product_2([(1, 3), (2, 3)],[4]))
# [((1, 3), 4), ((2, 3), 4)]
print(list_extend(((1, 3), 4)))
# [1, 3, 4]
print(product_multi(SET))
# [[1, 4, 6, 8], [1, 4, 6, 9], [1, 4, 7, 8], [1, 4, 7, 9], [1, 5, 6, 8], [1, 5, 6, 9], [1, 5, 7, 8], [1, 5, 7, 9], [2, 4, 6, 8], [2, 4, 6, 9], [2, 4, 7, 8], [2, 4, 7, 9], [2, 5, 6, 8], [2, 5, 6, 9], [2, 5, 7, 8], [2, 5, 7, 9], [3, 4, 6, 8], [3, 4, 6, 9], [3, 4, 7, 8], [3, 4, 7, 9], [3, 5, 6, 8], [3, 5, 6, 9], [3, 5, 7, 8], [3, 5, 7, 9]]

이번에는 제법 복잡한 코드입니다.

하나씩 추가해서 product 를 만들어 냅니다. 그런 후 결과를 펼치게 됩니다.

결과를 펼친다는 의미는 list_extend 를 한다는 의미입니다.

print(list_extend(((1, 3), 4)))
# [1, 3, 4]

즉 (1,3),4 란 결과가 나오면 이것은 (1,3,4)로 만들어야 하기 때문에 결과를 펼치게 됩니다.

최종 구현한 함수는 product_multi 함수를 참고 바랍니다.




2023년 4월 30일 일요일

순열(Permutations)과 조합(Combinations) in python

집합에서 조합

일반적으로 조합이라고 말은 하지만 수학적인 표현에 있어서는 2가지 순열과 조합이 있습니다.

순열은 순서를 따지기 때문에 집합에 있어서 {1,3} 과 {3,1} 을 다르게 생각합니다.

그리고 집합이 1개일때는 순열과 조합만 고려하면 되겠지만 집합이 2개 이상일 경우 집합끼리의 조합은 Product 연산이 됩니다.

여기에서는 집합(list 로 가정)하나에서 순열과 조합을 만드는 방법에 대해서 알아보도록 하겠습니다.

python에서는 여러가지 패키지가 있지만, list에서 쉽게 순열과 조합을 할 수 있는 패키지가 준비가 되어 있습니다.


공통적으로 아래 패키지를 import 해줍니다.

import itertools


순열

중복 없이 순서에 상관있게 나열합니다.

python 코드로는 다음과 같습니다.

val = [1, 2, 3]

for i in range(1, len(val)+1):
    perm_set = itertools.permutations(val, i)
    for sets in perm_set:
        print(sets)

결과

(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)


조합

집합에서 원소를 선택하는 것 혹은 선택의 결과로 정의됩니다. 어떤 순서로 원소를 선택했는지는 중요하지 않습니다.

val = [1, 2, 3]

for i in range(1, len(val)+1):
    comb_set = itertools.combinations(val, i)
    for sets in comb_set:
        print(sets)

결과

(1,)
(2,)
(3,)
(1, 2)
(1, 3)
(2, 3)
(1, 2, 3)


중복 조합

조합을 할때 같은 원소를 허용을 하는 경우 입니다.

val = [1, 2, 3]

for i in range(1, len(val)+1):
    perm_set = itertools.combinations_with_replacement(val, i)
    for sets in perm_set:
        print(sets)

결과

(1,)
(2,)
(3,)
(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)
(1, 1, 1)
(1, 1, 2)
(1, 1, 3)
(1, 2, 2)
(1, 2, 3)
(1, 3, 3)
(2, 2, 2)
(2, 2, 3)
(2, 3, 3)
(3, 3, 3)



2021년 10월 10일 일요일

python (dictionary) 자료구조 기본-딕셔너리(정렬)


dictionary(딕셔너리)

파이썬에 내장된 굉장히 쓸모있는 그리고 자주 사용하게 되는 자료 구조인 딕셔너리 입니다. 다른 언어의 map과 동일하거나 그 이상의 기능을 가집니다. 

map의 구조에 대해서 잘 모르시는 분은 '키',해당되는'값'을 매핑하는 연관 자료 구조라고 이해하면 됩니다.

키는 문자열과 숫자 그리고 문자열과 숫자로만 구성된 튜플이 될 수 있습니다.

당연한 얘기지만 한 딕셔너리 안에서 키가 중복되지 않습니다. 키:값 쌍 목록이 딕셔너리 표현법입니다.

삭제는 del을 이용합니다. 딕셔러리에 list(d) 를 수행하면 딕셔너리에서 사용되고 있는 모든 키의 리스트를 삽입 순서대로 돌려줍니다.


딕션너리 정의

dict() 함수를 이용해 만들 수 있습니다.

>>> a=dict()
>>> a
{}
>>> a=dict({'hello':100,'lion':200})
>>> a
{'hello': 100, 'lion': 200}
>>> a=dict(hello=100,lion=200)
>>> a
{'hello': 100, 'lion': 200}

대괄호를 이용해서 만들 수 있습니다.

>>> a={}
>>> a
{}
>>> a={'hello': 100, 'lion': 200}
>>> a


접근 참조 인덱싱

>>> a={1:100,0:200,"1":300}
>>> a
{1: 100, 0: 200, '1': 300}
>>> a[1]
100
>>> a["1"]
300
>>> a[0]
200
>>> a["1"]=400
>>> a
{1: 100, 0: 200, '1': 400}


삭제

삭제는 [키]로 이루어진다.

>>> a
{1: 100, 0: 200, '1': 400}
>>> del a[0]
>>> a
{1: 100, '1': 400}


반복/루프

딕셔너리의 list의 목록은 key가 돌아온다. 키를 이용해 디셔너리에 접근하여 처리가 가능하다.

>>> a
{1: 100, '1': 400}
>>> list(a)
[1, '1']
>>> for x in a:
...     print(x,a[x])
...
1 100
1 400


키정렬

키를 정렬 할것인가 값을 정렬할것인가에 따라 나뉘어집니다.

간단하게 키를 정렬하는 예제입니다. sorted 함수를 이용하면 키의 sort된 결과가 list형태로 돌아옵니다. 이것을 for loop를 사용해서 출력하면 됩니다. reverse정렬은 reverse=True 를 하면 됩니다.

if __name__ == "__main__":
	dict_test = {'ccc':300,'aaa':100,'bbb':200, 'ddd':150}
	
	print("\n key sort")
	rdata = sorted(dict_test)
	print(rdata)
	for x in rdata:
		print(x,dict_test[x])
		
	print("\n key sort reverse")
	rdata = sorted(dict_test,reverse=True)
	print(rdata)
	for x in rdata:
		print(x,dict_test[x])

결과

 key sort
['aaa', 'bbb', 'ccc', 'ddd']
aaa 100
bbb 200
ccc 300
ddd 150

 key sort reverse
['ddd', 'ccc', 'bbb', 'aaa']
ddd 150
ccc 300
bbb 200
aaa 100


값정렬

딕션너리의 items()라는 함수를 사용합니다. 그러면 tuple list형태로 변환이 되게 되는데 이것을 sorted 함수로 정렬합니다. 이것을 코드로 구현하면 아래와 같습니다.

f1(x) 함수는 정렬할때 정력할 키의 위치를 알려줄때 사용합니다. 딕셔너리의 키와는 다른 개념입니다.

def f1(x):
	return x[1]

if __name__ == "__main__":
	dict_test = {'ccc':300,'aaa':100,'bbb':200, 'ddd':150}

	print("\n value sort")
	rdata = sorted(dict_test.items(),key=f1)
	print(rdata)
	for x,y in rdata:
		print(x,y)
		
	print("\n value sort reverse")
	rdata = sorted(dict_test.items(),key=f1,reverse=True)
	print(rdata)
	for x,y in rdata:
		print(x,y)

결과

 value sort
[('aaa', 100), ('ddd', 150), ('bbb', 200), ('ccc', 300)]
aaa 100
ddd 150
bbb 200
ccc 300

 value sort reverse
[('ccc', 300), ('bbb', 200), ('ddd', 150), ('aaa', 100)]
ccc 300
bbb 200
ddd 150
aaa 100


키정렬2

위 개념을 이해했다면 다른방식으로도 키 정렬이 가능합니다. sorted 함수에 key에 x[0]가 되도록 설정하면 됩니다.

def f0(x):
	return x[0]

if __name__ == "__main__":
	dict_test = {'ccc':300,'aaa':100,'bbb':200, 'ddd':150}
	
	print("\n key sort")
	rdata = sorted(dict_test.items(),key=f0)
	print(rdata)
	for x,y in rdata:
		print(x,y)


리스트값의 정렬

좀 더 복잡한 형태입니다. 디셔너리가 리스트 형태를 취하고 있고 그중 특정 item의 정렬이 필요한 경우 입니다. f1() 함수의 변형이 필요합니다. 아래 예제에서는 list의 세번째 인자 값을 기준으로 정렬하는 예제입니다.

def f2(x):
	return x[1][2]

if __name__ == "__main__":

	dict_test = {'ccc':[100,300,140],'aaa':[200,400,300],'bbb':[100,40,300], 'ddd':[100,20,30]}
	print("\n list value sort")
	rdata = sorted(dict_test.items(),key=f2)
	print(rdata)
	for x,y in rdata:
		print(x,y)
	

여기에서 f2 함수의 x[1][2]의 의미입니다. 'ccc':[100,300,140]이란 첫번째 값의 경우 items로 변환이 되면 [('ccc',[100,300,140]),...] 이련 헝태도 변환되며 즉 x[1][2]의 경우 3번째 140의 값을 가지게 됩니다.

	x[1][2]
	-------
	x[0]:'ccc'
	x[1]:[100,300,140] 
	x[1][0]:100
	x[1][1]:300
	x[1][2]:140

결과

 list value sort
[('ddd', [100, 20, 30]), ('ccc', [100, 300, 140]), ('aaa', [200, 400, 300]), ('bbb', [100, 40, 300])]
ddd [100, 20, 30]
ccc [100, 300, 140]
aaa [200, 400, 300]
bbb [100, 40, 300]



2021년 10월 9일 토요일

python (tuple) 자료구조-튜플

튜플

앞에서 리스트에 대해서 공부했습니다. 리스트 개념은 자료구조에 대해서 공부한 사람이라면 누구나 예상 가능한 형태입니다. 그런데 튜플이란 뭘까요?

이해하기 쉽게 한줄로 승부를 걸겠습니다.


...

...

제가 나름대로 정리해본 그것은

...

...

List의 축소판, List와 성질은 같으나 값을 변경할 수 없는 자료 구조 입니다.


튜플값 정의

( ) 를 사용할수도 있고 없이도 사용할 수 있습니다.

>>> a = (1,2,3)
>>> a
(1, 2, 3)
>>> a = 1,2,3
>>> a
(1, 2, 3)

아래 예제를 보겠습니다. b는 list이고 a는 tuple 입니다. 

>>> b=[1,2,3]
>>> b.append(4)
>>> b
[1, 2, 3, 4]

>>> a=1,2,3
>>> a
(1, 2, 3)
>>> a.append(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> a
(1, 2, 3)

tuple 는 값을 추가하는것을 할 수 없습니다. 물론 삭제도 안되고요. 값 변경도 안됩니다.

>>> b[0]=10
>>> b
[10, 2, 3, 4]

>>> a[0]=10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a
(1, 2, 3)
>>> a[0]
1

내부 항목 access는 list처럼 []를 이용하여 인덱싱이 가능합니다. 결과를 놓고보면 단순 사용은 list와 동일합니다. 그런데 왜 이런 자료형을 만든것일까요?

생각해보면 단순합니다. C 언어를 사용했던 사람이라면 알고 있다면 const 지시어를 왜 만들었을까요? java의 static final 이 왜 있을까요? 

약간 성격이 다를 수 있지만, C언어의 const 경우 RO 영역에 배치를 한다던가 해서 얻는 이득이 있을겁니다. 하지만 python은 애초에 컴파일해서 RO영역에 배치하는 그런 언어들이 아니기 때문에 그런 부분에 이득을 얻을려고 하는것은 아닐 겁니다. 결국 생각 해볼 수 있는 것은 속도나 인간이 잘못해서 변경하는 부분을 방지하는 차원일것이라 예상해볼 수 있습니다.

stackoverflow 검색해보면 속도면에서 이득이 있다라는 댓글이 있습니다.


언패킹

튜플이나 리스트 모두 지원합니다.

>>> a,b,c=[1,2,3]
>>> a
1
>>> b
2
>>> c
3
>>> a,b,c=(1,2,3)
>>> a
1
>>> b
2
>>> c
3
>>> a,b,c=1,2,3
>>> a
1
>>> b
2
>>> c
3

함수의 값을 리턴할때 많이 사용합니다.

많은 언어들이 return type이 하나이지만 python은 튜플을 이용해서 여러개가 처리가 가능합니다.

return a,b,c 이런식으로 처리하면 받는쪽에서는 튜플 형태로 리턴이 됩니다.


2021년 9월 25일 토요일

python (list) 자료구조-리스트(삭제,합치기,추가,extend)

python (basic, start)기초 설치 및 시작하기

python (number,variable,string)숫자,변수,문자열

python (list) 자료구조-리스트


list

파이썬은 다른 값들을 덩어리로 묶는데 사용되는 가장 편한 방법은 리스트 입니다. 대괄호 사이에 쉼표로 구분된 값(항목)들의 목록으로 표현될 수 있습니다. 그리고 리스트는 서로 다른 형의 항목들을 포함할 수 있습니다.

문자열(그리고, 다른 모든 내장 시퀀스 형들)처럼 리스트는 인덱싱하고 슬라이싱할 수 있습니다.

모든 슬라이스 연산은 요청한 항목들을 포함하는 새 리스트를 돌려줍니다.

id() 함수는 python 자원의 id값을 넘겨줍니다. 아래 예제에서 사본의 경우 id가 다름을 알 수 있습니다.

>>> a = [1, 3, 5, 7, 9]
>>> a
[1, 3, 5, 7, 9]
>>> a[0]
1
>>> a[3]
7
>>> a[3:]
[7, 9]
>>> a[:]
[1, 3, 5, 7, 9]
>>> id(a)
1727802766976
>>> id(a[:])
1727802954304

리스트는 + 연산도 지원합니다. 뒤쪽으로 붙습니다.

>>> [1,2,3]+[2,3,4]
[1, 2, 3, 2, 3, 4]

리스트는 내용 변경이 가능합니다.

>>> a=[1,3,5,7]
>>> a[2]=6
>>> a
[1, 3, 6, 7]

list.append(x) 

메서드 (method) 를 사용하면 리스트의 끝에 새 항목을 추가할 수 있습니다. + 항목과 조금 다릅니다.

추가하려는 type형태를 취해야하고 list형태를 넣게 되면 list type항목으로 추가가 됩니다.

>>> a.append(9)
>>> a
[1, 3, 5, 7, 9]
>>> a.append([10])
>>> a
[1, 3, 5, 7, 9, [10]]
>>> [1,3,5,7]+2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "int") to list
>>> [1,3,5,7]+[2]
[1, 3, 5, 7, 2]

슬라이스 대입

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']

교체와 삭제

슬라이싱 크기보다 작은 list를 입력하면 길이가 줄어듭니다.

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> letters[2:5] = ['C', 'D']
>>> letters
['a', 'b', 'C', 'D', 'f', 'g']
>>> letters[2:5] = []
>>> letters
['a', 'b', 'g']

내장 함수 len() 은 리스트에도 적용됩니다:

>>> a=[1,3,5,7]
>>> len(a)
4

리스트를 중첩하여 다차원으로 배열처럼 사용할 수 있습니다.

>>> a=[['a', 'b', 'c'], [1, 2, 3]]
>>> a[1][0]
1
>>> a[0][0]
'a'
>>> a[0][1]
'b'
>>> a[0][2]
'c'

list.insert(i, x)

주어진 위치에 항목을 삽입합니다. 첫 번째 인자는 삽입되는 요소가 갖게 될 인덱스입니다. 그래서 a.insert(0, x) 는 리스트의 처음에 삽입하고, a.insert(len(a), x) 는 a.append(x) 와 동등합니다.

>>> a=[1,3,5,7]
>>> a.insert(1,2)
>>> a
[1, 2, 3, 5, 7]

참고

     [1,3,5,7]
index 0 1 2 3
        *
     [1,*,3,5,7] 

list.remove(x)

리스트에서 값이 x 와 같은 첫 번째 항목을 삭제합니다. 그런 항목이 없으면 ValueError를 일으킵니다.

remove의 인자는 인덱스가 아님을 주의해야합니다.

>>> a=[1,3,5,7]
>>> a.remove(3)
>>> a
[1, 5, 7]

특정 위치를 삭제하고자 한다면 index 슬라이싱을 이용하여 삭제합니다. del 을 이용하여 삭제 가능합니다.

슬라이싱에 넘어가는 인자는 from 일때 인덱스 포함, to 인덱스 미포함 입니다.

아래예제에서 index [2]인 5라는 숫자를 삭제하고자 하려고 하는 시도 입니다. 첫번째 시도 a[2]=[]로는 제대로 동작하지 않음을 참고하세요.

또한 pop() 메소드를 이용한 방법도 있습니다.

>>> a=[1,3,5,7]
>>> a[2]=[]
>>> a
[1, 3, [], 7]
>>> a[2:3]=[]
>>> a
[1, 3, 7]

list.pop([i])

리스트에서 주어진 위치에 있는 항목을 삭제하고, 그 항목을 돌려줍니다. 인덱스를 지정하지 않으면, a.pop() 은 리스트의 마지막 항목을 삭제하고 돌려줍니다. (메소드에서 i 를 둘러싼 대괄호는 매개변수가 선택적임을 나타냅니다. 그 위치에 대괄호를 입력해야 한다는 뜻이 아닙니다. 이 표기법은 파이썬 라이브러리 레퍼런스에서 자주 등장합니다.)

>>> a=[1,3,5,7]
>>> a.pop()
7
>>> a
[1, 3, 5]
>>> a.pop(1)
3
>>> a
[1, 5]

list.clear()

리스트의 모든 항목을 삭제합니다. del a[:] 와 동등합니다.

>>> a=[1,3,5,7]
>>> a.clear()
>>> a
[]

list.index(x[, start[, end]])

리스트에 있는 항목 중 값이 x 와 같은 첫 번째 것의 0부터 시작하는 인덱스를 돌려줍니다. 그런 항목이 없으면 ValueError 를 일으킵니다.

선택적인 인자 start 와 end 는 슬라이스 표기법처럼 해석되고, 검색을 리스트의 특별한 서브 시퀀스로 제한하는 데 사용됩니다. 돌려주는 인덱스는 start 인자가 아니라 전체 시퀀스의 시작을 기준으로 합니다.

>>> a=[1,3,5,7]
>>> a.index(3)
1
>>> a.index(7)
3
>>> a=[1,3,5,3]
>>> a.index(3)
1
>>> a.index(3,2)
3

list.count(x)

리스트에서 x 가 등장하는 횟수를 돌려줍니다.

>>> a=[1,3,5,3]
>>> a.count(1)
1
>>> a.count(3)
2
>>> a.count(2)
0

list.sort(*, key=None, reverse=False)

리스트의 항목들을 제자리에서 정렬합니다 (인자들은 정렬 커스터마이제이션에 사용될 수 있습니다. 설명은 sorted() 를 검색해 보세요). 여기에서는 간단한 예제만 들도록 하겠습니다.

>>> a=[1,3,5,3]
>>> a.sort()
>>> a
[1, 3, 3, 5]
>>> a.sort(reverse=True)
>>> a
[5, 3, 3, 1]

list.reverse()

리스트의 요소들을 순서를 뒤집습니다.

>>> a=[1,3,5,3]
>>> a.reverse()
>>> a
[3, 5, 3, 1]

list.copy()

리스트의 사본을 돌려줍니다. a[:] 와 동등합니다.

>>> a=[1,3,5,3]
>>> a.copy()
[1, 3, 5, 3]

리스트를 스택으로 사용하기

리스트 메서드들은 리스트를 스택으로 사용하기 쉽게 만드는데, 마지막에 넣은 요소가 처음으로 꺼내지는 요소입니다 (《last-in, first-out》). 스택의 꼭대기에 항목을 넣으려면 append() 를 사용하세요. 스택의 꼭대기에서 값을 꺼내려면 명시적인 인덱스 없이 pop() 을 사용하세요. 

>>> a=[]
>>> a.append(6)
>>> a.append(7)
>>> a
[6, 7]
>>> a.pop()
7
>>> a.pop()
6
>>> a.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop from empty list

list.extend(x)

이건 append(x)와 비슷한데 추가할때 append는 x 형태 그대로 리스트에 붙이지만

extend는 x를 list한거풀 벗기고 추가하게 됩니다.

예를 들어 보겠습니다.

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]


list index삭제 방법 여러가지 존재함

1. list[X:Y]=[]

2. list.pop(index)

3. del list[index]

4. del list[X:Y]





python (number,variable,string)숫자,변수,문자열

python (basic, start)기초 설치 및 시작하기

python (number,variable,string)숫자,변수,문자열

python (list) 자료구조-리스트

 

몇 가지 간단한 파이썬 명령을 사용해봅시다. 인터프리터를 실행하고 기본 프롬프트, >>>, 를 기다리세요. 

# 표시는 주석 입니다.


1. 숫자

다른 언어에서 처럼 숫자 사용 가능합니다. 

인터프리터는 간단한 계산기로 기능합니다. 표현식을 입력하면 값을 출력합니다. 표현식 문법은 간단합니다. +, -, *, / 연산자들은 대부분의 다른 언어들처럼 동작합니다. 괄호 (()) 는 묶는 데 사용합니다.

>>> 2+2
4
>>> 10+299
309
>>> (100+1)*3
303

정수 (예를 들어 2, 4, 20)는 int 형입니다. 소수부가 있는 것들 (예를 들어 5.0, 1.6)은 float 형입니다.

나눗셈 (/) 은 항상 float를 돌려줍니다. 정수 나눗셈 으로 (소수부 없이) 정수 결과를 얻으려면 // 연산자를 사용하면 됩니다. 나머지를 얻으려면 % 를 사용할 수 있습니다.

>>> 10/2
5.0
>>> 10/3
3.3333333333333335
>>> 10//3
3
>>> 10%3
1

파이썬에서는 거듭제곱을 계산할 때 ** 연산자를 사용합니다

>>> 10**3
1000

정리 - 사칙연산(+, -, *, /), 정수나누기 //, 나머지 %, 나누기 연산은 float 형태가 됨, 거듭제곱 **


2. 변수

변수에 값을 대입할 때는 등호(=)를 사용합니다. 

인터프리터에서 변수를 입력하면 변수안에 들어 있는 값을 출력합니다.

>>> width = 20
>>> height = 5 * 9
>>> width
20
>>> height
45
>>> width*height
900

변수가 《정의되어》 있지 않을 때 (값을 대입하지 않았을 때) 사용하려고 시도하는 것은 에러를 일으킵니다.

>>> n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined


3. 문자열

숫자와는 별개로, 파이썬은 문자열도 다룰 수 있는데 여러 가지 방법으로 표현됩니다. 작은따옴표('...') 나 큰따옴표("...")로 둘러쌀 수 있는데 모두 같은 결과를 줍니다. 따옴표를 이스케이핑 할 때는 \ 를 사용할 수 있습니다.

>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> "Isn't, they said."
"Isn't, they said."
>>> "Isn't, they said.
  File "<stdin>", line 1
    "Isn't, they said.
                     ^
SyntaxError: EOL while scanning string literal
>>>

만약 큰따옴표나 작은따옴표 규칙에 오류가 발생한다면 오류를 발생시킵니다.

print() 함수는 따옴표를 생략하고, 이스케이핑된 특수 문자를 출력해서 더 읽기 쉬운 출력을 만들어냅니다.

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s
'First line.\nSecond line.'
>>> print(s)
First line.
Second line.

\n : new line으로 개행을 의미합니다.

\ 뒤에 나오는 문자가 특수 문자로 취급되게 하고 싶지 않다면, 첫 따옴표 앞에 r 을 붙여서 날 문자열 (raw string) 을 만들 수 있습니다.

>>> s = r'First line.\nSecond line.'
>>> print(s)
First line.\nSecond line.

문자열은 여러 줄로 확장될 수 있습니다. 한 가지 방법은 삼중 따옴표를 사용하는 것입니다: """...""" 또는 '''...'''. 줄 넘김 문자는 자동으로 문자열에 포함됩니다. 하지만 줄 끝에 \ 를 붙여 이를 방지할 수도 있습니다.

아래 예제 참고 : \ 는 줄바꿈 처리를 하지 않는다.

>>> print(""" usage:\
... thing [opt]
... -h
... -H\
... hostname""")
 usage:thing [opt]
-h
-Hhostname

문자열은 + 연산자로 이어붙이고, * 연산자로 반복시킬 수 있습니다

>>> 3 * 'un' + 'ium'
'unununium'

두 개 이상의 문자열 리터럴 (즉, 따옴표로 둘러싸인 것들) 가 연속해서 나타나면 자동으로 이어 붙여집니다.

>>> 'Python''Py' 'thon'
'PythonPython'

변수들끼리 혹은 변수와 문자열 리터럴을 이어붙이려면 + 를 사용해야 합니다

>>> prefix = 'Py'
>>> prefix + 'thon'
'Python'

문자열은 인덱스 (서브 스크립트) 될 수 있습니다. 첫 번째 문자가 인덱스 0에 대응됩니다. 문자를 위한 별도의 형은 없습니다. 단순히 길이가 1인 문자열입니다

인덱스는 음수가 될 수도 있는데, 끝에서부터 셉니다 마지막 문자의 인덱스는 -1 입니다.

>>> word = 'Python'
>>> word[0]
'P'
>>> word[-1]
'n'

인덱싱에 더해 슬라이싱(slicing) 도 지원됩니다. 인덱싱이 개별 문자를 얻는데 사용되는 반면, 슬라이싱은 부분 문자열(substring)을 얻는 데 사용됩니다.

슬라이싱 개념은 [X:Y] X는 포함하는 인덱스를 출발하여 Y까지로 하되 Y는 포함하지 않는다.

from position X (included) to Y (excluded)

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
   0   1   2   3   4   5   6
  -6  -5  -4  -3  -2  -1

예를 들어 ho 라는 부분 문자열을 얻기위해서 index -3,3 는 'h'로 출발하고 'n' 위치는 포함하지 않는 index인 5,-1이 되어야한다.

>>> word = 'Python'
>>> word[-3:-1]
'ho'
>>> word[3:5]
'ho'
>>> word[-3:0]
''
>>> word[-3:-4]
''
>>> word[-3:-3]
''
>>> word[3:3]
''
>>> word[3:4]
'h'
>>> word[3:-1]
'ho'

첫 번째 인덱스를 생략하면 기본값 0 이 사용되고, 두 번째 인덱스가 생략되면 기본값으로 슬라이싱 되는 문자열의 길이가 사용됩니다.

아래 예제에서 첫번째 생략하면 0, 두번째가 생략되면 문자열 길이 6과 같아진다.

>>> word = 'Python'
>>> word[3:5]
'ho'
>>> word[:5]
'Pytho'
>>> word[0:5]
'Pytho'
>>> word[3:]
'hon'
>>> word[3:6]
'hon'

파이썬 문자열은 변경할 수 없다. 필요하다면 새로 생성 해야한다.

>>> word[0]='Z'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word = 'Python'
>>> 'Z'+word[1:]
'Zython'

내장 함수 len() 은 문자열의 길이를 돌려준다.

>>> len('Python')
6


정리

문자형(type)은 없음, 문자열 길이가 1임

파이썬 문자열은 변경할 수 없습니다. 변경하려고 하면 새로 만들어야 합니다.

내장 함수 len() 은 문자열의 길이를 돌려줍니다: