구랩

웹에 있는 정보를 가져오는 것

!pip install requests, BeautifulSoup

from bs4 import BeautifulSoup
import requests

requests, BeautifulSoup 모듈을 이용

1. html 

- 웹사이트에 요청, html이라는 형식으로 유저에게 정보를 보내줌 파싱(해석),랜더링(가공)을 거처 우리 눈으로 보게됨 이것을 http프로토콜이라고함. 
- html

<학교 이름 = 'xx대학교'>
	<학과 value = '통계학과'>
		<학번 value = '16학번'>
			<학생 value = '201611460'> 이우현 </학생>
			<학생 value = '201611461'> 이지은 </학생>
			<학생 value = '201611463'> 이예지 </학생>
		</반>	
		<학번 value = '17학번'>
			<학생 value = '2010711562'> 황예지 </학생>	
		</반>
		<학번 value = '3반'> ...</반>
	</학과>

	<학과 value = '경영학과'> ....

이런 형식으로 구성됨 하위로 가지를 뻗는 형태 json형식과도 비슷함

이우현 학생에게 접근하려면 xx대학교의 통계학과 16학번인 201611460의 이우현학생 이렇게 접근할 수 있음

각각 부모 자식의 관계로 구성이 됨 

네이버 월요웹툰의 html구조를보면 

이런식으로 나옴 

크롬브라우저의 경우 f12를 누르면 우측에 저런식으로 창이 뜨는데 

그 창이 해당 브라우저의 html문서, 화살표를 누르면 자식태그를 볼 수 있게 확장됨

만약 백수세끼라는 제목에 대한 태그를 확인하고 싶다면

빨간펜으로 표시된 버튼을 누르고 백수세끼라는 제목으로 누르면 우측창에 해당하는 태그 경로를 알 수 있음

이런 경로를 xpath라고도 함

원하는 부분에 마우스 우클릭을하면 copy - > copy xpath를 클릭하면 해당 하는 부분의 xpath를 복사해준다

//*[@id="content"]/div[1]/ul/li[2]/dl/dt/a/strong 

이게 백수세끼의 xpath이다.

<strong title="백수세끼">백수세끼</strong>

이 구문을 보면 스트롱이라는 태그는 title이라는 속성을 가진다. title값은 '백수세끼'이다.

그리고 </strong>으로 strong이라는  태그의 정보를 종료하는데 주황값으로 표시한

부분에는 택스트가 들어간다. 보통 우리가 접근하는 값은 이 값이다.

이런 속성정보는 태그이름이 동일한경우 내가 원하는 태그에 접근하고 싶을 때 유용하게 사용된다.

td 태그가 많은데 제목에 접근하고 싶다면 td태그이면서 class가 title인 녀석에 접근하면 될  것이다.

2. requests

import requests

url = 'https://comic.naver.com/webtoon/list?titleId=733074&weekday=mon'
res = requests.get(url)
res.raise_for_status() # 오류가 생기면 셀종료
res.text

리퀘스트 패키지를 이용해서 이렇게 네이버 월요웹툰의 html을 가져올 수 있다.

requests의 get명령어를 사용하면 해당 url의 html을 가져올 수 있고

res.raise_for_status() 명령어로 성공적으로 페이지를 가져왔는지 확인할 수 있다. 

만약 제대로 가져오지못했다면 에러가 생겼을 것이다

text 명령어를 통해 html을 확인할 수 있다.

3. BeautifulSoup

html에서 검색의 역할을 해준다고 생각하면 편하다,

from bs4 import BeautifulSoup


url = 'https://comic.naver.com/webtoon/list?titleId=733074&weekday=mon'
res = requests.get(url)
res.raise_for_status() # 오류가 생기면 셀종료
soup = BeautifulSoup(res.text, 'lxml')
print(soup.find('td', attrs = {'class':'title'}))

print('-'*50)

print(soup.find_all('td', attrs = {'class':'title'}))

