데이터를 구문 분석하고 유효성을 검사하는 Python 패키지

오늘 주제는 Python 유형 힌팅을 사용한 데이터 유효성 검사 및 설정 관리입니다. 우리는 Python 패키지를 사용할 것입니다.Pydantic런타임에 유형 힌트를 적용합니다. 사용자 친화적 인 오류를 제공하여 잘못된 데이터를 포착 할 수 있습니다. 공식 문서에 따르면 Pydantic은

“… 주로 검증 라이브러리가 아니라 구문 분석 라이브러리입니다. 검증은 목적을위한 수단입니다. 제공된 유형과 제약 조건을 준수하는 모델을 구축합니다.

즉, pydantic은 입력 데이터가 아닌 출력 모델의 유형과 제약을 보장합니다.”

이 자습서에는 세 가지 섹션이 있습니다.

1. 설정
2. 이행
3. 결론

다음 섹션으로 이동하여 필요한 모듈 설치를 시작하겠습니다.

1. 설정

설치를 진행하기 전에 가상 환경을 만드는 것이 좋습니다.

기본 설치

터미널을 열고 다음 명령을 실행하여 설치하십시오.Pydantic

pip install pydantic

기존 패키지 업그레이드

이미 기존 패키지가 있고 업그레이드하려면 다음 명령을 실행하십시오.

pip install -U pydantic

아나콘다

Anaconda 사용자의 경우 다음과 같이 설치할 수 있습니다.

conda install pydantic -c conda-forge

선택적 종속성

Pydantic필요에 따라 다음과 같은 선택적 종속성이 제공됩니다.

• 이메일 유효성 검사기— 이메일 검증을 지원합니다.
• 타이핑 확장— 지원 사용정확한Python 3.8 이전.
• python-dotenv- 을지 지하다Dotenv설정 파일.

수동으로 설치할 수 있습니다.

# install email-validator
pip install email-validator# install typing-extensions
pip install typing_extensions# install python-dotenv
pip install python-dotenv

또는 함께Pydantic다음과 같이 :

# install email-validator
pip install pydantic[email]# install typing-extensions
pip install pydantic[typing_extensions]# install python-dotenv
pip install pydantic[dotenv]# install all dependencies
pip install pydantic[email,typing_extensions,dotenv]

2. 구현

이 섹션에서는 다음에서 사용할 수있는 몇 가지 유용한 기능을 살펴 보겠습니다.Pydantic.

개체 정의Pydantic에서 상속하는 새 클래스를 만드는 것만 큼 간단합니다.BaseModel. 클래스에서 새 개체를 만들 때Pydantic결과 모델 인스턴스의 필드가 모델에 정의 된 필드 유형을 따르도록 보장합니다.

수입

Python 파일 상단에 다음 가져 오기 선언을 추가합니다.

from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel

사용자 클래스

상속하는 새 클래스를 선언하십시오.BaseModel다음과 같이:

class User(BaseModel):
    id: int
    username : str
    password : str
    confirm_password : str
    alias = 'anonymous'
    timestamp: Optional[datetime] = None
    friends: List[int] = []

Pydantic기본 제공 유형 힌트 구문을 사용하여 각 변수의 데이터 유형을 결정합니다. 무대 뒤에서 일어나는 일을 하나씩 살펴 보겠습니다.

• 신분증— 정수 변수는 ID를 나타냅니다. 기본값이 제공되지 않으므로이 필드는 필수이며 객체 생성 중에 지정해야합니다. 문자열, 바이트 또는 부동 소수점은 가능한 경우 정수로 강제 변환됩니다. 그렇지 않으면 예외가 발생합니다.
• 사용자 이름— 문자열 변수는 사용자 이름을 나타내며 필수입니다.
• 암호— 문자열 변수는 암호를 나타내며 필수입니다.
• 비밀번호 확인— 문자열 변수는 확인 암호를 나타내며 필수입니다. 나중에 데이터 유효성 검사에 사용됩니다.
• 별명— 문자열 변수는 별칭을 나타냅니다. 필수 사항은 아니며 객체 생성 중에 제공되지 않으면 익명으로 설정됩니다.
• 타임 스탬프— 필수가 아닌 날짜 / 시간 필드. 기본값은 없음입니다.Pydanticunix timestamp int 또는 날짜 / 시간을 나타내는 문자열을 처리합니다.
• 친구— 정수 입력 목록입니다.

개체 인스턴스화

다음 단계는 다음에서 새 개체를 인스턴스화하는 것입니다.사용자수업.

data = {'id': '1234', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}user = User(**data)

인쇄 할 때 다음과 같은 출력을 얻어야합니다.사용자변하기 쉬운. 당신은 알 수 있습니다신분증입력이 문자열 인 경우에도 자동으로 정수로 변환되었습니다. 마찬가지로 바이트는 다음과 같이 자동으로 정수로 변환됩니다.친구들.

id=1234 username='wai foong' password='Password123' confirm_password='Password123' timestamp=datetime.datetime(2020, 8, 3, 10, 30) friends=[1, 2, 3] alias='anonymous'

BaseModel의 메소드 및 속성

상속하는 클래스BaseModel다음과 같은 메소드와 속성이 있습니다.

• dict ()— 모델의 필드 및 값 사전을 반환합니다.
• json ()— JSON 문자열 표현 사전을 반환합니다.
• 부()— 모델의 전체 복사본을 반환합니다.
• parse_obj ()— 객체가 사전이 아닌 경우 오류 처리를 사용하여 모델에 객체를로드하는 유틸리티
• parse_raw ()— 다양한 형식의 문자열을로드하는 유틸리티
• parse_field ()- 비슷하다parse_raw ()그러나 파일을 의미
• from_orm ()— 임의의 클래스에서 모델로 데이터를로드합니다.
• 개요()— 모델을 나타내는 사전을 JSON 스키마로 반환합니다.
• schema_json ()— 다음의 JSON 문자열 표현을 반환합니다.개요()
• 구성 ()— 검증을 실행하지 않고 모델을 생성하기위한 클래스 메소드
• __fields_set__— 모델 인스턴스가 초기화 될 때 설정된 필드 이름 세트
• __필드__— 모델 필드의 사전
• __config__— 모델의 구성 클래스

