미정

1. count 함수

문자열 안에서 찾고 싶은 문자의 개수를 찾을 수 있다. 어떤 함수는 문자열에서만 사용 가능한 함수도 있는데 count 함수는 튜플, 리스트, 집합과 같은 반복 가능한 iterable 자료형에서도 사용 가능하다. 모든 자료형에서 사용 가능한 것은 아니어서 사용되지 않는 자료형은 아래에서 마저 설명하도록 하겠다.

사용방법은 '변수. count(찾는 요소)' 형태로 사용한다. 괄호( ) 안에 찾고자 하는 값을 입력하면 함수를 사용한 변수 안에서 해당 값의 개수를 숫자로 반환한다. 

2. 문자열 사용예시

'ooyyy'라는 아무 의미 없는 문자열을 예로 들어본다. 해당 문자열에서 y가 몇 개인지 를 count 함수를 사용하여 찾아보겠다. 

>>> 'ooyyy'.count('y')
3

문자열이 짧아서 육안으로도 금방 확인이 가능하다. y의 개수를 숫자인 3으로 반환하였다. 이런 짧은 문자열의 경우 함수를 굳이 사용하지 않겠지만 문자가 길어지거나 요소가 많은 iterable 자료형의 경우 유용하게 사용될 수 있다.

이번엔 임의의 변수에 문자열을 선언하여 사용해보겠다. 

'ox o x oxoxox'라는 의미 없는 문자의 나열을 b라는 변수에 선언해보았다. 사용방법은 위와 동일하다.

b.count( )로 사용하면 되고 괄호 안에 찾고자 하는 문자를 찾는다. 'ox'라는 'o'와 'x'가 붙은 문자열이 몇 개인지를 찾아본다.

>>> b = 'ox o x oxoxox'
>>> b.count('ox')
4

'o'와 'x'가 떨어져 있는 경우를 제외한 개수 4를 반환하였다.

3. 리스트 사용 예시

위에 문자열을 사용한 것과 동일한 패턴으로 사용해보았다. a라는 변수에 리스트를 선언하고서 count 함수를 사용해보고 변수로 선언하지 않은 리스트에서 곧바로 count 함수를 사용했다.

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

>>> ['ox', 'o', 'x', 'oxoxox'].count('ox')
1

4. 에러가 발생하는 자료형

dictionary, set 자료형에서는 count 함수를 사용할 수 없었다. 에러코드는 AttributeError가 발생했다.

그 밖에 bool타입을 변수에 저장한 경우에는 출력되었는데 tuple로 인식되었기 때문에 사용이 되었다.

bool이라는 변수에 쉼표를 이용해서 True, False의 불리언 값 세 개를 선언했더니 bool이라는 변수가 tuple 타입으로 저장되었다. 즉, count 함수를 사용할 수 있는 tuple 타입이었기에 사용된 것이다.

>>> bool = True, False, True
>>> bool.count(True)
2

>>> type(bool)
<class 'tuple'>

이번에는 리스트에 map을 사용해보겠습니다. map은 리스트의 요소를 지정된 함수로 처리해주는 함수입니다(map은 원본 리스트를 변경하지 않고 새 리스트를 생성합니다).

• list(map(함수, 리스트))
• tuple(map(함수, 튜플))

예를 들어 실수가 저장된 리스트가 있을 때 이 리스트의 모든 요소를 정수로 변환하려면 어떻게 해야 할까요? 먼저 for 반복문을 사용해서 변환해보겠습니다.

>>> a = [1.2, 2.5, 3.7, 4.6]
>>> for i in range(len(a)):
...     a[i] = int(a[i])
...
>>> a
[1, 2, 3, 4]

for에 range(len(a))를 사용해서 인덱스를 가져왔습니다. 그리고 가져온 인덱스로 요소 하나 하나에 접근한 뒤 int로 변환하여 다시 저장했습니다.

매번 for 반복문으로 반복하면서 요소를 변환하려니 조금 번거롭습니다. 이때는 map을 사용하면 편리합니다.

>>> a = [1.2, 2.5, 3.7, 4.6]
>>> a = list(map(int, a))
>>> a
[1, 2, 3, 4]

