프로그래밍 꿀팁모음

Matplotlib 색상 설정 (색상표 포함)

Jammie — Mon, 6 Feb 2023 14:35:35 +0900

파이썬은 자주 색을 그립니다

Jammie — Mon, 6 Feb 2023 14:32:24 +0900

#색상별대응코드입니다
cnames = {
'aliceblue': '#F0F8FF',
'antiquewhite': '#FAEBD7',
'aqua': '#00FFFF',
'aquamarine': '#7FFFD4',
'azure': '#F0FFFF',
'beige': '#F5F5DC',
'bisque': '#FFE4C4',
'black': '#000000',
'blanchedalmond': '#FFEBCD',
'blue': '#0000FF',
'blueviolet': '#8A2BE2',
'brown': '#A52A2A',
'burlywood': '#DEB887',
'cadetblue': '#5F9EA0',
'chartreuse': '#7FFF00',
'chocolate': '#D2691E',
'coral': '#FF7F50',
'cornflowerblue': '#6495ED',
'cornsilk': '#FFF8DC',
'crimson': '#DC143C',
'cyan': '#00FFFF',
'darkblue': '#00008B',
'darkcyan': '#008B8B',
'darkgoldenrod': '#B8860B',
'darkgray': '#A9A9A9',
'darkgreen': '#006400',
'darkkhaki': '#BDB76B',
'darkmagenta': '#8B008B',
'darkolivegreen': '#556B2F',
'darkorange': '#FF8C00',
'darkorchid': '#9932CC',
'darkred': '#8B0000',
'darksalmon': '#E9967A',
'darkseagreen': '#8FBC8F',
'darkslateblue': '#483D8B',
'darkslategray': '#2F4F4F',
'darkturquoise': '#00CED1',
'darkviolet': '#9400D3',
'deeppink': '#FF1493',
'deepskyblue': '#00BFFF',
'dimgray': '#696969',
'dodgerblue': '#1E90FF',
'firebrick': '#B22222',
'floralwhite': '#FFFAF0',
'forestgreen': '#228B22',
'fuchsia': '#FF00FF',
'gainsboro': '#DCDCDC',
'ghostwhite': '#F8F8FF',
'gold': '#FFD700',
'goldenrod': '#DAA520',
'gray': '#808080',
'green': '#008000',
'greenyellow': '#ADFF2F',
'honeydew': '#F0FFF0',
'hotpink': '#FF69B4',
'indianred': '#CD5C5C',
'indigo': '#4B0082',
'ivory': '#FFFFF0',
'khaki': '#F0E68C',
'lavender': '#E6E6FA',
'lavenderblush': '#FFF0F5',
'lawngreen': '#7CFC00',
'lemonchiffon': '#FFFACD',
'lightblue': '#ADD8E6',
'lightcoral': '#F08080',
'lightcyan': '#E0FFFF',
'lightgoldenrodyellow': '#FAFAD2',
'lightgreen': '#90EE90',
'lightgray': '#D3D3D3',
'lightpink': '#FFB6C1',
'lightsalmon': '#FFA07A',
'lightseagreen': '#20B2AA',
'lightskyblue': '#87CEFA',
'lightslategray': '#778899',
'lightsteelblue': '#B0C4DE',
'lightyellow': '#FFFFE0',
'lime': '#00FF00',
'limegreen': '#32CD32',
'linen': '#FAF0E6',
'magenta': '#FF00FF',
'maroon': '#800000',
'mediumaquamarine': '#66CDAA',
'mediumblue': '#0000CD',
'mediumorchid': '#BA55D3',
'mediumpurple': '#9370DB',
'mediumseagreen': '#3CB371',
'mediumslateblue': '#7B68EE',
'mediumspringgreen': '#00FA9A',
'mediumturquoise': '#48D1CC',
'mediumvioletred': '#C71585',
'midnightblue': '#191970',
'mintcream': '#F5FFFA',
'mistyrose': '#FFE4E1',
'moccasin': '#FFE4B5',
'navajowhite': '#FFDEAD',
'navy': '#000080',
'oldlace': '#FDF5E6',
'olive': '#808000',
'olivedrab': '#6B8E23',
'orange': '#FFA500',
'orangered': '#FF4500',
'orchid': '#DA70D6',
'palegoldenrod': '#EEE8AA',
'palegreen': '#98FB98',
'paleturquoise': '#AFEEEE',
'palevioletred': '#DB7093',
'papayawhip': '#FFEFD5',
'peachpuff': '#FFDAB9',
'peru': '#CD853F',
'pink': '#FFC0CB',
'plum': '#DDA0DD',
'powderblue': '#B0E0E6',
'purple': '#800080',
'red': '#FF0000',
'rosybrown': '#BC8F8F',
'royalblue': '#4169E1',
'saddlebrown': '#8B4513',
'salmon': '#FA8072',
'sandybrown': '#FAA460',
'seagreen': '#2E8B57',
'seashell': '#FFF5EE',
'sienna': '#A0522D',
'silver': '#C0C0C0',
'skyblue': '#87CEEB',
'slateblue': '#6A5ACD',
'slategray': '#708090',
'snow': '#FFFAFA',
'springgreen': '#00FF7F',
'steelblue': '#4682B4',
'tan': '#D2B48C',
'teal': '#008080',
'thistle': '#D8BFD8',
'tomato': '#FF6347',
'turquoise': '#40E0D0',
'violet': '#EE82EE',
'wheat': '#F5DEB3',
'white': '#FFFFFF',
'whitesmoke': '#F5F5F5',
'yellow': '#FFFF00',
'yellowgreen': '#9ACD32'}

파이썬 그림의 범례 레전드 설정입니다

Jammie — Mon, 6 Feb 2023 14:29:05 +0900

1. 위치. loc='upper right' 또는 loc=1 로 설정합니다.그리고 다음과 같은 옵션이 있습니다

             'best':         0,  # only implemented for axes legends
             'upper right':  1,
             'upper left':   2,
             'lower left':   3,
             'lower right':  4,
             'right':        5,
             'center left':  6,
             'center right': 7,
             'lower center': 8,
             'upper center': 9,
             'center':       10,

2,bbox_to_anchor라는 매개변수를 사용하여 범례를 그림 외부에 배치할 수 있습니다.여기 봐요

　　3.투명한 범례 설정, 여기 참조

