In [2]:
str = '안녕하세요. 홍길동 고객님!'
str[:-2]
Out[2]:
'안녕하세요. 홍길동 고객'
In [7]:
print(str[::-1])
#파이썬은 마이너스 인덱싱을 지원
#-1은 끝에서부터 거꾸로
#::은 str전체를 뒤집음
!님객고 동길홍 .요세하녕안
In [1]:
str_1 = "Alphabet"
print(str_1.lower()) #소문자로 바뀌는 함수
alphabet
In [2]:
str_1.lower #함수만 호출되는 것이기 때문에 ()있어야 함.
# () -> 값을 호출해달라고 함
Out[2]:
<function str.lower()>
In [3]:
str_1.upper()
Out[3]:
'ALPHABET'
In [5]:
str_1 #값을 할당하지 않았기 때문에 str_1은 그대로다
Out[5]:
'Alphabet'
In [6]:
str_1.count('a')
Out[6]:
1
In [8]:
#str_1에서 모든 것을 소문자로 바꾼 다음에 a문자의 갯수를 세려면?
str_1.lower().count('a')
Out[8]:
2
In [9]:
str_1.find('t')
Out[9]:
7
In [10]:
str_1.index('z')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[10], line 1
----> 1 str_1.index('z')
ValueError: substring not found
In [11]:
str_2 = 'Life is C between B and D'
str_2
Out[11]:
'Life is C between B and D'
In [12]:
str_2.replace('C', 'Chicken')
str_2
Out[12]:
'Life is C between B and D'
In [13]:
str_2.split(' ') #split: 안에 기준을 넣을 수 있다.
Out[13]:
['Life', 'is', 'C', 'between', 'B', 'and', 'D']
In [15]:
str_2.split('C')
Out[15]:
['Life is ', ' between B and D']
In [16]:
str_2.strip(' ')
#strip은 꺽쇠가 없어짐
Out[16]:
'Life is C between B and D'
In [17]:
str_2.strip().split(' ')
Out[17]:
['Life', 'is', 'C', 'between', 'B', 'and', 'D']
In [21]:
str_3 = 'abcd'
','.join(str_3) #따옴표 ''사이에 삽입할 문자를 넣기
Out[21]:
'a,b,c,d'
In [20]:
str_4 = str_2.split()
' '.join(str_4) #split한 결과에 join을 사용하면 다시 문자열로 만들 수 있다.
Out[20]:
'Life is C between B and D'
In [23]:
print(dir(str_2)) #string의 method
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
In [24]:
#[]을 사용하여 리스트(list)임을 선언
#int, float 같은 다양한 데이터 타입 포함
#시퀀스 자료형, 여러 데이터들의 집합
list_1 = [3,2,5]
list_2 = list()
type(list_1)
Out[24]:
list
In [25]:
#list는 모든 자료형을 담을 수 있다
#삽입, 수정, 삭제가 자유롭다
#순서가 있는 자료형이기에 인덱싱과 슬라이싱이 가능하다
list_3 = [1, 2, '문자', ['이중 리스트', '가능'], ('리스트 속', '튜플')]
list_3[3]
Out[25]:
['이중 리스트', '가능']
In [26]:
list_3[4][1]
Out[26]:
'튜플'
In [28]:
#2차원 리스트는 리스트 안에 리스트를 넣어서 만든다
#,(콤마)로 구분
#리스트 = [[값, 값], [값, 값],[값,값]]
#요소 접근하기=> 리스트[세로인덱스][가로인덱스]
list_4 = [[1,2,3,4],
[2,4,6,8],
[3,6,9,12],
[4,8,12,16],
[5,10,15,20]]
list_4[1][3] #앞에서부터 순서대로 #1번 행, 3번째 열
Out[28]:
8
In [30]:
list_5 = [[[1,2,3],[4],[5,[6,7,8,9]]],
[10,11,[12,13,[14]]]]
list_5[1][2][2]
Out[30]:
[14]
In [31]:
list_6 = ['a','b','c']
list_7 = ['가','나','다']
list_6+list_7
Out[31]:
['a', 'b', 'c', '가', '나', '다']
In [32]:
list_6*3
Out[32]:
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
In [33]:
a in list_6
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In[33], line 1
----> 1 a in list_6
NameError: name 'a' is not defined
In [34]:
'a' in list_6
Out[34]:
True
In [56]:
list_8 = ['파이썬', 'C', 'java']
list_8.append('R') #삽입
list_8
Out[56]:
['파이썬', 'C', 'java', 'R']
In [57]:
#insert는 원하는 위치에
list_8.insert(2, 'C++')
list_8
Out[57]:
['파이썬', 'C', 'C++', 'java', 'R']
In [58]:
list_8.insert(5, 'C')
list_8
Out[58]:
['파이썬', 'C', 'C++', 'java', 'R', 'C']
In [59]:
#수정: 덮어쓰기 -> 인덱스나 슬라이싱을 통해 수정
list_8[0] = 'Phython'
list_8
Out[59]:
['Phython', 'C', 'C++', 'java', 'R', 'C']
In [60]:
#확장
list_8.extend(['MATLAB','Julia'])
list_8
Out[60]:
['Phython', 'C', 'C++', 'java', 'R', 'C', 'MATLAB', 'Julia']
In [61]:
#삭제:remove
list_8
Out[61]:
['Phython', 'C', 'C++', 'java', 'R', 'C', 'MATLAB', 'Julia']
In [62]:
#remove는 지우고자 하는 요소를 명시해야 함
#가장 앞에 있는 요소가 삭제됨
list_8.remove('C')
list_8
Out[62]:
['Phython', 'C++', 'java', 'R', 'C', 'MATLAB', 'Julia']
In [63]:
del list_8[6]
list_8
Out[63]:
['Phython', 'C++', 'java', 'R', 'C', 'MATLAB']
In [64]:
list_8.pop()
#꺼내오기:pop
Out[64]:
'MATLAB'
In [65]:
list_8
Out[65]:
['Phython', 'C++', 'java', 'R', 'C']
In [66]:
#pop은 괄호()안 인덱스에 해당하는 요소를 반환
#인덱스를 생략하면 가장 마지막 요소를 꺼내옴
In [67]:
#정렬:sort
list_9 = [1,5,7,2,6]
list_9.sort() #리스트 자체를 정렬
list_9
Out[67]:
[1, 2, 5, 6, 7]
In [ ]:
#list.sort(key=None, reverse=False)
#key: 정렬해주고 싶은 기준, 기본적으로 < 비교에 의해 정렬 (오름차순)
#reverse: True로 설정하게 되면 비교에 의해 정렬 (내림차순)
In [68]:
list_10 = [1,47,12,6]
list_10.sort(reverse=True)
list_10
Out[68]:
[47, 12, 6, 1]
In [69]:
list_9
Out[69]:
[1, 2, 5, 6, 7]
In [72]:
list_9.reverse()
list_9
Out[72]:
[7, 6, 5, 2, 1]
In [73]:
#현재 리스트 요소 순서를 뒤집음
#리스트 자체를 뒤집음
In [74]:
#뒤집기: reverse
list_10 = [1,47,12,6]
list_10.sort(reverse=True)
list_10
Out[74]:
[47, 12, 6, 1]
In [75]:
list_10.reverse()
list_10
Out[75]:
[1, 6, 12, 47]
In [76]:
a=[10,9,8,7,6]
b=[5,6,7,8,9,10]
print(id(a),id(b))
2959612968704 2959613019840
In [77]:
b=a
print(id(a), id(b))
2959612968704 2959612968704
In [80]:
a.sort()
print(b)
[6, 7, 8, 9, 10]
In [81]:
#sorted : return이 없음 -> 원본에 적용이 되지 않는다
In [82]:
id?
Signature: id(obj, /)
Docstring:
Return the identity of an object.
This is guaranteed to be unique among simultaneously existing objects.
(CPython uses the object's memory address.)
Type: builtin_function_or_method
In [84]:
#같은 값을 복사하고 싶다면?
a = [5,4,3,2,1]
b=a[:]
print(id(a),id(b))
2959613019840 2959613054208
In [85]:
b
Out[85]:
[5, 4, 3, 2, 1]
In [86]:
a.sort()
a
Out[86]:
[1, 2, 3, 4, 5]
In [87]:
b
Out[87]:
[5, 4, 3, 2, 1]
In [89]:
#case2
a = [5,4,3,2,1]
b = a.copy()
print(id(a),id(b))
2959612969792 2959613060928
In [90]:
a.sort()
a
Out[90]:
[1, 2, 3, 4, 5]
In [91]:
b
Out[91]:
[5, 4, 3, 2, 1]
In [92]:
a
Out[92]:
[1, 2, 3, 4, 5]
In [99]:
#얕은 복사는 객체의 참조값(주소 값)을 복사하고, 깊은 복사는 객체의 실제 값을 복사한다.
#case 3
import copy
a = [5,4,3,2,1]
b=copy.deepcopy(a)
print(id(a),id(b))
2959614125120 2959614125504
In [100]:
b
Out[100]:
[5, 4, 3, 2, 1]
In [101]:
a.sort()
a
Out[101]:
[1, 2, 3, 4, 5]
In [102]:
#case 4
a = [5,4,3,2,1]
b=a[:]
print(id(a),id(b))
2959612969984 2959614125056
In [103]:
b
Out[103]:
[5, 4, 3, 2, 1]
In [104]:
a.sort()
a
Out[104]:
[1, 2, 3, 4, 5]
In [105]:
b
Out[105]:
[5, 4, 3, 2, 1]
In [121]:
#case 5 #값만 복사하는건 2차원에서는 안됨
a = [[1,2],[3,4]]
a
Out[121]:
[[1, 2], [3, 4]]
In [122]:
b = a[:]
a[0][1]=100
a
Out[122]:
[[1, 100], [3, 4]]
In [123]:
b
Out[123]:
[[1, 100], [3, 4]]
In [125]:
#튜플(tuple)
#()을 이용하여 튜플(tuple)임을 선언
#보존해야 할것들에 쓰인다
tuple_1 = ()
tuple_2 = tuple()
tuple_3 = (1,2)
tuple_4 = (3,) #placeholder, 가변공간이다. #가변공간을 두개 이상 허락하지 않는다
tuple_5 = (4,5,(6,7))
tuple_6 = 8,9,10
#한 개의 요소만 사용할 때는 콤마(,)를 반드시 사용해야 함
#괄호가 없어도 튜플로 선언할 수 있다.
In [127]:
#tuple
#인덱싱과 슬라이싱이 가능
#리스트와 달리 요소를 삽입/삭제/수정 할 수 없음
tuple_3 = (1,2)
tuple_3[0] = 3
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[127], line 5
1 #tuple
2 #인덱싱과 슬라이싱이 가능
3 #리스트와 달리 요소를 삽입/삭제/수정 할 수 없음
4 tuple_3 = (1,2)
----> 5 tuple_3[0] = 3
TypeError: 'tuple' object does not support item assignment
In [135]:
#dictionary {}을 이용하여 딕셔너리임을 선언
#딕셔너리는 key와 value 값으로 이뤄진 자료형
#순서가 있는 자료형이 아니며, key를 통해 value값에 접근이 가능
#key는 고유한 값으로 중복될 수 없음
#value는 중복 가능
#인덱스 대신에 key사용
dict_3 = {'홍길동' :100, '홍계월': 200}
dict_3['슈퍼맨'] = 300
dict_3
Out[135]:
{'홍길동': 100, '홍계월': 200, '슈퍼맨': 300}
In [136]:
#요소 수정하기: 덮어쓰기
dict_3['홍길동'] = 1
dict_3
Out[136]:
{'홍길동': 1, '홍계월': 200, '슈퍼맨': 300}
In [137]:
#요소 삭제하기
#del: 파이썬 자체의 명령어로 메모리 자체에서 삭제
del dict_3['슈퍼맨']
dict_3
Out[137]:
{'홍길동': 1, '홍계월': 200}
In [138]:
#key와 value에 접근학
#1. key에 접근하기: keys()
dict_3 = {'홍길동' : 100, '홍계월': 200, '슈퍼맨' : 150, '배트맨' : 250}
print(dict_3.keys())
print(type(dict_3.keys()))
dict_keys(['홍길동', '홍계월', '슈퍼맨', '배트맨'])
<class 'dict_keys'>
In [139]:
#2. value에 접근하기: values()
print(dict_3.values())
print(type(dict_3.values()))
dict_values([100, 200, 150, 250])
<class 'dict_values'>
In [141]:
#3. key와 value에 함께 접근하기
print(dict_3.items())
print(type(dict_3.items()))
#리스트처럼 보이나 실제로는 dict의 개체이므로 리스트의 메소드를 사용할 수 없음
dict_items([('홍길동', 100), ('홍계월', 200), ('슈퍼맨', 150), ('배트맨', 250)])
<class 'dict_items'>
In [143]:
#리스트처럼 사용하고 싶다면 리스트로 형 변환을 해야 함
list(dict_3.keys())[0]
Out[143]:
'홍길동'
In [144]:
#key로 value에 접근하기
#1) 인덱싱처럼 키 값을 이용하여 바로 접근
#2) 메소드 get을 사용
dict_3
Out[144]:
{'홍길동': 100, '홍계월': 200, '슈퍼맨': 150, '배트맨': 250}
In [145]:
print(dict_3['배트맨'])
print(dict_3.get('배트맨'))
250
250
In [148]:
#key로 value에 접근하기
print(dict_3['peanut'])
#키값을 이용하여 접근할 경우, 해당 키가 없으면 오류 발생
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
Cell In[148], line 2
1 #key로 value에 접근하기
----> 2 print(dict_3['peanut'])
KeyError: 'peanut'
In [149]:
print(dict_3['peanut'])
#get을 통해 접근할 경우,None을 반환
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
Cell In[149], line 1
----> 1 print(dict_3['peanut'])
KeyError: 'peanut'
In [151]:
#set: {}을 이용하여 set을 선언
#중복을 허용하지 않음
#순서가 없음
set_1 = set()
set_2 = set('Hello')
set_3 = set([1,2,3])
set_4 = {3,5, 'hi'}
set_2
Out[151]:
{'H', 'e', 'l', 'o'}
In [152]:
set_3
Out[152]:
{1, 2, 3}
In [153]:
set_4
Out[153]:
{3, 5, 'hi'}
In [154]:
#set의 연상
#교집합
set_5 = {1,2,3,4}
set_6 = {4,5,6,7}
set_5&set_6
Out[154]:
{4}
In [155]:
set_5.intersection(set_6)
Out[155]:
{4}
In [156]:
#합집합
set_5 | set_6
Out[156]:
{1, 2, 3, 4, 5, 6, 7}
In [157]:
set_5.union(set_6)
Out[157]:
{1, 2, 3, 4, 5, 6, 7}
In [158]:
#차집합
set_5 - set_6
Out[158]:
{1, 2, 3}
In [159]:
set_5.difference(set_6)
Out[159]:
{1, 2, 3}
In [160]:
#set의 메소드
#1. 한 개 추가하기: add
set_6 = {4,5,6,7}
set_6.add(8)
set_6
Out[160]:
{4, 5, 6, 7, 8}
In [161]:
#2. 여러 개 추가하기: update
set_6.update([1,2,3])
set_6
Out[161]:
{1, 2, 3, 4, 5, 6, 7, 8}
In [162]:
#3. 한 개 지우기: remove
set_6.remove(3)
set_6
Out[162]:
{1, 2, 4, 5, 6, 7, 8}
In [164]:
#bool: 참과 거짓을 나타내는 자료형
type(False)
Out[164]:
bool
In [165]:
money = True
if money:
print("여행을 간다")
else:
print("집에서 쉰다")
여행을 간다
In [168]:
#조건문 if/elif/else
money = 20000
if money < 5000:
print('라면을 먹는다')
elif 5000 < money <25000:
print('치킨을 먹는다')
elif 25000 < money < 50000:
print('삼겹살을 먹는다')
else:
print('소고기를 먹는다')
치킨을 먹는다
In [169]:
#조건문 if/elif/else
money = 20000
if money > 0:
if money < 5000:
print('라면을 먹는다')
elif 5000 < money <25000:
print('치킨을 먹는다')
elif 25000 < money < 50000:
print('삼겹살을 먹는다')
else:
print('소고기를 먹는다')
else:
print('양수를 입력해주세요')
치킨을 먹는다
In [170]:
a = 3
b = 5
a < b
Out[170]:
True
In [171]:
c = 3
d = 3
c <= d
Out[171]:
True
In [172]:
c != d
Out[172]:
False
In [173]:
#메모리 주소는 다르고 값만 같다!!!
a = [1,2,3,4,5]
b=a[:]
a is b
Out[173]:
False
In [174]:
#논리연산자 and
#조건이 True/False로 반환이 됨
#&: 비트연산자로 작동 됨
#비교하는 대상이 모두 참이어야만 True 반환
a=100
if a>0 and (a%2)==0:
print('a is even')
a is even
In [176]:
5 and 7
#항상 큰 수가 나온다
Out[176]:
7
In [177]:
5 and 13
Out[177]:
13
In [180]:
5 & 7 #&은 비트연산자로 작동됨
Out[180]:
5
In [181]:
7 & 13 #0111&1101
Out[181]:
5
In [182]:
#논리연산자: or
#비교하는 대상 중 하나만 참이어도 True 반환
#조건이 True/False로 반환이 됨
a=100
if a>0 or (a%2)!=0:
print('a is even')
a is even
In [183]:
5 or 7
Out[183]:
5
In [184]:
7 or 13
Out[184]:
7
In [185]:
7 | 13 #|: 비트연산자로 작동 됨
Out[185]:
15
In [186]:
13 | 7
Out[186]:
15
In [187]:
#요소인지 파악하기: in/not in
#not: 참이면 False, 거짓이면 True를 반환
#1) x가 s의 요소인가
e = [1,3,5,7]
0 in e
Out[187]:
False
In [188]:
1 in e
Out[188]:
True
In [190]:
#x가 s의 요소가 아닌가, x not in s
2 not in e
Out[190]:
True
In [191]:
3 not in e
Out[191]:
False
In [194]:
#if문 안에 if문: 조건 안에 조건을 만들 수 있음
money = 20000
card = True
if card:
if money < 30000:
print('삼겹살을 먹는다')
else:
print('소고기를 먹는다')
else:
if money <= 1000:
pass
else:
print('라면을 먹는다')
삼겹살을 먹는다
In [195]:
#pass: 조건을 만족해도 아무 일도 일어나지 않게 하는것
In [197]:
#삼항 연산자(Ternary Operators)
#Condition(조건)이 참이면 true_value값을 취하고 거짓이면 false_value 값을 취함
#[true_value]if[condition] else[false_value]
value = 20
if value%2==0:
is_even: True
else:
is_even: False
print(is_even)
True
In [198]:
#formatting
num = 1
print('문자열 포맷팅 하기 예시 %d' %num)
문자열 포맷팅 하기 예시 1
In [199]:
ch = '이름'
print('내 이름은: %s' %ch)
내 이름은: 이름
In [200]:
fl = 2.566132
print('반올림 하기: %0.1f' %fl)
반올림 하기: 2.6
In [201]:
#%: 괄호로 묶어주면 두 개 이상도 포매팅 할 수 있음
a = 3
b = 5
print('%d와 %d를 더하면 %d' %(a,b,a+b))
3와 5를 더하면 8
In [202]:
#format
#'{}'.format(포맷팅할 변수)
print('문자열 포맷팅 하기 예시 {}'.format(2))
문자열 포맷팅 하기 예시 2
In [203]:
print('내 이름은: {}'.format(ch))
내 이름은: 이름
In [204]:
#괄호로 묵어주면 두 개 이상도 포맷팅 할 수 있음
a = '류'
b = '영표'
print('성은 {}, 이름은 {}'.format(a,b))
성은 류, 이름은 영표
In [205]:
#인덱스를 통해 순서를 지정할 수도 있음
print('성은 {0}, 이름은{1}'.format(a,b))
성은 류, 이름은영표
In [206]:
print('First name: {1}, Last name:{0}'.format(a,b))
First name: 영표, Last name:류
In [207]:
#format
#이름을 통해서 포맷팅할수도있음
print('나는 오늘 {음료}를 {개수}잔이나 마셨다'.format(음료='커피', 개수=3))
나는 오늘 커피를 3잔이나 마셨다
In [208]:
#f-string(f문자열 포맷팅)
#f'{}'
year = 2020
f'올해는 {year}'
Out[208]:
'올해는 2020'
In [209]:
#다른 포맷팅과는 달리 표현식을 지원함
drink = '커피'
nums = 3
f'나는 오늘 {drink}를 {nums + 1} 잔이나 마셨다'
Out[209]:
'나는 오늘 커피를 4 잔이나 마셨다'
In [210]:
#문자열 맨 앞에 f를 붙이고, 출력할 변수, 값을 중괄호 안에 넣습니다.
s='coffee'
n = 5
result1 = f'저는 {s}를 좋아합니다. 하루 {n}잔 마셔요.'
print(result1)
저는 coffee를 좋아합니다. 하루 5잔 마셔요.
In [213]:
'나는 오늘 %s를 %d+1잔이나 마셨다' %('커피',3)
#format은 연산을 못한다.
Out[213]:
'나는 오늘 커피를 3+1잔이나 마셨다'
In [212]:
drink = 'coffee'
nums = 3
f'I drank {nums+1} cups of {drink} today.'
Out[212]:
'I drank 4 cups of coffee today.'
In [214]:
#padding:여유 공간을 지정하여 글자배열+소수점 자릿수를 맞추기
print('Product: %8s, Price:%.5f.' %('Peer',3.241)) #8칸을 비우고, 5개의 소수점을 찍어라.
print('Product: {0:8s}, Price: {1:.5f}.'.format('Peer',3.241))
Product: Peer, Price:3.24100.
Product: Peer , Price: 3.24100.