입력을 변경하겠습니다.신분증다음과 같이 문자열에 :

data = {'id': 'a random string', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}user = User(**data)

코드를 실행할 때 다음 오류가 발생해야합니다.

value is not a valid integer (type=type_error.integer)

ValidationError

오류에 대한 자세한 정보를 얻으려면 다음과 같이 try-catch 블록 안에 래핑하는 것이 좋습니다.

from pydantic import BaseModel, ValidationError# ... codes for User classdata = {'id': 'a random string', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}try:
    user = User(**data)
except ValidationError as e:
    print(e.json())

다음 JSON을 출력합니다.신분증유효한 정수가 아닙니다.

[
  {
    "loc": [
      "id"
    ],
    "msg": "value is not a valid integer",
    "type": "type_error.integer"
  }
]

필드 유형

PydanticPython 표준 라이브러리에서 대부분의 일반적인 유형을 지원합니다. 전체 목록은 다음과 같습니다.

• 부울
• int
• 흙손
• str
• 바이트
• 명부
• 튜플
• dict
• 세트
• 얼어 붙은
• datetime.date
• datetime.time
• datetime.datetime
• datetime.timedelta
• 타이핑.
• 타이핑 .TypeVar
• 타이핑. 유니온
• 입력합니다.
• 타이핑. 목록
• 타이핑. 튜플
• 타이핑. 딕트
• 타이핑. 세트
• 타이핑 .FrozenSet
• 타이핑. 시퀀스
• 타이핑.
• 타이핑. 유형
• 타이핑.
• 타이핑. 패턴
• ipaddress.IPv4Address
• ipaddress.IPv4Interface
• ipaddress.IPv4Network
• ipaddress.IPv6Address
• ip address.IPv6 인터페이스
• ipaddress.IPv6Network
• enum.Enum
• enum.IntEnum
• decimal.Decimal
• pathlib.Path
• uuid.UUID
• 바이트 크기

제한된 유형

다음을 통해 자신의 제한을 시행 할 수 있습니다.제한된 유형. 다음 예를 살펴 보겠습니다.

from pydantic import (
    BaseModel,
    NegativeInt,
    PositiveInt,
    conint,
    conlist,
    constr
)class Model(BaseModel):
    # minimum length of 2 and maximum length of 10
    short_str: constr(min_length=2, max_length=10)    # regex
    regex_str: constr(regex=r'^apple (pie|tart|sandwich)$')    # remove whitespace from string
    strip_str: constr(strip_whitespace=True)

    # value must be greater than 1000 and less than 1024
    big_int: conint(gt=1000, lt=1024)
    
    # value is multiple of 5
    mod_int: conint(multiple_of=5)
    
    # must be a positive integer
    pos_int: PositiveInt
    
    # must be a negative integer
    neg_int: NegativeInt

    # list of integers that contains 1 to 4 items
    short_list: conlist(int, min_items=1, max_items=4)

엄격한 유형

검증 된 값이 해당 유형이거나 해당 유형의 하위 유형 인 경우에만 검증을 통과하는 엄격한 제한을 찾고 있다면 다음과 같은 엄격한 유형을 사용할 수 있습니다.

• StrictStr
• StrictInt
• StrictFloat
• StrictBool

다음 예는 적절한 시행 방법을 보여줍니다.StrictBool상속 된 클래스에서.

from pydantic import BaseModel, StrictBool,class StrictBoolModel(BaseModel):
    strict_bool: StrictBool

문자열'그릇된'둘 중 하나만 허용하므로 ValidationError를 발생시킵니다.진실또는그릇된입력으로.

유효성 검사기

또한 다음을 사용하여 사용자 정의 유효성 검사기를 만들 수 있습니다.검증 인상속 된 클래스 내부의 데코레이터. 다음 예를 살펴 보겠습니다.신분증4 자리 숫자이고비밀번호 확인일치암호들.

from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, ValidationError, validatorclass User(BaseModel):
    id: int
    username : str
    password : str
    confirm_password : str
    alias = 'anonymous'
    timestamp: Optional[datetime] = None
    friends: List[int] = []    @validator('id')
    def id_must_be_4_digits(cls, v):
        if len(str(v)) != 4:
            raise ValueError('must be 4 digits')
        return v    @validator('confirm_password')
    def passwords_match(cls, v, values, **kwargs):
        if 'password' in values and v != values['password']:
            raise ValueError('passwords do not match')
        return v

3. 결론

오늘 배운 내용을 요약 해 보겠습니다.

데이터를 구문 분석하고 검증하는 데 도움이되는 Pydantic에 대한 자세한 설명부터 시작했습니다.

다음으로 가상 환경을 만들고 pip 또는 conda를 통해 Pydantic을 설치했습니다. 또한 사용 사례에 따라 세 가지 추가 종속성에 대한 지원도 포함됩니다.

설치가 완료되면 패키지에서 제공하는 기본 기능을 심도있게 살펴 보았습니다. 기본 구성 요소는 다음에서 상속되는 새 클래스를 만드는 것입니다.BaseModel.

Pydantic은 Python 표준 라이브러리에서 대부분의 일반적인 데이터 유형을 지원한다는 것을 배웠습니다. 우리는제한된 유형과엄격한 유형사용자 지정 제한을 적용하는 데 도움이됩니다.

마지막으로, 당신은검증 인네 자리 입력 만 허용하는 데코레이터신분증, 그리고비밀번호 확인일치해야합니다암호들.

