실제 개발을 진행한다면 앞선 방식보다는 정형화된 방법으로 데이터를 저장하고 다루는것이 공동개발과 유지보수에도 좋을 겁니다. 그렇다면 아키텍쳐 디자인 패턴인 MVVM 패턴에 대해 공부해보겠습니다.

MVVM 패턴이란?

마이크로소프트에서는 MVVM 패턴에 대해 다음과 같이 정의하고 있습니다.

MVVM(Model-View-ViewModel)은 UI 및 비 UI 코드를 분리하기 위한 UI 아키텍처 디자인 패턴입니다. MVVM을 사용하여 UI를 XAML로 선언적으로 정의하고 데이터 바인딩 태그를 사용하여 데이터 및 명령을 포함하는 다른 계층에 연결합니다. 데이터 바인딩 인프라는 UI 및 연결된 데이터를 동기화된 상태로 유지하고, 사용자 입력을 적절한 명령으로 라우팅하는 느슨한 결합을 제공합니다.

느슨한 결합을 제공하기 때문에, 데이터 바인딩을 사용하면 서로 다른 종류의 코드 간에 하드 종속성이 줄어듭니다. 이렇게 하면 다른 단원에서 의도치 않은 부작용을 발생시키지 않고도 개별 코드 단위(메서드, 클래스, 컨트롤 등)를 보다 쉽게 변경할 수 있습니다. 이러한 분리는 여러 디자인 패턴에서 중요한 개념인 문제의 분리 예입니다.

즉,

1) UI와 UI가 아닌 코드를 분리하여 정의한다.

2) 데이터 바인딩 태그를 사용하여 다른 계층에 연결하고 UI 및 연결된 데이터를 동기화된 상태로 유지한다.

3) 느슨한 결합을 제공하여 하드 종속성이 줄어 의도치 않은 부작용을 발생시키지 않고 개별 코드 단위를 보다 쉽게 변경할 수 있다.

MVVM 패턴의 구조

• 모델 (Model)

  데이터를 나타내는 형식을 정의한다.

• 뷰 (View)

  사용자에게 보여지는 역할, 유저의 입력을 받아 뷰 모델(View Model)에게 명령을 내립니다.

  뷰는 재사용성이 강조되며 중복되는 코드를 줄이는 것이 중요하다.

• 뷰 모델 (View Model)

  핵심적인 비즈니스 로직을 담고 있는 계층입니다.

  뷰(View)와 데이터 바인딩을 하여 연결 후, 뷰(View)에게서 액션을 받고 또한 뷰(View)를 업데이트합니다.

MVVM 패턴의 장점

그렇다면 MVVM 패턴을 사용하는 이유는 무엇일까?

• 뷰(View)와 모델(Model)이 서로 전혀 알지 못하기에 독립성을 유지할 수 있습니다.
• 독립성을 유지하기 때문에 효율적인 유닛테스트가 가능합니다.
• 뷰(View)와 뷰 모델(View Model)을 바인딩하기 때문에 코드의 양이 줄어듭니다.

MVVM 패턴 예제

다음 동영상을 참고하여 SwiftUI에서 MVVM 패턴을 사용해보겠습니다.

- 파일 생성

기본적으로 생성되는 뷰(ContentView) 파일과 함께 추가로 모델(Person), 뷰 모델(PersonViewModel) 파일을 생성해줍니다.

// Person
import SwiftUI

struct Person: Identifiable {
    var id = UUID()
    var name: String
    var email: String
    var phoneNumber: String
}

// ContentView
import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello World")
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

// PersonViewModel
import SwiftUI

class PersonViewModel: ObservableObject {
    @Published var people: [Person] = []
}

뷰 모델에는 ObservableObject 프로토콜을 부여하여 후에 뷰가 뷰 모델의 변경사항을 감시할 수 있게 됩니다.

추가로 @Published로 표시된 속성이 있는 오브젝트가 변경될 때마다 해당 오브젝트를 사용하는 모든 뷰가 다시 로드되어 해당 변경 사항을 반영합니다.

- 뷰 모델에 기능과 데이터를 추가합니다.

다음 포스팅에는 Firebase로부터 가져온 데이터를 저장하고 활용하겠지만 지금은 데이터를 임의로 추가해줍니다.

// PersonViewModel

import SwiftUI

class PersonViewModel: ObservableObject {
    @Published var people: [Person] = []

    init() {
        addPeople()
    }

    func addPeople() {
        people = peopleData
    }

    func shuffleOrder() {
        people.shuffle()
    }

    func reverseOrder() {
        people.reverse()
    }

    func removeLastPerson() {
        people.removeLast()
    }
}

let peopleData = [
    Person(name: "Paul Atreides", email: "Paul@naver.com", phoneNumber: "111-1111"),
    Person(name: "Lady Jessica", email: "Jessica@naver.com", phoneNumber: "222-2222"),
    Person(name: "Duke Atreides", email: "Leto@naver.com", phoneNumber: "333-3333"),
    Person(name: "Baron Harkonnen", email: "Harkonnen@naver.com", phoneNumber: "444-4444"),
    Person(name: "Duncan Idaho", email: "Duncan@naver.com", phoneNumber: "555-5555")
]

데이터를 생성해주고 init()을 사용하여 최초 실행 시 people변수에 데이터를 추가해 줍니다.

- 데이터 바인딩

// ContentView
import SwiftUI

struct ContentView: View {
    @ObservedObject var viewModel = PersonViewModel()

    var body: some View {
        VStack(alignment: .leading) {
            ForEach(viewModel.people) { person in
                HStack {
                    Text(person.name)
                        .font(.title)
                    Text(person.email)
                }
            }
            Button {
                viewModel.reverseOrder()
            } label: {
                Text("Reverse")
            }
            Button {
                viewModel.removeLastPerson()
            } label: {
                Text("RemoveLast")
            }
        }
        .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

@ObservedObject는 관찰중인 객체의 변경에 반응해서 화면을 업데이트할 수 있게 해주는 프로퍼티 래퍼입니다. ObservableObject속성을 사용하는 PersonViewModel의 변경사항을 감시하게 됩니다.

PersonViewModel의 인스턴스를 생성하고 프로퍼티를 사용하여 저장된 데이터를 불러오고 사용할 수 있습니다.

마지막으로 MVVM 패턴의 불필요성에 대한 글이 있어 함께 공유합니다.

SwiftUI에서 MVVM 사용을 멈추자"라고 생각이 들었던 이유

0. Xcode에서 새로운 프로젝트 생성

새로운 SwiftUI 프로젝트를 생성한다.

1. Firebase 프로젝트 생성

Firebase console에 들어가 새로운 프로젝트를 생성한다.

iOS를 선택하여 다음 단계로 넘어간다.

2. Apple 앱에 Firebase 추가

1) 앱 등록

Apple 번들 ID는 프로젝트명.xcodeproj > General > Identity > Bundle Identifier에서 확인할 수 있다.

2) 구성 파일 다운로드

제공되는 파일을 다운받아 프로젝트 하단에 추가해준다. (다양한 방법으로 파일을 추가할 수 있지만 그럴 경우 에러가 발생한다는 이야기가 있으므로 Add Files to...로 추가해주는 것을 추천한다.)

3) Firebase SDK 추가

Xcode에서 File > Add Packages로 이동하여 검색란에 주어진 URL을 입력하여 나오는 패키지를 Add Packages한다.

