Higher의 창작소

리스트형

# 파이썬 리스트
# 자료구조에서 중요
# 파이썬 배열 제공X
# 리스트 자료형(순서O, 중복O, 수정O, 삭제O)

리스트 사용법

리스트 선언
리스트 특징
리스트 인덱싱
리스트 슬라이싱
리스트 함수
리스트 삭제




# 선언

a = [] #비어있는 리스트
b = list() #비어있는 리스트
c = [70, 75, 80, 85] #0번~3번
d = [1000, 10000, 'Ace', 'Base', 'Captine']
e = [1000, 10000, ['Ace', 'Base', 'Captine']] #리스트 안에 리스트
f  = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]

# 인덱싱(내가 원하는 데이터를 꺼내오는 과정)

print('d - ', type(d), d) #d -  <class 'list'> [1000, 10000, 'Ace', 'Base', 'Captine']
print('d - ', d[1]) #d -  10000
print('d - ', d[0] + d[1] + d[1]) #d -  21000
print('d - ', d[-1]) #d -  Captine
print('e - ', e[-1][1]) #e -  Base 안쪽의 리스트를 선택한 다음 그 안의 1번 인덱스를 선택
print('e - ', list(e[-1][1])) #e -  ['B', 'a', 's', 'e']

# 슬라이싱

print('d - ', d[0:3]) #d -  [1000, 10000, 'Ace']
print('d - ', d[2:]) #d -  ['Ace', 'Base', 'Captine']
print('e - ', e[2][1:3]) #e -  ['Base', 'Captine'] 리스트 자체를 슬라이싱해서 리스트를 갖고 왔다.

# 리스트 연산(리스트를 연산하면 리스트가 결과로 나온다.)

print('c + d - ', c + d) #c + d -  [70, 75, 80, 85, 1000, 10000, 'Ace', 'Base', 'Captine'] 
 
print('c * 3 - ', c * 3) #c * 3 -  [70, 75, 80, 85, 70, 75, 80, 85, 70, 75, 80, 85]
 
# print("c[0] + 'hi' - ",c[0] + 'hi') 정수형+문자열이라서 계산 안됨
 
print("'Test' + c[0] - ", 'Test' + str(c[0])) #'Test' + c[0] -  Test70

# 값 비교

print(c == c[:3] + c[3:]) #True

# 같은 id(identity) 값

temp = c
print(c == temp) #True
 
print(id(temp)) #140570143319808
print(id(c)) #140570143319808 파이썬의 효욜성 때문에 리스트 역시 하나의 주소값을 공유한다.

# 리스트 수정, 삭제

c[0] = 4
print('c - ', c) #c -  [4, 75, 80, 85]
 
c[1:2] = ['a', 'b', 'c'] #슬라이싱을 했을 땐 리스트가 들어가지 않고 원소로 들어간다.
print('c - ', c) #c -  [4, 'a', 'b', 'c', 80, 85]
 
c[1:2] = [['a', 'b', 'c']] #[[]]을 해줘야 리스트로 들어간다.
print('c - ', c) #c -  [4, ['a', 'b', 'c'], 'b', 'c', 80, 85]
 
c[1] = ['a', 'b', 'c'] #인덱스를 딱 지정했을 땐 그냥 리스트 자체가 들어간다.
print('c - ', c) #c -  [4, ['a', 'b', 'c'], 'b', 'c', 80, 85]
 
c[1:3] = [] #삭제를 한 것
print('c - ', c) #c -  [4, 'c', 80, 85]
 
del c[3] #삭제
print('c - ', c) #c -  [4, 'c', 80]

# 리스트 함수

a = [5, 2, 3, 1, 4]
 
print('a - ', a) #a -  [5, 2, 3, 1, 4]
 
a.append(6) #마지막 끝 부분에 데이터를 삽입할 때 쓰는 함수
print('a - ', a) #a -  [5, 2, 3, 1, 4, 6]
 
a.sort() #오름차순 정렬
print('a - ', a) #a -  [1, 2, 3, 4, 5, 6]
 