<td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=89&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','89')">89화 롤케이크</a>
<img alt="UP" height="15" src="https://ssl.pstatic.net/static/comic/images/2012/ico_toonup.png" width="27"/>
</td>
--------------------------------------------------
[<td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=89&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','89')">89화 롤케이크</a>
<img alt="UP" height="15" src="https://ssl.pstatic.net/static/comic/images/2012/ico_toonup.png" width="27"/>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=88&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','88')">88화 컵과일</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=87&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','87')">87화 짜장라면</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=86&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','86')">86화 찐만두</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=85&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','85')">85화 어묵</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=84&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','84')">84화 로제 떡볶이</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=83&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','83')">83화 하ㅇ정식</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=82&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','82')">82화 김치부침개</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=81&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','81')">81화 크로플</a>
</td>, <td class="title">
<a href="/webtoon/detail?titleId=733074&amp;no=80&amp;weekday=mon" onclick="nclk_v2(event,'lst.title','733074','80')">80화 주꾸미 볶음</a>
</td>]

requests 모듈로 가져온 html정보로부터 soup객체를 생성하고

find를 사용하면 td태그 중에서class가 title인 첫번째 태그를 가져온다

find_all을 사용하면 td태그 중에서class가 title인 태그들을 리스트형태로 가져온다.

만약 우리가 제목을 알고 싶다면.

titles = soup.find_all('td', attrs = {'class':'title'})

for title in titles:
    print(title.a.get_text())

89화 롤케이크
88화 컵과일
87화 짜장라면
86화 찐만두
85화 어묵
84화 로제 떡볶이
83화 하ㅇ정식
82화 김치부침개
81화 크로플
80화 주꾸미 볶음

titles에 td태그 중에서class가 title인 태그들을 저장하고 포문으로 각각 타이틀들의 a태그의 텍스트에 접근한다.

각각 회차의 링크를 가져오고 싶다면

for title in titles:
    print('https://comic.naver.com' + title.a['href'])

https://comic.naver.com/webtoon/detail?titleId=733074&no=89&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=88&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=87&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=86&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=85&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=84&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=83&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=82&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=81&weekday=mon
https://comic.naver.com/webtoon/detail?titleId=733074&no=80&weekday=mon

이렇게 된다.

하위 태그로 들어가고 싶다면 td.a 이렇게 .으로 이어서 접근하면되고 해당태그안의 속성에 관심이 있다면;

a['href']이렇게 접근하면 된다.

4. 최종실습

from bs4 import BeautifulSoup
import pandas as pd
df= pd.DataFrame()

url = 'https://comic.naver.com/webtoon/list?titleId=733074&weekday=mon'
res = requests.get(url)
res.raise_for_status() # 오류가 생기면 셀종료
soup = BeautifulSoup(res.text, 'lxml')

titles = soup.find_all('td', attrs = {'class':'title'})

for title in titles:
    name = title.a.get_text()
    link = 'https://comic.naver.com' + title.a['href']
    data = {'title':name, 'link':link}
    df = df.append(data, ignore_index=True)
    
display(df)

판다스에서 나타내는 과정에서짤려서 실제로 접근은안되지만 풀데이터프레임으로 접근시 가능

pandas

import pandas as pd

- 빅데이터 연산의 기초

- 데이터 구조를 정의

- numpy와 같은 타 모듈과의 전환이 용이

- pd라고 alias를 정의해 빠르게 사용 다른 alias를 지정해도 사용에는 무방하나 pd로 칭하는게 암묵적인 룰

시리즈란

- 파이썬기본 데이터유형인 딕셔너리와 유사한형태

- index : value 형태로 이루어진 데이터 

- 집계연산의 편의, 인덱싱의 편의

- 시리즈를 결합하면 데이터프레임이됨

- 데이터프레임에서 그룹 연산시 산출물이 시리즈로 제공되기 때문에 알고있어야 도움

생성

series1 = pd.Series({'국어':100, '수학':90, '영어':80})
series2 = pd.Series([100,20,45,90,100,87,45], index = ['k','e','a','b','f','c','d'])
series3 = pd.Series([100,20,45,90,100,87,45])
print(series1)
print('-'*30)
print(series2)
print('-'*30)
print(series3)

국어    100
수학     90
영어     80
dtype: int64
------------------------------
k    100
e     20
a     45
b     90
f    100
c     87
d     45
dtype: int64
------------------------------
0    100
1     20
2     45
3     90
4    100
5     87
6     45
dtype: int64

value와 인덱스를 지정하여 생성가능 인덱스를 지정하지 않을시 0에서 시작하는 정수로 순서대로 임의의 인덱스 부여

딕셔너리와 유사한 형태이기때문에 딕셔너리로 생성도 가능