　　4, 범례 글꼴 크기 설정, fontsize 매개 변수: intor floator {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'} 이 7가지 조절 값만 있습니다.
　　prop 인자를 사용할 수도 있습니다: font1 = {'size': 15} 를 먼저 정의합니다.그런 다음 매개변수 prop=font1을 사용하여 글꼴 크기를 마음대로 조정할 수 있습니다.

　　다음은 그의 모든 매개변수입니다

def __init__(self, parent, handles, labels,
                 loc=None,
                 numpoints=None,    # the number of points in the legend line
                 markerscale=None,  # the relative size of legend markers
                                    # vs. original
                 markerfirst=True,  # controls ordering (left-to-right) of
                                    # legend marker and label
                 scatterpoints=None,    # number of scatter points
                 scatteryoffsets=None,
                 prop=None,          # properties for the legend texts
                 fontsize=None,        # keyword to set font size directly

                 # spacing & pad defined as a fraction of the font-size
                 borderpad=None,      # the whitespace inside the legend border
                 labelspacing=None,   # the vertical space between the legend
                                      # entries
                 handlelength=None,   # the length of the legend handles
                 handleheight=None,   # the height of the legend handles
                 handletextpad=None,  # the pad between the legend handle
                                      # and text
                 borderaxespad=None,  # the pad between the axes and legend
                                      # border
                 columnspacing=None,  # spacing between columns

                 ncol=1,     # number of columns
                 mode=None,  # mode for horizontal distribution of columns.
                             # None, "expand"

                 fancybox=None,  # True use a fancy box, false use a rounded
                                 # box, none use rc
                 shadow=None,
                 title=None,  # set a title for the legend

                 framealpha=None,  # set frame alpha
                 edgecolor=None,  # frame patch edgecolor
                 facecolor=None,  # frame patch facecolor

                 bbox_to_anchor=None,  # bbox that the legend will be anchored.
                 bbox_transform=None,  # transform for the bbox
                 frameon=None,  # draw frame
                 handler_map=None,
                 ):

파이썬 그림 입문입니다

Jammie — Mon, 6 Feb 2023 14:26:36 +0900

'''파이썬 그림 그리는 공부'''
import turtle#调用turtle库
from turtle import *# turtle의 모든 함수를 호출하여 그림을 쉽게 그릴 수 있습니다.
setup(1000.0,800.0,140,140) #아무거나 설정해놨어요
"" "첫 번째 단계: 캔버스의 크기를 설정합니다. 자세한 디버깅이 필요합니다. width 창 너비, 정수는 픽셀 값, 소수는 창과 화면 사이의 비율을 나타냅니다.
height: 창의 높이, 정수는 픽셀 값, 소수는 창과 화면 사이의 비율, starty, startx의 상단과 좌측 픽셀 거리입니다.
"""
turtle.pensize(10) #붓의 굵기 입니다
turtle.pencolor("red")
turtle.penup() # 브러시를 들어 올립니다
fd(0)
turtle.pendown() #은 브러시를 내리는 것을 의미합니다.
turtle.fd(300)
seth(90)#turtle.seth는 브러시의 방향을 조절하며 방향은 플러스 마이너스 360도 범위로 초과 시 재계산됩니다.
fd(300)#는 음의 방향 이동을 나타내며, fd는 약자입니다.
seth(180)
fd(300)
turtle.color('purple')
seth(180)
fd(300)

뒤에 추가되었습니다:

for i in range (1,5):
turtle.circle(190,600,6)
실행 상황:

1. setup()에 필요한 파라미터입니다.

2. 약자로 쓰는 경우가 있습니다.

3.파이썬은 포기하고 자바 배우세요!

#회형을 그리며, 함수에 캡슐화합니다.
import turtle
from turtle import *
i=0

def cirs():
setup(1000.0,900.0,800,880)
pensize(30)
pencolor("red")
pd()

for i in range(1,7):
turtle.circle(10,21,5)
turtle.circle(-150,30)
fd(1)
i+=1
for i in range(1,10):
pensize(10)
pencolor("purple")
for i in range(1,10):
turtle.circle(10,21,9)


fd(10)
seth(90)
turtle.circle(100,-21,-5)
fd(100)

seth(-90)
fd(10)
i+=1
cirs()

파이썬 스레드 풀입니다

Jammie — Mon, 6 Feb 2023 14:18:13 +0900

Python은 스레드 풀의 역할을 설정할 수 있습니다.

설정된 스레드를 미리 켭니다.스레드가 종료된 후에도 프로그램은 해당 스레드를 계속 사용할 수 있습니다.

여러 개의 스레드를 켜서 시스템이 충돌하지 않도록 최대 스레드 수를 설정합니다.

유휴 시간이 많은 프로세스에서 다중 스레드를 구성하면 프로그램이 병렬로 처리되고 처리 속도가 향상될 수 있습니다.

스레드 풀의 기본 클래스는 concurrent.futures 모듈의 Executor이며 Executor는 ThreadPoolExecutor와 ProcessPoolExecutor의 두 가지 하위 클래스를 제공하며, 여기서 ThreadPoolExecutor는 스레드 풀을 생성하는 데 사용되며 ProcessPoolExecutor는 프로세스 풀을 생성하는 데 사용됩니다.

파이썬(Python)의 스레드는 GIL 잠금이 있기 때문에 싱글 코어입니다.
파이썬의 프로세스는 각각 독립적인 GIL 잠금 장치가 있기 때문에 멀티코어이지만, 각각 독립적으로 메모리 공간을 할당해야 하므로 공간을 많이 차지합니다.

스레드 풀을 사용하여 스레드 작업을 수행하는 단계는 다음과 같습니다.

ThreadPoolExecutor 클래스의 생성자를 불러 스레드 풀을 만듭니다.
스레드 작업으로 일반 함수를 정의합니다.
스레드 작업을 제출하기 위해 ThreadPoolExecutor 개체의 submit() 메서드를 호출합니다.
ThreadPoolExecutor 개체의 shutdown(wait = True) 메서드를 호출하여 스레드 풀을 닫습니다

def fun(index):
	print(index)
	time.sleep(3)
	
from concurrent.futures import ThreadPoolExecutor
theard_pool = ThreadPoolExecutor(max_workers=2)
for i in range(1000):
	thread_pool.submit(fun, i)
thread_pool.shutdown(wait= True)

몇 가지 질문이 있습니다.

논리적으로 말하면, 반드시 엄격하고 질서 있는 것을 보장할 수 있는 것은 아니다.
모든 작업을 큐에 던져 구현하기 때문에 tb급 데이터를 처리할 때 오버플로우가 발생합니다??(확인 필요)

Pycharm 출력 메시지에서 깨진 문자를 해결합니다

Jammie — Mon, 6 Feb 2023 11:34:49 +0900

Pycharm 출력 정보의 중국어 깨짐 문제는 주로 코딩 문제로 인해 발생합니다.

Pycharm에서 기본 인코딩 형식은 UTF-8이지만 프로그램의 인코딩 형식이 기본과 다르면 깨짐이 발생합니다.운영 체제의 기본 인코딩 형식이 UTF-8이 아닐 수도 있으며, 이는 또한 출력 정보의 중국어 깨짐 문제를 유발할 수 있습니다.그리고 당신의 입력 파일 인코딩 형식이 UTF-8이 아니더라도 출력 정보의 중국어 깨짐 문제가 발생할 수 있습니다

해결 방안입니다
Pycharm에서 설정에 들어가 'Editor' -> 'File Encodings'를 찾아 인코딩을 UTF-8로 설정할 수 있습니다

여전히 프로그램에서 출력 형식을 UTF-8로 설정해 볼 수 있는 문제를 해결할 수 없습니다

프로그램에 #-coding:utf-8-을 추가하면 중국어 깨짐 문제를 해결할 수 있습니다

Python 복사 붙여넣기를 합니다

Jammie — Mon, 6 Feb 2023 11:29:49 +0900

하나, pyperclip을 설치합니다

pip install pyperclip

1.1 사용방법
1.1.1 복사하기

pyperclip.copy("hello world")

1.1.2 붙여넣기

pyperclip.paste()

2. PyKeyboard를 설치합니다.
2.1 pywin32를 설치합니다
pywin32 다운로드를 누르십시오

여기에서 whl 파일을 다운로드하고 명령행 pip install로 설치하세요. 해당하는 버전을 선택하십시오.

2.2 pyHook을 설치합니다
pyHook 다운로드를 누르십시오

같은 작업입니다.

2.3 PyKeyboard를 설치합니다

pip install PyKeyboard

3. 테스트 코드입니다

from selenium import webdriver
import time
from bs4 import BeautifulSoup
import pyperclip
from pykeyboard import PyKeyboard

def main():
browser = webdriver.Chrome()
browser.get ('https://baidu.com ') # 현재 브라우저에서 바이두에 액세스합니다
pyperclip.copy("selenium")
browser.find_element_by_name('wd').click() # 바이두 입력 상자를 누르십시오
time.sleep(0.5)
k = PyKeyboard()
# 아날로그 키보드는 ctrl+v를 클릭합니다
k.press_key(k.control_key)
k.tap_key('v')
k.release_key(k.control_key)
browser.find_element_by_name('wd').click()
time.sleep(1000)

if __name__ == '__main__':
main()

Python이 사전을 만드는 8가지 방법입니다

Jammie — Sat, 4 Feb 2023 15:06:29 +0900

Python이 사전을 만드는 8가지 방법입니다
1. 빈 사전을 만듭니다

dic = {}
type(dic)
# <type 'dict'>

2. 직접 값을 할당하여 만듭니다

dic = {'spam':1, 'egg':2, 'bar':3}
print(dic)
# {'bar': 3, 'egg': 2, 'spam': 1}

3.키워드 dict와 키워드 파라미터를 통해 만듭니다

dic = dict(spam = 1, egg = 2, bar =3)
print(dic)
# {'bar': 3, 'egg': 2, 'spam': 1}

4. 이원 그룹 목록으로 만듭니다

lis = [('spam', 1), ('egg', 2), ('bar', 3)]
dic = dict(lis)
print(dic)
# {'bar': 3, 'egg': 2, 'spam': 1}
v

5.dict와 zip을 결합하여 만듭니다

dic = dict(zip('abc', [1, 2, 3]))
print(dic)
# {'a': 1, 'c': 3, 'b': 2}

6.사전유도식으로 만듭니다

dic = {i:2*i for i in range(3)}
print(dic)
# {0: 0, 1: 2, 2: 4}

7.dict.fromkeys( )로 만듭니다

사전을 초기화하고 value의 기본값을 설정합니다

dic = dict.fromkeys(range(3), 'x')
print(dic)
# {0: 'x', 1: 'x', 2: 'x'}

8.기타요

lis = ['x', 1, 'y', 2, 'z', 3]
dic = dict(zip(lis[::2], lis[1::2]))
print(dic)
# {'y': 2, 'x': 1, 'z': 3}

python 소수점 설정 후 소수점 두 자리를 유지합니다

Jammie — Sat, 4 Feb 2023 14:53:49 +0900

python에서 소수점 두 자리를 유지하는 방법을 설정합니다.

1, 문자열을 사용하여 포맷합니다

x=int(input())
y=int(input())
print(x//y,x%y)
a=x/y
print("%.2f" % a)

#3,2를 입력하세요
#출력 11입니다
# 1.50

2, round 내장 함수 사용

a = 12.345
a1 = round(a, 2)
print(a1)
 
# 12.35

3. decimal 모듈을 사용합니다.

from decimal import Decimal
a = 12.345
Decimal(a).quantize(Decimal("0.00"))
Decimal('12.35')

4. 시퀀스에서 슬라이스를 사용합니다

a = 12.345
str(a).split('.')[0] + '.' + str(a).split('.')[1][:2]
'12.34'

5. re모듈을 사용합니다

import re
a = 12.345
re.findall(r"\d{1,}?\.\d{2}", str(a))
['12.34']

MacOS에서 Python 환경을 설정합니다

Jammie — Sat, 4 Feb 2023 14:50:05 +0900

Python에 적합한 개발 프로젝트:

웹 응용 프로그램은 웹 사이트, 백그라운드 서비스 등을 포함합니다.
시스템 관리자가 필요로 하는 스크립트 작업 등 일상적으로 필요한 많은 가젯이 있습니다.
또한 다른 언어로 개발된 프로그램을 재포장하여 편리하게 사용할 수 있도록 합니다v

물론 파이썬도 단점이 있습니다.

파이썬은 C프로그램에 비해 매우 느립니다.
Python은 해석형 언어이기 때문에 당신의 코드는 실행 시 CPU가 이해할 수 있는 기계 코드로 한 줄씩 번역되는데, 이 번역 과정은 시간이 많이 걸리기 때문에 매우 느립니다.
그리고 C 프로그램은 실행 전에 CPU가 실행할 수 있는 기계 코드로 직접 컴파일되기 때문에 매우 빠릅니다

python 개발 환경을 Mac에 설정합니다.
(1) Mac OS X 시스템은 python을 가지고 있으며, 단말기에서 python을 입력하여 버전을 볼 수 있습니다. [exit()를 입력하면 종료됩니다]는 다음과 같습니다.

물론 시스템 자체 python 2.7 버전은 더 이상 권장되지 않으며 일반적으로 절판되었음을 알 수 있습니다.

(2) 파이썬 설치 방법:

Mac OS에서 Python을 설치하는 주요 방법은 두 가지가 있습니다.

홈브루 설치입니다

홈페이지에서 다운로드하여 설치합니다.

홈브루 설치입니다
설치 키트 관리 도구 - 홈브루

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

python3 설치, 터미널 설치 명령입니다

설치 명령: brew install python3 입니다

설치가 성공했는지 확인합니다
터미널 입력 명령: python3, 설치 성공 메시지가 표시됩니다

다른 작업입니다
단말기에서 다음 명령을 입력하여 Python 설치 위치를 확인합니다.
which python

터미널에서 Python의 현재 버전을 보려면 아래 명령을 입력하십시오
python --version

터미널에서 다음 명령을 입력하여 Python 인터랙티브 모드로 들어갑니다
python

python에서 strip () 함수에 대한 자세한 설명입니다

Jammie — Sat, 4 Feb 2023 14:42:34 +0900

하나,배경입니다

요즘 문자열 처리 과정에서 strip() 함수의 기능을 잘 몰라서 이 블로그에서 strip() 함수를 해석합니다.

strip 함수의 해석:

문자 그대로의 뜻은 다음과 같습니다.

선행 및 후속 공백이 삭제된 문자열 사본을 반환합니다.None 대신 chars가 주어진 경우 chars의 문자를 삭제합니다.

다음과 같은 3가지 상황이 발생합니다.

2. 구체적인 상황입니다.

첫 번째: strip () 함수에 문자가 없으면 문자열의 선두와 공백의 뒤를 잇는 문자열의 복사본을 삭제합니다

위의 그림에서 보는 바와 같이 strip() 함수에 문자가 없으면 삭제 문자열의 앞뒤 공백을 얻습니다.

두 번째 유형은 strip() 함수의 문자가 ''일 때 위의 결과와 동일합니다

세 번째: strip () 함수 안에 문자가 있을 때 문자열의 처음과 끝에 해당하는 문자를 삭제한 문자열의 복사본을 얻습니다

3. 총결산합니다.

strip() 함수는 함수의 문자를 기반으로 문자열을 스캔하여 왼쪽에서 오른쪽으로 선행 및 후행하는 함수의 해당 문자를 삭제하여 문자열의 해당 사본을 얻습니다

Python-- 문자열입니다

Jammie — Wed, 11 Jan 2023 12:03:35 +0900

문자열 유형은 Python에서 매우 중요한 유형으로 일반적으로 따옴표 중간에 문자를 추가하여 표현하며 다른 언어와 달리 Python의 큰따옴표('')와 작은따옴표('')는 구별할 수 없습니다.문자열을 나타낼 수 있습니다

생성, 할당 및 접근합니다
1. 두 가지 방법으로 만듭니다.
(1) 직접 값을 지정합니다

s = "abcdef"

(2) str() 함수를 통해요

str() 함수의 역할은 들어오는 매개변수를 통해 string형 개체를 생성하는 것과 동일하며, 이 들어오는 매개변수는 정형, 부동 소수점 유형 또는 목록, 메타그룹, 사전 등이 될 수 있습니다

s = str(21) # >>> "21"
s = str(12.3) # >>> "12.3"
s = str([1, 2, 3]) # >>> "[1, 2, 3]"

주의할 점은, "들어오는 것은 무엇이고, 얻는 것은 무엇인가" 예를 들어 우리가 목록을 전송하면, 얻어진 문자열의 첫 번째 문자는 목록의 첫 번째 요소가 아니라, "["이며, 같은 이치로도 문자열의 일부로 간주됩니다.

2. 문자열에 액세스합니다
(1) 단일 문자에 접근합니다

s = "1234567"
print(s[1]) # >>> "2"
print(s[-1]) # >>> "7"
print(s[-7]) # >>> "1"

문자열도 당연히 시퀀스이므로 각 요소(즉, 각 문자)는 인덱스에 해당하며 인덱스의 디자인은 다른 언어와 마찬가지로 0부터 시작됩니다.

또한 파이썬은 마지막 요소의 인덱스를 -1, 끝에서 두 번째 요소의 인덱스를 -2로 만드는 '마이너스 인덱스'를 제공하여 첫 번째 요소의 인덱스가 -n(단, n은 시퀀스의 길이)임을 유추합니다.

(2) 슬라이스에 액세스합니다

s = "1234567"
print(s[1:4]) # >>> "234"

슬라이스는 파이썬에서 매우 독특한 문법이며, 물론 슬라이스가 적용되는 대상은 시퀀스(문자열, 목록, 메타그룹)로 시퀀스의 일부를 표현하는 데 매우 편리합니다.슬라이스에는 세 가지 매개변수 제어가 있으며 그의 형태는 다음과 같이 나타낼 수 있습니다

[begin: end: step]

가운데는 다음과 같이 구분되며, begin은 얻을 수 있는 시퀀스의 시작 위치를 나타내며 이 위치를 포함하고 end는 얻을 수 있는 시퀀스의 끝 위치를 나타내지만 이 위치의 요소를 포함할 수 없습니다.예:

s = "1234567"
s1 = s[2:5] # >> s에서 두 번째 자리부터 네 번째 자리까지를 따온 수, 즉 '345'입니다.

begin 및 end에 대한 해당 매개변수를 명시적으로 제공하지 않으면 begin은 기본적으로 0으로 간주되고 end는 다음과 같은 n(시퀀스 길이)으로 기본 설정됩니다

s = "1234567"
s1 = s[:5] # >>> s1 = "12345"
s2 = s[2:] # >>> s2 = "34567"
s3 = s[:] # >> 전체 s를 복사했습니다

슬라이스의 마지막 매개변수 step은 다음과 같은 '단계 길이'를 나타냅니다

s = "1234567"
s1 = s[1:6:2] # >> 1번 위치에서 시작하여 5번 위치에서 끝날 때까지 2보씩 '점프'하면 '246'을 받습니다.

원소를 취했을 때 뒤로 '점프'하는 걸음 수를 step이라고 이해하면 되는데, 예를 들어 위의 예는 두 걸음 점프한 것입니다.그러나 step이라는 매개변수는 반드시 주어져야 하는 것은 아니며 기본값은 1이며 기본값 1을 사용할 때 step 이전의 것도 특별한 요구 사항이 없으면 생략할 수 있습니다.

(3) 음절편입니다.

더 특별한 슬라이스 사용 방법이 있는데, 그것은 '마이너스 슬라이스'입니다. 일반적으로 step을 마이너스로 만드는 슬라이스입니다. 위에서 파이썬이 '마이너스 인덱스'를 제공한다고 말했기 때문에, 같은 이치에 따르면, 마이너스 슬라이스는 자연스럽게 뒤에서 시작하여 매 번 해당 단계를 앞으로 건너뛰는 것입니다. 예를 들어

s = "1234567"
print(s[6:1:-1]) # >> 6,5,4,3,2 위치의 요소를 차례로 취하면 "76543"이 됩니다.
print(s[-2:-4:-1]) # >> -2, -3 위치의 요소를 차례로 취하면 "65"가 됩니다

포지티브 섹션이든 네거티브 섹션이든 Begin과 end는 모두 '왼쪽 닫힘 및 오른쪽 열림' 원칙을 충족합니다.양성 슬라이스는 왼쪽에서 오른쪽으로(또는 후방으로) 반면 음성 슬라이스는 반대 방향입니다.

양성 슬라이스와 마찬가지로 step의 값은 물론 -1이 아닐 수도 있고 다른 음의 정수를 취할 수도 있습니다

s = "1234567"
print(s[6:1:-2]) # >> 6,4,2 위치의 요소를 차례로 취하면 "753" 입니다

양성 및 음성 슬라이스에 관계없이 begin 또는 end가 시퀀스의 범위를 벗어나면 이상을 일으키지 않는다는 점에 유의해야 합니다

a = "1234"
print(a[8:]) # >>> ""
print(a[0:8]) # >>> "1234"

양 절편에서 begin > end이고 begin이 end와 같은 번호이거나 음 절편에서 begin < end이고 begin이 end와 같은 번호일 경우 빈 시퀀스를 반환합니다

a = "1234567"
print(a[3:1:1]) # >>> ""
print(a[1:3:-1]) # >>> ""

그러나 begin이 end와 다른 번호를 갖는 경우 먼저 음의 인덱스를 해당 양의 인덱스로 변환한 다음 슬라이스를 구현합니다

a = "1234567"
print(a[-2:0:-1]) # >> a[5:0:-1]로 변환합니다.
print(a[2:-1]) # >> a[2:6]로 변환합니다.

불변성입니다
나는 이전에 정형, 문자열 등과 같이 이러한 유형의 데이터는 변경할 수 없다고 말했습니다(자세한 내용은 내 블로그: Python-Memory Management 참조). 즉, 이러한 유형의 데이터에 메모리가 할당되면 변경할 수 없습니다.예를 들어, 다음을 수행하면 이상이 발생합니다.

s = "1234567"
s[0] = "e"

하지만 현실적으로 우리가 문자열 자체의 내용을 바꿔야 하는 경우가 많은 것은 사실입니다.그러면 Python에서 우리가 일반적으로 사용하는 방법은 다음과 같은 string형 개체를 다시 만드는 것입니다

s = "1234567"
s = s[0:3] + "Python" # >>> s = "123Python"

결과는 s를 변경한 것처럼 보이지만 실제로는 이전 s의 슬라이스 s[0:3]와 문자열 'Python'으로 연결된 새로운 문자열을 재구성하고 s라는 이름에 의해 참조되었습니다.

마찬가지로, 우리는 물론 다음과 같은 문자열의 특정 요소를 제거할 수 있습니다

s = "1234567"
s = s[0:3] + s[4:] # >> s = "123567" 삭제 4

사실, 문자열 유형의 개체를 새로 만들었습니다.

문자열 연산자입니다
1. 멤버요
우리는 연산자 in과 not in을 사용하여 한 문자 또는 한 문자열이 다른 문자열에 있는지 여부를 결정합니다

s = "abcdef"
print("ef" in s) # >>> True
print("ac" in s) # >>> False
print("d" not in s) # >>> False

2. 연결하세요
두 문자열의 연결을 +로 나타내는데, 사실 앞에서 이미 이런 예를 본 적이 있습니다

s1 = "I wrote"
s2 = "Python"
print(s1 + " " + s2) # >>> "I wrote Python"

3. 반복합니다

s = "123"
print(s * 3) # >>> "123123123"

* 표현은 사실 수학적으로 같은 뜻이에요, 여러 개를 더하면.

4. 비교합니다
문자열 간의 비교는 두 문자열 간의 첫 번째 다른 문자에 해당하는 ascii 코드의 크기를 기반으로 합니다

s1 = "abcde"
s2 = "abce"
print(s1 > s2) # >>> False

두 문자열의 앞부분이 같을 때, 긴 문자열을 기준으로 합니다

s1 = "abcd"
s2 = "abc"
print(s1 > s2) # >>> True

문자열의 내장 함수입니다
1. 문자열 길이입니다
문자열의 길이를 len(str) 형식으로 찾습니다

print(len("1234567")) # >>> 7

2. 문자열의 최대값과 최소값입니다
사실 대응하는 ascii는 가장 크고 작은 문자를 인코딩합니다

print(max("abcd")) # >>> "d"
print(min("1234")) # >>> "1"

3. enumerate and zip
문자열을 매개 변수로 enumerate() 및 zip() 함수에 전달하여 해당 enumerate 유형 개체와 zip 유형 개체를 생성한 다음 루프를 통해 이러한 개체를 원하는 대로 출력합니다.예를 들어 다음과 같습니다.

enum_obj = enumerate("abcd") # >> enumerate 형식의 개체를 새로 만들었습니다
for index, ele in enum_obj:
print(index, ele) # >> 0 "a", 1 "b", 2 "c", 3 "d" 를 차례로 출력합니다.

for i in zip("abcd", "1234"):
print(i) # >> 순서대로 출력:("a", "0", "b", "1", "c", "2", "d", "3")

이러한 함수는 우리에게 데이터를 처리하는 보다 편리한 방법을 제공할 수 있습니다.

4. 문자열 찾기입니다
find()와 index() 함수는 앞서 말한 멤버 연산자를 사용하여 문자열이 다른 문자열에 있는지 여부를 판단할 수 있습니다.

s = "Python"
print(s.find("Py")) # >>> 0
print(s.find("hy")) # >>> -1

find() 함수의 기능은 일치하는 부분이 보이면 처음의 그 위치로 되돌리고, 보이지 않으면 -1로 되돌리는 것입니다. 물론 find() 함수에서는 찾는 시작과 끝의 위치를 설정할 수도 있습니다.그러나 문자열에 내장된 함수가 너무 많고 많은 함수의 매개변수 설정도 매우 상세하기 때문에 저는 단지 '벽돌을 던져 옥을 끌어당기기'만 할 뿐 하나하나 열거하지 않습니다.

index() 함수는 유사한 기능을 구현하지만, 찾지 못하면 이상을 유발합니다.따라서 index() 함수를 사용하려면 구성원 연산자를 사용하여 미리 판단문을 추가하고, 만약 그렇다면 index()를 사용하여 일치하는 필드의 시작 위치를 반환하는 것이 가장 좋습니다

s = "Python"
print(s.index("yth")) # >>> 1
print(s.index("hy") # >> 이상을 유발합니다.

5. 문자열 판별입니다
파이썬은 또한 많은 문자열의 판별 함수를 제공합니다.

(1) string.isalnum () 문자열의 문자가 모두 문자 또는 숫자일 때 True를 반환하고, 그렇지 않으면 False를 반환합니다

s1 = "123asd"
s2 = "as, 123"
print(s1.isalnum()) # >>> True
print(s2.isalnum()) # >>> False

(2) string.isalpha() string의 모든 문자는 문자입니다. True를 반환하고, 그렇지 않으면 False를 반환합니다

s1 = "Python"
s2 = "C++"
print(s1.isalpha()) # >>> True
print(s2.isalpha()) # >>> False

(3) string.isdigit( ) string의 모든 문자는 숫자입니다. True를 반환하고, 그렇지 않으면 False를 반환합니다

s1 = "0106584376"
s2 = "010-7487345"
print(s1.isdigit()) # >>> True
print(s2.isdigit()) # >>> False

(4) string.isupper() string의 모든 글자는 대문자로, True를 반환하고, 그렇지 않으면 False를 반환합니다.
string.islower( ) string의 모든 글자는 소문자로 True를 반환하고, 그렇지 않으면 False를 반환합니다

s1 = "SELECT"
s2 = "Python3.5"
print(s1.isupper()) # >>> True
print(s2.islower()) # >>> False

6. 문자열 바꾸기
string.replace() 함수는 문자열 치환을 구현합니다.새 문자열 개체를 만듭니다. 새 개체는 대체된 개체입니다

s = "123456"
s = s.replace("456", "abc") # >>> s = "123abc"

기본 매개변수는 두 가지가 있는데, 오래된 것은 앞에 있고 새 것은 뒤에 있습니다.

7. 문자열 분할입니다
일반적으로 사용되는 분할 상관 함수는 세 가지입니다: string.split( ); string.partition( ); string.join( )

(1) (1) string.split()：

s = "I love you"
s.split("") # >>> 문자열을 구분자로 분할합니다: ["I", "love", "you"]

이 분할 방법은 실제로 문자열의 시작점을 점으로, 끝점을 점으로, 그리고 각 구분 기호를 점으로 하는 것입니다. 만약 인접한 두 점 사이에 또 문자열이 있다면, 이 문자열은 목록의 한 요소입니다. 만약 인접한 두 점 사이에 물건이 없다면, 빈 문자(공백이 아니라 빈 문자)"를 반환합니다. 예를 들어, 위의 예를 들어, 우리는 다음과 같이 변경합니다

s = "I love you "
s.split("") # >>> 문자열 s를 구분자로 분할합니다: ["I", "", "love", "you", "", ""]

실제로 점으로 표현하면 다음과 같습니다: s = ".I..love.you..." 시작과 끝에는 각각 점이 있습니다. 각 인접한 점 사이의 항목을 목록의 요소로 취하면 위의 결과를 얻을 수 있습니다.

(2) (2) string.partition()：

s = "I love you"
s.partition("" ") # >>> 공간을 구분자로 사용하여 문자열 s를 구분자로 나눕니다: ["I", "love you"]

partition()은 split()과 같은 역할을 합니다. 다만 결과는 세 요소의 목록이고 구분자는 두 번째 요소여야 합니다.

(3) (3) string.join()：
이것은 실제로 연결 함수이지만, 저는 여전히 그것을 분할 안에 두고 이야기했습니다.그것의 기능은 string을 구분자로 사용하여 괄호 안의 문자열 시퀀스를 연결하는 것입니다(참고, 문자열로 구성된 목록과 같은 문자열 형식의 시퀀스여야 함).

print(",".join(["I", "wrote", "Python"])) # >>> "I,wrote,Python"
print("**".join("123")) # >>> "1**2**3"

8. 대소문자 변환입니다
세 가지 주요 함수를 소개합니다.

(1) string.upper( ): 모든 소문자를 대문자로 변환합니다. 그러나 이것은 새로운 개체를 생성했을 뿐 원래 개체는 변경되지 않았습니다.

s = "bupt"
print(s.upper()) # >>> "BUPT"
print(s) # >>> "bupt"

(2) string.lower( ): string.upper( )와 같은 의미로 대문자를 소문자로 변환합니다.

s = "Python3"
print(s.lower()) # >>> "python3"

(3) string.swapcase( ) : 새 객체를 생성하며, 새 객체 중 대문자는 소문자로, 소문자는 대문자로 바꿉니다

s = "I Need You"
print(s.swapcase()) # >>> "i nEED yOU"

9. 문자열 단순화합니다
때때로 문자열의 왼쪽 끝과 오른쪽 끝에 공백이 있는 경우가 있는데 이러한 공백은 문자열을 처리하는 데 영향을 미치므로 문자열을 단순화하고 이러한 양쪽 끝의 공백을 제거할 수 있는 기능이 있으면 매우 편리합니다.string.strip() 함수가 이 일을 합니다.

위의 함수와 마찬가지로 실제로 그는 새로운 문자열 객체를 생성했는데, 이 문자열은 원래 문자열과 비교하여 왼쪽과 오른쪽의 공백을 제거합니다.

s = "   I  Need You     "
s = s.strip() # >>> "I  Need You"

문자열 중앙의 공백은 영향을 받지 않습니다

10. 문자열을 뒤집습니다
문자열은 불변 객체이기 때문에 원칙적으로 위의 함수와 마찬가지로 새로운 객체만 생성할 수 있으며, 새로운 객체의 요소 배열은 원래 문자열이 뒤집힌 후의 모습입니다.
뒤집는 방법에는 두 가지가 있습니다.

(1) reversed( ) 함수입니다

s = "1234567"
s1 = reversed(s) # >> 새 개체 만들기
print(s1) # >>> "7654321"

(2) step = 1의 슬라이스입니다

s = "1234567"
s1 = s[:: -1] # >> 새로운 객체입니다
print(s1) # >>> "7654321"

Python-- 목록 해석입니다

Jammie — Wed, 11 Jan 2023 11:31:21 +0900

목록 분석의 출현은 Python에게 절대적으로 혁명적인 변화입니다.우리는 매우 간단한 목록 분석 공식을 통해 특정 규칙에 맞는 목록 구성을 완료하거나 함수 프로그래밍에서 map(), filter()와 같은 함수의 역할을 대체할 수 있습니다(함수 프로그래밍은 나중에 요약합니다).

먼저 목록 해석의 구문을 살펴보겠습니다:[expr foriter_val in iterable]
간단히 말해서, 반복 가능한 객체의 각 요소에 대해 식을 통해 요소에 작용하여 계산 결과를 얻은 다음 for 루프를 통해 반복 가능한 객체의 각 요소를 순회하고 작용 후 결과를 목록을 구성하는 것입니다.이 효과의 결과는 이전 요소에서 계산된 새로운 개체이거나 원래 요소일 수 있습니다.

컨셉 자체는 딱히 할 말이 없는데 너무 직관적이지 않아요.그래서 나는 리스트 해석이 어떻게 사용되는지 아래의 예를 들어 설명하겠습니다.

1. 시퀀스의 각 값을 순서대로 계산합니다.
순서를 하나 주려면, 이 순서 중의 매 수의 제곱을 얻어야 합니다

a = [1, 2, 3, 4, 5]
result = [x ** 2 for x in a] # x是元素，列表a是可迭代对象
print(result) # >>> [1, 4, 9, 16, 25]

물론 반복 가능한 대상이 어떤 법칙에 부합한다면 range() 표현으로 나타낼 수도 있습니다

print([x + 1 for x in range(10)]) # >>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

표현은 연산자를 통해 직접 쓸 수 있을 뿐만 아니라, 이미 정의된 함수일 수도 있습니다

def fun(num):
    return 2 * num - 1

print([fun(x) for x in range(3, 10)]) # >>> [5, 7, 9, 11, 13, 15, 17]

2. 체질서열입니다
사실 순서 중의 각 원소에 대한 계산이기도 하지만, 단지 선별하는 기능을 하는 것입니다.

예를 들어, 이제 2~30개의 모든 소수를 선별해서 리스트를 만들고 싶습니다

import math

# 소성 판단 함수를 정의합니다
def isPrime(num):
k = int(math.sqrt(num))
for i in range(2, k + 1):
if num % i == 0:
return False
return True

print([x for x in range(2, 31) if isPrime(x)]) # >>> [2, 3, 5, 7, 11, 13, 19, 23, 29]

3. 여러 쌍을 만듭니다
이제 할 일은 다음과 같은 형태로 2×32×3개의 숫자 쌍을 구성하는 것입니다.

(1,1),(1,2),(1,3),(2,1),(2,2),(2,3)(1,1),(1,2),(1,3),(2,1),(2,2),(2,3)
그러면 리스트 해석식을 통해서 이렇게 생성할 수 있습니다

[(x + 1, y + 1) for x in range(2) for y in range(3)]

4. 통계 문자입니다
물론 목록 해석을 통해 문자열의 문자 수를 계산할 수도 있습니다

s = "I wrote Python"
print(sum([len(i) for i in s.split()])) # >>> 12

이 예에서 먼저 s.split( )을 통해 시퀀스를 구성하고 시퀀스의 각 요소는 문자열 s의 각 단어이며 [len(i) for ins.split( )]을 통해 이러한 단어의 길이로 구성된 목록을 생성하고 마지막으로 sum( ) 함수를 통해 합쳐서 원래 여러 줄의 코드가 필요했던 작업, 목록 해석을 통해 간단한 코드 1줄만 필요함을 알 수 있습니다.

【이중 y축 그래프】파이썬은 이중 y축 그래프를 만듭니다

Jammie — Wed, 11 Jan 2023 11:21:48 +0900

import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 1, num=10)
y1 = x ** 2
y2 = -x ** 2
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot(x, y1, 'r', label="y1")
ax1.set_ylabel('y1')
ax2 = ax1.twinx()  # this is the important function
ax2.plot(x, y2, 'g', label="y2")
fig.legend()  # 合并图例
ax2.set_ylabel('y2')
ax2.set_xlabel('x')
plt.show()

파이썬 그림 - 점을 표시하고 점선을 그립니다

Jammie — Wed, 11 Jan 2023 11:19:31 +0900

import matplotlib.pyplot as plt
import numpy as np

# 함수 그래프
x = np.arange(0, 3, 0.01)
y = x ** 2 - 3 * x + 2
plt.plot(x, y)
plt.scatter ([1.5], [-0.25], s=25, c='r'') # 최소 치수입니다.
# 점의 레이블 (좌표에서 더하기 또는 빼기 `0.15`는 표시된 위치의 오프셋이므로 점을 가리지 않습니다)
plt.text(1.5+0.15, -0.25-0.15, 'minima', ha='center', va='bottom', fontsize=10.5) # horizontal alignment

# 점선 두 개를 긋습니다
plt.plot([0, 1.5], [-0.25, -0.25], c='b', linestyle='--')
plt.plot([1.5, 1.5], [0, -0.25], c='b', linestyle='--')

# 좌표축의 위치를 바꿉니다.
ax = plt.gca()
# 원래 위치로 이동합니다.
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))

파이썬 그림 함수

Jammie — Wed, 11 Jan 2023 11:12:41 +0900

파이썬 그림 함수
1.터틀 모듈을 사용합니다

import turtle

2. 브러시 상태 함수입니다

turtle.penup () # 브러시를 들어 올리면 이동 후 도형이 그려지지 않습니다.
turtle.pendown() #붓을 내려놓고 이동 후 도형을 그리며 penup()과 함께 사용합니다.
turtle.pensize(width) # 브러시 선의 굵기를 설정합니다. () 숫자를 채우면 숫자가 클수록 붓이 굵어집니다.
turtle.speed() # 브러시의 속도를 0에서 10 사이로 설정합니다.
turtle.pencolor () # 펜의 색을 설정합니다.
turtle.color( ) # 펜의 색상과 채우기 색상을 설정합니다
turtle.begin_fill( ) # 도면을 채우기 전에 이 함수를 호출합니다.
turtle.end_fill( ) #도면을 채웁니다.
turtle.filling () # 채우기 상태를 반환합니다. True는 채우기, False는 채우기입니다.
turtle.hideturtle () # 브러시를 숨깁니다.
turtle.showturtle() #브러쉬를 보여줍니다.
turtle.isvisible () # 브러시가 보이는지 확인하고, 보이면 True로 돌아갑니다

3.창 함수입니다

turtle.setup(width,height,startx,starty)
"""
wideth: 창 너비입니다.만약 정수가 되면 픽처의 값을 나타내고, 소수는 창폭과 화면의 비율을 나타냅니다
height : 창 높이입니다.만약 정수가 되면 픽처의 값을 나타내고, 소수는 창폭과 화면의 비율을 나타냅니다
startx: 창 왼쪽과 화면 왼쪽의 픽셀 거리입니다.값은 None이고 폼은 화면 수평 중앙에 있습니다
starty: 창 오른쪽과 화면 오른쪽의 픽셀 거리입니다.값은 None이고 창은 화면 수평 중앙에 있습니다
"""
turtle.screensize( ) # 창의 높이, 너비, 배경색을 설정합니다
turtle.clear( ) # 브러시의 상태를 변경하지 않고 현재 창을 비웁니다.
turtle.reset( ) # 현재 창을 비우고 위치 등을 기본값으로 재설정합니다

4. 브러시 운동 함수입니다

turtle.forword () # 현재 방향으로 움직입니다 () 픽셀 거리
turtle.backword () # 현재 반대 방향으로 움직입니다 () 픽셀 거리
turtle.right (angle) # 오른쪽으로 angle 각도 돌립니다
turtle.left(angle) # 왼쪽으로 angle 각도 돌립니다
turtle.setheading(angle) #현재 angle로 향하는 방향을 설정합니다
turtle.goto(x,y) #좌표로 이동합니다. (x,y)
turtle.setx(x) # 브러시의 가로 좌표를 x로 수정하고 세로 좌표는 변경하지 않습니다.
turtle.sety(y) # 브러시의 세로 좌표를 y로 수정하고 가로 좌표는 변경하지 않습니다.
turtle.home() # 브러시 위치를 원점으로 하고 방향을 동쪽으로 합니다.
turtle.circle(r,extent=None, step=None) #반경 r, 각도 e의 원 또는 호를 그립니다. steps는 원의 내접 다각형, 변의 수는 steps입니다.
turtle.undo () # 브러시의 마지막 단계를 취소합니다.
turtle.dot(radius, e) #반경이 r이고 색이 e인 점을 그립니다.
turtle.done () # 그림을 끝냅니다

5.터틀 라이브러리의 연습입니다.
예1: 하나의 for 사이클로, 보기 좋은 도형을 만듭니다

import turtle
turtle.speed(0)
turtle.color("red")
for i in range(260):
    turtle.forward(i)
    turtle.right(160)
turtle.done()

예 2: 터틀 프로그램을 사용하여 중앙 위치에서 시작하여 가장자리의 특정 지점에서 멈추는 방식으로 각자 자유롭게 걷는 것을 모방합니다

#체크요
import turtle
import random
turtle.speed(0)
row=8 #줄입니다
col=8 #열입니다
cell=40
uplimit=(row//2)*cell #상한입니다
downlimit=-(row//2)*cell #하한입니다
leftlimit=-(col//2)*cell #좌한계입니다
rightlimit=(col//2)*cell #오른쪽한계입니다
turtle.penup()
turtle.goto(leftlimit,uplimit)
turtle.pendown()
"""
#방법1소격법입니다
for i in range(1,9):
for j in range(1,9):
for k in range(1,5):
turtle.forward(cell)
turtle.right(90)
turtle.forward(cell)
turtle.penup()
turtle.goto(leftlimit,uplimit-i*cell)
turtle.pendown()
#turtle.done()
"""
# 방법2 가로세로선법입니다
for i in range(1,row+2):
turtle.forward(col*cell)
turtle.penup()
turtle.goto(leftlimit,uplimit-i*cell)
turtle.pendown()
turtle.up()
turtle.goto(leftlimit,uplimit)
turtle.pendown()
turtle.right(90)
for j in range(1,col+2):
turtle.forward(row*cell)
turtle.penup()
turtle.goto(leftlimit+j*cell,uplimit)
turtle.pendown()

turtle.penup()
turtle.goto(0,0)
turtle.pendown()
turtle.pensize(5)
x=0
y=0
while x!=leftlimit and y!=uplimit and y!=downlimit and x!=rightlimit:
direction=random.randint(0,3) #0동 1북 2서 3남입니다.
if direction==0:
x+=cell
if direction==1:
y+=cell
if direction==2:
x-=cell
if direction==3:
y-=cell
turtle.setheading(direction*90)
turtle.forward(cell)
print(x,y)
turtle.done()
turtle.hideturtle()

예3:write 함수를 사용하지 않고 lay를 켭니다

import turtle
#알파벳L입니다
turtle.penup()
turtle.goto(-200,150)
turtle.pendown()
turtle.pensize(10)
turtle.pencolor("yellow")
turtle.goto(-220,-100)
turtle.right(90)
turtle.circle(50,150)
# 알파벳 a입니다.
turtle.penup()
turtle.goto(-50,20)
turtle.pendown()
turtle.pencolor("red")
turtle.left(70)
turtle.circle(55,280)
turtle.penup()
turtle.goto(-50,20)
turtle.pendown()
turtle.right(170)
turtle.circle(70,90)
# 알파벳 y입니다.
turtle.penup()
turtle.goto(20,150)
turtle.pendown()
turtle.pencolor("blue")
turtle.goto(10,70)
turtle.right(50)
turtle.circle(50,60)
turtle.penup()
turtle.goto(100,150)
turtle.pendown()
turtle.goto(80,-130)
turtle.left(90)
turtle.circle(60,-100)
turtle.right(30)
turtle.circle(30,-60)
turtle.goto(150,0)
turtle.penup()
turtle.goto(45,30)
turtle.pendown()
turtle.left(130)
turtle.circle(50,70)
turtle.hideturtle()
turtle.done()

파이썬으로 크리스마스 트리를 만들어요

Jammie — Tue, 3 Jan 2023 10:48:40 +0900

코드를 입력하세요.
하나, 녹색 크리스마스 트리입니다

import turtle as t
from turtle import *
import random as r
import time

t.title("Merry Christmas")
screensize (bg='black') # 배경색입니다
setup(700, 700, startx=None, starty=None)
speed("fastest")


pencolor("#008500")
pensize(10)
penup()
hideturtle()
goto(0, 150)
showturtle()
pendown()
shape(name="classic")


# 1
seth(-120)
for i in range(10):
fd(12)
right(2)
penup()
goto(0, 150)
seth(-60)
pendown()
for i in range(10):
fd(12)
left(2)
seth(-150)
penup()
fd(10)
pendown()
for i in range(5):
    fd(10)
    right(15)
seth(-150)
penup()
fd(8)
pendown()
for i in range(5):
    fd(10)
    right(15)
seth(-155)
penup()
fd(5)
pendown()
for i in range(5):
    fd(7)
    right(15)
# 2
penup()
goto(-55, 34)
pendown()
seth(-120)
for i in range(10):
    fd(8)
    right(5)
 
penup()
goto(50, 35)
seth(-60)
pendown()
for i in range(10):
   fd(8)
    left(5)
seth(-120)
penup()
fd(10)
seth(-145)
pendown()
for i in range(5):
    fd(10)
    right(15)
penup()
fd(10)
seth(-145)
pendown()
for i in range(5):
    fd(12)
    right(15)
penup()
fd(8)
seth(-145)
pendown()
for i in range(5):
    fd(10)
    right(15)
penup()
seth(-155)
fd(8)
pendown()
for i in range(5):
    fd(11)
    right(15)

# 3
penup()
goto(-100, -40)
seth(-120)
pendown()
for i in range(10):
    fd(6)
    right(3)
penup()
goto(80, -39)
seth(-50)
pendown()
for i in range(10):
    fd(6)
    left(3)
seth(-155)
penup()
fd(10)
pendown()
for i in range(5):
    fd(8)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(8)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(7)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(7)
    right(10)
penup()
fd(8)
seth(-140)
pendown()
for i in range(7):
    fd(6)
    right(10)
 
# 4
penup()
goto(-120, -95)
seth(-130)
pendown()
for i in range(7):
    fd(10)
    right(5)
penup()
goto(100, -95)
seth(-50)
pendown()
for i in range(7):
    fd(10)
    left(5)
penup()
seth(-120)
fd(10)
seth(-155)

pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-155)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-155)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-160)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-160)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-165)
pendown()
for i in range(5):
    fd(10)
    right(11)
# 5
penup()
goto(-70, -165)
seth(-85)
pendown()
for i in range(3):
    fd(5)
    left(3)
penup()
goto(70, -165)
seth(-95)
pendown()
for i in range(3):
    fd(5)
    right(3)
seth(-170)
penup()
fd(10)
pendown()
pendown()
for i in range(10):
    fd(12)
    right(2)
# 6
penup()
goto(70, -165)
pendown()
seth(-90)
pensize(8)
pencolor("#00cc00")
circle(-20, 90)
 
penup()
goto(30, -185)
pendown()
seth(-180)
pensize(8)
pencolor("#00cc00")
fd(40)
 
penup()
goto(-5, -170)
pendown()
seth(-180)
pensize(8)
pencolor("#00cc00")
fd(35)
 
 
def guest(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(10)
        right(10)
 
 
def guet(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(10)
        left(10)
 
 
def qu(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(6)
        right(10)
    seth(-150)
    fd(20)
# 나뭇가지요
guest(-70, -150, 160)
guest(100, -150, 160)
guet(110, -110, 50)
guest(160, -140, 150)
qu(80, -120, 180)
guest(70, -85, 165)
guest(-40, -85, 165)
guet(90, -50, 50)
guest(130, -80, 150)
pencolor("#00cc00")
qu(-40, -60, 180)
pencolor('#00cc00')
qu(80, -30, 180)
pencolor("#00cc00")
qu(40, 10, 180)
pencolor("#00cc00")
guest(-60, 30, 120)
guest(-20, -20, 150)
guet(45, 40, 60)
guest(-30, 40, 170)
guest(-30, 110, 115)
guet(40, 90, 60)
guest(80, 50, 160)
pencolor("red")

def hdj(x, y):
    penup()
    goto(x, y)
    seth(80)
    pendown()
    pensize(2)
    circle(5)
    seth(10)
    fd(15)
    seth(120)
    fd(20)
    seth(240)
    fd(20)
    seth(180)
    fd(20)
    seth(-60)
    fd(20)
    seth(50)
    fd(20)
    seth(-40)
    fd(30)
    seth(-130)
    fd(5)
    seth(135)
    fd(30)
    seth(-60)
    fd(30)
    seth(-150)
    fd(6)
    seth(110)
    fd(30)
 
 
def uit(x, y):
    penup()
    goto(x, y)
    pendown()
    pensize(2)
    circle(5)
    seth(-10)
    fd(15)
    seth(90)
    fd(15)
    seth(200)
    fd(15)
    seth(160)
    fd(15)
    seth(-90)
    fd(15)
    seth(10)
    fd(15)
    seth(-60)
    fd(20)
    seth(-180)
    fd(5)
    seth(110)
    fd(20)
    seth(-90)
    fd(20)
    seth(-180)
    fd(6)
    seth(70)
    fd(15)
    hideturtle()
 
 
def yut(x, y, z):
    penup()
    goto(x, y)
    pendown()
    seth(z)
    for po in range(5):
        fd(4)
        left(36)
 
 
def ytu(x, y, z):
    penup()
    goto(x, y)
    pendown()
    seth(z)
    for kk in range(5):
        fd(4)
        left(36)
 
 
# 작은 리본이요
seth(0)
uit(40, -160)
hdj(-80, -120)
yut(-67, -115, 120)
yut(-86, -123, 150)
hdj(40, -50)
yut(52, -45, 130)
yut(34, -55, 160)
seth(0)
pencolor("pink")
uit(-20, -60)
ytu(-4, -60, 100)
ytu(-20, -60, 120)
hdj(-30, 20)
yut(-15, 25, 130)
yut(-40, 20, 180)
uit(30, 70)
ytu(45, 70, 100)
ytu(30, 70, 120)
# 빅 리본이요
pencolor("yellow")
pensize(5)
penup()
seth(0)
goto(0, 150)
pendown()
circle(10)
seth(-15)
fd(40)
seth(90)
fd(40)
seth(200)
fd(40)
seth(160)
fd(40)
seth(-90)
fd(40)
seth(15)
fd(40)
seth(-70)
pencolor("yellow")
pensize(4)
fd(40)
seth(-180)
fd(10)
seth(100)
fd(40)
seth(-100)
fd(40)
seth(-180)
fd(10)
seth(70)
fd(40)
penup()
seth(0)
goto(0, 130)
pencolor("yellow")
pendown()
 
 
def iou(x, y, z):
    penup()
    goto(x, y)
    pencolor("yellow")
    pendown()
    seth(z)
    for po in range(10):
        fd(4)
        left(18)
 
 
seth(0)
iou(35, 145, 100)
iou(-7, 145, 110)
pencolor("red")
pensize(7)
penup()
goto(-35, 135)
pendown()
 
# 산타 모자요
seth(-20)
pensize(2)
penup()
goto(-30, -120)
pencolor("white")
pendown()
fillcolor("red")
fd(30)
circle(4, 180)
fd(30)
circle(4, 180)
penup()
goto(-25, -115)
seth(75)
pendown()
begin_fill()
for i in range(5):
    fd(6)
    right(20)
seth(-10)
for i in range(5):
    fd(8)
    right(15)
seth(145)
for i in range(5):
    fd(5)
    left(2)
seth(90)
for i in range(5):
    fd(1)
    left(2)
seth(-90)
for i in range(4):
    fd(4)
    right(6)
seth(161)
fd(30)
end_fill()
pensize(1)
pencolor("white")
 
 
def koc(x, y, size):
    pensize(2)
    pencolor("yellow")
    penup()
    goto(x, y)
    pendown()
    begin_fill()
    fillcolor("yellow")
    for i in range(5):
        left(72)
        fd(size)
        right(144)
        fd(size)
    end_fill()
 
 
# 별
seth(-15)
koc(-120, -70, 10)
seth(10)
koc(100, -20, 10)
seth(-10)
koc(10, 40, 10)
seth(30)
koc(-80, 60, 10)
koc(100, -150, 10)
koc(-140, -150, 10)
koc(20, 120, 10)
# 양말
seth(-20)
pensize(2)
penup()
goto(-20, 80)
pencolor("white")
pendown()
fillcolor("red")
fd(25)
circle(4, 180)
fd(25)
circle(4, 180)
penup()
goto(-15, 80)
pendown()
begin_fill()
fillcolor("red")
seth(-120)
fd(20)
seth(150)
fd(5)
circle(7, 180)
fd(15)
circle(5, 90)
fd(30)
seth(160)
fd(18)
end_fill()
penup()
seth(0)
goto(100, -230)
pendown()
 
pencolor("yellow")
write("Merry Christmas To You              ", align="center", font=("Comic Sans MS", 24, "bold"))
 
def drawsnow():
    t.ht()  # 펜슬을 숨깁니다
    t.pensize(2)
    for i in range(70):
        t.pencolor("white")
        t.pu()  # 집필하다
        t.setx(r.randint(-350, 350))
        t.sety(r.randint(-80, 350))
        t.pd()  # 붓을 대다. 쓰기 시작하다
        dens = 6  # 눈송이의 수를 6으로 설정합니다
        snowsize = r.randint(1, 10)
        for j in range(dens):
            t.fd(int(snowsize))
            t.backward(int(snowsize))
            t.right(int(360 / dens))  #회전각도입니다
 
drawsnow()
done()

2.핑크크리스마스 트리입니다

import turtle as t
from turtle import *
import random as r
import time
 
t.title("Merry Christmas")
screensize(bg='black')#배경색입니다
setup(700, 700, startx=None, starty=None)
speed("fastest")
 
 
pencolor("pink")
pensize(10)
penup()
hideturtle()
goto(0, 150)
showturtle()
pendown()
shape(name="classic")
 
 
# 1
seth(-120)
for i in range(10):
    fd(12)
    right(2)
penup()
goto(0, 150)
seth(-60)
pendown()
for i in range(10):
    fd(12)
    left(2)
seth(-150)
penup()
fd(10)
pendown()
for i in range(5):
    fd(10)
    right(15)
seth(-150)
penup()
fd(8)
pendown()
for i in range(5):
    fd(10)
    right(15)
seth(-155)
penup()
fd(5)
pendown()
for i in range(5):
    fd(7)
    right(15)
# 2
penup()
goto(-55, 34)
pendown()
seth(-120)
for i in range(10):
    fd(8)
    right(5)
 
penup()
goto(50, 35)
seth(-60)
pendown()
for i in range(10):
    fd(8)
    left(5)
seth(-120)
penup()
fd(10)
seth(-145)
pendown()
for i in range(5):
    fd(10)
    right(15)
penup()
fd(10)
seth(-145)
pendown()
for i in range(5):
    fd(12)
    right(15)
penup()
fd(8)
seth(-145)
pendown()
for i in range(5):
    fd(10)
    right(15)
penup()
seth(-155)
fd(8)
pendown()
for i in range(5):
    fd(11)
    right(15)
# 3
penup()
goto(-100, -40)
seth(-120)
pendown()
for i in range(10):
    fd(6)
    right(3)
penup()
goto(80, -39)
seth(-50)
pendown()
for i in range(10):
    fd(6)
    left(3)
seth(-155)
penup()
fd(10)
pendown()
for i in range(5):
    fd(8)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(8)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(7)
    right(10)
penup()
fd(8)
seth(-145)
pendown()
for i in range(7):
    fd(7)
    right(10)
penup()
fd(8)
seth(-140)
pendown()
for i in range(7):
    fd(6)
    right(10)
 
# 4
penup()
goto(-120, -95)
seth(-130)
pendown()
for i in range(7):
    fd(10)
    right(5)
penup()
goto(100, -95)
seth(-50)
pendown()
for i in range(7):
    fd(10)
    left(5)
penup()
seth(-120)
fd(10)
seth(-155)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-155)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-155)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-160)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-160)
pendown()
for i in range(6):
    fd(8)
    right(10)
penup()
seth(-160)
fd(10)
seth(-165)
pendown()
for i in range(5):
    fd(10)
    right(11)
# 5
penup()
goto(-70, -165)
seth(-85)
pendown()
for i in range(3):
    fd(5)
    left(3)
penup()
goto(70, -165)
seth(-95)
pendown()
for i in range(3):
    fd(5)
    right(3)
seth(-170)
penup()
fd(10)
pendown()
pendown()
for i in range(10):
    fd(12)
    right(2)
# 6
penup()
goto(70, -165)
pendown()
seth(-90)
pensize(8)
pencolor("#de8891")
circle(-20, 90)
 
penup()
goto(30, -185)
pendown()
seth(-180)
pensize(8)
pencolor("#de8891")
fd(40)
 
penup()
goto(-5, -170)
pendown()
seth(-180)
pensize(8)
pencolor("#de8891")
fd(35)
 
 
def guest(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(10)
        right(10)
 
 
def guet(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(10)
        left(10)
 
 
def qu(x, y, z):
    penup()
    goto(x, y)
    seth(-z)
    pendown()
    for angel in range(5):
        fd(6)
        right(10)
    seth(-150)
    fd(20)
 
 
# 나뭇가지
guest(-70, -150, 160)
guest(100, -150, 160)
guet(110, -110, 50)
guest(160, -140, 150)
qu(80, -120, 180)
guest(70, -85, 165)
guest(-40, -85, 165)
guet(90, -50, 50)
guest(130, -80, 150)
pencolor("#de8891")
qu(-40, -60, 180)
pencolor('#de8891')
qu(80, -30, 180)
pencolor("#de8891")
qu(40, 10, 180)
pencolor("#de8891")
guest(-60, 30, 120)
guest(-20, -20, 150)
guet(45, 40, 60)
guest(-30, 40, 170)
guest(-30, 110, 115)
guet(40, 90, 60)
guest(80, 50, 160)
pencolor("red")
 
 
def hdj(x, y):
    penup()
    goto(x, y)
    seth(80)
    pendown()
    pensize(2)
    circle(5)
    seth(10)
    fd(15)
    seth(120)
    fd(20)
    seth(240)
    fd(20)
    seth(180)
    fd(20)
    seth(-60)
    fd(20)
    seth(50)
    fd(20)
    seth(-40)
    fd(30)
    seth(-130)
    fd(5)
    seth(135)
    fd(30)
    seth(-60)
    fd(30)
    seth(-150)
    fd(6)
    seth(110)
    fd(30)
 
 
def uit(x, y):
    penup()
    goto(x, y)
    pendown()
    pensize(2)
    circle(5)
    seth(-10)
    fd(15)
    seth(90)
    fd(15)
    seth(200)
    fd(15)
    seth(160)
    fd(15)
    seth(-90)
    fd(15)
    seth(10)
    fd(15)
    seth(-60)
    fd(20)
    seth(-180)
    fd(5)
    seth(110)
    fd(20)
    seth(-90)
    fd(20)
    seth(-180)
    fd(6)
    seth(70)
    fd(15)
    hideturtle()
 
 
def yut(x, y, z):
    penup()
    goto(x, y)
    pendown()
    seth(z)
    for po in range(5):
        fd(4)
        left(36)
 
 
def ytu(x, y, z):
    penup()
    goto(x, y)
    pendown()
    seth(z)
    for kk in range(5):
        fd(4)
        left(36)
 
 
# 작은 리본이요
seth(0)
uit(40, -160)
hdj(-80, -120)
yut(-67, -115, 120)
yut(-86, -123, 150)
hdj(40, -50)
yut(52, -45, 130)
yut(34, -55, 160)
seth(0)
pencolor("pink")
uit(-20, -60)
ytu(-4, -60, 100)
ytu(-20, -60, 120)
hdj(-30, 20)
yut(-15, 25, 130)
yut(-40, 20, 180)
uit(30, 70)
ytu(45, 70, 100)
ytu(30, 70, 120)
 
# 빅 리본이요
pencolor("#f799e6")
pensize(5)
penup()
seth(0)
goto(0, 150)
pendown()
circle(10)
seth(-15)
fd(40)
seth(90)
fd(40)
seth(200)
fd(40)
seth(160)
fd(40)
seth(-90)
fd(40)
seth(15)
fd(40)
seth(-70)
pencolor("#f799e6")
pensize(4)
fd(40)
seth(-180)
fd(10)
seth(100)
fd(40)
seth(-100)
fd(40)
seth(-180)
fd(10)
seth(70)
fd(40)
penup()
seth(0)
goto(0, 130)
pencolor("white")
pendown()
 
 
def iou(x, y, z):
    penup()
    goto(x, y)
    pencolor("#f799e6")
    pendown()
    seth(z)
    for po in range(10):
        fd(4)
        left(18)
 
#산타 모자요
seth(0)
iou(35, 145, 100)
iou(-7, 145, 110)
pencolor("red")
pensize(7)
penup()
goto(-35, 135)
pendown()
 
# 산타 모자요
seth(-20)
pensize(2)
penup()
goto(-30, -120)
pencolor("white")
pendown()
fillcolor("red")
fd(30)
circle(4, 180)
fd(30)
circle(4, 180)
penup()
goto(-25, -115)
seth(75)
pendown()
begin_fill()
for i in range(5):
    fd(6)
    right(20)
seth(-10)
for i in range(5):
    fd(8)
    right(15)
seth(145)
for i in range(5):
    fd(5)
    left(2)
seth(90)
for i in range(5):
    fd(1)
    left(2)
seth(-90)
for i in range(4):
    fd(4)
    right(6)
seth(161)
fd(30)
end_fill()
pensize(1)
pencolor("white")
 
 
def koc(x, y, size):
    pensize(2)
    pencolor("white")
    penup()
    goto(x, y)
    pendown()
    begin_fill()
    fillcolor("yellow")
    for i in range(5):
        left(72)
        fd(size)
        right(144)
        fd(size)
    end_fill()
 
 
# 별
seth(-15)
koc(-120, -70, 10)
seth(10)
koc(100, -20, 10)
seth(-10)
koc(10, 40, 10)
seth(30)
koc(-80, 60, 10)
koc(100, -150, 10)
koc(-140, -150, 10)
koc(20, 120, 10)
 
#양말
seth(-20)
pensize(2)
penup()
goto(-20, 80)
pencolor("white")
pendown()
fillcolor("red")
fd(25)
circle(4, 180)
fd(25)
circle(4, 180)
penup()
goto(-15, 80)
pendown()
begin_fill()
fillcolor("red")
seth(-120)
fd(20)
seth(150)
fd(5)
circle(7, 180)
fd(15)
circle(5, 90)
fd(30)
seth(160)
fd(18)
end_fill()
penup()
seth(0)
goto(100, -230)
pendown()
 
pencolor("yellow")
 
write("엄마, 크리스마스 잘 보내세요  ", align="center", font=("Comic Sans MS", 24, "bold"))
 
def drawsnow():
    t.ht()  # 펜슬을 숨깁니다
    t.pensize(2)
    for i in range(70):
        t.pencolor("white")
        t.pu()  # 집필하다
        t.setx(r.randint(-350, 350))
        t.sety(r.randint(-80, 350))
        t.pd()  # 붓을 대다. 쓰기 시작하다
        dens = 6  # 눈송이의 수를 6으로 설정합니다
        snowsize = r.randint(1, 10)
        for j in range(dens):
            t.fd(int(snowsize))
            t.backward(int(snowsize))
            t.right(int(360 / dens))  # 회전각도입니다
 
drawsnow()
done()

수정할 수 있습니다
코드의 브러시 색상, 덕담, 눈송이 모두 수정 가능합니다

python이 matplotlib의 savefig를 사용하여 그림을 저장할 때 불완전한 문제가 있습니다

Jammie — Thu, 15 Dec 2022 14:40:59 +0900

그림 1과 같이 다음과 같은 형식의 코드를 사용하여 이미지를 저장할 때 저장된 이미지가 불완전합니다.

plt.colorbar()
plt.savefig(title)
plt.show()

처음에 사진 크기 비율이 맞지 않는 줄 알고 아래 코드를 통해 수정했습니다

plt.figure(figsize=(10,8))

그런데 아무리 수정해도 밑에 불완전하게 보이거나 왼쪽에 불완전하게 보이거나 이런 경우가 항상 발생합니다.왜 그럴까요?

이것은 colorbar가 오른쪽을 차지하기 때문에 출력된 이미지가 왼쪽으로 치우쳐지기 때문입니다.

한참 동안 모색한 끝에 최종 해결책은 savefig( )의 매개변수에 bbox_inches = 'tight'를 추가하는 것입니다

plt.colorbar()
plt.savefig(title, dpi=300, bbox_inches = 'tight')
plt.show()

Python Matplotlib 그림 그리기 시작

Jammie — Thu, 15 Dec 2022 14:36:39 +0900

Matplotlib 소개입니다
Matplotlib은 다양한 하드 카피 형식과 플랫폼 간 대화형 환경으로 출판 품질 수준의 그래픽을 생성하는 파이썬의 2D 그래픽 라이브러리입니다.Matplotlib 매핑 스타일은 MATLAB에 매우 가깝기 때문에 Matplotlib라고 합니다.

만약 여러분이 Matplotlib을 배워야 한다면, 아마도 다음과 같습니다: 1. Matplotlib은 매우 강력한 Python 그림 그리기 도구입니다. 2. 손에 많은 데이터가 있습니다. 하지만 이 데이터를 어떻게 표현해야 할지 모르겠습니다.

선 그래프, 산점도, 등고선도, 막대 그래프, 막대 그래프, 막대 그래프, 3D 그래픽, 심지어 그래픽 애니메이션 등을 그립니다.

기본 개념입니다
우리가 matplotlib를 조작할 때 일반적으로 캔버스라고 하는 Figure에서 시작하여 실제로 그림을 그릴 때 캔버스처럼 작동합니다.그림판에 우리는 한 폭과 여러 폭의 도형을 그릴 수 있는데,이 도형이 바로 axes입니다.

좌표축, 눈금선, 레이블, 선, 마커 등과 같은 모든 그래픽 요소는 그래픽 인스턴스 위에 있습니다.

axes 인스턴스가 하나만 있는 경우 matplotlib.pyplot을 사용하여 이러한 그래픽 요소를 조작하여 완전한 그림을 '구성'할 수 있습니다.

기본 그림입니다.
도면을 작성하기 전에 해당 패키지를 가져와야 합니다. 그래프 요소를 조작하기 위해 파이플롯을 사용하고 도면에 필요한 기본 데이터를 생성하는 데 numpy를 사용합니다

import numpy as np
import matplotlib.pyplot as plt

기본적인 그림도 볼 수 있습니다:

x = np.linspace(0.0, 10, 1000)
y = np.sin(x)
plt.plot(x, y, ls="-.", lw=2, c="c", label="line plot")
plt.annotate("maximux", xy=(np.pi/2, 1), xytext=((np.pi/2)+1.0, 0.8), weight="bold", color="b",
            arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="b"))
plt.text(3.10, 0.09, "y=sin(x)", weight="bold", color="b")
plt.axhline(y=0.0, c="r", ls="--", lw=2)
plt.xlabel("x-axis")
plt.ylabel("y-axis")
plt.xlim(0, 11)
plt.title("y=sin(x)")
plt.legend(loc="upper right")
plt.show()

이 코드 문자열은 기본적으로 위의 대부분의 함수를 사용합니다

그림 개요

최종 그래서 코드입니다

#데이터 준비합니다
x = np.linspace(0.5, 3.5, 100)
y = np.sin(x)
np.random.seed(20)
y1 = np.random.randn(100)

#산점도요
plt.scatter(x, y1, c="0.25", label="scatter figure")

#선도표입니다
plt.plot(x, y, ls='--', lw=2, label="plot figure")

#위쪽과 오른쪽의 축을 숨깁니다
for spine in plt.gca().spines.keys():
if spine == "top" or spine == "right":
plt.gca().spines[spine].set_color("none")

#위쪽과 오른쪽의 좌표축 눈금을 숨깁니다
plt.gca().xaxis.set_ticks_position("bottom")
plt.gca().yaxis.set_ticks_position("left")

#좌표 가로 세로 범위입니다
plt.xlim(0.0, 4.0)
plt.ylim(-3.0, 3.0)

#좌표축 레이블을 설정합니다
plt.xlabel("x_axis")
plt.ylabel("y_axis")

#좌표 격자 설정하기
plt.grid(True, ls=":", color="r")

#수평선을 추가합니다.
plt.axhline(y=0.0, c="r", ls="--", lw=2)
#수직 영역을 추가합니다.
plt.axvspan(xmin=1.0, xmax=2.0, facecolor="y", alpha=.3)

#댓글 정보를 설정합니다

#최고점 주석입니다.
plt.annotate("maximum", xy=(np.pi/2, 1.0), xytext=((np.pi/2)+0.15, 1.8), weight="bold", color="r",
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#spines 주석 오른쪽 화살표입니다
plt.annotate("spines", xy=(0.75, -3), xytext=(0.35, -2.25), weight="bold", color="r",
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="b"))

#spines 주석 왼쪽 화살표입니다
plt.annotate("", xy=(0, -2.78), xytext=(0.4, -2.32),
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="b"))

# tickline 주석 화살표입니다
plt.annotate("", xy=(3.5, -2.98), xytext=(3.6, -2.70),
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="b"))

#tickline 주석 문자입니다
plt.text(3.6, -2.70,"'|' is tickline", weight="bold", color="b")
plt.text(3.6, -2.95,"3.5 is ticklabel", weight="bold", color="b")

# 제목을 설정합니다.
plt.title("structure of matplotlib")

#grid 주석입니다
plt.annotate("grid()", xy=(0.22, 1), xytext=(0.36, 1.4), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

# 제목 설명입니다
plt.annotate("title()", xy=(2.1, 3.0), xytext=(1.2, 2.4), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#수평선 주석입니다
plt.annotate("axhline()", xy=(0.4, 0), xytext=(0.1, -0.8), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

# 범례 주석입니다.
plt.annotate("legend()", xy=(3.5, 2), xytext=(3.9, 1.2), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

# 산점도 주석입니다.
plt.annotate("scatter()", xy=(3.49, 0.86), xytext=(3.9, 0.6), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#선도 주석입니다.
plt.annotate("plot()", xy=(3.48, -0.31), xytext=(3.9, -0.5), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#텍스트 주석입니다.
plt.annotate("text()", xy=(3.9, -2.5), xytext=(3.9, -1.8), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#수직 영역 설명입니다
plt.annotate("axvspan()", xy=(1.2, 2.1), xytext=(0.3, 2.2), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#화살표 주석이 달린 주석입니다.
plt.annotate("annotate()", xy=(0.4, -2.05), xytext=(0.18, -1.5), color='g',
arrowprops=dict(arrowstyle="->", connectionstyle="arc3", color="r"))

#횡좌표 텍스트 주석입니다.
plt.text(2.2, -3.85, "-->xlabel()",color='g')

# 가로 좌표 범위 설명입니다
plt.text(1.7, -4.4, "[0.0,4.0]: xlim()",color='g')

#바깥테두리 밑부분이요
plt.text(-0.7, -4.6, "----------------"*8, color="r")

#외곽 상단입니다
plt.text(-0.7, 4.2, "----------------"*8, color="r")

#바깥쪽 테두리 왼쪽
plt.text(-0.75, -4.4, '-----------'*8,color='r', rotation='vertical')

#바깥틀 오른쪽입니다
plt.text(4.76, -4.4, '-----------'*8,color='r', rotation='vertical')

#Figure 주석입니다.
plt.text(-0.65, 3.8, 'Figure', fontsize=16, color='r', weight='bold')

#axes 설명입니다
plt.text(0.03, 2.7, 'Axes', fontsize=16, color='r', weight='bold')

# 범례를 설정합니다.
plt.legend(loc="upper right")

plt.savefig(fname="./test_chao_2.png", dpi=300)
plt.show()

또 다른 화법은 Axes를 이용하는 거예요

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import AutoMinorLocator, MultipleLocator, FuncFormatter

np.random.seed(19680801)
# 동일한 seed() 값을 사용하면 매번 생성되는 난수가 동일합니다.이 값을 설정하지 않으면 매번 생성되는 난수가 다릅니다.

X = np.linspace (0.5, 3.5, 100) # 생성x입니다.
Y1 = 3+np.cos(X) # y1
Y2 = 1+np.cos(1+X/0.75)/2 # y2
Y3 = np.random.uniform(Y1, Y2, len(X))
# 균일한 분포[low, high]에서 무작위로 샘플링되며 정의 도메인은 왼쪽 닫힘과 오른쪽 열림, 즉 low를 포함하고 high를 포함하지 않습니다.

fig = plt.figure (figsize= (8, 8)) # 그림 크기입니다.
ax = fig.add_subplot(1, 1, 1, aspect=1) # 다중 서브그래프입니다.

def minor_tick(x, pos): # 작은 tick을 정의합니다.
if not x % 1.0:
return ""
return "%.2f" % x

ax.xaxis.set_major_locator(MultipleLocator(1.000))
ax.xaxis.set_minor_locator(AutoMinorLocator(4))
ax.yaxis.set_major_locator(MultipleLocator(1.000))
ax.yaxis.set_minor_locator(AutoMinorLocator(4) # 길이 tick 설정하기
ax.xaxis.set_minor_formatter(FuncFormatter(minor_tick)) # 형식입니다.
# ax.xaxis.set_major_locator의 방법으로 눈금 위치를 설정합니다

ax.set_xlim (0, 4) # x 표시 범위입니다
ax.set_ylim (0, 4) #y 표시 범위입니다.

ax.tick_params(which='major', width=1.0) # tick
ax.tick_params(which='major', length=10)
ax.tick_params(which='minor', width=1.0, labelsize=10)
ax.tick_params(which='minor', length=5, labelsize=10, labelcolor='0.25')

ax.grid (linestyle="--", linewidth=0.5, color=".25", zorder=-10) # 격자점선입니다.

ax.plot(X, Y1, c=(0.25, 0.25, 1.00), lw=2, label="Blue signal", zorder=10)
ax.plot(X, Y2, c=(1.00, 0.25, 0.25), lw=2, label="Red signal")
ax.plot(X, Y3, linewidth=0,
marker='o', markerfacecolor='w', markeredgecolor='k')

ax.set_title("Anatomy of a figure", fontsize=20, verticalalignment='bottom')
ax.set_xlabel("X axis label")
ax.set_ylabel("Yaxis label") #y 이름입니다.

ax.legend()

def circle(x, y, radius=0.15): # 함수를 정의합니다.
from matplotlib.patches import Circle
from matplotlib.patheffects import withStroke
circle = Circle((x, y), radius, clip_on=False, zorder=10, linewidth=1,
edgecolor='black', facecolor=(0, 0, 0, .0125),
path_effects=[withStroke(linewidth=5, foreground='w')])
ax.add_artist(circle)

def text(x, y, text):
ax.text(x, y, text, backgroundcolor="white",
ha='center', va='top', weight='bold', color='blue')

# # Minor tick
circle(0.50, -0.10)
text(0.50, -0.32, "Minor tick label")

# # Major tick
circle(-0.03, 4.00)
text(0.03, 3.80, "Major tick")

# # Minor tick
circle(0.00, 3.50)
text(0.00, 3.30, "Minor tick")

# # Major tick label
circle(-0.15, 3.00)
text(-0.15, 2.80, "Major tick label")

# # X Label
circle(1.80, -0.27)
text(1.80, -0.45, "X axis label")

# # Y Label
circle(-0.27, 1.80)
text(-0.27, 1.6, "Y axis label")

# # Title
circle(1.60, 4.13)
text(1.60, 3.93, "Title")

# # Blue plot
circle(1.75, 2.80)
text(1.75, 2.60, "Line\n(line plot)")

# # Red plot
circle(1.20, 0.60)
text(1.20, 0.40, "Line\n(line plot)")

# # Scatter plot
circle(3.20, 1.75)
text(3.20, 1.55, "Markers\n(scatter plot)")

# # Grid
circle(3.00, 3.00)
text(3.00, 2.80, "Grid")

# # Legend
circle(3.70, 3.80)
text(3.70, 3.60, "Legend")

# # Axes
circle(0.5, 0.5)
text(0.5, 0.3, "Axes")

# # Figure
circle(-0.3, 0.65)
text(-0.3, 0.45, "Figure")

# 화살표, 글꼴 치수입니다
color = 'blue'
ax.annotate('Spines', xy=(4.0, 0.35), xycoords='data',
xytext=(3.3, 0.5), textcoords='data',
weight='bold', color=color,
arrowprops=dict(arrowstyle='->',
connectionstyle="arc3",
color=color))

ax.annotate('', xy=(3.15, 0.0), xycoords='data',
xytext=(3.45, 0.45), textcoords='data',
weight='bold', color=color,
arrowprops=dict(arrowstyle='->',
connectionstyle="arc3",
color=color))

ax.text(4.0, -0.4, "Made with http://matplotlib.org", # text
fontsize=10, ha="right", color='.5')

plt.savefig(fname="./test.png", dpi=300)
plt.show()

Python 그림 그리기, 점선 그림입니다

Jammie — Thu, 15 Dec 2022 14:28:42 +0900

import matplotlib.pyplot as plt
import matplotlib.pylab as pylab
import scipy.io
import numpy as np
params={
'axes.labelsize': '35', #축 위의 글자입니다.
'xtick.labelsize': '27', #축 범례
'ytick.labelsize': '27', #축 범례
'lines.linewidth':2, #선폭입니다.
'legend.fontsize': '27', # 범례 크기입니다.
'figure.figsize': '12, 9' # set figure size, 가로 12, 세로 9입니다.
}
pylab.rcParams.update(params) #set figure parameter
#그림 라이브러리 업데이트입니다.

#line_styles=['ro-','b^-','gs-','ro--','b^--','gs--'] #set line style

#We give the coordinate date directly to give an example.
x1 = [-20,-15,-10,-5,0,0,5,10,15,20]

y1 = [0,0.04,0.1,0.21,0.39,0.74,0.78,0.80,0.82,0.85]
y2 = [0,0.014,0.03,0.16,0.37,0.78,0.81,0.83,0.86,0.92]
y3 = [0,0.001,0.02,0.14,0.34,0.77,0.82,0.85,0.90,0.96]
y4 = [0,0,0.02,0.12,0.32,0.77,0.83,0.87,0.93,0.98]
y5 = [0,0,0.02,0.11,0.32,0.77,0.82,0.90,0.95,1]


plt.plot(x1,y1,'bo-',label='m=2, p=10%',markersize=20) # in 'bo-', b is blue, o is O marker, - is solid line and so on
plt.plot(x1,y2,'gv-',label='m=4, p=10%',markersize=20)
plt.plot(x1,y3,'ys-',label='m=6, p=10%',markersize=20)
plt.plot(x1,y4,'ch-',label='m=8, p=10%',markersize=20)
plt.plot(x1,y5,'mD-',label='m=10, p=10%',markersize=20)

fig1 = plt.figure(1)
axes = plt.subplot(111)
#코드는 별로 할 말이 없습니다, 여기 plt.subplot(111)이라는 함수만 말씀드리겠습니다.
#plt.subplot(111)과 plt.subplot(1,1,1)은 동등합니다.영역을 1행 1열로 나눈다는 뜻으로, 현재 첫 번째 그림(줄에서 열로 정렬)을 그립니다.
#plt.subplot(211)은 영역을 2행 1열로 나누는 것을 의미하며, 현재 첫 번째 그림(첫 번째 줄, 첫 번째 열)을 그립니다.이와 같이 유추하면 10을 초과하지 않는 한 쉼표를 생략할 수 있습니다.

#axes = plt.gca()
axes.set_xticks([-20,-15,-10,-5,0,5,10,15,20])
axes.set_yticks([0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0])
axes.grid(True) # add grid

plt.legend(loc="lower right") #set legend location
plt.ylabel('Percentage') # set ystick label
plt.xlabel('Difference') # set xstck label

plt.savefig('plot_test1.png',dpi = 1000,bbox_inches='tight')
plt.show()

파이썬 그림 애플릿입니다

Jammie — Thu, 15 Dec 2022 14:24:41 +0900

올림픽 오륜입니다

import turtle
t = turtle.Pen()
t.speed(1)
# 브러쉬 색상은 파란색입니다
t.pencolor("blue")
# 브러시의 너비는 8입니다.
t.pensize(8)
# 반지름이 60인 원, 바스켓을 그려주세요.
t.circle(60)
# 첫 번째 링입니다
t.penup()
t.goto(100,0)
t.pendown()
링의 색을 설정합니다
t.pencolor("black")
t.circle(60)
# 두 번째 고리입니다
t.penup()
t.goto(200,0)
t.pendown()
t.pencolor("red")
t.circle(60)
# 세 번째 고리입니다
t.penup()
t.goto(60,-70)
t.pendown()
t.pencolor("yellow")
t.circle(60)
# 네 번째 고리입니다
t.penup()
t.goto(150,-70)
t.pendown()
t.pencolor("green")
t.circle(60)

탕후루요

import turtle
t = turtle.Pen()
# 브러시 속도를 설정합니다.
t.speed(3)
# 빨간색 채우기를 시작합니다.
t.begin_fill()
# 채우기 색상은 빨간색으로 합니다
t.color("red")
# 반경이 50인 원을 그리세요.
t.circle(60)
t.end_fill()
# 파란색 동그라미가 있어요
t.penup()
t.goto(65,65)
t.pendown()
# 채우기 시작합니다
t.begin_fill()
# 채우기 색을 설정합니다
t.color("blue")
# 브러시 색상을 설정합니다.
t.pencolor("red")
t.circle(60)
t.end_fill()
# 노란색 동그라미가 있어요
t.penup()
t.goto(130,130)
t.pendown()
t.begin_fill()
t.color("yellow")
t.pencolor("red")
t.circle(60)
t.end_fill()
# 보라색 원이에요.
t.penup()
t.goto(195,195)
t.pendown()
t.begin_fill()
t.color("purple")
t.pencolor("red")
t.circle(60)
t.end_fill()
# 막대기요
t.penup()
# 막대 너비를 설정합니다
t.pensize(10)
# 막대기 색을 설정합니다.
t.pencolor("green")
# 막대 시작 좌표를 설정합니다
t.goto(240,280)
t.pendown()
# 막대 끝 좌표를 설정합니다
t.goto(-140,-90)

파이썬이 그림을 그릴 때 사용하는 색상입니다

Jammie — Thu, 15 Dec 2022 14:18:58 +0900

matplotlib에서 color를 사용할 수 있는 색상:

‘aliceblue’: ‘#F0F8FF’,
‘antiquewhite’: ‘#FAEBD7’,
‘aqua’: ‘#00FFFF’,
‘aquamarine’: ‘#7FFFD4’,
‘azure’: ‘#F0FFFF’,
‘beige’: ‘#F5F5DC’,
‘bisque’: ‘#FFE4C4’,
‘black’: ‘#000000’,
‘blanchedalmond’: ‘#FFEBCD’,
‘blue’: ‘#0000FF’,
‘blueviolet’: ‘#8A2BE2’,
‘brown’: ‘#A52A2A’,
‘burlywood’: ‘#DEB887’,
‘cadetblue’: ‘#5F9EA0’,
‘chartreuse’: ‘#7FFF00’,
‘chocolate’: ‘#D2691E’,
‘coral’: ‘#FF7F50’,
‘cornflowerblue’: ‘#6495ED’,
‘cornsilk’: ‘#FFF8DC’,
‘crimson’: ‘#DC143C’,
‘cyan’: ‘#00FFFF’,
‘darkblue’: ‘#00008B’,
‘darkcyan’: ‘#008B8B’,
‘darkgoldenrod’: ‘#B8860B’,
‘darkgray’: ‘#A9A9A9’,
‘darkgreen’: ‘#006400’,
‘darkkhaki’: ‘#BDB76B’,
‘darkmagenta’: ‘#8B008B’,
‘darkolivegreen’: ‘#556B2F’,
‘darkorange’: ‘#FF8C00’,

‘darkorchid’: ‘#9932CC’,
‘darkred’: ‘#8B0000’,
‘darksalmon’: ‘#E9967A’,
‘darkseagreen’: ‘#8FBC8F’,
‘darkslateblue’: ‘#483D8B’,
‘darkslategray’: ‘#2F4F4F’,
‘darkturquoise’: ‘#00CED1’,
‘darkviolet’: ‘#9400D3’,
‘deeppink’: ‘#FF1493’,
‘deepskyblue’: ‘#00BFFF’,
‘dimgray’: ‘#696969’,
‘dodgerblue’: ‘#1E90FF’,
‘firebrick’: ‘#B22222’,
‘floralwhite’: ‘#FFFAF0’,
‘forestgreen’: ‘#228B22’,
‘fuchsia’: ‘#FF00FF’,
‘gainsboro’: ‘#DCDCDC’,
‘ghostwhite’: ‘#F8F8FF’,
‘gold’: ‘#FFD700’,
‘goldenrod’: ‘#DAA520’,
‘gray’: ‘#808080’,
‘green’: ‘#008000’,
‘greenyellow’: ‘#ADFF2F’,
‘honeydew’: ‘#F0FFF0’,
‘hotpink’: ‘#FF69B4’,
‘indianred’: ‘#CD5C5C’,
‘indigo’: ‘#4B0082’,
‘ivory’: ‘#FFFFF0’,
‘khaki’: ‘#F0E68C’,
‘lavender’: ‘#E6E6FA’,

‘lavenderblush’: ‘#FFF0F5’,
‘lawngreen’: ‘#7CFC00’,
‘lemonchiffon’: ‘#FFFACD’,
‘lightblue’: ‘#ADD8E6’,
‘lightcoral’: ‘#F08080’,
‘lightcyan’: ‘#E0FFFF’,
‘lightgoldenrodyellow’: ‘#FAFAD2’,
‘lightgreen’: ‘#90EE90’,
‘lightgray’: ‘#D3D3D3’,
‘lightpink’: ‘#FFB6C1’,
‘lightsalmon’: ‘#FFA07A’,
‘lightseagreen’: ‘#20B2AA’,
‘lightskyblue’: ‘#87CEFA’,
‘lightslategray’: ‘#778899’,
‘lightsteelblue’: ‘#B0C4DE’,
‘lightyellow’: ‘#FFFFE0’,
‘lime’: ‘#00FF00’,
‘limegreen’: ‘#32CD32’,
‘linen’: ‘#FAF0E6’,
‘magenta’: ‘#FF00FF’,
‘maroon’: ‘#800000’,
‘mediumaquamarine’: ‘#66CDAA’,
‘mediumblue’: ‘#0000CD’,
‘mediumorchid’: ‘#BA55D3’,
‘mediumpurple’: ‘#9370DB’,
‘mediumseagreen’: ‘#3CB371’,
‘mediumslateblue’: ‘#7B68EE’,

‘mediumspringgreen’: ‘#00FA9A’,
‘mediumturquoise’: ‘#48D1CC’,
‘mediumvioletred’: ‘#C71585’,
‘midnightblue’: ‘#191970’,
‘mintcream’: ‘#F5FFFA’,
‘mistyrose’: ‘#FFE4E1’,
‘moccasin’: ‘#FFE4B5’,
‘navajowhite’: ‘#FFDEAD’,
‘navy’: ‘#000080’,
‘oldlace’: ‘#FDF5E6’,
‘olive’: ‘#808000’,
‘olivedrab’: ‘#6B8E23’,
‘orange’: ‘#FFA500’,
‘orangered’: ‘#FF4500’,
‘orchid’: ‘#DA70D6’,
‘palegoldenrod’: ‘#EEE8AA’,
‘palegreen’: ‘#98FB98’,
‘paleturquoise’: ‘#AFEEEE’,
‘palevioletred’: ‘#DB7093’,
‘papayawhip’: ‘#FFEFD5’,
‘peachpuff’: ‘#FFDAB9’,
‘peru’: ‘#CD853F’,
‘pink’: ‘#FFC0CB’,
‘plum’: ‘#DDA0DD’,
‘powderblue’: ‘#B0E0E6’,
‘purple’: ‘#800080’,
‘red’: ‘#FF0000’,

rosybrown’: ‘#BC8F8F’,
‘royalblue’: ‘#4169E1’,
‘saddlebrown’: ‘#8B4513’,
‘salmon’: ‘#FA8072’,
‘sandybrown’: ‘#FAA460’,
‘seagreen’: ‘#2E8B57’,
‘seashell’: ‘#FFF5EE’,
‘sienna’: ‘#A0522D’,
‘silver’: ‘#C0C0C0’,
‘skyblue’: ‘#87CEEB’,
‘slateblue’: ‘#6A5ACD’,
‘slategray’: ‘#708090’,
‘snow’: ‘#FFFAFA’,
‘springgreen’: ‘#00FF7F’,
‘steelblue’: ‘#4682B4’,
‘tan’: ‘#D2B48C’,
‘teal’: ‘#008080’,
‘thistle’: ‘#D8BFD8’,
‘tomato’: ‘#FF6347’,
‘turquoise’: ‘#40E0D0’,
‘violet’: ‘#EE82EE’,
‘wheat’: ‘#F5DEB3’,
‘white’: ‘#FFFFFF’,
‘whitesmoke’: ‘#F5F5F5’,
‘yellow’: ‘#FFFF00’,
‘yellowgreen’: ‘#9ACD32’}

위에 해당하는 색상:

다른 표시 방식:

다른 그림을 그릴 때 자주 사용합니다:

‘.’ point marker
‘,’ pixel marker
‘o’ circle marker
‘v’ triangle_down marker
‘^’ triangle_up marker
‘<’ triangle_left marker
‘>’ triangle_right marker
‘1’ tri_down marker
‘2’ tri_up marker
‘3’ tri_left marker
‘4’ tri_right marker
‘s’ square marker
‘p’ pentagon marker
‘*’ star marker
‘h’ hexagon1 marker
‘H’ hexagon2 marker
‘+’ plus marker
‘x’ x marker
‘D’ diamond marker
‘d’ thin_diamond marker
‘|’ vline marker
‘_’ hline marker

정말 재미있는 파이썬 그림 - 날짜를 그립니다

Jammie — Tue, 13 Dec 2022 14:54:43 +0900

초라하고 간단한 글씨입니다

import turtle


def drawline(draw):
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)


def drawdigit(digit):
    drawline(True) if digit in [2, 3, 4, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 3, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 6, 8] else drawline(False)
    turtle.left(90)
    drawline(True) if digit in [0, 4, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 3, 5, 6, 7, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else drawline(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)


def drawdate(date):
    for i in date:
        drawdigit(eval(i))


def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawdate('20200421')
    turtle.hideturtle()
    turtle.done()


main()

실행 결과입니다

고급 글씨입니다

import turtle, time


def drawgap():
    turtle.penup()
    turtle.fd(5)


def drawline(draw):
    drawgap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawgap()
    turtle.right(90)


def drawdigit(digit):
    drawline(True) if digit in [2, 3, 4, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 3, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 6, 8] else drawline(False)
    turtle.left(90)
    drawline(True) if digit in [0, 4, 5, 6, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 2, 3, 5, 6, 7, 8, 9] else drawline(False)
    drawline(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else drawline(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)


def drawdate(date):
    turtle.pencolor('red')
    for i in date:
        if i == '-':
            turtle.write('年', font=('Arial', 18, 'normal'))
            turtle.pencolor('green')
            turtle.fd(40)
        elif i == '=':
            turtle.write('月', font=('Arial', 18, 'normal'))
            turtle.pencolor('blue')
            turtle.fd(40)
        elif i == '+':
            turtle.write('日', font=('Arial', 18, 'normal'))
        else:
            drawdigit(eval(i))


def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawdate(time.strftime('%Y-%m=%d+', time.gmtime()))
    turtle.hideturtle()
    turtle.done()


main()

실행 결과입니다

파이썬은 여러 가지 재미있는 그림과 소스를 그립니다

Jammie — Tue, 13 Dec 2022 14:42:29 +0900

Turtle 라이브러리는 Python 언어에서 널리 사용되는 그래픽 매핑의 함수 라이브러리로 가로축이 x이고 세로축이 y인 좌표계의 원점(0,0) 위치에서 시작하는 작은 거북이를 상상하며 함수 명령의 제어에 따라 이 평면 좌표계를 이동하여 기어가는 경로에 그래픽을 그립니다

1.안드로이드 소인이요

#!/usr/bin/env python
import turtle
aj=turtle.Pen()
y=0
aj.speed(5)
#turtle.screensize(200,800)
turtle.bgcolor("black")
#aj.shape("turtle")
def head():
    aj.color("green")
    aj.fd(160)
    x=aj.xcor()
    aj.seth(90)
    aj.begin_fill()
    #aj.color("green")
    aj.circle(x/2,180)
    aj.end_fill()
    aj.penup()
    aj.goto(33,37)
    aj.pendown()
    aj.dot(13,"black")
    aj.penup()
    aj.goto(126,37)
    aj.pendown()
    aj.dot(13,"black")
    aj.penup()
    aj.home()
    aj.pendown()
    aj.hideturtle()
    aj.fd(160)
    aj.seth(90)
    aj.circle(x/2,60)
    aj.right(90)
    aj.pensize(5)
    aj.fd(30)
 
    aj.penup()
    aj.home()
    #aj.pendown()
    aj.hideturtle()
    aj.fd(160)
    aj.seth(90)
    aj.circle(x/2,120)
    aj.right(90)
    aj.pensize(5)
    aj.pendown()
    aj.fd(30)
    aj.penup()
    aj.home()
    aj.penup()
 
def body():
    aj.pensize(0)
    aj.home()
    aj.showturtle()
    aj.goto(0,-7)
    aj.pendown()
    aj.begin_fill()
    aj.fd(160)
    aj.right(90)
    aj.fd(120)
    aj.right(90)
    aj.fd(160)
    y=aj.ycor()
    aj.right(90)
    aj.fd(120)
    aj.end_fill()
 
def legs():
    aj.penup()
    #turtle.color("red")
    aj.goto(33,-169)
    aj.pendown()
    aj.pensize(32)
    aj.fd(43)
    aj.penup()
    aj.goto(130,-169)
    aj.pendown()
    aj.fd(43)
    aj.penup()
def hands():
    aj.home()
    aj.pensize(30)
    aj.goto(-18,-77)
    aj.pendown()
    aj.left(90)
    aj.fd(65)
    aj.penup()
    aj.goto(179,-77)
    aj.pendown()
    aj.fd(65)
    aj.penup()
    aj.hideturtle
    aj.fd(100)
    aj.hideturtle()
    aj.circle(100)
    aj.circle(100,360,59)
    aj.reset()
    turtle.bgcolor("black")
    turtle.pencolor("green")
    turtle.hideturtle()
    turtle.goto(-300,0)
    aj.hideturtle
    turtle.write("Thank you for watching....", font = ("Bodoni MT Black", 28, "bold"))
    turtle.penup()
    turtle.goto(-40,-170)
    turtle.pendown()
    turtle.pencolor("yellow")
    turtle.write("Developed by 버그 잘 쓰는 안태늑대입니다", font = ("Palatino Linotype", 22, "bold"))
head()
body()
legs()
hands()
turtle.done()

효과도:

2. 드래곤 커브 (Dragon Curve) 입니다.
프랙탈 용이라고도 하며, 자기 유사 파쇄 곡선의 총칭으로 용의 굽이굽이 구부러져 있다고 해서 붙여진 이름입니다

# -*- coding: utf-8 -*-
 
from turtle import *
length = 5
angle  = 90
setup(1280,720)
up()
goto(300,-100)
 
down()
def draw_path(path):
    for symbol in path:
        if symbol == 'f':
            import random
            colormode(255)
            color(random.randint(0,255),random.randint(0,255),random.randint(0,255))
            fd(length)
        elif symbol == '-':
            lt(angle)
        elif symbol == '+':
            rt(angle)
 
def apply_path(rules,path):
    lit = [x for x in path]
    for i in range(len(lit)):
        symbol = lit[i]
        if symbol == 'x':
            lit[i] = rules[symbol]
        elif symbol == 'y':
            lit[i] = rules[symbol]
    path = ''.join(lit)
    return path
 
rules = {
    'x':'x+yf+',
    'y':'-fx-y'
}
path = 'fx'
speed(0)
for i in range(13):
    path = apply_path(rules,path)
draw_path(path)
done()

효과도:

3. 앵두나무입니다.

# # -*- coding: utf-8 -*-

import turtle

toplevel = 8 # 총 6계층 재귀입니다
angle = 30
rangle = 15


def drawTree(length, level):
turtle.left(angle) # 왼쪽 가지를 그립니다
turtle.color("black")
turtle.forward(length)

if level == toplevel: # 잎입니다
turtle.color("pink")
turtle.circle(2, 360)

if level < toplevel: # 왼쪽 가지를 되돌리기 전에 재귀합니다.
drawTree(length - 10, level + 1)
turtle.back(length)

turtle.right (angle + rangle) # 오른쪽 가지를 그립니다
turtle.color("black")
turtle.forward(length)

if level == toplevel: # 잎입니다
turtle.color("pink")
turtle.circle(2, 360)

if level < toplevel: # 오른쪽 가지를 되돌리기 전에 재귀합니다.
drawTree(length - 10, level + 1)
turtle.color("black")
turtle.back(length)
turtle.left(rangle)


turtle.left(90)
turtle.penup()
turtle.back(300)
turtle.pendown()
turtle.forward(100)
turtle.speed('fastest')
drawTree(80, 1)

turtle.done()

효과도:

4, 코흐 눈꽃입니다.
(더 많은 자료를 얻으려면 아래로 내려주세요)

import turtle as t
from turtle import *
import random
 
def draw_path(path):
    t.colormode(255)
    t.color(random.randint(0,255),random.randint(0,255),random.randint(0,255))
    for symbol in path:
        if symbol == 'F':
            forward(length)
        elif symbol == '-':
            right(angle)
        elif symbol == '+':
            left(angle)
 
def apply_rule(path):
    rule = 'F+F--F+F'
    return path.replace('F',rule)
 
length = .5
angle  = 60
setup(1280,720)
bgcolor('black')
up()
color("#0fe6ca")
goto(0,0)
down()
path = 'F--F--F'
speed(0)
up()
goto(-440,-250)
down()
for i in range(5):
    path = apply_rule(path)
draw_path(path)
draw_path(path)
draw_path(path)
a,b = pos()
for i in range(3):
    up()
    a += 250
    goto(a,b)
    down()
    draw_path(path)
    draw_path(path)
    draw_path(path)
b += 220
for i in range(2):
    up()
    a -= 250
    goto(a,b)
    down()
    draw_path(path)
    draw_path(path)
    draw_path(path)
b += 220
for i in range(2):
 
    draw_path(path)
    draw_path(path)
    draw_path(path)
    up()
    a += 130
    goto(a,b)
    down()

효과도:

5, 비주얼 쇼크 1입니다.

import turtle as t
from turtle import *


angle = 60 #각도를 바꾸어 다양한 다각형을 그립니다
t.setup(1280,720)
t.bgcolor('black')
t.pensize(2)
randomColor = ['red','blue','green','purple','gold','pink']
t.speed(0)
for i in range(600):
t.color(randomColor[i%6])
t.fd(i)
t.rt(angle+1)
up()
color("#0fe6ca")
goto(0,0)
down()
t.done()

효과도:

6, 비주얼 쇼크 2입니다

# # -*- coding: utf-8 -*-

import turtle as t
from turtle import *

angle = 60 #각도를 바꾸어 다양한 다각형을 그립니다
t.bgcolor('black')
t.pensize(2)
randomColor = ['red','blue','green','purple','gold','pink']
t.speed(0)
for i in range(200):
t.color(randomColor[i%6])
t.circle(i)
t.rt(angle+1)
up()
color("#0fe6ca")
goto(0,0)
down()

효과도:

7. 비주얼 3입니다

from turtle import *
import time
 
speed(0)
colormode(255)
clrs = ["MidnightBlue", "Navy", "DarkBlue", "MediumBlue", "RoyalBlue", "MediumSlateBlue", "CornflowerBlue",
        "DodgerBlue", "DeepskyBlue", "LightSkyBlue", "SkyBlue", "LightBlue"]
 
time.sleep(2)
 
for j in range(120):
 
    cn = 0
    c = 30
    f = 70
 
    for i in range(12):
        pencolor(clrs[cn])
        circle(c)
        left(90)
        penup()
        forward(f)
        right(90)
        pendown()
        c = c * 0.8
        f = f * 0.8
        circle(c)
        cn = cn + 1
 
    penup()
    goto(0, 0)
    forward(5)
    right(3)
    pendown()

효과도:

8. 힐베르트 곡선:

# -*- coding: utf-8 -*-
 
from turtle import *
import random
length = 10
angle  = 90
setup(1280,720)
up()
 
goto(-640,-360)
down()
def draw_path(path):
    for symbol in path:
        if symbol == 'f':
            colormode(255)
            color(random.randint(0,255),random.randint(0,255),random.randint(0,255))
            fd(length)
        elif symbol == '+':
            lt(angle)
        elif symbol == '-':
            rt(angle)
 
def apply_path(rules,path):
    lit = [x for x in path]
    for i in range(len(lit)):
        symbol = lit[i]
        if symbol == 'x':
            lit[i] = rules[symbol]
        elif symbol == 'y':
            lit[i] = rules[symbol]
    path = ''.join(lit)
    return path
 
rules = {
    'x':'+yf-xfx-fy+',
    'y':'-xf+yfy+fx-'
}
path = 'x'
speed(0)
for i in range(7):
    path = apply_path(rules,path)
draw_path(path)
done()

효과도:

9. Sierpi ski 화살표 곡선입니다

# -*- coding: utf-8 -*-
 
 
from turtle import *
length = 5
angle = -60
setup(1280,720)
up()
 
goto(-640,-350)
down()
def draw_path(path):
    for symbol in path:
        if symbol == 'A' or symbol == 'B':
            import random
            colormode(255)
            color(random.randint(0,255),random.randint(0,255),random.randint(0,255))
            forward(length)
        elif symbol == '-':
            right(angle)
        elif symbol == '+':
            left(angle)
    ht()
 
def apply_rules(path,rules):
    lit = [_ for _ in path]
    for i in range(len(lit)):
        symbol = lit[i]
        if symbol in rules:
            lit[i] = rules[symbol]
    path = ''.join(lit)
    return path
 
 
rules = {
    'A':'B-A-B',
    'B':'A+B+A'
}
path = 'A'
speed(0)
for i in range(7):
    path = apply_rules(path,rules)
draw_path(path)
up()
goto(0,-340)
angle = 60
down()
draw_path(path)
up()
goto(0,-340)
angle = -60
down()
draw_path(path)

효과도:

10.Koch 라인입니다

# -*- coding: utf-8 -*-
 
from turtle import *
import random
length = 2
angle  = 90
setup(1280,720)
up()
goto(-600,-350)
down()
def draw_path(path):
    for symbol in path:
        if symbol == 'F':
            colormode(255)
            color(random.randint(0,255),random.randint(0,255),random.randint(0,255))
            forward(length)
        elif symbol == '-':
            right(angle)
        elif symbol == '+':
            left(angle)
    ht()
 
def apply_rule(path):
    rule = 'F+F-F-F+F'
    return path.replace('F',rule)
 
path = 'F'
speed(0)
for i in range(5):
    path = apply_rule(path)
for i in range(5):
    draw_path(path)
up()
goto(-478,-228)
down()
for i in range(4):
    draw_path(path)
up()
goto(-356,-106)
down()
for i in range(3):
    draw_path(path)
up()
goto(-235,16)
down()
for i in range(2):
    draw_path(path)
up()
goto(-115,137)
down()
draw_path(path)

효과도:

python 그림 - 간단한 시작과 접힌 선 그림입니다

Jammie — Mon, 12 Dec 2022 15:23:51 +0900

1. 환경 준비입니다.
리눅스 ubuntu 아래에 세 개의 패키지를 설치해야 합니다:
Numpy, Scipy,Matplotlib
각각 아래의 코드를 입력하여 설치합니다

pip install numpy
pip install scipy
sudo apt-get install python-matplotlib

설치가 성공했는지 테스트합니다

python
>>> import pylab

오류가 없으면 설치가 완료됩니다
2. 그림을 그리세요.
1. 가장 간단한 직선도를 그립니다.
코드는 다음과 같습니다

import numpy as np
import matplotlib.pyplot as plt
 
x=[0,1]
y=[0,1]
plt.figure()
plt.plot(x,y)
plt.savefig("easyplot.jpg")

결과는 다음과 같습니다

코드 해석:

#x축, y축입니다.
x=[0,1]
y=[0,1]
#도면 개체를 만듭니다
plt.figure()
#현재 도면 오브젝트에 그림을 그립니다. (두 개의 인자는 x, y 축의 데이터입니다)
plt.plot(x,y)
#이미지를 저장합니다.
plt.savefig("easyplot.jpg")

2. 그림에 해시태그와 제목을 붙입니다.
위의 그림에는 해당하는 X, Y축 라벨 설명과 제목이 없습니다.
상술한 코드에 이러한 내용을 추가할 수 있습니다.
코드는 다음과 같습니다

import numpy as np
import matplotlib.pyplot as plt
 
x=[0,1]
y=[0,1]
 
plt.figure()
plt.plot(x,y)
plt.xlabel("time(s)")
plt.ylabel("value(m)")
plt.title("A simple plot")

결과는 다음과 같습니다

코드 해석:

plt.xlabel("time(s)) #X축 레이블입니다.
plt.ylabel("value(m)) #Y축 레이블입니다.
plt.title("A simple plot") # 제목입니다

3. sinx 곡선을 그립니다
코드는 다음과 같습니다

# # -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt

#x,y축의 값을 설정합니다(y=sinx).
x = np.linspace(0, 10, 1000)
y = np.sin(x)

#도면 오브젝트를 작성합니다. figsize 매개 변수는 도면 오브젝트의 폭과 높이를 인치, 인치=80px 단위로 지정할 수 있습니다.
plt.figure(figsize=(8,4))

#현재 그리기 객체에 그림을 그립니다(x축, y축, 그려진 곡선의 이름, 선 색상, 선 너비)
plt.plot(x,y,label="$sin(x)$",color="red",linewidth=2)

#X축 문자입니다
plt.xlabel("Time(s)")

#Y축 문자입니다.
plt.ylabel("Volt")

#그래프의 제목입니다
plt.title("PyPlot First Example")

#Y축의 범위입니다
plt.ylim(-1.2,1.2)

#그림 보이기입니다
plt.legend()

# 그림을 표시합니다.
plt.show()

# 그림을 저장합니다.
plt.savefig("sinx.jpg")

결과는 다음과 같습니다

4. 꺾은선 그림을 그립니다.
코드는 다음과 같습니다

# # -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt
#X축, Y축 데이터입니다
x = [0,1,2,3,4,5,6]
y = [0.3,0.4,2,5,3,4.5,4]
plt.figure (figsize=(8,4) #도면 객체를 만듭니다
plt.plot(x,y, "b--", linewidth=1) #현재 도형 오브젝트에 도형합니다(X축, Y축, 파란색 점선, 선폭).
plt.xlabel("Time(s)) #X축 레이블입니다.
plt.ylabel("Volt") #Y축 레이블입니다.
plt.title("Line plot") # 그림 제목입니다.
plt.show () # 그림을 보여줍니다.
plt.savefig("line.jpg") # 그림을 저장합니다

결과는 다음과 같습니다

파이썬을 이용해서 그림을 그립니다

Jammie — Mon, 12 Dec 2022 14:35:08 +0900

1. 환경 설정입니다.
리눅스 ubuntu에는 Numpy, Scipy, Matplotlib라는 세 개의 패키지를 설치해야 합니다.

각각 아래의 코드를 입력하여 설치합니다

2. 간단한 그림을 그리세요.
(1) 직선도입니다.

#coding:utf-8
import numpy as np
import matplotlib.pyplot as plt

x = [0, 1] #x축입니다
y = [0, 1] #y축입니다
plt.figure( )# 그리기 개체를 만듭니다
plt.ylabel('ACC@1', size=20)#y 축의 좌표 size는 글꼴 크기입니다.
plt.xlabel ('Iters' , size=20) #x 축의 좌표입니다.
plt.title ('line', size=30) # 제목입니다.
plt.plot(x, y, linewidth=3, c='r'') #현재 객체에 그림을 그립니다. c는 색상, linewidth는 선의 너비입니다.
plt.show () # 현재 그림을 표시합니다.
plt.savefig("1.jpg")# 그림을 저장합니다.
결과는 그림과 같습니다

(2) 꺾은선 그래프입니다.

# # -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt

# X축, Y축 데이터입니다
x = [0, 1, 2, 3, 4, 5, 6]
y = [0.3, 0.4, 2, 5, 3, 4.5, 4]
plt.figure (figsize=(8, 4) # 그리기 개체를 만듭니다
plt.plot (x, y, "b--", linewidth=1) # 현재 그리기 개체( X축, Y축, 파란색 점선, 선폭)
plt.xlabel("Time(s)) # X축 레이블입니다.
plt.ylabel("Volt") # Y축 레이블입니다.
plt.title("Line plot") # 그림 제목입니다.
plt.show () # 그림을 보여줍니다.
plt.savefig("line.jpg") # 그림을 저장합니다.
결과는 아래 그림과 같습니다

(3) 선을 두 개 긋습니다.

# # encoding=utf-8
import matplotlib.pyplot as plt
from pylab import * # 중국어 지원
# # mpl.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['xtick.direction'] = 'in' # 눈금 사분면에 있습니다.
plt.rcParams['ytick.direction'] = 'in'
names = [0.1,0.2,0.3,0.5,0.8,1]
x = range(len(names))
y = [0.476, 0.475, 0.475,0.474,0.473, 0.468]
y1 = [0.674, 0.671, 0.682,0.681,0.684,0.686]

#plt.plot(x, y, 'ro-')
#plt.plot(x, y1, 'bo-')
#pl.xlim(-1, 11) #가로축의 범위를 한정합니다
plt.ylim (0.45, 0.7) # 세로축의 범위를 한정합니다
plt.tick_params(labelsize=13)

plt.plot(names, y, 'r--',linewidth = 3,label='ACC@1')
plt.plot(names, y1, 'b--',linewidth = 3,label='ACC@5')

plt.legend(loc=0, numpoints=1)
leg = plt.gca().get_legend()
ltext = leg.get_texts()
plt.setp(ltext, fontsize=15) # 범례를 유효하게 합니다. fontsize는 좌표 눈금 글꼴의 크기를 의미합니다.
# plt.xticks(x, names, rotation=100) #rotation 왼쪽 눈금의 기울기를 말합니다.
plt.margins(0)
plt.subplots_adjust(bottom=0.15)
plt.xlabel("$\\alpha$",size=18) #X축 레이블,그리스 문자 표시방식에 \\"를 추가합니다.
plt.ylabel("ACC",size=18) #Y축 레이블입니다.
# plt.title("A simple plot") # 제목입니다.
plt.savefig('alpha.eps')
plt.show()
결과는 그림과 같습니다

(4) 막대 그래프입니다.

# # -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import tensorflow as tf

name_list = ['1', '2', '3']
num_list = [574.0, 320.0, 400]
plt.bar(range(num_list), num_list, color='rgb', width=0.2, tick_label=name_list) #width를 사용하여 컬럼의 폭을 조정합니다. color를 색상으로 설정합니다.
plt.show()
결과는 그림과 같습니다.

(5) 산점도입니다.

import matplotlib.pyplot as plt

x_values=[1,2,3,4,5]
y_values=[1,4,9,16,25]
# s는 점의 크기입니다.
plt.scatter(x_values,y_values,s=100)

# 그래프 제목을 설정하고 좌표축에 레이블을 붙입니다
plt.title("Scatter pic",fontsize=24)
plt.xlabel("Value",fontsize=14)
plt.ylabel("Scatter of Value",fontsize=14)

# 눈금 표시의 크기를 설정합니다
plt.tick_params(axis='both',which='major',labelsize=14)

plt.show()

프로그래밍 언어가 이렇게 많은데 왜 파이썬을 선택했나요?

Jammie — Fri, 9 Dec 2022 15:19:34 +0900

C, C++, Java, PHP, Javascript, Ruby, Perl 및 Python과 같은 수백 가지 일반적인 프로그래밍 언어가 있습니다.초보자의 경우 새로운 언어를 선택하려면 첫 번째 장면, 언어 학습 비용 등 두 가지 시나리오를 고려해야 합니다.두 번째 장면, 언어의 응용 장면이요.마침 파이썬 언어가 최적입니다.

또한 인공지능의 부상에 따라 파이썬의 위상도 높아졌고, 각 대기업은 인공지능에 진출했으며 파이썬 관련 인재도 각 대기업에서 경쟁했습니다.다음은 샤오첸이 파이썬을 선택한 구체적인 이유를 분석하겠습니다.

1.단순하고 친근한 언어입니다.
Python은 다른 언어에 비해 사용하기 쉽고 영어와 마찬가지로 친숙하고 이해하기 쉽습니다.일부 복잡한 개념은 메모리 적용 및 방출, 변수의 내용 고려 없이 바로 사용할 수 있도록 캡슐화되었습니다.

2. 고속성장, 응용장면 넓습니다.
인공지능과 빅데이터의 발전으로 파이썬은 인공지능의 제1언어로 인기가 치솟고 있습니다.향후 10년은 인공지능의 10년일 것이며 파이썬의 생명력은 매우 강력합니다

응용 분야도 매우 광범위하며 자동화 테스트, Devops 운영 및 유지 관리, 크롤러 엔지니어, 웹 개발, 데이터 분석, 기계 학습 모두 파이썬을 사용할 수 있으며 언어를 배우면 이렇게 많은 일을 할 수 있는 경우가 거의 없습니다.통속적으로 말하면, 가성비가 매우 높습니다.

3. 크로스 플랫폼입니다.
Python은 이식성이 높으며 교차 플랫폼을 지원합니다.Windows, Mac, Linux, Solaris, FreeBSD 등과 같은 파이썬을 어디에서나 실행할 수 있습니다.

4、미래가 기대됩니다
2017년 교육부 고시센터에서 '전국 컴퓨터등급(NCRE) 체계 조정에 대하여'라는 공지를 내고 2018년 3월부터 컴퓨터 2급 시험에 '파이썬 언어 프로그래밍' 과목을 넣기로 한 것은 인공지능 시대가 도래하면서 파이썬이 인기를 얻고 있음을 보여준다.수험생에게 파이썬(Python)은 수험생 입문 컴퓨터의 선택 중 하나입니다.

빅데이터와 인공지능 시대에 인터넷에서 트릭을 나누려면 파이썬 언어가 매우 중요합니다.그러니, 입사하고 싶은 당신은 시간을 내서 체계적으로 공부하세요!

파이썬은 어떤 장점이 있나요?

Jammie — Fri, 9 Dec 2022 15:13:17 +0900

파이썬은 약 40년 전 등장한 이래 수천 개의 웹사이트와 소프트웨어 프로젝트가 이 기술을 기반으로 하고 있으며, 파이썬은 독특한 특성으로 인해 많은 개발 언어에서 두각을 나타내어 전 세계 개발자들로부터 많은 사랑을 받고 있습니다.그럼 파이썬의 장점은 무엇인가요?

아래에서 샤오첸은 파이썬의 가장 두드러진 면을 열거했습니다.이러한 모든 장점으로 인해 많은 다국적 기업이 파이썬을 프로그래밍 언어로 선택했습니다

1.간단합니다
Python은 간단한 언어이며 읽고 쓰기가 매우 쉽다고 할 수 있으며, 문제가 발생했을 때 프로그래머는 프로그램 언어와 문법에 많은 노력을 기울이지 않고 문제 자체에 더 많은 주의를 기울일 수 있습니다.

2.무료입니다
파이썬은 무료 오픈 소스입니다.이것은 프로그래머가 돈을 들이지 않고도 그것을 공유하고, 복제하고, 교환할 수 있다는 것을 의미하며, 파이썬이 강력한 커뮤니티를 형성하고, 그것을 더 잘 사용하고, 더 빠르게 기술 발전하는 데 도움이 됩니다.전문가는 지역사회에서 초보자와 지식과 경험을 공유할 수 있습니다.

당신이 사용할 수 있는 오픈 소스 라이브러리를 찾으면 어떤 이점을 얻을 수 있습니까?프로젝트 지출을 절반으로 줄이세요!

3.호환성입니다
파이썬은 수많은 플랫폼과 호환되기 때문에 개발자들이 다른 언어를 사용하는 데 종종 겪는 어려움을 겪지 않습니다.

4.객체지향적입니다
파이썬은 프로세스 지향 프로그래밍과 객체 지향 프로그래밍을 모두 지원합니다.프로세스 지향 프로그래밍에서는 프로그래머가 코드를 다중화하고 객체 지향 프로그래밍에서는 데이터 및 함수 기반 객체를 사용합니다.객체 지향 프로그래밍 언어는 일반적으로 매우 복잡하지만 파이썬은 간결함을 유지하려고 합니다.

5.창고입니다
파이썬 커뮤니티는 다양한 파이썬 라이브러리를 많이 만들었습니다.그들의 도움으로 당신은 문서를 관리하고 셀 테스트, 데이터베이스, 웹 브라우저, 이메일, 암호학, 그래픽 사용자 인터페이스 및 기타 것들을 수행할 수 있습니다.모든 것이 표준 라이브러리에 포함되어 있지만, 그것 말고도 많은 라이브러리가 있습니다.

이상이 샤오첸(小千)이 요약한 파이썬(Python)의 몇 가지 장점입니다.향후 10년은 빅데이터와 인공지능이 폭발하는 시대가 될 것이며 파이썬 엔지니어에 대한 수요도 급증할 것입니다. 파이썬은 데이터 처리와 인공지능 응용 방향에 대해 천혜의 이점을 가지고 있기 때문입니다.그러니 이 고임금 분야에 진출하고 싶다면 서둘러 파이썬을 배우세요!

파이썬 인터프리터는 무엇입니까?

Jammie — Fri, 9 Dec 2022 15:06:49 +0900

1.파이썬 해석기는 무엇입니까?
컴퓨터의 뇌는 CPU이고 중국어 이름은 중앙처리장치이며 파이썬 언어를 직접 처리할 수 없습니다.CPU는 기계 명령어만을 직접 처리할 수 있는데, 그것은 0과 1의 숫자로 이루어진 언어이며, 이는 우리가 직접 쓰기 어려운 언어입니다.그래서 우리는 Python 언어를 컴퓨터 CPU가 알아들을 수 있는 기계 명령 언어로 번역하는 번역이 필요합니다. 그래야 컴퓨터가 우리의 Python 프로그램의 요구 사항에 따라 일을 할 수 있습니다. .py 끝의 파일은 인터프리터가 실행되어야 합니다.

2.파이썬 인터프리터의 구성과 그 각 부분의 기능
인터프리터는 소스 코드를 바이트 코드 파일로 변환하는 컴파일러와 바이트 코드를 실행하는 가상 시스템으로 구성됩니다.
따라서 해석형 언어에도 사실 컴파일 과정이 있지만, 이 컴파일 과정은 대상 코드를 직접 생성하는 것이 아니라 중간 코드(바이트 코드)를 생성한 다음 가상 머신을 통해 바이트 코드를 한 줄씩 해석하여 실행합니다.

3.수행과정의 원리입니다
1. python XX.py을 실행하면 Python의 인터프리터가 시작됩니다
2. python 인터프리터의 컴파일러는 .py 소스 파일을 바이트 코드로 컴파일(해석)하여 PyCode Object 바이트 코드 개체를 메모리에 저장합니다.
3. 파이썬 인터프리터의 가상 시스템은 실행 메모리의 바이트 코드 개체를 기계 언어로 변환하고 가상 시스템은 운영 체제와 상호 작용하여 기계 언어가 기계 하드웨어에서 실행될 수 있도록 합니다.
4. 실행 후 python 인터프리터는 PyCode Object를 pyc 파일로 다시 씁니다.python 프로그램이 두 번째 실행되면 먼저 프로그램이 하드 디스크에서 pyc 파일을 찾고 찾으면 바로 로딩하고 그렇지 않으면 위의 과정을 반복합니다

Python 인터프리터는 프로그램의 세 단계를 수행합니다. 예를 들어 실행 (python3 D:\test.py)
1단계: 먼저 python3 인터프리터를 시작합니다
Step2: Python3 인터프리터는 텍스트 편집기처럼 파일을 python3 D:\ test.py 하드 드라이브에서 메모리로 읽습니다
3단계: Python3 인터프리터가 실행 파일 코드를 설명합니다.
3단계에서만 python의 문법을 인식합니다

4.파이썬 인터프리터의 종류입니다
1.Cpython
공식적으로 다운로드한 파이썬 2.7은 모두 Cpython입니다.Cpython은 C언어로 개발되었기 때문에 붙여진 이름입니다.
2.Ipython
IPython은 CPython을 기반으로 하는 대화형 인터프리터이며 즉, IPython은 대화형 방식에서만 향상되지만 Python 코드를 실행하는 기능은 CPython과 동일합니다.예를 들어, 많은 국산 브라우저는 외관은 다르지만 커널은 사실 IE를 사용합니다.
CPython은 >>를 힌트로 사용하고 IPython은 In [시퀀스]:를 힌트로 사용합니다.
3.PyPy
PyPy는 실행 속도를 목표로 하는 또 다른 Python 인터프리터입니다.PyPy는 JIT 기술을 사용하여 Python 코드를 동적으로 컴파일하므로(해석되지 않음에 유의하십시오) Python 코드의 실행 속도를 크게 향상시킬 수 있습니다.
대부분의 Python 코드는 PyPy에서 실행될 수 있지만 일부 PyPy와 CPython은 다르기 때문에 동일한 Python 코드가 두 인터프리터 모두에서 다르게 실행될 수 있습니다.당신의 코드를 PyPy에 넣고 실행하려면 PyPy와 CPython의 차이점을 알아야 합니다.
4.Jython
Jython은 Java 플랫폼에서 실행되는 파이썬 인터프리터로 파이썬 코드를 Java 바이트 코드로 직접 컴파일하여 실행할 수 있습니다.
5.Ironpython
IronPython은 Jython과 유사하지만 IronPython은 Microsoft .Net 플랫폼에서 실행되는 Python 인터프리터이며 Python 코드를 .Net의 바이트 코드로 직접 컴파일할 수 있습니다

놓칠 수 없는 파이썬의 하이라이트 플레이법입니다

Jammie — Fri, 9 Dec 2022 12:35:37 +0900

색인과 슬라이스입니다
파이썬 목록의 인덱스와 슬라이스는 파이썬에서 목록의 임의의 요소를 가져올 수 있는 매우 강력한 기능입니다.일반적인 양성 인덱스를 지원하는 것 외에도 파이썬은 음성 인덱스와 슬라이스도 지원합니다.

올바른 색인입니다

a_list = [100, 200, 300, 400, 500, 600]
print(a_list[0]) # 출력 100입니다.
print(a_list[1]) # 200을 출력합니다.
print(a_list[2]) # 출력 300입니다

음의 색인입니다

a_list = [100, 200, 300, 400, 500, 600]
print(a_list[-1]) # 출력 600입니다.
print(a_list[-3]) # 400을 출력합니다

다음은 목록 슬라이스의 예입니다

a_list = [1, 2, 5, 10, 20, 30]

b_list = a_list[1:3] # 생성 [2, 5] 입니다.
c_list = a_list[4:] # 생성 [20, 30] 입니다.
d_list = a_list[-4::1] # 생성 [5, 10, 20] 입니다.
e_list = a_list[-1:] # 생성 [30] 입니다

문자열 정렬입니다
문자열 포맷은 명령줄 도구 개발에 매우 중요합니다. str 클래스에는 텍스트 정렬을 위한 기본 방법이 포함되어 있습니다. 왼쪽 정렬, 오른쪽 정렬 또는 중앙 정렬입니다

str.ljust (width [, fillchar]) # 왼쪽 정렬입니다.
str.rjust (width [, fillchar]) # 오른쪽 정렬합니다
str.center (width [, fillchar]) # 가운데 정렬합니다
digit_str.zfill(width) #을 "0"으로 채웁니다

다음은 몇 가지 예입니다

new_str = 'Help!'.center(10, '#') 
print(new_str)

이 예의 출력은 다음과 같습니다

##Help!###

new_str = '750'.rjust(6, '0') 
print(new_str)

이 예제의 출력은 다음과 같습니다

위의 예는 단순한 문자열 포맷의 샘플일 뿐이며, '고차 Python: 코드 정밀도의 길'에는 더 복잡한 포맷 방법도 많이 소개되어 있습니다.

목록 도출식 & 사전 도출식입니다
파이썬 2.0 버전에 도입된 가장 중요한 기능 중 하나는 목록 도출입니다.목록에서 일련의 값을 생성하는 컴팩트한 구문을 제공합니다.사전, 집합(set) 및 기타 유형의 집합에도 적용할 수 있습니다.

a_list에 있는 각 요소의 제곱을 포함하는 새로운 목록을 만든다고 가정하면 다음과 같이 구현될 수 있습니다

   b_list = [ ] 
    for i in a_list: 
        b_list.append(i * i)

a_list에 요소 [1, 2, 3]가 포함되어 있는 경우 이러한 문장의 결과는 [1, 4, 9]를 포함하는 새 목록을 만들고 이 목록을 변수 b_list에 할당하는 것입니다.이 경우 해당 목록 도출식은 다음과 같습니다

   b_list = [i * i   for i in a_list]

메타그룹 목록이 사전으로 변환된다고 가정하면, 메타그룹 목록은 다음과 같습니다

   vals_list = [ ('pi', 3.14), ('phi', 1.618) ]

키 값 표현(i[0]:i[1])의 콜론(:) 사용에 주의하십시오.

가변 길이 인자 목록입니다
파이썬의 가장 일반적인 기능 중 하나는 가변 길이 매개변수 목록에 액세스할 수 있다는 것입니다.이 기능을 사용하면 내장된 print 함수와 같이 모든 수의 매개변수를 처리할 수 있습니다.가변 길이 매개변수의 특성은 명명된 매개변수로 확장될 수도 있습니다

   def func_name([ordinary_args,] *args): 
        statements

여기서 중괄호는 *args 앞에 임의의 수의 일반 매개변수가 있을 수 있음을 나타내며 여기서는 ordinary_args로 표시됩니다.이러한 매개변수는 선택 사항입니다.다음은 예시 코드입니다

   def my_var_func(*args): 
        print('The number of args is', len(args)) 
        for item in args: 
            print(items)

이 함수 my_var_func는 임의의 길이의 매개변수 목록을 수용할 수 있습니다

  >>> my_var_func(10, 20, 30, 40) 
    The number of args is 4 
    10 
    20 
    30 
    40

가변 길이 매개변수 목록은 다음과 같이 키워드 매개변수도 지원합니다

 def pr_named_vals(**kwargs): 
        for k in kwargs: 
            print(k, ':', kwargs[k])

위의 함수는 kwargs가 나타내는 사전 매개변수를 통과하고 들어오는 매개변수의 키( 매개변수 이름에 해당)와 해당 값을 인쇄합니다

   For example: 
    >>> pr_named_vals(a=10, b=20, c=30) 
    a : 10 
    b : 20 
    c : 30

args와 kwargs를 조합하여 사용할 수 있는데, 다음은 하나의 예입니다

def pr_vals_2(*args, **kwargs): 
        for i in args: 
            print(i) 
        for k in kwargs: 
            print(k, ':', kwargs[k]) 
 
    pr_vals_2(1, 2, 3, -4, a=100, b=200)

실행 시, 이 프로그램은 다음 내용을 출력합니다

numpy를 사용하여 선형 대수 연산을 수행합니다
선형 대수 연산은 딥 러닝에서 매우 중요하며 numpy 라이브러리는 파이썬에 효율적인 선형 대수 연산 모듈을 제공합니다.

numpy의 선형 대수 모듈은 매우 완벽하며 점적 계산을 예로 들어 소개합니다.

numpy를 사용할 때 점적 함수 dot를 사용하여 점적을 계산할 수 있습니다

numpy.dot(A, B, out=None)

A와 B는 점적 연산을 수행하는 두 개의 배열이고, out 매개변수(지정된 경우)는 결과를 저장하는 데 사용되는 올바른 배열이며, '올바른 모양'은 A와 B의 모양에 따라 다릅니다.

두 개의 1차원 배열의 점적은 매우 간단합니다.배열의 길이는 같아야 합니다.점적 계산은 A의 각 요소와 B의 해당 요소를 곱한 다음 이러한 곱을 합산하여 스칼라 값을 얻는 것입니다

D. P. = A[0]*B[0] + A[1]*B[1] + ... + A[N-1] * B[N-1]

예:

import numpy as np  
A = np.ones(5)  
B = np.arange(5)  
print(A, B)  
[1. 1. 1. 1. 1.] [0 1 2 3 4]  
np.dot(A, A)  
5.0  
np.dot(A, B)  
10.0  
np.dot(B, B)  
30

2차원 행렬 사이의 점적은 비교적 복잡합니다.배열 간의 일반적인 곱셈과 마찬가지로 두 배열의 모양은 호환되어야 하지만 이는 차원 중 하나에서 동일하기만 하면 됩니다.

다음은 2D 배열에 대한 점적 적용을 설명하는 일반적인 모드입니다

(A, B) * (B, C) => (A, C)

아래의 2×3 배열에 대해 생각하고 3×2 배열과 결합하면 그 점적은 2×2 배열입니다

A = np.arange(6).reshape(2,3)  
B = np.arange(6).reshape(3,2)  
C = np.dot(A, B)  
print(A, B, sep='\n\n')  
print('\nDot product:\n', C)
[[0 1 2]  
[3 4 5]]
 
[[0 1]  
[2 3]  
[4 5]]
 
Dot product:  
[[10 13]   
[28 40]]

파이썬 그림 기초입니다

Jammie — Wed, 7 Dec 2022 15:17:06 +0900

python은 그림을 그리는 데 사용됩니다. matplotlib과 seaborn*
1.matplotlib
사용하기 전에 API를 가져와야 합니다
import matplotlib.pyplot as plt

1.1 기본 그림을 그립니다
1.1.1 꺾은선 그래프
1.데이터를 준비합니다
import random
x = range(60)
y = [random.uniform(15,18) for i in x]
#random.uniform의 매개변수는 값 범위입니다.

2. 캔버스를 만듭니다.
plt.figure(figsize=(20,5),dpi=100)
#여기서 매개변수 figsize는 이미지 크기이고 dpi는 해상도입니다.

3. 그림을 그립니다
plt.plot(x,y)

4.이미지 디스플레이입니다.
plt.show()

1.1.2 산점도입니다.
1, 2, 4단계를 반복합니다.
3단계를 plt.scatter(x,y)로 변경합니다.
그림 표시:

1.1.3 막대그래프
1, 2, 4단계를 반복합니다.
3단계를 plt.bar(x,y)로 변경합니다.
그림 표시:

1.1.4 히스토그램입니다
1, 2, 4단계를 반복합니다.
3단계를 plt.hist(y)로 변경합니다.
하나의 y 매개 변수만 들어오며, y의 분포를 나타냅니다.
그림 표시:

x의 분포를 나타내는 x 매개변수를 가져올 수도 있습니다(단, x는 0~59이므로 의미가 없습니다).
그림 표시:

1.2 다른 기능을 구현합니다.
우리는 우리가 만든 데이터를 상해시 아침 10시부터 11시까지 온도 변화로 사용합니다

#1. 데이터 준비합니다
x_shanghai = x
y_shanghai = y

#2. 캔버스를 만듭니다
plt.figure(figsize=(20,5),dpi=100)

#3. 그림을 그립니다
plt.plot(x_shanghai,y_shanghai)
#3.1 x, y 눈금을 추가합니다.
x_ticks = ['10:{}분'format(i) for i in x_shanghai]
y_ticks = range(40)
#3.2 x, y의 눈금을 수정합니다.
plt.xticks(x_shanghai[::5],x_ticks[::5])
#plt.xticks 첫 번째 인자는 눈금이고 두 번째 인자는 눈금 레이블입니다(plt.yticks도 마찬가지입니다).
plt.yticks(y_ticks[::5])
#5분마다 눈금을 긋습니다
#3.3 그리드 디스플레이를 추가합니다.
plt.grid(True,linestyle = "--",alpha = 0.6)
매개변수 linestyle은 그리드 선의 종류이고 알파는 그리드 선의 깊이입니다

그림 표시:

1.3 좌표계에 여러 개의 그림을 그립니다

#0 데이터를 준비합니다
x = range(60)
y_shanghai = [random.uniform(15,18) for i in x]
y_beijing = [random.uniform(1,3) for i in x]

#1 캔버스를 만듭니다
plt.figure(figsize=(20,5),dpi=100)

#2 그림을 그립니다
plt.plot(x,y_shanghai,label = "상하이")
#상하이라는 해시태그를 그려주세요.
plt.plot(x,y_beijing,color = 'r',linestyle="--",label="베이징")
#베이징의 이미지를 그려주세요.
plt.legend(loc ="best")
#plt.legend () 함수 설정 범례 위치입니다

#2.1 x,y 눈금을 추가합니다.
x_shanghai_ticks = ['10시 {}분'.format(i) for iin x]
y_shanghai_ticks = range(40)

#2.2 x, y 눈금을 수정합니다.
plt.xticks(x[::5],x_shanghai_ticks[::5])
plt.yticks(y_shanghai_ticks[::5])

#2.3 그리드 디스플레이를 추가합니다.
plt.grid(True , linestyle = "--",alpha = 0.6)

#2.4 태그 데이터 추가요
plt.xlabel("시간", fontsize=20) 입니다.
plt.ylabel("온도", fontsize=20) 입니다.
plt.title("어떤 도시의 어느 날 10시부터 11시까지 온도변화 꺾임선도", fontsize=20)
#fontsize는 글꼴 크기입니다

# 그림을 저장합니다.
plt.savefig("test.png")

#3 그림 보이기입니다
plt.show()

그림 표시:

1.4 다중 좌표 작도

#0 데이터를 준비합니다
x = range(60)
y_shanghai = [random.uniform(15,18) for i in x]
y_beijing = [random.uniform(1,3) for i in x]

#1 캔버스를 만듭니다
plt.figure(figsize=(20,8),dpi=100)
# # fig,axes=plt.subplot(nrows=1,ncols=2,figsize=(20,8),dpi=100)

#2 그림을 그립니다
# axes[0].plot(x,y_shanghai,label = "상하이")
# axes[1].plot(x,y_beijing,color = 'r',linestyle="--",label="베이징")입니다.
f1=plt.subplot(1,2,1)# figure를 한 줄 두 줄로 나누고, 세 번째 숫자는 첫 번째 위치의 그림을 나타냅니다.
f1.scatter(x,y_shanghai,label="상하이",color="r",linestyle="--") #각각 x의 표시범위는 0-3,y의 좌표 0-1입니다.
f2=plt.subplot(1,2,2)# figure를 한 줄 두 줄로 나누고, 세 번째 숫자는 두 번째 위치의 그림을 나타냅니다.
f2.scatter(x,y_beijing,label="베이징")

# #2.1 x,y 눈금을 추가합니다.
x_ticks= ["10시{}분.format(i) for i in x" 입니다.
y_shanghai_ticks = range(40)

# #2.2 x, y 눈금을 수정합니다.
# # plt.xticks(x[::5],x_ticks[::5])
# # plt.yticks(y_shanghai_ticks[::5])
f1.set_xticks(x[::5])
f1.set_yticks(y_shanghai_ticks[::5])
f1.set_xticklabels(x_ticks[::5])
f2.set_xticks(x[::5])
f2.set_yticks(y_shanghai_ticks[::5])
f2.set_xticklabels(x_ticks[::5])

# #2.3 그리드 디스플레이를 추가합니다.
f1.grid(True , linestyle = "--",alpha = 0.6)
f2.grid(True , linestyle = "--",alpha = 0.6)

# #2.4 태그 데이터 추가요
# plt.xlabel("시간", fontsize=20) 입니다.
# plt.ylabel("온도", fontsize=20) 입니다.
# plt.title("어떤 도시의 어느 날 10시부터 11시까지 온도변화 꺾임선도", fontsize=20)
f1.set_xlabel("시간") 입니다.
f1.set_ylabel("온도") 입니다.
f1.set_title("상하이시 10시부터 11시까지 온도변화", fontsize=20)
f2.set_xlabel("시간") 입니다.
f2.set_ylabel("온도") 입니다.
f2.set_title("베이징시 10시부터 11시까지 온도변화", fontsize=20)
f1.legend(loc=0)
f2.legend(loc=0)

# 그림을 저장합니다.
plt.savefig("test.png")
#3 그림 보이기입니다
plt.show()

그림 표시:

1.5 그림 그리기 응용 프로그램입니다

import numpy as np
# 일반 함수의 그림을 그립니다
# 검정색 접선 함수의 그림을 그립니다
# 0 데이터를 준비합니다
x = np.linspace(-10,10,1000)
# x는 -10부터 10까지 등간격으로 1000부 취합니다.
y = np.arctan(x)

# 1 캔버스 만들기
plt.figure(figsize=(20,8),dpi = 100)

# 2 그림을 그립니다
plt.plot(x,y)

# 2.1 그리드를 추가합니다.
plt.grid(True,linestyle = "--",alpha=0.6)

# 3 그림을 표시합니다
plt.show()

그림 표시:

#정비율 함수를 그립니다
y = x

그림 표시:

Python matplotlib 그림 그리기 (첫 번째, 선 색상, 유형 설정)

Jammie — Wed, 7 Dec 2022 14:58:36 +0900

1, 선 색상, 유형 설정입니다.

#색상설정 : color='g' 입니다.
#선의 종류 : linestyle='-' 입니다.
#실 굵기 : linewidth=5 입니다
plt.scatter(df_2012[vnlCol], df_2012[srNLCol], color='g')
plt.plot(xlst, xlst, color='r', linestyle=':')

matplotlib 색상표입니다

파이썬 묘화 기법 (고화질 그림)

Jammie — Wed, 7 Dec 2022 14:54:49 +0900

1. 일반적인 다선도를 그립니다.
일반적인 스타일 좌표 이름 및 크기 조정 외에도 해결해야 할 몇 가지 특별하지만 필요한 문제가 있습니다.

1. 우리가 자주 보관하는 그림은 흰색이 많이 남도록 주의하여 이 문제를 해결합니다.

2.중국어가 깨집니다.

3. 이미지가 흐려져 선명도가 부족해도 해결합니다

import cv2
from pylab import * # 중국어 지원
mpl.rcParams['font.sans-serif'] = ['SimHei']

img2 = cv2.imread("img/fenge-1-1.jpg")
img4 = cv2.imread("img/fenge-1-1-0.06.jpg")
img5 = cv2.imread("img/fenge-1-1-0.02.jpg")
img6 = cv2.imread("img/fenge-1-1-0.1.jpg")


img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2HSV)
h1, s, img2 = cv2.split(img2) #싱글 채널 보기
img_array2 = np.array(img2) # 그림을 배열 형식으로 변환합니다. img = np.asarray(image)
mean2 = np.average (img_array2, axis=0) # 열을 기준으로 평균을 냅니다

img4 = cv2.cvtColor(img4, cv2.COLOR_BGR2HSV)
h1, s, img4 = cv2.split(img4) # 싱글 채널 보기입니다.
img_array4 = np.array(img4) # 그림을 배열 형식으로 변환합니다. img = np.asarray(image)
mean4 = np.average (img_array4, axis=0) # 열을 기준으로 평균을 냅니다

img5 = cv2.cvtColor(img5, cv2.COLOR_BGR2HSV)
h1, s, img5 = cv2.split(img5) # 단일 채널을 봅니다
img_array5 = np.array(img5) # 그림을 배열 형식으로 변환합니다. img = np.asarray(image)
mean5 = np.average(img_array5, axis=0) # 열을 기준으로 평균을 냅니다

img6 = cv2.cvtColor(img6, cv2.COLOR_BGR2HSV)
h1, s, img6 = cv2.split(img6) #싱글 채널 보기
img_array6 = np.array(img6) # 그림을 배열 형식으로 변환합니다. img = np.asarray(image)
mean6 = np.average(img_array6, axis=0) # 열을 기준으로 평균을 냅니다

# # plt.plot(mean2,c="g",label=u'a=std/(255*2)')
# # plt.plot(mean4,linestyle=":",c="r",label=u'a=0.06')
# # plt.plot(mean5,linestyle="-.",c="b",label=u'a=0.02')
# # plt.plot(mean6,linestyle="--",c="k",label=u'a=0.1')

plt.plot(mean2,linewidth=1,c="g",label=u'a=std/(255*2)')
plt.plot(mean4,linewidth=1,linestyle=":",c="r",label=u'a=0.06')
plt.plot(mean5,linewidth=1,linestyle="--",c="b",label=u'a=0.02')
plt.plot(mean6,linewidth=1,linestyle="-.",c="darkorange",label=u'a=0.1')


plt.legend (loc='upper right', prop={'family':'SimHei', 'size':9}) # 범례를 유효하게 합니다.
# plt.legend (loc='upper right', size=5) # 범례가 활성화되도록 합니다lower
plt.tick_params(direction='in') # 눈금이 안쪽을 향합니다.
plt.xlim ([0, 255]) # 가로 좌표 범위입니다.
plt.ylim ([100, 150]) # 가로 좌표 범위입니다.
plt.ylim ([100, 150]) # 가로 좌표 범위입니다.
# plt.grid (True) ## 격자점을 추가합니다.
plt.axis('tight') # 좌표축 적응 데이터량 axis 좌표축 설정
plt.xlabel("그림 1 너비/ (픽셀)", size=10) 입니다.
plt.ylabel("열의 평균 회색 값", size=10) 입니다.

# plt.title("a 값을 다르게 하는 L*(x,y)의 1차원 그래프") # 제목입니다.

#방법 1입니다.
# plt.rcParams['savefig.dpi'] = 800 #이미지 픽셀입니다.
# #
# # plt.rcParams['figure.dpi'] = 800 #해상도입니다.
# #
# # # # plt.axis ('off') 축으로 이동할 수 있습니다.
# # # plt.savefig('img/name-2.jpg')
# 방법 2입니다.
#저장된 그림의 선명도, 크기를 직접 설정할 수 있습니다.
# plt.set_size_inches(6, 6) # 그림을 저장할 크기를 설정합니다
plt.savefig('img/name-1.jpg', dpi=800,bbox_inches='tight')

#bbox_inches는 생성된 그림 주위의 공백을 좁힙니다
# plt.show() 이전에 plt.savefig() 를 호출하지 않으면 공백이 생깁니다.

plt.show()

cv2.waitKey(0)
cv2.destroyAllWindows()

2. 주의: 눈금 방향을 설정하는 또 다른 방법:

import matplotlib.pyplot as plt

plt.rcParams['xtick.direction'] = 'in' # x 주 눈금 방향을 안쪽으로 설정합니다.
plt.rcParams['ytick.direction'] = 'in' # y축의 눈금 방향을 안쪽으로 설정합니다.

plt.rcParams['xtick.direction'] = 'out' # x바퀴의 눈금 방향을 바깥쪽으로 설정합니다.
plt.rcParams['ytick.direction'] = 'out' # y축의 눈금 방향을 안팎으로 설정합니다.

plt.rcParams['xtick.direction'] = 'inout' #x바퀴의 눈금 방향을 가운데로 설정합니다.
plt.rcParams['ytick.direction'] = 'inout' # y축의 눈금 방향을 가운데로 설정합니다

3.컬러 스타일입니다

4. 3D 그림을 그리세요(쇼해 보세요)

import cv2
from pylab import * # 중국어 지원
mpl.rcParams['font.sans-serif'] = ['SimHei']
from IPython.core.pylabtools import figsize # import figsize

img = cv2.imread("img/1-2.jpg", 0)
# print(img.shape)#2003채널인지 싱글채널인지 확인할 수 있습니다
cv2.imshow('img',img)
height, width= img.shape[:2]
print(height, width)

img = cv2.resize(img, (height,width))

xx, yy = np.mgrid[0:img.shape[0], 0:img.shape[1]]

# # create the figure
fig = plt.figure()
ax = fig.gca(projection='3d')
# # ax.invert_yaxis()
ax.invert_xaxis()

ax.plot_surface(xx, yy, img,rstride=1, cstride=1, cmap=plt.cm.gray,linewidth=0) #plt.cm.jet
ax.set_zlabel("그림 그레이 값") 입니다.
ax.set_xlabel('그림 2 너비/(픽셀)')
ax.set_ylabel ('그림 2 높이/ (픽셀)')
ax.set_ylim(bottom=0) #y축은 0부터 시작합니다
ax.set_zlim(bottom=0) #z축은 0부터 시작합니다
# plt.xlabel("그림 1 너비/ (픽셀)", size=10) 입니다.
# plt.ylabel("그림 1 높이/ (픽셀)", size=10) 입니다.
# plt.tick_params(direction='in') # 눈금이 안쪽을 향합니다.
plt.rcParams['xtick.direction']='in'
# # plt.rcParams['ytick.direction']='in'
# figsize (8, 4) # figsize를 설정합니다
# plt.rcParams['savefig.dpi'] = 600 #이미지 픽셀입니다.

# plt.rcParams['figure.dpi'] = 600 #해상도입니다.
# # plt.savefig('img/3D-1-2.jpg')
#2. 저장된 이미지의 크기입니다.
fig.set_size_inches(6, 6) # 그림을 저장할 크기를 설정합니다
plt.savefig('img/3D-1-2.jpg', dpi=600,bbox_inches='tight')
#bbox_inches는 생성된 그림 주위의 공백을 좁힙니다
# plt.show() 이전에 plt.savefig() 를 호출하지 않으면 공백이 생깁니다.
plt.show()
cv2.waitKey()
cv2.destroyAllWindows()# 모든 창을 삭제합니다

3차원 좌표의 것과 2차원에는 여전히 차이가 있습니다

5.이중 y축 적용입니다.
핵심 코드:

# plt.xticks (x, x, rotation=45) # 가로 좌표 눈금 45도 회전합니다
plt.xticks([ ]) # 가로 좌표 눈금을 표시하지 않습니다
plt.xlim ([0.5, 4.5]) # 가로 좌표 범위입니다.
plt.ylim( [0, 1]) #좌표 범위입니다.


plt.xlabel (u" 원본 그림 MSRCR CALHE 알고리즘") # X축 레이블
plt.title("알고리즘에 따른 평가지표값의 변화") # 제목

# # plt.plot(greyScale_map, color='r')
plt.tick_params(direction='in') # 눈금이 안쪽을 향합니다.

# 다른 Y축을 그립니다
plt.twinx()
plt.plot(x, y1, marker='*', mec='g', mfc='w', ms=10, label=u' 정보 엔트로피 그래프')입니다.
plt.plot (x1, y4, marker='.', ms=10, label=u'PSNR 그래프')

터플이 하트 고백을 그려줍니다

Jammie — Wed, 7 Dec 2022 12:01:39 +0900

코드. 부호

#1-1 turtle 모듈을 도입하여 설계합니다
import turtle
import time

#1-2 하트 원호를 그립니다
def hart_arc():
for i in range(200):
turtle.right(1)
turtle.forward(2)


def move_pen_position(x, y):
turtle.hideturtle () # 브러시 숨기기 (먼저)
turtle.up( ) # 펜 들어 올립니다
turtle.goto(x, y) # 브러시를 지정된 시작 좌표로 이동합니다. (창의 중심은 0, 0)
turtle.down () # 다음 펜입니다.
turtle.showturtle( ) # 브러시를 보여줍니다.


love = input("고백 멘트를 입력하십시오:)"
signature = input("이름에 서명하세요:)"
date=input("날짜를 적어주세요:)"

if love == '':
love = 'I Love You'

#1-3 초기화합니다
turtle.setup (width=800, height=500) # 캔버스 크기입니다.
turtle.color ('red', 'pink') # 브러시 색상입니다.
turtle.pensize(3) # 브러시 두께입니다.
turtle.speed(1) # 그리기 속도입니다.
# 브러시 시작 좌표를 초기화합니다
move_pen_position (x=0, y=-180) # 브러시 위치를 이동합니다.
turtle.left(140) # 왼쪽으로 140도 회전합니다.

turtle.begin_fill( ) # 배경 채우기 위치를 표시합니다

#1-4 그림을 그리고 전시합니다
turtle.forward(224) # 브러시를 앞으로 움직이며 길이는 224입니다.
# 하트 원을 그리세요
hart_arc( ) # 왼쪽 원호입니다
turtle.left(120) # 브러시 각도를 조정합니다
hart_arc( ) # 오른쪽 원호입니다
# 하트 직선을 그립니다 (오른쪽 아래)
turtle.forward(224)

turtle.end_fill( ) # 배경 채우기 끝 위치를 표시합니다

move_pen_position (x=70, y=160) # 브러시 위치를 이동합니다.
turtle.left(185) # 왼쪽으로 180도 회전합니다
turtle.circle(-110,185) # 오른쪽 원호입니다.
# 하트 직선을 그립니다 (오른쪽 아래)
#turtle.left(20) #왼쪽 180도 회전합니다
turtle.forward(50)
move_pen_position (x=-180, y=-180) # 브러시 위치를 이동합니다.
turtle.left(180) # 왼쪽으로 140도 회전합니다.

# 하트 직선을 그립니다 (왼쪽 아래)
turtle.forward(600) # 브러시를 앞으로 224 길이로 이동합니다.

# 하트에 고백할 말을 써요
move_pen_position (0,50) # 고백어 위치입니다.
turtle.hideturtle () # 브러시를 숨깁니다.
turtle.color ('#CD5C5C', 'pink') # 글꼴 색상입니다.
# font: 글꼴, 크기 설정(컴퓨터 아래에 존재하는 글꼴 모두 설정 가능) align: 중심 정렬
turtle.write(love, font=('Arial', 20, 'bold'), align="center")

# 서명과 날짜를 기입하시오
if (signature != '') & (date != ''):
turtle.color('red', 'pink')
time.sleep(2)
move_pen_position(220, -180)
turtle.hideturtle () # 브러시를 숨깁니다.
turtle.write(signature, font=('Arial', 20), align="center")
move_pen_position(220, -220)
turtle.hideturtle () # 브러시를 숨깁니다.
turtle.write(date, font=('Arial', 20), align="center")

#1-5 창을 클릭하여 프로그램을 닫습니다.
window = turtle.Screen()
window.exitonclick()

2022년 호랑이 해 불꽃놀이 코드입니다

Jammie — Wed, 7 Dec 2022 11:51:44 +0900

파이썬 코드입니다설명하다. 시범을 보이다

import pygame
from math import *
from pygame.locals import *

import random


class firew:
    
    def __init__(self, pos, color, light, size, move):
        self.pos = list(pos)
        self.color = list(color)
        self.light = light
        self.size = size
        
        self.move = list(move)
    
    def force(self, force):
        self.move[0] += force[0]
        self.move[1] += force[1]

        self.move[0] *= force[2]
        self.move[1] *= force[2]
    
    def update(self):
        self.pos[0] += self.move[0]
        self.pos[1] += self.move[1]

    def render(self, fenster, glitter):
        glitter = (glitter and random.randint(40, 100)/100) or 1
        c = rund( mult(self.color, self.light*glitter) )
        rad = int(round(self.light* self.size))
        rad += rad < 1
        #print(c)
        
        pygame.draw.circle(fenster, c, rund(self.pos), rad)
        

def summon(fws, pos, pre_move = [0,0]):
    mix.stop()
    #anz = random.randint(30, 250)
    anz = random.randint(200, 350)
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    
        
    for i in range(anz):
        ang = random.randint(0, 360)        
        speed = random.randint(100, 1000) / 250
        
        move = (cos(radians(ang))*speed + pre_move[0],
                sin(radians(ang))*speed + pre_move[1])

        light = random.randint(60, 100)/100
        size = random.randint(100, 300)/100
        
        fws.append( firew(pos, (r,g,b), light, size, move) )

    # Sound abspielen
    l, r = ( 0.2 + 0.8*(ww-pos[0])/ww, 0.2 + 0.8*pos[0]/ww )
    mix.set_volume(l, r)
    
    mix.play(sound)

    return fws


def rund(liste):
    new = []
    for i in liste:
        new.append(int(round(i)))
    
    return new

def mult(color, multi):
    new = list(color)
    new[0] *= multi
    new[1] *= multi
    new[2] *= multi
    
    return new


pygame.init()

sound = pygame.mixer.Sound("firew.wav")
mix = pygame.mixer.Channel(0)
mix.set_volume(1, 1)

bg = (0, 0, 0)
ww, wh = (1200, 800)
fenster = pygame.display.set_mode((ww, wh))
#pygame.display.set_caption("[Leertaste] für Pause; [c] für automatisches Feuerwerk")


fws = [] # firework particles
rockets = []
force = [0, 0.02, 0.985]

max_counter = random.randint(0, 200)
counter = max_counter

auto  = True
pause = False

run = 1
clock = pygame.time.Clock()

while run:
    pygame.display.set_caption("[Spacebar] to pause; [c] disable automatic fireworks")
    counter -= (auto and not pause)

    if counter <= 0: # neues erstellen
        #pos = [random.randint(ww*1/4, ww*3/4), random.randint(wh*1/4, wh*3/5)]
        pos = [random.randint(ww*2/5, ww*3/5), wh]
        move = [random.randint(-100, 100)/100, -random.randint(800, 1500)/110]
        
        rockets.append( firew(pos, (255, 255, 255), 1, 2, move) )
        
        #fuse = random.randint(50, 150) # Zuendschnur
        fuse = random.randint(50, 80)
        rockets[-1].fuse = fuse

        #fws = summon(fws, pos)
        
        max_counter = random.randint(10, 100)
        counter = max_counter

    for e in pygame.event.get():
        if e.type == QUIT:
            run = 0
        if e.type == KEYDOWN:
            if e.key == K_c:
                auto = not auto
            if e.key == K_SPACE:
                pause = not pause
            if e.key == K_v:
                fws = []; rockets = []
            
        if e.type == MOUSEBUTTONDOWN:
            fws = summon(fws, e.pos)
        

    fenster.fill(bg)
    dellist1 = []
    dellist2 = []

    for i, rocket in enumerate(rockets):
        if not pause:
            rocket.force(force)
            rocket.update()
            
        rocket.render(fenster, False)
        rocket.fuse -= not pause
        
        if rocket.fuse < 0:
            dellist1.append(i)
            # explosion erschaffen
            fws = summon(fws, rocket.pos, rocket.move)
            
    
    for i, f in enumerate(fws):
        if not pause:
            f.force(force)
            f.update()


        f.render(fenster, True and not pause)

        f.light -= (not pause) * random.randint(0, 150) / 7500

        if f.light < 0:
            dellist2.append(i)

    dellist1.reverse()
    dellist2.reverse()
    
    for d in dellist1:
        del rockets[d]
    for d in dellist2:
        del fws[d]

    pygame.display.update()
    clock.tick(80)


pygame.quit()

설명하다. 시범을 보이다

python 코드로 대상에게 산타 모자를 씌웁니다

Jammie — Wed, 7 Dec 2022 11:48:11 +0900

코드. 부호

import numpy as np
import cv2
import dlib

# # img 속 인물사진에 산타 모자를 씌우고, 얼굴은 바른 얼굴이 좋습니다.
def add_hat(img,hat_img):
# # rgba채널을 분리하여 rgb3채널 모자도면을 합성하고 a채널뒤에 mask로 사용합니다
r,g,b,a = cv2.split(hat_img)
rgb_hat = cv2.merge((r,g,b))

cv2.imwrite("hat_alpha.jpg",a)

# # -------------------------------------------------------------------------------------------------
# # # 그레이스케일 변환입니다
# # # gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# # # opencv에 내장된 얼굴 검출기로 얼굴을 검출합니다
# # # face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
# # # faces = face_cascade.detectMultiScale(gray,1.05,3,cv2.CASCADE_SCALE_IMAGE,(50,50))

# # -------------------------------------------------------------------------------------------------

# # dlib 얼굴 키포인트 검출기입니다
predictor_path = "shape_predictor_5_face_landmarks.dat"
predictor = dlib.shape_predictor(predictor_path)

# # dlib 정면 검출기입니다
detector = dlib.get_frontal_face_detector()

# # 얼굴 검사입니다
dets = detector(img, 1)

# # 얼굴 감지되면요
if len(dets)>0:
for d in dets:
x,y,w,h = d.left(),d.top(), d.right()-d.left(), d.bottom()-d.top()
# # # x,y,w,h = faceRect
# # # cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2,8,0)

# # 키포인트 테스트, 5가지 키포인트입니다.
shape = predictor(img, d)
# # # for point in shape.parts():
# # # cv2.circle(img,(point.x,point.y),3,color=(0,255,0))

# # # cv2.imshow("image",img)
# # # cv2.waitKey()

# # 좌우 눈가의 점을 고르세요
point1 = shape.part(0)
point2 = shape.part(2)

# # 두 점 중심 구합니다
eyes_center = ((point1.x+point2.x)//2,(point1.y+point2.y)//2)

# # # cv2.circle(img,eyes_center,3,color=(0,255,0))
# # # cv2.imshow("image",img)
# # # cv2.waitKey()

# # 얼굴 크기에 따라 모자 크기를 조절합니다
factor = 1.5
resized_hat_h = int(round(rgb_hat.shape[0]*w/rgb_hat.shape[1]*factor))
resized_hat_w = int(round(rgb_hat.shape[1]*w/rgb_hat.shape[1]*factor))

if resized_hat_h > y:
resized_hat_h = y-1

# # 얼굴 크기에 따라 모자 크기를 조절합니다
resized_hat = cv2.resize(rgb_hat,(resized_hat_w,resized_hat_h))

# # 알파 채널을 mask로 사용합니다.
mask = cv2.resize(a,(resized_hat_w,resized_hat_h))
mask_inv = cv2.bitwise_not(mask)

# # 모자의 상대적인 얼굴 테두리 위의 선과의 간격띄우기 양입니다
dh = 0
dw = 0
# # 원본 ROI입니다.
# # # bg_roi = img[y+dh-resized_hat_h:y+dh, x+dw:x+dw+resized_hat_w]
bg_roi = img[y+dh-resized_hat_h:y+dh,(eyes_center[0]-resized_hat_w//3):(eyes_center[0]+resized_hat_w//3*2)]

# # 원본 ROI에서 캡을 넣은 영역을 추출합니다.
bg_roi = bg_roi.astype(float)
mask_inv = cv2.merge((mask_inv,mask_inv,mask_inv))
alpha = mask_inv.astype(float)/255

# # 곱하기 전에 크기가 일치하도록 합니다(반올림으로 인해 일치하지 않을 수 있음)
alpha = cv2.resize(alpha,(bg_roi.shape[1],bg_roi.shape[0]))
# # # print("alpha size: ",alpha.shape)
# # # print("bg_roi size: ",bg_roi.shape)
bg = cv2.multiply(alpha, bg_roi)
bg = bg.astype('uint8')

cv2.imwrite("bg.jpg",bg)
# # # cv2.imshow("image",img)
# # # cv2.waitKey()

# # 모자 영역을 추출합니다
hat = cv2.bitwise_and(resized_hat,resized_hat,mask = mask)
cv2.imwrite("hat.jpg",hat)

# # # cv2.imshow("hat",hat)
# # # cv2.imshow("bg",bg)

# # # print("bg size: ",bg.shape)
# # # print("hat size: ",hat.shape)

# # 추가하기 전에 크기가 일치하도록 합니다(반올림으로 인해 일치하지 않을 수 있음)
hat = cv2.resize(hat,(bg_roi.shape[1],bg_roi.shape[0]))
# # 두 ROI 영역을 추가합니다.
add_hat = cv2.add(bg,hat)
# # # cv2.imshow("add_hat",add_hat)

# # 모자가 추가된 부분을 원래 사진으로 다시 넣어주세요.
img[y+dh-resized_hat_h:y+dh,(eyes_center[0]-resized_hat_w//3):(eyes_center[0]+resized_hat_w//3*2)] = add_hat

# # 효과를 보여줍니다.
# # # cv2.imshow("img",img )
# # # cv2.waitKey(0)

return img


# # 모자 그림을 읽습니다. 두 번째 매개 변수 -1은 rgba 채널로, 그렇지 않으면 rgb 채널로 읽힙니다.
hat_img = cv2.imread("hat2.png",-1)

# # 프로필 사진을 읽습니다
img = cv2.imread("1.png")
output = add_hat(img,hat_img)

# # 효과를 보여줍니다.
cv2.imshow("output",output )
cv2.waitKey(0)
cv2.imwrite("output.jpg",output)
# # # import glob as gb

# # # img_path = gb.glob("./images/*.jpg")

# # # for path in img_path:
# # # img = cv2.imread(path)

# # # 모자 추가요
# # # output = add_hat(img,hat_img)

# # # # 효과를 보여줍니다.
# # # cv2.imshow("output",output )
# # # cv2.waitKey(0)

cv2.destroyAllWindows()

파이썬은 네트워크 보안을 지향합니다: nmap

Jammie — Wed, 7 Dec 2022 10:50:28 +0900

설치 및 안내
설치:

 pip install python-nmap

주의: 환경 변수를 설정합니다!
설정 후 pycharm을 재부팅하면 ok 됩니다.

네트워크 보안에 널리 사용되는 오픈 소스 도구 분석기입니다.라이브러리를 사용하면 Nmap을 Python 스크립트와 통합할 수 있으므로 Nmap의 기능을 사용하여 호스트를 검색한 다음 Python 스크립트의 결과와 상호 작용할 수 있습니다.Nmap은 Nmap 검색 결과를 수정하여 자동 검색 작업을 수행하는 데 전문적이기 때문에 Nmap은 침투 테스터가 검색 결과를 분석하고 호스트에 대한 맞춤형 공격을 시작하는 데 사용하는 도구입니다.

문서:

https://pypi.org/project/python-nmap/
https://nmap.org/man/zh/

판례
예를 들어, 예를 들어 내 네이티브 ip의 1~500 포트에 대한 TCP 스캔을 한 번 수행합니다

import nmap
nm = nmap.PortScanner()
a=nm.scan ('당신의 ip', '1-500', '-sS')
print(a)

Python GUI 계산기, 복잡한 연산을 수행할 수 있습니다. [소스 첨부]

Jammie — Wed, 7 Dec 2022 10:46:22 +0900

효과입니다
정상적인 더하기, 빼기, 곱하기 및 빼기 관련 연산을 수행할 수 있으며 소스 코드가 부착되어 자체 테스트됩니다

소스 코드

# # coding=gbk
"""
from tkinter import *

calc = Tk()
calc.title('가와와 계산기')
operator = ''

def clear():
global operator
operator=''
txt_input.set("")
display.insert (0, '계산 시작...')

def button_press(number_or_operator):
global operator
operator = operator+str(number_or_operator)
txt_input.set(operator)

def equal():
global operator
result = float(eval(operator))
txt_input.set(result)
operator=''


txt_input =StringVar (value='계산 시작...')

#-----------------DISPLAY-----------------------------------
display = Entry(calc,font =('arial',30),fg='white',bg='green'
,justify='right',bd='50',textvariable=txt_input)
display.grid(columnspan=4)

#------------------row 1--------------------------------------

button7 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='7',command=lambda:button_press(7)).grid(row=1,column=0)
button8 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='8',command=lambda:button_press(8)).grid(row=1,column=1)
button9 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='9',command=lambda:button_press(9)).grid(row=1,column=2)
button_clear = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='green',
font=('arial',30,'bold'),text='C',command=clear).grid(row=1,column=3)