4) 초기화 코드 추가

예시에는 위와 같은 코드로 나와있지만 다음과 같은 코드로도 적용 가능하다. (ContentView.swift 파일이 아닌 프로젝트 생성 시 자동으로 생성되는 '프로젝트명App.swift' 파일이다.)

//프로젝트명App.swift
import SwiftUI
import Firebase

@main
struct 프로젝트명App: App {

    init() {
        FirebaseApp.configure()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

다음 포스팅에서는 Firebase에 간단한 데이터를 저장하고 앱으로는 그 데이터를 보여주는 것을 해보겠습니다.

그러나, 새로운 페이지가 실행돼도 하단의 탭바가 사라지지 않고 존재했다. 원인을 찾아보니 NavigationStack의 위치 때문에 발생한 것이었다. 해당 사이트를 참고하였다.

기존 구조는 NavigationView()가 NavigationLink의 바로 상위에서 감싸고 있었다. 이는 새로운 페이지로 이동하여도 하단의 CustomTabView가 보이게 되는 사태를 초래했다.

수정한 구조는 NavigationView()가 가장 상위단계에 위치하게 된다. 이를 통해 새로운 페이지로 이동할 시 CustomTabView가 보이지 않게 된다.

SwiftUI에서는 TabView를 통해 쉽게 구현할 수 있다.

//TabView
struct ContentView : View {
  var body: some View {
    TabView {
      Text("The First Tab")
        .tabItem {
          Image(systemName: "1.square.fill")
        }
      Text("The Second Tab")
        .tabItem {
          Image(systemName: "2.square.fill")
        }
      Text("The Third Tab")
        .tabItem {
            Image(systemName: "3.square.fill")
        }
    }
  }
}

하지만 내가 만들고자 하는 Tab Bar를 구현하기 위해서는 많은 수정이 불가피했다. 다음 동영상을 참고하여 Custom Tab Bar를 구현해보았다.

//Custom TabView
enum Tab {
    case first
    case second
    case third
}

struct ContentView : View {
    @State var selectedTab: Tab = .first
    var body: some View {
        VStack {
            Spacer()
            switch selectedTab {
            case .first:
                Text("The First Tab")
            case .second:
                Text("The Second Tab")
            case .third:
                Text("The Third Tab")
            }
            Spacer()
            CustomTabView(selectedTab: $selectedTab)
        }
    }
}

struct CustomTabView: View {
    @Binding var selectedTab: Tab
    var body: some View {
        HStack {
            Spacer()
            Button() {
                selectedTab = .first
            } label: {
                Image(systemName: "1.square.fill")
            }
            Spacer()
            Button {
                selectedTab = .second
            } label: {
                Image(systemName: "2.square.fill")
            }
            Spacer()
            Button {
                selectedTab = .third
            } label: {
                Image(systemName: "3.square.fill")
            }
            Spacer()
        }
    }

}

ZStack을 사용해 동그란 버튼을 만들고 offset으로 위치를 변경하였다.

struct CustomTabView: View {
    @Binding var selectedTab: Tab
    var body: some View {
        HStack {
            Spacer()
            Button() {
                selectedTab = .first
            } label: {
                Image(systemName: "1.square")
            }
            Spacer()
            ZStack {
                Circle()
                    .foregroundColor(Color(.orange))
                    .frame(width: 90, height: 90)
                Button {
                    selectedTab = .second
                } label: {
                    Image(systemName: "2.square")
                }
            }
            .offset(y: -32)
            Spacer()
            Button {
                selectedTab = .third
            } label: {
                Image(systemName: "3.square")
            }
            Spacer()
        }
    }
}

Tab Bar의 배경은 도형을 그리는 것이 익숙치 않아 이미지로 넣어주었고 색상은 Assets에 "Symbol"로 지정하여 사용하였다. 몇가지를 추가로 수정한 코드와 결과는 다음과 같다.

struct CustomTabView: View {

    @Binding var selectedTab: Tab

    var body: some View {
        ZStack {
            Image("background")
                .resizable()
                .aspectRatio(contentMode: .fill)
                .offset(y: 15)
            HStack {
                Spacer()
                Button {
                    selectedTab = .home
                } label: {
                    Image(systemName: selectedTab == .home ? "house.fill" : "house")
                        .resizable()
                        .aspectRatio(contentMode: .fit)
                        .frame(width: 30)
                        .foregroundColor(.white)
                }
                Spacer()
                Button {
                    selectedTab = .shop
                } label: {
                    ZStack {
                        Circle()
                            .foregroundColor(Color("Symbol"))
                            .frame(width: 90, height: 90)
                        Image(systemName: selectedTab == .shop ? "basket.fill" : "basket")
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                            .frame(width: 40)
                            .foregroundColor(.white)
                    }
                    .offset(y: -32)
                }
                Spacer()
                Button {
                    selectedTab = .profile
                } label: {
                    Image(systemName: selectedTab == .profile ? "person.fill" : "person")
                        .resizable()
                        .aspectRatio(contentMode: .fit)
                        .frame(width: 30)
                        .foregroundColor(.white)
                }
                Spacer()
            }
        }
        .frame(height: 50)
    }
}

• Argument, Parameter 그게 뭔데?

다음은 Swift에서의 함수 예시이다.

func plus(a: Int, b: Int) -> Int {
    return a + b
}

plus(4, 6)

함수를 정의할 때 사용되는 변수를 Parameter(매개변수), 실제로 함수가 호출될 때 넘기는 변수값을 Argument(인수) 라고 한다. 위 예시에서 Parameter는 a, b가, Argument는 4, 6이 된다.

•Argument label과 Parameter name

Swift에서는 함수를 정의할 때 함수 사용자의 입장에서 매개변수의 역할을 좀 더 명확하게 표현하고자 할 때 Argument label(인자이름)을 사용할 수 있다.

func 함수명(인자이름 매개변수: 인자타입) -> (반환 타입) {
  var result = 매개변수
  return result
}

함수명(인자이름: 15)

func convertToString(from numbers: Set<Int>) -> String {
    let result = numbers.map { String($0) }.joined(separator: ", ")

    return result
}

let exampleNumbers: Set<Int> = [2, 4, 1, 6, 5]
convertToString(from: exampleNumbers) // "2, 4, 1, 6, 5"

위 예시에서 Parameter name은 numbers가, Argument label은 from이 된다.

• 그럼 이건?

다음 예시에서 Parameter name과 Argument label은 각각 무엇일까?

func greet(person: String) {
    let greeting = "Hello, " + person + "!"
    print(greeting)
}

greet(person: "Jimmy")    // "Hello, Jimmy!"

Parameter name과 Argument label이 구별되어 있지 않은 경우엔 동일한 의미가 된다. 즉, 모두 person을 의미한다.

By default, parameters use their parameter name as their argument label.

• 번외

함수를 호출할 때 Argument label을 쓰는 것이 번거로울 경우도 있습니다. 이 때는 _를 통해 인자이름을 생략하여 쓸 수 있습니다.

func orderTo(_ coffee: String) {
    print("주문하신 \(coffee) 나왔습니다.")
}

orderTo("caffeLatte")    // "주문하신 caffeLatte 나왔습니다."

• Promote Clear Usage (명확하게 사용하기)
• Strive for Fluent Usage (자연스러운 사용을 위해 노력하기)
• Use Terminology Well (적절한 기술 용어 사용하기)

• Promote Clear Usage (명확하게 사용하기)

• Include all the words needed to avoid ambiguity (모호함을 피하기 위해 모든 단어를 포함한다.)

  ✅
  extension List {
  public mutating func remove(at position: Index) -> Element
  }
  employees.remove(at: x)

  ⛔️
  employees.remove(x) // unclear: are we removing x?

  at 이라는 단어를 생략한다면 x의 쓰임을 분명하게 알 수 없다.

• Omit needless words (불필요한 단어는 생락한다.)

  ⛔️
  public mutating func removeElement(_ member: Element) -> Element?
  

allViews.removeElement(cancelButton)

```swift
✅
public mutating func remove(_ member: Element) -> Element?

allViews.remove(cancelButton) // clearer

분명한 의도를 위해 더 많은 단어가 필요할 수 있지만, 읽는 사람이 이미 알고 있는 중복되는 정보는 생략한다.

⛔️
func setIntToString(setInt: Set<Int>) -> String {
    let setInt = setInt
    let setString = setInt.map {String($0)}
    let string = setString.joined(separator: ", ")

    return string
}

✅
func convertToString(from numbers: Set<Int>) -> String {
    let result = numbers.map {String($0)}.joined(separator: ", ")

    return result
}

특히, 타입 정보만 반복하는 단어는 생략한다. 타입 제약이 아닌 해당 역할에 따라 변수, 매개변수 및 연관 타입을 명명한다.

• Strive for Fluent Usage (자연스러운 사용을 위해 노력하기)

• Prefer method and function names that make use sites form grammatical English phrases. (사용되는 메서드와 함수의 이름은 영어 문법에 맞는 구가 되는 것이 좋다.)

  ✅
  x.insert(y, at: z)          “x, insert y at z”
  x.subViews(havingColor: y)  “x's subviews having color y”
  x.capitalizingNouns()       “x, capitalizing nouns”

  ⛔️
  x.insert(y, position: z)
  x.subViews(color: y)
  x.nounCapitalize()

• Begin names of factory methods with “make”, e.g. x.makeIterator(). (x.makeIterator()와 같이 팩토리 메서드는 "make"로 시작한다.)
• Name functions and methods according to their side-effects (함수와 메서드는 그 부수 효과에 따라서 명명한다.)
• • • without side-effects, e.g. x.distance(to: y), i.successor() 부수 효과가 없는 함수 및 메서드는 **명사 구로 읽는다.
    • • • with side-effects, e.g., print(x), x.sort(), x.append(y) 부수 효과가 있는 함수 및 메서드는 명령형인 **동사 구로 읽는다.

• Use Terminology Well (적절한 기술 용어 사용하기)

• Avoid obscure terms (이해하기 힘든 용어는 피한다.) Don’t say “epidermis” if “skin” will serve your purpose. "피부" 로 의미가 전달된다면 "표피" 로 말하지 않는다.
• Avoid abbreviations. (축약어는 피한다.)

  ⛔️
  var randomNum: Int
  var resultArr: [String]

  ✅
  var randomNumber: Int
  var resultArray: [String]

• Embrace precedent (선례를 따르도록 한다.) It is better to name a contiguous data structure Array than to use a simplified term such as List. 연속적인 자료구조의 이름으로 List보다는 Array를 사용하는 것이 좋다.

이제는 직접 사용해봅시다. 가장 먼저 챗GPT와의 차이를 물었습니다.

Q : 너와 chatgpt의 차이가 뭐야

A : 제가 할 수 있는 작업 범위가 미리 정해져 있고, 그 범위 내에서 명령을 수행합니다. 반면, chatgpt는 인공지능 챗봇으로 대화를 통해 범위를 넘어서는 다양한 작업을 수행할 수 있습니다. 또한 chatgpt는 자연어 처리 능력이 뛰어나기 때문에 대화의 유연성과 자연스러움에서 우수합니다.

다음으로, 네이버에서 오늘 자 뉴스를 가져오게 했습니다

Q : https://www.naver.com/에서 오늘의 뉴스 크롤링해줘

A : 오늘의 뉴스

• 손흥민, 토트넘과 2년 연장 계약...한국인 역대 최고 연봉(골닷컴)
• 미법원 "트럼프 '탄핵' 건 살아남았다"...의회 집권여부 결정할 듯(종합)
• 美, 대만 군사력 공식 지원 결정…中, "우리 군사력 강화 필요"
• '유럽도 질식'…'초미세 먼지' 서구 국가들도 미세먼지로 고민(종합)
• 유즈루, 눈길 끄는 '우주복' 투입…연말까지 3차례 테스트

위 네이버 뉴스 페이지에서 스크래핑한 오늘의 뉴스입니다. 각 뉴스의 제목을 클릭하면 해당 뉴스의 본문을 읽을 수 있습니다.

다음으로는 직접 크롤링을 할 수 있는 코드를 짜달라고 해봤습니다.

Q : https://www.naver.com/에서 오늘의 뉴스 크롤링 코드 짜줘

A :

import requests
from bs4 import BeautifulSoup

url = '<https://news.naver.com/main/home.naver>'

# requests.get()을 사용해 해당 URL 페이지를 가져옵니다.
response = requests.get(url)

# 가져온 페이지의 html 소스코드를 파싱합니다.
soup = BeautifulSoup(response.text, 'html.parser')

# 오늘의 뉴스 전체를 담고 있는 태그를 찾습니다.
today_news = soup.find('div', {'class': 'hdline_flick_item'})

# 각 뉴스마다 제목과 링크를 출력합니다.
for news in today_news:
    title = news.find('a').text
    link = news.find('a')['href']
    print(title)
    print(link)

위 코드를 사용해 오늘의 뉴스를 크롤링할 수 있습니다. 뉴스의 제목과 링크를 출력하며, 뉴스의 내용을 크롤링하려면 해당 링크를 따라가서 내용을 가져와야 합니다. 이를 위해서는 각 뉴스마다 링크를 따로 저장해야 합니다.

*주의: 이 코드는 네이버 뉴스 페이지의 구조가 바뀌거나, 뉴스의 링크 형식이 바뀌면 작동하지 않을 수 있습니다. *

위 기능은 실로 엄청나다고 생각합니다.

네이버가 임의로 지정한 뉴스 클래스 고유의 태그('hdline_flick_item')를 노션AI가 실제 웹 사이트에 들어가 추출해온 결과입니다. 이렇듯 ‘뉴스’라는 사람의 자연어를 파악하고 네이버에서 뉴스 클래스의 태그를 가져온 것이죠. 더 나아가 그것을 바로 크롤링 할 수 있게 코드로까지 구현하는 수준입니다.

Q : 도봉구청 공지사항 크롤링 코드 짜줘

A : 도봉구청 공지사항 크롤링 코드

도봉구청 공지사항을 크롤링하기 위해서는 파이썬에서 BeautifulSoup과 requests 라이브러리를 사용해야 합니다. 아래는 도봉구청 공지사항 페이지에서 제목과 링크를 추출하는 코드입니다.

import requests
from bs4 import BeautifulSoup

url = '<http://www.dobong.go.kr/subpage/main.jsp?id=www0402010000>'
response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')
notice_list = soup.select('.table_list tbody tr')

for notice in notice_list:
    title = notice.select_one('a').text.strip()
    link = '<http://www.dobong.go.kr>' + notice.select_one('a')['href']
    print(title, link)

위 코드를 실행하면 도봉구청 공지사항 페이지에서 최신 10개의 제목과 링크를 출력합니다. 이 코드를 활용해 필요한 정보를 추출하시면 됩니다.

마찬가지로 도봉구청의 공지사항을 크롤링해오는 코드를 부탁했습니다. 하지만 이번에는 해당하는 웹사이트의 주소를 알려주지 않았습니다. 알아서 도봉구청 홈페이지의 공지사항 페이지로 들어가 코드로 구현하는 모습입니다.

마지막으로 그림을 부탁해봤습니다.

Q : 파이썬으로 헬로키티 그려줘

A : 아래는 파이썬을 사용하여 헬로키티를 그리는 코드입니다. 이 코드를 실행하려면 turtle 모듈이 필요합니다.

import turtle

def draw_circle(color, radius, x, y):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()
    turtle.fillcolor(color)
    turtle.begin_fill()
    turtle.circle(radius)
    turtle.end_fill()

def draw_ribbon(color, width, length, x, y):
    turtle.penup()
    turtle.goto(x, y)
    turtle.setheading(0)
    turtle.pendown()
    turtle.color(color)
    turtle.pensize(width)
    turtle.forward(length)

def draw_hellokitty():
    draw_circle('#ffffff', 100, 0, 0)  # face
    draw_circle('#000000', 10, -40, 120)  # left eye
    draw_circle('#000000', 10, 40, 120)  # right eye
    draw_circle('#ff66af', 30, 0, 80)  # nose
    draw_circle('#ffffff', 20, -40, 130)  # left eye ball
    draw_circle('#ffffff', 20, 40, 130)  # right eye ball
    draw_circle('#ff66af', 60, 0, -40)  # ribbon
    draw_ribbon('#ffffff', 10, 80, 0, -20)  # ribbon
    draw_ribbon('#ff66af', 10, 60, -40, -60)  # ribbon
    draw_ribbon('#ff66af', 10, 60, 40, -60)  # ribbon

turtle.speed(10)
draw_hellokitty()
turtle.done()

이 코드를 실행하면 헬로키티가 그려진 윈도우 창이 열립니다.

위 노션AI가 작성해준 코드를 실행해보았습니다.

이 세계의 헬로키티는 아닌 듯 합니다.

저는 컴퓨터를 배우는 사람이지만 요새 열풍을 일으키는 챗GPT에 대해 비관적인 입장을 가지고 있었습니다. '기껏해봐야 심심이 삼촌 정도 아니겠어?' 하며 말이죠. 하지만 직접 사용해 본 노션AI는 상상 그 이상이었습니다. 올해가 얼마 지나지 않았지만 단연코 올해 최고의 발견이라고 할 수 있겠습니다. 더군다나 챗GPT는 노션AI보다 뛰어난 성능을 갖췄다고 하니 사용해보지 않을 수 없겠습니다. 이러한 것은 어쩌면 유화불굴인지도 모르겠습니다.

유화불굴이 무엇이냐고요?

Q : 세상이 너무 빠르게 흘러간다는 뜻의 사자성어는?

A : 세상이 너무 빠르게 흘러간다는 뜻의 사자성어는 "유화불굴(流花不遇)"입니다.

유화불굴이라는 사자성어는 사실 존재하지 않습니다. AI의 판단이 모두 정답일 순 없겠지만 많은 것을 바꿔놓을 향후 미래가 기대됩니다.

감사합니다.

1.조건으로 검색하기 2.함수로 데이터 처리하기 3.그룹으로 묶기 4.MultiIndex & pivot_table

1. 조건으로 검색하기

numpyarray와 마찬가지로 masking 연산이 가능 조건에 맞는 DataFrame row를 추출 가능하다

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(5, 2), columns=["A", "B"])

df[(df["A"] < 0.5) & (df["B"] > 0.3)] #인덱스 방식
df.query("A < 0.5 and B > 0.3") #query 방식

문자열이라면 다른 방식으로도 조건 검색이 가능하다

pet["animal"].str.contains("cat") #contains
pet.animal.str.match("cat")          #match

2. 함수로 데이터 처리하기

apply를 통해서 함수로 데이터를 다룰 수 있다

df= pd.DataFrame(np.arange(5), columns=["Num"])

def square(x):
  return x**2

df['Square_1'] = df["Num"].apply(square)
df["Square_2"] = df.Num.apply(lambda x: x ** 2) #람다식

replace: apply 기능에서 데이터 값만 대체하고 싶을때 사용

df['age'] = df.age.replace({"child": 0, "adult": 1})   #변수에 값 대입
df.age.replace({"child": 0, "adult": 1}, inplace=True) #값 바로 변경

3. 그룹으로 묶기

df / df.groupby('key').sum() / df.groupby(['key','data1']).sum()

df= pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C'],
                  'data1': [1,2,3,1,2,3],
                  'data2':np.random.randint(0, 6, 6)})

df.groupby('key')
#<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7f5d92085d10>
df.groupby('key').sum()
df.groupby(['key','data1']).sum()

• aggregate groupby를 통해서 집계를 한번에 계산하는 방법

df.groupby('key').aggregate(['min', np.median, max])
df.groupby('key').aggregate({'data1': 'min', 'data2': np.sum})

• filter groupby를 통해서 그룹 속성을 기준으로 데이터 필터링

def filter_by_mean(x):
  return x['data2'].mean() > 3

df.groupby('key').mean()
df.groupby('key').filter(filter_by_mean)

• apply groupby를 통해서 묶인 데이터에 함수 적용

df.groupby('key').apply(lambda x: x.max() - x.min())

4. MultiIndex & pivot_table

• MultiIndex 인덱스를 계층적으로 만들 수 있다.

  df= pd.DataFrame(np.random.randn(4, 2), 
                 index=[['A', 'A', 'B', 'B'], [1, 2, 1, 2]],
                 columns=['data1', 'data2'])

  열 인덱스 또한 계층적으로 만들 수 있다.

df= pd.DataFrame(np.random.randn(4, 4),
                 columns=[["A", "A", "B", "B"], ["1", "2", "1", "2"]])

• pivot_table 데이터에서 필요한 자료만 뽑아서 새롭게 요약, 분석할 수 있는 기능

df.pivot_table(index='sex', 
               columns='class', 
               values='survived', aggfunc=np.mean)

파이썬 라이브러리 구조화된 데이터를 효과적으로 처리하고 저장 Array 계산에 특화된 NumPy를 기반으로 설계

• Series

• numpy array가 보강된 형태 Data와 Index를 가지고 있음

import pandas as pd

data = pd.Series([1, 2, 3, 4])

• 인덱스를 가지고 있고 인덱스로 접근 가능

  data = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
  data['b'] #2

• name 인자로 이름을 지정할 수 있음

  data = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'], name="Title")
  data['c'] = 5

• Dictionary로 Series 변환

  population_dict= {'korea': 5180,
                  'japan': 12718,
                  'china': 141500,
                  'usa': 32676}
  population = pd.Series(population_dict)

• DataFrame

여러 개의 Series가 모여서 행과 열을 이룬 데이터

population_dict= {'korea': 5180,
                  'japan': 12718,
                  'china': 141500,
                  'usa': 32676}
gdp_dict= {'korea': 169320000,
           'japan': 516700000,
           'china': 1409250000,
           'usa': 2041280000,}

population = pd.Series(population_dict)
gdp= pd.Series(gdp_dict)

country = pd.DataFrame({'population': population,'gdp': gdp})

• Dictionary로 변환할 수 있다.

country['gdp’] # ↑↑

country.index
#Index(['china', 'japan', 'korea', 'usa'], dtype='object’)
country.columns
#Index(['gdp', 'population'], dtype='object’)

• Series도 numpy array처럼 연산자를 활용

gdp_per_capita= country['gdp'] / country['population']
country['gdp_per capita'] = gdp_per_capita

• 저장과 불러오기

  country.to_csv(“./country.csv”)     #csv 파일로 저장
  country.to_excel(“country.xlsx”) #엑셀 파일로 저장
  

country = pd.read_csv(“./country.csv”) #csv 파일 불러오기 country = pd.read_excel(“country.xlsx”) #엑셀 파일 불러오기

- 데이터 추가
리스트로 추가, 딕셔너리로 추가
![](https://velog.velcdn.com/images/0000_0010/post/7f274418-d8b8-4874-94c6-c217aa15e29e/image.png)

```py
dataframe= pd.DataFrame(columns=['이름','나이','주소'])

dataframe.loc[0] = ['둘리', '6', '한강'] #리스트 방식
dataframe.loc[1] = {'이름':'길동', '나이':'45', '주소':'쌍문'} #딕셔너리 방식

• 데이터 수정

dataframe.loc[0, '주소'] = '쌍문'

• 새로운 column 추가

  dataframe['전화번호'] = np.nan
  dataframe.loc[1, '전화번호'] = '011-7777-7777'

• 컬럼 선택하기 컬럼 이름이 하나만 있다면 Series 컬럼 이름이 리스트로 여러개 있다면 DataFrame

  dataframe['이름']
  dataframe[['이름','나이']] #대괄호 2개!

• Pandas 연산과 함수

• 누락된 데이터 확인 현실의 데이터는 누락되어 있는 경우가 많다.

  dataframe.notnull() #값이 null일 경우 False
  dataframe.isnull()  #값이 null일 경우 True

  • 누락된 데이터 제거 / 변경 기존 dataframe / dropna() 결과 / fillna() 결과

    dataframe.dropna()
    

dataframe['전화번호'] = dataframe['전화번호'].fillna('전화번호없음')

- 사칙 연산
![](https://velog.velcdn.com/images/0000_0010/post/2cafd81d-9baa-49b5-9b40-3edcbc3dc36f/image.png)
A / B / A+B / A.add(B, fill_value)
```py
A = pd.DataFrame(np.random.randint(0, 10, (2, 2)), columns=list("AB"))
B = pd.DataFrame(np.random.randint(0, 10, (3, 3)), columns=list("ABC"))
A + B
A.add(B, fill_value=0)

• 집계함수 df / df.sum() / df.mean()

df = pd.DataFrame(np.random.randint(0, 10, (3, 3)), columns=list("ABC"))

df.sum()
df.mean()
df['A'].sum()

• DataFrame 정렬

  df= pd.DataFrame({'col1': [2, 1, 9, 8, 7, 4],
                  'col2': ['A', 'A', 'B', np.nan, 'D', 'C'],
                  'col3': [0, 1, 9, 4, 2, 3],})
  

df.sort_values('col1') #오름차순 df.sort_values('col1', ascending=False) #내림차순 df.sort_values(['col2', 'col1']) ```

Python에서 대규모 다차원 배열을 다룰 수 있게 도와주는 라이브러리 → 파이썬 리스트(List)에 비해, 빠른 연산을 지원하고 메모리를 효율적으로 사용

-기본적인 배열 만들기

list(range(10)) 
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

import numpy as np

np.array([1, 2, 3, 4, 5]) 
#array([1, 2, 3, 4, 5])

np.array([[1, 2], [3, 4]])
#array([[1, 2], [3, 4]])

np.array([1, 2, 3, 4], dtype='float’)
#array([1., 2., 3., 4.])

-dtype / astype

배열 데이터의 타입을 알아보기 위해 dtype을 사용한다. 배열 데이터의 타입을 변환하기 위해 astype을 사용한다.

arr= np.array([1, 2, 3, 4], dtype=float)
arr               #array([1., 2., 3., 4.])
arr.dtype         #dtype(‘float64’)
arr.astype(int) #array([1, 2, 3, 4])
arr.dtype        #dtype('int64')

-다양한 배열 만들기

◦ np.zeros((Shape)) 배열을 주어진 행렬만큼 0으로 채운다.

◦ np.ones((Shape)) 배열을 주어진 행렬만큼 1로 채운다.

◦ np.arange(A,B,Step) 배열을 구간에서 주어진 간격만큼 떨어져있는 수들로 채운다.

◦ np.linspace(A,B,N) 배열을 구간 내 주어진 원소의 갯수만큼의 수들로 채운다.

np.zeros(10, dtype=int)
#array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

np.ones((3, 4), dtype=float)
#array([[1., 1., 1., 1.],[1., 1., 1., 1.],[1., 1., 1., 1.]])

np.arange(0, 20, 2)
#array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])

np.linspace(0, 1, 5)
#array([0. , 0.25, 0.5 , 0.75, 1. ])

-난수로 채워진 배열 만들기

◦ np.random.random((Shape)) 배열을 범위 내의 임의의 실수로 채운다.

◦ np.random.nomal(A,B,(Shape)) 배열을 정규분포로부터 샘플링된 난수로 채운다.

◦ np.random.randint(A,B,(Shape)) 배열을 범위 내의 임의의 정수로 채운다.

np.random.random((2, 2))
#array([[0.30986539, 0.85863508],[0.89151021, 0.19304196]])

np.random.normal(0, 1, (2, 2))
#array([[ 0.44050683,  0.04912487],[-1.67023947, -0.70982067]])

np.random.randint(0, 10, (2, 2))
#array([[3, 9],[3, 2]])

-배열의 기초

x2 = np.random.randint(10, size=(3, 4))
# array([[2, 2, 9, 0],[4, 2, 1, 0],[1, 8, 7, 3]])

x2.ndim   #2       → 배열의 차원 수
x2.shape  #(3, 4) → 배열 각 차원(행,열..)의 크기
x2.size   #12       → 전체 원소의 갯수 반환
x2.dtype  #dtype(‘int64’) → 배열 데이터 타입

• Indexing / Slicing

Indexing: 인덱스로 찾아냄

x = np.arange(7)
x[3]     #3
x[7]     #IndexError: index 7 is out of bounds
x[0]=10 #array([10, 1, 2, 3, 4, 5, 6])

Slicing: 인덱스 값으로 배열의 부분을 가져옴

x = np.arange(7)
x[1:4]  #array([1, 2, 3])
x[1:]    #array([1, 2, 3, 4, 5, 6])
x[:4]    #array([0, 1, 2, 3])
x[::2]    #array([0, 2, 4, 6])

• 배열의 모양 바꾸기

◦ reshape() array의 shape를 변경

x = np.arange(8)
x.shape #(8,)

x2 = x.reshape((2, 4)) #array([[0, 1, 2, 3],[4, 5, 6, 7]])
x2.shape #(2, 4)

◦ concatenate() array를 이어 붙임

x = np.array([0, 1, 2])
y = np.array([3, 4, 5])

np.concatenate([x, y]) #array([0, 1, 2, 3, 4, 5])

matrix = np.arange(4).reshape(2, 2)
np.concatenate([matrix, matrix], axis=0)

◦ split() axis 축을 기준으로 분할

matrix = np.arange(16).reshape(4, 4)
upper, lower = np.split(matrix, [3], axis=0)

matrix = np.arange(16).reshape(4, 4)
left, right = np.split(matrix, [3], axis=1)

• NumPy 연산

-사칙연산

array는 + - * / 에 대한 기본 연산을 지원

x = np.arange(4) #array([0, 1, 2, 3])

x + 5 #array([5, 6, 7, 8])
x - 5 #array([-5, -4, -3, -2])
x * 5 #array([ 0,  5, 10, 15])
x / 5 #array([0. , 0.2, 0.4, 0.6])

-행렬 간 연산

다차원 행렬에서도 적용 가능

x = np.arange(4).reshape((2, 2))
y = np.random.randint(10, size=(2, 2))

x + y #array([[1, 7],[6, 5]])
x - y #array([[-1, -5],[-2,  1]])

-브로드캐스팅

shape이 다른 array끼리 연산

matrix + 5

matrix + np.array([1, 2, 3])

np.arange(3).reshape((3,1)) + np.arange(3)

-집계함수

데이터에 대한 요약 통계

x = np.arange(8).reshape((2, 4))

np.sum(x)  #28
np.min(x)  #0
np.max(x)  #7
np.mean(x) #3.5

np.sum(x, axis=0) #array([ 4,  6,  8, 10])
np.sum(x, axis=1) #array([ 6, 22])

앞서 공부한 반복문, 함수, 모듈이 도입된 이유는 효율적인 코드를 위해서이다.

print("hi")         =        for i in range(5):
print("hi")                        print("hi")
print("hi")
print("hi")
print("hi")

-객체

성질과 할 수 있는 행동이 담긴 자료

-클래스 (Class)

객체를 만들 수 있는 틀

-클래스 생성 class 클래스이름:

class Human:

-필드 (Field)

객체가 가지고 있는 성질 = 객체가 가지고 있는 변수

class Human:
    name : 'jin'
    age : 24

-메서드 (Method)

객체가 할 수 있는 행동 = 객체가 할 수 있는 함수

class Human:
    def study(self):
        print(“hard!”)

self: 메서드라면 가져야 하는 첫번째 매개변수

-인스턴스 (Instance)

객체를 만들 수 있는 틀(클래스)로 찍어낸 객체 -인스턴스 만들기 인스턴스 이름 = 클래스 이름()

Lee = Human()

-인스턴스의 변수 인스턴스.변수

Lee = Human()
Lee.name #jin
Lee.age #24

-인스턴스의 메서드 인스턴스.메서드()

Lee = Human()
Lee.study() #hard!

-객체지향 프로그래밍의 특징

1. 추상화 (Abstraction)
2. 상속 (Inheritance)
3. 다형성 (polymorphism)
4. 캡슐화 (Encapsulation)

1. 추상화 (Abstraction)

객체들의 공통적인 특징(기능, 속성)을 도출하는 것 객체지향적 관점에서는 클래스를 정의하는 것을 추상화라고 할 수 있다.

2. 상속 (Inheritance)

하나의 클래스가 가진 특징(함수, 데이터)을 다른 클래스가 그대로 물려받는 것 이미 작성된 클래스를 받아서 새로운 클래스를 생성하는 것

3. 다형성 (polymorphism)

약간 다른 방법으로 동작하는 함수를 동일한 이름으로 호출하는 것 동일한 명령의 해석을 연결된 객체에 의존하는 것

4. 캡슐화 (Encapsulation)

객체가 독립적으로 역할을 할 수 있도록 데이터와 기능을 하나로 묶어 관리하는 것 코드가 묶여있어서 오류가 없어 편리하다.

• 모듈 • 모듈 사용하기 • 모듈 활용하기 • 모듈과 패키지

• 모듈

특정 목적을 가진 함수, 자료의 모임

코드의 길이가 길어지는 상황
이때, 모든 함수, 변수를 구현하는 것은 불가능
→ 누군가 만들어놓은 함수, 변수 등을 활용

-모듈 사용하기

import(불러오다) 키워드를 이용해서 모듈 사용

import random
#random 모듈 불러오기

.(dot)을 쓴 후에 모듈 속 함수/변수 사용

import random
print(random.randrange(0,2))
#0이상 2미만 수 중 임의로 출력

-모듈 만들기

우리가 원하는 내용이 담긴 모듈 제작 가능 .py(파이썬파일)로 만들 수 있다

1) py파일을 생성 후, 함수와 변수를 만든다

#cal.py
def plus(a, b):
    c = a + b
    return c

2) 다른 파일에서 만들어 둔 py파일을 불러온다

#main.py
import cal

3) 불러온 모듈 속 함수, 변수를 활용한다

#main.py
import cal
print(cal.plus(3,4)) #7

-모듈 활용하기

◦ math ◦ random ◦ time 이외 다수..

◦ math

수학 연산을 도와주는 모듈

import math

print(math.pi) #3.141592...
print(math.e) #2.718281...

◦ random

랜덤한 숫자를 선택해주는 함수들이 담긴 모듈

import random

print(random.randrange(1, 11)) 
#1부터10까지의숫자중하나를출력

◦ time

시간 데이터를 다루는 함수들이 담긴 모듈

import time

print(time.time())
#1970년 1월 1일을 기준으로 현재시각을 초로 나타내는 실수형 반환

• 모듈과 패키지

-패키지

모듈을 폴더(Directory)로 구분하여 관리하는 것 모듈을 편리하게 관리하기 위해 존재한다.

project/
    script/
    sound/
    audio/
    ...

-패키지 속 모듈 사용하기

1) import을 이용해서 폴더를 불러온 후, 함수 실행