이 글을 읽어 주셔서 감사합니다. 다음 기사에서 다시 뵙기를 바랍니다!

참고

1. Pydantic Github 페이지
2. Pydantic 문서

A Python package to parse and validate data

The topic for today is on data validation and settings management using Python type hinting. We are going to use a Python package called pydantic which enforces type hints at runtime. It provides user-friendly errors, allowing you to catch any invalid data. Based on the official documentation, Pydantic is

“… primarily a parsing library, not a validation library. Validation is a means to an end: building a model which conforms to the types and constraints provided.

In other words, pydantic guarantees the types and constraints of the output model, not the input data.”

There are three sections in this tutorial:

1. Setup
2. Implementation
3. Conclusion

Let’s proceed to the next section and start installing the necessary modules.

1. Setup

It is highly recommended to create a virtual environment before you proceed with the installation.

Basic installation

Open up a terminal and run the following command to install pydantic

pip install pydantic

Upgrade existing package

If you already have an existing package and would like to upgrade it, kindly run the following command:

pip install -U pydantic

Anaconda

For Anaconda users, you can install it as follows:

conda install pydantic -c conda-forge

Optional dependencies

pydantic comes with the following optional dependencies based on your needs:

• email-validator — Support for email validation.
• typing-extensions — Support use of Literal prior to Python 3.8.
• python-dotenv — Support for dotenv file with settings.

You can install them manually:

# install email-validator
pip install email-validator# install typing-extensions
pip install typing_extensions# install python-dotenv
pip install python-dotenv

or along with pydantic as follows:

# install email-validator
pip install pydantic[email]# install typing-extensions
pip install pydantic[typing_extensions]# install python-dotenv
pip install pydantic[dotenv]# install all dependencies
pip install pydantic[email,typing_extensions,dotenv]

2. Implementation

In this section, we are going to explore some of the useful functionalities available in pydantic.

Defining an object in pydantic is as simple as creating a new class which inherits from theBaseModel. When you create a new object from the class, pydantic guarantees that the fields of the resultant model instance will conform to the field types defined on the model.

Import

Add the following import declaration at the top of your Python file.

from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel

User class

Declare a new class which inherits the BaseModel as follow:

class User(BaseModel):
    id: int
    username : str
    password : str
    confirm_password : str
    alias = 'anonymous'
    timestamp: Optional[datetime] = None
    friends: List[int] = []

pydantic uses the built-in type hinting syntax to determine the data type of each variable. Let’s explore one by one what happens behind the scenes.

• id — An integer variable represents an ID. Since the default value is not provided, this field is required and must be specified during object creation. Strings, bytes, or floats will be coerced to integer if possible; otherwise, an exception will be raised.
• username — A string variable represents a username and is required.
• password — A string variable represents a password and is required.
• confirm_password — A string variable represents a confirmation password and is required. It will be used for data validation later on.
• alias — A string variable represents an alias. It is not required and will be set to anonymous if it is not provided during object creation.
• timestamp — A date/time field, which is not required. Default to None. pydantic will process either a unix timestamp int or a string representing the date/time.
• friends — A list of integer inputs.

Object instantiation

The next step is to instantiate a new object from the User class.

data = {'id': '1234', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}user = User(**data)

You should get the following output when you print out the user variable. You can notice that id has been automatically converted to an integer, even though the input is a string. Likewise, bytes are automatically converted to integers, as shown by the friends field.

id=1234 username='wai foong' password='Password123' confirm_password='Password123' timestamp=datetime.datetime(2020, 8, 3, 10, 30) friends=[1, 2, 3] alias='anonymous'

Methods and attributes under BaseModel

Classes that inherit the BaseModel will have the following methods and attributes:

• dict() — returns a dictionary of the model’s fields and values
• json() — returns a JSON string representation dictionary
• copy() — returns a deep copy of the model
• parse_obj() — a utility for loading any object into a model with error handling if the object is not a dictionary
• parse_raw() — a utility for loading strings of numerous formats
• parse_field() — similar to parse_raw() but meant for files
• from_orm() — loads data into a model from an arbitrary class
• schema() — returns a dictionary representing the model as JSON schema
• schema_json() — returns a JSON string representation of schema()
• construct() — a class method for creating models without running validation
• __fields_set__ — Set of names of fields which were set when the model instance was initialized
• __fields__ — a dictionary of the model’s fields
• __config__ — the configuration class for the model

Let’s change the input for id to a string as follows:

data = {'id': 'a random string', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}user = User(**data)

You should get the following error when you run the code.

value is not a valid integer (type=type_error.integer)

ValidationError

In order to get better details on the error, it is highly recommended to wrap it inside a try-catch block, as follows:

from pydantic import BaseModel, ValidationError# ... codes for User classdata = {'id': 'a random string', 'username': 'wai foong', 'password': 'Password123', 'confirm_password': 'Password123', 'timestamp': '2020-08-03 10:30', 'friends': [1, '2', b'3']}try:
    user = User(**data)
except ValidationError as e:
    print(e.json())

It will print out the following JSON, which indicates that the input for id is not a valid integer.

[
  {
    "loc": [
      "id"
    ],
    "msg": "value is not a valid integer",
    "type": "type_error.integer"
  }
]

Field types

pydantic provides support for most of the common types from the Python standard library. The full list is as follows:

• bool
• int
• float
• str
• bytes
• list
• tuple
• dict
• set
• frozenset
• datetime.date
• datetime.time
• datetime.datetime
• datetime.timedelta
• typing.Any
• typing.TypeVar
• typing.Union
• typing.Optional
• typing.List
• typing.Tuple
• typing.Dict
• typing.Set
• typing.FrozenSet
• typing.Sequence
• typing.Iterable
• typing.Type
• typing.Callable
• typing.Pattern
• ipaddress.IPv4Address
• ipaddress.IPv4Interface
• ipaddress.IPv4Network
• ipaddress.IPv6Address
• ipaddress.IPv6Interface
• ipaddress.IPv6Network
• enum.Enum
• enum.IntEnum
• decimal.Decimal
• pathlib.Path
• uuid.UUID
• ByteSize

