wolfsil (Wolfsil)

프로그래밍 명명법

Mon, 23 Oct 2023 05:15:03 +0900

파스칼 명명법(NameIs)을 쓸것

//파일이름
#include "Name"
using namespace Name
Using Name

//타입이름(클래스, 구조체, 컴포넌트)
class Cls{}
struct Str{}
function Compon{
    return {}
}

//속성
class Cls{
    int num;
    int Num{
        get{ return num; }
        set;
    }
}

//함수이름
public void Method{
    return;
}

카멜 명명법(nameIs)을 쓸것

//변수이름
int num;
str
let arr=[]

취향에 따라 선택

메서드: 카멜 명명법을 써도 됨
인스턴스: 앞에 I 를 붙여서 확실하게 하는 것도 좋음
파일 이름: 카멜 명명법을 써도 됨 -스네이크 표기법(name_is)은 추천안함. 길어짐

파이썬 디렉토리 다루기

Tue, 17 Oct 2023 22:39:48 +0900

디렉토리 다루기

#디렉토리 경로
import os
os.getcwd() #현재 디렉토리 경로가 반환
os.chdir(path) #작업 디렉토리 경로가 변경
os.listdir() #현재 디렉토리의 리스트를 보여줌
os.listdir(path) #디렉토리의 리스트를 보여줌
os.path.exists(path) #파일,디렉토리가 있는지 확인
os.path.isdir(path) #디렉토리가 있는지 확인
os.path.isfile(path) #파일 존재 확인
os.path.getsize(path) #파일 사이즈 확인
os.makedirs(path) #디렉토리 생성

makedirs는 마지막 디렉토리가 존재하면 오류발생

파이썬 pillow 라이브러리 사용법

Tue, 17 Oct 2023 21:36:12 +0900

PILLOW 이미지 라이브러리 사용법

기초

임포트

from PIL import Image

이미지 로드, 사이즈, 보여주기

image = Image.open('12.png')

#사이즈
print(image.width)
print(image.height)
print(image.size) 

#보여주기
image.show()

#보여주기2
import matplotlib.pyplot as plt
plt.imshow(image)

이미지 조작


#이미지 오픈
image = Image.open('12.png')

#이미지 모드 변환
image = image.convert("RGBA")

#이미지 생성
canvas = Image.new("RGBA", (300, 300))

#크기 조작. LANCZOS, Bilinear 추천
image=image.resize(size=(512,512),resample=Image.LANCZOS) 

#이미지 필터링
from PIL import ImageFilter
image=image.filter(ImageFilter.BLUR)

#이미지 회전
image= image.rotate(90)


#이미지 저장
image.save("12.png")


#이미지 넘파이 변환
imageArray=np.array(image)

이미지 생성: mage.new(mode, size)
이미지 오픈: Image.open(path)
필터: ImageFilter에 모여있음

이미지 그리기

from PIL import Image, ImageDraw

#이미지 그리기
canvas = Image.new("RGB", (300, 300))
d = ImageDraw.Draw(canvas,mode="RGBA")
d.line([10, 10, 290, 10, 290, 290, 10, 290, 10, 10], width=2, fill=(0,255,0,10))
d.text((10, 10), "Draw this text")

#이미지 옮겨붙이기
image = Image.new("RGBA", (300, 300),color=(255,255,255,0))
canvas = Image.new('RGBA', (400,400), color=(127,251,25,255))
canvas.paste(image, (0,0)) #canvas에 이미지가 옮겨붙여짐(값복사)

#마스크
image = Image.new("RGBA", (300, 300),color=(255,0,0,300))
canvas = Image.new('RGBA', (400,400), color=(0,255,0,127))
mask=Image.new('RGBA', (300,300), color=(0,0,0,127))
canvas.paste(image,(0,0),mask=mask)

ImageDraw에 이미지 그리는 함수가 모임
이미지 드로우 클래스는 이미지 클래스와 별개
이미지 드로우로 그린건 원본에 반영(canvas)
사이즈가 초과돼도 크기범위 내에 알아서 그림
마스크의 색은 무의미 하다. 오직 알파값만

c++ 요약

Mon, 09 Oct 2023 03:04:50 +0900

C++ 요약

C++ 기초

임포트. 입출력

#include <iostream> //iostream 헤더를 임포트
#include <stdio.h>
using namespace std; //네임스페이스 선언

int main() {
    //방법 1
    string s;
    scanf_s("%s", &s);
    printf("지역변수 : %s", s);
    //방법 2
    string a; //
    cin >> a; //입력 getline(cin,a)가 띄어쓰기도 포함해줌
    std::cout << a; //출력. 네임스페이스를 명시적 선언
    return 0;
}

