반응형

파이썬(python)은 복잡한 코드도 간단하게 코딩할 수 있는 정말 좋은 프로그램 언어입니다.

파이썬을 사용하면 인터 프린터 형태로 컴파일되기 때문에 한 개의 변수 형태로 많이 사용합니다.

간단한 코드는 다양한 변수를 사용해소 코드가 가능하지만, 조금씩 변수가 증가하면 매우 복잡해지겠죠.

먼저 간단하게 이름, 주소, 전화 번호를 출력하는 프로그램을 작성해보겠습니다.

def printInfo():
    name = "365talk"
    address = "seoul"
    phone = "010-1234-5678"

    print(f"name : {name}")
    print(f"address : {address}")
    print(f"phone : {phone} ")

name, address, phone 변수를 선언 후 정보를 저장합니다.

print() 함수를 사용해서 변수를 출력합니다.

name, address, phone 모든 내용을 한 번에 확인할 수 있습니다.

그럼 이번에는 변수 한개를 더 추가해보겠습니다.

email 변수를 사용해서 mail 정보를 입력합니다.

def printInfo():
    name = "365talk"
    address = "seoul"
    phone = "010-1234-5678"
    email = "365talk@gmail.com"

    print(f"name : {name}")
    print(f"address : {address}")
    print(f"phone : {phone} ")
    print(f"email : {email}")

email 변수 추가와 동시에 출력하기 위한 print() 정보도 추가합니다.

출력 결과도 동일하게 print()함수를 사용해서 출력할 수 있습니다.

간단한 변수를 여러개 사용할 경우 추가적으로 변수를 선언하면 됩니다.

하지만 변수 개수가 증가할수록 코드 길이가 길어지면서 관리하기가 점점 힘들어집니다.

변수를 혹 배열로 사용할 경우는 변수 관리는 더욱더 복잡해집니다.

 

클래스 구조

파이썬(python)은 이러한 관리 문제를 해결하기 위해서 클래스(Class)를 사용할 수 있습니다.

클래스(Class)는 간단하게 말하면 변수 그룹, 함수 그룹을 모두 하나의 그룹으로 관리할 수 있는 집합 객체입니다.

클래스(Class)를 사용하면 객체를 복사할 수 있기 때문에 배열에 사용하기도 매우 편리합니다.

파이썬(python)에서는 함수와 동일하게 class를 단어를 앞쪽에 선언해서 클래스(Class)를 선언할 수 있습니다.

class DataInfo:
    pass


info = DataInfo()
print(info)
print(type(info))

class DataInfo 객체를 생성했습니다.

DataInfo 객체를 생성하고 출력하면 객체가 생성된 주소 정보를 확인할 수 있습니다.

DataInfo 객체 시작 주소 정보는 0x00001FDA308F7C0 입니다.

DataInfo 클래스에 추가되는 함수, 변수 모두 주소 이후 연속으로 메모리에 할당됩니다.

type() 함수를 사용하면 생성한 클래스(Class) 타입도 확인이 가능합니다.

 

클래스 만들기

처음에 코딩한 변수 출력 부분을 클래스(Class)로 변경해보겠습니다.

class DataInfo:
    def set_DataInfo(self, name, address, phone, email):
        self.name = name
        self.address = address
        self.phone = phone
        self.email = email
    def print(self):
        print(f"print -----------------")
        print(f"name : {self.name}")
        print(f"address : {self.address}")
        print(f"phone : {self.phone} ")
        print(f"email : {self.email}")
        print(f"print END--------------")

파이썬(python)에서 클래스(Class)를 사용하기 위해서는 메서드앞에 self를 반드시 추가해야 합니다.

self는 클래스(Class)에 생성되는 모든 메서드에 포함되어야 합니다.

set_DataInfo() 메서드 사용 시 self에 name, address, phone, email 변수를 선언하고 인자를 저장합니다.

self에 저장된 변수는 print() 함수를 이용해서 각 변수에 접근 후 출력이 가능합니다.

name = "365talk"
address = "seoul"
phone = "010-1234-5678"
email = "365talk@gmail.com"

info = DataInfo()
info.set_DataInfo(name, address, phone, email)
info.print()

info 변수에 DataInfo() 클래스를 할당합니다.

set_DataInfo() 메서드를 사용해서 name, address, phone, email 정보를 저장할 수 있습니다.

클래스(Class) 객체 선언 후 간단하게 print() 메소드를 사용해서 모든 정보를 출력할 수 있습니다.

파이썬(phthon)에서 클래스(Class)를 사용하게 되면 모든 메서드에 self 인자를 무조건 처음에 사용해야 합니다.

self를 사용하지 않으면 컴파일 과정에서 오류가 발생합니다.

파이썬(phthon)에 사용되는 self 인자는 클래스(Class) 내부 인스턴스 객체로 초기 설정값을 저장하고 인스턴스 형태로 접근이 가능합니다.

즉 인스턴스 형태 메서드를 사용하던, 클래스 형태 메서드를 사용하던 모두 하나의 주소 정보에 접근합니다.

조금 어려운 부분이지만, 그냥 간단하게 객체를 관리하는 집주인이라고 생각하시면 됩니다.

 

클래스 초기화 __init__ 메서드

파이썬(phthon) 클래스(Class)에서도 생성자를 사용한 초기화가 가능합니다.

class DataInfo:
    def __init__(self, id):
        self.id = id
        print("Class Init")
    def set_DataInfo(self, name, address, phone, email):
        self.name = name
        self.address = address
        self.phone = phone
        self.email = email
    def print(self):
        print(f"print -----------------")
        print(f"name : {self.name}")
        print(f"address : {self.address}")
        print(f"phone : {self.phone} ")
        print(f"email : {self.email}")
        print(f"id : {self.id}")
        print(f"print END--------------")

생성된 클래스(Class)에서 __init___ 메서드를 사용해서 초기화가 가능합니다.

__init__ 메서드는 객체가 처음 생성되는 시점에 무조건 호출됩니다.

DataInfo 객체를 선언하는 시점에 __init__에 코딩한 print() 함수가 호출되는 것을 확인할 수 있습니다.

파이썬(python) 클래스(Class)에 미리 선언된 메서드는 "__이름__" 형태로 선언되어 있습니다.

파이참을 사용할 경우 메서드를 바로 확인할 수 있기 때문에 다양한 메서드를 확인해보세요.