Constrained types

You can enforce your own restriction via the Constrained Types. Let’s have a look at the following example:

from pydantic import (
    BaseModel,
    NegativeInt,
    PositiveInt,
    conint,
    conlist,
    constr
)class Model(BaseModel):
    # minimum length of 2 and maximum length of 10
    short_str: constr(min_length=2, max_length=10)    # regex
    regex_str: constr(regex=r'^apple (pie|tart|sandwich)$')    # remove whitespace from string
    strip_str: constr(strip_whitespace=True)

    # value must be greater than 1000 and less than 1024
    big_int: conint(gt=1000, lt=1024)
    
    # value is multiple of 5
    mod_int: conint(multiple_of=5)
    
    # must be a positive integer
    pos_int: PositiveInt
    
    # must be a negative integer
    neg_int: NegativeInt

    # list of integers that contains 1 to 4 items
    short_list: conlist(int, min_items=1, max_items=4)

Strict types

If you are looking for rigid restrictions which pass validation if and only if the validated value is of the respective type or is a subtype of that type, you can use the following strict types:

• StrictStr
• StrictInt
• StrictFloat
• StrictBool

The following example illustrates the proper way to enforce StrictBool in your inherited class.

from pydantic import BaseModel, StrictBool,class StrictBoolModel(BaseModel):
    strict_bool: StrictBool

The string ‘False’ will raise ValidationError as it will only accept either True or False as input.

Validator

Furthermore, you can create your own custom validators using the validator decorator inside your inherited class. Let’s have a look at the following example which determine if the id is of four digits and whether the confirm_password matches the password field.

from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, ValidationError, validatorclass User(BaseModel):
    id: int
    username : str
    password : str
    confirm_password : str
    alias = 'anonymous'
    timestamp: Optional[datetime] = None
    friends: List[int] = []    @validator('id')
    def id_must_be_4_digits(cls, v):
        if len(str(v)) != 4:
            raise ValueError('must be 4 digits')
        return v    @validator('confirm_password')
    def passwords_match(cls, v, values, **kwargs):
        if 'password' in values and v != values['password']:
            raise ValueError('passwords do not match')
        return v

3. Conclusion

Let’s recap what we have learned today.

We started off with a detailed explanation on Pydantic which helps to parse and validate data.

Next, we created a virtual environment and installed Pydantic via pip or conda. It also includes support for three additional dependencies based on our use cases.

Once we were done with the installation, we explored in-depth the basic functionalities provided by the package. The basic building block is to create a new class which inherits from BaseModel.

We learned that Pydantic provides support for most of the common data types under Python standard library. We tested out both the Constrained Types and Strict Types which helps to enforce our own custom restrictions.

Lastly, you played around with the validator decorator to allow only four digits input for id, and the confirm_password must match the password field.

Thanks for reading this piece. Hope to see you again in the next article!

Reference

1. Pydantic Github page
2. Pydantic Documentation

IPython 및 Jupyter 노트북에 유용한 명령

파이썬이 1991 년에 처음 등장했을 때, 그것은 "자신의 위험에 처한"컴퓨팅 언어로 더 많이 인식되었습니다. 오늘날 이는 데이터 과학, 기계 학습 및 소프트웨어 개발을위한 주요 언어입니다.

Python이 인기있는 주요 이유는 다음과 같은 새로운 기능과 기술을 추가 할 때 유연성이 있기 때문입니다.마법의 명령.

그렇다면 Python에서 마술 명령은 정확히 무엇입니까?

매직 명령은 일상적인 작업을 용이하게하도록 설계된 일반적인 Python 구문보다 향상된 기능 또는 바로 가기입니다.

이러한 특수 명령을 사용하면IPython외부 스크립트를 실행하거나 코드 조각의 실행 시간을 계산하는 등 표준 데이터 분석의 다양한 일반적인 문제를 해결합니다.

이 튜토리얼에서는 매우 유용한 몇 가지 주문을 알려 드리겠습니다. 이것들은 더 나은 프로그래밍 마법사가되는 데 도움이 될 것입니다.

이 모든 명령은 사전에 테스트되었습니다.Jupyter 노트북달리는Python 버전 3.7.4. 이 명령은 IDE의 모든 IPython 셸에서 완벽하게 실행되어야합니다.스파이더,파이 참등

매직 명령은 두 가지 형태로 제공됩니다.

• 라인 매직— 단일로 표시%접두사이며 한 줄의 입력에서 작동합니다.
• 세포 마법— 이중으로 표시%%접두사이며 전체 셀 또는 여러 줄의 입력에서 작동합니다.

가장 인기있는 몇 가지 마법 명령을 살펴 보겠습니다.

외부 스크립트 실행

새로운 프로젝트를 진행하고 있다고 가정합니다.Jupyter, 이전에 작성한 스크립트를 사용하려고합니다. 전체 코드를 Jupyter 셀에 복사하는 대신 Python 마법을 사용할 수 있습니다.

모든 스크립트는 다음을 사용하여 IPython 세션의 환경 내에서 실행할 수 있습니다.%운영명령.

다음과 같은 파일이 있다고 가정합니다.test_script.py다음 코드로 :

이를 실행하기 위해 다음을 사용합니다.

%run test_script.py

스크립트는 정의 된 가져 오기 또는 변수가없는 빈 네임 스페이스에서 실행됩니다.

동작은 다음을 사용하여 명령 줄에서 프로그램을 실행하는 것과 동일합니다.파이썬 test_script.py.