a.reverse() #들어있는 데이터를 반대로(reverse) 정렬
print('a - ', a) #a -  [6, 5, 4, 3, 2, 1]
 
print('a - ', a.index(3),a[3]) #a -  3 3 인덱스 3번째 값
 
a.insert(2, 7) #두번째 위치에 7을 넣겠다.
print('a - ', a) #a -  [6, 5, 7, 4, 3, 2, 1]
 
a.reverse()
 
a.remove(1) #remove함수 제거할 값을 입력
 
#del a[]은 데이터의 갯수가 많으면 비효율적이다(인덱스 번호를 확실히 알고있어야한다.)
#del은 함수가 아니라 예약어.
 
print('a - ', a) #a -  [2, 3, 4, 7, 5, 6]
print('a - ', a.pop()) #a -  6
print('a - ', a.pop()) #a -  5
print('a - ', a) #a -  [2, 3, 4, 7]
#pop은 기존의 리스트에서 마지막 index에 해당하는 원소를 가져오고 나머지 원소들로 리스트를 다시 구성하는 것.
 
print('a - ', a.count(4)) #a -  1  내가 찾는 값(4)이 몇 개가 있는가?
 
ex = [8, 9]
a.extend(ex)
print('a - ', a) #a -  [2, 3, 4, 7, 8, 9] #값 추가

# 삭제 remove, pop, del

# 반복문 활용

while a:
    data = a.pop()
    print(data)
 
9
8
7
4
3
2

문자형

파이썬 문자형
문자형 중요!

문자형사용법

문자형중요성
문자형출력
이스케이프
멀티라인
문자형 연산
문자형 형 변환
인덱싱
문자열 함수
슬라이싱

# 문자열 생성

str1 = "I am Python."
str2 = 'Python'
str3 = """How are you?"""
str4 = '''Thank you!'''

# 문자열 출력

print(type(str1)) #<class 'str'>
print(type(str2)) #<class 'str'>
print(type(str3)) #<class 'str'>
print(type(str4)) #<class 'str'>

# 문자열 길이(공백포함 length)

print(len(str1)) #12
print(len(str2)) #6
print(len(str3)) #12
print(len(str4)) #10

# 빈 문자열

str_t1 = ''
str_t2 = str() #형 변환할 때처럼 str(object)를 호출해서 그 안의 값을 ()로 준다.
 
print(type(str_t1), len(str_t1)) #<class 'str'> 0
print(type(str_t2), len(str_t2)) #<class 'str'> 0

# 이스케이프 문자 사용

"""
참고 : Escape 코드
 
\n : 개행
\t : 탭
\\ : 문자
\' : 문자
\" : 문자
\000 : 널 문자
...
 
"""
print("I'm Boy") #I'm Boy
print('I\'m Boy') #I'm Boy
 
escape_str1 = "Do you have a \"retro games\"?"
escape_str2 = 'What\'s on TV?'
 
 
# 출력1
print(escape_str1) #Do you have a "retro games"?
print(escape_str2) #What's on TV?
 
# 탭, 줄바꿈
t_s1 = "Click \t Start!"
t_s2 = "New Line \n Check!"
 
# 출력2
print(t_s1) #Click 	 Start!
print(t_s2) #New Line 
            # Check!

# Raw String(역슬래쉬 자체를 신경쓰지 않는다. 있는그대로를 표시함)

raw_s1 = r'D:\Python\python3'
raw_s2 = r"\\x\y\z\q"
 
 
# Raw String 출력
print(raw_s1) #D:\Python\python3
print(raw_s2) #\\x\y\z\q

#멀티라인 입력
#역슬래쉬 사용

 
multi_str1 = """   #이렇게하면 정상적으로 출력 된다.
    문자열
    멀티라인 입력
    테스트
    """
 
multi_str1 =   #이렇게 입력하면 오류가 일어난다.
    """
    문자열
    멀티라인 입력
    테스트
    """
 
 