#------------------row 2--------------------------------------

button4 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='4',command=lambda:button_press(4)).grid(row=2,column=0)
button5 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='5',command=lambda:button_press(5)).grid(row=2,column=1)
button6 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='6',command=lambda:button_press(6)).grid(row=2,column=2)
button_plus = Button(calc,padx =34,pady =12,bd=8,fg='black',bg='orange',
font=('arial',30,'bold'),text='+',command=lambda:button_press('+')).grid(row=2,column=3)

#------------------row 3--------------------------------------

button1 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='1',command=lambda:button_press(1)).grid(row=3,column=0)
button2 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='2',command=lambda:button_press(2)).grid(row=3,column=1)
button3 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='3',command=lambda:button_press(3)).grid(row=3,column=2)
button_minus = Button(calc,padx =38,pady =12,bd=8,fg='black',bg='orange',
font=('arial',30,'bold'),text='-',command=lambda:button_press('-')).grid(row=3,column=3)

#------------------row 4--------------------------------------

button_0 = Button(calc,padx =30,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='0',command=lambda:button_press(0)).grid(row=4,column=0)
button_dot = Button(calc,padx =36,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='.',command=lambda:button_press('.')).grid(row=4,column=1)
button_divide = Button(calc,padx =36,pady =12,bd=8,fg='black',bg='orange',
font=('arial',30,'bold'),text='/',command=lambda:button_press('/')).grid(row=4,column=2)
button_mult = Button(calc,padx =38,pady =12,bd=8,fg='black',bg='orange',
font=('arial',30,'bold'),text='*',command=lambda:button_press('*')).grid(row=4,column=3)

