유용한 팁과 요령으로 친구들에게 깊은 인상을 남기세요

유용한 Python 도움말과 유용한 정보가 온라인에 있습니다. 다음은 Python 게임을 강화하는 데 사용할 수있는 재미 있고 멋진 트릭입니다.과동시에 친구들에게 깊은 인상을 남기십시오. 한 돌로 두 마리의 새를 죽이십시오.

더 이상 고민하지 않고 바로 시작하겠습니다.

1. YouTube-DL로 YouTube 동영상 다운로드

YouTube 동영상 (다른 많은 웹 사이트의 동영상) 사용유튜브 -dl Python의 모듈.

먼저 pip를 사용하여 모듈을 설치하겠습니다.

pip install youtube-dl

설치가 완료되면 다음 한 줄 명령을 사용하여 터미널 또는 명령 프롬프트에서 직접 비디오를 다운로드 할 수 있습니다.

youtube-dl <Your video link here>

또는 이후유튜브 -dlPython에 대한 바인딩이 있으면 프로그래밍 방식으로 동일한 작업을 수행하는 Python 스크립트를 만들 수 있습니다.

모든 링크가 포함 된 목록을 만들고 아래의 빠르고 더러운 스크립트를 사용하여 비디오를 다운로드 할 수 있습니다.

이 모듈을 사용하면 비디오뿐만 아니라 전체 재생 목록, 메타 데이터, 섬네일, 자막, 주석, 설명, 오디오 등을 쉽게 다운로드 할 수 있습니다.

이를 달성하는 가장 쉬운 방법은 이러한 매개 변수를 사전에 추가하고이를 사전에 전달하는 것입니다.YoutubeDL객체 생성자.

아래 코드에서 사전을 만들었습니다.ydl_options, 일부 매개 변수와 함께 생성자에 전달했습니다.

1. 'format':'bestvideo+bestaudio' #Dowloads the video in the best available video and audio format.2. 'writethumbnail':'writethumbnail' #Downloads the thumbnail image of the video.3. 'writesubtitles':'writesubtitles' #Downloads the subtitles, if any.4. 'writedescription':'writedescription' #Writes the video description to a .description file.

노트 :터미널이나 명령 프롬프트에서 직접 모든 작업을 수행 할 수 있지만 Python 스크립트를 사용하는 것이 유연성 / 재사용 가능성으로 인해 더 좋습니다.

여기에서 모듈에 대한 자세한 내용을 찾을 수 있습니다.Github : youtube-dl.

2. Pdb로 코드 디버그

Python에는 pdb라는 자체 내장 디버거가 있습니다. 디버거는 프로그래머가 변수와 프로그램 실행을 한 줄씩 검사하는 데 도움이되는 매우 유용한 도구입니다. 디버거는 프로그래머가 코드에서 성가신 문제를 찾으려고 노력할 필요가 없음을 의미합니다.

pdb의 좋은 점은 표준 Python 라이브러리에 포함되어 있다는 것입니다. 결과적으로이 아름다움은 Python이 설치된 모든 컴퓨터에서 사용할 수 있습니다. 이것은 바닐라 Python 설치 위에 추가 기능을 설치하는 데 제한이있는 환경에서 유용합니다.

pdb 디버거를 호출하는 방법에는 여러 가지가 있습니다.

In-line breakpoint
pdb.set_trace()In Python 3.7 and later
breakpoint()pdb.py can also be invoked as a script to debug other scripts
python3 -m pdb myscript.py

다음은 다음을 사용하여 pdb를 호출하는 Python 3.8의 샘플 코드입니다.중단 점 ()함수:

다음은 디버깅 모험에 도움이되는 몇 가지 유용한 명령입니다.

• 엔: 현재 함수의 다음 줄에 도달하거나 반환 될 때까지 실행을 계속합니다.
• 엘: 목록 코드
• j <line>: 줄로 이동
• b <line>: breakpoint () 설정
• 씨: 중단 점까지 계속
• 큐: 종료

노트 :일단 pdb에 있으면엔,엘,비,씨, 및큐예약 된 키워드가됩니다. 마지막 변수는 이름이 변수 인 경우 pdb를 종료합니다.큐귀하의 코드에서.

여기에서 자세한 내용을 확인할 수 있습니다.pdb — 파이썬 디버거

3. PyInstaller를 사용하여 Python 코드를 실행 파일로 만들기

많은 사람들이 이것을 아는 것은 아니지만 Python을 변환 할 수 있습니다. 스크립트를 독립 실행 형 실행 파일로 변환합니다. 이것에 대한 가장 큰 이점은 Python 스크립트 / 애플리케이션이 Python (및 필요한 타사 패키지)이 설치되지 않은 컴퓨터에서 작동 할 수 있다는 것입니다.

PyInstaller는 Windows, GNU / Linux, Mac OS X, FreeBSD, Solaris 및 AIX를 포함한 거의 모든 주요 플랫폼에서 작동합니다.

설치하려면 pip에서 다음 명령을 사용하십시오.

pip install pyinstaller

그런 다음 프로그램이있는 디렉토리로 이동하여 다음을 실행하십시오.

pyinstaller myscript.py

그러면 실행 파일이 생성되어 다음과 같은 하위 디렉토리에 저장됩니다.dist.

PyInstaller는 사용자 정의를위한 다양한 옵션을 제공합니다.

pyinstaller --onefile --icon [icon file] [script file]# Using the --onefile option bundles everything in a single executable file instead of having a bunch of other files. 
# Using the --icon option adds a custom icon (.ico file) for the executable file

Pyinstaller는 Django, NumPy, Matplotlib, SQLAlchemy, Pandas, Selenium 등 대부분의 타사 패키지와 호환됩니다.

Pyinstaller가 제공하는 모든 기능과 다양한 옵션에 대해 알아 보려면 Github의 해당 페이지를 방문하십시오.Pyinstaller.

4. Tqdm으로 진행률 표시 줄 만들기

TQDM 라이브러리를 사용하면 Python 및 CLI에 대한 빠르고 확장 가능한 진행률 표시 줄을 만들 수 있습니다.

먼저 pip를 사용하여 모듈을 설치해야합니다.

pip install tqdm

몇 줄의 코드로 Python 스크립트에 스마트 진행률 표시 줄을 추가 할 수 있습니다.

TQDM은 Linux, Windows, Mac, FreeBSD, NetBSD, Solaris / SunOS와 같은 모든 주요 플랫폼에서 작동합니다. 뿐만 아니라 모든 콘솔, GUI 및 IPython / Jupyter 노트북과 원활하게 통합됩니다.