파이썬(python) 클래스(Class)는 다양한 API 객체로 배포되기 때문에 꼭 알아야 하는 개념입니다.

클래스(Class) 사용 개념이 없을 경우 크롤링, 주식 API 등 복잡한 코드에 접근하기 어렵습니다.

오늘도 열심히 파이썬(Python) 공부하세요.

감사합니다.

 

반응형
반응형

파이썬(python)에서 사용할 수 있는 팁 러닝 라이브러리 파이토치(PyTorch)는 팁 러닝에서 가장 많이 사용되는

신경망(Neural Networks)을 간편하게 변형하면서 활용이 가능합니다.

신경망(Nural Networks)은 피드 포인트 네트워크가 여러개의 레이어를 차례로 통과시킨 다음 마지막으로 출력을 반환하는 기술입니다.

학습 가능한 파라미터 및 가중치를 적용하여 입력 데이터 세트를 반복하면서 손실 계산 후 보정을 거쳐 네트워크의 가중치를 업데이트합니다.

파이토치(PyTorch)는 신경망(Nural Networks) 데이터에 대한 작업을 수행할 수 있는 계층, 모델을 지원합니다.

torch.nn 네임스페이스를 사용해서 신경 네트워크를 구축에 필요한 빌링 블록을 제공합니다.

신경망(Nural Networks)은 CPU 활용보다는 GPU 모델로 사용하는 것을 권장합니다.

GPU를 사용하기 위해서 Torch.cuda 설치 여부를 확인합니다.

evice = 'cuda' if torch.cuda.is_available() else 'cpu'
    print('Using {} device'.format(device))

전 아직 cuda 설치 전이기 때문에 cpu만 사용이 가능합니다.

 

신경망(Nural Nwtworks)를 사용하기 위해서 서브 클래싱을 통한 nn.Module 계층을 초기화가 필요합니다.

def CheckDevice():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print('Using {} device'.format(device))

    model = NeuralNetwork().to(device)
    print(model)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
            nn.ReLU()
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

nn.Module 하위 클래스는 forward 메서드의 입력 데이터에 대한 작업을 구현했습니다.

클래스를 사용한 인스턴스를 만들고 device 정보를 출력했습니다.

__init__에 정의된 정보가 device에 저장되어 출력됩니다.

forward는 백그라운드 작업으로 진행되기 때문에 model.forward()를 직접 호출할 필요가 없습니다.

X = torch.rand(1, 28, 28, device=device)
    logits = model(X)
    pred_probab = nn.Softmax(dim=1)(logits)
    y_pred = pred_probab.argmax(1)
    print(f"Predicted class: {y_pred}")

정의된 클래스에 원시 예측 값이 있는 10차원 텐서를 설정하기 위해서, nn.Softmax 모듈의 인스턴스를 사용해서 예측 확률을 확인합니다.

 

파이 토치 신경망 모델 레이어

모델의 레이어를 구분하기 위해서 간단한 28 x 28인 이미지 3개의 샘플을 저장합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

3개의  28 x 28 이미지를 확인할 수 있습니다.

nn.Flatten 레이어를 초기화하여 각 2D 28 x 28 이미지를 784 픽셀 값의 연속 배열로 변환합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

3개의 배열이 784 연속 배열로 변경되었습니다.

nn.Linear은 선형 레이어를 구현할 수 있습니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

    layer1 = nn.Linear(in_features=28 * 28, out_features=20)
    hidden1 = layer1(flat_image)
    print(hidden1.size())

hidden1 선형 레이어를 생성했습니다.

nn.ReLU은 입력과 출력 사이에 복잡한 매핑 비선형성을 사용할 수 있습니다.

선형 레이어 사이에 nn.ReLU를 사용해서 비선형성을 실행합니다.

def Modellayer():
    input_image = torch.rand(3, 28, 28)
    print(input_image.size())

    flatten = nn.Flatten()
    flat_image = flatten(input_image)
    print(flat_image.size())

    layer1 = nn.Linear(in_features=28 * 28, out_features=20)
    hidden1 = layer1(flat_image)
    print(hidden1.size())

    print(f"Before ReLU: {hidden1}\n\n")
    hidden1 = nn.ReLU()(hidden1)
    print(f"After ReLU: {hidden1}")

nn.Sequential은 모듈의 순서가 지정된 컨테이너를 생성할 수 있습니다.

정의된 데이터와 동일한 순서로 모든 모듈에 전달됩니다.

순차 컨테이너는 빠른 네트워크를 구성하기 위해서 사용됩니다.

seq_modules = nn.Sequential(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Linear(20, 10)
    )
    input_image = torch.rand(3,28,28)
    logits = seq_modules(input_image)
    print(logits)

nn.Softmax는 원시 값인 로짓을 반환합니다.

로짓은 각 클래스에 대한 모델의 확률을 나타내는 값[0,1]으로 지정됩니다.

매개변수는 값의 합이 1이 되어야 차원을 나타냅니다.

    softmax = nn.Softmax(dim=1)
    pred_probab = softmax(logits)

    print(pred_probab)

 

파이 토치 신경망 모데 매개변수

신경망에 사용되는 레이어는 매개변수화되어 있어 접근이 가능합니다.

서브 클래싱 된 nn.Module은 객체 내부에 정의된 모든 필드를 자동으로 추적하고 모델 parameters() 또는 named_parameters() 메서드를 사용하여 모든 매개변수에 액세스 할 수 있습니다.

    print("Model structure: ", model, "\n\n")

    for name, param in model.named_parameters():
        print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

처음 구현한 model에 추가 코드를 적용해서 매개변수를 확인했습니다.

파이토치(PyTorch) 신경망(Nural Networks)은 복잡한 정보를 클래스를 사용해서 다양한 구성이 가능합니다.

모델 레이어를 사용해서 가중치를 높이면서 정확한 데이터를 확보할 수 있습니다.

감사합니다.

반응형
반응형

파이썬(python)에서 사용할 수 있는 파이토치(PyTorch)는 간단하게 딥 러닝을 구현할 수 있는 좋은 라이브러리입니다.

오늘은 파이토치(PyTorch)에서 딥 러닝에서 많이 사용되는 데이터 정보를 관리할 수 있는 데이터 세트(Dataset) 및 데이터 로더(Dataloader)에 대해서 알아보겠습니다.