a = list(map(int, a)) 한 줄로 변환이 끝났습니다. map에 int와 리스트를 넣으면 리스트의 모든 요소를 int를 사용해서 변환합니다. 그다음에 list를 사용해서 map의 결과를 다시 리스트로 만들어줍니다.

▼ 그림 리스트에 map 함수 사용

사실 map에는 리스트뿐만 아니라 모든 반복 가능한 객체를 넣을 수 있습니다.

이번에는 range를 사용해서 숫자를 만든 뒤 숫자를 문자열로 변환해보겠습니다.

>>> a = list(map(str, range(10)))
>>> a
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

range로 0부터 9까지 숫자를 만들고, str을 이용해서 모두 문자열로 변환했습니다. 리스트를 출력해보면 각 요소가 ' '(작은따옴표)로 묶인 것을 볼 수 있습니다.

1.  input().split()과 map

input().split()의 결과가 문자열 리스트라서 map을 사용할 수 있었습니다.

다음과 같이 input().split()을 사용한 뒤에 변수 한 개에 저장해보면 리스트인지 확인할 수 있습니다.

>>> a = input().split()
10 20 (입력)
>>> a
['10', '20']

10 20을 입력하면 ['10', '20']처럼 문자열 두 개가 들어있는 리스트가 만들어집니다.

이제 map을 사용해서 정수로 변환해봅니다.

>>> a = map(int, input().split())
10 20 (입력)
>>> a
<map object at 0x03DFB0D0>
>>> list(a)
[10, 20]

다시 10 20을 입력하면 맵 객체(map object)가 만들어집니다. 이 상태로는 안에 들어있는 값을 볼 수 없으므로 list를 사용해서 리스트로 출력했습니다. 리스트를 보면 [10, 20]처럼 정수 두 개가 들어있습니다.

이 리스트 [10, 20]을 변수 두 개에 저장하면 지금까지 사용한 a, b = map(int, input().split())와 같은 동작이 됩니다.

>>> a, b = [10, 20]
>>> a
10
>>> b
20

사실 map이 반환하는 맵 객체는 이터레이터라서 변수 여러 개에 저장하는 언패킹(unpacking)이 가능합니다. 그래서 a, b = map(int, input().split())처럼 list를 생략한 것입니다

.

a, b = map(int, input().split())을 풀어서 쓰면 다음과 같은 코드가 됩니다.

x = input().split()    # input().split()의 결과는 문자열 리스트
m = map(int, x)        # 리스트의 요소를 int로 변환, 결과는 맵 객체
a, b = m               # 맵 객체는 변수 여러 개에 저장할 수 있음

파이썬 isdigit 설명

1-1) isdigit 설명

isdigit은 string 클래스에 있는 메서드 입니다.
즉 문자열.isdigit() 이런식으로 사용하는 메서드 입니다.

str.isdigit()

문자열이 '숫자'로만 이루어져있는지 확인하는 함수 입니다.

문자가 '단 하나'라도 있다면 False를 반환하고,
모든 문자가 '숫자'로만 이루어져있으면 True를 반환합니다.

사용법
1) str.isdigit("판단하고자 하는 문자열")
2) "판단하고자 하는 문자열".isdigit()

두가지 방법 다 사용이 가능합니다.

str.isdigit() 은 음수를 뜻하는 '-', 소수점을 뜻하는 '.' 이것들을 숫자가 아닌 문자로 판단을 하기 때문에
실수나 음수를 판단하지 못합니다.
즉, "-2".isdigit(), "1.234".isdigit() 둘다 False 가 나오게 됩니다.

정리하자면 "오직 0을 포함한 양수형 정수로만 이루어진 문자열"만 isdigit에서 True가 나올 수 있습니다.
추가적으로 지수를 뜻하는 n제곱 2³, 3², 4² 이것도 True가 올 수 있습니다.

1-2) 파이썬 isdigit 예제

a = "BlockDMask"  # 문자로만 이루어짐
b = "1234Blog"    # 문자 + 숫자
c = "131231"      # 숫자
d = "-234"        # 음수
e = "1.23"        # 소수점
f = "3²"          # 3의 2제곱 기호 숫자
g = "⅔"           # 수학 기호 숫자 2/3
h = "0"           # 0
i = "0123"        # 0 으로 시작한 숫자