tqdm의 모든 트릭에 대한 자세한 내용을 보려면 여기 공식 페이지를 방문하십시오.tqdm.

5. Colorama를 사용하여 콘솔 출력에 색상 추가

Colorama는 콘솔 출력에 색상을 추가하는 멋진 크로스 플랫폼 모듈입니다. pip를 사용하여 설치해 보겠습니다.

pip install colorama

Colorama는 다음과 같은 서식 상수를 제공합니다.

Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
Style: DIM, NORMAL, BRIGHT, RESET_ALL

다음은 Colorama를 사용하는 샘플 코드입니다.

위의 코드는 다음 출력을 생성합니다.

스타일 .RESET_ALL전경, 배경 및 밝기를 명시 적으로 재설정합니다. 그러나 Colorama는 프로그램 종료시이 재설정을 자동으로 수행합니다.

Colorama에는 여기에서 찾을 수있는 다른 기능이 있습니다.Colorama 웹 사이트.

6. Tabulate를 사용하여 예쁜 2D 목록 인쇄

종종 Python에서 표 형식의 출력을 처리하는 것은 고통입니다. 그 때의표로 만들다구조하러 온다. "출력이 나에게 상형 문자처럼 보입니까?"에서 출력을 변환 할 수 있습니다. "와, 예쁘 네요!" 음, 마지막 부분은 약간 과장된 것일 수도 있지만 출력의 가독성을 향상시킵니다.

먼저 pip를 사용하여 설치합니다.

pip install tabulate

다음은 tabulate를 사용하여 2D 목록을 표로 인쇄하는 간단한 스 니펫입니다.

아래 GIF는 위 코드의 출력이 표로 표시되거나 표시되지 않는 모습을 보여줍니다. 두 출력 중 어느 것이 더 읽기 쉬운 지 추측하는 것에 대한 보상은 없습니다!

Tabulate는 다음 데이터 유형을 지원합니다.

1. list of lists or another iterable of iterables
2. list or another iterable of dicts (keys as columns)
3. dict of iterables (keys as columns)
4. two-dimensional NumPy array
5. NumPy record arrays (names as columns)
6. pandas.DataFrameSource: https://pypi.org/project/tabulate/

다음은 사전에서 작동하는 예입니다.

이것은 사전을 예쁘게 인쇄합니다.

+-------+-----+
| item  | qty |
+-------+-----+
| spam  | 42  |
| eggs  | 451 |
| bacon |  0  |
+-------+-----+

여기에서 라이브러리에 대한 자세한 내용을 찾을 수 있습니다.표로 만들다.

7. Ptpython을 사용하여 표준 Python 셸 꾸미기

내 Python 셸이 내 Python 셸보다 섹시한 이유가 궁금한 경우 사용자 지정 Python 셸을 사용하고 있기 때문입니다. 이 껍질,ptpython, 표준 Python 셸에 비해 많은 개선 사항이 있습니다. 기본적으로 표준 Python 셸과 ptpython이 쌍둥이 인 경우 후자는 두 형제 중 더 예쁘고 더 성공적 일 것입니다.

pip를 통해 ptpython을 설치할 수 있습니다.

pip install ptpython

설치되면 다음을 입력하여 호출 할 수 있습니다.ptpython표준 셸에서.

표준 셸에 비해 몇 가지 기능이 있습니다.

1. Code indentation
2. Syntax highlighting
3. Autocompletion
4. Multiline editing
5. Support for color schemes
... and many other things

아래 GIF에서 작동중인 기능 1 ~ 3을 볼 수 있습니다.

기능에 대해 자세히 알아 보려면 다음 웹 사이트를 방문하십시오.ptpython.

기사를 즐겁게 읽고 그 과정에서 새로운 것을 배웠기를 바랍니다.

멋진 파이썬 트릭이 있습니까? 의견에 귀하의 의견을 들려주세요.

Impress your friends with these useful tips and tricks

There’s a treasure trove of useful Python tips and tricks online. Here are some fun, cool tricks you can use to beef up your Python game and impress your friends at the same time — kill two birds with one stone.

Without further ado, let’s jump right into it.

1. Download YouTube Videos With YouTube-Dl

You can easily download YouTube videos (and videos from many other websites) using the youtube-dl module in Python.

First, let’s install the module using pip:

pip install youtube-dl

Once installed, you can download videos directly from terminal or command prompt by using the following one-line command:

youtube-dl <Your video link here>

Alternatively, since youtube-dl has bindings for Python, you can create a Python script to do the same thing programmatically.

You can create a list with all the links and download the videos using the quick-and-dirty script below.

With this module, you can not only easily download videos, but entire playlists, metadata, thumbnails, subtitles, annotations, descriptions, audio, and much more.

The easiest way to achieve this is by adding a bunch of these parameters to a dictionary and passing it to the YoutubeDL object constructor.

In the code below I created a dictionary, ydl_options, with some parameters, and passed it on to the constructor:

1. 'format':'bestvideo+bestaudio' #Dowloads the video in the best available video and audio format.2. 'writethumbnail':'writethumbnail' #Downloads the thumbnail image of the video.3. 'writesubtitles':'writesubtitles' #Downloads the subtitles, if any.4. 'writedescription':'writedescription' #Writes the video description to a .description file.

Note: You can do everything directly within the terminal or a command prompt, but using a Python script is better due to the flexibility/reusability it offers.

You can find more details about the module here: Github:youtube-dl.

2. Debug Your Code With Pdb

Python has its own in-built debugger called pdb. A debugger is an extremely useful tool that helps programmers to inspect variables and program execution, line by line. A debugger means programmers don’t have to pull their hair out trying to find pesky issues in their code.

The good thing about pdb is that it is included with the standard Python library. As a result, this beauty can be used on any machine where Python is installed. This comes in handy in environments with restrictions on installing any add-on on top of the vanilla Python installation.

There are several ways to invoke the pdb debugger:

In-line breakpoint
pdb.set_trace()In Python 3.7 and later
breakpoint()pdb.py can also be invoked as a script to debug other scripts
python3 -m pdb myscript.py

Here’s a sample code on Python 3.8 that invokes pdb using the breakpoint() function:

Here are some of the most useful commands to aid you in your debugging adventure:

• n: To continue execution until the next line in the current function is reached or it returns.
• l: list code
• j <line>: jump to a line
• b <line>: set breakpoint()
• c: continue until breakpoint
• q: quit

