[데이터분석]파이썬 스터디노트12

선형검색: 선형으로 나열되어 있는 데이터를 순차적으로 스캔하면서 원하는 값 획득

datas = [3, 2, 5, 7, 9, 1, 0, 8, 6, 4]
print(f'datas: {datas}')
print(f'datas length: {len(datas)}')

searchData = int(input('찾으려는 숫자 입력: '))
searchResultIdx = -1

n = 0
while True:
    if n == len(datas):
        searchResultIdx = -1
        break

    elif datas[n] == searchData:
        searchResultIdx = n
        break

    n += 1

print(f'searchResultIdx:{searchResultIdx}')

보초법: 마지막 인덱스에 찾으려는 값을 추가해서 찾는 과정 간략화
검색 성공: 마지막 이전에 검색된 경우
검색 실패: 마지막에 검색된 경우

datas = [3, 2, 5, 7, 9, 1, 0, 8, 6, 4]
print(f'datas: {datas}')
print(f'datas length: {len(datas)}')

searchData = int(input('찾으려는 숫자 입력: '))
searchResultIdx = -1

datas.append(searchData)

n = 0
while True:

    if datas[n] == searchData:
        if n != len(datas) -1:
            searchResultIdx = n
        break

    n += 1

print(f'searchResultIdx:{searchResultIdx}')

이진검색: 정렬되어 있는 자료구조에서 중앙값과의 크고 작음을 이용해서 데이터 검색
(주의: 데이터가 정렬되어 있어야 함)

nums = [4, 10, 22, 5, 0, 17, 7, 11, 9, 61, 88)

nums.sort()

searchData = int(input('찾으려는 숫자 입력: '))
searchResultIdx = -1

staIdx = 0
endIdx = len(datas) - 1
midIdx = staIdx + endIdx // 2
midVal = nums[midIdx]

while searchData <= datas[len(datas)-1] and searchData >= datas[0]:
    if searchData == datas[len(datas)-1]:
        searchResultIdx = len(datas) -1
        break

    if searchData > midVal:
            staIdx = midIdx
            midIdx = (staIdx + endIdx) // 2
            midVal = datas[midIdx]

    elif searchData < midVal:
            endIdx = midIdx
            midIdx = (staIdx + endIdx) // 2
            midVal = datas[midIdx]

    elif searchData == midVal:
        searchResultIdx = midIdx
        break

print(f'searchResultIdx ={searchResultIdx}')

순위(순서)

import random

nums = random.sample(range(50, 101), 20)
ranks = [0 for i in range(20)] #길이가 20, 아이템 값 0인 list 출력

for idx, num1 in enumerate(nums):
    for num2 in nums:
        if num1 < num2:
            ranks[idx] += 1  #num1과 같은 위치의 ranks 값에 +1

print(f'nums: {nums}')
print(f'ranks: {ranks}')

for idx, num in enumerate(nums):
    print(f'num: {num} \t rank: {ranks[idx] + 1}')

버블정렬: 처음부터 끝까지 인접하는 인덱스의 값을 순차적으로 비교하면서 큰 숫자를 가장 끝으로 옮기는 알고리즘

length = len(nums) - 1
for i in range(length):
    for j in range(length -i):
        if nums[j] > nums[j+1]:
            temp = nums[j]
            nums[j] = nums[j+1]
            nums[j+1] = temp
자리 바꾸는 코드 더 간단히 표현 
nums[j], nums[j+1] = nums[j+1],nums[j]

🔔버블정렬(실습) – 깊은복사와 얕은복사

<모듈>

import copy

def bubbleSort(ns, deepcopy=True):

    if deepcopy:
        cns = copy.copy(ns)  #깊은 복사(데이터 자체 복사)

    else: cns = ns    #얕은 복사
    length = len(cns) -1
    for i in range(length):
        for j in range(length - i):
            if cns[j] > cns[j+1]:
                cns[j], cns[j+1] = cns[j+1],cns[j]

    return cns

<실행파일>

import random as rd

import sortMod as sm
students = []

for i in range(20):
    students.append(rd.randint(170,185))

print(f'students: {students}')

sortedStudents = sm.bubbleSort(students) 

print(f'students: {students}')
print(f'sortedStudents: {sortedStudents}')

💥기본값: deepcopy = true, 원본 데이터 유지하고 새로운 복사본 데이터로 정렬

sortedStudents = sm.bubbleSort(students,deepcopy=False)
->얕은 복사, 원본데이터로 지지고 볶고 ..

삽입정렬: 정렬되어 있는 자료 배열과 비교해서, 자신의 정렬위치를 찾음

nums = [5,10,2,1,0]

for i1 in range(1, len(nums)):  #10부터 시작해서 앞 숫자와 비교
    i2 = i1 - 1
    cNum = nums[i1]

    while nums[i2] > cNum and i2 >= 0:
        nums[i2 + 1] = nums[i2] # 앞 값이 뒤로 밀려남

        i2 -= 1

    nums[i2 +1] = cNum

    print(f'nums: {nums}')

🔔 실습) 1부터 1000까지의 난수 100개 생성하고, 다음의 요구사항을 만족하는 모듈 생성
요구사항1) 생성된 난수들을 오름차순, 내림차순으로 정렬하는 알고리즘 구현
요구사항2) 생성된 난수 중 최솟값, 최댓값 반환하는 함수 구현

class SortNumbers:

    def __init__(self, ns, asc=True):
        self.nums = ns
        self.isAsc = asc

    def isAscending(self, flag):
        self.isAsc = flag

    def setSort(self):
        for i1 in range(1, len(self.nums)):
            i2 = i1 - 1
            cNum = self.nums[i1]

            if self.isAsc:
                while self.nums[i2] > cNum and i2>=0:
                    self.nums[i2 + 1] = self.nums[i2]
                    i2 -= 1

            else:
                while self.nums[i2] < cNum and i2>=0:
                    self.nums[i2 + 1] = self.nums[i2]
                    i2 -= 1

            self.nums[i2 + 1] = cNum

    def getSortedNumbers(self):
        return self.nums

    def getMinNumber(self):
        if self.isAsc:
            return self.nums[0]

        else:
            return self.nums[len(self.nums) - 1]

    def getMaxNumber(self):
        if self.isAsc:
            return self.nums[len(self.nums) - 1]

        else:
            return self.nums[0]

<실행파일>

import random
import list as sm
nums = random.sample(range(1, 1000), 100)
print(f'not sorted numbers: {nums}')

#객체생성
sn = sm.SortNumbers(nums)

#오름차순(ascending)
sn.setSort()
sortedNumbers = sn.getSortedNumbers()
print(f'sortedNumbers: {sortedNumbers}')

#내림차순(descending)
sn.isAscending(False)
sn.setSort()
sortedNumbers = sn.getSortedNumbers()
print(f'sortedNumbers: {sortedNumbers}')

#min & max
print(f'min: {sn.getMinNumber()}')
print(f'min: {sn.getMaxNumber()}')

선택정렬: 주어진 리스트 중 최소값을 찾아, 그 값을 맨 앞에 위치한 값과 교체하는 방식으로 자료 정렬

nums = [4, 2, 5, 1, 3]

for i in range(len(nums)-1):  #기준이 되는 값 / 0~3까지
    minIdx = i

    for j in range(i+1, len(nums)):
        if nums[minIdx] > nums[j]:
            minIdx = j

    nums[i], nums[minIdx] = nums[minIdx], nums[i]