인덱싱과 슬라이싱

두가지 방법으로 가능 해당하는 인덱스로 / 위치로

print(series2)
print('-'*30)

# 인덱스로 인덱싱 혹은 슬라이싱
print(series2['k'])
print('-'*30)
print(series2['k':'a'])
print('-'*30)

# 위치로 
print(series2.iloc[1])
print('-'*30)
print(series2.iloc[:1])

k    100
e     20
a     45
b     90
f    100
c     87
d     45
dtype: int64
------------------------------
100
------------------------------
k    100
e     20
a     45
dtype: int64
------------------------------
20
------------------------------
k    100
dtype: int64

인덱싱시 해당하는 인덱스에 속한 밸류를 반환한다.

슬라이싱시 해당하는 범위의 시리즈를 반환한다.

iloc을 이용할시 위치에 따라 인덱싱과 슬라이싱이 가능하다 1번째 값은(파이썬은 0부터시작) 20이기에 20을 반환

iloc[:1] 은 1번째 전까지의 녀석을 시리즈로 반환한다.

series2[['a','b','d']]

a    45
b    90
d    45
dtype: int64

이렇게 원하는녀석들만 볼 수도있다.

불리언 인덱싱

print((90>=series2) & (series2>50))
print('-'*30)
print(series2.loc[(90>=series2) & (series2>50)])

k    False
e    False
a    False
b     True
f    False
c     True
d    False
dtype: bool
------------------------------
b    90
c    87
dtype: int64

시리즈의 밸류에 관하여 불리언 연산이 가능하고 

그 불리언의 트루에 해당하는값만을 슬라이싱 가능하다.

print(series2.loc[(series2.index > 'b').tolist()])

k    100
e     20
f    100
c     87
d     45
dtype: int64

이런식으로 한다면 인덱스의 불리언 연산도 가능하다.

따로 기능이있는지는 잘모르겠다

시리즈 정렬

print(series2.sort_values())
print('-'*30)
print(series2.sort_values(ascending = False))

e     20
a     45
d     45
c     87
b     90
k    100
f    100
dtype: int64
------------------------------
k    100
f    100
b     90
c     87
a     45
d     45
e     20
dtype: int64

시리즈의 값을 기준으로 정렬을 할 수 있다. ascending을 False로 설정하면 내림차순으로 정렬된다.

print(series2.sort_index())
print('-'*30)
print(series2.sort_index(ascending = False))

a     45
b     90
c     87
d     45
e     20
f    100
k    100
dtype: int64
------------------------------
k    100
f    100
e     20
d     45
c     87
b     90
a     45
dtype: int64

인덱스를 기준으로도 거의 동일하게 정렬이 가능하다.

갯수세기

series2.value_counts()

100    2
45     2
20     1
90     1
87     1
dtype: int64

밸류의 갯수세기도 가능하다

인덱스는 보통 유일한 값을 가지기때문에 인덱스에 대한 물음은 가지지않았다.

간단한 연산

print(series2.mean())
print(series2.max())
print(series2.min())
print(series2.median())

69.57142857142857
100
20
87.0

딕셔너리

- 키 : 밸류 형태

- pandas와 큰 연관

- 머신러닝 파라미터적용시 많이 사용

- 리스트와 같이 가장많이 쓰이는 집합자료형

생성

dict1 = {'국어':100, '수학':90, '영어':80}
print(dict1)
dict1['국어'] = 95
dict1['통계'] = 100
print(dict1)
k = dict1.pop('통계')
print(dict1)
print(k) # 밸류가 나온다

{'국어': 100, '수학': 90, '영어': 80}
{'국어': 95, '수학': 90, '영어': 80, '통계': 100}
{'국어': 95, '수학': 90, '영어': 80}
100

인덱싱은 key를 이용해서 가능하고 새로운 key:value도 인덱싱을 사용하여 삽입가능하다.

pop 또한 key를 이용하고 뽑아낸 원소는 value가 반환된다.

슬라이싱은 불가능하다.

물론 문자:숫자가 아닌 다른 경우도 가능하다

keys , values, items

print(list(dict1.keys()))
print(list(dict1.values()))
print(list(dict1.items()))
print(list(dict1.items())[0])

['국어', '수학', '영어']
[95, 90, 80]
[('국어', 95), ('수학', 90), ('영어', 80)]
('국어', 95)