배열과 같은 데이터 정보는 단순한 형태를 사용하기 편리하지만, 정보가 증가하면 유지 관리하기 어렵습니다.

데이터 세트(Dataset)는 가독성을 높이면서 데이터를 쉽게 액세스 할 수 있도록 도와줍니다.

파이토치(PyTorch) 데이터 세트(Dataset)를 사용하기 위해서는 torchvision 패키지를 인스톨해야 합니다.

torchvision 패키지 인스톨을 진행하면 java SDK를 업데이트합니다.

설치 화면에서 설치를 클릭해주세요.

 

데이터 세트(Dataset)는 기본적으로 사용할 수 있는 데이터 정보를 다운로드하여 저장할 수 있습니다.

training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )

FashionMNIST 메서드를 사용해서 이미지 정보를 training_data에 저장합니다.

FashionMNIST 메서드 root는 테스트 데이터 저장 경로입니다.

train은 데이터 세트 지정 정보입니다.

download는 데이터 다운로드 설정 정보입니다.

transform은 레이블 변환 지정입니다.

코드를 실행하면 출력 창에서 이미지 다운로드 화면을 확인할 수 있습니다.

training_data에 저장된 데이터 세트(Dataset) 정보를 출력해보겠습니다.

def showimage():
    training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )
    labels_map = {
        0: "T-Shirt",
        1: "Trouser",
        2: "Pullover",
        3: "Dress",
        4: "Coat",
        5: "Sandal",
        6: "Shirt",
        7: "Sneaker",
        8: "Bag",
        9: "Ankle Boot",
    }
    figure = plt.figure(figsize=(8, 8))
    cols, rows = 3, 3
    for i in range(1, cols * rows + 1):
        sample_idx = torch.randint(len(training_data), size=(1,)).item()
        img, label = training_data[sample_idx]
        figure.add_subplot(rows, cols, i)
        plt.title(labels_map[label])
        plt.axis("off")
        plt.imshow(img.squeeze(), cmap="gray")
    plt.show()

배열에 저장된 9개의 이미지 정보를 기준으로 데이터 세트(Dataset)에서 이미지를 확인 후 matplotlib 패키지 plt를 사용해서 이미지로 출력합니다.

출력 결과 9개의 이미지가 순차적으로 출력됩니다.

데이터 세트(Dataset)는 예제 정보를 다운로드할 수 있어 간단하게 이미지 관련 딥러닝을 실행할 수 있습니다.

 

데이터 세트(Dataset)는 배열처럼 사용하는 방법보다는 클래스로 구현하면 더욱더 쉽게 사용할 수 있습니다.

기복적으로 __init__, __len__, __getitem__ 세 가지를 함수를 추가 구현할 수 있습니다.

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

클래스에 사용할 수 있는 기본 함수는 자동 생성되기 때문에 필요한 부분을 추가 구현할 수 있습니다.

__init__ 함수는 데이터 세트(Dataset) 객체를 인스턴스화 할 때 한번 실행됩니다.

기본적으로 초기화에 필요한 정보를 입력할 수 있습니다.

__len__ 함수는 데이터 세트(Dataset) 객체 개수를 반환합니다.

__getitem__ 함수는 선택한 인덱스의 데이터 정보를 로드하여 반환합니다.

변환 정보는 처음 배운 텐서로 변환되어 사용할 수 있습니다.

 

데이터 로더(Dataloader)는 데이터 세트 클래스의 확장 형태로 간단하게 데이터 세트를 접근할 수 있습니다.

간단하게 말해서 데이터 로더(Dataloader)는 데이터 세트의 복잡성을 간단한 API로 추상화한 클래스입니다.

데이터 로더(Dataloader)를 사용하기 위해서 torch.utils.data 패키지를 설치합니다.

def DataLoaderEx():
    training_data = datasets.FashionMNIST(
        root="data",
        train=True,
        download=True,
        transform=ToTensor()
    )
    train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)

    train_features, train_labels = next(iter(train_dataloader))
    print(f"Feature batch shape: {train_features.size()}")
    print(f"Labels batch shape: {train_labels.size()}")
    img = train_features[1].squeeze()
    label = train_labels[1]
    plt.imshow(img, cmap="gray")
    plt.show()
    print(f"Label: {label}")

데이터 로더(Dataloader)를 로드된 데이터 세트를 생성자에 대입만 하면 바로 사용이 가능합니다.

데이터 로더(Dataloader)는 배열 사용과 동일하게 인덱스를 입력하면 바로 이미지를 확인할 수 있습니다.

데이터 로더(Dataloader) 인덱스 정보를 변경하면 다음 이미지를 확인할 수 있습니다.

파이토치(PyTorch)  데이터 세트(Dataset) 및 데이터 로더(Dataloader)는 이미지 정보와 같은 복잡한 정보를 누구가 쉽게 사용할 수 있도록 구현된 객체입니다.

기본 정보를 다운로드하여 객체에 저장하기 때문에 별도 이미지를 찾을 필요가 없습니다.

딥 러닝은 코드 보다도 알고리즘이 중요하기 때문에 코드를 매우 단순화할 수 있는 좋은 패키지라고 생각됩니다.

감사합니다.

https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html

 

Quickstart — PyTorch Tutorials 1.9.0+cu102 documentation

Note Click here to download the full example code Learn the Basics || Quickstart || Tensors || Datasets & DataLoaders || Transforms || Build Model || Autograd || Optimization || Save & Load Model Quickstart This section runs through the API for common task

pytorch.org

 

반응형
반응형

오늘은 지난 시간에 배운 matplotlib를 활용해서 여러 개의 파이썬 그래프를 그려보겠습니다.

파이썬 그래프는 다양한 타입이 있지만 오늘은 가장 많이 사용하는 막대그래프, 수평 막대그래프,

산점도 그래프, 히스토리 그래프, 차트 그래프를 알아보겠습니다.

첫 번째 파이썬 그래프는 막대그래프입니다.

matplotlib에서 bar() 함수를 사용해서 막대그래프를 확인할 수 있습니다.

def bar():
    xpos = np.arange(4)
    years = ["2018", "2019", "2020", "2021"]
    values = [200,300,400,500]

    plt.bar(xpos, values, align='edge', color='red')
    plt.xticks(xpos, years)
    plt.xlabel("years")
    plt.ylabel("trading volume")
    plt.show()