import user.cal

print(cal.plus(3, 4))

2) from-import사용

함수/변수 사용 시 .(dot)을 써주지 않아도 된다

from user.cal import plus

print(plus(3, 4)) 
#cal.plus()라고 적어주지 않아도 된다

• 함수 • 함수의 종류 • 전역 변수와 지역 변수 • 메서드 (Method)

• 함수

특정 기능을 수행하는 코드 재사용할 수 있게 만들어 놓은 것

• 함수의 종류

-내장 함수

아무런 설정없이 바로 사용 가능한 내장된 함수

◦ input() - 자료를 입력하는 함수 ◦ print() - 자료를 출력하는 함수 ◦ max() - 시퀀스 자료의 최댓값을 구하는 함수 ◦ min() - 시퀀스 자료의 최솟값을 구하는 함수 ◦ sum() - 숫자 원소로 이뤄진 시퀀스의 합 ◦ len() - 시퀀스 자료의 길이를 구하는 함수 외 다수...

-사용자 지정 함수

사용자가 새로 만든 함수 define(정의하다) 키워드를 이용해서 함수 정의

def 함수이름(매개변수):
    <수행할명령>

    return반환값

def plus(a, b):
    c = a+b
    return c

print(plus(3,4)) #7

매개변수를 이용해서 함수 내부로 값을 전달 return을 이용해서 함수 외부로 값을 전달

