list의 다양한 기능들

list.index

list Value값을 통해 index위치를 알 수 있다.

list1= [135,462,27,2753,234]
list1.index(27)

output - > 2

list1.index(50)# value에러 발생 없는값이니깡
#이럴때는 확인을 위해 if in 사용

list1= [135,462,27,2753,234]
if 50 in list1:
	list1.index(50)
else:
	print("Check the list value {}".format(list1))

list.extend

더하기 연산과 비슷하게 list값을 추가하는것(성능이 조금 더 좋다고 함)

list1= [135,462,27,2753,234]
list1.extend([9,10,11])
print(list1)
output -> [135,462,27,2753,234,9,10,11]

list.insert(들어갈 위치, 값)

2에 해당하는 위치에 값넣고 나머지값 오른쪽으로 밀어냄

list1= [135,462,27,2753,234,9,10,11]
list1.insert(2,999)
print(list1)

#output -> [135, 462, 999, 27, 2753, 234, 9, 10, 11]

뒤에서첫번째에 넣기(가장마지막자리에 넣고 그자리에 있던값을 오른쪽으로 한칸 밀어버림)

list1.insert(-1,9999)
print(list1)
#output -> [135, 462, 999, 27, 2753, 234, 9, 10, 9999,11]

리스트갯수에 벗어나는 수를 넣어도 가장 마지막에 들어가버림.

list1.insert(10000, 555)
print(list1)
#output -> [135, 462, 999, 27, 2753, 234, 9, 10, 9999, 11, 555]

list.sort() & reverse()

list1.sort()
#output - >[9,10,11,27,135,234,462,555,999,2753,9999]
list1.reverse()
#output - > 위와 반대의 정렬이됨.

list와 문자열

list의 인덱스로 값(value) 가져오는 방법

my_list = [1,2,3,4,5,6]
my_list[0]
#output- > 1

string(문자열)의 인덱스로 값(value) 가져오는 방법

str = "Hello World"
str[0]
#output = 'H'
str[1]
#output = 'e'

list안의 값으로 인덱스 가져오는법

my_list.index(5)
#output 4

str안의 값으로 인덱스 가져오는법

str.index("r")
#output 8

list안의 값 확인하는 방법

3 in my_list
#output -> True
9 in my_list
#output ->False

String안의 값 확인하는 방법

"H" in str
#output - >True
"z" in str
#output -> False

str 을 list로 바꿔보기

abcdef라는 문자열이 각각 하나로 나뉘어짐(list("string"))을 사용// string과 list의 차이 알아보기

characters = list("abcedf")
print(chracters)
#output ['a','b','c','d','e','f']

split을 이용하여 구분의 기준점을 줄 수 있음.

words = "Hello world는 프로그래밍을 배우기에 아주 좋은사이트입니다."
words_list = words.split()
print(words_list)
#output 공백기준으로 갈라져서 나온다.

time_str = "10:35:27"
time_list = time_str.split(":")
print(time_list)
#output["10", "35", "27"]

여기서 join을 쓰며 다시 str으로 만들 수 있다.

":"join(time_list)
#output '10:35:27'

Slice

list와 str의 Slicing 방법은 똑같다.

list = [1,2,3,4,5]
list[1]
#output 2
text ="Hello World"
text[1]
#output'e'
text[1:5]
'ello'
text[5]
' '

이렇게 범위를 지정해서 뽑아낼수도있다 [해당하는 숫자: 해당숫자까지의 값]

간략한 설명

text = "hello world"
text[1:5]         # ello          1번째부터 5번째 전까지
text[3:]          # lo world      3번째부터 끝까지
text[:3]          # hel           처음부터 3번째까지
text[:]           # hello world   처음부터 끝까지

예제1

list =['영','일','이','삼','사','오']
list[1:3]
#output ['일','이'] #1,2 의 index에 해당하는 값.
list[1]
#output['일']

예제2

list =['영','일','이','삼','사','오']
list[2:len(list)]
#output['이','삼','사','오']

list[2:]
#output['이','삼','사','오'] 위와 같은방식인것을 알 수 있다.