keys 는 key들을 반환한다.

values 는 value들을  반환한다.

items 는 key,value를 튜플로 묶은 쌍들을 반환한다.

for key, value in dict1.items():
    print('{}점수는 {}점 입니다'.format(key,value))

국어점수는 95점 입니다
수학점수는 90점 입니다
영어점수는 80점 입니다

이런 식으로 응용가능하다.

추후 게시할 pandas에 행을 추가할 때 주로 딕셔너리를 이용하기 때문에 잘 알아아 둘 필요가 있다.

in

print('국어' in dict1)
print('과학' in dict1)

True
False

get

print(dict1['과학'])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-32-1a2cdb189a8b> in <module>
----> 1 print(dict1['과학'])

KeyError: '과학'

일반 인덱싱을 이용하면 오류

print(dict1.get('과학'))
print(dict1.get('과학',0))

None
0

get을 이용하면 none 혹은 디폴트로 지정한 녀석을 반환한다.

이를 응용하면 카운트할 때 쉽다.

c_list = ['a','a','c','c','c','a','a','c','a','a','a','b','b','b','b']

count_dic = {}
for spel in c_list:
    count_dic[spel] = count_dic.get(spel, 0) + 1
print(count_dic)

{'a': 7, 'c': 4, 'b': 4}

물론 리스트의 count기능을 사용할 수 있지만 리스트의 길이 혹은 문자열의 길이가 셀수없이 길어진다면 모든 경우를 카운트하기에는 무리가 있다. 

셋

- 중복을 허용하지 않고 

- 인덱싱과 슬라이싱 불가능

- 집합연산 용이

생성

set1 = {'a','b','c','d','e'}
print(set1)

set2 = {'a','b','c','d','e','a','a','g','k'}
print(set2)

{'c', 'b', 'a', 'd', 'e'}
{'c', 'g', 'b', 'a', 'd', 'k', 'e'}

{} 로 생성한다. 셋을 생성하면 중복된 원소들은 제거된다.

인덱스 슬라이스 불가

set1[0]
set1[:2]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-c38563f1af7a> in <module>
----> 1 set1[0]

TypeError: 'set' object is not subscriptable

불가능하다.

집합연산

set1 = {'a','b','c','d','e'}
set2= {'c','d','e','f','g'}


print('set1',set1)
print('set2',set2)
print('교집합 ',set1&set2)
print('합집합 ',set1|set2)
print('차집합 ',set2-set1)
print('합집합 - 교집합 ',set1^set2)

{'c', 'b', 'a', 'd', 'e'}
{'c', 'g', 'd', 'f', 'e'}
set1 {'c', 'b', 'a', 'd', 'e'}
set2 {'c', 'g', 'd', 'f', 'e'}
교집합  {'c', 'e', 'd'}
합집합  {'c', 'g', 'b', 'a', 'd', 'f', 'e'}
차집합  {'g', 'f'}
합집합 - 교집합  {'g', 'f', 'b', 'a'}

보통 중복을 없애는데 사용한다

튜플

- 값의 수정이나 변경, 추가, 제거가 불가능하다. 변경 불가능한 리스트라고 이해

- 하지만 리스트에서 튜플 튜플에서 리스트로 변경은 가능

- 인덱싱 슬라이싱 리스트와 동일

- 모듈이나 기본함수의 출력값의 형식으로 많이 산출됨 

생성

tuple_ = ('a','b','c','d')
print(tuple_)

('a', 'b', 'c', 'd')

인덱싱, 슬라이싱

print(tuple_[2])
print(tuple_[-1])
print(tuple_[:2])
print(tuple_[::-1])

c
d
('a', 'b')
('d', 'c', 'b', 'a')

리스트와 동일하게 인덱싱 슬라이싱 가능하고 슬라이싱의 결과는 튜플 형태로 출력된다.

수정 및 추가

tuple_[0] = 'A'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-72-c25b0f105887> in <module>
----> 1 tuple_[0] = 'A'

TypeError: 'tuple' object does not support item assignment

수정 및 추가 삭제가 불가능하다.

리스트로의 변환을 활용한 추가, 제거

words = ['apple', 'banana', 'python', 'list', 'woo','woo','Java', 'won']