#------------------row 5--------------------------------------

button_equal = Button(calc,padx =95,pady =12,bd=8,fg='black',bg='green',
font=('arial',30,'bold'),text='=',command=equal).grid(row=5,column=0,columnspan=2)
button_open = Button(calc,padx =35,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text='(',command=lambda:button_press('(')).grid(row=5,column=2)
button_close = Button(calc,padx =38,pady =12,bd=8,fg='black',bg='white',
font=('arial',30,'bold'),text=')',command=lambda:button_press(')')).grid(row=5,column=3)

calc.mainloop()

Python 프로그램 실행 시간입니다

Jammie — Tue, 6 Dec 2022 16:41:17 +0900

Python 프로그램 실행 시간입니다

import datetime

t11 = datetime.datetime.now()
# 시간이 많이 걸리는 프로그램입니다.
time.sleep(1)
a = 'sssssss\taaaaa\taaaaaaa'
s = a.replace('\t', ',')

t22 = datetime.datetime.now()
tt = t22 - t11
print('시간 사용', tt)

결과 (시간:분:초:)

사용시간 0:00:01.005971입니다

time

import time
t1 = time.time()


time.sleep(1)
a = 'sssssss\taaaaa\taaaaaaa'
s = a.replace('\t', ',')

t2 = time.time()
t = t2 -t1
print('시간 사용', t)