독자적인 파일은 <> 대신, “주소”로 불러올수 있음

네임스페이스

using namespace name;
namespace name {
    class cls {

    };
    void func() {
        cout << "call name function";
    }
}//네임스페이스 선언

int main(){
    name::fun();//사용 방법 1. 명시적 방법
    fun(); //사용방법 2. using 구문 이용
}

자료형

int main() {
    //기본자료형
    int i= 1; //선언하는 방법
    string s="안녕";
    
    //배열
    int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
    arr[0] //arr 접근방법

    //다차원 배열
    int arr[10][10]={0} //배열의 형태를 확실히 입력시 첫 인자 스킵가능
    arr[0][0]=1
}

c++은 주소가 따로 있으므로 대입시 값이 (얕은) 복사

int	약 절대값 약 21억의 정수(32비트)
float	유효자리 15의 약 절대값 10^38(32비트)
char, wchar_t	문자. 1바이트, 2바이트(unsigned)
bool	참 거짓(1바이트)
string	인스턴스지만 대입시 값복사
class, struct	클래스와 구조체
그외	double(8바이트), longlong, unsigned
자료형 이름[크기]	배열은 선언후 다시 대입 불가

주소

자료형 *	자료형의 주소

연산

int a=10
int b=4
int result=0

//가감승제
result=a + b # 14
result=a - b # 6 
result=a * b # 40 
result=a / b # 2 (버림)

//나머지 
result=a%b # 2

//비트 연산 (&,|,^,~)
result= a&b # 0

//연산하고 대입
b+=a # b=b+a 와 동일 

//문자열 연산(널문자를 자동 처리해줌)
string a = "안녕 ";
string b = " 반가워";
cout << a + b; //안녕 반가워

정수와 소수자료형끼리 연산하면 자동 형변환
정수끼리 연산에는 형변환 없음
string 끼리는 연산 가능(char[]는 안됨)

조건문

//비교
1<1.1 //True 
1>1.1 //False
1<=1 //True 
1>=1 //True 
1==1 //True 
1==1.0 #True

//if문
int main() {
    int a = 1;
    if (a < 10) {
        cout << "a는 10보다 작습니다. "<<a;
    }
    else if(a==10){
        cout << "a는 10입니다 " << a;
    }
    else {
        cout << "a는 10보다 큽니다. " << a;
    }

//switch문(숫자형만 가능)
    int num=0;
    switch (num) {
    case 0:
        printf("입력값은 0입니다");
        break;//호출 안하면 아래도 실행해버림
    case 20:
        printf("입력값은 20입니다");
        break;
    default:
        printf("입력값은 어찌돼도 좋습니다.");
        break;
    }
    return 0;
}

반복문

//0~9까지 출력하는 반복문

int main(){
    int i = 0;
    //while 문
    while (i < 10) {
        cout << i << endl;
        i++;
    }
    //for문
    for (int i = 0; i < 10; i++) {
        cout << i << endl;
    }
}

do~while문 역시 있으나 잘 쓰지 않음

C++ 심화

메서드

int a=10;
void met(int input=2){
    int a=1; //전역변수 a와는 별개
    int b=2;
    return a+b;
}
int main(){
    met(1) // 2
    return 0;
}

반환형 이름(파라미터){ return 반환값 형식 }
디폴트 입력값 가능
파라미터에 넣은 값은 원본의 데이터의 값을 복사한 값임을 유의
원본값을 조작하려면 주소를 넘기는 방식을 쓸것 (*)

구조체

struct stu
    {
    private:
        int id;
        string name;
    public:
        stu(int id, string name) : id(id),name(name){}//생성자
        ~stu() {
            cout << "구조체 소멸" << endl;
        }// 소멸자
        void show() {
            cout << id << name;
        }
        void set(int id, string name) {
            this->id = id;//this를 써서 자신의 구조체(클래스)주소를 반환
            this->name = name;
        }
    }; //c와 다르게 typedef가 필요없다.
int main(){
    stu a={10,"name"};//a(10,"name")과 동일
    a.show();
    return 0;
}

기본적으로 public

클래스

class parent {
public:
    int id;
    string name;

    parent() {
        id = 10;
        name = "name";
        cout << id << name<<endl;
    }
    parent(int id, string name) : id(id), name(name) {
        cout << id << "  " << name<<endl;
    }

    void show() {

    }
};

class cls : public parent{
public:

    cls() :parent() {}