참고 : 다음을 사용하여 이미 정의 된 변수에 대한 액세스를 제공 할 수 있습니다.% run -i.

실행 된 스크립트에 정의 된 모든 변수는 이제 IPython 셸에서 액세스 할 수 있습니다.

예를 들어 외부 스크립트에 정의 된 함수를 재사용하는 방법을 참조하십시오.

필요한 경우 인수를 전달할 수도 있습니다. 여기서는 명령과 함께 단일 정수 인수를 전달합니다.

%run python_script.py 10`

에 대해 더 읽을 수 있습니다여기에서 외부 스크립트 실행.

외부 스크립트를 셀로 가져 오기 /보기

다음을 사용하여 외부 스크립트를 실행할 수 있습니다.%운영명령. 그러나 스크립트를 노트북 셀에 복사해야하는 상황이 있습니다.

걱정하지 마세요. Ctrl-C 및 Ctrl-V로 돌아갈 필요가 없습니다.

그만큼%하중매직 함수를 사용하면 스크립트를 코드 셀로 직접 가져올 수 있습니다.

%load test_script.py

위의 문장을 입력하고 실행을 누르십시오. 여기에서 마법을 직접 확인하십시오.

비슷한하중명령, 우리는pycat. 노트북을 떠나지 않고도 파일의 내용을 볼 수 있습니다.

%pycat test_script.py

% pycat외부 파일의 모든 내용을 출력으로 표시합니다.

에 대해 더 읽을 수 있습니다여기에 외부 스크립트 가져 오기.

노트북 셀을 외부 스크립트로 내보내기

데이터 과학자로서 저는 종종Jupyter 노트북. 그러나 프로덕션과 관련하여 코드는.py스크립트 파일.

여기,writefile마법이 유용합니다.writefile셀 내용 전체를 외부 파일로 내 보냅니다.

구경하다:

이중 퍼센트 (%%) 여기에 서명하십시오.writefile세포 마법입니다.

기존 파일에 코드를 추가 할 수도 있습니다.

에 대해 더 읽을 수 있습니다여기에 셀 내보내기.

코드 실행 시간

% timeitPython 표현식을 실행하기 위해 IPython 환경에 필요한 시간을 계산합니다.

이것을 사용하여 목록 이해력의 성능을...에 대한고리.

처음 1,000 개의 자연수의 제곱을 포함하는 목록을 만들 것입니다.

timeit표현식의 여러 실행을 수행합니다. 평균적으로 여러 번 실행되므로 결과가 더 안정적입니다.

우리는 또한timeit(%% timeit) 코드 블록의 경우.

다음을 사용하여 동일한 목록을 만들어 보겠습니다....에 대한고리:

이 시나리오에서 목록 이해는 동등한 것보다 약 10 % 더 빠릅니다....에 대한고리.

에 대해 더 읽을 수 있습니다여기에서 코드 시간 실행.

네임 스페이스에 변수 나열

네임 스페이스에 정의 된 모든 변수를 나열해야하는 경우 사용할 수있는 세 가지 명령이 있습니다.

• WHO: 최소한의 형식으로 모든 대화 형 변수를 인쇄합니다.
• who_ls: 모든 변수를 정렬 된 목록으로 반환합니다.
• 누구: 처럼%WHO, 그러나 각 변수에 대한 추가 정보를 제공합니다.

예를 들면 다음과 같습니다.

위의 코드는 네임 스페이스의 모든 사용자 정의 변수를 표시합니다. 특정 데이터 유형을 인수로 전달하여 표시 할 수 있습니다.

%who str# Output
# name

who_ls매우 유사하게 작동합니다. 유일한 차이점은 출력이 목록 형식이라는 것입니다.

%who_ls#Output:
# ['age', 'name', 'roll_number']

누구변수에 대한 자세한 정보를 제공합니다.

에 대해 더 읽을 수 있습니다여기에 변수 나열.

HTML 스크립트 실행

코드에 간단한 UI 요소를 제공해야하는 경우 IPython에서도 HTML 및 JavaScript 코드를 실행할 수 있습니다.

%% html셀에 HTML 코드를 작성할 수 있습니다. JavaScript의 경우%% js.

다음은 HTML로 간단한 표를 렌더링하는 예입니다.

셀은 HTML 편집기 역할을합니다. 코드가 실행되면 HTML 출력이 수신됩니다.

에 대해 더 읽을 수 있습니다여기서 HTML 스크립트 실행.

환경 변수 작업

그만큼envmagic 명령을 사용하면 시스템 환경 변수에 액세스하고 조작 할 수 있습니다.

다음 중 하나를 수행 할 수 있습니다.

• % env— 모든 환경 변수 나열
• % env var— 변수 값 가져 오기var
• % env var 값— 변수 값 설정var

매개 변수없이% env모든 환경 변수를 나열합니다.

특정 변수의 값을 반환하는 매개 변수를 추가합니다.

에 대해 더 읽을 수 있습니다여기에서 환경 변수 작업.

결론

다음을 사용하여 몇 가지 예와 함께 사용 가능한 매직 함수에 대한 일반적인 설명을 볼 수 있습니다.

%magic

특정 마법 기능에 대한 정보도 얻을 수 있습니다. 예를 들어 문서를 읽으려면%WHO마법은 다음을 입력하십시오.

자신 만의 매직 함수를 정의하려면 다음을 읽어야합니다.더 많은 IPython 리소스.

그래서 여기에 나의 소중한 파이썬 마법 명령이 있습니다. 아래 댓글에서 가장 좋아하는 것을 알려주십시오.

이 튜토리얼이 흥미롭고 유용하기를 바랍니다.

추가 읽기

• 내장 매직 명령 IPython
• 튜토리얼 포인트 — 매직 커맨드

Useful commands for IPython and Jupyter Notebooks

When Python first appeared in 1991, it was seen more as an “at your own risk” computing language. Today it is the predominant language for data science, machine learning, and software development.

A key reason behind Python’s popularity is its flexibility when it comes to adding new features and technologies like magic commands.

So, what exactly is a magic command in Python?

Magic commands are enhancements or shortcuts over the usual Python syntax designed to facilitate routine tasks.

These special commands enable us to easily control the behavior of the IPython system and solve various common problems in standard data analysis, for example, running an external script or calculating the execution time of a piece of code.

In this tutorial, I will teach you some very useful spells. These will help you to become better programming wizards.

All these commands were tested beforehand on a Jupyter Notebook running Python version 3.7.4. These commands should run perfectly in any IPython shell on your IDE, like Spyder, Pycharm, etc.

Magic commands come in two different forms:

• Line magic — is denoted by a single % prefix and operates on a single line of input
• Cell magic — is denoted by a double %% prefix and operates on the entire cell or multiple lines of input.

Let’s look at some of the most popular magic commands.

Run an External Script

Suppose you are working on a new project on Jupyter, and you wish to use a script that you wrote earlier. Rather than copying the entire code into a Jupyter cell, you can use some Python magic.

Any script can be run inside the environment of our IPython session using the %run command.

Suppose I have a file called test_script.py with the following code:

To run it, we use:

%run test_script.py

The script will run in an empty namespace with no imports or variables defined.

The behavior is identical to running the program on a command line using python test_script.py.

Note: You can provide access to already defined variables using %run -i.

All of the variables defined in the executed script are now accessible in the IPython shell.

For example, see how I reuse a function defined in the external script:

If needed, we can also pass arguments. Here, we pass a single integer argument along with our command.

%run python_script.py 10`