bar() 함수를 선언해서 파이썬 막대 그래프 코드를 입력하겠습니다.

xpos 배열을 사용해서 x축 정보를 저장합니다.

x축, y축 개수가 다를 경우 오류가 발생합니다. 정확한 개수를 확인해주세요.values 배열을 사용해서 y축 정보를 저장합니다.bar() 함수에, x, y 축 정보를 입력하고 기본 옵션을 지정합니다.

출력 결과 RED 색상 파이썬 막대그래프를 확인할 수 있습니다.

일반적으로 많이 사용되는 내용이기 때문에 그래프가 어떻게 구성되는지 감을 잡아주시면 됩니다.

 

두 번째는 파이썬 수평 막대 그래프를 알아보겠습니다.

matplotlib 패키지에서 barh함수를 사용해서 출력할 수 있습니다.

def barh():
    ypos = np.arange(4)
    years = ["2018", "2019", "2020", "2021"]
    values = [200, 300, 400, 500]
    plt.barh(ypos, values, tick_label=years)
    plt.ylabel("trading volume")
    plt.show()

barh 함수는 y축을 기준으로 정보가 동일해야 합니다.

tick_label 파라미터를 사용해서 y축 타이틀을 설정할 수 있습니다.

4개의 파이썬 수평 막대 그래프를 확인할 수 있습니다.

 

세 번째는 파이썬 산점도 그래프를 알아보겠습니다.

산점도 그래프는 x, y축 좌표에 데이터를 점으로 출력하는 그래프입니다.

분포도 사용 시 많이 사용되는 그래프입니다.

matplotlib 패키지에서 scatter() 함수를 사용해서 그래프를 그릴 수 있습니다.

def scatter():
    np.random.seed(19488045)

    N = 70
    xpos = np.random.rand(N)
    ypos = np.random.rand(N)
    colors = np.random.rand(N)
    area = ( 30 * np.random.rand(N))**2

    plt.scatter(xpos,ypos, s=area, c=colors, alpha=0.5)
    plt.show()

seed를 사용해서 랜덤 함수를 생성합니다.

seed() 함수는 0 ~ 4294967295 사이의 정수를 사용합니다.

random() 함수를 사용해서 설정된 값에 오차 범위를 지정합니다.

x , y 좌표에 70개의 난수 그래프가 출력됩니다.

투명도를 0.5로 지정해서 겹치는 부분까지 확인이 가능합니다.

 

네 번째는 파이썬 히스토리 그래프를 알아보겠습니다.

히스토리 그래프는 많은 데이터를 한눈에 보기에 좋은 그래프입니다.

구간별로 겹치지 않아 주식과 같은 차트 정보에 많이 사용되는 그래프입니다.

matplotlib에서 hist() 함수를 사용하면 히스토리 그래프를 사용할 수 있습니다.

def hist():
    apos = 2.0 * np.random.rand(10000) - 1.0
    bpos = np.random.standard_normal(10000)
    cpos = 20.0 * np.random.rand(5000) - 10.0
    dpos = 20.0 * np.random.rand(2000) - 10.0

    plt.hist(apos, bins=100, density=True, alpha=0.7, histtype='step')
    plt.hist(bpos, bins=50, density=True, alpha=0.5, histtype='stepfilled')
    plt.hist(cpos, bins=100, density=True, alpha=0.9, histtype='step')
    plt.hist(dpos, bins=50, density=True, alpha=0.5, histtype='stepfilled')
    plt.show()

파이썬 히스토리 그래프는 random() 함수를 사용해서 다양한 정보를 저장할 경우 균일한 편차를 주어야 여러 개의 그래프를 비교할 수 있습니다.

편차가 다를 경우 그래프가 이동하기 때문에 전체 그래프가 작아집니다.

histtype에서 step은 막대 내부가 비어 있는 상태입니다,

stepfilled는 막대 내부가 채워진 상태입니다.

출력 결과 4개의 그래프가 다양한 형태로 출력되는 것을 확인할 수 있습니다.

 

마지막으로 파이썬 차트 그래프를 알아보겠습니다.

차트 그래프는 matplotlib에서 pie() 함수를 사용해서 출력할 수 있습니다.

def pie():
    pos = [24, 56,12,34]
    labels = ['pos1', 'pos2', 'pos3', 'pos4']

    plt.pie(pos,labels=labels, autopct='%.1f%%', startangle=260, counterclock=False, shadow=True)

    plt.show()

pos를 사용해서 전체 개수를 지정하고, labels로 타이틀을 설정할 수 있습니다.

autopct 파라미터를 사용해서 내부 출력 타입을 지정할 수 있습니다.

차트 그래프는 부채꼴의 중심각 비율에 비례하게 출력됩니다.

shadow 파리 미터를 사용해서 외각 그림자를 사용할 수 있습니다. 

 파이썬 차트 그래프는 전체 분포도를 확인할 수 있는 편리한 그래프입니다.

파이썬은 다양한 크롤링을 사용해서 그래프를 사용하는 코드가 많습니다.

간단한 함수를 사용해서  파이썬 그래프를 사용할 수 있어 초보자도 쉽게 차트 분석이 가능합니다.

위 5개의 그래프만 잘 사용해도 크롤링한 정보를 출력하기에는 부족함이 없어 보입니다.

감사합니다.

#파이썬 #그래프 #그래프타입 #python

반응형
반응형

오늘은 파이썬(python)을 사용해서 폴더 하위 파일 이름을 한 번에 변경해보겠습니다.

C++을 사용하면 코드가 많아지지만 파이썬(python)은 정말 간단하게 구현 가능합니다.

폴더 하위 파일에 특정 단어가 중복되는 경우가 있습니다.

몇개 파일이라면 이름 변경은 매우 간단한 일입니다.

하지만 폴더 및 파일 개수가 많이 지면 일일이 모두 변경하기 쉽지 않습니다.

같은 단어 위치가 동일하다면 코드를 사용해서 변경이 가능합니다.

def DirCheck( path ):
    file_list = os.listdir(path)
    for name in file_list:
        newpath = os.path.join(path,name)
        #print("path:" + newpath)
        if os.path.isfile(newpath):
            print(name + ":파일")
            FileRename(name, newpath, path )
        elif os.path.isdir(newpath):
            print("폴더 시작")
            DirCheck(newpath)
            print("폴더 확인")
        else:
            print(name + ":아무것도아님")