    cls(int id, string name) :parent(id, name) {}//생성자.
    ~cls() {
        cout << "클래스 소멸" << endl;
    }// 소멸자
    void show() {
        cout << id << name<<endl;
    }
    void set(int id, string name) {
        this->id = id;//this를 써서 자신의 구조체(클래스)주소를 반환
        this->name = name;
    }
}; //c와 다르게 typedef가 필요없다.
int main() {
    //방법 1(대입시 내부의 값이 얕은 복사)
    cls a(1, "name");
    a.show(); 

    //방법 2(대입시 주소값만 복사)
    cls * b = new cls();
    b->show(); //(*b).show()를 간단하게 표현가능

    return 0;
}

기본적으로 private
구조체처럼 { } 할당 불가
딴언어랑 다르게 대입연산시 내부 내용 얕은 복사
복사말고 주소를 넘기려면 주소값을 사용해야함(*)
(*인스턴스)는 인스턴스→ 구문으로 바꿀수 있음
부모 생성자를 자동으로 부르기 때문에 { }안에 생성자를 명시적으로 부르면 안됨(두번 부르게 됨)

주소와 동적할당(point, refference)

void point(int* ref1, int* ref2) {
    int temp = *ref1;
    *ref1 = *ref2;
    *ref2 = temp;
}

void reff(int& ref1, int& ref2) { //레퍼런스
    int temp = ref1;
    ref1 = ref2;
    ref2 = temp;
}

void main() {
    int* ptr1 = new int(3);
    int* ptr2 = new int[3] {0, 1, 2};
    int* ptr3=new int();
    *ptr3 = 10; //주소에 접속해서 참조
    
    int temp=5;
    ptr3 =&temp; //기존의 값의 주소추출

    cout<<*ptr1<<" "<<*ptr2<<" "<<*ptr3;
    point(ptr1,ptr3);
    cout<<*ptr1<<" "<<*ptr2<<" "<<*ptr3;

    delete ptr1;
    delete[]ptr2; //객체 배열은 이렇게 해제
    //이중 배열이면 안에 있는 배열들부터 해제요망
    delete ptr3;

    int ref1 = 1;
    int ref2 = 2;
    int& ref3 = ref1; //ref1의 분신체
    reff(ref1, ref2);
    cout << ref1 << "  " << ref2;

}

주소를 넘기는 방식은
일차원 배열은 주소를 가르킴을 알 수 있다.
레퍼런스는 그 자체를 그대로 쓰는거고, 주소는 주소를 복사해 같은 곳을 가르킨다는 차이점이 있음

예외처리

void main() {
        try
        {
            int a=10;
            int b=0;
            if (b == 0) throw "0 이";
            cout << a << "를 " << b << "로 나눈 몫은 " << a / b << "입니다." << endl;
        }
        catch (string & excep)//오류를 던지는 자료형과 자료형이 일치해야함
        {
            cout << "예외 발생, 나누는 수는 " << excep << " 될 수 없습니다." << endl;
        }
}

c++의 예외처리는 받을 때 자료형을 따진다.

템플릿

template<typename T>
void swapping(T& num1, T& num2)
{
    T temp = num1;
    num1 = num2;
    num2 = temp;
}

void useTemp() {
    int num1 = 0, num2 = 1;
    swapping<int>(num1, num2); //꼭 명시적일 필욘 없으나 명시적인게 좋다
    cout << num1 << " " << num2;
}

템플릿으로 자료형을 자유롭게 설정가능한 코드 생성가능

자바스크립트 요약

Sun, 08 Oct 2023 18:31:42 +0900

자바스크립트 요약

자바스크립트 기초

자바스크립트 입출력

import * as readline from "readline"

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
    
  console.log("input: ", line);
  rl.close();
});

rl.on("close", () => {
  process.exit();
});

자바스크립트 자료형과 선언

//선언후에도 파이썬 처럼 자료형 변경이 자유로움
let id=10 //변수
const name="이름" //상수
console.log(id+name) //문자열과 연산하면 자동으로 형변환

//형변환1
parseInt(name) //문자를 숫자로 변환 "10"=>10, "이름"=>nan
        //그외 parseFloat 도 있다

//형변환2
String(id) //입력값을 문자로
Number(id) //문자형을 숫자로 변환

대입 연산시(=) 값이 복사되는것(불변형)

Number	숫자
Boolean	참거짓
String	문자열
null, undefined	명시적인 무 와 아직 할당 안한 무를 의미

대입 연산시(=) 주소가 복사되는것(복사시 같은 것을 가르키게 됨)(가변형)

class	같은 인스턴스를 가르킴
{ }	객체
[]	배열

자바스크립트 배열과 객체