• 전역 변수와 지역 변수

def my_func(a):
    x = “엑스”
    return a

a = 3
print(my_func(a)) #3
print(x) #error

함수 안에서 일어난 일은 함수 밖에 영향을 끼치지 않는다

-전역변수

어디서든지 사용할 수 있는 변수

x = “Hi!”
def my_func():
    print(x)

my_func() #Hi!
print(x) #Hi!

-지역변수

특정구문(for문,함수...) 안에서 정의한 변수 변수를 정의한 범위에서만 사용이 가능

def my_func():
    x = “Hi?”
    print(x)

my_func() #Hi?
print(x) #error

• 메서드 (Method)

특정 자료에 대해 특정 기능을 하는 코드

-함수와의 차이

메서드는 특정 자료와 연관지어 기능을한다 (자료뒤에.을찍어사용한다)

my_list= [1, 2, 3]
my_list.append(4)
my_list.count(2)
my_list.pop()

함수는 특정 기능을 한다 (매개변수를 이용해 자료를 전달해준다)

my_list= [1, 2, 3]
len(my_list)
sum(my_list)
min(my_list)

1. list.pop(index)
2. seq.count(data)
3. str.split(char)
4. list(str)
5. str.join(list)

1. list.pop(index)

인덱스 index의 원소를 제거 후 그 원소를 반환 (괄호를 비울 시 마지막 원소)