결과(초) 입니다

사용시간 1.007965326309204

Python 딥러닝에서 자주 사용하는 패키지 요약입니다

Jammie — Tue, 6 Dec 2022 16:35:33 +0900

Python 딥러닝에서 자주 사용하는 패키지 요약입니다

일반적으로 사용되는 Pytorch 프레임워크보다 일반적으로 사용되는 패키지를 기록하여 딥 러닝 환경을 쉽게 재구성할 수 있습니다.

1.틀입니다

다른 프레임은 일반적으로 다른 환경에 설치됩니다.
최신 Anaconda는 Python 3.6, Python 3.7 가상 환경을 만들어 Pytorch, tensorflow를 위한 별도의 환경을 만듭니다.
pytorch, tensorflow, paddle, mxnet 딥러닝 프레임워크가 GPU 기능을 올바르게 지원하는지 확인합니다.
python이 pip 수정 미러링 - cmd 명령을 수정했습니다
아나콘다 환경에서 conda 명령을 사용하여 cuda, cudnn, tensorflow(-gpu), pytorch를 설치합니다

1.1 pytorch

현재 설치 버전: 1.7.1입니다

pip install torch===1.7.1+cu110 torchvision===0.8.2+cu110 torchaudio===0.7.2 -f https://download.pytorch.org/whl/torch_stable.html