list[:2]
#output['영','일'] 이렇게 비워놓으면 좌우로 첫부분 또는 끝부분으로자동 설정됨.

list[:]
#output 원래의 값과 똑같이나오나 이건 값이 똑같은 새로운 리스트를 만드는 것이다.

함수로 사용한 예제

def substring(text, start, end):
	return text[start:ent]

my_text = "Hello world"
between_2_5 = substring(my_text, 2, 5) #함수사용값 변수에 넣음 // arg1: text, arg2: start, arg3: end;
print(between_2_5)

slice의 step

list = list (range(20))
#output  0~19까지의 list값이 나옴

list [5:15]
5~ 14까지

step 사용

list1[5:15:2]
#output [5,7,9,11,13] 
으로 두개씩 출력됨.

'-' step 사용

list1[5:15:-1]
#output []
list1[15:5:-1]
#output [15,14,13,12,11,10,9,8,7,6]
15부터 6까지 주욱 나옴

전체에서도 step 사용 가능

list1[::3]
#output [0,3,6,9,12,15,18]

slice로 list 수정하기

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

두개다 같은것임.

numbers = list(range(10))

del numbers [0]

print(numbers)
#ouput [1,2,3,4,5,6,7,8,9]

del numbers[:5]
#output [6,7,8,9]

numbers[1:3] 

#output [7,8]
numbers[1:3] = [77,88]

print (numbers)
#output [6,77,88,9]로 대체 되었다. 여기서

numbers[1:3] = [77,88,99]
pirnt(numbers)
#output [6,77,88,99,9]로  77,88이 있던 자리에 77,88,99가 들어갔다.

numbers[1:4] = [8]
pirnt(numbers)
#output [6,8,9]로

자료형 다루기

자료형 알아내기

s = "Hello World"
type(s)
<class 'str'>

f = 3.14
type(f)
class 'float'

i = 42
type(i)
class'int'

f2= 42.0
type(f2)
class float

42 == 42.0
True
### 자료형 검사
isinstance(42,int)
True
isinstance(42, float)
True
isinstance(42.0,int)
False

클래스와 인스턴스

클래스(class) = 함수나 변수들을 모아놓은 집합체

인스턴스(instance) = 클래스에 의해 생성된 객체
-> 인스턴스 각자 자신의 값을 가지고 있다.

numbers1 = []

numbers2 = list(range(10))
print(numbers)
#output ->[0,1,2,3,4,5,6,7,8,9]

characters = list("Hello")
print(characters)
#output - > ['H','e','l','l','o']

type(number2)
<class'list'>
type(characters)
<class'list'> # 둘다 동일한 list class 임

ininstance(numbers1,list)
True 
numbers1 == list
False

numbers1과 numbers2 는 각 각 서로 다른 인스턴스이지만
list클래스로서 같은 인스턴스이다.

아래 예제를 보자
is 연산을 하면 둘이 같은 인스턴스 인지 알아볼 수 있고

== 연산을 하면 둘이 같은 '값'을 가지는지 알아볼 수 있다.

list1 = [1, 2, 3]
list2 = [1, 2, 3]

if list1 is list1:
    print("당연히 list1과 list1은 같은 인스턴스입니다.")

if list1 == list2:
    print("list1과 list2의 값은 같습니다.")
    if list1 is list2:
        print("그리고 list1과 list2는 같은 인스턴스입니다.")
    else:
        print("하지만 list1과 list2는 다른 인스턴스입니다.")

당연히 list1과 list1은 같은 인스턴스입니다.
list1과 list2의 값은 같습니다.
하지만 list1과 list2는 다른 인스턴스입니다.

와 같이 출력된다.

클래스 만들기

• list class 는 값을 순서대로 저장할 수 있으며 변경가능하고 중복이 가능하다
• tuple 클래스는 값을 저장할 수 있으나 순서대로 저장 가능 불가하고 변경이 불가하당
• class와 instance를 이용하면 사람이 이용하기 쉽도록 코드를 정의할 수 있음.

클래스는 아래와 같이 만들면 된다
class name():

class Human(): #클래스선언
	'''사람'''
    
person1 = Human() #인스턴스 생성
person2 = Human()