# str.isdigit("문자열")
print(f"str.isdigit('{a}') : {str.isdigit(a)}")
print(f"str.isdigit('{b}') : {str.isdigit(b)}")
print(f"str.isdigit('{c}') : {str.isdigit(c)}")
print(f"str.isdigit('{d}') : {str.isdigit(d)}")
print(f"str.isdigit('{e}') : {str.isdigit(e)}")
print(f"str.isdigit('{f}') : {str.isdigit(f)}")
print(f"str.isdigit('{g}') : {str.isdigit(g)}")
print(f"str.isdigit('{h}') : {str.isdigit(h)}")
print(f"str.isdigit('{i}') : {str.isdigit(i)}")

print()

# "문자열".isdigit()
print(f"'{a}'.isdigit() : {a.isdigit()}")
print(f"'{b}'.isdigit() : {b.isdigit()}")
print(f"'{c}'.isdigit() : {c.isdigit()}")
print(f"'{d}'.isdigit() : {d.isdigit()}")
print(f"'{e}'.isdigit() : {e.isdigit()}")
print(f"'{f}'.isdigit() : {f.isdigit()}")
print(f"'{g}'.isdigit() : {g.isdigit()}")
print(f"'{h}'.isdigit() : {h.isdigit()}")
print(f"'{i}'.isdigit() : {i.isdigit()}")

결과에서 보시면 str.isdigit() 함수는
문자로만 이루어지거나, 문자가 하나라도 있는 경우는 False를 반환하는 것을 알 수 있습니다.
앞서 이야기 드렸듯 "-234" 음수나 "1.23" 과 같은 실수도 False로 반환 하는 것을 알 수 있습니다. -, . 을 문자로 인식했기 때문입니다.

오직 0을 포함한 양수로 이루어진 숫자와 지수만 True로 반환하는 것을 볼 수 있습니다.

<목차>
1. lambda 함수 설명
2. lambda 함수와 map
3. lambda 함수와 filter

1. 파이썬 람다 함수 설명

원래 함수라는게 복잡한 명령들을 편하게 반복해서 사용할 수 있도록 모아두는 역할을 하는데, def 를 이용해서 다른곳에 함수를 만들고 그걸 또 호출해서 부르기까지의 수고가 필요하지 않은 그런 "가벼운? 함수"들을 위해서 만들어진게 람다 함수 입니다.

> 람다함수 선언 방법

lambda 인자: 표현식

lambda 라는 키워드를 입력하고 뒤에는 매개변수(인자)를 입력하고 콜론(:)을 넣은다음에 그 매개변수(인자)를 이용한 동작들을 적으면 됩니다.
예를 들면 인자로 들어온 값에 2를 곱해서 반환한다고 하면 lambda x : x * 2 이런식으로 됩니다.
어떤가요? 간단하죠?

> 이해를 돕기위한 람다함수와 일반함수 비교

위에서 설명했듯이 람다함수는 일반함수를 가볍게 만든 함수이기 때문에
짝수를 판별하는 함수를 만든다고 했을때 일반함수는
def is_even(x):
return x % 2 == 0
이런식으로 표현을 할 수 있습니다.
이걸 람다로 표현하게 되면
is_even = lambda x : x % 2 == 0
이런식으로 표현할수 있습니다.
물론 일반함수, 람다함수 둘다 사용법은 같습니다.
이런식으로 호출을 하겠죠?
is_even(1) # False
is_even(2) # True

2. 파이썬 lambda 함수와 map

이미 아시는 분들은 아시겠지만
map함수는 리스트나 튜플에 어떤 특별한 처리를 할때 사용하는 함수입니다.

> map 함수의 모양과 사용법

map(함수, 리스트나 튜플)

첫번째 인자인 함수는 두번째 인자로 들어온 리스트나, 튜플에 특별한 가공 처리를 하는 함수이며, 사용자가 직접 함수를 정의해서 넣습니다.
두번째 인자인 리스트나 튜플은 바꾸고자 하는 데이터들을 집어 넣습니다.