파일을 변경하기 전에 폴더가 중복으로 존재할 수 있어 폴더를 먼저 확인하는 함수를 작성했습니다.

재귀 호출을 사용해서 파일과 폴더를 구분합니다.

os.listdir() 함수를 사용하면 폴더 경로 하위 파일 정보를 확인할 수 있습니다.

처음 경로를 확인하기 위해서 경로를 newpath에 저장합니다.

os.path.join()을 사용하면 폴더 경로와 파일 이름을 합성하여 신규 경로를 생성합니다.

os.path.isfile() 함수를 사용해서 파일을 확인합니다.

파일일 경우는 fileRename() 함수를 사용해서 파일 이름 변경을 실행합니다.

os.path.isdir() 함수를 사용해서 폴더를 확인합니다.

폴더일 경우 재귀 함수 호출로 폴더를 재 검색하게 합니다.

def FileRename( name, bepath, afpath ):
    replaceword = " - Once"
    newName = str(name)
    newName = newName.replace(replaceword,"")
    os.rename(bepath, afpath + "/" + newName)
    print(newName)

FileRename() 함수는 replaceword에 설정된 문자열을 변경하고 경로에 저장합니다.

replace() 함수를 사용하면 특정 문자열을 변경할 수 있습니다.

os.rename() 함수를 사용해서 기존 경로 파일 정보를 신규 정보로 변경합니다.

path_dir = R'D:\Once - 원스 OST'
DirCheck(path_dir)

상위 경로를 설정 후 DirCheck() 함수를 사용하면 하위 폴더를 검색하고 파일 이름에서 "- Once"를 공백으로 변경합니다.

출력 결과 입니다.

처음 파일을 검색하고 이름을 변경한 내용을 확인할 수 있습니다.

폴더 확인 결과 정상적으로 파일 이름이 한 번에 모두 변경되었습니다.

파이썬(python)은 간단한 코드를 사용해서 반복적인 작업을 간단하게 수행할 수 있습니다.

폴더 및 파일 접근은 매우 중요한 내용이기 때문에 꼭 확인해주세요.

감사합니다.

반응형
반응형

오늘은 파이썬(python)에서 matplotlib을 사용한 차트 그리기를 알아보겠습니다.

파이썬(python) 차트를 그리기 위해서 다양한 패키지를 사용할 수 있습니다.

matplotlib 패키지는 간단하면서 다양한 차트를 출력할 수 있습니다.

파이썬(python) 차트를 그리기 위해서 패키지를 선언해줍니다.

import matplotlib.pyplot as plt
import numpy as np

pip install matplotlib를 사용해서 패키지를 설치해주세요.

파이참을 사용할 경우 세팅에서 패키지를 검색 후 인스톨하면 됩니다.

정상적으로 인스톨되면 리스트에서 "maplotlib"를 확인할 수 있습니다.

기본적으로 차트는 x,y 좌표 정보가 필요합니다.

이번 시간에는 일반적인 차트가 아닌 로또 번호에 따른 카운트를 확인해보겠습니다.

먼저 x, y에 사용할 로또 번호 정보를 저장합니다.

    NumberInfoCount = list()
    NumberXInfo = list()
    for i in range(45):
         NumberInfoCount.append(0)
         NumberXInfo.append(i + 1)

리스트, 배열 모두 파이썬 차트에 적용할 수 있습니다.

로또 번호는 45개 이기 때문에 45개 배열을 생성합니다.

NumberInfoCount는 y 측 value로 사용하겠습니다.

NumberXInfo는 x 측으로 1 ~ 45 번호를 적용하겠습니다.

지난 시간에 작성한 코드를 변경했습니다.

https://believecom.tistory.com/732

 

[python] 파이썬 엑셀을 활용한 로또 회차 정리하기

오늘은 파이썬(python)을 사용해서 엑셀파일을 사용해보겠습니다. 엑셀 파일은 다양한 정보를 순차적으로 정리할 수 있어 빅데이터 활용에 좋습니다. 엑셀 파일을 그냥 활용하기는 지루하니까 오

believecom.tistory.com

위 내용을 참고해주세요.

    for i in range(len(revNumbers[0])):
        line = ""
        for j in range(len(revNumbers)):
            value = int(revNumbers[j][i])
            line += str(value) + ","
            NumberInfoCount[value-1] = int(NumberInfoCount[value-1]) + 1
        print(str(i + 1) + "회차:" + line )

    print(NumberInfoCount)

1부터 45번호까지 루프를 확인하며 저장된 당첨 정보를 각 번호에 카운트하여 저장하는 로직입니다.

출력 결과 1부터 45번까지 카운트가 계산되어 배열이 저장됩니다.

이제 파이썬 차트에 사용할 x, y 모든 정보가 생성되었습니다.

    x = np.arange(45)
    plt.bar(x,NumberInfoCount)
    plt.xticks(x, NumberXInfo)
    plt.show()

np.arange()를 사용해서 파이썬 차트 x 정보를 저장합니다.

bar() 함수를 사용해서 x 측 정보를 저장합니다.

마지막으로 xticks() 함수를 사용해서 y 측 정보를 저장합니다.

show() 함수를 사용해서 파이썬 차트를 출력합니다.

출력 결과 1부터 45번까지 당첨된 횟수를 모두 확인할 수 있습니다.

966회 차 기준으로 43 번호가 가장 많이 당첨되었습니다.

파이썬(python) 차트는 4줄 코딩으로 바로 출력이 가능합니다.

일반적인 언어에서는 차트하나 개발하기가 정말 어렵지만, 파이썬(python)에서는 손쉽게 출력됩니다.

다음 시간에는 matplotlib를 이용한 다양한 차트를 알아보겠습니다.

감사합니다.

 

반응형
반응형

오늘은 파이썬(python)을 사용해서 엑셀파일을 사용해보겠습니다.

엑셀 파일은 다양한 정보를 순차적으로 정리할 수 있어 빅데이터 활용에 좋습니다.

엑셀 파일을 그냥 활용하기는 지루하니까 오늘은 로드 회차를 정리해보겠습니다.

파이썬(python)에서 엑셀 파일을 사용하기 위해서는 pandas, xlrd 패키지를 설치해야 합니다.

pip 명령어를 사용해서 2개 패키지를 모두 인스톨해주세요.

import pandas as pd
import xlrd