multi_str1 = \ #위 처럼하려면 역슬래쉬를 사용해야 정상적으로 출력이 된다.
    """
    문자열
    멀티라인 입력
    테스트
    """

#역슬래쉬로 끝나면 파이썬은 '이 다음에 어떤 변수를 바인딩하는구나'라고 인식한다. 

그래서 다음라인에 원하는 변수를 선언하면 된다.

또 다른 예시)
asdf= \
'dsadasd' \
'dsdsd' \

print(asdf) #dsadasddsdsd

# 멀티라인 출력

print(multi_str1)
#   문자열
#   멀티라인 입력
#   테스트
 
 
multi_str2 = \
    '''
    문자열 멀티라인
    역슬래시(\) \
    테스트
    '''
    
# 멀티라인(역슬래시) 출력
 
print(multi_str2)
#   문자열 멀티라인
#   역슬래시(\)     테스트

# 문자열 연산

str_o1 = "python"
str_o2 = "Apple"
str_o3 = "How are you doing?"
str_o4 = "Seoul Deajeon Busan Jinju"
 
print(3 * str_o1) #pythonpythonpython
print(str_o1 + str_o2) #pythonApple
print(dir(str_o1)) #(너무 길어서 생략)
 
print('y' in str_o1) #True
 #y라는 알파벳이 str_o1에 있냐고 물어보는 것
 #시퀀스형은 in연산자 사용이 가능하다.ex)list,str,tuple
 
print('n' in str_o1) #True
print('P' not in str_o2) #True

# 문자열 형 변환

print(str(66),type(str(66)))  # 66 <class 'str'>
print(str(10.1)) #10.1
print(str(True)) #True
print(str(complex(12))) #(12+0j)

# 문자열 함수(upper, isalnum, startswith, count, endswith, isalpha 등)

print("Capitalize: ", str_o1.capitalize()) #Capitalize:  Python 첫글자를 대문자로 바꿈
print("endswith?: ", str_o2.endswith("s")) #endswith?:  False 마지막글자가 s로 끝나냐?
print("join str: ", str_o1.join(["I'm ", "!"])) #join str:  I'm python!
print("replace1: ", str_o1.replace('thon', ' Good'))#replace1:  py Good
print("replace2: ", str_o3.replace("are", "was")) #replace2:  How was you doing?
 
print("split: ", str_o4.split(' '))  #split:  ['Seoul', 'Deajeon', 'Busan', 'Jinju']
#공백을 기준으로 쪼갠다.
#각각의 단어를 하나하나 리스트 배열 형태로 만듬 
 
print("sorted: ", sorted(str_o1))  # sorted:  ['h', 'n', 'o', 'p', 't', 'y'] list 형 변환. 순서가 정렬이 돼서 나옴
print("reversed1: ", reversed(str_o2)) #reversed1:  <reversed object at 0x00000207A4009F10>
#reversed 함수는 reversed 객체를 return하기 때문에 위와같이 나온다.
 
print(sorted(str_o2,reverse=True)) #['p', 'p', 'l', 'e', 'A'] reverse=True 내림차순
 
print("reversed2: ", list(reversed(str_o2))) #reversed2:  ['e', 'l', 'p', 'p', 'A']

# 반복(시퀀스) 설명

im_str = "Good Boy!"
 
print(dir(im_str))  # __iter__ 있으면 시퀀스. 즉, 반복할 수 있다는 것이다.
 
# 출력(반복문)
for i in im_str:  
    print(i)
    
G
o
o
d
 
B
o
y
!

# 슬라이싱(문자열은 시퀀스형이기 때문에 슬라이싱 처리를 할 수 있다.)

str_sl = 'Nice Python'
 