my_list = [1, 2, 3, 4, 5]
print(my_list.pop(0)) #1
print(my_list.pop()) #5

2. seq.count(data)

시퀀스 내부의 자료 data의 개수를 반환

my_seq = [2,2,2,4,4]
print(my_seq.count(2)) #3

3. str.split(char)

char를 기준으로 문자열을 쪼개서 리스트를 반환 (괄호를 비울 시 공백)

my_str= “1 2 3 4 5”
print(my_str.split()) #[‘1’, ‘2’, ‘3’, ‘4’, ‘5’]
element = “Na,Mg,Al,Si”
print(element.split(‘,’)) #[‘Na’, ‘Mg’, ‘Al’, ‘Si’]

4. list(str)

문자열 str을 리스트로 반환

my_str="Lion"
print(list(my_str)) #['L','i','o','n']

5. str.join(list)

str을 기준으로 리스트 원소들을 전부 합쳐서 문자열을 반환 (괄호를 비울 시 공백)

my_list = [‘a’, ‘p’, ‘p’, ‘l’, ‘e’]
print(‘’.join(my_list)) #apple
friend = [‘Pat’, ‘Mat’]
print(‘&’.join(friend)) #Pat&Mat

• 튜플 (Tuple)

여러자료를 함께 담을 수 있는 자료형 () 소괄호로 묶어서 표현