예를들어 리스트의 모든값에 2씩 더해서 새로운 리스트를 만든다고 할때 map 함수는 아래와 같이 사용할 수 있습니다.
map 의 반환값을 리스트로 다시 변경할수 있는데요 이때는 list(map(~~~)) 이런식으로 list 로 형변환해주는 함수로 감싸주면 됩니다.

# 1. 일반 함수 버전
def plus_two(x):
    return x + 2

result1 = list(map(plus_two, [1, 2, 3, 4, 5]))
print(result1)


# 2.  람다 함수 버전
result2 = list(map((lambda x: x + 2), [1, 2, 3, 4, 5]))
print(result2)

> 결과

이런식으로 def를 통해서 함수를 map의 인자로 전달해줘도 되지만,
map을 통해서 "리스트를 가공하는게 이번 한번 뿐이다" 라는 상황이라던지 lambda를 사용해서 간단하게 작업이 가능한 경우라면
람다 함수 사용을 고려해보는 것도 좋을듯 합니다.
여기서 이제 range와 결합하면
result3 = list(map((lambda x : x + 2), range(2, 6)) 이런식으로도 쓸 수 있습니다.

이렇게 람다 함수는 map 함수와 같이 사용자 정의 함수를 받을때 유용하게 작성할 수 있습니다.
아래 또다른 예제를 한번 볼까요?

3. python 람다 함수와 filter

filter 함수는 map 함수와 비슷하게 리스트나 튜플을 두번째인자로 받고 첫번쨰 인자로 함수를 받습니다.

> filter 함수 모양과 설명

filter(함수, 리스트나 튜플)

첫번째 인자에는 두번째 인자로 들어온 리스트나 튜플을 하나하나씩 받아서 필터링할 함수를 넣습니다.
두번쨰 인자에는 리스트나 튜플을 집어 넣습니다.
예를들어 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 까지의 리스트가 있을때 짝수들만 filter 함수를 이용해서 리스트를 다시 만든다고 했을때, filter 함수와 람다를 이용할 수 있습니다.

# 1. 일반 함수 버전
def is_even(x):
    return x % 2 == 0


result1 = list(filter(is_even, range(10)))  # [0 ~ 9]
print(result1)


# 2.  람다 함수 버전
result2 = list(filter((lambda x: x % 2 == 0), range(10)))  # [0 ~ 9]
print(result2)

> 결과

이때 첫번째 인자인 함수를 일반함수와 lambda 함수로 나눠서 예시를 들어보았는데요.
결과 화면을 보앗듯 filter 함수의 첫번째 인자가 True 인 경우의 값만 가지고와서 리스트를 만들었습니다.
filter 함수와 람다 함수를 결합하여 깔끔하게 filter가 가능합니다.

정리

lambda (익명함수)

람다함수의 장점: 코드의 간결함, 메모리 절약

사용 방법 -     lambda 인자 : 표현식

# 예시

def plus(x, y):
	return x + y
    
plus(1, 2)  # 값: 3

# 위의 함수를 람다로 표현한다면?
(lambda x,y: x + y)(1,2)  #값: 3

1. map 함수 설명과 사용법

1-1) 파이썬 맵 함수 기본 설명 

map 함수의 모양

>> map(function, iterable)

첫 번째 매개변수로는 함수, 두 번째 매개변수로는 반복 가능한 자료형(리스트, 튜플 등)

map 함수의 반환 값은 map객체 이기 때문에 해당 자료형을 list 혹은 tuple로 형 변환시켜주어야 합니다.

함수의 동작은 두 번째 인자로 들어온 반복 가능한 자료형 (리스트나 튜플)을 첫 번째 인자로 들어온 함수에 하나씩 집어넣어서 함수를 수행하는 함수입니다.

>> map(적용시킬 함수, 적용할 값들) 이런 식

예를 들어 첫 번째 인자가 값에 +1을 더해주는 함수라고 하고 두번째 인자에 [1, 2, 3, 4, 5] 라는 리스트를 집어넣으면

함수의 모양은 map( 값에 +1 을 더해주는 함수, [1,2,3,4,5]) 
함수의 반환을 list(. )로 감싸주면
[2,3,4,5,6] 이 되는 함수입니다.