Note: Once you are in pdb, n, l, b, c, and q become reserved keywords. The last one will quit pdb if you have a variable named q in your code.

You can find more details about this here: pdb — The Python Debugger

3. Make Your Python Code Into an Executable File Using PyInstaller

Not a lot of people know this, but you can convert your Python scripts into standalone executables. The biggest benefit to this is that your Python scripts/applications can then work on machines where Python (and any necessary third-party packages) are not installed.

PyInstaller works on pretty much all the major platforms, including Windows, GNU/Linux, Mac OS X, FreeBSD, Solaris and AIX.

To install it, use the following command in pip:

pip install pyinstaller

Then, go to the directory where your program is located and run:

pyinstaller myscript.py

This will generate the executable and place it in a subdirectory called dist.

PyInstaller provides many options for customization:

pyinstaller --onefile --icon [icon file] [script file]# Using the --onefile option bundles everything in a single executable file instead of having a bunch of other files. 
# Using the --icon option adds a custom icon (.ico file) for the executable file

Pyinstaller is compatible with most of the third-party packages — Django, NumPy, Matplotlib, SQLAlchemy, Pandas, Selenium, and many more.

To learn about all the features and the myriad of options Pyinstaller provides, visit its page on Github: Pyinstaller.

4. Make a Progress Bar With Tqdm

The TQDM library will let you create fast, extensible progress bars for Python and CLI.

You’d need to first install the module using pip:

pip install tqdm

With a few lines of code, you can add smart progress bars to your Python scripts.

TQDM works on all major platforms like Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS. Not only that, but it also integrates seamlessly with any console, GUI, and IPython/Jupyter notebooks.

To get more details on all the tricks tqdm has up its sleeve, visit its official page here: tqdm.

5. Add Color to Your Console Output With Colorama

Colorama is a nifty little cross-platform module that adds color to the console output. Let’s install it using pip:

pip install colorama

Colorama provides the following formatting constants:

Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
Style: DIM, NORMAL, BRIGHT, RESET_ALL

Here’s a sample code to use Colorama:

The code above yields the following output:

Style.RESET_ALL explicitly resets the foreground, background, and brightness — although, Colorama also performs this reset automatically on program exit.

Colorama has other features that you can find here: Colorama Website.

6. Pretty Print 2D Lists Using Tabulate

Often, dealing with tabular output in Python is a pain. That’s when tabulate comes to the rescue. It can transform your output from “The output looks like hieroglyphs to me?” to “Wow, that looks pretty!”. Well, maybe that last part is a slight exaggeration, but it will improve the readability of your output.

First, install it using pip:

pip install tabulate

Here’s a simple snippet to print a 2D list as a table using tabulate:

The GIF below shows how the output of the code above looks with and without tabulate. No prizes for guessing which of the two outputs is more readable!

Tabulate supports the following data types:

1. list of lists or another iterable of iterables
2. list or another iterable of dicts (keys as columns)
3. dict of iterables (keys as columns)
4. two-dimensional NumPy array
5. NumPy record arrays (names as columns)
6. pandas.DataFrameSource: https://pypi.org/project/tabulate/

Here’s an example that works on a dictionary:

This pretty-prints the dictionary:

+-------+-----+
| item  | qty |
+-------+-----+
| spam  | 42  |
| eggs  | 451 |
| bacon |  0  |
+-------+-----+

You can find more details about the library here: tabulate.

7. Spruce Up Your Standard Python Shell With Ptpython

In case you’re wondering why my Python shell is sexier than yours, it’s because I’ve been using a custom Python shell. This shell, ptpython, has a lot of enhancements over the standard Python shell. Basically, if the standard Python shell and ptpython were twins, the latter would be the prettier (and more successful) of the two siblings.

You can install ptpython through pip:

pip install ptpython

Once installed, you can invoke it by typing ptpython in your standard shell.

It has several features over the standard shell:

1. Code indentation
2. Syntax highlighting
3. Autocompletion
4. Multiline editing
5. Support for color schemes
... and many other things

In the GIF below, you can see features 1–3 in action:

To learn more about its features, visit its website here: ptpython.

I hope you enjoyed the article and learned something new in the process.

Do you have any cool Python tricks? Chime in with yours in the comments.

Python의 함수 선언, 특히 공용 API에 대한 모범 사례

프로그래밍 언어가 사용하는 구현 메커니즘에 관계없이 모두 기능을위한 예약 된 자리를 가지고 있습니다. 함수는 데이터 준비 및 처리와 사용자 인터페이스 요소 구성을 담당하므로 모든 코드 프로젝트의 필수 부분입니다. 예외없이 Python은 객체 지향 프로그래밍 언어로 자리를 잡았지만 데이터 관련 작업을 수행하는 함수에 의존합니다. 따라서 좋은 함수를 작성하는 것은 탄력적 인 코드 기반을 구축하는 데 중요합니다.

작은 프로젝트에서 몇 가지 간단한 기능을 정의하는 것은 간단합니다. 프로젝트 범위가 확대됨에 따라 기능이 훨씬 더 복잡해질 수 있으며 더 많은 기능에 대한 필요성이 기하 급수적으로 증가합니다. 모든 기능을 혼동없이 함께 작동시키는 것은 숙련 된 프로그래머에게도 골칫거리가 될 수 있습니다. 프로젝트 범위가 커짐에 따라 함수 선언에 모범 사례를 적용하는 것이 더욱 중요해집니다. 이 기사에서는 함수 선언에 대한 모범 사례, 즉 수년간 코딩을 통해 쌓아온 지식에 대해 이야기하고 싶습니다.

1. 일반 지침

이러한 일반 지침에 익숙 할 수 있지만 많은 프로그래머가 인정하지 않는 높은 수준의 우수 사례이므로 먼저 논의하고 싶습니다. 개발자가 이러한 지침을 따르지 않으면 대가를 지불해야합니다. 코드를 유지 관리하기가 매우 어렵습니다.

노골적이고 의미있는 이름

기능에 의미있는 이름을 부여해야합니다. 아시다시피 함수는 파이썬의 객체이기도하므로 함수를 정의 할 때 기본적으로 함수 유형의 변수를 만듭니다. 따라서 변수 이름 (즉, 함수 이름)은 수행하는 작업을 반영해야합니다.

현대 코딩에서는 가독성이 더욱 강조되었지만 대부분 주석과 관련하여 논의되고 있으며 코드 자체와 관련하여 논의되는 빈도는 훨씬 적습니다. 따라서 함수를 설명하기 위해 광범위한 주석을 작성해야하는 경우 함수에 좋은 이름이 없을 가능성이 큽니다. 긴 함수 이름에 대해 걱정하지 마십시오. 거의 모든 최신 IDE에는 뛰어난 자동 완성 힌트가 있으므로 전체 긴 이름을 입력하지 않아도됩니다.