person1.language = '한국어' #같은 인간클래스이나 인스턴스끼리는 다른값을 가지게 됨.
person2.language = 'English'

print(person1.language)
print(person2.language)

#output
한국어
English

클래스와 인스턴스를 이용하여 데이터와 코드를 사람이 이용하기 쉽게 포장한 경우가 있다.
함수를 넣어서 작성한것을 살펴보자

함수가 클래스 밖에 있는 경우

class Human(): #클래스선언
	'''사람'''
    
person1 = Human() #인스턴스 생성
person2 = Human()

person1.language = '한국어' #같은 인간클래스이나 인스턴스끼리는 다른값을 가지게 됨.
person2.language = 'English'

person1.name = '서울시민' # 행동을클래스 안에 넣은것과 같은것.
person2.name = '대구시민'

def speak(person):
	print("{}이 {}로 말을 합니다.".format(person.name, person.language))


speak(person1)
speak(person2)

#output
서울시민이 한국어로 말을합니다.
대구시민이 English로 말을 합니다.

함수가 클래스 밖에 있는 경우

class Human(): #클래스선언
	'''사람'''
    
person1 = Human() #인스턴스 생성
person2 = Human()

person1.language = '한국어' #같은 인간클래스이나 인스턴스끼리는 다른값을 가지게 됨.
person2.language = 'English' #이해가 안된다면 인스턴스각자에게 인스턴스 값을 저장했다고 생각하자.

person1.name = '서울시민' # 행동을클래스 안에 넣은것과 같은것.
person2.name = '대구시민'

def speak(person):
	print("{}이 {}로 말을 합니다.".format(person.name, person.language))	
Human.speak = speak

person1.speak()
person2.speak()

#output
서울시민이 한국어로 말을합니다.
대구시민이 English로 말을 합니다.

모델링(Modeling)

클래스로 현실의 개념을 표현하는것을 모델링이라고 한다!

아래는 예제이다

class Human():
	'''인간'''
    
person = Human()
person.name ='철수'
person.weight = 60.5

위와같이 하면 매번 새로운 인스턴스를 만들어야 하는 불편함이 있으니
함수를 만들어보자

class Human():
	'''인간'''

def create_human(name,weight): # 이름과 몸무게 arg를 받음
	person = Human() #인스턴스 만들기
    person.name = name #인스턴스를 매개변수 받은 이름으로 지정
    person.weight =weight
    return person
 
Human.create = create_human # 함수를 Human클래스안에 넣어서 작성

person = Human.create("철수",60.5) #이러면 철수와 60.5 를가진 person 이란 인스턴스가 생김

def eat(person):
	person.weight +=0.1
    print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))
    
def walk(person):
	person.weight -=0.1
    print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
    
Human.eat = eat # 위 두개의 함수를 Human class안에 넣어 변수로만듦.
Human.walk = walk

person = Human.create("철수",60.5) #이러면 철수와 60.5 를가진 person 이란 인스턴스가 생김
person.walk()
person.eat()
person.walk()
    

메소드 이해하기(Method)

메소드는 함수와 비슷하며 클래스에 묶여서 클래스의 인스턴스와 관계되는 일을 하는 함수라고 한다.

인스턴스에다가 함수를 호출하는것을 method라 한다.

빈클래스를 만들고 함수를 따로 만드는 것이 클래스에 다시 함수를 넣고 하는 것이 번거로우므로
클래스안에 바로 함수를 적어버릴 수 있다

이렇게 하면 별도로 클래스안에 함수를 넣어주는 작업을 따로 하지 않아도 된다.

class Human():
	'''인간'''
	def create_human(name,weight): # 이름과 몸무게 arg를 받음
        person = Human() #인스턴스 만들기
        person.name = name #인스턴스를 매개변수 받은 이름으로 지정
        person.weight =weight
        return person
        
 	def eat(person):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(person):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
    

person = Human.create("철수",60.5) #이러면 철수와 60.5 를가진 person 이란 인스턴스가 생김
person.walk()
person.eat()
person.walk()
    

파이썬에서는 보통 메소드의 첫번째 인자를 self라고 쓰는데 위 함수를 아래와 같이 바꿀 수 있다.