1-2) map 함수를 사용하는 것과 아닌 것의 차이

똑같은 작업을 map을 이용했을 때와 그렇지 않을 때를 비교해보겠습니다.

# 리스트에 값을 하나씩 더해서 새로운 리스트를 만드는 작업
myList = [1, 2, 3, 4, 5]

# for 반복문 이용
result1 = []
for val in myList:
    result1.append(val + 1)

print(f'result1 : {result1}')


# map 함수 이용
def add_one(n):
    return n + 1


result2 = list(map(add_one, myList))  # map반환을 list 로 변환
print(f'result2 : {result2}')

이런 식으로 만약에 map 함수를 이용하지 않으면
for 반복문 같은걸 이용해서 일일이 하나하나 리스트 요소에 접근해서 계산을 해서 리스트에 하나씩 또 append 해주어야 하는 번거로움이 있습니다.
하. 지. 만. map 함수를 이용하면 우리는 요소에 적용할 함수 하나만 딱 넘겨준다면
알아서, 자동적으로 리스트를 함수에 적용해서 map 객체를 반환해 줍니다. 우리는 그걸 list로 형 변환해서 사용하면 됩니다.

2. map 함수 예제

2-1) 리스트와 map 함수

import math  # math.ceil 함수 사용

# 예제1) 리스트의 값을 정수 타입으로 변환
result1 = list(map(int, [1.1, 2.2, 3.3, 4.4, 5.5]))
print(f'map(int, 리스트) : {result1}')


# 예제2) 리스트 값 제곱
def func_pow(x):
    return pow(x, 5)  # x 의 5 제곱을 반환


result2 = list(map(func_pow, [1, 2, 3, 4, 5]))
print(f'map(func_pow, 리스트) : {result2}')


# 예제3) 리스트 값 소수점 올림
result3 = list(map(math.ceil, [1.1, 2.2, 3.3, 4.4, 5.5, 6.6]))
print(f'map(func_ceil, 리스트) : {result3}')

예제 1번)
데이터 타입을 변환하는 함수를 바로 넣어 줄 수 있습니다.
첫 번째 인자로 들어간 함수가 int (x)이고 들어간 x의 데이터 타입을 int로 변경해주는 것이기 때문에 실수인 1.1, 2.2 등의 값이 들어가서 정수 타입으로 나오는 것을 알 수 있습니다.

예제 2번)
값의 n 제곱을 구할 수 있는 함수 pow를 이용해서 들어온 리스트의 값을 5 제곱하도록 만들어 주었습니다.

예제 3번)
math.ceil(x) 함수를 바로 직접 넣어줌으로써 리스트의 값을 소수점 올림 처리를 해보았습니다.
이처럼 인자가 1개인 함수는 직접 넣어줄 수 도 있습니다.

2-2) 람다와 map 함수

map의 첫 번째 인자로 함수가 들어간다면
이름 없는 함수 즉, 람다 함수도 가능하다는 뜻 아니겠습니까?
만약에 map의 인자로 사용할 함수가 일회성이거나 매우 짧은 경우에는 람다 함수를 사용해서 넘기는 게 좀 더 효율적 일 것입니다.

# map 과 lambda

# 일반 함수 이용
def func_mul(x):
    return x * 2


result1 = list(map(func_mul, [5, 4, 3, 2, 1]))
print(f"map(일반함수, 리스트) : {result1}")

# 람다 함수 이용
result2 = list(map(lambda x: x * 2, [5, 4, 3, 2, 1]))
print(f"map(람다함수, 리스트) : {result2}")

이런 식으로 map 함수와 def를 이용해서 리스트의 값을 변화시킬 수도 있지만
간단+일회성 작업이라면 굳이 def를 이용할 필요 없이 map 함수와 lambda를 이용하면 좀 더 유용하게 작업을 할 수 있습니다.

a1 = [6, 3, 9] 
print('a1:', a1) 
a2 = a1.sort() # 원본을 정렬하고 수정합니다(in-place) 
print('-----정렬 후-----') 
print('a1:', a1) 
print('a2:', a2)

출력