You can read more about running an external script here.

Import/View an External Script Into a Cell

We can run an external script using the %run command. But, there are situations when we must copy the script into a notebook cell.

Don’t worry, you don’t need to go back to Ctrl-C and Ctrl-V.

The %load magic function allows us to import a script directly into a code cell.

%load test_script.py

Just type the above statement and press run. Here, see the magic yourself:

Similar to the load command, we have pycat. It allows us to view the content of any file without leaving our notebook.

%pycat test_script.py

%pycat displays all the content of the external file as its output.

You can read more about importing an external script here.

Export a Notebook Cell as an External Script

As a data scientist, I often end up coding in a Jupyter notebook. But when it comes to production, the code needs to be in a .py script file.

Here, the writefile magic comes in handy. writefile exports the entirety of a cell’s content to an external file.

Take a look:

Notice the double percent(%%) sign here, as writefile is a cell magic.

We can also append code to an existing file.

You can read more about exporting a cell here.

Code Execution Time

%timeit calculates the time required by the IPython environment to execute a Python expression.

Let’s use this to compare the performance of list comprehension with a for loop.

We will create a list that contains the squares of the first 1,000 natural numbers.

timeit performs multiple runs of the expression. As we receive an average of several executions, the results are more reliable.

We also have a cell version for timeit (%%timeit) for a code block.

Let’s create the same list using a for loop:

In this scenario, list comprehension is about 10% faster than an equivalent for loop.

You can read more about code time execution here.

List Variables in the Namespace

If we need to list all the variables defined in the namespace, we have three commands at our disposal.

• who: Print all the interactive variables, with minimal formatting
• who_ls: Returns all the variables as a sorted list
• whos: Like %who, but gives some extra information about each variable

Here’s an example:

The above code displays all the user-defined variables in the namespace. We can display specific data types by passing them as arguments.

%who str# Output
# name

who_ls works very similarly. The only difference is that the output is in the form of a list.

%who_ls#Output:
# ['age', 'name', 'roll_number']

whos provides detailed information about the variables.

You can read more about listing variables here.

Execute HTML Script

If you need to provide some simple UI elements to your code, you can execute HTML and JavaScript code in IPython as well.

%%html allows us to write HTML code in the cell. For JavaScript, use %%js.

Here’s an example that will render a simple table in HTML:

The cell acts as an HTML editor. Once the code is run, you receive the HTML output.

You can read more about executing HTML script here.

Work With Environment Variables

The env magic command allows you to access and manipulate system environment variables.

You can either:

• %env — List all the environment variables
• %env var — Get value for variable var
• %env var value — Set value for variable var

Without any parameter, %env will list down all the environment variables.

We add a parameter to return the value of a specific variable.

You can read more about working with environment variables here.

Conclusion

You can see a general description of available magic functions, along with some examples, using:

%magic

We can also get information on a specific magic function. So, for example, to read the documentation of the %who magic simply type this:

If you wish to define your own magic functions, you should read this: More IPython Resources.

So here were some of my treasured Python magic commands. Let me know your favorite ones in the comments below.

I hope you found this tutorial interesting and useful.

Further Reading

• Built-In Magic Commands IPython
• Tutorials Point — Magic Commands

잘 알려지지 않은 Python의 기능

소개

프로그래밍 경험이있는 사람은 누구나다른 경우라면성명서. 기본적으로 특정 조건을 검사하여 논리적 분기를 만듭니다. 조건이 참으로 평가되면 프로그램은 다음에서 작업을 실행합니다.만약절, 그렇지 않으면그밖에절. 특히,이 두 절의 코드는 상호 배타적입니다. 즉,만약절이 실행되면그밖에절은 모두 건너 뛰고 그 반대의 경우도 마찬가지입니다.

서로 다른 언어간에 구문 세부 정보가 다양합니다. 예를 들어 Kotlin에서는 조건 평가에 괄호를 사용해야하지만 Swift와 Python에서는 괄호가 선택 사항입니다. Kotlin과 Swift 모두 각각에 중괄호를 사용합니다.만약과그밖에그러나 Python은 콜론과 들여 쓰기를 사용하여 범위를 나타냅니다. 다른 언어에는 약간의 차이가 있지만 이러한 특정 언어의 전문가가 아닌 기술에 정통한 외부인에게는 놀라운 일이 아닙니다.