tuple_2 = tuple(words)
print(tuple_2, type(tuple_2), sep='  /  ')
tuple_2 = list(tuple_2)
print(tuple_2, type(tuple_2), sep='  /  ')
tuple_2.append('g')
tuple_2 = tuple(tuple_2)
print(tuple_2, type(tuple_2), sep='  /  ')

('apple', 'banana', 'python', 'list', 'hye', 'woo', 'Java', 'won')  /  <class 'tuple'>
['apple', 'banana', 'python', 'list', 'hye', 'woo', 'Java', 'won']  /  <class 'list'>
('apple', 'banana', 'python', 'list', 'hye', 'woo', 'Java', 'won', 'g')  /  <class 'tuple'>

변경을 원하는 경우에는 먼저 리스트로 형변환 이후에 변경하고 다시 튜플로 변환하면 가능하다 

index, count

words = ('apple', 'banana', 'python', 'list', 'woo','woo','Java', 'won')


print('apple' in words)
print('grape' in words)

print(words.index('apple'))
print(words.count('woo'))

True
False
0
2

함수의 결과

nums = [3,56,6,2]

def base_stat(list_):
    return max(list_),min(list_)

base_stat(nums)

(56, 2)

튜플의 변경이 불가능하다는 특성 때문인지 함수의 반환결과는 튜플로 반환되는 경우가 많습니다.

import pandas as pd
df = pd.read_csv('address.csv')
df.shape

(3042, 2)

리스트란

- 파이썬 기본 자료구조 형태중 하나

- 값을 나열한 것

- 시퀀스데이터 (자료의 순서가 있는 것)

- 자료의 변경, 삭제 , 추가가 자유로움.

리스트만들기

letters1 = ['a','b','c']
letters2 = ['d','e','f']

리스트명 = [ 원소1, 원소2, 원소3 , ... ]

위와 같이

리스트명 = [ 원소1, 원소2, 원소3 , ... ] 이런 형식으로 리스트를 생성할 수 있다.

내부원소의 자료형이 통일될 필요는 없다.

리스트 인덱싱

letters1 = ['a','b','c','d','e']
print(letters1[0])
print(letters1[1])
print(letters1[2])

letters1[0] = 3
print(letters1)

a
b
c

[3, 'b', 'c', 'd', 'e']

파이썬 리스트의 인덱스는 0부터  시작하며 첫 원소부터 차례대로 대응된다.

만약 print(letters1[3]) 

이와 같이 리스트에 없는 인덱스의 원소를 요청했다면 오류가 발생된다.

인덱싱을 활용하면 자료의 변경이 쉽게 가능하다.

리스트 슬라이싱

print(letters1[:3])  # 처음부터 3번 원소 전까지
print(letters1[2:])  # 2번 원소 전부터 끝까지
print(letters1[2:3]) # 2번 원소 전부터 3번원소 전까지
print(letters1[2:3][0]) # 원소에 직접접근하려면

print(letters1[::2]) # 처음부터 끝까지 2칸씩 띄워서 홀수 번째 친구들 
print(letters1[1::2]) # 1번원소 전부터 끝까지 2칸씩 띄워서 짝수 번째 친구들

['a', 'b', 'c']
['c', 'd', 'e']
['c']
c

['a', 'c', 'e']
['b', 'd']

리스트의 일부를 잘라 리스트로 반환한다. 

이때 중요한 점은 리스트로 반환한다는 점이다. 

3번째 경우 슬라이싱의 결과도 원소의 갯수가 1인 리스트로 반환이 되기 때문에 원소에 직접 접근하고 싶다면 

4번째줄의 코드와 같이 인덱싱을 진행해주어야한다.

다중리스트

리스트안에 리스트가 있는경우

letters1 = ['a','b','c','d','e']
letters2 = [letters1, 'f', 'g']
print(letters2)
print(letters2[0][2])

[['a', 'b', 'c', 'd', 'e'], 'f', 'g']
c

c에 접근하고싶다면 먼저 letters2의 첫번째 원소인 letters1에  접근하고 해당 리스트에서 인덱스로 접근한다.

리스트 함수 

1. len

print(len(letters1))
print(len(letters2))

5
3

리스트의 길이를 반환해준다. 

다중리스트의 경우 내부리스트가 얼마나 길든 1로 계산한다.

2. 리스트 이어붙이기