b1 = [6, 3, 9] 
print('b1:', b1) 
b2 = sorted(b1) # 원본은 유지하고 정렬한 새 리스트를 만듭니다 
print('-----정렬 후-----') 
print('b1:', b1) 
print('b2:', b2)

# 예시 1
sorted("This is a test string from Andrew".split(), key=str.lower) # 대소 문자를 구분하지 않는 문자열 비교

# 값: ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
# 예시2
student_tuples =[
	('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
]

sorted(student_tuples, key=lambda student: student[2])  # 나이로 정렬

# 값: ('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

<목차>
1. for 반복문을 이용한 평균 구하기
2. sum 함수를 이용한 평균 구하기
3. numpy 모듈을 이용해서 평균 구하기
4. statiscics 라이브러리 이용해서 평균 구하기

1. 파이썬 평균 구하기 for 반복문

숫자들을 하나하나 읽어서 더하고
더한 결과를 숫자들의 갯수 만큼 나눠주는
전형적인 방법 입니다.

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

result = 0
for val in arr:
    result += val  # 하나하나 더하기

# 평균 구하기
print(f"average : {result / len(arr)}")

이렇게 arr 리스트에 있는 값들을 하나하나 for 반복문을 통해서 돌면서 값들을 더합니다.
이렇게 더한 값들을 arr 리스트 값들의 총 갯수로 나누어 주면 평균을 구할 수 있습니다.

2. 파이썬 sum 을 이용한 평균 구하기

우리에게는 리스트의 합을 한번에 계산할 수 있는 sum 함수가 있습니다.
sum ([리스트]) 이렇게 함수를 작성하면 해당 리스트에 있는 숫자들의 합을 한번에 구해줄 수 있습니다.

그러니까, 1번 방법 처럼 for 문으로 번거롭게 더하지말고 한번에 sum 함수를 이용해서 리스트의 합을 구하면 됩니다.

바로 코드로 넘어가겠습니다.

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

# 합계 구하기
result = sum(arr)

# 평균 구하기
print(f"average : {result / len(arr)}")

for 문으로 3줄 작성하던게 한줄 sum(arr)로 끝나게되었습니다. 간편하지 않나요?
그래도 아직 합을 구한다음에 len(arr)을 이용해서 리스트의 총 갯수를 나눠야 하는 부분이 남아있습니다.

sum 함수에 대해서 더 궁금하시다면 [바로가기] 포스팅을 가시면 확인 가능합니다.

3. 파이썬 numpy 모듈로 평균 구하기

숫자를 다루는 모듈중에서 유명한 모듈인 numpy 라는 모듈이 있습니다.
해당 모듈에서 평균을 구하는 mean 함수를 제공해 주고 있습니다.
이 함수는 2번 방법인 sum 을 구해서 len(리스트) 해서 리스트의 숫자로 나누는 그런 작업도 필요없이
numpy.mean(리스트) 이렇게 하면 바로 평균이 나와버립니다. 정말 간편하죠?

pip install numpy 
명령어를 이용해서 numpy 를 설치합니다.

설치를 완료했으면 numpy 를 import 해서 mean 함수를 사용하면 됩니다.

import numpy

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

# 평균 구하기
average = numpy.mean(arr)

# 출력
print(f"average : {average}")

이렇게 간단하게 numpy 의 mean 함수를 이용해서 평균을 구할 수 있습니다.

4. 파이썬 평균 구하기 statiscics 라이브러리 이용

마지막으로는 파이썬에서 제공해주는 statiscics 라이브러리를 이용할 수 있습니다.
이 statistics 라이브러리는 파이썬 3.4 버전 부터 사용할 수 있습니다.
이 라이브러리를 자세히 보고싶다면 파이썬 문서 [바로가기] 에서 확인할 수 있습니다.

statistics 라이브러리는 여러 수학 관련 함수를 제공해주는데
우리가 사용할 평균을 구하는 함수는 mean 이라는 함수 입니다.

파이썬에서 제공해주는것이기 때문에 따로 pip install 할 필요 없이 바로 import 하면 됩니다.

import statistics

arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
arr2 = [100, 90, 80, 10, 20, 30, 60, 70, 50, 40]

# 평균 구하기
result1 = statistics.mean(arr1)
result2 = statistics.mean(arr2)

# 출력
print(f"average1 : {result1}")
print(f"average2 : {result2}")

statistics.mean ( 리스트) 를 이용해서 쉽게 평균을 구할 수 있습니다.

1. sort 함수

리스트 정렬 함수

1-1) sort 함수 기본