이러한 대부분의 언어에서만약과그밖에절은다른 경우라면 언어의 다른 곳에서는 나타나지 않습니다. 그러나 Python은 이와 관련하여 드문 경우입니다.그밖에조항. 이 기사에서 우리는 그것들이 무엇인지, 그리고 몇 가지 현실적인 예를 통해 어떻게 사용할 수 있는지 검토 할 것입니다.

"for"문

반복은 자동화를 가능하게하는 중요한 방법으로 프로그램에서 수행하는 가장 일반적인 작업 중 하나입니다. 특히, 우리는 주로...에 대한반복하고 목록, 사전, 세트 및 기타 여러 가지 반복 가능한 유형을 통해 특정 작업을 수행합니다. 가장 기본적인 형식은 다음과 같습니다.

우리는그밖에다음 조항...에 대한고리. else 절은 어떤 조건에서 실행됩니까? 여기에 규칙이 있습니다.

의 코드그밖에절은...에 대한루프는 모든 반복을 완료합니다. 만약...에 대한루프는 break 문에 의해 조기에 중지됩니다.그밖에절도 생략됩니다.

헷갈 리게 들리나요? 당연히. 그만큼그밖에절은 문맥 외부에있을 때 실제로 까다 롭습니다.다른 경우라면성명서. 간단한 코드 예제를 통해이 사용법을 이해하겠습니다.

위와 같이 주문한 상품이 준비되면그밖에절이 실행되어 그룹 순서가 가능함을 보여줍니다. 사용할 수없는 항목이있는 경우 실행은단절문 (6 행)을 사용하면그밖에절.

"while"문

그만큼동안문은 나중에 실행 중에 조건이 변경 될 때 특히 유용합니다. 특히, 조건이 참인 동안동안원인은 조건이 거짓이 될 때까지 실행됩니다. 먼저 예를 보겠습니다.

위와 같이동안절은 저축 잔고가 0보다 크지 않을 때까지 계속 실행됩니다. 하위 섹션 제목에서 알 수 있듯이그밖에절동안성명서. 규칙은 다음과 같습니다.

의 코드그밖에절은동안조건이 거짓으로 평가되기 때문에 루프가 정상적으로 종료됩니다. 만약동안루프는 break 문에 의해 조기에 중지됩니다.그밖에절도 생략됩니다.

혼란 스럽기도합니다. 보다 현실적인 예를 통해 더 잘 이해할 수 있습니다. 간단히 추가하겠습니다.그밖에위의 예제에 대한 절을 몇 가지 수정했습니다.

위와 같이 이제 경고 수준을 설정하고 그 아래에서 다음을 실행하여 인출 활동을 중지합니다.단절성명서. 보시다시피 경고 수준이 100으로 설정되면동안최종 잔액이 0에 도달하기 때문에 루프가 정상적으로 종료됩니다. 그러나 경고 수준이 500으로 설정되면 세 번째 출금 후 잔액이 400이되어 코드 실행이 시작됩니다.만약진술, 따라서단절성명은동안루프 실행을 조기에 중지합니다.그밖에절이 실행되지 않습니다.

"시도"진술

예외 처리는 코딩에서 까다로운 작업입니다. 그렇게하지 않으면 프로그램이 매우 취약 해집니다. 그러나 너무 많이하면 코드의 가독성이 크게 떨어집니다. 따라서 예외를 처리해야하는 양과시기에 대한 균형을 찾아야합니다. 확실히 현재 기사는 Python에서 예외를 처리하는 것에 관한 것이 아닙니다. 대신 예외 처리 기능에 대해 이야기 해 보겠습니다. 특히, 우리는시도…파이썬에서 예외를 처리하는 문. 예를 보겠습니다.

위와 같이 단순히 문자열을 정수로 캐스팅하려고합니다. 문자열을 캐스트 할 수있는 경우시험절이 실행됩니다. 그러나 정수와 호환되지 않는 문자열을 캐스팅하면 예외가 발생하고외절. 아주 간단한 예외 처리 죠? 이 기사는그밖에절, 우리는 또한 사용할 수 있습니다그밖에절시도…그리고 당신은 그것에 대해 절대적으로 옳습니다. 규칙을 보겠습니다.

의 코드그밖에절은시험절은 예외없이 정상적으로 완료됩니다.

이 세 가지 중에서 이해하기 가장 쉬운 방법 일 것입니다.그밖에조항 사용법. 그럼에도 불구하고 특정 용도에 대해 다음 코드를 고려하십시오.

위의 코드에서 우리는인쇄원래 있던 기능시험조항에그밖에절. 이 두 함수 호출의 경우 보시다시피그밖에절은ValueError의도 된 사용법과 일치하는 예외가 발생했습니다.

특히, 코드의 최소화시험어떤 코드가 예외를 유발할 수 있는지 정확히 알려주기 때문에 절은 중요합니다.int ()함수. 그래서그밖에절은 이전 두 가지 사용법에 비해 코드를 더 깔끔하게 만드는 데 추가 된 이점이 있습니다.

결론

이 기사에서는 다른 세 가지를 검토했습니다.그밖에가장 잘 알려진 용법 외에 조항그밖에절만약성명서. 다음은 이러한 세 가지 용도에 대한 간략한 요약입니다.

• 때그밖에절은...에 대한과동안성명, 코드그밖에이전 절 (...에 대한또는동안) 만남 a단절성명서. 그렇지 않으면 이전 절 다음에 실행됩니다.
• 때그밖에절은시도…성명, 코드그밖에실행 중에 예외가 발생하면 절이 실행되지 않습니다.시험절. 때만 실행됩니다시험절은 예외를 발생시키지 않습니다.