tuple_zero= ()
tuple_one= (1,)
tuple_ = (1, 2, 3, 4, 5)
tuple_ = 1, 2, 3, 4, 5

-튜플의 특징

시퀀스 자료형으로 인덱싱/슬라이싱 가능 in 연산자로 튜플 안에 원소 확인 len() 함수로 튜플의 길이 확인 + 연산자로 튜플과 튜플을 연결 *** 연산자로 튜플을 반복 **자료추가, 삭제, 변경 불가 한번 만들어지면 고정

• 딕셔너리 (Dictionary)

짝이 있는 자료형 {key : value}의 형식: key를 알면 value를 알 수 있음 {} 중괄호로 묶어서 표현

dict_zero= {}
person = {‘name’:‘Michael’, ‘age’:10}

-key

열쇠처럼 자료를 꺼낼 수 있는 도구 ex) name, age

-value

딕셔너리에서 key로 꺼낸 자료 ex) Michael, 10

-Dictionary[key]

딕셔너리에서 자료를 꺼내고 추가하기

person = {‘name’:‘Michael’, ‘age’:10}
print(person[‘name’]) #Michael
person[‘hometown’] = Seoul #딕셔너리에 추가
print(person[‘hometown’]) #Seoul

-del

del 함수로 딕셔너리의 원소 삭제