설치 후 import를 사용하면 오류가 발생합니다.

xlrd 패키지도 설치하라고 합니다.

pip 기능을 사용해서 xlrd를 설치하면 아래 오류가 다시 발생합니다.

파이참을 사용할 경우 pip 명령어로 패키지를 설치해도 다시 파이참에서 설정이 필요합니다.

세팅에서 설치된 항목을 확인할 수 있습니다.

"File" -> "Settings" -> "project" 메뉴에서 패키지를 재 설치할 수 있습니다.

오류 발생 시 필요한 패키지를 계속 설치하면 import가 정상적으로 동작합니다.

그럼 이젠 로또 정보가 저장된 엑셀파일을 다운로드해야 합니다.

https://www.dhlottery.co.kr/gameResult.do?method=byWin&wiselog=C_A_1_2 

 

로또6/45 - 회차별 당첨번호

967회 당첨결과 (2021년 06월 12일 추첨) 당첨번호 1 6 13 37 38 40 967회 순위별 등위별 총 당첨금액, 당첨게임 수, 1게임당 당첨금액, 당첨기준, 비고 안내 순위 등위별 총 당첨금액 당첨게임 수 1게임당

www.dhlottery.co.kr

사이트로 이동해서 하단에 있는 "엑셀다운로드" 버튼을 클릭하면 엑셀파일을 다운로드할 수 있습니다.

먼저 엑셀 파일을 로드해보겠습니다.

Location = "D:/"
FileName = "excel.xlsx"
data_pd = pd.read_excel("d:\excel.xlsx",header=None, index_col=None, names=None)

pd.read_excel 함수를 사용해서 파일을 로드합니다.

data_pd에 배열로 엑셀 정보가 저장됩니다.

엑셀 파일을 확인하면 추출하기 위한 당첨번호가 맨 뒤쪽에 있는 것을 확인할 수 있습니다.

이번에는 전체 배열에서 당첨번호만 배열에 저장하겠습니다.

RowShift = 3
NumberCount = len(data_pd[13]) - RowShift
numbers = [data_pd[13], data_pd[14], data_pd[15], data_pd[16], data_pd[17], data_pd[18], data_pd[19]]

 엑셀파일 인덱스 단위로 배열이 저장되기 때문에 RowShift를 사용해서 이동이 필요합니다.

data_pd에 저장된 보너스 번호까지 총 7개를 numbers에 저장합니다.

revNumbers = []
    for i in range(7):
       rows = []
       for j in range(NumberCount):
           j += RowShift
           rows.append(int(numbers[i][j]))
       revNumbers.append(list(reversed(rows)))
       print(revNumbers)

for 문을 사용해서 엑셀파일 정보를 revNumbers에 저장합니다.

그런데 문제가 있습니다.

엑셀파일은 로또 회차가 아래쪽부터입니다.

그럼 로드된 번호 순서를 reversed를 사용해서 반대로 변경합니다.

list로 변경 후 다시 배열에 저장하면 1회 차부터 확인이 가능합니다.

엑셀 파일 회차가 아래쪽부터 시작이기 때문에 조금 번거로운 작업이 필요합니다.

이젠 저장된 revNumbers 배열을 사용해서 전체 로또 회차 정보를 출력해보겠습니다.

  for i in range(len(revNumbers[0])):
        line = ""
        for j in range(len(revNumbers)):
            line += str(revNumbers[j][i]) + ","
        print(str(i + 1) + "회차:" + line )

revNumbers에 저장된 정보는 배열 형태로 저장되어 있기 때문에 이중 배열 출력을 사용했습니다.

처음 전체 배열을 확인하면서 저장된 7개 번호를 재확인하는 구조입니다.

출력하면 1 ~ 최종 회차까지 확인이 가능합니다.

Location = "D:/"
    FileName = "excel.xlsx"
    data_pd = pd.read_excel("d:\excel.xlsx",
                            header=None, index_col=None, names=None)
    RowShift = 3
    NumberCount = len(data_pd[13]) - RowShift
    numbers = [data_pd[13], data_pd[14], data_pd[15], data_pd[16], data_pd[17], data_pd[18], data_pd[19]]

    revNumbers = []
    for i in range(7):
       rows = []
       for j in range(NumberCount):
           j += RowShift
           rows.append(int(numbers[i][j]))
       revNumbers.append(list(reversed(rows)))
       print(revNumbers)

    #회차별 출력
    for i in range(len(revNumbers[0])):
        line = ""
        for j in range(len(revNumbers)):
            line += str(revNumbers[j][i]) + ","
        print(str(i + 1) + "회차:" + line )

파이썬(python)은 엑셀파일을 정말 쉽게 접근할 수 있어 대량 엑셀 정보를 쉽게 변경 가능합니다.

다른 언어에서는 엑셀파일을 직접 접근할 수 없어 별도 파일로 변경 후 사용하는데

파이썬(python)은 패키지를 사용해서 직접 접근하기 때문에 세팅만 잘되어 있다면 빠른 분석이 가능합니다.

배열 사용은 모든 언어에 기본이기 때문에 꼭 공부해주세요.

감사합니다.

반응형
반응형

오늘은 테서랙트(Tesseract)를 활용한 파이썬(python) OCR 분석을 알아보겠습니다.

파이썬(python)에서 테서랙트(Tesseract)를 사용하기 위해서 pytesseract 패키지를 설치합니다.

또한 이미지 및 open cv를 사용하기 위해서 추가 패키지를 설치합니다.

패키지 설치는 pip 명령어를 사용하거나, 파이참에서 패키지를 바로 설치할 수 있습니다.

pip install pillow 
pip install pytesseract 
pip install opencv-python

정상적으로 패키지가 설치되면 import를 사용해서 패키지를 로드할 수 있습니다.

지난 시간에 사용한 영문 이미지를 동일하게 OCR을 적용하겠습니다.

먼저 tesseract_cmd에 테서랙트(Tesseract) 경로를 선언해주세요.

Image 클래스를 사용해서 영어 이미지를 로드합니다.

마지막으로 image_to_string 함수를 사용해서 영어 문자를 추출합니다.

pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract'
img = Image.open(r'd:\en.jpg')
print(pytesseract.image_to_string(img))

tesseract_cmd 경로가 틀릴 경우 경로를 찾을 수 없다는 오류를 확인할 수 있습니다.