class Human():
	'''인간'''
	def create_human(name,weight): # 이름과 몸무게 arg를 받음
        person = Human() #인스턴스 만들기
        person.name = name #인스턴스를 매개변수 받은 이름으로 지정
        person.weight =weight
        return person
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))

def eat(self):
    person.weight +=0.1
    print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))    

person = Human.create("철수",60.5) #이러면 철수와 60.5 를가진 person 이란 인스턴스가 생김

person.eat() #eat(person)  
#똑같이 출력됨. / person이라는 instance에 eat을 호출하면 self라는 첫번째 매개변수에 자동으로 전달되기 때문
    

전달해야하는 매개변수가 두개일 경우를 살펴보자

class Human():
	'''인간'''
	def create_human(name,weight): # 이름과 몸무게 arg를 받음
        person = Human() #인스턴스 만들기
        person.name = name #인스턴스를 매개변수 받은 이름으로 지정
        person.weight =weight
        return person
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def speak(self, message):
        print(message)    

person = Human.create("철수",60.5) #이러면 철수와 60.5 를가진 person 이란 인스턴스가 생김

person.speak("안녕하세요.") # self는 넣어주지 않고 message에 해당하는 것만 넣어줌. 

클래스에서 사용할 수 있는 특수한 메소드!

특수한 메소드는 언더바를 이용해서 나타내 준다.

• init : 인스턴스를 만들때 실행되는함수.
• str : 인스턴스 자체를 출력할때의 형식을 지정해주는 함수.

init

class Human():
	'''인간'''
    
    def __init__(self):
    	'''초기화함수'''
        print("__init__실행")
    def __str__(self):
    	'''문자열화 함수'''
    
	def create_human(name,weight): # 이름과 몸무게 arg를 받음
        person = Human() #인스턴스 만들기
        person.name = name #인스턴스를 매개변수 받은 이름으로 지정
        person.weight =weight
        return person
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
 
 
 person = Human()
 #단지 Human클래스의 인스턴스를 person에 저장한 것 뿐인데 init함수가 실행되면서 print문이 실행됨
 #output - > __init__실행
 #init함수는 인스턴스를 만드는순간 자동으로 호출이 되는 함수이기 때문이다!

class Human():
	'''인간'''
    
    def __init__(self, name, weight):
    	'''초기화함수'''
        print("__init__실행")
        print("이름은{}, 몸무게는 {}".format(name,weight))
        
    def __str__(self):
    	'''문자열화 함수'''
    
	def create_human(name,weight): # 이름과 몸무게 arg를 받음
        person = Human() #인스턴스 만들기
        person.name = name #인스턴스를 매개변수 받은 이름으로 지정
        person.weight =weight
        return person
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
 
 
 person = Human("사람", 60.5)

#init을 직접 호출하는 것은 아니지만 Human class에 넣어주면 됨
#무조건 호출되기 때문??

init함수를 통해 create함수를 대체할 수 있을 것 같다.
아래는 대체한 예제이다.

class Human():
	'''인간'''
    
    def __init__(self, name, weight):
    	'''초기화함수'''

        self.name = name  # person에서 self가 된다. 
        self.weight = weight

# init을 통해 create를 대체했다.

    def __str__(self):
    	'''문자열화 함수'''
    
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
 
 
 person = Human("사람", 60.5)
print(person.name)
print(person.weight)

str

이제 문자열화 함수인 str을 사용해보자

class Human():
	'''인간'''
    
    def __init__(self, name, weight):
    	'''초기화함수'''

        self.name = name  # person에서 self가 된다. 
        self.weight = weight


    def __str__(self):
    	'''문자열화 함수'''
		return "{}(몸무게{}kg)".format(self.name,self.weight)
    
        
 	def eat(self):
        person.weight +=0.1
        print("{}가 먹어서 {}kg 이 되었습니다.".format(person.name, person.weight))

    def walk(self):
        person.weight -=0.1
        print("{}가 걸어서 {}kg 이 되었습니다.".format(person.name, person.weight))
 
 
person = Human("사람", 60.5)
print(person)

#output
사람(몸무게 60.5kg)
__str__함수에서 정의한 폼대로 출력이 됨.