//배열
let arr=[0,1,2,3]
arr.push(4)//0을 뒤에 삽입
arr.unshift(-1)//-1을 맨 앞에 삽입
console.log("배열: ",arr, "길이: ",arr.length)
console.log(arr.pop())//맨뒤의 값을 추출 후 삭제
console.log(arr.shift())//맨앞의 값을 추출 후 삭제(dequene)
console.log(arr[1])//임의위치 접근
console.log(arr)

//객체
const obj={
    name:"익명",
    func: function(){
        console.log("함수1")
    },
    get fullName(){
        return this.name+""+"is Name"
    },
    set fullName(value){
        this.name=value //객체 내부 함수에서 객체값에 접근할떈 무조건 this가 필요
    }
}
ref={}
name="유저" //값형식은 복제
ref.func=()=>console.log("함수2")//주소형식은 주소를 전달
ref["name"]=obj.name //두가지 방식으로 객체 사용가능
console.log(obj) 
obj.func()
obj["fullName"]="객체 is Name"

//스프레드
let a=[0,1,2]
let b=[...a] //펼쳐서 복사

let { c, d, e=3}= { c: 1, d: 2 } //키 값이 같은 것에 맵핑. 없으면 무시

const object = { f: 1, g: 2, h:3 }
let {f, ...rest}=object //f 빼고 나머지는 rest로 간다

자바스크립트는 왠만하면 에러가 안난다.
길이 4짜리 배열에 [4]을 연산해도 undefined가 뜰뿐
배열이 아닌 자료형에도 [ ] 연산해도 undefined가 뜬다.
객체는 파이썬의 딕셔너리와 비슷

자바스크립트 연산

let a=10
let b=4
let result=0

//가감승제
result=a + b // 14
result=a - b // 6 
result=a * b // 40 
result=a / b // 2.5 (자료형 변환)
result++ // 3.5 단항 연산

//나머지 제곱
result=a%b # 2
result=a**b # 10^4

//문자열 연산
a="가"
b="나"
c=1
print(a+b) # 가나 (c는 자료형이 다르므로 안됨)
print(a,b,c)# 가나1

//널 연산
1+nan #nan 
1+undefined #nan
1+null #1

//비트 연산 (&,|,^,~) 왠만해선 사용하지 말것
result= a&b # 0b1010 0b100 0

//연산하고 대입
b+=a # b=b+a 와 동일

숫자형 끼리는 자동 형변환을 해줌
숫자형을 문자열로 자동으로 바꿔주진 못함

파이썬 조건문

//비교
a=1
b=1.0
c="1"
d=[1]
e=[1]//같은 값을 가져도 주소가 다르므로 다른 취급
console.log(
        "==는 자료형을 따지지 않는다\n", //!=
        "비교 예: ",a==b, " ",
        "비교 예: ",a==c, " ",
        "비교 예: ",a==d, " ",
        "비교 예: ",d==e, " ")//모두 True, 마지막만 false 
console.log(
        "===는 자료형을 엄격하게 따진다\n", //!==
        "비교 예: ",a===b, " ", 
        "비교 예: ",a===c, " ", 
        "비교 예: ",d===e, " ")첫번째만 True

//switch 문
let value="5"

switch (value) {
    case '1':
      console.log('1번');
      break;
    case '2':
        console.log('2번');
      break;
    default:
        console.log('3번');
}

//if문
let a=10
let b=11