List.sort()

• list.sort() 메서드는 list 객체 자체를 정렬해주는 함수이다.
• 리스트에만 사용 가능 
• list 객체의 멤버 함수, 즉 메서드
• list.sort() 함수는 기본적으로 리스트를 오름차순으로 정렬해주는 기능

** 추가 설명
새로운 정렬된 리스트를 반환하는 함수는 sorted 함수이고, 
리스트 자체를 정렬시켜버리는 것은 sort 함수

1-2) sort 함수 예제

list_num = [33, 2, 81, -77, 44, 1, 10, 99, 5, 0, -2]
list_str1 = ['b', 'l', 'o', 'c', 'k', 'd', 'm', 'a', 's', 'k']
list_str2 = ['B', 'l', 'o', 'c', 'k', 'D', 'M', 'a', 's', 'k']

# 숫자 리스트 정렬
print("1. 숫자 리스트 정렬")
list_num.sort()
print(list_num)

# 문자열 리스트 정렬1 (소문자만)
print("\n2. 소문자 문자열 리스트 정렬")
list_str1.sort()
print(list_str1)

# 문자열 리스트 정렬2 (대/소문자 포함)
print("\n3. 대소문자 문자열 리스트 정렬")
list_str2.sort()
print(list_str2)

• 숫자리스트.sort() 의 결과
  숫자리스트를 보면 음수, 0, 양수 이렇게 작은 수부터 큰 수로 오름차순으로 정렬해주는 것을 볼 수 있다.

• 소문자문자리스트.sort() 의 결과
  우리가 알고 있는 알파벳순 a, b, c, d, e 순서로 잘 정렬되는 것을 볼 수 있다.

• 대소문자문자리스트.sort() 결과
  대소문자 리스트.sort()는 대문자 ABCD 순으로 다 나온 후에, 소문자 abcd 순으로 정렬이 되는 것을 볼 수 있다.
  이는, 문자 자체를 아스키코드 값에 대응해서 숫자로 판단하기 때문이다.
  아스키코드표에 보면 대문자 A는 65번에 해당하고 소문자 a는 97번에 해당된다.
  (구글에 '아스키코드표'라고 검색하면 표가 나옴)
  즉, A~Z는 65~90 대역대에 존재하고 소문자 a~z는 97~122에 존재하게 된다.
  여기서 문자의 sort() 기준은 아스키코드표에 각 문자에 대응하는 숫자에 따라 판단을 하기 때문에 65~90에 있는 대문자들을 쫘르륵 정렬한 후에, 97~122번에 있는 소문자가 오게된다.

2. 파이썬 오름차순, 내림차순 정렬

리스트.sort() 함수에는 reverse 옵션(매개변수)이 존재한다.
디폴트는 리스트.sort(reverse=False) 인 게 디폴트여서 리스트가 오름차순으로 정렬이 되는 것이고
리스트.sort(reverse=True)로 변경하면 리스트가 내림차순으로 정렬이 된다.

a = [3, 2, 8, 4, 1, 10, 99, 5]
b = [3, 2, 8, 4, 1, 10, 99, 5]
c = [3, 2, 8, 4, 1, 10, 99, 5]

# 기본값 (오름차순)
a.sort()
print("a.sort()")
print(a)

# 오름차순
b.sort(reverse=False)
print("\nb.sort(reverse=False)")
print(b)

# 내림차순
c.sort(reverse=True)
print("\nc.sort(reverse=True)")
print(c)

위처럼 세 가지 동일한 리스트가 있다고 할 때,
sort(), sort(reverse=False), sort(reverse=True)로 정렬을 해보면

결괏값을 보다시피
sort(), sort(reverse=False)가 오름차순으로 정렬되고
sort(reverse=True)가 리스트를 내림차순으로 정렬하는 것을 볼 수 있다.