정확하게 테서랙트(Tesseract)가 설치된 경로를 입력해주세요.

실행 결과 출력 창에 정상적으로 영어 텍스트 추출 정보를 확인할 수 있습니다.

한글 텍스트를 추출하기 위해서는 lang를 사용해서 옵션을 추가합니다.

img2 = Image.open(r'd:\kor.jpg')
print(pytesseract.image_to_string(img2, lang='kor'))

pytesseract는 다양한 옵션을 사용해서 테서랙트(Tesseract)를 제어할 수 있습니다.

https://pypi.org/project/pytesseract/

 

pytesseract

Python-tesseract is a python wrapper for Google's Tesseract-OCR

pypi.org

한글 텍스트도 정확하게 추출됩니다.

OCR은 다양한 이미지 정보를 사용하기 때문에 눈으로 이미지를 확인하거나, 이미지를 변경할 수 있어야 합니다.

파이썬(python)에서는 opencv를 사용해서 이미지를 출력하거나, 이미지 프로세싱을 적용할 수 있습니다.

이미지를 확인하기 위해서 cv2 클래스를 사용해서 이미지를 출력할 수 있습니다.

imread 함수는 이미지를 로드해서 객체에 저장할 수 있습니다.

또한 다양한 옵션을 사용해서 이미지 로드 시점에 기본 색상 변경이 가능합니다.

cv2.IMREAD_UNCHANGED 원본 이미지 사용
cv2.IMREAD_GRAYSCALE 1개 채널 그레이스케일 사용
cv2.IMREAD_COLOR 3개 채널, BGR 이미지 사용
cv2.IMREAD_ANYDEPTH 선택 이미지에 따라 정밀도를 16/32비트, 8비트로 적용
cv2.IMREAD_ANYCOLOR 3개 채널, 색상 이미지 사용
cv2.IMREAD_REDUCED_GRAYSCALE_2 1개 채널, 1/2 크기, 그레이스케일 적용
cv2.IMREAD_REDUCED_GRAYSCALE_4 1개 채널, 1/4 크기, 그레이스케일 적용
cv2.IMREAD_REDUCED_GRAYSCALE_8 1개 채널, 1/8 크기, 그레이스케일 적용
cv2.IMREAD_REDUCED_COLOR_2 3개 채널, 1/2크기, BGR 이미지 사용
cv2.IMREAD_REDUCED_COLOR_4 3개 채널, 1/4크기, BGR 이미지 사용
cv2.IMREAD_REDUCED_COLOR_8 3개 채널, 1/8크기, BGR 이미지 사용

imshow 함수를 사용해서 이미지를 모니터 화면에 출력하고 waitKey 함수를 사용해서 키 입력할 때까지 무한 대기합니다.

실행 결과 로드된 이미지가 화면에 출력됩니다.

opencv는 다양한 이미지를 변환할 수 있어 OCR 텍스트 추출 시 인식률을 높일 수 있습니다.

파이썬(python)은 테서랙트(Tesseract) 래퍼 클래스(Wrapper Class) pytesseract와 opencv를 사용해서 다양한 이미지 텍스트 추출을 쉽게 진행할 수 있어 매우 편리합니다

다음 시간에는 opencv를 사용해서 이미지를 변경하는 방법을 알아보겠습니다.

감사합니다.

https://believecom.tistory.com/726

 

[python] 파이썬 Tesseract OCR 활용 설치하기

오늘은 파이썬(python)을 활용해서 OCR를 사용하는 방법을 알아보겠습니다. OCR(optical character recognition)은 이미지에 포함된 텍스트 정보를 추출하는 기술입니다. 요즘은 텍스트 정보 추출 기술이 발

believecom.tistory.com

반응형
반응형

오늘은 파이썬(python)을 활용해서 OCR를 사용하는 방법을 알아보겠습니다.

OCR(optical character recognition)은 이미지에 포함된 텍스트 정보를 추출하는 기술입니다.

요즘은 텍스트 정보 추출 기술이 발전되어 AI 기반으로 많이 사용됩니다.

수많은 OCR 제품이 있지만, 무료 사용할 수 있으면서 활용도가 높은 테서랙트(Tesseract)를 사용해서 이미지 텍스트를 추출해보겠습니다.

이번 시간에는 테서랙트(Tesseract)를 설치해서 이미지 텍스트를 추출하는 방법을 알아보겠습니다.

먼저 아래 사이트에서 설치 파일을 다운로드해주세요.

https://github.com/UB-Mannheim/tesseract/wiki

 

UB-Mannheim/tesseract

Tesseract Open Source OCR Engine (main repository) - UB-Mannheim/tesseract

github.com

전 Windows 기준으로 v5.0.0 64bit 버전을 다운로드하였습니다.

설치 파일을 더블 클릭해서 실행해주세요.

별도 선택 필요 없이 "Next" 버튼을 클릭하면 바로 설치됩니다.

설치 경로는 기본적으로 "Program Files" 아래 "Tesseract-OCR" 폴더에 설치됩니다.

먼저 이 경로를 복사해주세요.

이제 테서랙트( Tesseract ) 명령어를 사용하기 위해서 시스템에서 환경 변수를 등록해주세요.

복사한 경로를 시스템 환경 변수 "PATH"에 추가해주세요.

정상적으로 추가되면 "tesseract" 명령어로 내용을 확인할 수 있습니다.

이제 OCR을 테스트하기 위해서 영어 이미지를 만들었습니다.

테서랙트(Tesseract) 데이터 부분을 캡처했습니다.

테서랙트(Tesseract) 기본 명령어는 stdout -l를 사용해서 언어를 선택할 수 있습니다.

tesseract [경로] stdout -l [언어]

tesseract d:\en.jpg stdout -l eng

텍스트 추출 결과 영어이라서 그런지 대부분 텍스트를 정상적으로 추출했습니다.

이번에는 한글을 추출하기 위해서 옵션을 "kor"로 변경했습니다.

이미지도 한글이 포함된 이미지를 생성했습니다.

영어와 동일하게 이미지 경로와 언어만 변경했습니다.

그런데 "Failed loading language 'kor' " 오류가 발생하면서 텍스트 추출이 안됩니다.

확인해보면 테서랙트(Tesseract)는 tessdata 폴더에 포함된 언어 정보를 확인해서 텍스트를 추출하는데 'kor' traineddata가 없어서 발생한 문제입니다.