if (a > b) {
  console.log('a 가 b보다 큽니다.');
} else if(a == b){
    console.log('a 가 b와 같습니다.');
} else{
    consolo.log("a 가 b보다 작습니다"
}

문자형도 숫자형으로 자동 형변환 해줌
단일원소 배열도 같은 취급 해버림(다만 배열끼리는 안됨)
객체는 같은 원소가 들어있어도 키 때문에 다른 취급(객체끼린 안됨)
null, undefined, 0, NaN은 false 취급
삼항연산자도 사용가능

자바스크립트 반복문

//쉬운 사용법
let value=[]
for(let i=0;i<10;i++){
  value.push(i)
}
for(i in value)
{
  console.log(i)
}

value="0" 
//이런 말도 안되는게 허용된다. 심하게 자유로운 구조
while(value<10){
  console.log(value)
  value++
}
console.log(typeof(value))//자료형이 변환되있다

//반복 함수
const array = [1, 2, 3, 4, 5, 6, 7, 8];
//모두 결과가 같다
array.forEach(n => {
  console.log(n)  
});//원소를 각각 반복

array.map(n => console.log(n))// 원소를 각각 반복

console.log("인덱스 찾기",array.indexOf("1")) //없는 값은 -1로, 있는 값은 인덱스로 반환

filteringArr=array.filter(n=>n%2===0)//조건에 맞는 배열(객체)를 반환가능   
console.log("짝수로 필터링: ",filteringArr)

자바스크립트 심화

파이썬 메서드

//방법1
function method(first=1, second=2){
    console.log("변수값: ",first, second)
    return first+second
}
result=method(1,10)
console.log(result)

//방법2
method=(first=1, second=2)=>{
    console.log("변수값: ",first, second)
    return first+second
}
result=method(11,10)
console.log(result)

자바스크립트 클래스

class instanceClassParent{
    constructor(name){
        this.name=name //this로 인스턴스 변수 선언
        console.log(name)
    }//생성자
}//c#처럼 생성가능. 생성자를 constructor로 하기로 약속

class instanceClass extends instanceClassParent{
    constructor(name="기본파라메터"){
        super(name)//부모 생성자 명시적으로 호출 해야함
    }//생성자

    func() {
        console.log(this.name)
    }
}//extends로 상속 가능

new instanceClass().func() //c#처럼 new 로 선언

다중 상속 불가
자바처럼 extends로 상속

자바스크립트 익스포트 임포트

//익스포트 a.js
function sayHi(user) {
    console.log(`Hello, ${user}!`);
}
  
function sayBye(user) {
    console.log(`Bye, ${user}!`);
}
  
export {sayHi, sayBye}; // 두 함수를 내보냄

//익스포트 b.js
function sayGood(){
    console.log(`Good`);
}
export default sayGood; //하나만 내보냄

//익스포트 c.js
function sayBad(){
    console.log(`Bad`);
}
export.sayBad = sayBad;

//임포트 main.js
import * as say  from './a.js';// 여러개를 따로 받으므로 따로 따로 호출
import good from './b.js'; //하나만 받으므로 그 자체 취급

say.sayHi('John');
good();
say.sayBye('John');

//임포트 main2.js
const bad = require("./c.js")
bad.sayBad()

import 구문은 es6부터 지원되므로 package.json에 "type": "module” 를 추가
c.js에서 export 그 자체를 require("./c.js")로 불러오는 구조

자바스크립트 초중요 비동기

//옛날 방법1. 프로미스를 변수처럼 생성
//프로미스 생성만으로 실행된다. resolve는 성공, reject는 에러시에 사용
const myPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
        console.log("myPromise Call")
        resolve(1)
    }
       , 500) //0.5초 뒤에 결과값을 반환
})

myPromise.then(n => {
    console.log(n);
}).catch(error => {
    console.log(error);
})//결과값을 반환 받고 함수를 실행. 에러가 나면 캐치가 해결
//myPromise call->1

//옛날방법2. 함수로 생성
function promiseRecursion(n){
    return new Promise((resolve, reject) => {
       console.log("지금값은 ",n)
       resolve(++n)
       return n
    });
}
promiseRecursion(0).then(
    promiseRecursion
).then(
    promiseRecursion
).then(
    promiseRecursion
).catch(e=>{
    console.error(e)
})//반환값을 연속 비동기사용. 호출시 자동 사용
//지금값은 0->1->2->3 (1초간격으로)

//추천 async await방법
async function asyAwait(){
    console.log('안녕하세요!')
    await new Promise(resolve=> setTimeout(resolve, 1000))
    console.log('반갑습니다!')
    
}
async function useAsync(name){
    try {
        await asyAwait(); //await 로 기다릴수 있다. 함수밖 루프는 속행
                        //(함수밖도 await로 기다리지 않을때)
      } catch (e) {
        console.error(e);
      }finally{
        console.log(name,"종료")
        return name
        
      }
}

await useAsync("유저") //안녕하세요->1초후->반갑습니다
//await가 있으면 종료까지 기다리고. 없으면 실행시키도 멈추면 다음으로

자바스크립트를 쓰는 대표적인 이유
async await만은 꼭 알아둘것
await Promise.all([a,b,c]) //비동기 세개의 배열반환
await Promise.race([a,b,c]) //입력값중 하나 먼저온것만 반환. 셋다 실행은 됨

파이썬 요약

Sat, 07 Oct 2023 10:09:57 +0900

파이썬 요약

파이썬 기초

import math
import sys

class test:
    def __init__(self, arr):
        self.arr=arr
    def logArr(self):
        for i in self.arr:
            print(i)

inp = list(map(int,sys.stdin.readline().split()))
cls=test(inp)
cls.logArr()

파이썬 입출력

#입력 방법1
inp=input("값을 입력하세요") #값을 입력하지 않으면 빈 문자열

#방법2 단일 정수를 받을 때
import sys
inp = int(sys.stdin.readline())