좋은 명명 규칙은 함수의 인수와 함수 내의 모든 지역 변수에도 적용되어야합니다. 주목해야 할 또 다른 점은 함수가 클래스 또는 모듈 내에서 사용되도록 의도 된 경우 이름 앞에 밑줄을 붙여야 할 수 있다는 것입니다 (예 :def _internal_fun () :)는 이러한 함수가 비공개 용도이며 공개 API가 아님을 나타냅니다.

작고 단일 목적

기능은 작게 유지해야 관리하기 쉽습니다. 집을 짓고 있다고 상상해보십시오 (저택이 아님). 그러나 사용중인 벽돌은 1 미터 큐브입니다. 사용하기 쉽습니까? 아마 아닐 것입니다. 너무 큽니다. 기능에도 동일한 원칙이 적용됩니다. 기능은 프로젝트의 벽돌입니다. 기능의 크기가 모두 방대하다면 건설이 원활하게 진행되지 않습니다. 크기가 작 으면 다양한 장소에 더 쉽게 맞출 수 있으며 필요에 따라 이동합니다.

또한 기능이 단일 목적을 수행하는 것이 중요하므로 기능을 작게 유지하는 데 도움이됩니다. 단일 목적 함수의 또 다른 이점은 이러한 함수의 이름을 훨씬 쉽게 지정할 수 있다는 것입니다. 의도 된 단일 목적에 따라 함수의 이름을 간단하게 지정할 수 있습니다. 다음은 함수를 리팩토링하여 각 함수가 각각 하나의 목적에만 사용되도록하는 방법입니다. 주목해야 할 또 다른 사항은 모든 함수 이름이 이야기를 전달하기 때문에 작성해야하는 주석을 최소화 할 수 있다는 것입니다.

바퀴를 재발 명하지 마십시오

필요한 모든 작업에 대해 함수를 작성하는 데 무제한의 에너지와 시간이 필요하지 않으므로 표준 라이브러리의 공통 함수에 익숙해지는 것이 중요합니다. 자신의 기능을 정의하기 전에 특정 비즈니스 요구가 일반적인 것인지 생각해보십시오. 그렇다면 이러한 특정 및 관련 요구가 이미 해결되었을 가능성이 높습니다.

예를 들어 CSV 형식의 데이터로 작업하는 경우 다음에서 기능을 살펴볼 수 있습니다.CSV 모듈. 또는팬더 라이브러리CSV 파일을 정상적으로 처리 할 수 ​​있습니다. 또 다른 예로, 목록의 요소를 계산하려면 다음을 고려해야합니다.카운터이러한 작업을 위해 특별히 설계된 collections 모듈의 클래스입니다.

2. 기본 인수

관련 시나리오

함수를 처음 정의 할 때 일반적으로 특정 목적에 사용됩니다. 그러나 프로젝트에 더 많은 기능을 추가하면 밀접하게 관련된 일부 기능이 병합 될 수 있음을 알 수 있습니다. 유일한 차이점은 병합 된 함수의 호출에는 때때로 다른 인수를 전달하거나 약간 다른 인수를 설정해야한다는 것입니다. 이 경우 인수에 기본값을 설정하는 것을 고려할 수 있습니다.

또 다른 일반적인 시나리오는 함수를 선언 할 때 함수가 차등 매개 변수를 사용하는 함수 호출과 함께 여러 목적을 제공 할 것으로 예상하는 반면 일부 다른 매개 변수는 약간의 변형이 필요하다는 것입니다. 기본값을 덜 가변적 인 인수로 설정하는 것을 고려해야합니다.

기본 인수 설정

기본 인수 설정의 이점은 간단합니다. 대부분의 경우 불필요한 인수 설정을 처리 할 필요가 없습니다. 그러나 이러한 매개 변수를 함수 시그니처에 유지할 수 있으므로 필요할 때 함수를 더 유연하게 사용할 수 있습니다. 예를 들어, 내장정렬 됨 ()함수를 호출하는 방법에는 여러 가지가 있지만 대부분의 경우 기본 형식 만 사용합니다.정렬 됨 (the_iterable), 오름차순 사전 순으로 iterable을 정렬합니다. 그러나 오름차순이나 기본 사전 순서를 변경하려는 경우 다음을 지정하여 기본 설정을 재정의 할 수 있습니다.역전과키인수.

우리 자신의 함수 선언에 동일한 방법을 적용해야합니다. 어떤 값을 설정해야하는지에 관해서는 대부분의 함수 호출에 사용할 기본값을 선택해야합니다. 이것은 선택적 인수이기 때문에 귀하 (또는 귀하의 API 사용자)는 대부분의 상황에서이를 설정하고 싶지 않습니다. 다음 예를 고려하십시오.

변경 가능한 기본 인수의 함정을 피하십시오

기본 인수를 설정하는 방법이 있습니다. 인수가 변경 가능한 객체 인 경우 기본 생성자를 사용하여 설정하지 않는 것이 중요합니다. 함수는 Python의 객체이며 정의 될 때 생성되기 때문입니다. 부작용은 함수 선언시 기본 인수가 평가되므로 기본 가변 객체가 생성되고 함수의 일부가된다는 것입니다. 기본 개체를 사용하여 함수를 호출 할 때마다 기본적으로 함수와 연결된 동일한 변경 가능한 개체에 액세스하게됩니다.하지만 의도적으로 새로운 개체를 만드는 함수가있을 수 있습니다. 다음 코드 스 니펫은 기본 변경 가능 인수 설정의 원치 않는 부작용을 보여줍니다.

위에서 볼 수 있듯이 두 개의 개별 쇼핑 목록을 만들려고했지만 두 번째 함수 호출은 여전히 ​​동일한 기본 개체에 액세스하여축구동일한 목록 개체에 추가 된 항목. 문제를 해결하려면 다음 구현을 사용해야합니다. 구체적으로는없음변경 가능한 인수의 기본값으로 :

3. 여러 값 반환 고려

튜플의 여러 값