아래 사이트에서 테서랙트(Tesseract)다양한 언어 정보를 확인할 수 있습니다.

https://github.com/tesseract-ocr/tessdata

 

tesseract-ocr/tessdata

Trained models with support for legacy and LSTM OCR engine - tesseract-ocr/tessdata

github.com

아래쪽으로 스크롤하면 "kor.traineddata" 파일을 확인할 수 있습니다.

클릭하고 다운로드해주세요.

테서랙트(Tesseract) "tessdata" 폴더에 다운로드된 kor 파일을 복사합니다.

한글 텍스트를 추출하기 위해서 다시 명령어를 입력하면 정상적으로 한글 텍스트를 추출하는 것을 확인할 수 있습니다.

이번에는 한글과 영어를 한 번에 확인할 수 있는 이미지를 만들었습니다.

명령어는 기존과 동일하지만 언어 부분에 "kor+eng"로 변경했습니다.

tesseract [경로] stdout -l [언어]

tesseract d:\keng.jpg stdout -l kor+eng
tesseract d:\keng.jpg stdout -l kor+eng > keng.txt

정상적으로 한글, 영어 모두 추출되는 것을 확인할 수 있습니다.

한글, 영어를 분리해서 사용할 경우가 가장 추출 내용이 정확합니다.

한글, 영어를 혼합해서 사용할 경우 유실되는 정보가 조금씩 존재합니다. 

별도 텍스트 파일로 저장하고 싶다면 ">" 기호를 사용해서 텍스트 파일을 저장할 수 있습니다.

테서랙트(Tesseract)는 다양한 이미지 정보에 포함된 텍스트 정보를 추출할 수 있는 좋은 모듈입니다.

무료 사용도 가능하고 다양한 언어를 추출할 수 있기 때문에 더욱더 편리합니다.

다음 시간에는 테서랙트(tesseract)를 이용한 파이썬(python) 코드를 알아보겠습니다.

감사합니다.

반응형
반응형

파이썬(python)은 문자열을 자유롭게 사용할 수 있습니다.

문자열은 배열로 저장하기 때문에 사용하기 더욱더 편리합니다.

파이썬(python) 문자열을 사용하기 위해서는 큰따옴표( " )와 작은따옴표( ' )를 사용합니다.

a = "파이썬 문자열 시작합니다."
b = '파이썬 문자열 시작합니다.'

print(a)
print(b)

이번에는 지난 시간에 설치한 파이참을 사용해서 빌드하겠습니다.

a, b 변수에 문자열을 할당합니다.

출력은 print() 함수를 사용합니다.

출력 결과 동일한 내용 텍스트를 확인할 수 있습니다.

텍스트 선언 시 큰따옴표와 작은따옴표를 같이 사용할 없습니다.

시작한 문자열과 마지막 문자열이 동일해야 오류가 없습니다.

 

파이썬 이스케이프 코드 사용법

a = "이스케이프 코드 라인 피드 \n"
b = '이스케이프 코드 캐리지 리턴 \r'
c = '이스케이프 코드 탭 \t'
d = "이스케이프 코드 작은 따옴표 \'"
e = "이스케이프 코드 큰 따옴표 \""
f = "이스케이프 코드 백슬래시 \\"

print(a)
print(b)
print(c)
print(d)
print(e)
print(f)

파이썬도 다른 언어와 동일하게 문자열 사용 시 이스케이프 코드를 사용해서 특수 문자열을 추가할 수 있습니다.

이스케이프 코드는 라인피드, 캐리지 리턴, 탭, 작은따옴표, 큰 따옴표, 백 슬래시 등을 사용할 수 있습니다.

 

파이썬 문자열 배열 사용법

파이썬은 문자열을 선언하면 배열형태로 저장되어 인덱싱에 따른 위치 정보를 바로 확인할 수 있습니다.

a = "문자열 배열"
b = "python string array"

print(a[0])
print(a[4])

print(b[0])
print(b[5])

영문과 한글 모두 배열로 저장되며, 좋은 점은 유니코드 상관없이 자동으로 문자열을 변형되어 사용이 가능합니다.

한글 2byte, 영문 1byte 구분 없이 배열에 순서대로 저장되기 때문에 초보자가 사용하기 매우 편리합니다.

설정한 인덱스에 따른 위치 문자가 출력됩니다.

배열 크기 보다 클 경우는 오류가 발생합니다.

인덱스는 배열이기 때문에 0부터 시작합니다.

 

파이썬 문자열 연산자 사용법

파이썬은 + 연산자를 사용해서 문자열을 붙일 수 있습니다.

a = "문자열 배열"
b = "python string array"
c = a + "문자열 추가"
f = a * 10

d = a + b

print(d)
print(c)
print(f)

a, b 선언된 문자열을 + 연산자를 사용해서 d에 저장이 가능합니다.

파이썬에서는 '*' 연산자를 사용해서 문자열 복사가 가능합니다.

출력 결과 문자열을 붙어 있는 것을 확인할 수 있습니다.

a 변수를 10 복사한 내용도 확인이 가능합니다.

문자열을 직관적으로 사용할 수 있어 정말 편리합니다.

 

파이썬 문자열 메서드 사용법

파이썬에서는 문자열을 선언하면 객체로 인식하면 다양한 메서드를 사용할 수 있습니다.

a = "문자열 배열"
b = "python string array"
c = "문자열1|문자열2|문자열3"

print(len(a))
print(a.find('배'))
print(a.index("배"))
print(b.isupper())
print(a.rfind('배'))
print(c.split('|'))

a문자열에 "."을 사용하면 메서드를 확인할 수 있습니다.

다양한 메소드를 사용해서 문자열 정보를 확인할 수 있습니다.

문자열 메소드 중에서 split를 사용하면 구분자를 확인해서 배열 형태로 문자열이 저장됩니다.

파이썬은 문자열을 직관적으로 변경하거나, 연산할 수 있어 사용하기 매우 편리합니다.

decode(), encode()를 사용해서 문자열 인코딩도 가능하고, 바이트 배열에 따른 문자열 출력도 가능합니다.

쉽게 문자열을 접근할 수 있어 코드 내용이 많아 질 경우 오류를 최소화할 수 있습니다.

문자열은 매우 중요한 내용이기 때문에 꼭 많이 코딩해보세요.

감사합니다.

반응형

+ Recent posts