letters1 = ['a','b','c']
letters2 = ['d','e','f']

print(letters1 + letters2)

nums1 = [1,2,3]
nums2 = [4,5,6]
print(nums1 + nums2)

print(nums1 * 3)

['a', 'b', 'c', 'd', 'e', 'f']
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]

더하기 연산자로 이을 수 있다.

모든 원소가 숫자인 리스트도 각 인덱스에 대응하는 원소끼리의 연산이 아닌 두 리스트를 이은 리스트가 반환된다.

곱하기 연산자를 사용할 경우 곱하는 숫자만큼 리스트의 원소를 반복한 뒤 반환한다.

3. in

print('a' in letters1)
print('A' in letters1)
print('a' in letters2)

True
False
False

리스트에 해당하는 원소가 있으면 True 없으면 FALSE를 반환한다.

파이썬은 대소문자를 구분한다.

letters2에는 'a'가 있어보이지만 letters2에 있는 letters1에 a가 존재하는 것이다.

4. count

letters3 = ['a','a','b']
letters3.count('a')

2

리스트내의 일치하는 원소의 갯수를 세어준다

5. append

print(letters1)
letters1.append('f')
print(letters1)

['a', 'b', 'c']
['a', 'b', 'c', 'f']

리스트의 맨뒤에 새로운 원소를 삽입한다.

nums1 = [1,2,3]
nums2 = [4,5,6]
result = []

for i in range(len(nums1)):
    result.append(nums1[i]+nums2[i])
print(result)

[5, 7, 9]

이런식으로 빈리스트에 새로운 값들을 추가할 수도있다.

6. insert

맨뒤에 값을 추가하는 append와는 다르게 insert는 원하는 위치에 값을 삽입할 수 있다.

print(letters1)
letters1.insert(1,'A')
print(letters1)

['a', 'b', 'c', 'd', 'e']
['a', 'A', 'b', 'c', 'd', 'e']

7. pop 

print(letters1)
k = letters1.pop(1)
print(letters1)
print(k)

['a', 'A', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']
A

원하는 인덱스의 값을 빼내어 준다. 빼낸값을 저장할 수도 있다.

인덱스를 입력하지 않으면 제일 뒤의 값을 빼내어 준다.

이런식으로 값이 순환하게 할 수도 있다.

print(letters1)
k = letters1.pop(0)
letters1.append(k)
print(letters1)

['a', 'b', 'c', 'd', 'e']
['b', 'c', 'd', 'e', 'a']

8. remove

print(letters1)
letters1.remove('b')
print(letters1)

['a', 'b', 'c', 'd', 'e']
['a', 'c', 'd', 'e']

해당하는 원소를 삭제한다.

9. sort

nums = [5, 2, 22, 4, 5, 3, 7, 1]
words = ['apple', 'banana', 'python', 'list', 'woo','Java', 'won']

nums.sort()  #정수 정렬
words.sort()     #문자열 정렬

print(nums)
print(words)

nums.sort(reverse=True)  #정수 정렬
words.sort(reverse=True)     #문자열 정렬

print(nums)
print(words)

[1, 2, 3, 4, 5, 5, 7, 22]
['Java', 'apple', 'banana', 'list', 'python', 'won', 'woo']
[22, 7, 5, 5, 4, 3, 2, 1]
['woo', 'won', 'python', 'list', 'banana', 'apple', 'Java']

리스트 내의 원소들을 정렬하여 반환한다. 기본값은 오름차순이다.

10. reverse

words = ['apple', 'banana', 'python', 'list', 'woo','Java', 'won']
print(words)
words.reverse()
print(words)

['apple', 'banana', 'python', 'list', 'woo', 'Java', 'won']
['won', 'Java', 'woo', 'list', 'python', 'banana', 'apple']

리스트의 원소의 순서를 뒤집어 반환한다.

11. index

words = ['apple', 'banana', 'python', 'list', 'woo','woo','Java', 'won']
print(words.index('woo'))

words[words.index('woo')] = 'hye'
print(words)

4
['apple', 'banana', 'python', 'list', 'hye', 'woo', 'Java', 'won']

리스트안에 일치하는 원소의 첫번째 인덱스를 반환한다.

산출된 인덱스를 이용해서 원소를 변경도 가능하다.

리스트안에 일치하는 원소가 없다면 오류를 반환한다.