#방법 3 여러 정수를 받을 때
import sys
inp = list(map(int,sys.stdin.readline().split()))
        #map클래스를 리스트 튜플 셋 딕셔너리 등 자동화 가능

#출력방법
print(inp)

파이썬 자료형

#변수 생성
x=30 # int형
y="30" # str형
z={"a": 1, "b": 2} # dict 형
type() # 출력값: <class 'dict'>

#자료형 변환 (파이썬은 자료형이 달라져도 변수에 대입 OK)
y=int(y) # int 형 30 이 출력,

대입 연산시(=) 값이 복사되는것

int	약 절대값 약 21억의 자연수(32비트)
float	유효자리 15의 약 절대값 10^308(64비트)
str	문자열
tuple	튜블
bool	참 거짓
그외	long(무한 자연수), complex, decimal(유효자리 넓은 정수), None(null)

대입 연산시(=) 주소가 복사되는것(복사시 같은 것을 가르키게 됨)

list	리스트 [1,2,3]
set	셋 {1,2,3}
dict	딕셔너리 {”a”:1,”b”:2,”c”:3}
class	클래스 class name(parent):
numpy, pandas	데이터 처리 라이브러리

파이썬 연산

a=10
b=4
result=0

#가감승제
result=a + b # 14
result=a - b # 6 
result=a * b # 40 
result=a / b # 2.5 (자료형 변환)
result=a // b # 2  (변환없이 버림)

#나머지 제곱
result=a%b # 2
result=a**b # 10^4

#문자열 연산
a="가"
b="나"
c=1
print(a+b) # 가나 (c는 자료형이 다르므로 안됨)
print(a,b,c)# 가나1

#비트 연산 (&,|,^,~) 왠만해선 사용하지 말것
result= a&b # 0b1010 0b100 0

#연산하고 대입
b+=a # b=b+a 와 동일 

#변수 삭제
del b # 이후 새 b를 생성하기 전까지 사용하면 에러

숫자형 끼리는 자동 형변환을 해줌
숫자형을 문자열로 자동으로 바꿔주진 못함

파이썬 조건문

# 동등비교
"1"==1#False 
[1]==1

1==1.0 #True
complex(real=1,imag=0)==1
1==1

#비교
1<1.1 #True 
1>1.1 #False
1<=1 #True 
1>=1 #True 

#if문
a=10
b=11
if a>b:
    print("a가 b보다 큽니다") #a가 클경우
elif a<b:
    print("b가 a보다 큽니다") #b가 클경우
else:
    print("같습니다") #같을 경우

자료형이 다르면 False,
숫자 자료형은 보통 형변환을 자동으로 해줌

파이썬 반복문

#0~9까지 출력하는 반복문

#while 문 
count = 0
while count < 10:
    print(count)
    count += 1

#for 문
for count in range(0, 10):
    print(count)

# 리스트,튜플 등의 반복
for i in [0,1,2,3,4,5,6,7,8,9]:
    print(i)

#리스트 튜플 등의 전체 반복
tuple(map(int,[0,1,2,3,4,5,6,7,8,9]))

#딕셔너리 반복
dic={'0': 0,
 '1': 1,
 '2': 2,
 '3': 3,
 '4': 4,
 '5': 5,
 '6': 6,
 '7': 7,
 '8': 8,
 '9': 9}
for key, value in dic.items():
        print("{}:{}".format(key,value))

break 구문을 사용해서 언제든지 반복문을 종료
continue 를 사용해서 반복문을 다음단계로 강제 진행

파이썬 문자열

#문자열 생성
mystr="  abcd efgh   "
mystr='  abcd efgh   '
mystr="""Hello, world!
안녕하세요.
Python입니다.""" # 여러줄인 경우
mystr=str(10)# '10' #형변환

#문자열 다루기 (기본적으로 원본에는 영향 없다)
mystr="  012345 가나다라  "
mystr+"결합된 문자"  # "  012345 가나다라  결합된 문자"
mystr.strip() # "012345 가나다라" #좌우 공백 제거
        #(입력값을 넣으면 넣은 값들 제거)
"ABCD".lower() # "abcd" (소문자화, 반대는 upper())
mystr.replace("012345","abcd") # "  abcd 가나다라  "
str.join(" ",["안녕","하세요","1234"]) # **'안녕 하세요 1234'**
mystr.find("5") # 7 #문자열을 찾아서 인덱스 반환(없으면 -1 반환)

#포맷팅
formating="문자열: {}".format("문자열 입니다")
formating="문자열: {1}, {0}".format("문자열 입니다", 100)
        #숫자도 형변환 해줌

파이썬 배열

[이 단원 요약] 이것만 외우면 된다!!