person = {‘name’:‘Michael’, ‘age’:10}
del person[‘age’]
print(person) #{‘name’:‘Michael’}

-딕셔너리의 특징

key는 변할 수 없는 자료형이기 때문에 리스트는 안되고 튜플은 된다.

datas= {[1, 2, 3]:‘Alphabet’} #Error
datas= {(1, 2, 3):‘Number’} #OK

어떠한 조건이나, 범위 내에서 어떠한 명령을 반복적으로 수행하는 것

• for 문

원소로 반복하는 방법 시퀀스의 원소를 하나씩 변수에 넣어가면서 명령 실행

for 변수 in 시퀀스:
    <수행할 명령>

sum = 0
for i in [1,2,3]:
    sum = sum + i

• for range 문

-range

연속되는 숫자를 만들어주는 시퀀스 자료형

range(0,9) #0,1,2,..,6,7,8
range(5) #range(0,5) | 0,1,2,3,4

-for range(a,b)

구간으로 반복하는 방법 a이상 b미만의 수를 변수에 넣어가면서 명령을수행

a = [1]
for i in range(2, 4):
    a.append(i)
print(a) #[1, 2, 3]

-for range(a)

횟수로 반복하는 방법 a번 만큼 명령을 수행

count = 0
for i in range(10):
    count = count + 1
print(count) #10

• while 문

조건으로 반복하는 방법 조건이 True이면 명령을 수행

while 조건:
    <수행할 명령>

i = 5
while i<10:
    print(i)
    i++

-while문에서 조건이 항상 True라면 → 무한정 코드가 실행된다. 빠져나올 수 없는 무한루프에 빠진다.

• break 문

if 문으로 조건을 걸어준 다음, break 실행 반복문을 탈출하는 역할

i= 0
while True:
    print(“knock”)
    if i>=3:
        break
    i= i+ 1

>>>knock
>>>knock
>>>knock
>>>knock

1. list.append(data)
2. list.insert(index, data)
3. list.remove(data)
4. list.sort()

1. list.append(data)

자료 data를 리스트 마지막 원소 뒤에 추가 오직 한 개의 자료만 넣을 수 있다

a = []
b = [‘a’, ‘b’, ‘c’]
a.append(10)
b.append(‘d’)
print(a) #[10]
print(b) #[‘a’, ‘b’, ‘c’, ‘d’]

2. list.insert(index, data)

인덱스 index에 자료 data를 추가 오직 한 개의 자료만 넣을 수 있다

c = [1, 2, 4, 5]
c.insert(2, 3)
print(c) #[1, 2, 3, 4, 5]

3. list.remove(data)

처음 나오는 자료 data를 제거

d = [3, 1, 2, 3]
d.remove(3)
print(d) #[1, 2, 3]

4. list.sort()

리스트를 정렬 숫자형은 오름차순, 문자열은 사전순

e = [6, 2, 4, 1]
f = [‘carrot’, ‘apple’, ‘banana’]
e.sort()
f.sort()
print(e) #[1, 2, 4, 6]
print(f) #[‘apple’, ‘banana’, ‘carrot]

• 시퀀스 자료형

순서가 있는 자료형 리스트, 문자열 등이 이에 속함

a = “Black” #문자열
b = ['P','I','N','K'] #리스트
c = (1,2,3,4,5) #튜플

-시퀀스의 특징