# 슬라이싱 연습
print(str_sl[0:3]) #Nic   0:3은 인덱스를 의미한다. 나오는건 3-1까지 나온다.
print(str_sl[5:])  #Python  5번째부터 끝까지 가져오라는 뜻. [5:11]과 같은 값
print(str_sl[:len(str_sl)]) #Nice Python   str_sl[:11] 처음부터 11까지
print(str_sl[:len(str_sl) - 1]) #Nice Pytho   str_sl[:11]
print(str_sl[:])  #Nice Python
print(str_sl[1:4:2]) #ie   세번째 인수는 단위를 의미한다.
print(str_sl[-4:-2]) #th  왼쪽에서는 0부터 오른쪽부터는-1부터 본다.
print(str_sl[1:-2])  #ice Pyth
print(str_sl[::-1]) #nohtyP eciN 처음과 끝을 가져오는데 순서는 오른쪽>왼쪽으로
print(str_sl[::2]) #Nc yhn 처음부터 끝까지 두 칸 간격으로 가져와리

# 아스키코드(또는 유니코드)

a = 'z'
 
print(ord(a)) #122 문자를 -> 아스키코드로
print(chr(122)) #z 아스키코드를 ->문자로

숫자형

숫자형 사용법
파이썬 모든 자료형
데이터 타입 선언
연산자 활용
형 변환
외부 모듈 사용

# 파이썬 지원 자료형

'''
int : 정수
float : 실수
complex : 복소수
bool : 불린(true 참, false거짓)
str : 문자열(시퀀스)
list : 리스트(시퀀스) #시퀀스: 반복을 처리 기능, 어떤 순서가 있거나 이런것들을 의미
tuple : 튜플(시퀀스)
set : 집합
dict : 사전
'''

이외에도 있지만 기본적으로 이 정도만 알아두자.

# 데이터 타입

str1 = "Python"
bool = True
str2 = 'Anaconda'
float_v = 10.0 #10은 정수(int) 10.0은 실수 (float)
int_v = 7
list = [str1, str2] #대괄호 사용
dict = {
    "name": "Machine Learning", #name,version을 키(key)라고 부른다.
    "version": 2.0
}
tuple = (3, 5, 7) #소괄호를 쓴다. 괄호없이 사용해도 된다.
set = {7, 8, 9} #중괄호 사용
 
# 데이터 타입 출력
print(type(str1)) #<class 'str'>
print(type(bool)) #<class 'bool'>
print(type(str2)) #<class 'str'>
print(type(float_v)) #<class 'float'>
print(type(int_v)) #<class 'int'>
print(type(dict)) #<class 'dict'>
print(type(tuple)) #<class 'tuple'>
print(type(set)) #<class 'set'>

# 숫자형 연산자

"""
+
-
*
/
// : 몫
% : 나머지
abs(x) #절대값
int(x)
float(x)
complex(x)
pow(x, y) #x의 y제곱
x ** y : #x의 y제곱
....
"""

# 정수 선언

# 정수 선언
i = 77
i2 = -14
big_int = 999999999999999999999999999999999999999
 
# 정수 출력
print(i) #77
print(i2) #-14
print(big_int) #999999999999999999999999999999999999999

# 실수 선언

# 실수 선언
f = 0.9999
f2 = 3.141592
f3 = -3.9
f4 = 3 / 9
 
# 실수 출력
print(f) #0.9999
print(f2) #3.141592
print(f3) #-3.9
print(f4) #0.3333333333333

# 연산 실습

 
i1 = 39
i2 = 939
big_int1 = 123456789123456789012345678901234567890
big_int2 = 999999999999999999999999999999999999999
f1 = 1.234
f2 = 3.939
 
# +
print(">>>>> + ")
print("i1 + i2 : ", i1 + i2) #i1 + i2 :  978
print("f1 + f2 : ", f1 + f2) #f1 + f2 :  5.173
print("big_int1 + big_int2 : ", big_int1 + big_int2)#big_int1 + big_int2 :  1123456789123456789012345678901234567889
 
#a = 3(정수형) + 1.0(실수형)
#a= 4.0 서로 다른 형을 계산하면 형 변환이 자동으로 이루어짐
#type(a)
#<class 'float'>
 