mylist=[1]
mylist.append(2)
mylist.pop()
print(mylist,len(mylist))

mytuple=(1)
print(mytuple)

mydic={"1":1}
mydic["2"]=2
mydic.pop("2")
print(mydic.items(),len(mydic))

myset={1}
myset.add(2)
myset.discard(2)
print(myset,len(myset))

파이썬 리스트

#리스트 생성
lis=[] # 빈 리스
lis=list() # 빈 리스트
lis=list(range(10)) # [0~9] 까지의 리스트

#레인지 생성
range(10)# [0,9) 레인지
range(0,10,2)# [0,9)의 2의 배수 레인지
list(range(10)) # [0,9) 리스트
tup(range(10)) # [0,9) 튜플

#리스트 비교(자료형이 같아야 한다)
lisa=[0]
lisb=[0]
lisa==lisb # True
lisa==0 # False

#리스트 
lisa+lisb #[0,0]
lisa*3 #[0,0,0]

#리스트 다루기
lis[0] #0 0 번째 요소
lis[-1] #9 뒤에서 1번째 요소
lis[0:5:2]# [0,2,4] [0,5)까지 1칸씩 뛰어서(슬라이스)

len(lis) #리스트의 길이 10 !!!!
lis.count(0) #0이 몇개 있는지 반환
lis.index(10) #입력값에 해당하는 값의 인덱스(없음 에러)
100 in lis #False 리스트에 값이 있는지 확인

#아래 메서드들은 모두 원본 리스트에 영향을 줌\
#중요한 메서드 append,pop, sort
lis[len(lis):]=[0]#맨 뒤에 0 추가
lis[len(lis):]=[1,2]#맨 뒤에 1,2 추가
lis.append(10)# 맨 뒤에 10 추가(중요) !!!!
lis.extend([11,12]) # 맨 뒤에 11,12 추가
lis.insert(0,100) # 0번째 인덱스에 100 추가(한칸씩 밀린다)
lis.remove(100) #입력값을 하나 제거(맨 앞부터, 한칸씩 밀림)
lis.pop() # 맨 뒤의 값 제거, 반환(중요) !!!!
lis.sort() # 정렬
lis.reverse() #역순
lis[0]=-1 # 0 인덱스에 -1 대입
lis.copy()#리스트를 카피함
                        #(단, 다차원 형태면 주소가 복사됨(주의))
lis.clear()#리스트를 비움

#리스트 컴프리헨션
mylis=[[0,1],[2,3],[4,5]]
newlis=[i+i for i in mylis if i[0]<4] 
        # [[0, 1, 0, 1], [2, 3, 2, 3]]

#다차원 리스트
lis=[[0,1],[2,3]]#[
                                        [0,1],
                                        [2,3]
                                    ]
lis[0][0] # 0
lis[0][0:1] # [0]
lis[0:1] # [[0,1]]

리스트, 튜플, 맵 모두 인덱스에 해당하는 원소가 없으면 에러발생

파이썬 튜플

#튜플 생성(리스트와 비슷함)
tup=() # 빈 리스
tup=tuple() # 빈 리스트
tup=(0, 1, 2)# [0~9] 까지의 리스트
tup=tuple(list())
tup=((0,1),(2,3))

#튜플 다루기
len(tup) #튜플의 길이
tup[0] #0 번째 요소
tup[0:1:1]#[0,1) 1간격으로 뽑은 튜플 

#튜플 비교(자료형이 같다면 같은것은 같게 취급)
tupa=(0,1)
tupb=(0,1)
lisa=[0,1]
tupa==tupb # True
tupa==lisa # False

#그외 메서드
#count(찾을값), index(찾을값) 찾을값 in (튜플)

파이썬 딕셔너리

#딕셔너리 생성
dic = {}
dic = dict()
dic = {"0": 1, "1": 2,"2":3} #문자열을 인덱스로 줄수 있다. 

#딕셔너리 다루기
dic["0"] # "0" 인덱스의 값 1
dic.get("0", 0) # 위와 동일, 디폴트 값을 줄 수 있다
dic["0"]= 0 # "0" 인덱스에 0 대입(없으면 추가)
dic.pop("0", 0) # 키 값을 반환하고 딕셔너리에서 없앤다.
        #(두번째 인자는 디폴트값)
del dic["1"] #"1" 인덱스 값을 제거
dic.items() #딕셔너리의 키 값 쌍을 모두 가져옴 [(키,값)]
dic.copy()#리스트를 카피함
                        #(단, 다차원 형태면 주소가 복사됨(주의))
dic.clear()#딕셔너리를 비움