이 세 가지 중 사람들은그밖에절시도…성명서. 다른 두 가지와 관련하여 새로운 Python 코더에게는 매우 혼란 스러울 수 있습니다. 더 노련한 기능을 사용하더라도 좋은 기능으로 사용하지 않으면 여전히 혼란 스러울 수 있습니다. 따라서 이러한 기능을 아는 것이 좋습니다. 그러면 해당 기능을 사용할 수있는 다른 사람의 코드를 읽을 수 있습니다. 이러한 기능을 직접 사용하는 경우 코드 리더 (예 : 팀 프로젝트)도 이러한 기능을 이해할 수 있는지 확인하는 것이 좋습니다.

읽어 주셔서 감사합니다!

Some lesser-known features of Python

Introduction

Anyone with any programming experience should be familiar with the if…else statement. Basically, it creates a logical branch by examining a particular condition. When the condition is evaluated to be true, the program will execute the operations in the if clause, otherwise executing those in the else clause. Notably, the code in these two clauses will be mutually exclusive, which means that when the code in the if clause gets executed, the code in the else clause will be skipped altogether and vice versa.

Between different languages, there are variations in syntactical details. For example, Kotlin requires that you use parentheses for the condition evaluations, while parentheses are optional in Swift and Python. Both Kotlin and Swift use curly braces for each if and else clauses, but Python uses colons and indentations to denote the scope. Other languages have some other variances, but nothing is surprising to tech-savvy outsiders who are not experts in these particular languages.

In most of these languages, the if and else clauses only exist in the if…else statement, and they don’t appear anywhere else in the language. However, Python is unusual in this regard, because there are three other usages of the else clauses. In this article, we’ll review what they are and how we can use them with some realistic examples.

The “for” Statement

We know that iteration is one of the most common operations that we do in the program as an important way to enable automation. Specifically, we mostly use the for loop, and perform particular actions by going over some sort of iterables, such as lists, dictionaries, sets, and many others. The most basic format is shown below.

We can append an else clause following the for loop. At what condition does the else clause get executed? Here’s the rule.

The code in the else clause will execute only when the for loop completes all the iterations. If the for loop is prematurely stopped by a break statement, the else clause will be skipped too.

Sounds confusing? Sure, is. The else clause is indeed tricky when it’s outside the context of the if…else statement. Let’s understand this usage with a simple code example.

As shown above, when the ordered items are are available, the else clause gets executed, showing that the group order is possible. When any item is found to be unavailable, the execution will run into the break statement (Line 6), which will result in the skip of the else clause.

The “while” Statement

The while statement is particularly useful when a condition is subject to change at a later time during execution. Specifically, while the condition is true, the code in the while cause will execute until the condition becomes false. Let’s see an example first.

As shown above, the code in the while clause continues to execute until the saving balance isn’t greater than zero. As indicated by the subsection title, we can also have an else clause with the while statement. Here’s the rule:

The code in the else clause will execute only when the while loop exits normally because the condition evaluates false. If the while loop is prematurely stopped by a break statement, the else clause will be skipped too.

I know that it’s confusing as well. It’s better understood through a more realistic example. I’ll just simply append the else clause to the above example with a few tweaks.

As shown above, we now set an alert level, below which, we’ll stop the withdrawal activities by executing the break statement. As you can see, when the alert level is set to 100, the while loop exits normally because the final balance reaches zero. However, when the alert level is set to 500, after the third withdrawal, the balance becomes 400, which will trigger the code execution in the if statement, and thus the break statement will make the while loop stop execution prematurely, by doing which, the else clause won’t execute.

The “try” Statement

Exception handling is a tricky task in coding. When you don’t do it, your program is very fragile. However, if you do it too much, the readability of your code is severely reduced. Thus, you need to find a balance for how much and when you need to handle exceptions. Certainly, the current article isn’t about handling exceptions in Python. Instead, let’s just talk about the feature of exception handling. Specifically, we will use the try…except statement to handle an exception in Python. Let’s see an example:

As shown above, we simply try to cast a string to an integer. When a string is able to be cast, all of the code in the try clause executes. However, when we cast a string that isn’t integer compatible, the exception is raised and handled by the code in the except clause. Pretty straightforward exception handling, right? Since this article is talking about else clauses, you can bet that we can also use an else clause in the try…except statement, and you’re absolutely right about that. Let’s see the rule:

The code in the else clause will execute only when the try clause completes normally without encountering any exceptions.

This is probably the easiest one to understand among these three else clause usages. Nevertheless, consider the following code for its specific usage.

In the above code, we move the print function that was originally in the try clause to the else clause. For these two function calls, as you can see, the else clause executes only when there is no ValueError exception raised, consistent with its intended usage.

Notably, minimizing the code in the try clause is significant, because it will inform us exactly of what code can cause exceptions, in which case, it’s the int() function. Thus, the else clause has added benefits in making our code cleaner compared to the previous two usages.

Conclusions

In this article, we reviewed three other else clauses besides the most well-known usage of else clause in the if statement. Here’s a quick recap of these three usages.

• When the else clause is used in the for and while statement, the code in the else clause won’t execute if the preceding clause (for or while) encounters a break statement. Otherwise, it will execute following the preceding clause.
• When the else clause is used in the try…except statement, the code in the else clause won’t execute if any exception is raised during the execution of the try clause. It will only run when the try clause raises no exceptions.

Among these three, people may be the most familiar with the else clause in the try…except statement. Regarding the other two, they can be very confusing to new Python coders. Even for those more seasoned ones, if you don’t use these under appreciated features, they can still be confusing. Thus, my advice is to know these features, which will allow you to read others’ code who may happen to use them. If you’re using these features yourself, you may want to make sure that your code readers (e.g., in a team project) can appreciate these features, too.

Thanks for reading!