# -
print(">>>>> -")
print("i1 - i2: ", i1 - i2) #f1 - f2:  -2.705
print("f1 - f2: ", f1 - f2) #f1 - f2:  -2.705
print("big_int1 - big_int2: ", big_int1 - big_int2) #big_int1 - big_int2:  -876543210876543210987654321098765432109
 
# *
print(">>>>> *")
print("i1 * i2: ", i1 * i2) #i1 * i2:  36621
print("f1 * f2: ", f1 * f2) #f1 * f2:  4.860726
print("big_int1 * big_int2: ", big_int1 * big_int2) #big_int1 * big_int2:  123456789123456789012345678901234567889876543210876543210987654321098765432110
 
# /
print(">>>>> /")
print("i2 / i1: ", i2 / i1) #i2 / i1:  24.076923076923077
print("f2 / f1: ", f2 / f1) #f2 / f1:  3.1920583468395463
print("big_int2 / big_int1: ", big_int2 / big_int1) #big_int2 / big_int1:  8.10000006561
 
# //
print(">>>>> //")
print("i2 // i1: ", i2 // i1) #i2 // i1:  24
print("f2 // f1: ", f2 // f1) #f2 // f1:  3.0
print("big_int2 // big_int1: ", big_int2 // big_int1) #big_int2 // big_int1:  8
 
# %
print(">>>>> %")
print("i1 % i2 :", i1 % i2) #i1 % i2 : 39
print("f1 % f2 :", f1 % f2) #f1 % f2 : 1.234
print("big_int1 % big_int2 :", big_int1 % big_int2) #big_int1 % big_int2 : 123456789123456789012345678901234567890
 
# **
print(">>>>> **")
print("2 ** 3: ", 2 ** 3) #2 ** 3:  8
print("i1 ** i2: ", i1 ** i2) #i1 ** i2:  1022506312626635583804665030439848517886568042318083335...
print("f1 ** f2: ", f1 ** f2) #f1 ** f2:  2.289235194260789

# 형 변환 실습

a = 3. #실수 0은 생략가능
b = 6  #정수
c = .7 #실수 0은 생략가능
d = 12.7#실수
 
# 타입 출력
print(type(a), type(b), type(c), type(d))#<class 'float'> <class 'int'> <class 'float'> <class 'float'>
 
# 형 변환
print(float(b))  # 정수 -> 실수 6.0
print(int(c))  # 실수 -> 정수 0
print(int(d))  # 실수 -> 정수 12
print(int(True))  # Bool -> 정수 1 True:1. False:0을 의미한다.
print(float(True))  # Bool -> 정수 1.0
print(int(False))  # Bool -> 정수 0
print(float(False))  # Bool -> 정수 0.0
print(complex(3))  # 정수 -> 복소수 (3+0J)
print(complex('3'))  # 문자 -> 복소수 (3+0j) 문자열 3을 넣어도 내부적으로 문자혈 ->숫자형으로 바꾸고 실행된다.
print(complex(False))  # Bool -> 복소수 0j

# 앞의 코드에서 float=10.0, int=7로 변수에 네이밍을 줬기 때문에 float_v=10.0 int_v=7로 바꿔줘야한다. 

안그러면 똑같은 예약어를 사용했기 때문에 에러가 난다.

# 수치 연산 함수

print(abs(-7)) #절대값 7
x, y = divmod(100, 8)
print(x, y) #12 4 x는 몫, y는 나머지
print(pow(5, 3), 5 ** 3) #125 125

#외부 모듈(패키지 안에 모듈이 있다고 한다.)

import math
 
#ceil
print(math.ceil(5.1))   #6  x 이상의 수 중에서 가장 작은 정수
 
#pi
print(math.pi) #3.141592653589793

변수

다양한 변수 선언법

변수 할당 설명
object identity
변수 네이밍 규칙
예약

# 기본 선언
n = 700
 
# 출력
print(n) #700
print(type(n)) #<class 'int'> 정수형이다.
 
# 동시 선언
x = y = z = 700
 
# 출력
print(x, y ,z) #700 700 700

#type함수는 데이터타입(자료형)을 보여준다.

#선언
var = 75
 
# 출력
print(var) #75
print(type(var)) #<class 'int'>
 
# 재 선언
var = "Change Value" #기존에 선언된 값이 마지막에 선언된 값에 덮어 씌어진다.
 
# 출력
print(var) #Change Value
print(type(var)) #<class 'str'> 문자

# Object References(객체참조)

# 변수의 값  할당 상태일 때
# 1. 타입에 맞는 오브젝트 생성
# 2. 값 생성
# 3. 콘솔에 출력

# 예1)
print(300) #300 print(int(300))하고 같음

 #이 300이라는 것은 변수로 할당하지 않았다. 그렇기 때문에 이 함수 내에서 첫 번째로 타입에 맞는 오브젝트를 생성하고 두번째로 값을 생성하고 세번째로 콘솔출력 이러한 순서로 작동을 한다.

 #300은 int형이다. 이게 바로 오브젝트다. class형태로 내부적으로 이 300이라는 것을 int형으로 생성을 해서 그 다음에 값을 만들고 그 다음에 콘솔에 나오는 3단계를 걸치는 것이다.

# 예2)
# n -> 777
n = 777
#<class 'int'>형을 만들고 값 777을 넣는다.
 
print(n) #777
print(type(n)) #<class 'int'>
#최종적으로 print문에서 값을 출력한다.

m = n
# m-> 777 <- n
 
print(m, n) #777 777
print(type(m), type(n))#<class 'int'> <class 'int')
 
m = 400
# m-> 400, 777 <-n
 
print(m) #400
print(type(m)) #<class 'int'>

# id(identity)확인 : 객체(object)의 고유값 확인

m = 800
n  = 655
 
print(id(m))#140460940621328
print(id(n))#140460940621424
print(id(m) == id(n)) #false
 
 
m = 800
n  = 800
 
# 같은 오브젝트 참조
print(id(m)) #140460940621328
print(id(n)) #140460940621328
print(id(m) == id(n)) #True

#이름은 다른 변수에 똑같은 값이 할당 돼 있을 때는 하나의 오브젝트(똑같은 하나의 인스턴스)로 생성해버린다.(효율성을 위해)

/////////////////////////////////////////////////////////////////////////////////

[객체와 인스턴스의 차이]

클래스로 만든 객체를 인스턴스라고도 한다. 그렇다면 객체와 인스턴스의 차이는 무엇일까? 이렇게 생각해보자.

a = Cookie() 이렇게 만든 a는 객체이다. 그리고 a객체는 Cookie()의 인스턴스이다.

즉 인스턴스라는 말은 특정 객체(a)가 어떤 클래스(Cookie)의 객체인지를 관계 위주로 설명할 때 사용한다.

"a는 인스턴스"보다는 "a는 객체"라는 표현이 어울리며

"a는 Cookie의 객체"보다는 "a는 Cookie의 인스턴스"라는 표현이 훨씬 잘 어울린다.

////////////////////////////////////////////////////////////////////////////////////

# 다양한 변수 선언
# Camel Case :  numberOfCollegeGraduates 첫글자 소문자 그다음 연결되는 단어의 첫번째는 대문자 Method를 선언할 때 주로 사용한다.
# Pascal Case :  NumberOfCollegeGraduates 첫글자 대문자 연결되는 단어의 첫번째도 대문자 주로 class를 선언할 때 주로 사용한다.
# Snake Case :  number_of_college_graduates 전부소문자 변수를 선언할 때 주로 사용한다.
 
# 허용하는 변수 선언 법
age = 1
Age = 2
aGe = 3
AGE = 4
a_g_e = 5
_age = 6
age_ = 7
_AGE_ = 8

#특수문자나 숫자로 시작하는 변수는 사용하지 못한다. ex)1AGE = 7
#$, _등의 특수문자는 허용한다.
#숫자로는 시작하지 말고 웬만하면 소문자나 snake case형태로 변수를 선언하는게 깔끔한 코드를 만들 수 있다.

# 예약어는 변수명으로 불가능

"""
False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass
"""