함수가 복잡한 작업을 수행 할 때 이러한 작업이 두 개 이상의 개체를 생성 할 수 있으며,이 모든 개체는 후속 데이터 처리에 필요합니다. 이론적으로는 함수가 클래스 인스턴스를 출력으로 반환 할 수 있도록 이러한 객체를 래핑하는 클래스를 만들 수 있습니다. 그러나 Python에서는 함수가 여러 값을 반환 할 수 있습니다. 보다 정확하게 말하면 이러한 여러 값은 튜플 객체로 반환됩니다. 다음 코드는 간단한 예를 보여줍니다.

위에 표시된 것처럼 반환 된 값은 쉼표로 구분됩니다. 기본적으로 튜플 객체를 생성합니다.유형()함수.

그러나 3 개 이하

한 가지 주목할 점은 Python 함수가 여러 값을 반환 할 수 있지만이 기능을 남용해서는 안된다는 것입니다. 하나의 값 (함수가 명시 적으로 아무것도 반환하지 않으면 실제로없음모든 것이 간단하고 대부분의 사용자는 일반적으로 함수가 하나의 값만 반환하기를 기대하기 때문입니다. 경우에 따라 두 개의 값을 반환하는 것이 좋으며 세 개의 값을 반환하는 것도 괜찮지 만 네 개의 값을 반환하지 마십시오. 어떤 사용자에게 많은 혼란을 줄 수 있습니다. 이런 일이 발생하면 함수를 리팩토링해야 함을 나타내는 좋은 표시입니다. 함수는 여러 용도로 사용되며 더 많은 전용 책임이있는 작은 함수를 만들어야합니다.

4. Try… Except 사용

함수를 공개 API로 정의 할 때 사용자가 원하는 매개 변수를 함수에 설정했다고 항상 가정 할 수는 없습니다. 우리가 직접 함수를 사용하더라도 일부 매개 변수가 우리의 통제를 벗어나 생성되어 우리의 함수와 호환되지 않을 수 있습니다. 이 경우 함수 선언에서 무엇을해야합니까?

첫 번째 고려 사항은시도…일반적인 예외 처리 기술입니다. 잘못 될 수있는 코드 (예 : 특정 예외 발생)를시험절과 가능한 예외는외절.

다음 시나리오를 살펴 보겠습니다. 특정 비즈니스 요구 사항은 함수가 파일 경로를 사용하고 파일이 존재하고 성공적으로 읽힌 경우 함수가 파일에 대해 일부 데이터 처리 작업을 수행하고 결과를 반환하고 그렇지 않으면 반환하는 것입니다.-1. 이러한 요구를 구현하는 방법에는 여러 가지가 있습니다. 아래 코드는 가능한 솔루션을 보여줍니다.

즉, 함수 사용자가 코드에서 예외를 발생시키는 일부 인수를 설정할 수 있다고 예상하는 경우 이러한 가능한 예외를 처리하는 함수를 정의 할 수 있습니다. 그러나 예에 표시된 기능의 일부가 아닌 한 사용자에게 명확하게 전달해야합니다 (return-1파일을 읽을 수없는 경우).

5. 인수 유효성 검사 고려

사용하는 이전 기능시도…선언문은 EAFP (허가보다 용서를 쉽게 구하기) 코딩 스타일이라고도합니다. LBYL (Look Before You Leap)이라는 또 다른 코딩 스타일이 있는데, 특정 코드 블록을 실행하기 전에 온 전성 검사를 강조합니다.

앞의 예에 따라 LBYL을 함수 선언에 적용 할 때 다른 고려 사항은 함수의 인수를 확인하는 것입니다. 인수 유효성 검사의 일반적인 사용 사례 중 하나는 인수가 올바른 데이터 유형인지 확인하는 것입니다. 우리 모두 알다시피 Python은 동적 유형 언어로 유형 검사를 시행하지 않습니다. 예를 들어 함수의 인수는 정수 또는 부동 소수점 숫자 여야합니다. 그러나 문자열 (호출 자체)을 설정하여 함수를 호출하면 함수가 실행될 때까지 오류 메시지가 표시되지 않습니다.

다음 코드는 코드를 실행하기 전에 인수의 유효성을 검사하는 방법을 보여줍니다.

토론 : EAFP 대 LBYL

EAFP 및 LBYL은 함수 인수를 처리하는 것 이상으로 적용될 수 있습니다. 기능의 어느 곳에 나 적용 할 수 있습니다. EAFP는 Python 세계에서 선호되는 코딩 스타일이지만 사용 사례에 따라 EAFP 스타일로 얻는 일반적인 기본 제공 오류 메시지보다 더 사용자 친화적 인 함수 별 오류 메시지를 제공 할 수있는 LBYL 사용을 고려해야합니다. .

6. Lambda 함수를 대안으로 고려

다른 기능의 매개 변수로서의 기능

일부 함수는 특정 작업을 수행하기 위해 다른 함수 (또는 일반적인 용어로 호출 가능)를 사용할 수 있습니다. 예를 들어정렬 됨 ()기능에는키더 많은 사용자 지정 정렬 동작을 정의 할 수있는 인수입니다. 다음 코드 스 니펫은 사용 사례를 보여줍니다.

대안으로서의 Lambda 기능

특히sorting_grade함수는 한 번만 사용되었으며 간단한 함수입니다.이 경우 람다 함수 사용을 고려할 수 있습니다.

람다 함수에 익숙하지 않은 경우 다음은 간단한 설명입니다. 람다 함수는 lambda 키워드를 사용하여 선언 된 익명 함수입니다. 0 개 이상의 인수가 필요하며 다음 형식의 적용 가능한 작업에 대해 하나의 표현식이 있습니다.람다 인수 : 표현식. 다음 코드는 람다 함수를 사용하는 방법을 보여줍니다.정렬 됨 ()위의 솔루션보다 약간 깔끔해 보이는 함수 :

많은 데이터 과학자와 관련된 또 다른 일반적인 사용 사례는 Pandas 라이브러리로 작업 할 때 람다 함수를 사용하는 것입니다. 다음 코드는 간단한 예입니다.람다함수는 다음을 사용하여 데이터 조작을 지원합니다.지도()팬더의 각 항목을 작동하는 함수시리즈목적:

7. 데코레이터 고려

데코레이터

데코레이터는 핵심 기능에 영향을주지 않고 다른 기능의 동작을 수정하는 기능입니다. 즉, 장식적인 수준에서 장식 된 기능을 수정합니다. 데코레이터에 대해 잘 모르시 겠다면 이전 기사를 참조하십시오 (1,2, 및삼). 다음은 데코레이터가 Python에서 작동하는 방식에 대한 간단한 예입니다.

표시된대로 데코레이터 함수는 단순히 데코 레이팅 된 함수를 두 번 실행합니다. 데코레이터를 사용하려면 데코레이터 함수 이름을 데코 레이팅 된 함수 위에@접두사. 알 수 있듯이 데코 레이팅 된 함수는 두 번 호출되었습니다.

함수 선언에 데코레이터 사용

예를 들어 유용한 데코레이터 중 하나는 사용자 정의 클래스에서 사용할 수있는 속성 데코레이터입니다. 다음 코드는 작동 방식을 보여줍니다. 본질적으로@특성데코레이터는 인스턴스 메서드를 변환하여 점 표기법을 사용하는 액세스를 허용하는 일반 속성처럼 작동하도록합니다.

데코레이터의 또 다른 사소한 사용 사례는 시간 로깅 데코레이터로, 함수의 효율성이 중요한 경우 특히 유용 할 수 있습니다. 다음 코드는 이러한 사용법을 보여줍니다.

8. * args와 ** kwargs를 사용하라 — 그러나 간결하게

이전 섹션에서* args과** kwargs데코레이터 함수를 정의 할 때 데코레이터 함수를 사용하여 모든 함수를 데코레이션 할 수 있습니다. 본질적으로 우리는* args모든 (또는 더 일반적으로 결정되지 않은 수의) 위치 인수를 캡처하는 동안** kwargs모든 (또는 더 일반적으로 결정되지 않은 수의) 키워드 인수를 캡처합니다. 특히 위치 인수는 함수 호출에서 전달 된 인수의 위치를 ​​기반으로하는 반면, 키워드 인수는 매개 변수를 특별히 명명 된 함수 인수로 설정하는 것을 기반으로합니다.

이러한 용어에 익숙하지 않은 경우 여기에서 기본 제공의 서명을 간단히 살펴볼 수 있습니다.정렬 됨 ()함수:정렬 됨 (반복 가능,*,key = 없음,reverse = 거짓). 그만큼반복 가능인수는 위치 인수이고키과역전인수는 키워드 인수입니다.

사용의 주요 이점* args과** kwargs동일한 문제에 대해 함수 선언을 깨끗하게하거나 덜 시끄럽게 만드는 것입니다. 다음 예는 다음의 합법적 인 사용을 보여줍니다.* arg함수 선언에서 함수가 임의의 수의 위치 인수를 허용하도록합니다.

다음 코드는 합법적 인 사용을 보여줍니다.** kwargs함수 선언에서. 마찬가지로** kwargs사용자가 원하는 수의 키워드 인수를 설정하여 함수를보다 유연하게 만들 수 있습니다.

그러나 대부분의 경우 사용할 필요가 없습니다.* args또는** kwargs. 선언을 좀 더 깔끔하게 만들 수 있지만 함수의 서명을 숨 깁니다. 즉, 함수 사용자는 함수가 취하는 매개 변수를 정확히 파악해야합니다. 그러니 제 충고는 필요하지 않으면 사용하지 않는 것입니다. 예를 들어 사전 인수를 사용하여** kwargs? 마찬가지로 목록 또는 튜플 객체를 사용하여* args? 대부분의 경우 이러한 대안은 문제없이 작동합니다.

9. 인수에 대한 유형 주석

앞서 언급했듯이 Python은 동적 형식의 프로그래밍 언어이자 해석 언어이며, 이는 Python이 코딩 시간 동안 형식 호환성을 포함한 코드 유효성을 확인하지 않는다는 의미입니다. 코드가 실제로 실행될 때까지 함수와 호환되지 않는 유형을 입력합니다 (예 : 정수가 예상 될 때 함수에 문자열 전송).

이러한 이유로 Python은 입력 및 출력 인수 유형의 선언을 시행하지 않습니다. 즉, 함수를 만들 때 어떤 유형의 매개 변수가 있어야하는지 지정할 필요가 없습니다. 그러나 최근 Python 릴리스에서는 그렇게 할 수있게되었습니다. 유형 주석을 사용할 때의 주요 이점은 일부 IDE (예 : PyCharm 또는 Visual Studio Code)에서 주석을 사용하여 유형 호환성을 확인할 수 있으므로 사용자 또는 다른 사용자가 함수를 사용할 때 적절한 힌트를 얻을 수 있다는 것입니다.

또 다른 관련 이점은 IDE가 매개 변수 유형을 알고있는 경우 적절한 자동 완성 제안을 제공하여 더 빠르게 코딩 할 수 있다는 것입니다. 물론 함수에 대한 독 스트링을 작성할 때 이러한 유형 주석은 코드의 최종 개발자에게도 유익합니다.

10. 책임있는 문서

나는 좋은 문서를 책임감있는 문서와 동일시합니다. 함수가 사적인 용도로 사용되는 경우 매우 철저한 문서를 작성할 필요가 없습니다. 코드가 스토리를 명확하게 전달한다고 가정 할 수 있습니다. 어느 곳에서나 약간의 설명이 필요한 경우 코드를 재검토 할 때 자신이나 다른 독자에게 알림 역할을 할 수있는 매우 간단한 주석을 작성할 수 있습니다. 여기에서 책임있는 문서에 대한 논의는 공용 API로서의 함수의 독 스트링과 더 관련이 있습니다. 다음 측면이 포함되어야합니다.

• 함수의 의도 된 작업에 대한 간략한 요약입니다.이것은 매우 간결해야합니다. 대부분의 경우 요약은 한 문장 이상이어서는 안됩니다.
• 입력 인수 : 유형 및 설명.입력 인수의 유형과 특정 옵션을 설정하여 수행 할 수있는 작업을 지정해야합니다.
• 반환 값 : 유형 및 설명.입력 인수와 마찬가지로 함수의 출력을 지정해야합니다. 아무것도 반환하지 않는 경우 선택적으로없음반환 값으로.

결론

코딩 경험이 있다면 대부분의 시간이 함수 작성 및 리팩토링에 소비된다는 것을 알게 될 것입니다. 결국 데이터는 일반적으로 너무 많이 변경되지 않으며 데이터를 처리하고 조작하는 기능입니다. 데이터를 신체의 줄기라고 생각하면 기능은 사용자를 움직이는 팔과 다리입니다. 따라서 우리는 프로그램을 민첩하게 만들기 위해 좋은 함수를 작성해야합니다.

이 기사가 코딩에 사용할 수있는 유용한 정보를 전달했으면합니다.

읽어 주셔서 감사합니다.

Best practices for function declarations in Python — particularly public APIs

No matter what implementation mechanisms programming languages use, all of them have a reserved seat for functions. Functions are essential parts of any code project because they’re responsible for preparing and processing data and configuring user interface elements. Without exception, Python, while positioned as an object-oriented programming language, depends on functions to perform data-related operations. So, writing good functions is critical to building a resilient code base.

It’s straightforward to define a few simple functions in a small project. With the growth of the project scope, the functions can get far more complicated and the need for more functions grows exponentially. Getting all the functions to work together without any confusion can be a headache, even to experienced programmers. Applying best practices to function declarations becomes more important as the scope of your project grows. In this article, I’d like to talk about best practices for declaring functions — knowledge I have accrued over years of coding.

1. General Guidelines

You may be familiar with these general guidelines, but I’d like to discuss them first because they’re high-level, good practices that many programmers don’t appreciate. When developers don’t follow these guidelines, they pay the price — the code is very hard to maintain.

Explicit and meaningful names

We have to give meaningful names to our functions. As you know, functions are also objects in Python, so when we define a function, we basically create a variable of the function type. So, the variable name (i.e. the name of the function) has to reflect the operation it performs.

Although readability has become more emphasized in modern coding, it’s mostly talked about in regards to comments — it’s much less often discussed in relation to code itself. So, if you have to write extensive comments to explain your functions, it’s very likely that your functions don’t have good names. Don’t worry about having a long function name — almost all modern IDEs have excellent auto-completion hints, which will save you from typing the entire long names.

Good naming rules should also apply to the arguments of the function and all local variables within the function. Something else to note is that if your functions are intended to be used within your class or module, you may want to prefix the name with an underscore (e.g., def _internal_fun():) to indicate that these functions are for private usages and they’re not public APIs.

Small and Single Purpose

Your functions should be kept small, so they’re easier to manage. Imagine that you’re building a house (not a mansion). However, the bricks you’re using are one meter cubed. Are they easy to use? Probably not — they’re too large. The same principle applies to functions. The functions are the bricks of your project. If the functions are all enormous in size, your construction won’t progress as smoothly as it could. When they’re small, they’re easier to fit into various places and moved around if the need arises.

It’s also key for your functions to serve single purposes, which can help you keep your functions small. Another benefit of single-purpose functions is that you’ll find it much easier to name such functions. You can simply name your function based on its intended single purpose. The following is how we can refactor our functions to make each of them serve only one purpose each. Another thing to note is that by doing that, you can minimize the comments that you need to write — because all the function names tell the story.

Don’t reinvent the wheel

You don’t have unlimited energy and time to write functions for every operation you need, so it’s essential to be familiar with common functions in standard libraries. Before you define your own functions, think about whether the particular business need is common — if so, it’s likely that these particular and related needs have already been addressed.

For instance, if you work with data in the CSV format, you can look into the functionalities in the CSV module. Alternatively, the pandas library can handle CSV files gracefully. For another instance, if you want to count elements in a list, you should consider the Counter class in the collections module, which is designed specifically for these operations.

2. Default Arguments

Relevant scenarios

When we first define a function, it usually serves one particular purpose. However, when you add more features to your project, you may realize that some closely related functions can be merged. The only difference is that the invocation of the merged function sometimes involves passing another argument or setting slightly different arguments. In this case, you can consider setting a default value to the argument.

The other common scenario is that when you declare a function, you already expect that your function serves multiple purposes, with function calls using differential parameters while some other parameters requiring few variations. You should consider setting a default value to the less varied argument.

Set default arguments

The benefit of setting default arguments is straightforward — you don’t need to deal with setting unnecessary arguments in most cases. However, the availability of keeping these parameters in your function signature allows you to use your functions more flexibly when you need to. For instance, for the built-in sorted() function, there are several ways to call the function, but in most cases, we just use the basic form: sorted(the_iterable), which will sort the iterable in the ascending lexicographic order. However, when you want to change the ascending order or the default lexicographic order, we can override the default setting by specifying the reverse and key arguments.

We should apply the same practice to our own function declaration. In terms of what value we should set, the rule of thumb is you should choose the default value that is to be used for most function calls. Because this is an optional argument, you (or the users of your APIs) don’t want to set it in most situations. Consider the following example:

Avoid the pitfalls of mutable default arguments

There is a catch for setting the default argument. If your argument is a mutable object, it’s important that you don’t set it using the default constructor — because functions are objects in Python and they’re created when they’re defined. The side effect is that the default argument is evaluated at the time of function declaration, so a default mutable object is created and becomes part of the function. Whenever you call the function using the default object, you’re essentially accessing the same mutable object associated with the function, although your intention may be having the function to create a brand new object for you. The following code snippet shows you the unwanted side effect of setting a default mutable argument:

As shown above, although we intended to create two distinct shopping lists, the second function call still accessed the same underlying object, which resulted in the Soccer item added to the same list object. To solve the problem, we should use the following implementation. Specifically, you should use None as the default value for a mutable argument:

3. Consider Returning Multiple Values

Multiple values in a tuple

When your function performs complicated operations, the chances are that these operations can generate two or more objects, all of which are needed for your subsequent data processing. Theoretically, it’s possible that you can create a class to wrap these objects such that your function can return the class instance as its output. However, it’s possible in Python that a function can return multiple values. More precisely speaking, these multiple values are returned as a tuple object. The following code shows you a trivial example:

As shown above, the returned values are simply separated by a comma, which essentially creates a tuple object, as checked by the type() function.

But no more than three

One thing to note is that although Python functions can return multiple values, you should not abuse this feature. One value (when a function doesn’t explicitly return anything, it actually returns None implicitly) is best — because everything is straightforward and most users usually expect a function to return only one value. In some cases, returning two values is fine, returning three values is probably still OK, but please don’t ever return four values. It can create a lot of confusion for the users over which are which. If it happens, this is a good indication that you should refactor your functions — your functions probably serve multiple purposes and you should create smaller ones with more dedicated responsibilities.

4. Use Try…Except

When you define functions as public APIs, you can’t always assume that the users set the desired parameters to the functions. Even if we use the functions ourselves, it’s possible that some parameters are created out of our control and they’re incompatible with our functions. In these cases, what should we do in our function declaration?

The first consideration is to use the try…except statement, which is the typical exception handling technique. You embed the code that can possibly go wrong (i.e., raise certain exceptions) in the try clause and the possible exceptions are handled in the except clause.

Let’s consider the following scenario. Suppose that the particular business need is that your function takes a file path and if the file exists and is read successfully, your function does some data processing operations with the file and returns the result, otherwise returns -1. There are multiple ways to implement this need. The code below shows you a possible solution:

In other words, if you expect that users of your functions can set some arguments that result in exceptions in your code, you can define functions that handle these possible exceptions. However, this should be communicated with the users clearly, unless it’s part of the feature as shown in the example (return -1 when the file can’t be read).

5. Consider Argument Validation

The previous function using the try…except statement is sometimes referred to as the EAFP (Easier to Ask Forgiveness than Permission) coding style. There is another coding style called LBYL (Look Before You Leap), which stresses the sanity check before running particular code blocks.

Following the previous example, in terms of applying LBYL to function declaration, the other consideration is to validate your function’s arguments. One common use case for argument validation is to check whether the argument is of the right data type. As we all know, Python is a dynamically-typed language, which doesn’t enforce type checking. For instance, your function’s arguments should be integers or floating-point numbers. However, calling the function by setting strings — the invocation itself — won’t prompt any error messages until the function is executed.

The following code shows how to validate the arguments before running the code:

Discussion: EAFP vs. LBYL

It should be noted that both EAFP and LBYL can be applied to more than just dealing with function arguments. They can be applied anywhere in your functions. Although EAFP is a preferred coding style in the Python world, depending on your use case, you should also consider using LBYL which can provide more user-friendly function-specific error messages than the generic built-in error messages you get with the EAFP style.

6. Consider Lambda Functions As Alternatives

Functions as parameters of other functions

Some functions can take another function (or are callable, in general terms) to perform particular operations. For instance, the sorted() function has the key argument that allows us to define more custom sorting behaviors. The following code snippet shows you a use case:

Lambda functions as alternatives

Notably, the sorting_grade function was used just once and it’s a simple function — in which case, we can consider using a lambda function.

If you’re not familiar with the lambda function, here’s a brief description. A lambda function is an anonymous function declared using the lambda keyword. It takes zero to more arguments and has one expression for applicable operations with the form: lambda arguments: expression. The following code shows you how we can use a lambda function in the sorted() function, which looks a little cleaner than the solution above:

Another common use-case that’s relevant to many data scientists is the use of lambda functions when they work with the pandas library. The following code is a trivial example how a lambda function assists data manipulation using the map() function, which operates each item in a pandas Series object:

7. Consider Decorators

Decorators

Decorators are functions that modify the behavior of other functions without affecting their core functionalities. In other words, they provide modifications to the decorated functions at the cosmetic level. If you don’t know too much about decorators, please feel free to refer to my earlier articles (1, 2, and 3). Here’s a trivial example of how decorators work in Python.

As shown, the decorator function simply runs the decorated function twice. To use the decorator, we simply place the decorator function name above the decorated function with an @ prefix. As you can tell, the decorated function did get called twice.

Use decorators in function declarations

For instance, one useful decorator is the property decorator that you can use in your custom class. The following code shows you how it works. In essence, the @property decorator converts an instance method to make it behave like a regular attribute, which allows the access of using the dot notation.

Another trivial use case of decorators is the time logging decorator, which can be particularly handy when the efficiency of your functions is of concern. The following code shows you such a usage:

8. Use *args and **kwargs — But Parsimoniously

In the previous section, you saw the use of *args and **kwargs in defining our decorator function, the use of which allows the decorator function to decorate any functions. In essence, we use *args to capture all (or an undetermined number of, to be more general) position arguments while **kwargs to capture all (or an undetermined number of, to be more general) keyword arguments. Specifically, position arguments are based on the positions of the arguments that are passed in the function call, while keyword arguments are based on setting parameters to specifically named function arguments.

If you’re unfamiliar with these terminologies, here’s a quick peek to the signature of the built-in sorted() function: sorted(iterable, *, key=None, reverse=False). The iterable argument is a position argument, while the key and reverse arguments are keyword arguments.

The major benefit of using *args and **kwargs is to make your function declaration looks clean, or less noisy for the same matter. The following example shows you a legitimate use of *arg in function declaration, which allows your function to accept any number of position arguments.

The following code shows you a legitimate use of **kwargs in function declaration. Similarly, the function with **kwargs allows the users to set any number of keyword arguments, to make your function more flexible.

However, in most cases, you don’t need to use *args or **kwargs. Although it can make your declaration a bit cleaner, it hides the function’s signature. In other words, the users of your functions have to figure out exactly what parameters your functions take. So my advice is to avoid using them if you don’t have to. For instance, can I use a dictionary argument to replace the **kwargs? Similarly, can I use a list or tuple object to replace *args? In most cases, these alternatives should work without any problems.

9. Type Annotation for Arguments

As mentioned previously, Python is a dynamically-typed programming language as well as an interpreted language, the implication of which is that Python doesn’t check code validity, including type compatibility, during coding time. Until your code actually executes, will type incompatibility with your function (e.g., send a string to a function when an integer is expected) emerge.

For these reasons, Python doesn’t enforce the declaration of the type of input and output arguments. In other words, when you create your functions, you don’t need to specify what types of parameters they should have. However, it has become possible to do that in recent Python releases. The major benefit of having type annotation is that some IDEs (e.g., PyCharm or Visual Studio Code) could use the annotations to check the type compatibility for you, so that when you or other users use your functions you can get proper hints.

Another related benefit is that if the IDEs know the type of parameter, it can give proper auto-completion suggestions to help you code faster. Certainly, when you write docstrings for your functions, these type annotations will also be informative to the end developers of your code.

10. Responsible Documentation

I equate good documentation with responsible documentation. If your functions are for private uses, you don’t have to write very thorough documentation — you can make the assumption that your code tells the story clearly. If anywhere requires some clarification, you can write a very brief comment that can serve as a reminder for yourself or other readers when your code is revisited. Here, the discussion of responsible documentation is more concerned with the docstrings of your function as public APIs. The following aspects should be included:

• A brief summary of the intended operation of your function. This should be very concise. In most cases, the summary shouldn’t be more than one sentence.
• Input arguments: Type and explanation. You need to specify what type of your input arguments should be and what they can do by setting particular options.
• Return Value: Type and explanation. Just as with input arguments, you need to specify the output of your function. If it doesn’t return anything, you can optionally specify None as the return value.

Conclusions

If you’re experienced with coding, you’ll find out that most of your time is spent on writing and refactoring functions. After all, your data usually doesn’t change too much itself— it’s the functions that process and manipulate your data. If you think of data as the trunk of your body, functions are the arms and legs that move you around. So, we have to write good functions to make our programs agile.

I hope that this article has conveyed some useful information that you can use in your coding.

Thanks for reading.