pytorch 1.9.0

pip3 install torch==1.9.0+cu111 torchvision==0.10.0+cu111 torchaudio===0.9.0 -f https://download.pytorch.org/whl/torch_stable.html

1.2 tensorflow 1.15 cpu, gpu 버전입니다

파이썬 버전 3.5 - 3.7이면요

pip install tensorflow==1.15 -i http://pypi.douban.com/simple/

# gpu 버전입니다.
pip install tensorflow-gpu==1.15

Linux 시스템을 설치하는 가장 좋은 방법입니다

conda install -c conda-forge tensorflow-gpu==1.15.0

cudatoolkit과 cudnn 플러그인을 설치하는 동안 GPU의 cuda를 글로벌하게 설치하지 않아도 됩니다. 글로벌 cuda를 구성하는 것은 매우 어렵기 때문입니다.

conda는 적절한 cudatoolkit과 cudnn 버전을 자동으로 선택하여 설치합니다

아직 나도 conda 명령만 성공했을 뿐 pip 명령은 모릅니다

1.3tensorflow2.0

# gpu 버전입니다.
pip install tensorflow-gpu==2.0
# cpu 버전입니다.
pip install tensorflow==2.0

1.4 Anaconda 가상 환경에 Tensorflow-gpu-멀티버전에 CUDA를 설치합니다
인터넷에서 Tensorflow-gpu의 설치 튜토리얼을 읽으면 cuda를 설치할 때 사람들이 대머리가 보입니다. 왜냐하면 그들은 모두 공식 웹 사이트에서 cuda와 cudnn을 다운로드하도록 하고 Windows 시스템을 기반으로 다양한 환경 변수를 추가하고 모든 버전이 호환되어야 하며 여러분의 몸과 마음을 힘들게 하기 때문입니다.