#딕셔너리 반복
for key, value in dic.items():
    print("{}:{}".format(key,value))

파이썬 셋

#셋 생성
myset={1,2,3,1} #{1,2,3}

#셋 다루기
len(myset)
1 in myset # True

#셋 집합 연산(&,|,^}
{1,2,3} & {2,3,4} #{2,3}

파이썬 심화

파이썬 메서드

#기본적인 사용
def func(input1=1, input2=2):
    result= input1+input2 #result는 밖의 값
    return result #값을 반환
func(input1=10)

#위치인수
def func(*inputList):
    print(inputList)
func(1,2,3,4,5)

#키워드인수
def func(**inputDic):    
    print(list(inputDic.items()))
func(a=1,b=2)  

#클로저(범위)
x = 10    # 전역 변수
def foo():
    x=11
    print(x) # 11
foo()
print(x) # 10  (내부에서 대입하면 내부에 지역변수가 생긴다)
        (외부에는 영향을 못끼친다)

입력값에 디폴트 값을 줄 수 있다(예: input1 = 1 )
값 입력시 넣을 곳 이름을 지정 가능
위치인수(), 키워드(*) 매개변수는 디폴트 불가
재귀호출 역시 가능하다(다만 코테 이외에는 추천하지 않는다)
클로저 밖의 값을 쓸려면, nonlocal, global 을 써야한다.

파이썬 람다

def func(x):
    if x%2==0:
        return str(x)
    else:
        return x

#위 코드와 같은 기능을 하는 함다
func=(lambda x: str(x) if x % 2 == 0 else x)
func(2)

파이썬 클래스

#파이썬 클래스
class Lineage:
    def __init__(self):
        print("안녕하세요")
        
#상속 오버라이드
class MidClass(Lineage): #다중 상속 가능
    __rank="[브론즈]" #클래스 변수 (__를 붙이면 private)
    
    def __init__(self, user): #클래스 초기화 함수를 오버라이드
        super().__init__() #부모를 명시적으로 불러야 함
        self.user=user # 인스턴스 속성
        print("활용을 시작해 볼까요", MidClass.rank, self.user)
    
    def func(self): #self를 붙여야 인스턴스 함수가 됨
        MidClass.rank,
        print()
        
    @classmethod #클래스 메서드 생성
    def classFunc(cls): #self가 없음. cls가 있음
        print(cls.rank)
        
MidClass("가나다")
MidClass.classFunc()

파이썬 예외


try: #실행할 코드
    print("실행중")
        #raise Exception(에러메시지) #에러 발생사카
except Exception as e: #예외 발생시 코드
        print("에러 발생")
else: # 예외 발생 안할때 코드
    print("에러 비발생")
finally:
    print("반드시 실행")

파이썬 임포트

#방법 1
import sys # sys 패키지를 불러옴
inp = list(map(int,sys.stdin.readline().split()))

#방법 2
from sys import stdin # stdin 만 불러옴
inp = list(map(int,stdin.readline().split())) #sys를 안써도 됨

파이썬 익스포트

#파일 a.py
vari = 10
 
def func():
    print("파일 a의 함")
 
class cl:
    def __init__(self):
        print("파일 a의 클래스")

if __name__ == '__main__':
        func()
        cl()
        print(vari)

#파일 main
import 파일a

파이썬 파일 다루기

Fri, 06 Oct 2023 15:18:59 +0900

파이썬 파일 다루기

#방법 쓰기 1
file = open('hello.txt', 'w')
file.write('Hello, world!')
file.close()

#방법 쓰기 2
with open('hello.txt', 'w') as file:    
    file.write("안녕")

#방법 한번에 많이 쓰기
with open('hello.txt', 'w') as file:    
    file.writelines(['안녕하세요.\n', '파이썬\n', '코딩 도장입니다.\n'])

#방법 읽기 줄을 나눠서 읽기
with open('hello.txt', 'r') as file: 
    lines = file.readlines() #배열 반환
    print(lines)

#방법 읽기 모두 한번에 읽기
with open('hello.txt', 'r') as file: 
    line = file.read()
    print(line)

#방법 추가하기 
with open('hello.txt', 'a+') as file: 
    print(file.read())#커서가 맨 뒤. 공백 출력
    file.write("끝")

쓰기 모드로 열면 적혀 있던 내용 모두 삭제된다.(+를 붙이던 말던)
+를 붙이면 읽고 쓸수 있게된다.(w는 어차피 삭제되므로 의미 없다)
w r로 시작하면 포인터가 맨 앞에서, a로 시작하면 뒤에서 시작한다
wb, ab, rb 등 바이너리를 저장하는 방법도 있다.