1. 원소 간의 순서가 존재
2. 멤버 조회
3. 길이 확인
4. 연결 연산
5. 반복 연산

1. 원소 간의 순서가 존재

인덱싱/슬라이싱이 가능하다. 음수를 넣거나 자리를 비우는 것이 가능

a = “Black”
b = ['P','I','N','K']
print(a[3]) #c
print(b[0:2]) #['P','I','N']
print(a[-1]) #k | 뒤에서 1번째 원소
print(b[:2]) #[‘P’, ‘I’, ‘N’] | 처음~3번째 슬라이싱

2. 멤버 조회

in 연산자로 시퀀스 안에 원소가 있는지 확인 가능

a = “Black”
b = ['P','I','N','K']
print('b' in a) #True
print('B' in b) #False

3. 길이 확인

len 연산자로 시퀀스 안에 원소가 몇 개인지 확인 가능

a = “Black”
b = ['P','I','N','K']
print(len(a)) #5
print(len(b)) #4

4. 연결 연산

+ 연산자로 같은 시퀀스 두개를 이어 붙일 수 있다

c = ['P','I'] + ['N','K']
print(c) #['P','I','N','K']

5. 반복 연산

***** 연산자로 시퀀스를 반복할 수 있다

d = "area" * 3
print(d) #areaareaarea

변수를 사용하여 사용자가 전달한 값을 보관합니다. 변수 = input()

var = input()

무엇을 입력하든 문자열로 입력이 받아진다. 만약 숫자를 입력해야 한다면 입력을 받은 후 가공을 해주어야 한다.

• 형 변환

interger → 숫자(정수) float → 숫자(실수) string → 문자열 list → 리스트

a = ‘345’
b = int(‘345’)
print(a,b) #345 345
print(type(a)) #<class ‘str’> | 문자열
print(type(b)) #<class ‘int’> | 숫자

• 논리형 자료와 비교연산

1. 논리 자료형
2. 비교 연산자
3. 논리 자료형의 연산

1. 논리 자료형

참(True) 혹은 거짓(False)을 나타내는 자료형을 논리 자료형이라고 합니다.

2. 비교 연산자

숫자나 문자의 값을 비교하는 연산자 주어진 진술이 참이면 True, 거짓이면 False

-비교 연산자의 종류

==: 같다
!=: 다르다
>: 왼쪽이 더 크다
<: 오른쪽이 더 크다
>=: 왼쪽이 같거나 크다
<=: 오른쪽이 같거나 크다

print(2 < 7)   #True
print(8 == 5)  #False
print(3 >= 12) #False
print(5 != 14) #True

3. 논리 자료형의 연산

1. AND
2. OR
3. NOT

1. AND

각 논리가 모두 True여야 True

print(4==4 and 2<=5 and 6>2)
#세 항이 모두 True이므로, True!
>>>True

2. OR

논리들 중 True가 존재하면 True

print(3==6 or 2<=7 or 4<1)
#2<=7이 True이므로, True가존재하기에 True!
>>>True

3. NOT

논리값을 뒤집는다

print(not3==4)
#False에 Not을 붙였으므로, True!
>>>True

• 조건문

어떠한 특정 조건에 따라서 실행되는 명령이 달라지는 구문

-if 문

조건이 True일때, 명령 실행

if 조건:
    <수행할 명령>
    <수행할 명령>

if array[0]==3:
    count = count + 1
    print(array)

-if else 문

조건이 True면 if문, False면 else문 실행

if 조건:
    <수행할 명령>
else:
    <수행할 명령>

x = input()
if x in [‘a’, ‘e’, ‘i’, ‘o’, ‘u’]:
    print(“모음입니다.”)
else:
    print(“자음입니다.”)

-if elif 문

조건1이 True면 if문, 조건1이 False이면서 조건2가 True면 elif문 실행

if 조건:
    <수행할 명령>
elif 조건:
    <수행할 명령>

x = int(input())
if x%2==0:
    print(“2의배수입니다.”)
elif x%3==0:
    print(“3의배수입니다.”)

1. 숫자형 (Number)
2. 문자열 (String)
3. 리스트 (List)

1. 숫자형 (Number)

숫자로 이루어진 자료형 정수나 실수 등을 다룰수있다. 숫자끼리의 연산이 가능하다.

3      #정수형(integer)
3.14 #실수형(float)
3+4j #복소수

2. 문자열 (String)

문자나 문자들을 늘어놓은것 큰 따옴표(" ")와 작은 따옴표(' ')로 구분

'안녕하세요'
'3.14' #작은 따옴표 OK
"3.14" #큰 따옴표 OK

3. 리스트 (List)

여러 자료를 보관하는 자료형 다른 종류의 자료를 함께 담을 수 있습니다. 자료 안에 순서가 있습니다.

[] #빈 리스트
['a', 'b', 'c']
['1', 1] #문자 1과 숫자 1
[['x', 'y'], 2, 'e']

• 변수

자료를 ʻ그릇ʼ에 담아서보관, 사용하면 편리합니다. 이를 변수(variable)라 합니다.

-변수 사용방법

변수 이름 = 자료

num = 10 #숫자
name = ‘Michael’ #문자열
grade = [‘A+’, ‘B+’, ‘A0’] #리스트

-변수 작명방법

1. 숫자, 알파벳, 한글, 언더바(_) 등을 사용할 수 있다.
2. 변수 이름이 숫자로 시작하면 안 된다.
3. 파이썬에서 사용되는 예약어(ex. if, while...) 사용 금지
4. 공백 문자(' ')와 연산자(+, -, * 등) 사용 금지

• 자료형의 연산

1. 숫자형 자료의 연산
2. 문자형 자료의 연산

1. 숫자형 자료의 연산

숫자형 자료의 사칙연산

+: 덧셈 연산자 -: 뺄셈 연산자 *: 곱셈 연산자 /: 나누셈 연산자

print(2+5) #7
print(2-5) #-3
print(2*5) #10
print(2/5) #0.4

숫자형 자료의 특수연산

//: 몫 연산자 %: 나머지 연산자 **: 제곱 연산자

print(12//5) #2
print(12%5)     #2
print(2**5)     #32

2. 문자형 자료의 연산

+: 이어붙이기 *: 반복하기

print("안녕"+"하세요") #안녕하세요
print("안녕"*3) #안녕안녕안녕

• 문자열/리스트 접근하기

'IM FEARLESS'과 'LE SSERAFIM'은 다른 문자열이다. [1, 2, 3]과 [3, 2, 1]은 다른 리스트이다.

→ 원소의 배치 순서가 다르기 때문이다.

-인덱스

문자열과 리스트 자료형은 여러 원소로 이루어져있고 각각의 위치를 0부터 순서대로 매길 수 있습니다.

'happy'            [2,4,6,8]
 01234 → 인덱스 ←  0 1 2 3

-인덱싱

Index를 이용해서 리스트나 문자열의 특정 위치의 원소를 가져오는 방법

# alpha에서 인덱스1인 원소‘e’를 출력
alpha = ‘Ready’
print(alpha[1])
>>> e

-슬라이싱

Index를 이용해서 리스트나 문자열의 일부분을 잘라서 가져오는 방법

# beta에서 2번째 원소 이상, 5번째 원소 미만을 가져온다.
beta = [2, 4, 6, 8, 10, 12, 14]
print(beta[2:5])
>>> [6, 8, 10]