당신이 필요로 하는 텐서플로우 버전을 참고하여 해당 버전의 쿠다를 설치하는 것이 중요합니다!!!!

1.쿠다툴킷(CUDA)을 설치합니다

CUDA를 설치할 때는 반드시 버전을 지정해야 합니다. 예를 들어 TensorFlow는 2.3.0 버전입니다. 위 그림을 참고하세요  나는 CUDA 10.1을 설치할 것입니다

conda install-canaconda cudatoolkit #-c는 channel을 나타냅니다. 검색 팩의 채널을 지정하는 데 사용됩니다. 기본 최신 버전입니다.
or
conda install cudatoolkit=10.1 # 버전을 지정하려면

2.cudnn을 설치합니다

이전 단계에서 버전을 지정하면 여기서 ~가 자동으로 일치하므로 CUDA를 설치할 때 버전을 지정하여 설치합니다.이렇게 하면 다음 첫 번째 명령을 사용하여 설치할 수 있습니다

conda install - canaconda cudnn #버전을 위에서 지정하면 자동으로 일치합니다~
conda install cudnn=7.3.1

1.5 DGL 그림 네트워크 프레임워크입니다

# 위의 pytorch 1.7.1과 함께 사용하려면 pytorch 1.7.1을 먼저 설치합니다.
pip install dgl-cu110

2.공구집입니다.
총명령입니다
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

pip install matplotlib numpy opencv-python pillow scikit-learn pandas openpyxl h5py scipy tqdm seaborn grip  jupyter notebook

NLP의 가방을 추가합니다

pip install jieba wordcloud gensim

파충류 가방 좀 주세요

pip install requests selenium beautifulsoup4 lxml

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

2.1 scikit-learn(sklearn)

pip install scikit-learn

현재 버전: 0.24.1입니다.

2.2 pandas

pip install pandas

현재 버전: 1.2.2입니다

pandas를 설치하면 numpy가 설치됩니다.

2.3 numpy

pip install numpy

현재 버전: 1.20.1입니다

이전 pytorch 설치에서는 최신 numpy를 사용할 수 없었습니다.1.16.6 가능합니다.

하지만 지금은 최신버전으로 가능합니다

2.4 matplotlib
그림 꾸러미를 그립니다

pip install matplotlib

현재 버전: 3.3.4입니다.

2.5 jupyter notebook

pip install jupyter notebook

2.6 gensim

젠심은 구문(또는 전체 문장 또는 문서와 같은 상위 구조) 패턴을 측정하여 문서의 의미 구조를 마이닝하는 도구입니다.
알고리즘에는 Word2vec, doc2vec 등이 있습니다

pip install gensim

설치 포인트: gensim의 명령어 버전에 따라 매개변수가 다를 수 있으며 scipy 버전과도 관련이 있습니다.
일부 오래된 코드와 같이 일반적으로 gensim 3.0이 사용되지만 이것은 scipy==1.2.1이 필요할 수 있습니다. 그렇지 않으면 오류가 발생하거나 Attribute Error: module 'scipy. misc' has no attribute XXX의 이상이 보고될 수 있습니다.이 이상을 신고하면 scipy 버전이 틀렸다는 뜻입니다.
최신 젠심을 사용하면 인터넷에서 찾은 코드를 어느 정도 수정해야 할 수도 있습니다

3 적게 쓰는 가방입니다
3.1 networkx
networkx는 복잡한 그래프 구조를 구성하고 조작하고 그래프 분석 알고리즘을 제공하는 파이썬의 패키지입니다

pip install networkx

현재 버전: 2.5입니다.

3.2 seaborn
Seaborn은 matplotlib의 강력한 확장입니다

pip install seaborn

파이썬넘바 라이브러리

Jammie — Tue, 6 Dec 2022 15:16:20 +0900

파이썬넘바 라이브러리
기사 목록입니다.
파이썬넘바 라이브러리
1넘바 소개입니다
왜 numba를 선택했나요?
2.numba 설치 사용방법
**설치합니다**
1넘바 소개입니다
numba는 파이썬 배열 및 수치 계산 함수를 컴파일하는 데 사용되는 컴파일러로 파이썬을 직접 사용하여 작성된 함수의 연산 속도를 크게 향상시킬 수 있습니다.

numba는 LLVM 컴파일러 아키텍처를 사용하여 순수한 파이썬 코드를 최적화하고 파이썬의 인터프리터를 변경하지 않고 간단한 주석을 추가하여 배열 지향 및 많은 수의 수학을 사용하는 파이썬 코드를 c, c++ 및 Fortran과 유사한 성능으로 최적화합니다.numba의 컴파일 방식은 아래 그림과 같습니다

왜 numba를 선택했나요?
cython이나 Pypy와 같은 많은 다른 컴파일러들이 있지만, Numbade를 선택하는 이유는 python 코드의 편안한 영역을 벗어날 필요가 없고, 당신의 코드를 변경하기 위해 약간의 가속을 얻기 위해 장식기를 Python 함수에 추가하면 가속이 완료되며, 가속 효과는 cython 코드에 필적합니다.

2.numba 설치 사용방법
설치하다

pip install numba

numba가 코드를 가속할 때 **, 최적화할 함수에 @jit 최적화기를 추가하면 **입니다.jit을 사용할 때 numba가 언제 어떻게 최적화할지 결정할 수 있습니다.다음과 같은 간단한 예를 보여 줍니다

from numba import jit
@jit
def f(x, y):
    return x + y

print(f(1,2))
print(f(1.5,2))

이 코드의 계산은 호출에 의해 처음 수행되며 numba는 호출 중에 매개변수 유형을 추론한 다음 이 정보를 기반으로 최적화된 코드를 생성합니다.numba는 또한 입력된 유형의 컴파일을 기반으로 특정 코드를 생성할 수 있습니다.예를 들어, 위의 코드의 경우 들어오는 정수와 부동 소수점 수를 매개변수로 사용하면 다른 코드가 생성됩니다.

이제 한 가지 예를 보겠습니다

from numba import jit
import time
@jit
def foo():
    x = []
    for a in range(100000000):
        x.append(a)

def foo_withoutfit():
    y = []  
    for b in range(100000000):
        y.append(b)

이제 우리는 동일한 방법을 정의하고 구현된 기능도 동일합니다. 하나는 numba를 사용하여 가속하고 하나는 가속하지 않은 것입니다. 실행 시간을 살펴보겠습니다

결과에서 알 수 있듯이 numba를 가속에 사용했을 때 속도가 10배 이상 증가했습니다

python-imutils 패키지 프로필 사용

Jammie — Tue, 6 Dec 2022 14:27:51 +0900

python-imutils 패키지 프로필 사용
기사 목록입니다.
python-imutils 패키지 프로필 사용
1.imutils 기능 소개입니다
설치 방법:
2.이뮤틸스 사용법입니다
2.1 그림을 이동시킵니다
2.2 확대/ 축소합니다
2.3 그림을 회전시킵니다
2.4 골격추출(가장자리추출)
2.5 RGB를 돌려서 Matplotlib로 표시합니다
2.6 OPenCV 버전 탐지입니다
1.imutils 기능 소개입니다
imutils는 OPenCV 인터페이스를 호출하는 보다 간단한 목적을 달성하기 위해 OPenCV를 기반으로 하는 패키지로 이미지의 이동, 회전, 스케일링 및 골격화와 같은 일련의 작업을 쉽게 실현할 수 있습니다.

설치 방법:

pip install imutils

numpy, scipy, matplotlib 및 opencv가 설치되어 있는지 설치 전에 확인해야 합니다.

패키지 누락 오류가 발생하면요

다음 설치 명령을 사용하여 모든 패키지를 설치할 수 있습니다

pip install NumPy SciPy opencv-python matplotlib imutils

2.이뮤틸스 사용법입니다
2.1 그림을 이동시킵니다

원래 cv에 비해, imutiles를 사용하면 변환 행렬을 구성하지 않고 변환 픽셀을 직접 지정할 수 있습니다

이미지 병진 구현은 OpenCV에서도 제공되며 먼저 병진 행렬을 계산한 다음 아핀 변환을 사용하여 병진을 구현하려면 이미지 병진을 이뮤틸에서 직접 수행할 수 있습니다.

translated = imutils.translate(img,x,y)

매개 변수:

img: 이동할 그림입니다
x:x축 방향으로 움직이는 픽셀의 개수입니다
y: y축 방향으로 움직이는 픽셀의 개수입니다

실행 코드 설명:

이미지 주소를 변경하려면 주소에 중국어를 포함할 수 없습니다

cv에서 그림을 읽는 것은 BGR 형식이고, img[:,:,::::1]은 RGB 형식으로 되돌리기 위한 것입니다. 그래야 컬러 이미지를 정상적으로 표시할 수 있습니다

import numpy as np
import cv2 as cv
import imutils
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #중국어 탭을 정상적으로 표시합니다.
plt.rcParams['axes.unicode_minus'] = False # 일반 음수 표시에 사용합니다.


img = cv.imread ('image1.jpg') # 그림 주소 변경하기
translated = imutils.translate(img, 100, 50) # 변환 함수입니다.

plt.figure()
plt.subplot(121)
plt.imshow(img[:,:::: -1]) # img[:::::::::::::::::::::::::::::::::
plt.title ('원본 그림')
plt.subplot(122)
plt.imshow(translated[:,:,::-1])
plt.title( '결과 이동')
plt.show()

2.2 확대/ 축소합니다
OPenCV에서 사진의 줌은 종횡비를 유지하도록 주의해야 합니다.이뮤틸스에서는 자동으로 원래 사진의 가로 세로 비율을 유지하고, 너비 weight와 height만 지정하면 됩니다.

스케일링 함수: imutils.resize(img, width=100)

import numpy as np
import cv2 as cv
import imutils
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #중국어 탭을 정상적으로 표시합니다.
plt.rcParams['axes.unicode_minus'] = False # 일반 음수 표시에 사용합니다.


img = cv.imread('image1.jpg')
# 일반적으로 width 매개 변수가 있으면 width 매개 변수를 설치하여 스케일링하고 height 매개 변수를 무시하며, 두 매개 변수가 비례하지 않으면 width를 설치하여 스케일링합니다.
resized = imutils.resize(img,width=100) # 너비를 지정하면 해당 비율의 높이가 자동으로 계산되며 파라미터 height도 있습니다.


print('원본 크기: ', img.shape')
print( '크기 크기 조정', resized.shape)
plt.figure()
plt.subplot(121)
plt.imshow(img[:,:,::-1])
plt.title ('원본 그림')
plt.subplot(122)
plt.imshow(resized[:,:,::-1])
plt.title ('줌 그림')
plt.show()

3 그림 회전합니다
OpenCV에서 회전할 때 아핀 변환을 사용하는데 여기서 이미지 회전 방법은 imutils.rotate( )로 두 가지 매개변수가 있으며 첫 번째는 이미지 데이터, 두 번째는 회전 각도, 회전은 반시계 방향입니다.동시에 imutils는 시계 방향으로 회전하는 또 다른 유사한 방법인 rotate_round( )를 제공합니다

함수:

시계 반대 방향으로 돌립니다

rotated = imutils.rotate(image, 90)

시계 방향으로 돌립니다

rotated_round = imutils.rotate_bound(image, 90)

import numpy as np
import cv2 as cv
import imutils
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #중국어 탭을 정상적으로 표시합니다.
plt.rcParams['axes.unicode_minus'] = False # 일반 음수 표시에 사용합니다.


image = cv.imread('image1.jpg')
# 시계 반대 방향으로 돌립니다
rotated = imutils.rotate(image, 90)
# 시계 방향으로 돌립니다
rotated_round = imutils.rotate_bound(image, 90) # 그림을 그립니다
plt.figure(figsize=[10, 10])
plt.subplot(1,3,1)
plt.imshow(img[:,:,::-1])
plt.title ('원본 그림')
plt.axis("off")
plt.subplot(1,3,2)
plt.imshow(rotated[:,:,::-1])
plt.title('반시계방향으로 90도 회전')
plt.axis("off")
plt.subplot(1,3,3)
plt.imshow(rotated_round[:,:,::-1])
plt.title('시계 방향으로 90도 회전')
plt.axis("off")
plt.show()

2.4 골격추출(가장자리추출)
스켈레톤 추출(엣지 추출)은 사진 속 물체를 토폴로지 스켈레톤으로 구성하는 과정을 말합니다.

imutils에서 제공하는 방법은 skeletonize( )입니다.

두 번째 매개변수는 구조적 매개변수의 크기(structuring element)로 입자 크기에 해당하며 작을수록 처리 시간이 길어집니다.(3,3)로 설정할 수 있으며, 아래의 실험에서는 (7,7의)를 사용하였습니다

주의, 모든 그림에서 골격을 구할 수 있는 것은 아닙니다. 예를 들어 제가 위에 사용한 도라에몽은 안 됩니다

import cv2 as cv
import imutils
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei'] #중국어 탭을 정상적으로 표시합니다.
plt.rcParams['axes.unicode_minus'] = False # 일반 음수 표시에 사용합니다.


# 1 그림 읽기입니다
image2 = cv.imread('earth.png')
# 2 그레이스케일링합니다
gray = cv.cvtColor(image2, cv.COLOR_BGR2GRAY)
# 3 스켈레톤 추출입니다
skeleton = imutils.skeletonize(gray, size=(7, 7))

# 4 그림으로 보여 줍니다
plt.figure()
plt.subplot(121), plt.imshow(image2[:,::::1]), plt.title('원본') 입니다.

plt.subplot (122), plt.imshow (skeleton, cmap="gray"), plt.title ('스켈레톤 추출 결과') # 그레이스케일 그림을 표시합니다. gray를 선언하려면

plt.show()

2.5 RGB를 돌려서 Matplotlib로 표시합니다
OpenCV의 파이썬 바인딩에서 이미지는 BGR 순서로 NumPy 배열로 표시됩니다.이 cv2.imshow 기능을 사용할 때 효과가 좋습니다.그러나 Matplotlib를 사용하려는 경우 이 plt.imshow 함수는 이미지가 RGB 순서로 정렬된다고 가정합니다.이 문제를 해결하기 위해 cv2.cvtColor를 호출하거나 opencv2matplotlib의 편리한 기능을 사용할 수도 있습니다

img = cv.imread("lion.jpeg")
plt.figure()
plt.imshow(imutils.opencv2matplotlib(img))

2.6 OPenCV 버전 탐지입니다
OpenCV4 출시 후 주요 버전이 업데이트됨에 따라 역호환성 문제가 특히 두드러졌습니다.OPenCV를 사용할 때 현재 사용 중인 OpenCV 버전을 확인한 다음 적절한 함수 또는 방법을 사용해야 합니다.imutils의 is_cv2(), is_cv3() 및 is_cv4()는 현재 환경을 자동으로 결정하는 데 사용할 수 있는 OpenCV의 간단한 기능입니다

print("OPenCV 버전: {}).format(cv2._version_)) 입니다

python은 ValueError could not broadcast input array from shape 또는 Can't convert non-rectangular를 보고합니다

Jammie — Tue, 6 Dec 2022 14:17:28 +0900

python 보고서ValueError: could not broadcast input array from shape

numpy valueError: could not broadcast input array from shape 입니다.

tensorflow 보고 ValueError: Can't convert non-rectangular Python sequence to Tensor.

이 두 가지 오류는 모두 동일한 원인입니다

numpy 및 tensorflow를 사용하여 list를 array 또는 tensor로 변환할 때 오류를 보고합니다.

잘못된 코드가 뜹니다:

a = np.array([[1.1,1.2],[2.1,2.2]])
b = np.array([[1.1,1.2,1.3],[2.1,2.2,2.3]])
c = [a,b]
d = np.array(c)
# d = tf.constant(c)

오류 메시지 설명입니다

ValueError: could not broadcast input array from shape (2,2) into shape (2)
# ValueError: Can't convert non-rectangular Python sequence to Tensor.

문제 분석입니다
이 문제가 발생하는 주요 원인은 list에서 array의 shape가 일치하지 않기 때문에 이 문제가 발생할 경우 list에서 배열의 shape를 모두 출력하여 관찰해 봅니다

print(a.shape,b.shape)

정보를 출력합니다

(2, 2) (2, 3)

문제를 해결하다.
이 문제에 대한 세 가지 주요 해결 방법이 있는데 첫 번째는 사전을 사용하는 것으로 변경하는 것입니다.두번째는 list에 있는 array를 모두 전개하는 것이고, 세번째는 mask를 이용하여 배열의 shape를 일치시키는 것입니다.

첫 번째는 사전을 사용하는 것으로 바꿉니다

각 목록을 사전으로 구분하여 저장하고, 각 목록을 tensorflow나 numpy의 데이터 형식으로 변환할 수 있습니다.

만약 나중에 변수 c를 조작한다면, 이 방식을 추천합니다

a = np.array([[1.1,1.2],[2.1,2.2]])
b = np.array([[1.1,1.2,1.3],[2.1,2.2,2.3]])
c = {'a':tf.constant(a),'b':tf.constant(b)}
print(c)

{'a': <tf.Tensor: id=0, shape=(2, 2), dtype=float64, numpy=
array([[1.1, 1.2],
       [2.1, 2.2]])>, 'b': <tf.Tensor: id=1, shape=(2, 3), dtype=float64, numpy=
array([[1.1, 1.2, 1.3],
       [2.1, 2.2, 2.3]])>}

사용할 때는 사전 사용만 누르면 됩니다.

배열을 펼칩니다
이 방법을 사용할 때는 배열의 행이나 열을 일치시켜야 하는데, 하나의 차원이 다를 수밖에 없고, 그렇지 않으면 배열이 환원될 수 없습니다

a = np.array([[1.1,1.2],[2.1,2.2]])
b = np.array([[1.1,1.2,1.3],[2.1,2.2,2.3]])
c = np.array([a.ravel(),b.ravel()])
print(c)
for arr in c:
print(arr.reshape(2,-1) # 모양을 바꿉니다

정보를 출력합니다

[array([1.1, 1.2, 2.1, 2.2]) array([1.1, 1.2, 1.3, 2.1, 2.2, 2.3])]

[[1.1 1.2]
 [2.1 2.2]]
[[1.1 1.2 1.3]
 [2.1 2.2 2.3]]

mask를 이용합니다.
이 방법은 주로 사진에 적용하는데, 보통 사진의 최대 크기를 템플릿으로 사용합니다. 물론 사진이라면 resize를 통해서도 shape를 일치시킬 수 있습니다. 다만 resize를 사용하면 사진이 변형되어 사진 표현에 영향을 줄 수 있습니다

import copy
a = np.array([[1.1,1.2],[2.1,2.2]])
b = np.array([[1.1,1.2,1.3],[2.1,2.2,2.3]])
mask = np.zeros((2,3))
a_mask = copy.deepcopy(mask)
a_mask[:a.shape[0],:a.shape[1]] = a
b_mask = copy.deepcopy(mask)
b_mask[:b.shape[0],:b.shape[1]] = b
c = np.array([a_mask,b_mask])
print(c)

정보를 출력합니다

[[[1.1 1.2 0. ]
  [2.1 2.2 0. ]]

 [[1.1 1.2 1.3]
  [2.1 2.2 2.3]]]

python 현재 실행 중인 스레드 이름과 개수를 가져옵니다. threading.enumerate( )

Jammie — Tue, 6 Dec 2022 14:11:07 +0900

python 현재 실행 중인 스레드 이름과 개수를 가져옵니다. threading.enumerate( )

import threading
import time


def test1():
for i in range(5):
print("-----test1-----%s" % i)
time.sleep(1)


def test2():
for i in range(3):
print("-----test2-----%s" % i)
time.sleep(1)


def main():
# thread를 호출하기 전에 현재 스레드 정보를 인쇄합니다
print(threading.enumerate())
# 스레드를 만듭니다
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)

t1.start()
t2.start()

# 스레드 목록과 수량을 봅니다
while True:
# threading.enumerate(): 스레드 이름과 ID를 포함하는 실행 중인 스레드를 포함하는 list를 반환합니다.
thread_num = len(threading.enumerate())
print("스레드 수는%d"% thread_num) 입니다
print(threading.enumerate())
if thread_num <= 1:
break
time.sleep(1)


if __name__ == '__main__':
main()

[<_MainThread(MainThread, started 15900)>]
-----test1-----0
-----test2-----0
스레드 수량은 3입니다
[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>, <Thread(Thread-2, started 14980)>]
-----test2---1 스레드 수는 3입니다

-----test1-----1[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>, <Thread(Thread-2, started 14980)>]

스레드 수량은 3입니다
[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>, <Thread(Thread-2, started 14980)>]
-----test1-----2-----test2-----2

스레드 수량은 3입니다
[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>, <Thread(Thread-2, started 14980)>]
-----test1-----3
스레드 수량은 2입니다
[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>]
-----test1-----4
스레드 수량은 2입니다
[<_MainThread(MainThread, started 15900)>, <Thread(Thread-1, started 14704)>]
스레드 수량은 1입니다
[<_MainThread(MainThread, started 15900)>]

python flask send_file 파일을 업로드하고 jquery.js를 통해 다운로드합니다

Jammie — Tue, 6 Dec 2022 14:03:00 +0900

python flask send_file 파일을 업로드하고 jquery.js를 통해 다운로드합니다
백엔드 라우팅입니다

@app.route("/download_data_file", methods=['GET', 'POST'])
def download_data_file():
"""
브라우저 다운로드 파일 인터페이스입니다
flask의 send_file로 파일을 보냅니다
"""
# 파일 이름 (확장자 포함)
info = json.loads(request.form.get('data'))
filename = info['filename']
filepath = info['filepath']
# # print(filepath)
# 파일 크기입니다
fsize = os.path.getsize(filepath)

response = make_response(send_file(filepath, as_attachment=True))
response.headers["Content-Disposition"] = "attachment; filename={}".format(filename.encode().decode('latin-1'))
response.headers["Content-length"] = fsize
return response

프론트 js입니다

function download_data_btn_func(obj) {
let filename = test.txt;
let filepath = ./test.txt;
let params = {};
params['filepath'] = filepath
params['filename'] = filename
console.log(params)
// 참고: 파일을 다운로드한 ajax는 dataType이 'json'이 아니라고 요청했습니다.그를 제거하면 ajax가 자동으로 dataType 속성 값을 맞춥니다.
$.ajax({
url: '/download_data_file',
type: 'post',
data: { 'data': JSON.stringify(params) },
success: function (result) {
// a 요소를 시뮬레이션하여 파일을 다운로드합니다
let blob = new Blob([result]);
let a = document.createElement('a');
let url = window.URL.createObjectURL(blob);
a.href = url;
a.download = filename;
a.click();
window.URL.revokeObjectURL(url);
},
error: function (result) {
console.log(result)
}
})
}

vscode를 사용하여 Python 프로그램을 만들고 실행합니다

Jammie — Sat, 3 Dec 2022 14:20:56 +0900

최근에는 컴퓨터 비전 소백을 중심으로 파이썬 입문, 파이토치 딥러닝 프레임워크 입문 기사 시리즈를 준비하고 있습니다.

컴퓨터 비전문 독자나 컴퓨터 비전에 막 입문한 독자에게 기초를 다지기 위해 며칠 전 특별히 입문 글을 써서 컴퓨터 비전에서 가장 기초적인 개념과 명사를 소개했습니다.

오늘은 vscode에서 Python 프로그램을 만들고 실행하는 방법을 주로 공유하여 나중에 쉽게 배울 수 있도록 하겠습니다.

여기 나는 win10에서 했고 Ubuntu에서의 구성 방법은 이와 유사합니다.

당신도 Win10에서 완료한다면 Python을 미리 설치해야 합니다.

Win10에서 Python3을 설치하는 방법

Ubuntu에서 완료했다면 Python을 설치할 필요가 없었을 것입니다.

0.vscode를 설치합니다
vscode는 win10, Ubuntu 등 다양한 주류 운영 체제를 지원하는 코드 편집기입니다.vscode에는 코드 작성, 디버깅, 실행 및 버전 관리를 쉽게 완료할 수 있는 실용적인 확장 도구가 많이 있습니다

다운로드 인터페이스에서 운영 체제에 따라 다른 다운로드 파일을 선택하십시오.다운로드가 완료되면 뇌 없이 설치하시면 됩니다.

설치된 시작 아이콘을 찾아서 vscode를 시작하고 시작 아이콘은 아래 그림과 같습니다

부팅 후 인터페이스는 아래 그림과 같습니다

1.vscode에 Python 플러그인을 설치합니다
vscode에서 Python 코드를 효율적으로 편집하려면 Python 플러그인을 설치해야 합니다. 아래 그림의 빨간색 테두리 안에 있는 버튼을 클릭하십시오:

그런 다음 왼쪽 상단 검색 상자에 Python을 입력하고 아래 그림에서 보는 바와 같이 빨간색 테두리 안의 버튼을 클릭하여 플러그인을 설치하면 빨간색 테두리 안의 버튼이 'Installing'으로 바뀌어 'Installing'이 사라질 때까지 기다립니다

vscode를 껐다가 다시 켜보시고, 아래 그림의 빨간색 상자 안에 있는 버튼을 클릭하시면 설치된 플러그인을 보실 수 있습니다

Python 플러그인이 설치되어 있고 vscode에서 Jupyter 플러그인이 자동으로 설치되어 있는 것으로 확인되었습니다.

2. 파이썬 인터프리터를 선택합니다.
vscode 인터페이스에서 키보드 단축키: F1(또는 Ctrl+Shift+P)을 누르면 vscode 인터페이스 위에 아래 그림의 빨간색 상자에 텍스트 상자가 나타나며 이를 명령 모음이라고 합니다

다음 그림과 같이 명령란에 Python:Select Interpreter를 입력합니다

위 그림의 파란색 텍스트를 클릭하면 아래 그림과 같은 내용이 표시됩니다

나는 여기에 파이썬 인터프리터가 여러 개 설치되어 있기 때문에 여기에 여러 개가 표시됩니다.당신이 Python을 한 번만 설치했다면, 여기에 당신이 설치한 그 Python.exe만 나와야 합니다.설치한 Python.exe를 선택하고 잠시 기다리면 vscode 인터페이스의 왼쪽 하단에 아래 그림의 빨간색 상자 안에 있는 텍스트가 표시됩니다. 즉, vscode가 Python 인터프리터를 인식했음을 나타냅니다.빨간색 상자의 "Python" 문자 뒤에 있는 숫자가 우리가 설치한 Python 버전입니다

3.첫 번째 python 파일을 만듭니다.
C 디스크 아래에 "Python 학습"이라는 폴더를 만들고 vscode 인터페이스 아래에서 아래 그림의 빨간색 버튼과 보라색 버튼을 차례로 클릭하는 등 디스크에 새 폴더를 만듭니다

방금 새로 만든 폴더를 선택한 후 아래 그림의 빨간색 상자에 있는 "폴더 선택" 단추를 누르십시오. 아래 그림과 같이

위의 조작이 완료되면 아래 그림의 빨간색 테두리 안에 있는 버튼을 클릭하십시오

위 사진에서 보라색 상자가 있는 곳에서 방금 선택한 폴더 이름을 볼 수 있습니다.위 그림의 녹색 화살표가 가리키는 버튼을 클릭하면 파일을 새로 만들고 이름을 붙일 수 있습니다.여기서 새 파일을 만드는 것은 우리가 보통 win10에서 새 파일을 만드는 것과 같은 효과입니다.

hello.py'이라는 이름의 새 파일은 vscode가 Python 파일로 인식하도록 파일 접미사가 .py라는 점에 유의하십시오.

이 파일에 다음과 같은 코드를 입력하십시오.

msg = 'Hello World'
print(msg)

입력이 완료되면 아래 그림과 같습니다

4.hello.py를 실행합니다.
여기 파이썬 파일을 실행하는 두 가지 방법이 있습니다.

방법 1입니다.
vscode의 오른쪽 상단 모서리에 있는 녹색 삼각형을 누르십시오. 즉, 아래 그림의 오른쪽 빨간색 상자 안에 있는 아이콘을 클릭합니다

완료를 클릭하면 아래 그림과 같이 vscode 인터페이스 아래에서 실행 결과를 볼 수 있습니다

방법 2입니다.
코드가 쓰여진 위치를 오른쪽 버튼으로 클릭하고 표시되는 메뉴에서 "Run Python File in Terminal"을 선택하면 아래 그림과 같이 hello.py 파일을 실행할 수도 있습니다

selenium 프레임워크 stealth.min.js 파일은 브라우저 지문 기능을 숨깁니다

Jammie — Fri, 2 Dec 2022 15:06:56 +0900

브라우저 지문이 무엇입니까?

브라우저 지문은 브라우저의 다양한 정보를 말하며, 우리가 다른 사이트를 방문할 때 익명 모드에서도 웹사이트가 우리의 신원을 식별하는 데 도움을 줄 수 있습니다.
사람의 손에 있는 지문이 유일한 이유는 각각의 지문이 독특한 무늬를 가지고 있고 이 무늬가 요철 피부에 형성되어 독특한 특징을 가지고 있기 때문입니다.

브라우저 지문과 손과 손가락의 지문은 모두 독특한 특성을 가지고 있습니다.웹 사이트는 브라우저 식별 정보를 얻고 일부 계산을 수행하여 값을 얻으며 이 값은 브라우저 지문입니다.

브라우저 지문을 수동으로 엽니다

정상적인 상황에서는 수동으로 브라우저를 열고 웹사이트 https://bot.sannysoft.com/를 입력합니다.

selenium 인터페이스 모드 없이 브라우저를 엽니다

selenium 운영 브라우저는 웹 사이트에서 수십 가지 특징을 감지하여 당신이 크롤러임을 쉽게 식별할 수 있습니다

seleenium 인터페이스 모드 브라우저 열기:

from selenium import webdriver


chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
driver = webdriver.Chrome(chrome_options=chrome_options)

driver.get('https://bot.sannysoft.com/')

#현재 페이지를 캡처합니다
driver.save_screenshot('1.png')

<br/>

그림 생성하기:

분명히 웹 사이트에 파충류인 것으로 밝혀졌습니다!

브라우저의 지문을 숨기는 방법입니다

브라우저의 지문 기능을 해결하는 열쇠는 실제로 stealth.min.js 파일입니다. 파이썬을 통해 이 js 파일을 실행하면 브라우저의 지문을 숨길 수 있습니다

stealth.min.js 파일 다운로드 주소: 팔로우 글 말 공식 계정, 답변: 브라우저 지문 숨기기

요청 헤더 추가 + stealth.min.js 파일 실행으로 브라우저 지문을 숨깁니다:

from selenium import webdriver

chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
# 요청 헤더 위장 브라우저를 추가합니다
chrome_options.add_argument(
    'user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36')
driver = webdriver.Chrome(chrome_options=chrome_options)

with open('stealth.min.js') as f:
    js = f.read()

driver.execute_cdp_cmd("Page.addScriptToEvaluateOnNewDocument", {
    "source": js
})

driver.get('https://bot.sannysoft.com/')
driver.save_screenshot('2.png')

실행 결과:

stealth.min.js를 실행하여 브라우저 지문을 숨기는 것은 이미 일반 접속과 같습니다!

kali Linux에서 python 2.7을 설치합니다. (python 3도 일반적입니다)

Jammie — Fri, 2 Dec 2022 14:56:48 +0900

하나. 공식으로 가서 설치 패키지를 다운로드하세요

다운로드를 위해 설치해야 하는 설치 패키지를 찾습니다.그런 다음 kali에 업로드하여 압축을 풀고 설치하는데, 아래의 절차는 아래의 방법2를 참고하시면 됩니다.

2. wget 명령으로 설치합니다

1. kali의 명령줄에 다음을 입력하십시오

wget https://www.python.org/ftp/python/2.7.9/Python-2.7.9.tgz

설치를 진행하려면, 자체적으로 수정할 수 있는 버전이 필요합니다

다운로드가 완료되면 압축 해제, 컴파일 및 설치 작업을 수행할 수 있습니다

2.스트레스를 풀어요

tar -zxvf Python-2.7.9.tgz

3. 컴파일:

cd python-2.7.9
 
 ./configure --prefix=/usr/local/python2.7 --with-threads --enable-shared

4.설치합니다

make && make altinstall

5.python을 잘못 입력하면 다음 명령을 입력할 수 있습니다

update-alternatives --install /usr/bin/python python /usr/bin/python2 100
 
update-alternatives --install /usr/bin/python python /usr/bin/python3 150

그런 다음 다음을 입력합니다.

python --version

6.버전을 바꾸려면:

update-alternatives --config python

그리고 당신이 필요로 하는 파이썬 버전을 선택하고 일련번호를 입력하면 됩니다.(파이썬 버전으로 다시 전환하려면):

Python에서 super () 의 상세 설명과 장면 적용 예시를 보여줍니다

Jammie — Fri, 2 Dec 2022 14:14:14 +0900

기사 목록입니다.
첫째, 서언입니다.
2. 슈퍼가 뭐예요
3. super의 자주 사용하는 장면입니다.
첫째, 서언입니다.
최근 super 관련 문의가 왔는데 인터넷에 검색된 튜토리얼이 이해하기 쉽지 않아 보고도 잘 이해가 안 된다고 하네요.그래서 여기에서는 저만의 이해를 바탕으로 슈퍼에 대해 알아보겠습니다.

2. 슈퍼가 뭐예요
1.슈퍼도 한 종류죠, 그렇죠.그는 방법도 아니고 내장된 키워드도 아닙니다

class A:
    pass

print(type(super(A)))

결과를 출력합니다

<class 'super'>

super의 소스코드를 직접 봐도 알 수 있습니다

또한, super는 부류의 방법을 호출하는 데 사용된다는 인터넷 기사도 잘못된 관점입니다!

가령 다음과 같은 예가 있습니다

class A:
    def __init__(self):
        print("A")


class B(A):
    def __init__(self):
        print("B")
        super().__init__()


class C(A):
    def __init__(self):
        print("C")
        super().__init__()


class D(B, C):
    def __init__(self):
        print("D")
        super().__init__()
D()

"super는 부류를 호출하는 방법"이라는 이해에 비추어 볼 때, 상기 코드의 실행 과정은 다음과 같아야 합니다.

print("D") - [super는 B와 C를 차례로 실행함] - B:print("B") - [super는 A를 실행합니다] - print("A") - [super는 B와 C를 차례로 실행함] - [super는 A를 차례로 실행함] - print("C") - [super는 A를 차례로 실행함] - print("A")를 실행합니다.

실행 결과 이론은 다음과 같아야 합니다: DBACA

하지만 실제 상황은 그렇지 않습니다!

실제 실행 결과입니다

D
B
C
A

그래서 '슈퍼란 부류를 호출하는 방법'이라는 말은 틀렸습니다!

실제로 super 호출은 Python의 [MRO(방법 해석 순서)]에 따라 수행되며, Python3에서 MRO는 C3 알고리즘을 기반으로 구현됩니다

3. super의 자주 사용하는 장면입니다.
1. 만약 우리가 상속받은 여러 부모에 같은 이름의 메서드가 있다면, super를 사용하여 사용할 부모에 대한 메서드를 지정할 수 있습니다.

class A:
def test(self):
print('A')

class B:
def test(self):
print('B')

class C(A, B):
def __init__(self):
super( ).test( ) # 클래스 A에서 test 메서드를 호출합니다
super(C, self).test( ) # 클래스 A에서 test 메서드를 호출합니다
super( A, self).test( ) # 클래스 B의 test 메서드를 불러옵니다

C()

결과를 출력합니다

A
A
B

2. 하위 클래스에서 상위 클래스의 메서드를 사용하고 특정 확장을 원하지만 완전히 다시 쓰기를 원하지 않는 경우 super()를 사용하여 메서드를 증분 수정할 수 있습니다.

일례로 우리가 list에 있는 append의 방법을 중국어로 바꾸려면 어떻게 해야 하나요?

그리고 python에서 list가 append 메서드를 호출하면 반환값이 없습니다. 요소 추가 작업이 성공한 후 반환 값을 추가하여 성공적으로 반환하려면 어떻게 해야 합니까?

먼저 원래 list를 호출해서 실행한 결과를 보겠습니다

a=list()
res=a.append(1)
print(res)

결과를 출력합니다

None

append 메서드를 호출하고 None을 반환하는 것을 볼 수 있습니다

이제 우리는 super를 통해 다시 쓰고, 반환 값을 가지며, append를 중국어로 직접 호출할 수 있습니다.

class 목록( list):
def 추가 (self, *args, **kwargs):
super().append(*args, **kwargs)
return "추가되었습니다"

x = 목록입니다( )
res = x.(1) 을( 를) 추가합니다.
print(res)
print(x)

결과를 출력합니다

성공적으로 추가되었습니다.
[1]

super는 실제로 많이 사용되는데, 예를 들어 restfremework에서 응답 결과의 Response 정보를 다시 써야 할 경우 django의 미들웨어를 통해 구현하는 것 외에도 super를 사용하여 dispatch를 다시 쓰는 것도 가능합니다

세 줄의 코드를 사용하여 Python을 사용하여 동영상을 Gif로 변환합니다

Jammie — Fri, 2 Dec 2022 12:15:48 +0900

기사 목록입니다.
첫째, 서언입니다.
2. 튜토리얼입니다.
1. 필수 라이브러리 moviepy 설치
2. 코드를 기록합니다.
3. 전환효과입니다
4. GIF가 큰 솔루션입니다
4. 영상 길이 변환을 캡처합니다
5. 변환된 이미지의 크기(해상도)를 지정합니다.
첫째, 서언입니다.
많은 사이트에서 동영상을 GIF로 돌리는 기능을 제공하지만, 유료이거나 광고가 있습니다.

실제로 파이썬(python)을 통해 몇 줄의 코드만으로 동영상을 gif로 바꿀 수 있습니다

2. 튜토리얼입니다.
1. 필수 라이브러리 moviepy 설치
pip install moviepy -i https://pypi.tuna.tsinghua.edu.cn/simple

2. 코드를 기록합니다

from moviepy.editor import *

clip = (VideoFileClip("movie.mp4") # GIF의 비디오 파일 경로로 변환해야 합니다.
clip.write_gif("movie.gif")

3. 전환효과입니다

방금 GIF 그림은 몇 초밖에 안 됐지만 크기가 9M이나 됩니다!(이미 해상도를 조정한 상태일 수도 있습니다

만약 변환해야 하는 동영상이 수십 초라면, 파일 크기는 수백 메가 이상이 되어야 합니다!

그럼 어떻게 해결하면 될까요?

4. GIF가 큰 솔루션입니다
스케일 해상도 resize 뿐만 아니라 fps 매개 변수 프레임을 설정하여 크기를 줄일 수 있습니다

from moviepy.editor import *

clip = (VideoFileClip("movie.mp4").resize((488,225)))
clip.write_gif("movie.gif", fps=15) #초당 15프레임으로 설정합니다

초당 15프레임으로 설정하니 파일 크기가 2m 남짓이었는데 4배나 줄었습니다!

그리고 비주얼도 크게 다르지 않아요

4. 영상 길이 변환을 캡처합니다
subclip 매개 변수를 설정하여 변환된 비디오의 범위를 지정할 수도 있습니다.

subclip: 원본 비디오의 t_start에서 t_end까지의 비디오 클립을 캡처합니다.

1-2초짜리 비디오를 Gif로 변환합니다

from moviepy.editor import *

clip = (VideoFileClip("movie.mp4").subclip(t_start=1, t_end=2).resize((488, 225)))
clip.write_gif("movie.gif", fps=15)

5. 변환된 이미지의 크기(해상도)를 지정합니다.
resize 매개 변수는 변환된 그림의 크기를 지정할 수 있습니다

허용되는 매개 변수는 다음과 같습니다.

픽셀 또는 부동 소수점 (width, height) 입니다
0.5와 같은 백분율 크기를 조정합니다.
예시입니다.

1. 변환된 이미지를 600*400으로 설정합니다

clip = (VideoFileClip("movie.mp4").resize((600, 400)))

2. 원본 영상을 50% 확대합니다

clip = (VideoFileClip("movie.mp4").resize(0.5))