파이썬코딩

NoSQL 데이터 저장소

&$#@ — Fri, 12 Nov 2021 22:11:35 +0900

일부 데이터베이스는 관계형 데이터베이스가 아니므로 SQL을 지원하지 않습니다. 이는 매우 큰 데이터 세트를 처리하거나, 보다 유연한 데이터 정의를 허용하거나, 사용자 지정 데이터 작업을 지원하기 위해 작성되었습니다. 이들은 집합적으로 NoSQL(이전에는 SQL이 없었으나 이제는 SQL뿐만 아니라 덜 대립한다는 의미)로 분류되었습니다.

dbm 제품군

DBM 포맷은 NoSQL이 만들어지기 훨씬 전에 존재했다. 키 밸류 스토어로, 웹 브라우저와 같은 응용 프로그램에 내장되어 다양한 설정을 유지합니다. DBM 데이터베이스는 다음과 같은 면에서 파이썬 사전과 같습니다.

• 키에 값을 할당할 수 있으며, 자동으로 디스크에 있는 데이터베이스에 저장됩니다. • 키에서 값을 얻을 수 있습니다.

다음은 간단한 예입니다. 다음 open() 메서드에 대한 두 번째 인수는 읽으려면 'r', 쓰려면 'w', 둘 다의 경우 'c'로 파일이 존재하지 않을 경우 파일을 만듭니다.

>>> import dbm
>>> db = dbm.open('definitions', 'c')

키-값 쌍을 만들려면 사전과 마찬가지로 키에 값을 할당하면 됩니다.

>>> db['mustard'] = 'yellow'

>>> db['ketchup'] = 'red'

>>> db['pesto'] = 'green'

잠시 멈추고 지금까지 보여드린 내용을 확인해 보겠습니다.

>>> len(db)

>>> db['pesto']

b'green'

닫았다가 다시 열어 실제로 저장했는지 확인합니다.

>>> db.close()

>>> db = dbm.open('definitions', 'r')

>>> db['mustard']

b'yellow'

키와 값은 바이트로 저장됩니다. 데이터베이스 오브젝트 DB를 반복할 수는 없지만 len()을 사용하여 키 수를 얻을 수 있습니다. 사전에서와 같이 get() 및 setdefault()가 작동합니다.

Memcached

memcached는 빠른 메모리 내 키 값 캐시 서버입니다. 종종 데이터베이스 앞에 놓이거나 웹 서버 세션 데이터를 저장하는 데 사용됩니다. Linux 및 OS X용 및 Windows용 버전을 다운로드할 수 있습니다. 이 섹션을 사용하려면 memcached 서버와 Python 드라이버가 필요합니다.

Python 드라이버에는 여러 가지가 있습니다. Python 3에서 작동하는 드라이버는 python3 memcached이며 다음 명령을 사용하여 설치할 수 있습니다.

$ pip install python-memcached

이를 사용하려면 memcached 서버에 연결하고, 그런 다음 다음을 수행할 수 있습니다.

• 키 값 설정 및 가져오기

• 값의 증가 또는 감소

• 키 삭제

데이터가 영구적이지 않고 이전에 작성한 데이터가 사라질 수 있습니다. 이것은 memcached에 내재되어 있습니다. 캐시 서버이기 때문입니다. 오래된 데이터를 카드화하여 메모리 부족을 방지합니다.

여러 memcached 서버에 동시에 연결할 수 있습니다. 다음 예에서는 같은 컴퓨터에 있는 사람과 대화하고 있습니다.

>>> import memcache
>>> db = memcache.Client(['127.0.0.1:11211']) >>> db.set('marco', 'polo')
True
>>> db.get('marco')
'polo'
>>> db.set('ducks', 0)
True
>>> db.get('ducks')
0
>>> db.incr('ducks', 2)
2
>>> db.get('ducks')
2

레디스

Redis는 데이터 구조 서버입니다. memcached와 마찬가지로 Redis 서버의 모든 데이터는 메모리에 맞아야 합니다(데이터를 디스크에 저장할 수 있는 옵션이 있습니다). memc ac aced와 달리 Redis는 다음을 수행할 수 있습니다.

• 안정성 및 재시작을 위해 데이터를 디스크에 저장

• 이전 데이터 유지

• 단순한 문자열보다 더 많은 데이터 구조 제공

Redis 데이터 유형은 Python과 거의 일치하며, Redis 서버는 하나 이상의 Python 애플리케이션이 데이터를 공유하는 데 유용한 매개체가 될 수 있다. 나는 그것이 매우 유용하다는 것을 알았기 때문에 여기에서 약간의 추가 커버리지를 할 가치가 있다.

파이썬 드라이버 redis-py는 온라인 문서뿐만 아니라 GitHub에 소스 코드와 테스트를 가지고 있다. 다음 명령을 사용하여 설치할 수 있습니다.

$ pip install redis
Redis 서버 자체의 설명서가 좋습니다. 로컬 컴퓨터에 네트워크 닉네임 localhost를 사용하여 Redis 서버를 설치하고 시작하는 경우 다음 섹션에서 pro ing을 사용할 수 있습니다.

Strings
단일 값을 갖는 키는 Redis 문자열입니다. 간단한 파이썬 데이터 유형이 자동으로
변환됩니다. 일부 호스트(기본값: localhost) 및 포트(de 오류: 6379)에서 Redis
서버에 연결합니다.
>>> import redis
>>> conn = redis.Redis()
redis.Redis('localhost') 또는 redis.Redis('localhost', 6379)도 같은 결과를 냈을 것이다.

모든 키 나열(현재 없음):

>>> conn.keys('*')

[]

단순 문자열(키 'secret', 정수(키 '캐럿') 및 플로트(키 'fever') 설정:

>>> conn.set('secret', 'ni!')

True

>>> conn.set('carats', 24)

True

>>> conn.set('fever', '101.5')

True

키로 값을 다시 가져옵니다.

>>> conn.get('secret')

b'ni!'

>>> conn.get('carats')

b'24'

>>> conn.get('fever')

b'101.5'

여기서 setnx() 메서드는 키가 없는 경우에만 값을 설정합니다.

>>> conn.setnx('secret', 'icky-icky-icky-ptang-zoop-boing!')

False

이미 '비밀'을 정의했기 때문에 실패했습니다.

>>> conn.get('secret')

b'ni!'

getset() 메서드는 이전 값을 반환하고 동시에 새 값으로 설정합니다.

>>> conn.getset('secret', 'icky-icky-icky-ptang-zoop-boing!')

b'ni!'

너무 앞서가지 맙시다. 효과가 있던가요?

>>> conn.get('secret')

b'icky-icky-icky-ptang-zoop-boing!'

이제 getrange()를 사용하여 하위 문자열을 가져옵니다(파이썬에서와 같이 오프셋 0=start, -1=end).

>>> conn.getrange('secret', -6, -1)

b'boing!'

setrange()를 사용하여 하위 문자열을 교체합니다(영점 기반 오프셋 사용).

>>> conn.setrange('secret', 0, 'ICKY')

>>> conn.get('secret')

b'ICKY-icky-icky-ptang-zoop-boing!'

그런 다음 mset()을 사용하여 여러 키를 한 번에 설정합니다.

>>> conn.mset({'pie': 'cherry', 'cordial': 'sherry'})

True

mget()을 사용하여 두 개 이상의 값을 동시에 가져옵니다.

>>> conn.mget(['fever', 'carats'])

[b'101.5', b'24']

삭제()를 사용하여 키 삭제:

>>> conn.delete('fever')

True

incr() 또는 incrbyfloat() 명령을 사용하여 증가시키고 decr()을 사용하여 감소시킵니다.

>>> conn.incr('carats')

>>> conn.incr('carats', 10)

>>> conn.decr('carats')

>>> conn.decr('carats', 15)

>>> conn.set('fever', '101.5')

True

>>> conn.incrbyfloat('fever')

102.5

>>> conn.incrbyfloat('fever', 0.5)

103.0

디크르비플로트가 없습니다. 열을 낮추려면 음의 증분을 사용합니다.

>>> conn.incrbyfloat('fever', -2.0)

101.0

재지정 목록에는 문자열만 포함할 수 있습니다. 이 목록은 처음 삽입할 때 작성됩니다. lpush()를 사용하여 처음에 삽입합니다.

>>> conn.lpush('zoo', 'bear')

처음에 두 개 이상의 항목을 삽입합니다.

>>> conn.lpush('zoo', 'alligator', 'duck')

삽입()을 사용하여 값 앞 또는 뒤에 삽입:

>>> conn.linsert('zoo', 'before', 'bear', 'beaver')

>>> conn.linsert('zoo', 'after', 'bear', 'cassowary')

lset()을 사용하여 오프셋에 삽입(목록이 이미 존재해야 함):

>>> conn.lset('zoo', 2, 'marmoset')

True

rpush()를 사용하여 끝에 삽입합니다.

>>> conn.rpush('zoo', 'yak')

lindex()를 사용하여 오프셋의 값을 가져옵니다.

>>> conn.lindex('zoo', 3)

b'bear'

lrange()(0 ~ -1)를 사용하여 오프셋 범위의 값을 가져옵니다.

>>> conn.lrange('zoo', 0, 2)

[b'duck', b'alligator', b'marmoset']

ltrim()으로 목록을 트리밍하고 오프셋 범위에만 유지합니다.

>>> conn.ltrim('zoo', 1, 4)

True

lrange()를 사용하여 값의 범위를 가져옵니다(모두에 대해 0 ~ -1 사용).

>>> conn.lrange('zoo', 0, -1)

[b'alligator', b'marmoset', b'bear', b'cassowary']

이 장에서는 Redis 목록과 게시-구독을 사용하여 구현할 수 있는 방법을 보여줍니다.

작업 대기열

Hashes

Redis 해시는 Python 사전과 유사하지만 문자열만 포함할 수 있습니다. 그러므로, 여러분은 깊은 내피 구조를 만들 수 없고 오직 한 단계만 깊이 들어갈 수 있습니다. 다음은 노래라는 Redis 해시를 만들고 재생하는 예입니다.

hmset()을 사용하여 해시 송에서 do 및 re 필드를 한 번에 설정합니다.

>>> conn.hmset('song', {'do': 'a deer', 're': 'about a deer'})

True

hset()을 사용하여 해시의 단일 필드 값을 설정합니다.

>>> conn.hset('song', 'mi', 'a note to follow re')

hget()을 사용하여 필드 값 가져오기:

>>> conn.hget('song', 'mi')

b'a note to follow re'

hmget()을 사용하여 여러 필드 값을 가져옵니다.

>>> conn.hmget('song', 're', 'do')

[b'about a deer', b'a deer']

hkeys()를 사용하여 해시의 모든 필드 키를 가져옵니다.

>>> conn.hkeys('song')

[b'do', b're', b'mi']

hval()을 사용하여 해시의 모든 필드 값을 가져옵니다.

>>> conn.hvals('song')

[b'a deer', b'about a deer', b'a note to follow re']

hlen()을 사용하여 해시의 필드 수를 가져옵니다.

>>> conn.hlen('song')

hgetall()을 사용하여 해시의 모든 필드 키 및 값을 가져옵니다.

>>> conn.hgetall('song')

{b'do': b'a deer', b're': b'about a deer', b'mi': b'a note to follow re'}

hsetnx()를 사용하여 해당 키가 없는 필드를 설정합니다.

>>> conn.hsetnx('song', 'fa', 'a note that rhymes with la')

파이썬코드 SQL 표현식 언어

&$#@ — Wed, 6 Oct 2021 07:14:12 +0900

다음 레벨 업은 SQLlchemy의 SQL 표현 언어입니다. 다양한 작업을 위한 SQL 생성 기능을 소개합니다. 표현식 언어는 하위 엔진 계층보다 더 많은 SQL 방언 차이를 처리합니다. 관계형 데이터베이스 애플리케이션에 편리한 중간 접근 방식이 될 수 있습니다.

다음은 동물원 테이블을 만들고 채우는 방법입니다. 다시 말하지만, 이것들은 단일 프로그램의 연속된 조각들입니다.

가져오기 및 연결은 이전과 동일합니다.

>>> import sqlalchemy as sa
>>> conn = sa.create_engine('sqlite://')

동물원 테이블을 정의하기 위해 SQL 대신 표현식 언어 중 일부를 사용하기 시작합니다.

>>> meta = sa.MetaData()

>>> zoo = sa.Table('zoo', meta,

... sa.Column('critter', sa.String, primary_key=True),
... sa.Column('count', sa.Integer),
... sa.Column('damages', sa.Float)
... )
>>> meta.create_all(conn)

앞의 예에서 여러 줄 통화의 괄호를 확인하십시오. 표() 메서드의 구조는 표 구조와 일치합니다. 표에 세 개의 열이 있는 것처럼 표() 메서드 호출의 괄호 안에 열()에 대한 세 개의 호출이 있습니다.

한편, zoo는 SQL 데이터베이스 세계와 파이썬 데이터 구조 세계를 연결하는 마법의 객체입니다.

표현 언어 함수가 더 많은 데이터를 삽입합니다.

... conn.execute(zoo.insert(('bear', 2, 1000.0)))

<sqlalchemy.engine.result.ResultProxy object at 0x1017ea910>

>>> conn.execute(zoo.insert(('weasel', 1, 2000.0)))

<sqlalchemy.engine.result.ResultProxy object at 0x1017eab10>

>>> conn.execute(zoo.insert(('duck', 10, 0)))

<sqlalchemy.engine.result.ResultProxy object at 0x1017eac50>

그런 다음 SELECT 문을 만듭니다(zoo.select()). 예를 들어, SELECT * FROM ZOO가 일반 SQL에서 수행하는 것과 같이 동물원 개체가 나타내는 테이블에서 모든 것을 선택합니다.

>>> result = conn.execute(zoo.select())

마지막으로 다음과 같은 결과를 얻습니다.

>>> rows = result.fetchall()
>>> print(rows)
[('bear', 2, 1000.0), ('weasel', 1, 2000.0), ('duck', 10, 0.0)]

객체-상대 매퍼

마지막 섹션에서 zoo 객체는 SQL과 파이썬 간의 중간 수준 연결이었다. SQLlchemy의 최상위 계층에서 ORM(Object-Relational Mapper)은 SQL 표현 언어를 사용하지만 실제 데이터베이스 메커니즘을 보이지 않게 하려고 합니다. 클래스를 정의하면 ORM이 데이터베이스로 데이터를 가져오거나 내보내는 방법을 처리합니다. "객체-관계형 맵퍼"라는 복잡한 구절 뒤에 숨겨진 기본 개념은 여러분이 코드에 있는 객체를 참조할 수 있고, 따라서 관계형 데이터베이스를 사용하면서 파이썬이 동작하는 방식에 근접할 수 있다는 것입니다.

동물원 클래스를 정의해서 ORM에 연결하겠습니다. 이번에는 SQLite에서 zoo.db 파일을 사용하도록 하여 ORM이 작동했는지 확인합니다.

앞의 두 절에서와 같이, 다음에 나오는 토막글은 실제로 설명으로 구분된 하나의 프로그램입니다. 이해가 안 가더라도 걱정하지 마세요. SQLArchemy 문서에는 모든 세부 사항이 포함되어 있습니다. 이 내용은 복잡해질 수 있습니다. 이 장에서 논의한 접근 방식 중 자신에게 적합한 방법을 결정할 수 있도록 이 작업을 수행하는 데 얼마나 많은 작업이 필요한지 파악해 주시기 바랍니다.

초기 가져오기는 동일하지만 이번에는 다른 것도 필요합니다.

>>> import sqlalchemy as sa
>>> from sqlalchemy.ext.declarative import declarative_base

여기, 우리는 다음과 같은 연결을 만듭니다.

>>> conn = sa.create_engine('sqlite:///zoo.db')

이제 SQLArchemy의 ORM에 대해 알아보겠습니다. Zoo 클래스를 정의하고 해당 속성을 테이블 열과 연결합니다.

>>> Base = declarative_base() >>> class Zoo(Base):

... __tablename__ = 'zoo'
... critter = sa.Column('critter', sa.String, primary_key=True)
... count = sa.Column('count', sa.Integer)
... damages = sa.Column('damages', sa.Float)
... def __init__(self, critter, count, damages):
... self.critter = critter
... self.count = count
... self.damages = damages
... def __repr__(self):
... return "<Zoo({}, {}, {})>".format(self.critter, self.count, self.damages)
다음 행은 데이터베이스와 테이블을 마법처럼 작성합니다.
>>> Base.metadata.create_all(conn)
그런 다음 파이썬 개체를 만들어 데이터를 삽입할 수 있습니다. ORM은 이러한 것들을 관리한다.
내부:
>>> first = Zoo('duck', 10, 0.0)
>>> second = Zoo('bear', 2, 1000.0)
>>> third = Zoo('weasel', 1, 2000.0)
>>> first
<Zoo(duck, 10, 0.0)>
다음으로, 우리는 ORM이 우리를 SQL 랜드로 데려가게 합니다. 데이터베이스와 대화하기 위한 세션을 만듭니다.
. >>> from sqlalchemy.orm import sessionmaker >>> Session = sessionmaker(bind=conn)
>>> session = Session()
세션 내에서, 우리는 우리가 만든 세 개의 객체를 데이터베이스에 작성합니다. add() 함수는 하나의 객체를 추가하고 add_all()은 목록을 추가합니다.
.
>>> session.add(first)
>>> session.add_all([second, third])
마지막으로, 우리는 모든 것을 완료하도록 강요해야 합니다.
>>> session.commit()

효과가 있던가요? 현재 디렉터리에 zoo.db 파일을 만들었습니다. 사용할 수 있습니다.

확인할 명령줄 sqlite3 프로그램:

$ sqlite3 zoo.db
SQLite version 3.6.12
Enter ".help" for instructions
Enter SQL statements terminated with a ";" sqlite> .tables
zoo
sqlite> select * from zoo;
duck|10|0.0

bear|2|1000.0

weasel|1|2000.0

이 섹션의 목적은 ORM이 무엇이고 높은 수준에서 어떻게 작동하는지 보여주기 위한 것이다. SQLlchemy의 작성자가 전체 자습서를 작성했습니다. 이 내용을 읽은 후 다음 중 필요에 가장 적합한 수준을 결정하십시오.

• 이전 SQLite 섹션에서와 같이 일반 DB-API

• SQLArchemy 엔진룸

• SQLArchemy 표현 언어

• SQLChemy ORM

SQL의 복잡성을 피하기 위해 ORM을 사용하는 것은 자연스러운 선택인 것 같습니다. 하나 쓸까요? 어떤 사람들은 ORM을 피해야 한다고 생각하지만, 다른 사람들은 이 비판이 지나치다고 생각한다. 누가 옳든, ORM은 추상화입니다. 그리고 모든 추상화들은 어느 순간 무너집니다. 그것들은 새어나갑니다. ORM이 원하는 작업을 수행하지 않는 경우 SQL에서 ORM의 작동 방식과 해결 방법을 모두 파악해야 합니다. 인터넷 밈을 빌리려면: 어떤 사람들은 어떤 문제에 직면했을 때, "알아요, ORM을 써야겠어요."라고 생각합니다. 이제 그들은 두 가지 문제를 안고 있습니다. ORM은 거의 사용하지 않으며 대부분 간단한 애플리케이션에 사용합니다. 응용 프로그램이 그렇게 간단한 경우 스트레이트 SQL(또는 SQL 표현식 언어)을 사용할 수도 있습니다.

또는 데이터 집합과 같은 간단한 것을 시도할 수 있습니다. SQL, JSON 및 CSV 스토리지를 위한 간단한 ORM을 제공하는 SQLLchemy는 SQL, JSON 및 CSV 스토리지를 제공합니다.

파이썬코드 Db-api sqlite mysql

&$#@ — Mon, 4 Oct 2021 22:12:04 +0900

DB-API

API(응용 프로그램 프로그래밍 인터페이스)는 일부 서비스에 액세스하기 위해 호출할 수 있는 함수 집합입니다. DB-API는 관계형 데이터베이스에 액세스하기 위한 Python의 표준 API입니다. 이를 사용하여 각 데이터베이스에 대해 별도의 프로그램을 작성하는 대신 여러 종류의 관계형 데이터베이스에서 작동하는 단일 프로그램을 작성할 수 있습니다. 그것은 자바의 JDBC나 펄의 dbi와 비슷하다.

주요 기능은 다음과 같습니다.

연결하다

데이터베이스에 연결합니다. 사용자 이름, 암호, 서버 주소 등의 인수를 포함할 수 있습니다.

커서가 있는

쿼리를 관리할 커서 개체를 만듭니다. 사형 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행 집행.

데이터베이스에 대해 하나 이상의 SQL 명령을 실행합니다.

fetchone() , fetchmany() 및 fetchall() 실행에서 결과를 가져옵니다.

다음 절의 Python 데이터베이스 모듈은 DB-API를 준수하며, 종종 확장과 세부 사항의 일부 차이점이 있습니다.

SQLite

SQLite는 우수하고 가벼운 오픈 소스 관계형 데이터베이스입니다. 표준 파이썬 라이브러리로 구현되며 데이터베이스를 일반 파일에 저장합니다. 이 파일들은 ma ch chines 및 운영 체제 간에 이동 가능하므로 SQLite는 단순한 관계형 데이터베이스 애플리케이션을 위한 매우 휴대성이 뛰어난 솔루션이 됩니다. MySQL 또는 Postgre만큼 완벽한 기능은 아닙니다.SQL은 지원하지만 여러 명의 동시 사용자를 관리합니다. 웹 브라우저, 스마트폰 및 기타 응용 프로그램은 SQLite를 내장 데이터베이스로 사용합니다.

사용 또는 작성할 로컬 SQLite 데이터베이스 파일에 대한 연결()로 시작합니다. 이 파일은 부모가 다른 서버에 있는 테이블로 사용하는 디렉토리와 같은 데이터베이스와 동일합니다. 특수 문자열 ':memory:'는 메모리에만 데이터베이스를 만듭니다. 이 문자열은 빠르고 테스트에 유용하지만 프로그램이 종료되거나 컴퓨터가 다운되면 데이터가 손실됩니다.

다음 예로, 번창하는 길가 애완 동물원의 사업을 관리하기 위해 Enterprise.db라는 데이터베이스와 테이블 동물원(table zoo)을 만들어 보겠습니다. 테이블 열은 다음과 같습니다.

생물의 가변 길이 문자열 및 기본 키

수를 세다

이 동물에 대한 현재 재고의 정수 개수

손해

현재 동물과 인간의 상호작용으로 인한 손실의 액수입니다.

>>> import sqlite3
>>> conn = sqlite3.connect('enterprise.db') >>> curs = conn.cursor()
>>> curs.execute('''CREATE TABLE zoo

(critter VARCHAR(20) PRIMARY KEY,

count INT,

damages FLOAT)''')

<sqlite3.Cursor object at 0x1006a22d0>

Python의 삼중따옴표는 SQL 쿼리와 같은 긴 문자열을 만들 때 유용합니다.

이제 동물원에 동물을 추가하세요.

>>> curs.execute('INSERT INTO zoo VALUES("duck", 5, 0.0)')

<sqlite3.Cursor object at 0x1006a22d0>

>>> curs.execute('INSERT INTO zoo VALUES("bear", 2, 1000.0)')

<sqlite3.Cursor object at 0x1006a22d0>

자리 표시자를 사용하여 데이터를 더 안전하게 삽입할 수 있습니다.

>>> ins = 'INSERT INTO zoo (critter, count, damages) VALUES(?, ?, ?)'

>>> curs.execute(ins, ('weasel', 1, 2000.0))

<sqlite3.Cursor object at 0x1006a22d0>

이번에는 SQL에 물음표 3개를 사용하여 3개의 값을 삽입한 다음 이 3개의 값을 목록으로 실행() 함수에 전달할 계획임을 나타냅니다. 보험 계약자는 인용과 같은 지루한 세부 사항을 처리합니다. SQL 주입으로부터 사용자를 보호합니다. SQL 주입은 웹에서 일반적으로 시스템에 악의적인 SQL 명령을 삽입하는 외부 공격입니다.

이제, 우리가 우리의 모든 동물들을 다시 꺼낼 수 있는지 봅시다.

>>> curs.execute('SELECT * FROM zoo') <sqlite3.Cursor object at 0x1006a22d0> >>> rows = curs.fetchall()
>>> print(rows)

[('duck', 5, 0.0), ('bear', 2, 1000.0), ('weasel', 1, 2000.0)]

다시 불러오죠. 하지만 숫자대로 정렬합니다.

>>> curs.execute('SELECT * from zoo ORDER BY count')

<sqlite3.Cursor object at 0x1006a22d0>

>>> curs.fetchall()

[('weasel', 1, 2000.0), ('bear', 2, 1000.0), ('duck', 5, 0.0)]

이봐, 우린 내림차순으로 원했어.

>>> curs.execute('SELECT * from zoo ORDER BY count DESC')

<sqlite3.Cursor object at 0x1006a22d0>

>>> curs.fetchall()

[('duck', 5, 0.0), ('bear', 2, 1000.0), ('weasel', 1, 2000.0)]

어떤 종류의 동물이 가장 비용이 많이 드나요?

>>> curs.execute('''SELECT * FROM zoo WHERE

... damages = (SELECT MAX(damages) FROM zoo)''')

<sqlite3.Cursor object at 0x1006a22d0>

>>> curs.fetchall()

[('weasel', 1, 2000.0)]

여러분은 곰들이라고 생각했을 것입니다. 항상 실제 데이터를 확인하는 것이 가장 좋습니다.

SQLite를 떠나기 전에 정리를 해야 합니다. 연결과 커서를 연 경우 작업이 완료되면 커서를 닫아야 합니다.

>>> curs.close()

>>> conn.close()

MySQL

MySQL은 매우 널리 사용되는 오픈 소스 관계형 데이터베이스입니다. SQLite와 달리 실제 서버이므로 클라이언트가 네트워크상의 다른 장치에서 액세스할 수 있습니다.

MysqlDB는 가장 인기 있는 MySQL 드라이버였지만 아직 파이썬 3으로 포팅되지는 않았다. 표 8-3에는 파이썬에서 MySQL에 액세스하는 데 사용할 수 있는 드라이버가 나와 있습니다.

표 8-3. MySQL 드라이버

MySQL Connector PYMySQL
oursql

Link

http://bit.ly/mysql-cpdg

https://github.com/petehunt/ PyMySQL/

http://pythonhosted.org/oursql/

Pypi package Import as

mysql-connector- mysql.connector python

Notes

Requires the MySQL C client libraries.

PostgreSQl

링크

http://bit.ly/mysql-cpdg

https://github.com/petehunt/ PyMySQL/

http://pythonhosted.org/oursql/

Pypi 패키지 가져오기 위치

mysql-sql.mysql.mysql

메모들

MySQL C 클라이언트 라이브러리가 필요합니다.

Pymysql usql

pymysql

usql

포스트그레SQL은 MySQL보다 여러 면에서 더 많은 이점을 제공하는 완전한 기능의 오픈 소스 관계형 데이터베이스입니다. 표 8-4는 Python 드라이버에 액세스하는 데 사용할 수 있는 드라이버를 보여줍니다.

포스트그레SQL 드라이버

가장 인기 있는 드라이버는 psycopg2이지만 Postgre를 설치해야 한다.SQL 클라이언트 라이브러리.

SQLArchemy

SQL은 모든 관계형 데이터베이스에 대해 완전히 동일하지는 않으며 DB-API는 지금까지만 지원합니다. 각 데이터베이스는 그 특징과 철학을 반영하는 특정한 방언을 구현한다. 많은 도서관들이 이런 차이점들을 어떻게든 메우려고 노력한다. 가장 널리 사용되는 데이터베이스 간 파이썬 라이브러리는 SQLArchemy입니다.

그것은 표준 도서관에는 없지만, 많은 사람들에 의해 잘 알려져 있고 사용되고 있습니다. 다음 명령을 사용하여 시스템에 설치할 수 있습니다.

$ pip install sqlalchemy

• 가장 낮은 수준은 데이터베이스 연결 풀, SQL 명령 실행 및 결과 반환을 처리합니다. DB-API에 가장 가깝습니다.

• 다음은 SQL 표현 언어인 Pythonic SQL Builder입니다.

• 가장 높은 계층은 SQL 식을 사용하는 ORM(Object Relational Model) 계층입니다.

언어 및 관계형 데이터 구조와 응용 프로그램 코드를 바인딩합니다.

계속 진행하면서 이러한 수준의 용어가 무엇을 의미하는지 이해하게 될 것입니다. SQLArchemy는 이전 절에 설명된 데이터베이스 드라이버와 함께 작동합니다. 드라이버를 가져올 필요가 없습니다. SQLLCemy에 제공한 초기 연결 문자열이 드라이버를 결정합니다. 이 문자열은 다음과 같습니다.

dialect + driver :// user : password @ host : port / dbname

이 문자열에 입력한 값은 다음과 같습니다.

사투리를 쓰다

데이터베이스 유형

운전사의

해당 데이터베이스에 사용할 특정 드라이버

사용자 및 암호

데이터베이스 인증 문자열

숙주와 항구

데이터베이스 서버의 위치(: 이 서버의 표준 포트가 아닌 경우에만 필요)

dbname

서버에서 처음 연결할 데이터베이스

Table 8-5 lists the dialects and drivers.
Table 8-5. SQLAlchemy connection

dialect

sqlite

mysql

postgresql

driver

pysqlite (or omit) mysqlconnector pymysql
oursql psycopg2 pypostgresql

엔진 층

먼저, 기본 DB- API 기능보다 조금 더 낮은 수준의 SQLlchemy를 사용해 보겠습니다.

파이썬에 이미 내장된 SQLite를 사용해 보겠습니다. SQLite에 대한 연결 문자열이 호스트, 포트, 사용자 및 암호를 건너뜁니다. dbname은 데이터베이스를 저장하는 데 사용할 파일을 SQLite에 알려줍니다. dbname을 생략하면 SQLite는 메모리에 데이터베이스를 작성합니다. dbname이 슬래시(/)로 시작하는 경우 컴퓨터의 절대 파일 이름입니다(예: Windows의 C:\\). 그렇지 않으면 현재 디렉토리와 관련이 있습니다.

다음 세그먼트는 설명을 위해 여기에서 분리된 한 프로그램의 모든 부분입니다.

먼저 필요한 것을 가져오셔야 합니다. 다음은 문자열 sa를 사용하여 SQLLCemy 메서드를 참조할 수 있는 가져오기 별칭의 예입니다. 주로 sa가 sqlalchemy보다 훨씬 쉽게 입력되기 때문에 이 작업을 수행합니다.

>>> import sqlalchemy as sa

데이터베이스에 연결하고 메모리에 데이터베이스에 대한 저장소 만들기(인수 문자열)

'sqlite://:memory:'도 작동합니다.

>>> conn = sa.create_engine('sqlite://')

다음과 같은 세 개의 열로 구성된 zoo라는 데이터베이스 테이블을 만듭니다.

>>> conn.execute('''CREATE TABLE zoo

...

<sqlalchemy.engine.result.ResultProxy object at 0x1017efb10>

conn.execute()를 실행하면 ResultProxy라는 SQLLCemy 개체를 반환합니다. 너는 곧 그것을 어떻게 해야 할지 알게 될 것이다.

그나저나, 데이터베이스 표를 만들어 본 적이 없다면 축하드립니다. 버킷 리스트에서 하나를 체크하세요.

이제 비어 있는 새 테이블에 세 가지 데이터 세트를 삽입합니다.

>>> ins = 'INSERT INTO zoo (critter, count, damages) VALUES (?, ?, ?)'

>>> conn.execute(ins, 'duck', 10, 0.0)

<sqlalchemy.engine.result.ResultProxy object at 0x1017efb50>

>>> conn.execute(ins, 'bear', 2, 1000.0)

<sqlalchemy.engine.result.ResultProxy object at 0x1017ef090>

>>> conn.execute(ins, 'weasel', 1, 2000.0)

<sqlalchemy.engine.result.ResultProxy object at 0x1017ef450>

그런 다음 데이터베이스에 방금 입력한 모든 내용을 요청하십시오.

>>> rows = conn.execute('SELECT * FROM zoo')

SQLArchemy에서 행은 목록이 아니라 직접 인쇄할 수 없는 특별한 ResultProxy입니다.

>>> print(rows)
<sqlalchemy.engine.result.ResultProxy object at 0x1017ef9d0>

그러나 목록처럼 반복할 수 있으므로 한 번에 다음 행을 얻을 수 있습니다.

>>> for row in rows: ... print(row) ...
('duck', 10, 0.0) ('bear', 2, 1000.0) ('weasel', 1, 2000.0)

앞에서 보신 SQLite DB-API 예제와 거의 동일합니다. 한 가지 장점은 맨 위에 있는 데이터베이스 드라이버를 가져올 필요가 없다는 것입니다. SQLArchemy는 연결 문자열에서 이를 알아냈습니다. 연결 문자열을 변경하면 이 코드가 다른 유형의 데이터베이스로 이동될 수 있습니다. 또 다른 장점은 SQLlchemy의 연결 풀링이며, 이 풀링은 설명서 사이트에서 확인할 수 있습니다.

파이썬코드 피클을 사용하여 직렬화

&$#@ — Sun, 3 Oct 2021 23:34:48 +0900

데이터 구조를 파일에 저장하는 것을 직렬화라고 합니다. JSON과 같은 형식을 사용하려면 파이썬 프로그램의 모든 데이터 유형을 직렬화하기 위해 일부 사용자 지정 변환기가 필요할 수 있습니다. 파이썬은 특별한 바이너리 형식으로 객체를 저장하고 복원할 수 있는 피클 모듈을 제공한다.

날짜/시간 객체를 만났을 때 JSON이 어떻게 정신을 잃었는지 기억하십니까? 피클에 대한 확률 없음:

>>> import pickle
>>> import datetime
>>> now1 = datetime.datetime.utcnow()
>>> pickled = pickle.dumps(now1)
>>> now2 = pickle.loads(pickled)
>>> now1
datetime.datetime(2014, 6, 22, 23, 24, 19, 195722) >>> now2
datetime.datetime(2014, 6, 22, 23, 24, 19, 195722)

피클은 당신의 클래스나 오브젝트에서도 작동한다. 문자열로 처리될 때 문자열 'tiny'를 반환하는 Tiny라는 작은 클래스를 정의합니다.

>>> import pickle
>>> class Tiny():
... def __str__(self): ... return 'tiny' ...
>>> obj1 = Tiny()

>>> obj1
<__main__.Tiny object at 0x10076ed10>
>>> str(obj1)
'tiny'
>>> pickled = pickle.dumps(obj1)
>>> pickled b'\x80\x03c__main__\nTiny\nq\x00)\x81q\x01.' >>> obj2 = pickle.loads(pickled)
>>> obj2
<__main__.Tiny object at 0x10076e550>
>>> str(obj2)
'tiny'

절인 것은 물체 obj1로부터 만들어진 절인 2진법 끈이다. 우리는 그것을 객체 obj2로 다시 변환하여 obj1의 복사본을 만들었습니다. 덤프()를 사용하여 파일에 피클하고 로드()를 사용하여 파일에서 피클을 해제합니다.

피클은 파이썬 개체를 만들 수 있기 때문에 이전 섹션에서 설명한 것과 동일한 보안 경고 잉그가 적용됩니다. 신뢰하지 않는 것을 풀지 마라.

구조화된 이진 파일

일부 파일 형식은 특정 데이터 구조를 저장하기 위해 설계되었지만, 규격 데이터베이스도 NoSQL 데이터베이스도 아니다. 다음 절에서는 그 중 일부를 제시합니다.

스프레드시트

스프레드시트, 특히 Microsoft Excel은 널리 사용되는 이진 데이터 형식입니다. 스프레드시트를 CSV 파일에 저장할 수 있는 경우 앞서 설명한 표준 CSV 모듈을 사용하여 스프레드시트를 읽을 수 있습니다. 이진 xls 파일이 있는 경우 xlrd는 읽고 쓰기를 위한 타사 패키지입니다.

HDF5

HDF5는 다차원 또는 계층적 숫자 데이터를 위한 이진 데이터 형식입니다. 대용량 데이터셋(기가바이트 ~ 테라바이트)에 대한 빠른 랜덤 액세스가 일반적인 요구 사항인 과학 분야에서 주로 사용됩니다. 어떤 경우에는 HDF5가 데이터베이스의 좋은 대안이 될 수 있지만, 어떤 이유로 HDF5는 비즈니스 세계에서 거의 알려져 있지 않습니다. 충돌하는 쓰기로부터 데이터베이스를 보호할 필요가 없는 WORM(Write Once/Read Many) 애플리케이션에 가장 적합합니다. 다음은 유용한 몇 가지 모듈입니다.

h5py는 완전 저수준 인터페이스입니다. 설명서 및 코드를 읽습니다.

PyTables는 데이터베이스와 유사한 기능을 가진 좀 더 높은 레벨입니다. 설명서와 코드를 읽습니다.

이 두 가지 모두 부록 C에서 파이썬의 과학적 적용 측면에서 논의된다. 여기서 말하는 것은 대량의 데이터를 저장 및 검색해야 하는 경우 일반적인 데이터베이스 솔루션뿐만 아니라 외부 솔루션을 고려할 의사가 있는 경우입니다. 좋은 예는 HDF5 형식의 다운로드 가능한 노래 데이터가 있는 Million Song 데이터 세트입니다

관계형 데이터베이스

관계형 데이터베이스는 약 40년 밖에 되지 않았지만 컴퓨팅 세계 어디에서나 볼 수 있습니다. 여러분은 거의 틀림없이 한 번 혹은 여러 번 그들을 상대해야 할 것입니다. 그러면 다음과 같은 혜택을 누릴 수 있습니다.

• 여러 동시 사용자의 데이터 액세스

• 해당 사용자에 의한 손상 방지

• 효율적인 데이터 저장 및 검색 방법

• 스키마에 의해 정의되고 제약에 의해 제한되는 데이터

• 다양한 유형의 데이터에 걸친 관계를 찾기 위한 결합

• 선언적(필수적) 질의 언어: SQL(구조화된 쿼리 언어)

이것들은 서로 다른 종류의 데이터들 사이의 관계를 표의 형태로 보여주기 때문에 관계형이라고 불린다. 예를 들어, 앞의 메뉴 예에서는 각 품목과 가격 사이에 관계가 있습니다.

테이블은 스프레드시트와 유사한 행과 열의 그리드입니다. 테이블을 만들려면 테이블 이름을 지정하고 열의 순서, 이름 및 유형을 지정하십시오. 결측 데이터(null이라고 함)를 허용하도록 열을 정의할 수 있지만 각 행에는 동일한 열이 있습니다. 메뉴 예제에서는 판매되는 각 품목에 대해 하나의 행으로 테이블을 만들 수 있습니다. 각 품목에는 가격에 대한 열을 포함하여 동일한 열이 있습니다.

열 또는 열 그룹은 일반적으로 테이블의 기본 키이며 해당 값은 테이블에서 고유해야 합니다. 이렇게 하면 테이블에 동일한 데이터를 두 번 이상 추가할 수 없습니다. 이 키는 쿼리 중 빠른 검색을 위해 인덱싱됩니다. 색인은 책 색인처럼 작동하기 때문에 특정 행을 빨리 찾을 수 있습니다.

각 테이블은 디렉토리 내의 파일처럼 상위 데이터베이스 내에 있습니다. 두 단계의 위계질서가 상황을 조금 더 잘 정리하도록 도와줍니다.

예, 데이터베이스라는 단어는 서버, 테이블 컨테이너 및 여기에 저장된 데이터로 여러 가지 방법으로 사용됩니다. 모든 항목을 동시에 참조하는 경우 데이터베이스 서버, 데이터베이스 및 데이터라고 부르는 것이 도움이 될 수 있습니다.

키가 아닌 일부 열 값으로 행을 찾으려면 해당 열에 보조 인덱스를 정의합니다. 그렇지 않은 경우, 데이터베이스 서버는 테이블 검색을 수행해야 합니다. 즉, 일치하는 열 값을 찾기 위해 모든 행을 무차별적으로 검색합니다.

테이블은 외부 키를 사용하여 서로 연관될 수 있으며 열 값은 이러한 키에 변형될 수 있습니다.

SQL

SQL은 API나 프로토콜이 아니라 선언적 언어입니다. 어떻게 하느냐 보다는 원하는 것을 말합니다. 이것은 관계형 데이터베이스의 보편적인 언어입니다. SQL 쿼리는 클라이언트가 데이터베이스 서버로 보내는 텍스트 문자열로, 이 문자열로 수행할 작업을 결정합니다.

다양한 SQL 표준 정의가 존재했지만, 모든 데이터베이스 공급업체는 자체적인 수정과 확장을 추가하여 많은 SQL 방언들을 만들어냈다. 데이터를 관계형 데이터베이스에 저장하면 SQL이 어느 정도 휴대성을 제공합니다. 그러나 방언 및 운영상의 차이로 인해 데이터를 다른 유형의 데이터베이스로 이동하기가 어려울 수 있습니다.

SQL 문에는 두 가지 주요 범주가 있습니다.

DDL(데이터 정의 언어)

테이블, 데이터베이스 및 사용에 대한 작성, 삭제, 제약 조건 및 사용 권한 처리

DML(데이터 조작 언어)

데이터 삽입, 선택, 업데이트 및 삭제 처리 표 8-1은 기본 SQL DDL 명령을 나열합니다.

표 8-1. 기본 SQL DDL 명령

Operation

Create a database
Select current database
Delete a database and its tables Create a table
Delete a table
Remove all rows from a table

SQL pattern

CREATE DATABASE dbname
USE dbname
DROP DATABASE dbname CREATE TABLE tbname ( coldefs ) DROP TABLE tbname

TRUNCATE TABLE tbname

SQL example

CREATE DATABASE d
USE d
DROP DATABASE d
CREATE TABLE t (id INT, count INT) DROP TABLE t

TRUNCATE TABLE t

왜 대문자는 다 쓰죠? SQL은 대소문자를 구분하지 않지만 코드 검사에서 키워드를 SHOUT하는 것이 전통입니다. 열 이름과 구별하기 위해 사용합니다.

관계형 데이터베이스의 주요 DML 작업은 흔히 CRUD 약어로 알려져 있습니다.

• SQL INSERT 문을 사용하여 작성

• SELECT를 사용하여 읽기

• UPDATE를 사용하여 업데이트

• DELETE를 사용하여 삭제

표 8-2는 SQL DML에 사용할 수 있는 명령을 살펴본다. 표 8-2. 기본 SQL DML 명령

Operation

Add a row

Select all rows and columns Select all rows, some columns

Select some rows, some columns

Change some rows in a column Delete some rows

SQL pattern

INSERT INTO tbname VALUES( ...)

SELECT * FROM tbname SELECT cols FROM tbname

SELECT cols FROM tbname WHERE condition

UPDATE tbname SET col = value WHERE condition

DELETE FROM tbname WHERE condition

SQL example

INSERT INTO t VALUES(7, 40)

SELECT * FROM t
SELECT id, count FROM t

SELECT id, count from t WHERE count > 5 AND id = 9

UPDATE t SET count=3 WHERE id=5

DELETE FROM t WHERE count <= 10 OR id = 16

파이썬코드 xml

&$#@ — Sat, 2 Oct 2021 20:07:35 +0900

XML

구분된 파일은 행(줄)과 열(줄 안의 필드)의 두 차원만 전달합니다. 프로그램 간에 데이터 구조를 교환하려면 계층, 시퀀스, 세트 및 기타 구조를 텍스트로 인코딩하는 방법이 필요합니다.

XML은 법안에 가장 적합한 마크업 형식이다. 이 샘플 menu.xml 파일에서와 같이 태그를 사용하여 데이터를 구분합니다.

<?xml version="1.0"?>
<menu>
<breakfast hours="7-11">
<item price="$6.00">breakfast burritos</item>
<item price="$4.00">pancakes</item>

</breakfast>

<item price="$5.00">hamburger</item>

</lunch>

<item price="8.00">spaghetti</item>

</dinner>

</menu>

다음은 XML의 몇 가지 중요한 특성입니다.

• 태그는 < 문자로 시작합니다. 이 샘플의 태그는 메뉴, 아침, 점심, 그리고

디너와 아이템.

• 공백은 무시됩니다.

• 일반적으로 <메뉴>와 같은 시작 태그 다음에 다른 내용이 나온 다음 </menu>와 같은 최종 일치 끝 태그가 뒤따른다.

• 태그는 모든 수준으로 다른 태그에 중첩될 수 있습니다. 이 예에서 항목 태그는 아침, 점심 및 저녁 태그의 하위 항목이며, 차례로 메뉴의 하위 항목입니다.

• 시작 태그 내에서 선택적 속성이 발생할 수 있습니다. 이 예에서 가격은 품목의 속성입니다.

• 태그에는 값이 포함될 수 있습니다. 이 예제에서는 두 번째 아침 식사용 팬케이크와 같은 값이 각 품목에 있습니다.

• 어떤 물건에 값이나 자식 태그가 없는 경우, 그것은 <thing>과 같이 시작 태그와 끝 태그가 아닌 <thing/>와 같은 닫힘 각도 괄호 바로 앞에 슬래시를 포함시켜 단일 태그로 표현할 수 있다.

• 데이터를 저장할 위치(속성, 가치, 하위 태그)를 선택하는 것은 다소 어렵다. 예를 들어, 마지막 항목 태그를 <품목 가격="$8.00" 식품="food"/">으로 작성할 수 있었다.

XML은 종종 데이터 피드 및 메시지에 사용되며 RSS 및 Atom과 같은 보조 형식을 가집니다. 일부 산업에는 재무 분야와 같은 많은 전문 XML 형식이 있습니다.

XML의 위버 유연성은 접근 방식과 기능이 다른 여러 파이썬 라이브러리에 영감을 주었습니다.

파이썬에서 XML을 구문 분석하는 가장 간단한 방법은 ElementTree를 사용하는 것입니다. 다음은 menu.xml 파일을 구문 분석하고 태그와 속성을 인쇄하는 데 사용할 수 있는 작은 프로그램입니다.

>>> import xml.etree.ElementTree as et
>>> tree = et.ElementTree(file='menu.xml')
>>> root = tree.getroot()
>>> root.tag
'menu'
>>> for child in root:
... print('tag:', child.tag, 'attributes:', child.attrib)

... for grandchild in child:
... print('\ttag:', grandchild.tag, 'attributes:', grandchild.attrib) ...
tag: breakfast attributes: {'hours': '7-11'}

tag: item attributes: {'price': '$6.00'}

tag: item attributes: {'price': '$4.00'}

tag: lunch attributes: {'hours': '11-3'}

tag: item attributes: {'price': '$5.00'}

tag: dinner attributes: {'hours': '3-10'}

tag: item attributes: {'price': '8.00'} >>> len(root) # number of menu sections 3
>>> len(root[0]) # number of breakfast items 2

중첩 목록의 각 요소에 대해 태그는 태그 문자열이고 속성은 해당 특성의 사전입니다. 원소트리는 XML에서 파생된 데이터를 검색하고, 데이터를 mod if ifing하고, XML 파일을 쓰는 다른 많은 방법을 가지고 있습니다. 원소트리 설명서에 자세한 내용이 있습니다.

다른 표준 파이썬 XML 라이브러리는 다음을 포함한다:

xml.dom

JavaScript 개발자에게 익숙한 DOM(Document Object Model)은 웹 문서를 계층 구조로 나타냅니다. 이 모듈은 전체 XML 파일을 메모리에 로드하고 모든 항목에 동일하게 액세스할 수 있도록 합니다.

xml.sax

XML용 단순 API 또는 SAX는 XML을 즉시 구문 분석하므로 모든 것을 한 번에 메모리에 로드할 필요가 없습니다. 따라서 매우 큰 XML 스트림을 처리해야 하는 경우 이 방법을 선택하는 것이 좋습니다.

HTML

엄청난 양의 데이터가 웹의 기본 문서 형식인 HTML(Hypertext Markup Language)로 저장된다. 문제는 HTML 규칙을 따르지 않는 경우가 너무 많아서 구문 분석하기가 어려울 수 있다는 것입니다. 또한 HTML의 대부분은 데이터를 교환하기 보다는 출력을 포맷하기 위한 것이다. 이 장은 꽤 잘 정의된 데이터 형식을 설명하기 위한 것이기 때문에 HTML에 대한 논의를 다음포스팅에서 분리했습니다.

JSON

자바스크립트 객체 표기법(JSON)은 그것의 자바스크립트 기원을 넘어 매우 대중적인 데이터 교환 형식이 되었다. JSON 형식은 자바스크립트의 하위 집합이며 종종 합법적인 파이썬 구문이기도 하다. Python에 매우 적합하기 때문에 프로그램 간의 데이터 교환에 적합합니다. 웹 개발을 위한 JSON의 예는 다음포스팅에서 많이 볼 수 있습니다.

XML 모듈의 다양성과 달리 JSON 모듈은 단 하나이며, gettable 이름은 json입니다. 이 프로그램은 데이터를 JSON 문자열로 인코딩(덤프)하고 JSON 문자열을 데이터로 다시 디코딩(로드)합니다. 다음 예에서는 이전 XML 예제의 데이터를 포함하는 파이썬 데이터 스트럭 튜어를 구축해 보겠습니다.

>>>menu=\
... {
... "breakfast": {

...

... "lunch" : {

...

... "dinner": {

...

... }

"hours": "7-11",

"items": {

"breakfast burritos": "$6.00",

"pancakes": "$4.00"

}

"hours": "11-3",

"items": {

"hamburger": "$5.00"

"hours": "3-10",

"items": {

"spaghetti": "$8.00"

} }

그런 다음 덤프()를 사용하여 데이터 구조(메뉴)를 JSON 문자열(메뉴_json)로 인코딩합니다.

>>> import json
>>> menu_json = json.dumps(menu)
>>> menu_json
'{"dinner": {"items": {"spaghetti": "$8.00"}, "hours": "3-10"}, "lunch": {"items": {"hamburger": "$5.00"}, "hours": "11-3"}, "breakfast": {"items": {"breakfast burritos": "$6.00", "pancakes": "$4.00"}, "hours": "7-11"}}'

이제 로드()를 사용하여 JSON 문자열 메뉴_json을 파이썬 데이터 구조(메뉴2)로 다시 전환해 보겠습니다.

>>> menu2 = json.loads(menu_json)

>>> menu2

{'breakfast': {'items': {'breakfast burritos': '$6.00', 'pancakes':

'$4.00'}, 'hours': '7-11'}, 'lunch': {'items': {'hamburger': '$5.00'},

'hours': '11-3'}, 'dinner': {'items': {'spaghetti': '$8.00'}, 'hours': '3-10'}}

menu와 menu2는 둘 다 키와 값이 같은 사전입니다. 표준 사전에서 항상 그렇듯이 키를 받는 순서도 다릅니다.

여기에 설명된 대로 날짜/시간( 다음포스팅의 "달력 및 시계"에 자세히 나와 있음)과 같은 개체를 포함하여 일부 개체를 인코딩하거나 디코딩하는 동안 예외가 발생할 수 있습니다.

>>> import datetime
>>> now = datetime.datetime.utcnow()
>>> now
datetime.datetime(2013, 2, 22, 3, 49, 27, 483336)
>>> json.dumps(now)
Traceback (most recent call last):
# ... (deleted stack trace to save trees)
TypeError: datetime.datetime(2013, 2, 22, 3, 49, 27, 483336) is not JSON serializable

이 문제는 JSON 표준에서 날짜 또는 시간 유형을 정의하지 않기 때문에 발생할 수 있습니다. 사용자가 날짜 또는 시간 유형을 처리하는 방법을 정의해야 합니다. 날짜 시간을 문자열 또는 epoch 값과 같이 JSON이 이해하는 것으로 변환할 수 있습니다(다음포스팅에 나와 있습니다).

>>> now_str = str(now)
>>> json.dumps(now_str)
'"2013-02-22 03:49:27.483336"'
>>> from time import mktime
>>> now_epoch = int(mktime(now.timetuple())) >>> json.dumps(now_epoch)
'1361526567'

날짜/시간 값이 정상적으로 변환된 데이터 유형 중간에 발생할 수 있는 경우 이러한 특수 변환을 수행하는 것이 귀찮을 수 있습니다. 상속을 사용하여 JSON 인코딩 방법을 수정할 수 있습니다. 상속은 다음포스팅의 "상속"에 설명되어 있습니다. 파이썬의 JSON 설명서는 JSON을 데드 플레이하게 만드는 복잡한 숫자에 대한 예를 제공한다. 날짜/시간에 맞게 수정해 보겠습니다.

>>> class DTEncoder(json.JSONEncoder):

>>> json.dumps(now, cls=DTEncoder)

'1361526567'

def default(self, obj):
# isinstance() checks the type of obj if isinstance(obj, datetime.datetime):

return int(mktime(obj.timetuple()))
# else it's something the normal decoder knows: return json.JSONEncoder.default(self, obj)

...

>>> json.dumps(now, cls=DTEncoder)

'1361526567'

새 클래스 DTENCoder는 JSONENCoder의 하위 클래스 또는 하위 클래스입니다. 날짜 시간 처리를 추가하려면 기본() 메서드를 재정의하기만 하면 됩니다. 상속을 수행하면 다른 모든 항목이 상위 클래스에서 처리됩니다.

isinstance() 함수는 개체 obj가 datetime.da time 클래스인지 확인합니다. Python의 모든 것은 개체이므로 isinstance()는 어디에서나 작동합니다.

>>> type(now)
<class 'datetime.datetime'>
>>> isinstance(now, datetime.datetime) True
>>> type(234)
<class 'int'>
>>> isinstance(234, int)
True
>>> type('hey')
<class 'str'>
>>> isinstance('hey', str)
True

JSON 및 기타 구조화된 텍스트 형식의 경우 미리 구조에 대해 아무것도 알지 못한 상태에서 파일에서 데이터 구조로 로드할 수 있습니다. 그런 다음 isinstance() 및 type에 적합한 방법을 사용하여 구조를 살펴볼 수 있습니다. 예를 들어 항목 중 하나가 사전인 경우 키(), 값() 및 항목()을 통해 내용을 추출할 수 있습니다.

YAML

JSON과 마찬가지로 YAML에는 키와 값이 있지만 날짜 및 시간과 같은 더 많은 데이터 유형을 처리합니다. 표준 파이썬 라이브러리에는 아직 YAML 처리가 포함되어 있지 않으므로, YAML이라는 이름의 타사 라이브러리를 설치해야 합니다. load()는 YAML 문자열을 파이썬 데이터로 변환하지만 dump()는 반대로 변환합니다.

다음 YAML 파일인 mcintyre.yaml에는 캐나다 시인 제임스 맥킨타이어에 대한 정보가 들어 있습니다.

name:

first: James

last: McIntyre

dates:

birth: 1828-05-25

death: 1906-03-31

details:

bearded: true

themes: [cheese, Canada]

books:

url: http://www.gutenberg.org/files/36068/36068-h/36068-h.htm

poems:

- title: 'Motto'

text: |
Politeness, perseverance and pluck,
To their possessor will bring good luck.

- title: 'Canadian Charms'

text: |

Here industry is not in vain,
For we have bounteous crops of grain,

And you behold on every field
Of grass and roots abundant yield, But after all the greatest charm
Is the snug home upon the farm,
And stone walls now keep cattle warm.

true, false, on 및 off와 같은 값은 Python Booans로 변환됩니다. 정수와 문자열은 파이썬 등가물로 변환됩니다. 다른 구문은 목록 및 사전 목록을 만듭니다.

>>> import yaml
>>> with open('mcintyre.yaml', 'rt') as fin:
>>> text = fin.read()
>>> data = yaml.load(text)
>>> data['details']
{'themes': ['cheese', 'Canada'], 'bearded': True} >>> len(data['poems'])
2

생성된 데이터 구조는 YAML 파일의 구조와 일치합니다. 이 경우에는 한 단계 이상의 깊이가 있는 위치입니다. 다음 받아쓰기/목록/독재 참조와 함께 두 번째 시의 제목을 얻을 수 있습니다.

>>> data['poems'][1]['title']

'Canadian Charms'

PyYAML은 문자열에서 Python 개체를 로드할 수 있으며 이는 위험합니다. 신뢰하지 않는 YAML을 가져오는 경우 load() 대신 safe_load()를 사용합니다. 항상 safe_load()를 사용하는 것이 좋습니다. 읽기 전쟁은 Ruby on Rails 플랫폼을 어떻게 조작했는지에 대한 설명을 위한 평화입니다.

보안 노트

이 장에 설명된 모든 형식을 사용하여 객체를 파일에 저장한 후 다시 읽을 수 있습니다. 이 프로세스를 악용하여 보안 문제를 일으킬 수 있습니다.

예를 들어, 위키피디아의 10억 likes 페이지에서 다음 XML 조각은 10개의 중첩된 엔터티를 정의하며, 각각 하위 수준을 10배 확장하여 총 10억 개의 확장을 수행합니다.

<?xml version="1.0"?>

<!DOCTYPE lolz [

<!ENTITY lol "lol">

<!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">

<!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">

<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">

<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">

<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">

<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">

<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">

<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">

<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">

나쁜 소식은: 10억 번의 웃음이 이전 섹션에서 언급된 모든 XML 라이브러리를 날려버릴 것이라는 것이다. 해제된 XML은 이 공격 및 기타 공격과 파이썬 라이브러리의 취약성을 나열합니다. 링크에는 이러한 문제를 방지하기 위해 여러 라이브러리에 대한 설정을 변경하는 방법이 나와 있습니다. 또한 disusedxml 라이브러리를 다른 라이브러리의 보안 프런트엔드로 사용할 수 있습니다.

>>> # insecure:
>>> from xml.etree.ElementTree import parse >>> et = parse(xmlfile)
>>> # protected:
>>> from defusedxml.ElementTree import parse >>> et = parse(xmlfile)

구성 파일

대부분의 프로그램은 다양한 옵션 또는 설정을 제공합니다. 역동적인 것은 그램의 주장으로 제공될 수 있지만, 오래 지속되는 것은 어딘가에 보관될 필요가 있다. 빠르고 더러운 구성 파일 형식을 정의하려는 유혹이 강하지만 저항합니다. 그것은 종종 더러워지지만 그렇게 빠르지는 않다. 작성자 프로그램과 독서자 프로그램(파서라고도 함)을 모두 유지해야 합니다. 이전 섹션에 있는 것을 포함하여 프로그램에 참여할 수 있는 좋은 대안이 있습니다.

여기서는 Windows 스타일의 .ini 파일을 처리하는 표준 구성 파서 모듈을 사용합니다. 이러한 파일에는 키 = 값 정의 섹션이 있습니다. 다음은 최소 설정.cfg 파일입니다.

[english]

greeting = Hello

[french]

greeting = Bonjour

[files]
home = /usr/local
# simple interpolation: bin = %(home)s/bin

다음은 파이썬 데이터 구조로 읽는 코드입니다.

>>> import configparser
>>> cfg = configparser.ConfigParser()
>>> cfg.read('settings.cfg')
['settings.cfg']
>>> cfg
<configparser.ConfigParser object at 0x1006be4d0> >>> cfg['french']

<Section: french>

>>> cfg['french']['greeting']

'Bonjour'

>>> cfg['files']['bin']

'/usr/local/bin'

펑시어 보간법을 포함한 다른 옵션을 사용할 수 있습니다. 구성 도구 문서를 참조하십시오. 두 수준보다 깊은 내포가 필요한 경우 YAML 또는 JSON을 사용해 보십시오.

기타 교환 형식

이러한 이진 데이터 교환 형식은 일반적으로 XML이나 JSON보다 더 작고 빠릅니다.

• MsgPack
• Protocol Buffers

• Avro
• Thrift

이진수이기 때문에 텍스트 편집기를 사용하는 사람이 쉽게 편집할 수 있는 것은 없습니다.

파이썬코드쓰기()를 사용하여 이진 파일 쓰기

&$#@ — Fri, 1 Oct 2021 22:06:55 +0900

모든 문자열에 'b'를 포함하면 파일이 이진 모드로 열립니다. 이 경우 문자열 대신 바이트를 읽고 씁니다.

이진 시가 없기 때문에 0에서 255까지의 256바이트 값만 생성합니다.

>>> bdata = bytes(range(0, 256))

>>> len(bdata)

256

이진 모드에서 쓰기 위한 파일을 열고 모든 데이터를 한 번에 씁니다.

>>> fout = open('bfile', 'wb')

>>> fout.write(bdata)

256

>>> fout.close()

다시 쓰기()는 기록된 바이트 수를 반환합니다. 텍스트와 마찬가지로 이진 데이터를 청크로 쓸 수 있습니다.

>>> fout = open('bfile', 'wb')

>>> size = len(bdata)

>>> offset = 0

>>> chunk = 100

>>> while True:
... if offset > size:
... break
... fout.write(bdata[offset:offset+chunk]) ... offset += chunk
...
100
100
56
>>> fout.close()

읽기()를 사용하여 이진 파일 읽기

이 방법은 간단합니다. 'rb'로 열기만 하면 됩니다.

>>> fin = open('bfile', 'rb')

>>> bdata = fin.read()

>>> len(bdata)

256

>>> fin.close()

Close Files Automatically by Using with

열어본 파일을 닫지 않은 경우 더 이상 참조되지 않은 후 파이썬에 의해 닫힙니다. 즉, 함수 내에서 파일을 열고 명시적으로 닫지 않으면 함수가 종료될 때 파일이 자동으로 닫힙니다. 그러나 장기간 실행되는 기능이나 프로그램의 기본 섹션에서 파일을 열었을 수 있습니다. 나머지 쓰기를 강제로 완료하려면 파일을 닫아야 합니다.

파이썬에는 열린 파일과 같은 것들을 정리할 수 있는 컨텍스트 관리자가 있습니다. 식을 변수로 사용하여 양식을 사용할 수식입니다.

>>> with open('relativity', 'wt') as fout: ... fout.write(poem)
...

바로 그거예요. 컨텍스트 관리자 아래의 코드 블록(이 경우, 한 줄)이 완료된 후(일반적으로 또는 상향된 예외에 의해) 파일은 자동으로 닫힙니다.

탐색()으로 위치 변경

읽고 쓸 때 파이썬은 파일 내의 위치를 추적합니다. tell() 함수는 파일 시작 부분의 현재 오프셋(바이트)을 반환합니다. seek() 기능을 사용하여 파일의 다른 바이트 오프셋으로 이동할 수 있습니다. 즉, 마지막 바이트를 읽기 위해 파일의 모든 바이트를 읽을 필요는 없습니다. 마지막 바이트까지 찾고 1바이트만 읽을 수 있습니다.

이 예에서는 앞에서 작성한 256바이트 이진 파일 'bfile'을 사용합니다.

>>> fin = open('bfile', 'rb')

>>> fin.tell()

파일이 끝나기 전에 seek()를 1바이트까지 사용합니다.

>>> fin.seek(255)

255

파일 끝까지 읽기:

>>> bdata = fin.read()

>>> len(bdata)

>>> bdata[0]

255

seek()는 현재 오프셋도 반환합니다.

두 번째 인수를 사용하여 seek()를 호출할 수 있습니다. seek(오프셋, 오리진):

• 오리진이 0(기본값)이면 처음부터 오프셋 바이트로 이동합니다.

• 발신지가 1인 경우 현재 위치에서 오프셋 바이트로 이동

• 원본이 2인 경우, 끝 부분에 상대적인 오프셋 바이트로 이동합니다.

다음 값은 표준 OS 모듈에도 정의되어 있습니다.

>>> import os >>> os.SEEK_SET 0
>>> os.SEEK_CUR 1
>>> os.SEEK_END
2

마지막 바이트는 다른 방식으로 읽을 수 있었습니다.

>>> fin = open('bfile', 'rb')

파일 종료 전 1바이트:

>>> fin.seek(-1, 2)

255

>>> fin.tell()

255

파일 끝까지 읽기:

>>> bdata = fin.read()

>>> len(bdata)

>>> bdata[0]

255

구직 활동을 위해 tell을 부를 필요는 없다. 나는 단지 그들이 둘 다 같은 오프셋을 보고한다는 것을 보여주고 싶었다.

다음은 파일의 현재 위치에서 찾는 예제입니다.

>>> fin = open('bfile', 'rb')

이 다음 예는 파일이 끝나기 전에 2바이트가 됩니다.

>>> fin.seek(254, 0)

254

>>> fin.tell()

254

이제 1바이트 앞으로 이동합니다.

>>> fin.seek(1, 1)

255

>>> fin.tell()

255

마지막으로 파일 끝까지 읽습니다.

>>> bdata = fin.read()

>>> len(bdata)

>>> bdata[0]

255

이러한 함수는 이진 파일에 가장 유용합니다. 텍스트 파일과 함께 사용할 수 있지만, 파일이 ASCII(문자당 1바이트)가 아니면 오프셋을 계산하는 데 어려움이 있을 수 있습니다. 이는 텍스트 인코딩에 따라 달라지며 가장 널리 사용되는 인코딩(UTF-8)은 문자당 바이트 수를 다르게 사용합니다.

구조화된 텍스트 파일

단순 텍스트 파일의 경우 구성 수준은 줄뿐입니다. 때때로, 여러분은 그것보다 더 많은 구조를 원합니다. 프로그램에서 나중에 사용할 수 있도록 데이터를 저장하거나 다른 프로그램으로 데이터를 보낼 수 있습니다.

형식은 여러 가지가 있으며, 다음과 같이 구분할 수 있습니다.

• 탭('\t', 쉼표(',), 세로 막대 등의 구분 기호 또는 구분 기호

('|') CSV(쉼표로 구분된 값) 형식의 예입니다.

• 태그 주위에 '' 및 '''가 있습니다. 예를 들어 XML 및 HTML을 들 수 있습니다.

• 구두점. 예를 들어 자바스크립트 객체 표기법(JSON)이 있습니다.

• 들여쓰기. 예를 들어 YAML이 있습니다. 사용하는 출처에 따라 "YAML은 마크업 언어가 아닙니다. 직접 연구해야 합니다.

• 프로그램 구성 파일과 같은 기타.

이러한 각각의 구조화된 파일 형식은 하나 이상의 파이썬 모듈로 읽고 쓸 수 있다.

CSV

구분된 파일은 종종 스프레드시트 및 데이터베이스의 교환 형식으로 사용됩니다. CSV 파일을 한 번에 한 줄씩 수동으로 읽고 각 줄을 쉼표 구분 기호로 필드로 분할한 다음 목록 및 사전 양자와 같은 데이터 구조에 결과를 추가할 수 있습니다. 그러나 표준 csv 모듈을 사용하는 것이 좋습니다. 이러한 파일을 구문 분석하는 작업은 생각보다 복잡해질 수 있습니다.

• 쉼표 외에 다른 구분 기호를 사용하는 경우도 있습니다. '|' 및 '\t'(탭)가 일반적입니다.

• 일부는 이스케이프 시퀀스가 있습니다. 구분 기호 문자가 필드 내에서 발생할 수 있는 경우 전체 필드에는 따옴표 문자가 있거나 일부 이스케이프 문자가 앞에 있을 수 있습니다.

• 파일의 줄 끝 문자가 다릅니다. Unix는 '\n', Microsoft는 '\r \n', Apple은 '\r'을 사용했지만 지금은 '\n'을 사용합니다.

• 첫 줄에 열 이름이 있을 수 있습니다.

먼저, 각 행에 열 목록이 포함된 행 목록을 읽고 쓰는 방법에 대해 알아보겠습니다.

>>> import csv >>> villains = [

... ['Ernst', 'Blofeld'],
... ]
>>> with open('villains', 'wt') as fout: # a context manager ... csvout = csv.writer(fout)
... csvout.writerows(villains)

그러면 다음과 같은 행으로 파일 악당이 생성됩니다.

Doctor,No

Rosa,Klebb

Mister,Big

Auric,Goldfinger

Ernst,Blofeld

이제 다시 읽어보겠습니다.

>>> import csv
>>> with open('villains', 'rt') as fin: # context manager

... cin = csv.reader(fin)
... villains = [row for row in cin] # This uses a list comprehension ...
>>> print(villains)
[['Doctor', 'No'], ['Rosa', 'Klebb'], ['Mister', 'Big'],
['Auric', 'Goldfinger'], ['Ernst', 'Blofeld']]

잠시 목록 이해에 대해 생각해 보십시오. 우리는 리더() 함수에 의해 만들어진 구조를 이용했다. cin 객체에 행을 생성해 루프를 위해 a에서 추출할 수 있습니다.

기본 선택사항과 함께 독서자() 및 작성기()를 사용하여 열은 쉼표로 구분되고 행은 행 피드로 구분됩니다.

데이터는 목록 목록이 아닌 사전 목록일 수 있습니다. 이번에는 새 DictReader() 함수를 사용하여 다음과 같은 열 이름을 지정하여 악당 파일을 다시 읽어보겠습니다.

>>> import csv
>>> with open('villains', 'rt') as fin:

새로운 DictWriter() 함수를 사용하여 CSV 파일을 다시 쓰겠습니다. 또한 CSV 파일에 열 이름의 초기 줄을 쓰기 위해 쓰기 헤더()를 호출합니다.

import csv villains = [

{'first': 'Doctor', 'last': 'No'},

{'first': 'Rosa', 'last': 'Klebb'},

{'first': 'Mister', 'last': 'Big'},

{'first': 'Auric', 'last': 'Goldfinger'},

{'first': 'Ernst', 'last': 'Blofeld'},

]
with open('villains', 'wt') as fout:

cout = csv.DictWriter(fout, ['first', 'last'])

cout.writeheader()

cout.writerows(villains)

그러면 머리글 줄이 있는 악당 파일이 생성됩니다.

first,last

Doctor,No

Rosa,Klebb

Mister,Big

Auric,Goldfinger

Ernst,Blofeld

이제 다시 읽어보겠습니다. DictReader() 호출에서 필드 이름 인수를 생략하여 파일의 첫 줄(첫 번째, 마지막)에 있는 값을 열 레이블 및 일치하는 사전 키로 사용하도록 지시합니다.

>>> import csv
>>> with open('villains', 'rt') as fin:

... cin = csv.DictReader(fin)
... villains = [row for row in cin] ...>>> print(villains)[{'last': 'No', 'first': 'Doctor'}, {'last': 'Klebb', 'first': 'Rosa'}, {'last': 'Big', 'first': 'Mister'}, {'last': 'Goldfinger', 'first': 'Auric'}, {'last': 'Blofeld', 'first': 'Ernst'}]

파이썬코딩 데이터 저장위치

&$#@ — Fri, 1 Oct 2021 00:41:17 +0900

활성 프로그램은 RAM에 저장된 데이터에 액세스합니다. RAM은 매우 빠르지만 비용이 많이 들고 일정한 전원 공급이 필요합니다. 전원이 꺼지면 메모리의 모든 데이터가 손실됩니다. 디스크 드라이브는 RAM보다 느리지만 용량, 비용 및 전원 코드를 통해 작동한 후에도 데이터를 보존합니다. 따라서, 컴퓨터 시스템에서 엄청난 양의 노력이 디스크와 RAM에 데이터를 저장하는 것 사이에서 최상의 절충을 이루는데 투입되었습니다. 프로그래머로서 디스크와 같은 비휘발성 미디어를 사용하여 데이터를 저장하고 검색하는 지속성이 필요합니다.

이 장에서는 플랫 파일, 구조화된 파일 및 데이터베이스 등 각각 다른 용도에 맞게 최적화된 다양한 유형의 데이터 스토리지에 대해 설명합니다. 입력 및 출력 이외의 파일 작업은 다음내용의 "파일"에서 다룹니다.

또한 이 장에서는 표준 라이브러리와는 별도로 비표준 파이썬 모듈의 예를 보여 주는 첫 번째 장이기도 하다. pip 명령을 사용하여 설치할 수 있습니다. 이 명령은 통증이 없습니다.

File Input/Output

가장 간단한 종류의 지속성은 플랫 파일이라고도 하는 일반 오래된 파일입니다. 이것은 파일 이름 아래에 저장된 일련의 바이트입니다. 파일에서 메모리로 읽고 메모리에서 파일로 씁니다. 파이썬은 이러한 작업을 쉽게 합니다. 그것의 파일 운영은 친숙하고 대중적인 유닉스 계열들을 모델로 했다.

파일을 읽거나 쓰기 전에 파일을 열어야 합니다.

fileobj = open( filename, mode )

다음은 상담 내용에 대한 간단한 설명입니다.

• fileobj는 open()에 의해 반환되는 파일 개체입니다.

• 파일 이름은 파일의 문자열 이름입니다.

• 모드는 파일 형식과 파일로 수행할 작업을 나타내는 문자열입니다.

모드의 첫 번째 문자는 작동을 나타냅니다.

• r은 읽음을 의미한다.

• 쓰는 것을 의미합니다. 파일이 없으면 파일이 만들어집니다. 파일이 있으면 덮어씁니다.

• x는 쓰기(write)를 의미하지만, 파일이 아직 존재하지 않는 경우에만 해당됩니다.

• 파일이 있는 경우 추가(종료 후 쓰기)를 의미합니다.

모드의 두 번째 문자는 파일 형식입니다.

• t(또는 없음)는 텍스트를 의미한다.

• b는 이진수를 의미한다.

파일을 연 후, 당신은 데이터를 읽거나 쓰기 위해 함수를 호출합니다; 이것들은 다음과 같이 표시됩니다.

다음의 예들

마지막으로 파일을 닫아야 합니다.

한 프로그램에서 파이썬 문자열로 파일을 만든 다음 다음 다시 읽어 봅시다.

Write a Text File with write()

어떤 이유에선지, 특수 상대성 이론에 대한 리머릭은 많지 않다. 이것은 우리의 데이터 소스에 대한 것입니다.

>>> poem = '''There was a young lady named Bright,
... Whose speed was far faster than light;
... She started one day
... In a relative way,
... And returned on the previous night.'''
>>> len(poem)
150

다음 코드는 한 번의 통화로 전체 시를 '상대성' 파일에 기록합니다.

>>> fout = open('relativity', 'wt')
>>> fout.write(poem)
150
>>> fout.close()

쓰기() 함수는 기록된 바이트 수를 반환합니다. 인쇄()와 같이 공백이나 새 줄을 추가하지 않습니다. 텍스트 파일로()를 인쇄할 수도 있습니다.

>>> fout = open('relativity', 'wt')

>>> print(poem, file=fout)
>>> fout.close()

이 경우 write()를 사용해야 합니까, print()를 사용해야 합니까?라는 질문이 나타납니다. 기본적으로 인쇄()는 각 인수 뒤에 공백을 추가하고 끝에 새 줄을 추가합니다. 앞의 예에서는 상대성 파일에 새로운 선을 추가했다. write()와 같이 인쇄하려면 다음 두 인수를 전달합니다.

• sep(기본값 공백 ' ')

• 끝(기본적으로 새 줄 '\n')

print()는 다른 항목을 통과하지 않는 한 기본값을 사용합니다. 일반적으로 인쇄물에 의해 추가되는 모든 까다로움을 억제하기 위해 빈 줄을 전달합니다.

>>> fout = open('relativity', 'wt')
>>> print(poem, file=fout, sep='', end='') >>> fout.close()

소스 문자열이 큰 경우 소스가 완료될 때까지 청크를 쓸 수도 있습니다.

>>> fout = open('relativity', 'wt')

>>> size = len(poem)

>>> offset = 0

>>> chunk = 100

>>> while True:
... if offset > size:
... break
... fout.write(poem[offset:offset+chunk]) ... offset += chunk
...
100
50
>>> fout.close()

이것은 첫 번째 시도에서 100자를 썼고 마지막 50자를 다음 시도에서 썼다.

상대성 파일이 중요한 경우 모드 x를 사용하면 덮어쓰기를 방지할 수 있는지 알아보겠습니다.

>>> fout = open('relativity', 'xt')

Traceback (most recent call last):

File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: 'relativity'

예외 핸들러와 함께 사용할 수 있습니다.

>>> try:
... fout = open('relativity', 'xt')]

... fout.write('stomp stomp stomp')
... except FileExistsError:
... print('relativity already exists!. That was a close one.') ...
relativity already exists!. That was a close one.

Read a Text File with read(), readline(), or readlines()

다음 예제와 같이 전체 파일을 한 번에 후루룩 마실 인수 없이 read()를 호출할 수 있습니다. 대용량 파일을 사용할 때 주의하십시오. 기가바이트 파일은 1기가바이트의 메모리를 소모합니다.

>>> fin = open('relativity', 'rt' )

>>> poem = fin.read()

>>> fin.close()

>>> len(poem)

150

한 번에 반환되는 읽기() 양을 제한하기 위해 최대 문자 수를 제공할 수 있습니다. 한 번에 100자를 읽고 각 조각을 시 문자열에 추가하여 원본을 재구성해 봅시다.

>>> poem = ''
>>> fin = open('relativity', 'rt' ) >>> chunk = 100
>>> while True:

... fragment = fin.read(chunk)
... if not fragment:
... break
... poem += fragment
...
>>> fin.close()
>>> len(poem)
150
After you’ve read all the way to the end, further calls to read() will return an empty string (''), which is treated as False in if not fragment. This breaks out of the while True loop.
You can also read the file a line at a time by using readline(). In this next example, we’ll append each line to the poem string to rebuild the original:
>>> poem = ''
>>> fin = open('relativity', 'rt' ) >>> chunk = 100
>>> while True:
... fragment = fin.read(chunk)
... if not fragment:
... break
... poem += fragment
...
>>> fin.close()
>>> len(poem)
150
끝까지 읽은 후에는 읽기()에 대한 추가 호출이 빈 문자열('')을 반환하며, 이 문자열은 조각이 아닌 경우 False로 처리됩니다. 이 경우 True 루프가 중단됩니다.
리드라인()을 사용하여 파일을 한 번에 한 줄씩 읽을 수도 있습니다. 다음 예에서는 각 줄을 시 문자열에 추가하여 원본을 재구성합니다.
>>> poem = ''
>>> fin = open('relativity', 'rt' ) >>> while True:
>>> len(poem)
150

텍스트 파일의 경우 빈 줄이라도 길이가 1(새 줄 문자)이며 참으로 평가됩니다. 파일을 읽으면 read()와 같은 readline()도 빈 문자열을 반환하며, 이 문자열도 False로 평가됩니다.

텍스트 파일을 읽는 가장 쉬운 방법은 반복기를 사용하는 것입니다. 그러면 한 번에 한 줄씩 반환됩니다. 앞의 예와 비슷하지만 코드가 더 적습니다.

>>> poem = ''
>>> fin = open('relativity', 'rt' ) >>> for line in fin:
... poem += line
...
>>> fin.close()
>>> len(poem)
150

위의 모든 예들은 결국 하나의 현악시를 만들었다. 읽기 행() 호출은 한 번에 한 줄을 읽고 한 줄 문자열 목록을 반환합니다.

>>> fin = open('relativity', 'rt' ) >>> lines = fin.readlines()
>>> fin.close()
>>> print(len(lines), 'lines read') 5 lines read

>>> for line in lines:
... print(line, end='')
...
There was a young lady named Bright, Whose speed was far faster than light; She started one day
In a relative way,
And returned on the previous night.>>>

처음 네 줄에는 이미 새 줄이 있었기 때문에 우리는 인쇄물에게 자동 새 줄이 생기지 않도록 했다. 마지막 줄은 그렇지 않아 마지막 줄 바로 뒤에 대화형 프롬프트 >>>가 발생하였습니다.

파이썬코딩 format binary data etc

&$#@ — Fri, 10 Sep 2021 08:01:56 +0900

Format

우리는 지금까지 텍스트 서식을 거의 무시해 왔다. 2장에는 몇 가지 문자열 정렬 기능이 나와 있으며 코드 예제는 간단한 인쇄() 문을 사용하거나 대화형 인터프리터가 값을 표시하도록 합니다. 하지만 이제는 다양한 형식을 사용하여 데이터 값을 문자열로 변환하는 방법, 즉 문자열 내부에 값을 넣는 방법에 대해 알아보아야 합니다. 이를 통해 보고서 및 기타 출력물을 생성할 수 있으며, 이를 위해 분배가 필요할 수 있습니다.

Python은 문자열을 포맷하는 두 가지 방법, 즉 느슨하게 옛날 스타일과 새로운 스타일이라고 불린다. 두 스타일 모두 Python 2 및 3에서 지원됩니다(Python 2.6 이상의 새로운 스타일). 구식이 더 간단하니까 거기서부터 시작하죠.

이전 스타일(% 포함)

이전 스타일의 문자열 형식에는 형식 문자열% 데이터가 있습니다. 문자열 내부에는 보간 시퀀스가 있습니다. 아래는 가장 간단한 시퀀스가 % 다음에 형식화할 데이터 유형을 나타내는 문자가 있음을 보여준다.

%s string
%d decimal integer
%x hex integer
%o octal integer
%f decimal float
%e exponential float
%g decimal or exponential float %% a literal%

다음은 몇 가지 간단한 예입니다. 첫째, 정수:

>>> '%s' % 42

'42'

>>> '%d' % 42

'42'

>>> '%x' % 42

'2a'

>>> '%o' % 42

'52'

플로트:

>>> '%s' % 7.03

'7.03'

>>> '%f' % 7.03

'7.030000'

>>> '%e' % 7.03

'7.030000e+00'

>>> '%g' % 7.03

'7.03'

정수 및 리터럴 %:

>>> '%d%%' % 100

'100%'

일부 문자열 및 정수 보간법:

>>> actor = 'Richard Gere'

>>> cat = 'Chester'

>>> weight = 28

>>> "My wife's favorite actor is %s" % actor

"My wife's favorite actor is Richard Gere"

>>> "Our cat %s weighs %s pounds" % (cat, weight)

'Our cat Chester weighs 28 pounds'

문자열 내부의 %s은 문자열을 보간한다는 의미입니다. 문자열에 나타나는 % 개수는 % 이후의 데이터 항목 개수와 일치합니다. 행위자와 같은 단일 데이터 항목은 % 바로 뒤에 있습니다. (cat, weight)와 같은 튜플(괄호로 묶고 쉼표로 구분)로 여러 데이터를 그룹화해야 합니다.

가중치가 정수임에도 불구하고 문자열 안에 있는 %s이(가) 문자열로 변환했습니다.
%와 형식 지정자 사이에 다른 값을 추가하여 최소값을 지정할 수 있습니다.

최대 너비, 정렬 및 문자 채우기:
변수의 경우 정수 n, 플로트 f 및 문자열 s를 정의하겠습니다.

>>>n=42 >>>f=7.03
>>> s = 'string cheese'

기본 너비를 사용하여 형식 지정:

>>>'%d%f%s'%(n,f,s) '42 7.030000 string cheese'

각 변수에 대해 최소 필드 너비를 10자로 설정하고 오른쪽에 정렬하여 왼쪽의 사용되지 않는 부분을 공백으로 채웁니다.

>>> '%10d %10f %10s' % (n, f, s)

' 42 7.030000 string cheese'

동일한 필드 너비를 사용하지만 왼쪽으로 정렬합니다.

>>> '%-10d %-10f %-10s' % (n, f, s)

'42 7.030000 string cheese'

이번에는 필드 너비는 같지만 최대 문자 너비는 4이고 오른쪽에 정렬됩니다. 이 설정을 사용하면 문자열이 잘리고 소수점 뒤의 부동자리가 4자리로 제한됩니다.

>>> '%10.4d %10.4f %10.4s' % (n, f, s)

' 0042 7.0300 stri'

이전과 동일하지만, 오른쪽 정렬:

>>> '%.4d %.4f %.4s' % (n, f, s)

'0042 7.0300 stri'

마지막으로, 인수에서 필드 너비를 하드 코딩하지 않고 가져옵니다.

>>> '%*.*d %*.*f %*.*s' % (10, 4, n, 10, 4, f, 10, 4, s)

' 0042 7.0300 stri'

New style formatting with {} and format

이전 스타일 형식은 여전히 지원됩니다. 버전 2.7에서 동결되는 파이썬 2에서는 영원히 지원될 것이다. 그러나 파이썬 3을 사용하는 경우에는 새로운 스타일 포맷이 권장됩니다.

가장 간단한 용법은 다음과 같습니다.

>>> '{} {} {}'.format(n, f, s)

'42 7.03 string cheese'

이전 형식의 인수는 해당 자리 표시자의 %가 문자열에 나타나는 순서로 제공되어야 합니다. 새 유형을 사용하여 순서를 지정할 수 있습니다.

>>> '{2} {0} {1}'.format(f, s, n)

'42 7.03 string cheese'

값 0은 첫 번째 인수인 f를 가리킨 반면, 1은 문자열 s를 가리켰고 2는 마지막 인수인 정수 n을 가리켰습니다.

인수는 사전 또는 명명된 인수일 수 있으며 지정자에는 다음과 같은 인수의 이름이 포함될 수 있습니다.

>>> '{n} {f} {s}'.format(n=42, f=7.03, s='string cheese')

'42 7.03 string cheese'

다음 예에서는 세 가지 값을 사전으로 결합해 보겠습니다. 다음과 같습니다.

>>> d = {'n': 42, 'f': 7.03, 's': 'string cheese'}

다음 예제에서 {0}은(는) 전체 사전이고 {1}은(는) 문자열 '기타'입니다.

사전 다음에 나오는 내용:

>>> '{0[n]} {0[f]} {0[s]} {1}'.format(d, 'other')

'42 7.03 string cheese other'

이 예들은 모두 기본 형식으로 인수를 인쇄했습니다. 이전 형식에서는 문자열의 % 뒤에 형식 지정자를 사용할 수 있지만 새 형식에서는 : 뒤에 붙입니다. 첫째, 위치 인수:

>>> '{0:d} {1:f} {2:s}'.format(n, f, s)

'42 7.030000 string cheese'

이 예에서는 동일한 값을 사용하지만 명명된 인수와 같습니다.

>>> '{n:d} {f:f} {s:s}'.format(n=42, f=7.03, s='string cheese')

'42 7.030000 string cheese'

다른 옵션(최소 필드 너비, 최대 문자 너비, 정렬 등)도 지원됩니다.

최소 필드 너비 10, 오른쪽 정렬(기본값):

>>> '{0:10d} {1:10f} {2:10s}'.format(n, f, s)

' 42 7.030000 string cheese'

앞의 예제와 동일하지만 > 문자는 오른쪽 정렬을 더 명확하게 만듭니다.

>>> '{0:>10d} {1:>10f} {2:>10s}'.format(n, f, s)

' 42 7.030000 string cheese'

최소 필드 폭 10, 왼쪽 정렬:

>>> '{0:<10d} {1:<10f} {2:<10s}'.format(n, f, s)

'42 7.030000 string cheese'

최소 필드 폭 10, 가운데:

>>> '{0:^10d} {1:^10f} {2:^10s}'.format(n, f, s)

' 42 7.030000 string cheese'

이전 스타일에서 한 가지 변경 사항이 있습니다. 즉, 소수점 뒤의 정밀도 값은 부동 소수점 뒤의 자릿수와 문자열의 최대 문자 수를 의미하지만 정수에 대해서는 사용할 수 없습니다.

>>> '{0:>10.4d} {1:>10.4f} {2:10.4s}'.format(n, f, s)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
ValueError: Precision not allowed in integer format specifier >>> '{0:>10d} {1:>10.4f} {2:>10.4s}'.format(n, f, s)
' 42 7.0300 stri'

마지막 옵션은 채우기 문자입니다. 공백이 아닌 다른 출력 필드를 채우려면 :, 정렬(<, >, ^) 또는 너비 지정 피어 바로 앞에 놓습니다.

>>> '{0:!^20s}'.format('BIG SALE')

'!!!!!!BIG SALE!!!!!!'

Match with Regular Expressions

이전포스팅에서는 간단한 문자열 연산에 대해 다루었다. 입문 정보로 무장한 여러분은 명령행에서 .py로 끝나는 모든 파일 이름을 나열하는 것을 의미하는 ls *.py와 같은 단순한 "와일드카드" 패턴을 사용해 본 적이 있을 것이다.

이제 정규식을 사용하여 더 복잡한 패턴 일치를 살펴볼 차례입니다. 이것들은 우리가 수입할 표준 모듈 re에 제공된다. 일치시킬 문자열 패턴과 일치시킬 소스 문자열을 정의합니다. 단순 일치의 경우 용도는 다음과 같습니다.

result = re.match('You', 'Young Frankenstein')

여기서 'You'가 패턴이고 'Young Frankenstein'이 그 근원이다. 즉, 당신이 만든 끈이다.

want to check. match()는 소스가 패턴으로 시작하는지 여부를 확인합니다.

더 복잡한 일치의 경우 먼저 패턴을 컴파일하여 일치 속도를 높일 수 있습니다.

나중에:

youpattern = re.compile('You')

그런 다음 컴파일된 패턴에 대해 일치를 수행할 수 있습니다.

result = youpattern.match('Young Frankenstein')

match()만이 패턴과 소스를 비교하는 유일한 방법은 아니다. 다음은 사용할 수 있는 몇 가지 다른 방법입니다.

• 검색 결과 첫 번째 일치 항목이 있는 경우 반환됩니다.

• findall은 모든 비반복 일치 항목(있는 경우) 목록을 반환합니다.

• 분할은 패턴과 일치할 때 소스를 분할하고 문자열 조각 목록을 반환합니다.

• 하위 항목에서는 다른 교체 인수를 사용하여 패턴별로 일치하는 소스의 모든 부분을 교체로 변경합니다.

Exact match with match()

'Young Frankenstein'이라는 문자열은 'You'라는 단어로 시작되나요? 설명과 함께 몇 가지 코드가 있습니다.

>>> import re
>>> source = 'Young Frankenstein'
>>> m = re.match('You', source) # match starts at the beginning of source >>> if m: # match returns an object; do this to see what matched
... print(m.group())
...
You
>>> m = re.match('^You', source) # start anchor does the same
>>> if m:
... print(m.group())
...
You

'프랭크'는 어때?

>>> m = re.match('Frank', source) >>> if m:
... print(m.group())
...

이번에는 일치하는()이 반환되지 않았고 if가 인쇄 문을 실행하지 않았습니다. 앞에서 말했듯이 패턴이 원본의 시작 부분에 있을 경우에만 일치()가 작동합니다. 그러나 패턴이 있는 경우 검색()이 작동합니다.

>>> m = re.search('Frank', source) >>> if m:
... print(m.group())
...

Frank

패턴을 변경해 보겠습니다.

>>> m = re.match('.*Frank', source) >>> if m: # match returns an object ... print(m.group())

...

Young Frank

패턴을 변경합니다.• .는 단일 문자를 의미합니다.

• *는 앞의 모든 것을 의미합니다. 합쳐서 .*는 임의의 수의 문자 행위자(심지어 0)를 의미합니다.

• Frank는 우리가 일치시키고자 했던 문구입니다. match()는 일치하는 문자열을 반환했습니다.프랭크: '젊은 프랭크'.

First match with search()

검색()을 사용하여 .* 와일드카드를 사용하지 않고도 소스 문자열 'Young Frankenstein'의 아무 곳에서나 'Frank' 패턴을 찾을 수 있습니다.

>>> m = re.search('Frank', source) >>> if m: # search returns an object ... print(m.group())
...
Frank

All matches with findall()

위의 예들은 한 가지 일치만 찾았다. 하지만 단일 문자 문자열 'n'의 인스턴스 수를 알고 싶다면 어떻게 해야 할까요?

>>> m = re.findall('n', source)
>>> m # findall returns a list ['n', 'n', 'n', 'n']
>>> print('Found', len(m), 'matches') Found 4 matches

'n' 뒤에 오는 글자는 어떤가?

>>> m = re.findall('n.', source)

>>> m

['ng', 'nk', 'ns']

그것이 최종 'n'과 일치하지 않는다는 것을 주목하라. 우리는 'n' 뒤에 오는 문자는 ?:의 옵션이라고 말할 필요가 있습니다.

>>> m = re.findall('n.?', source)

>>> m

['ng', 'nk', 'ns', 'n']

Split at matches with split()

다음 예제에서는 일반 문자열 분할() 메서드와 같이 단순 문자열이 아닌 패턴별로 목록으로 문자열을 분할하는 방법을 보여 줍니다.

>>> m = re.split('n', source)
>>> m # split returns a list ['You', 'g Fra', 'ke', 'stei', '']

Patterns: special characters

정규식에 대한 많은 설명은 정규식을 정의하는 방법에 대한 모든 세부 정보에서 시작됩니다. 그건 실수라고 생각해요. 정규 표현은 그 자체로 그리 작지 않은 언어이며, 여러분의 머릿속에 한번에 들어가기에는 너무 많은 세부 사항들을 가지고 있다. 그들은 너무 많은 펑크 표현을 써서 마치 만화 속 캐릭터들이 욕을 하는 것처럼 보인다.

벨트 아래에 있는 식(일치), 검색() 및 findall() 및 sub()을 사용하여 작성에 대한 세부 정보를 살펴보겠습니다. 사용자가 만든 패턴은 다음 함수에 적용됩니다.

기본 사항을 살펴보았습니다.

• 특수하지 않은 문자와 문자 그대로 일치

• 가 있는 \n을 제외한 모든 단일 문자.

• *가 포함된 임의의 숫자(0 포함)

• 선택 사항(0 또는 1)은?

첫째, 특수 문자는 아래에 나와 있습니다.

\d a single digit
\D a single non-digit
\w an alphanumeric character
\W a non-alphanumeric character
\s a whitespace character
\S a non-whitespace character
\b a word boundary (between a\wand a\W, in either order) \B a non-word boundary

파이썬 문자열 모듈에는 테스트에 사용할 수 있는 미리 정의된 문자열 상수가 있습니다. 인쇄 가능한 ASCII 문자(경우, 숫자, 공백 문자, 구두점 등): 100개의 인쇄 가능한 ASCII 문자를 사용합니다.

>>> import string
>>> printable = string.printable
>>> len(printable)
100
>>> printable[0:50] '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN'
>>> printable[50:] 'OPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

인쇄 가능한 문자는 어떤 것입니까?

>>> re.findall('\d', printable)

['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

숫자, 문자 또는 밑줄 문자는 무엇입니까?

>>> re.findall('\w', printable)

['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',

'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',

'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',

'Y', 'Z', '_']

공백은 무엇입니까?

>>> re.findall('\s', printable)
[' ', '\t', '\n', '\r', '\x0b', '\x0c']

정규식은 ASCII에만 국한되지 않습니다. \d는 단지 ASCII 문자 '0'에서 '9'까지가 아니라 유니코드가 숫자를 호출하는 것과 일치합니다. FileFormat.info에서 ASCII가 아닌 두 개의 소문자를 추가해 보겠습니다.

이 테스트에서는 다음을 포함시킵니다.

• 세 개의 ASCII 문자

• \w와 일치하지 않아야 하는 세 개의 구두점 기호

• 서클플렉스를 포함한 유니코드 라틴 소형 문자 E(\u00ea)

• BREVE가 포함된 유니코드 라틴 소형 문자 E(\u0115)

>>> x = 'abc' + '-/*' + '\u00ea' + '\u0115'

예상대로 이 패턴에는 다음과 같은 문자만 있습니다.

>>> re.findall('\w', x)
['a', 'b', 'c', 'ê', 'ĕ']

Patterns: using specifiers

이제 아래에 나와 있는 일반적인 ex press pressions의 주요 패턴 지정자를 사용하여 "punctionation pizza"를 만들어 봅시다.

표에서 expr 및 다른 기울임꼴 단어는 유효한 정규식을 의미합니다.

abc
(expr) expr1|expr2
.
^
$
prev?
prev*
prev *?
prev+
prev +? prev{m} prev{m, n} prev{m, n}? [abc] [^abc]
prev (?= next ) prev (?! next ) (?<=prev)next (?<!prev)next

literal abc
expr
expr1 or expr2
any character except \n start of source string end of source string zero or one prev

zero or more prev, as many as possible zero or more prev, as few as possible one or more prev, as many as possible one or more prev, as few as possible m consecutive prev

m to n consecutive prev, as many as possible m to n consecutive prev, as few as possible aorborc(same asa|b|c)
not (aorborc)

prev if followed by next prev if not followed by next next if preceded by prev next if not preceded by prev

이 예들을 읽으려고 할 때 여러분의 눈은 영구적으로 교차할 수 있습니다. 먼저 소스 문자열을 정의하겠습니다.

>>> source = '''I wish I may, I wish I might

... Have a dish of fish tonight.'''

첫째, 어디서든 소원을 찾으세요.

>>> re.findall('wish', source)

['wish', 'wish']

다음으로, 어디에서나 소원이나 물고기를 찾으세요.

>>> re.findall('wish|fish', source)

['wish', 'wish', 'fish']

시작 부분에서 소원을 찾으세요.

>>> re.findall('^wish', source)

[]

시작 부분에서 내 바람 찾기:

>>> re.findall('^I wish', source)

['I wish']

마지막에 물고기 찾기:

>>> re.findall('fish$', source)

[]

마지막에 물고기 찾기:

마지막으로, 오늘밤 물고기를 찾으세요.

>>> re.findall('fish tonight.$', source)

['fish tonight.']

^ 및 $ 문자를 앵커(anchor)라고 합니다. ^ 검색의 시작 부분에 앵커(anchor)를 지정하고, $는 마침표를 포함하여 줄 끝에 있는 모든 문자와 일치하므로 효과가 있었습니다. 좀 더 정확히 말하자면, 우리는 문자 그대로 일치시키기 위해 점을 탈출해야 한다:

>>> re.findall('fish tonight\.$', source)

['fish tonight.']

w 또는 f를 찾은 다음 ish를 찾습니다.

>>> re.findall('[wf]ish', source)

['wish', 'wish', 'fish']

하나 이상의 w, s 또는 h 런을 찾습니다.

>>> re.findall('[wsh]+', source)

['w', 'sh', 'w', 'sh', 'h', 'sh', 'sh', 'h']

영숫자가 아닌 ght 다음에 오는 영숫자를 찾습니다.

>>> re.findall('ght\W', source)

['ght\n', 'ght.']

소원이 따라오는 것을 찾아라:

>>> re.findall('I (?=wish)', source)

['I ', 'I ']

그리고 마지막으로, I 앞에 소원이 있습니다.

>>> re.findall('(?<=I) wish', source)

[' wish', ' wish']

정규식 패턴 규칙이 파이썬 문자열 규칙과 충돌하는 몇 가지 경우가 있습니다. 다음 패턴은 피시로 시작하는 모든 단어와 일치해야 합니다.

>>> re.findall('\bfish', source) []

왜 안되죠? 이전포스팅에서 논의한 바와 같이, 파이썬은 문자열에 몇 가지 특수 이스케이프 문자 액터를 사용한다. 예를 들어, \b는 문자열의 백스페이스를 의미하지만 정규식의 미니 언어에서는 단어의 시작을 의미합니다. 정규식 문자열을 정의할 때 파이썬의 원시 문자열을 사용하여 이스케이프 문자를 실수로 사용하지 않도록 합니다. 정규식 패턴 문자열 앞에 항상 r 문자를 넣으십시오. 여기서 설명한 것처럼 파이썬 이스케이프 문자를 사용할 수 없습니다.

>>> re.findall(r'\bfish', source)

['fish']

Patterns: specifying match output

일치() 또는 검색()을 사용하면 결과 개체 m에서 모든 일치 항목이 m.group()으로 반환됩니다. 패턴을 괄호로 묶으면 일치 항목이 해당 그룹에 저장되며, 이 중 튜플은 다음과 같이 m.group()으로 사용할 수 있습니다.

>>> m = re.search(r'(. dish\b).*(\bfish)', source)

>>> m.group()

'a dish of fish'

>>> m.groups()

('a dish', 'fish')

이 패턴을 사용하면(?)P<name>expr), 일치 항목을 그룹에 저장합니다.

이름:

>>> m = re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)', source)

>>> m.group()

'a dish of fish'

>>> m.groups()

('a dish', 'fish')

>>> m.group('DISH')

'a dish'

>>> m.group('FISH')

'fish'

bytes and bytearray

파이썬 3은 다음과 같은 8비트 정수 시퀀스를 도입했으며, 0부터 255까지의 값을 두 가지 유형으로 사용할 수 있다.

• 바이트는 불변입니다. 바이트 튜플처럼 • 바이트 목록처럼 bytray는 변경할 수 있습니다.

블리스트라는 목록으로 시작하여 다음 예제는 바이트 변수인 바이트 변수와 바이트_array라는 바이어레이 변수를 생성합니다.

>> blist = [1, 2, 3, 255]
>>> the_bytes = bytes(blist)
>>> the_bytes
b'\x01\x02\x03\xff'
>>> the_byte_array = bytearray(blist) >>> the_byte_array bytearray(b'\x01\x02\x03\xff')

바이트 값의 표현은 b와 따옴표 문자 다음에 \x02 또는 ASCII charac sequences ters와 같은 16진수 시퀀스로 시작하고 일치하는 따옴표 문자로 끝납니다. 파이썬은 16진수 시퀀스 또는 ASCII 문자를 작은 정수로 변환하지만 유효한 ASCII 인코딩인 바이트 값을 ASCII 문자로 표시합니다.

>>> b'\x61' b'a'

>>> b'\x01abc\xff' b'\x01abc\xff'

다음 예에서는 바이트 변수를 변경할 수 없음을 보여줍니다.

>>> the_bytes[1] = 127

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

그러나 곁눈질 변수는 부드럽고 변이성이 있습니다.

>>> the_byte_array = bytearray(blist) >>> the_byte_array bytearray(b'\x01\x02\x03\xff')
>>> the_byte_array[1] = 127

>>> the_byte_array bytearray(b'\x01\x7f\x03\xff')

각 값은 0에서 255 사이의 값을 갖는 256 요소 결과를 생성합니다.

>>> the_bytes = bytes(range(0, 256))

>>> the_byte_array = bytearray(range(0, 256))

바이트 또는 byterray 데이터를 인쇄할 때 Python은 인쇄할 수 없는 바이트에 \x x를 사용하고 인쇄 가능한 바이트에 ASCII 등가(및 \x0a 대신 \n과 같은 일반적인 이스케이프 문자)를 사용합니다. 다음은_bytes의 인쇄된 표현입니다(한 줄당 16바이트를 표시하도록 수동 참조).

>>> the_bytes b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f \x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./
0123456789:;<=>?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ[\\]^_
`abcdefghijklmno
pqrstuvwxyz{|}~\x7f \x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f \x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f \xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf \xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf \xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf \xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf \xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef \xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

문자가 아닌 바이트(10개의 정수)이기 때문에 헷갈릴 수 있습니다.

해야 할 일

7.1. mystery라는 유니코드 문자열을 만들고 값을 '\U0001f4a9'로 지정합니다. 미스테리를 인쇄하다. 유니코드 이름을 찾아보십시오.

7.2. 이번에는 UTF-8을 사용하여 미스터리를 바이트 변수 pop_bytes로 인코딩합니다. pop_bytes를 인쇄합니다.

7.3. UTF-8을 사용하여 pop_bytes를 문자열 변수 pop_string으로 디코딩한다. pop_string을 인쇄합니다. 팝 스트링이 미스터리와 같은가?

7.4. 다음 시를 구식으로 쓰세요. 'roast beef', 'ham', 'head' 및 'clam' 문자열을 다음 문자열로 대체하십시오.

My kitty cat likes %s,

My kitty cat fell on his %s

And now thinks he's a %s.

7.5. 새로운 서식을 사용해서 양식 편지를 쓰세요. 다음 문자열을 문자로 저장합니다(다음 연습에서 사용합니다).

Dear {salutation} {name},

Thank you for your letter. We are sorry that our {product} {verbed} in your

{room}. Please note that it should never be used in a {room}, especially

near any {animals}.

Send us your receipt and {amount} for shipping and handling. We will send

you another {product} that, in our tests, is {percent}% less likely to

have {verbed}.

Thank you for your support.

Sincerely,

{spokesman}

{job_title}

7.6. 문자열 키 'salutation', 'name', 'product', 'verbed'(과거 시제 동사), 'room', 'animals', '양', 'per cent', 'spokesman', 'job_title'의 값을 가진 response라는 사전을 만드십시오. 반응 값이 포함된 문자를 인쇄합니다.

7.7. 텍스트 작업을 할 때 정규 표현식이 매우 유용합니다. 여러 가지 방법으로 특집 텍스트 샘플에 적용할 것입니다. 이 시는 1866년 제임스 맥킨타이어가 온타리오에서 만들어 국제 순회공연을 위해 보낸 7천 파운드짜리 치즈에 경의를 표하기 위해 쓴 "매머드 치즈 송가"라는 제목의 시입니다. 모든 것을 입력하지 않으려면, 좋아하는 검색 엔진을 사용하여 단어를 잘라내어 파이썬 프로그램에 붙여 넣으십시오. 아니면, 프로젝트 구텐베르크에서 가져와요. 텍스트 문자열을 매머드라고 합니다.

We have seen thee, queen of cheese,

Lying quietly at your ease,

Gently fanned by evening breeze,

Thy fair form no flies dare seize.

All gaily dressed soon you'll go

To the great Provincial show,

To be admired by many a beau

In the city of Toronto.

Cows numerous as a swarm of bees,

Or as the leaves upon the trees,

It did require to make thee please,

And stand unrivalled, queen of cheese.

May you not receive a scar as

We have heard that Mr. Harris

Intends to send you off as far as

The great world's show at Paris.

Of the youth beware of these,

For some of them might rudely squeeze

And bite your cheek, then songs or glees

We could not sing, oh! queen of cheese.

We'rt thou suspended from balloon,

You'd cast a shade even at noon,

Folks would think it was the moon

About to fall and crush them soon.

7.8. 파이썬의 정규식 함수를 사용하려면 re 모듈을 가져옵니다. re.findall()을 사용하여 c로 시작하는 모든 단어를 인쇄합니다.

7.9. c로 시작하는 4글자를 모두 찾아라.

7.10. r로 끝나는 모든 단어를 찾아라.

7.11. 정확히 세 개의 모음을 연속으로 포함하는 모든 단어들을 찾아라.

7.12. unexlify를 사용하여 이 16진수 문자열(페이지에 맞도록 두 개의 문자열에서 조합됨)을 gif라는 바이트 변수로 변환합니다.

'47494638396101000100800000000000ffffff21f9' +

'0401000000002c000000000100010000020144003b'

파이썬코드 Mangle Data Like a Pro

&$#@ — Thu, 9 Sep 2021 06:59:14 +0900

이번 포스팅에서는 데이터 길들이기 위한 여러 가지 기술에 대해 알아봅니다. 이들 대부분은 다음과 같은 내장 파이썬 데이터 유형에 관한 것이다.

줄들

텍스트 데이터에 사용되는 유니코드 문자 시퀀스.

바이트와 바이패스

이진 데이터에 사용되는 8비트 정수 시퀀스입니다.

텍스트 문자열

텍스트는 대부분의 독자들에게 가장 익숙한 데이터 유형입니다. 따라서 파이썬에서 텍스트 문자열의 강력한 기능 중 몇 가지를 살펴보겠습니다.

유니코드

지금까지 이 책의 모든 텍스트 예제는 평범한 옛 아스키이다. ASCII는 1960년대에 정의되었는데, 그 당시 컴퓨터는 냉장고 크기였고 계산을 조금 더 잘했다. 컴퓨터 저장의 기본 단위는 바이트이며, 바이트는 8비트에 256개의 고유값을 저장할 수 있다. 여러 가지 이유로 ASCII는 대문자 26개, 소문자 26개, 숫자 10개, 일부 펑크음 기호, 일부 띄어쓰기 문자 및 일부 비인쇄 제어 코드 등 7비트(128개의 고유 값)만 사용했습니다.

불행하게도, 세계는 ASCII가 제공하는 것보다 더 많은 글자를 가지고 있다. 당신은 식당에서 핫도그를 먹을 수 있지만, 카페에서는 절대로 게뷔르츠트라미네르1을 먹지 않는다. 더 많은 문자와 기호를 추가하기 위한 많은 시도가 있었고, 여러분은 때때로 그것들을 볼 수 있을 것입니다. 그 중 몇 가지 예를 들 수 있습니다.

1. 이 와인은 독일에 음라우트가 있는데 프랑스에서는 잃어버려요.

• Latin-1, or ISO 8859-1
• Windows code page 1252

이들 각각은 8비트를 모두 사용합니다. 하지만 그것조차도 충분하지 않습니다. 특히 비유럽 언어가 필요할 때는요. 유니코드는 수학과 다른 분야의 기호와 더불어 세계 모든 언어의 문자를 정의하는 지속적인 국제 표준이다.

유니코드는 플랫폼, 프로그램, 언어와 상관없이 모든 문자에 대해 고유한 번호를 제공합니다.

유니코드 코드 차트 페이지에는 이미지가 있는 현재 정의된 모든 문자 집합에 대한 링크가 있습니다. 최신 버전(6.2)에서는 각각 고유한 이름과 식별 번호를 가진 110,000자 이상의 문자를 정의합니다. 문자는 평면이라고 하는 8비트 집합으로 나뉩니다. 처음 256면은 기본 다국어 평면이다. 자세한 내용은 유니코드 평면에 대한 위키피디아 페이지를 참조하십시오.

파이썬 3 유니코드 문자열

Python 3 문자열은 바이트 배열이 아닌 유니코드 문자열입니다. 이는 일반 바이트 문자열과 유니코드 문자 문자열을 구분하는 파이썬 2와 비교할 때 가장 큰 변화입니다.

유니코드 ID 또는 문자 이름을 알고 있는 경우 파이썬 문자열에서 사용할 수 있습니다. 다음은 몇 가지 예입니다.

• \u 다음에 4개의 16진수2는 유니코드의 256개의 기본 다국어 평면 중 하나에 있는 문자를 지정합니다. 처음 두 개는 평면 번호(00에서 FF)이고 다음 두 개는 평면 내 문자 색인입니다. 평면 00은 오래된 ASCII이며, 평면 내의 문자 위치는 ASCII와 동일합니다.

• 고차원 문자의 경우 비트가 더 필요합니다. Python 이스케이프 시퀀스는 \U 다음에 8개의 16진수 문자가 나옵니다. 가장 왼쪽 문자는 0이어야 합니다.

• 모든 문자에 대해 \N{ 이름 }을(를) 사용하여 표준 이름으로 지정할 수 있습니다. 유니코드 문자 이름 색인 페이지에는 이러한 항목이 나열됩니다.

파이썬 유니코드다 모듈에는 양방향으로 변환하는 기능이 있습니다.

• 검색—대소문자를 구분하지 않는 이름을 사용하고 유니코드 문자를 반환합니다.

• 이름 표시—유니코드 문자를 사용하고 대문자 이름을 반환합니다.

다음 예에서는 Python Unicode char act acter를 사용하여 이름을 조회한 다음 이름(원래 문자와 일치해야 함)에서 문자를 다시 검색하는 테스트 함수를 작성하겠습니다.

>>> def unicode_test(value):

... import unicodedata
... name = unicodedata.name(value)
... value2 = unicodedata.lookup(name)
... print('value="%s", name="%s", value2="%s"' % (value, name, value2)) ...

일반 ASCII 문자로 시작하는 몇 가지 문자를 사용해 보겠습니다.

>>> unicode_test('A')
value="A", name="LATIN CAPITAL LETTER A", value2="A"
ASCII punctuation:
>>> unicode_test('$')
value="$", name="DOLLAR SIGN", value2="$"
A Unicode currency character:
>>> unicode_test('\u00a2')
value="¢", name="CENT SIGN", value2="¢"
Another Unicode currency character:
>>> unicode_test('\u20ac')
value="€", name="EURO SIGN", value2="€"

잠재적으로 발생할 수 있는 유일한 문제는 텍스트를 표시하는 데 사용하는 글꼴의 제한입니다. 모든 글꼴에 모든 유니코드 문자에 대한 이미지가 없는 경우 일부 자리 표시자 문자가 표시될 수 있습니다. 예를 들어, 딩뱃 글꼴의 기호와 같은 스노우맨의 유니코드 기호는 다음과 같습니다.

>>> unicode_test('\u2603')
value="☃", name="SNOWMAN", value2="☃"

카페라는 단어를 파이썬 문자열에 저장하려고 합니다. 한 가지 방법은 파일이나 웹 사이트에서 복사하여 붙여넣기하여 다음 작업을 수행하는 것입니다.

>>> place = 'café'
>>> place
'café'

UTF-8 인코딩을 사용한 원본에서 텍스트에 복사하여 붙여넣었기 때문에 가능했습니다.

최종문자를 어떻게 지정할 수 있습니까? E의 문자 색인을 보면, 급성 라틴 소문자 이름 E의 값이 00E9임을 알 수 있습니다. 방금 사용하던 이름() 및 조회() 함수로 확인해 보겠습니다. 먼저 코드를 입력하여 이름을 가져옵니다.

>>> unicodedata.name('\u00e9') 'LATIN SMALL LETTER E WITH ACUTE'

그런 다음 코드를 조회할 이름을 지정합니다.

>>> unicodedata.lookup('E WITH ACUTE, LATIN SMALL LETTER')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
KeyError: "undefined character name 'E WITH ACUTE, LATIN SMALL LETTER'"

유니코드 문자 이름 색인 페이지에 나열된 이름은 표시에 적합하게 정렬되도록 다시 포맷되었습니다. 이러한 이름을 실제 유니코드 이름(파이썬에서 사용하는 이름)으로 변환하려면 쉼표를 제거하고 쉼표 뒤에 있던 이름의 일부를 처음으로 이동합니다. 따라서 급성 라틴 소문자 E를 급성 라틴 소문자 E로 변경합니다.

>>> unicodedata.lookup('LATIN SMALL LETTER E WITH ACUTE') 'é'

이제 코드 또는 이름으로 문자열 카페를 지정할 수 있습니다.

>>> place = 'caf\u00e9'
>>> place
'café'
>>> place = 'caf\N{LATIN SMALL LETTER E WITH ACUTE}' >>> place

'café'

앞의 코드 조각에서 문자열에 직접 é를 삽입했지만 다음을 추가하여 문자열을 만들 수도 있습니다.

>>> u_umlaut = '\N{LATIN SMALL LETTER U WITH DIAERESIS}' >>> u_umlaut
'ü'
>>> drink = 'Gew' + u_umlaut + 'rztraminer'

>>> print('Now I can finally have my', drink, 'in a', place) Now I can finally have my Gewürztraminer in a café

문자열 렌 함수는 바이트가 아닌 유니코드 문자를 카운트합니다.

>>> len('$')
1
>>> len('\U0001f47b') 1

Encode and decode with UTF-8

일반적인 문자열을 처리할 때 파이썬에서 각 유니코드 문자를 저장하는 방법에 대해 걱정할 필요가 없습니다.

그러나 외부와 데이터를 교환할 때는 두 가지 사항이 필요합니다.

문자 문자열을 바이트로 인코딩하는 방법

문자 문자열로 바이트를 디코딩하는 방법

유니코드에 64,000자 미만의 문자가 있으면 각 유니코드 문자 ID를 2바이트로 저장할 수 있습니다. 불행하게도, 더 있습니다. 각 ID를 3, 4바이트 단위로 인코딩할 수 있지만, 그렇게 하면 공통 텍스트 문자열에 대한 메모리 및 디스크 저장 공간이 3, 4배 증가합니다.

Unix 개발자들에게 친숙한 이름을 가진 Ken Thompson과 Rob Pike는 어느 날 밤 뉴저지의 한 식당에서 UTF-8 동적 인코딩 방식에 서명했다. 유니코드 문자당 1~4바이트를 사용합니다.

• ASC용 1바이트Ⅱ

• 대부분의 라틴어에서 파생된 언어(키릴어는 아님)의 경우 2바이트

• 나머지 다국어 평면의 경우 3바이트

• 일부 아시아 언어와 기호를 포함한 나머지 4바이트

UTF-8은 Python, Linux 및 HTML의 표준 텍스트 인코딩입니다. 빠르고 완전하며 잘 작동합니다. 만약 당신이 코드 전체에 UTF-8 인코딩을 사용한다면, 삶은 다양한 인코딩에 들어가고 나오는 것보다 훨씬 쉬울 것이다.

웹 페이지와 같은 다른 원본에서 복사하여 붙여넣기하여 파이썬 문자열을 만드는 경우, 소스가 UTF-8 형식으로 인코딩되어 있는지 확인하십시오. Latin-1 또는 Windows 1252로 인코딩된 텍스트가 파이썬 문자열로 복사되어 나중에 잘못된 바이트 시퀀스로 돌출되는 것을 볼 수 있습니다.

Encoding
문자열을 바이트로 인코딩합니다. 문자열 인코딩() 함수의 첫 번째 인수는 en coding 부호화 이름입니다. 선택사항은 표 7-1에 제시된 것을 포함한다.
Table 7-1. Encodings
'ascii' Good old seven-bit ASCII
'utf-8' Eight-bit variable-length encoding, and what you almost always want to use
'latin-1' Also known as ISO 8859-1
'cp-1252' A common Windows encoding
'unicode-escape' Python Unicode literal format,\uxxxx or\Uxxxxxxxx

UTF-8로 인코딩할 수 있습니다. 유니코드 문자열 '\u2603'을 스노우맨 이름에 할당해 보겠습니다.

>>> snowman = '\u2603'

스노우맨은 내부적으로 저장하는 데 필요한 바이트 수에 관계없이 단일 문자를 가진 파이썬 유니코드 문자열입니다.

>>> len(snowman)

다음으로 이 유니코드 문자를 바이트 순서로 인코딩해 보겠습니다.

>>> ds = snowman.encode('utf-8')

앞서 언급했듯이 UTF-8은 가변 길이 인코딩입니다. 이 경우, 3개를 사용했습니다.

단일 눈사람 유니코드 문자를 인코딩하는 바이트:

>>> len(ds)
3
>>> ds b'\xe2\x98\x83'

이제 len()은 ds가 바이트 변수이기 때문에 바이트 수를 반환합니다.

UTF-8 이외의 인코딩을 사용할 수 있지만 인코딩으로 유니코드 문자열을 처리할 수 없는 경우 오류가 발생합니다. 예를 들어, ASCII 인코딩을 사용하는 경우 유니코드 문자도 유효한 ASCII 문자가 아니면 실패합니다.

>>> ds = snowman.encode('ascii')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode character '\u2603' in position 0: ordinal not in range(128)

인코딩() 함수는 인코딩 예외를 방지하는 데 도움이 되는 두 번째 인수를 사용합니다. 이전 예에서 볼 수 있는 기본값은 '엄격'입니다. ASC가 아닌 경우 유니코드EncodeError가 발생합니다.II 캐릭터. 다른 인코딩도 있습니다. 인코딩되지 않는 것을 버리려면 '무시'를 사용하십시오.

>>> snowman.encode('ascii', 'ignore')

b''

알 수 없는 문자를 대체하려면 '바꾸기'를 사용하십시오.

>>> snowman.encode('ascii', 'replace')

b'?'

유니코드와 같은 파이썬 유니코드 문자 문자열을 만들려면 '백슬래시 바꾸기'를 사용하십시오.

escape:
>>> snowman.encode('ascii', 'backslashreplace')

b'\\u2603'

유니코드 이스케이프 시퀀스의 인쇄 가능한 버전이 필요한 경우 이 옵션을 사용합니다. 다음은 웹 페이지에서 사용할 수 있는 문자 엔터티 문자열을 생성합니다.

>>> snowman.encode('ascii', 'xmlcharrefreplace')

b'☃'

디코딩

바이트 문자열을 유니코드 문자열로 디코딩합니다. 일부 외부 소스(파일, 데이터베이스, 웹 사이트, 네트워크 API 등)에서 텍스트를 가져올 때마다 바이트 문자열로 인코딩됩니다. 까다로운 부분은 어떤 인코딩이 실제로 사용되었는지 알기 때문에 이를 역방향으로 실행하고 유니코드 문자열을 가져올 수 있습니다.

문제는 바이트 문자열 자체에 사용된 인코딩을 나타내는 것은 없다는 것이다. 나는 앞서 웹사이트에서 복사와 붙여넣기의 위험에 대해 언급했다. 여러분은 아마도 보통 오래된 ASCII 문자가 있어야 하는 홀수 문자로 웹사이트를 방문한 적이 있을 것이다.

'카페' 값을 사용하여 플레이스라는 유니코드 문자열을 만듭니다.

>>> place = 'caf\u00e9' >>> place
'café'
>>> type(place)

place_bytes라는 바이트 변수로 UTF-8 형식으로 인코딩합니다.

>>> place_bytes = place.encode('utf-8') >>> place_bytes
b'caf\xc3\xa9'
>>> type(place_bytes)

place_bytes는 5바이트입니다. 처음 3개는 ASCII (UTF-8의 강도)와 동일하며, 마지막 2개는 'é'를 인코딩한다. 이제 바이트 문자열을 유니코드 문자열로 다시 디코딩해 보겠습니다.

>>> place2 = place_bytes.decode('utf-8')

>>> place2

'café'

UTF-8로 인코딩하고 UTF-8로 디코딩했기 때문에 가능했습니다. 다른 인코딩에서 디코딩하라고 하면 어떨까요?

>>> place3 = place_bytes.decode('ascii')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 3: ordinal not in range(128)

바이트 값 0xc3이 ASCII에서 잘못되었기 때문에 ASCII 디코더가 예외를 발생시켰습니다. 128 (헥스 80)과 255 (헥스 FF) 사이의 값이 UTF-8과 동일하지는 않지만 합법적인 일부 8비트 문자 집합 인코딩이 있습니다.

>>> place4 = place_bytes.decode('latin-1')

>>> place4

'cafÃ©'

>>> place5 = place_bytes.decode('windows-1252')

>>> place5

'cafÃ©'

Urk.

이 이야기의 교훈은 가능할 때마다 UTF-8 인코딩을 사용하라는 것이다. 모든 곳에서 작동하고 지원되며 모든 유니코드 문자를 표현할 수 있으며 빠르게 디코딩되고 인코딩됩니다.

자세한 정보는

자세한 내용은 다음 링크를 참조하십시오.

• 유니코드 HOWTO

• 실용 유니코드

• 모든 소프트웨어 개발자가 유니코드 및 문자 집합에 대해 절대적으로 알아야 하는 절대 최소값(변명 없음

파이상자 Handle Missing Keys with setdefault() and defaultdict()

&$#@ — Wed, 8 Sep 2021 06:25:04 +0900

Handle Missing Keys with setdefault() and defaultdict()

존재하지 않는 키로 사전에 액세스하려고 하면 탁월한 효과를 얻을 수 있습니다. 사전 get() 함수를 사용하여 기본값을 반환하면 예외가 발생하지 않습니다.

setdefault() 함수는 get()와 같지만 키가 없는 경우 사전에 항목을 할당합니다.

>>> periodic_table = {'Hydrogen': 1, 'Helium': 2} >>> print(periodic_table)
{'Helium': 2, 'Hydrogen': 1}

키가 사전에 없는 경우 새 값이 사용됩니다.

>>> carbon = periodic_table.setdefault('Carbon', 12)

>>> carbon

>>> periodic_table

{'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

기존 키에 다른 기본값을 할당하려고 하면 원래 값이 반환됩니다.

아무것도 변경되지 않습니다.

>>> helium = periodic_table.setdefault('Helium', 947)

>>> helium

>>> periodic_table

{'Helium': 2, 'Carbon': 12, 'Hydrogen': 1}

defaultdict()도 비슷하지만 사전을 만들 때 앞에 있는 모든 새 키의 기본값을 지정합니다. 인수는 함수입니다. 이 예에서는 int()라고 하는 함수 int를 전달하고 정수 0을 반환합니다.

>>> from collections import defaultdict >>> periodic_table = defaultdict(int)

이제 결측값은 정수(int)이며 값은 0입니다.

>>> periodic_table['Hydrogen'] = 1
>>> periodic_table['Lead']
0
>>> periodic_table
defaultdict(<class 'int'>, {'Lead': 0, 'Hydrogen': 1})

defaultdict() 인수는 누락된 키에 할당할 값을 반환하는 함수입니다. 다음 예에서 no_idea()는 필요할 때 값을 반환하기 위해 실행됩니다.

>>> from collections import defaultdict >>>
>>> def no_idea():
... return 'Huh?'

...

>>> bestiary = defaultdict(no_idea)

>>> bestiary['A'] = 'Abominable Snowman'

>>> bestiary['B'] = 'Basilisk'

>>> bestiary['A']

'Abominable Snowman'

>>> bestiary['B']

'Basilisk'

>>> bestiary['C']

'Huh?'

int() 함수, list() 함수 또는 dict() 함수를 사용하여 해당 유형의 기본 빈 값을 반환할 수 있습니다. int()는 0을 반환하고 list()는 빈 목록([])을 반환하며 dict()는 빈 사전({})을 반환합니다. 인수를 생략하면 새 키의 초기 값이 없음으로 설정됩니다.

그런데 통화 내에서 람다를 사용하여 기본 설정 함수를 정의할 수 있습니다.

>>> bestiary = defaultdict(lambda: 'Huh?') >>> bestiary['E']
'Huh?'

int를 사용하는 것도 자신만의 카운터를 만드는 한 가지 방법입니다.

>>> from collections import defaultdict
>>> food_counter = defaultdict(int)
>>> for food in ['spam', 'spam', 'eggs', 'spam']: ... food_counter[food] += 1
...
>>> for food, count in food_counter.items():
... print(food, count)
...
eggs 1
spam 3

앞의 예에서, food_counter가 디폴트딕트 대신 일반 사전이었다면, 파이썬은 초기화되지 않았기 때문에 food_counter[food] 사전 요소를 증가시키려고 할 때마다 예외를 제기했을 것이다. 여기에 표시된 것처럼 추가 작업이 필요했을 것입니다.

>>> dict_counter = {}
>>> for food in ['spam', 'spam', 'eggs', 'spam']:

...
>>> for food, count in dict_counter.items(): ... print(food, count)

...

spam 3 eggs 1

Count Items with Counter()

카운터 얘기가 나와서 말인데, 표준 라이브러리에는 이전 예제와 같은 작업을 수행하는 라이브러리가 있습니다.

>>> from collections import Counter
>>> breakfast = ['spam', 'spam', 'eggs', 'spam'] >>> breakfast_counter = Counter(breakfast)
>>> breakfast_counter
Counter({'spam': 3, 'eggs': 1})

most_common() 함수는 모든 요소를 내림차순으로 반환하거나 카운트가 주어진 경우 최상위 카운트 요소만 반환합니다.

>>> breakfast_counter.most_common()

[('spam', 3), ('eggs', 1)]

>>> breakfast_counter.most_common(1)

[('spam', 3)]

카운터를 결합할 수 있습니다. 먼저, breakfast_counter에 무엇이 있는지 다시 한 번 살펴보겠습니다.

>>> breakfast_counter

>>> Counter({'spam': 3, 'eggs': 1})

이번에는 점심이라고 불리는 새로운 목록과 점심 카운터라고 불리는 카운터를 만들겠습니다.

>>> lunch = ['eggs', 'eggs', 'bacon']

>>> lunch_counter = Counter(lunch)

>>> lunch_counter

Counter({'eggs': 2, 'bacon': 1})

두 카운터를 결합하는 첫 번째 방법은 +를 사용하는 덧셈입니다.

>>> breakfast_counter + lunch_counter

Counter({'spam': 3, 'eggs': 3, 'bacon': 1})

예상하신 대로 -를 사용하여 카운터 하나를 다른 카운터에서 뺍니다.

아침은 안먹고 점심은 안먹어?

>>> breakfast_counter - lunch_counter

Counter({'spam': 3})

좋아요, 그럼 아침으로 먹을 수 없는 점심으로 뭘 먹을 수 있을까요?

>>> lunch_counter - breakfast_counter

Counter({'bacon': 1, 'eggs': 1})

이전의 세트와 마찬가지로 교차로 op‐ erator &:를 사용하여 공통 항목을 얻을 수 있습니다.

>>> breakfast_counter & lunch_counter

Counter({'eggs': 1})

교차로는 공통 요소(계란)를 더 낮은 수로 선택했습니다. 이것은 말이 된다: 아침식사는 계란 한 개만 제공했기 때문에, 그것이 일반적인 계산이다.

마지막으로, 유니언 연산자를 사용하여 모든 항목을 가져올 수 있습니다. |:

>>> breakfast_counter | lunch_counter

Counter({'spam': 3, 'eggs': 2, 'bacon': 1})

'계란'이라는 항목은 다시 두 가지 모두에 공통적이었다. 조합은 덧셈과 달리 인원수를 늘리지 않고 더 큰 숫자를 골랐다.

Order by Key with OrderedDict()

이 책의 초기 장에 있는 많은 코드 예제는 사전의 키 순서를 예측할 수 없다는 것을 보여준다. 키 a, b 및 c는 해당 순서로 추가할 수 있지만 키()는 c, a, b를 반환할 수 있다. 여기 이전포스팅에서 용도를 변경한 예가 있습니다.

>>> quotes = {

... 'Moe': 'A wise guy, huh?',
... 'Larry': 'Ow!',
... 'Curly': 'Nyuk nyuk!', ... }
>>> for stooge in quotes:
... print(stooge)
...
Larry
Curly
Moe

OrderedDict()는 키 추가 순서를 기억하고 반복자로부터 동일한 순서로 반환합니다. (키, 값) 튜플 순서에서 OrderedDict를 만들어 보십시오.

>>> from collections import OrderedDict >>> quotes = OrderedDict([
Stack + Queue == deque

데크(데크 발음)는 스택과 큐의 기능을 모두 갖춘 이중 종단 큐입니다. 시퀀스의 양쪽 끝에서 항목을 추가 및 삭제할 때 유용합니다. 여기, 우리는 단어 양쪽 끝에서 중간까지 페일린 드롬인지 알아봅니다. popleft() 함수는 데크에서 맨 왼쪽 항목을 제거했다가 반환합니다. pop()은 맨 오른쪽 항목을 제거했다가 반환합니다. 함께, 그들은 끝에서 중간까지 일을 합니다. 끝 문자가 일치하는 한 중간에 도달할 때까지 계속 터집니다.

>>> def palindrome(word):

...

>>> palindrome('a')

True

from collections import deque dq = deque(word)
while len(dq) > 1:

if dq.popleft() != dq.pop(): return False

return True

>>> palindrome('racecar')

True

>>> palindrome('')

True

>>> palindrome('radar')

True

>>> palindrome('halibut')

False

저는 이것을 단순한 데크의 삽화로 사용했습니다. 만약 당신이 빠른 회문 체커를 원한다면, 단지 문자열을 그것의 반대와 비교하는 것이 훨씬 더 간단할 것이다. Python에는 문자열에 대한 역함수가 없지만 여기에 표시된 것처럼 슬라이스로 문자열을 역방향으로 사용할 수 있는 방법이 있습니다.

>>> def another_palindrome(word): ... return word == word[::-1] ...
>>> another_palindrome('radar') True

>>> another_palindrome('halibut')

False

Iterate over Code Structures with itertools

이터툴스는 특수 목적 반복기 기능을 포함한다. 각각 ...에 대해 a 내에서 호출하면 한 번에 하나의 항목을 반환합니다. 호출 사이의 상태를 기억합니다.

chain은 마치 하나의 참을 수 있는 것처럼 그 논거를 통과한다.

>>> import itertools
>>> for item in itertools.chain([1, 2], ['a', 'b']): ... print(item)
...
1
2
a
b

cycle()은 무한 반복자로, 그 인수를 순환한다.

>>> import itertools
>>> for item in itertools.cycle([1, 2]): ... print(item)
...
1
2
1
2
.
.
.

기타 등등.

누적은 누적된 값을 계산합니다. 기본적으로 합계가 계산됩니다.

>>> import itertools
>>> for item in itertools.accumulate([1, 2, 3, 4]): ... print(item)
...
1
3
6
10

누적()할 두 번째 인수로 함수를 제공할 수 있으며, 추가 대신 이 인수가 사용됩니다. 함수는 두 개의 인수를 사용하여 단일 결과를 반환해야 합니다. 이 예제에서는 누적 제품을 계산합니다.

>>> import itertools
>>> def multiply(a, b):
... returna*b
...
>>> for item in itertools.accumulate([1, 2, 3, 4], multiply): ... print(item)
...
1
2
6
24

이터툴즈 모듈에는 더 많은 기능이 있으며, 특히 필요에 따라 시간을 절약할 수 있는 조합과 순열에 대한 기능이 있습니다.

Print Nicely with pprint()

모든 예제는 인쇄()(또는 대화형 인터프리터의 변수 이름만)를 사용하여 인쇄했습니다. 때때로, 그 결과는 읽기 어렵다. 우리는 print 와 같은 예쁜 프린터가 필요하다.

>>> from pprint import pprint >>> quotes = OrderedDict([

... ('Moe', 'A wise guy, huh?'),
... ('Larry', 'Ow!'),
... ('Curly', 'Nyuk nyuk!'),
... ])
>>>

그냥 오래된 인쇄물은 물건들을 그냥 저기에 버립니다.

>>> print(quotes)
OrderedDict([('Moe', 'A wise guy, huh?'), ('Larry', 'Ow!'), ('Curly', 'Nyuk nyuk!')])

그러나 pprint()는 가독성을 높이기 위해 요소를 정렬하려고 합니다.

>>> pprint(quotes)
{'Moe': 'A wise guy, huh?',
'Larry': 'Ow!',
'Curly': 'Nyuk nyuk!'}

More Batteries: Get Other Python Code

때때로, 표준 라이브러리는 여러분이 필요로 하는 것을 가지고 있지 않거나, 아주 올바른 방법으로 그것을 하지 않습니다. 오픈 소스, 타사 파이썬 소프트웨어가 전 세계에 걸쳐 있습니다. 좋은 리소스는 다음과 같습니다.

• PyPi (also known as the Cheese Shop, after an old Monty Python skit)
• github
• readthedocs

activestate에서 더 작은 코드 예제를 많이 볼 수 있습니다.

이 책에 있는 거의 모든 파이썬 코드는 모든 내장 및 표준 라이브러리를 포함하는 컴퓨터에 표준 파이썬 설치를 사용합니다. 외부 패키지는 다음과 같은 위치에 있습니다. 1장에서 요청을 언급했으며, 222페이지의 "표준 라이브러리 너머: 요청"에서 자세한 내용을 설명합니다. 부록 D는 다른 많은 너트 앤 볼트 개발 세부사항과 함께 타사 파이썬 소프트웨어를 설치하는 방법을 보여준다.

해야 할 일

5.1. zoo.py이라는 파일을 만듭니다. 여기에서 '매일 9-5 열기' 문자열을 인쇄하는 hours()라는 함수를 정의합니다. 그런 다음 대화형 통역기를 사용하여 동물원 모듈을 가져오고 시간() 기능을 호출합니다.

5.2. 대화형 통역기에서 동물원 모듈을 menagerie로 가져오고 시간() 기능을 호출한다.

5.3. 통역실에 머무르면서 동물원으로부터 직접 시간() 기능을 가져와 전화한다.

5.4. 시간() 기능을 정보로 가져와 호출합니다.

5.5. 키-값 쌍 'a'가 1, 'b': 2, 'c'인 일반 사전을 만듭니다.

3번, 그리고 인쇄하세요.

5.6. 5.5에 나열된 동일한 쌍으로 팬시라고 불리는 OrderedDict를 만들어 인쇄합니다.

일반과 같은 순서로 인쇄되었습니까?

5.7. dict_of_lists라는 디폴트딕트를 만들어 인수 목록을 전달합니다. 목록을 dict_of_lists['a']로 만들고 한 번의 할당으로 'something for a' 값을 추가합니다. dict_of_lists['a']를 인쇄합니다.

파이 상자: 모듈, 패키지 및 프로그램

&$#@ — Mon, 6 Sep 2021 11:26:22 +0900

상향식 상향식 상향식에서는 내장 데이터 유형에서 점점 더 큰 데이터 및 코드 구조를 구축하는 방식으로 발전해 왔습니다. 이 챕터에서는 마지막으로 파이썬에서 사실적이고 큰 프로그램을 작성하는 방법에 대해 알아보겠습니다.

Standalone Programs

지금까지 Python의 대화형 인터프리터 내에서 다음과 같은 코드 조각을 작성하고 실행했습니다.

>>> print("This interactive snippet works.") This interactive snippet works.

이제 첫 번째 독립 실행형 프로그램을 만들어 보겠습니다. 컴퓨터에서 Python 코드 한 줄이 포함된 test1.py이라는 파일을 만드십시오.

print("This standalone program works!")

>> 프롬프트는 없으며 Python 코드 한 줄만 표시됩니다. 다음 항목이 있는지 확인합니다.

인쇄 전에 라인에 자국이 없습니다.

텍스트 터미널 또는 터미널 창에서 Python을 실행하는 경우

Python 프로그램과 프로그램 파일 이름:

$ python test1.py
This standalone program works!

지금까지 이 책에서 본 대화형 스니펫을 모두 파일로 저장하고 직접 실행할 수 있습니다. ▲를 잘라내어 붙여넣을 경우, 초기 >> 및 ...을(를) 삭제해야 합니다. (최종 공간을 확보합니다.)

Command-Line Arguments

컴퓨터에서 다음 두 줄이 포함된 test2.py 파일을 만듭니다.

import sys

print('Program arguments:', sys.argv)

이제 이 프로그램을 실행하려면 현재 버전의 Python을 사용하십시오. 이게 어떻게 보일지 알 수 있어요.

표준 셸 프로그램을 사용하는 Linux 또는 Mac OS X 터미널 창:

$ python test2.py
Program arguments: ['test2.py']
$ python test2.py tra la la
Program arguments: ['test2.py', 'tra', 'la', 'la']

Modules and the import Statement

Python 코드를 두 개 이상의 파일에서 만들고 사용하는 한 단계 더 나아갈 것입니다. 모듈은 Python 코드의 파일일 뿐입니다.

이 책의 텍스트는 단어, 문장, 단락, 장 등의 계층 구조로 구성되어 있습니다. 그렇지 않으면 한두 페이지 후에 읽을 수 없습니다. 코드는 대략 비슷한 상향식 구성을 가지고 있습니다. 데이터 유형은 단어, 문장은 문장, 함수는 단락, 모듈은 장과 같습니다. 비유를 계속하자면, 이 책에서 제가 프로그래밍 8장에서 설명할 내용은 다른 모듈의 코드를 참조하는 것과 같습니다.

우리는 수입 명세서를 사용하여 다른 모듈의 코드를 참조합니다. 이렇게 하면 가져온 모듈의 코드와 변수를 프로그램에서 사용할 수 있습니다.

Import a Module

가져오기 문을 가장 간단하게 사용하는 것은 가져오기 모듈입니다. 여기서 module은 .py 확장자가 없는 다른 Python 파일의 이름입니다. 기상 관측소를 시뮬레이션해서 기상 보고서를 출력해 봅시다. 하나의 메인 프로그램이 보고서를 인쇄하고, 단일 기능으로 별도의 모듈이 보고서에 사용된 날씨 설명을 반환합니다.

여기 메인 프로그램이 있습니다.py):

import report

description = report.get_description() print("Today's weather:", description)

다음은 모듈(report.py)입니다.

def get_description(): # see the docstring below? """Return random weather, just like the pros""" from random import choice

possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows'] return choice(possibilities)

이 두 파일이 동일한 디렉토리에 있고 Python이 weather▲ man.py을 메인 프로그램으로 실행하도록 지시하면, Python은 보고서 모듈에 액세스하여 get_tription tion 함수를 실행합니다. 문자열 목록에서 임의의 결과를 반환하기 위해 이 버전의 get_description()을 작성했습니다. 따라서 기본 프로그램은 다음과 같이 반환되고 인쇄됩니다.

$ python weatherman.py Today's weather: who knows $ python weatherman.py Today's weather: sun
$ python weatherman.py Today's weather: sleet

우리는 수입품을 두 곳에서 사용했습니다.

• 메인 프로그램 weatherman.py에서 모듈 보고서를 가져왔습니다.

• 모듈 파일 report.py에서 get_discription unction 함수가 Python의 표준 랜덤 모듈에서 choice 함수를 가져왔습니다.

우리는 또한 수입품을 두 가지 다른 방법으로 사용했습니다.

• 주요 프로그램이 import report를 호출한 후 report.get_descrip을 실행했습니다.

이온화

• 랜덤 가져오기에서 호출된 report.py의 get_discription function

선택 후 실행(가능성)했습니다.

첫 번째 경우 보고서 모듈 전체를 가져오지만 report.를 접두사로 사용해야 get_description()이(가) 가능합니다. report.py의 모든 내용은 보고서 이름 앞에 있는 보고서만 붙이면 주 프로그램에서 사용할 수 있습니다. 모듈의 내용을 모듈 이름으로 한정함으로써 이름 충돌이 발생하는 것을 방지할 수 있습니다. 다른 모듈에 get_description() 함수가 있을 수 있으며 실수로 호출하지는 않습니다.

두 번째 경우에는 함수 내에 있고 여기에 다른 명명된 선택 항목이 없으므로 임의 모듈에서 선택() 함수를 직접 가져왔습니다. 임의의 결과를 반환하는 다음과 같은 함수를 작성할 수 있었습니다.

def get_description(): import random

possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows'] return random.choice(possibilities)

프로그래밍의 여러 가지 측면과 마찬가지로 자신에게 가장 명확해 보이는 스타일을 고르십시오. 모듈 인증 이름(랜덤).(선택)이 더 안전하지만 조금 더 입력해야 합니다.위의 get_description() 예제는 가져올 항목의 다양성을 보여 주었지만 가져올 위치의 다양성은 나타내지 않았습니다. 모두 함수 내부에서 가져오기라고 했습니다. 함수 외부에서 임의로 가져올 수 있었습니다.

>>> import random
>>> def get_description():

... possibilities = ['rain', 'snow', 'sleet', 'fog', 'sun', 'who knows']
... return random.choice(possibilities) ...
>>> get_description()
'who knows'
>>> get_description()
'rain'

가져온 코드를 둘 이상의 장소에서 사용할 수 있는 경우 기능 외부에서 가져오고, 사용이 제한되는 경우 내부에서 가져오기를 고려해야 합니다. 일부 사람들은 코드의 모든 종속성을 명확히 하기 위해 모든 가져오기를 파일 맨 위에 놓는 것을 선호합니다. 어느 쪽이든 통한다.

mport a Module with Another Nam

우리의 주요 weatherman.py 프로그램에서 우리는 수입 보고서를 호출했습니다. 하지만 이름이 같은 다른 모듈이 있거나 더 니모닉하거나 더 짧은 이름을 사용하려는 경우 어떻게 해야 합니까? 이러한 경우 별칭을 사용하여 가져올 수 있습니다. 다음 별칭을 사용합니다.

import report as wr
description = wr.get_description() print("Today's weather:", description)
Import Only What You Want from a Module

Python을 사용하면 모듈의 하나 이상의 부품을 가져올 수 있습니다. 각 부분은 원래 이름을 유지하거나 별칭을 지정할 수 있습니다. 먼저 보고서 모듈에서 원래 이름으로 get_description()을 가져오겠습니다.

from report import get_description description = get_description() print("Today's weather:", description)

이제 do_it로 가져옵니다.

from report import get_description as do_it description = do_it()
print("Today's weather:", description)

Module Search Path

이제 do_it로 가져옵니다.Python은 가져올 파일을 어디에서 찾습니까? 표준 sys 모듈에 저장된 디렉토리 이름과 ZIP 아카이브 파일 목록을 변수 경로로 사용합니다. 이 목록에 액세스하여 수정할 수 있습니다. 다음은 Mac에서 Python 3.3용 sys.path의 값입니다.

>>> import sys
>>> for place in sys.path: ... print(place)
...

/Library/Frameworks/Python.framework/Versions/3.3/lib/python33.zip

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/plat-darwin

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/lib-dynload

/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/site-packages

초기 빈 출력 라인은 현재 디렉토리를 나타내는 빈 문자열 ''입니다. sys.path에서 '가 처음인 경우 Python은 무언가를 가져오려고 할 때 현재 디렉토리를 먼저 찾습니다. 가져오기 보고서는 report.py을 찾습니다.

첫 번째 매치가 사용됩니다. 즉, 랜덤이라는 모듈을 정의하고 표준 라이브러리 이전의 검색 경로에 있는 경우 표준 라이브러리의 랜덤에 액세스할 수 없습니다.

Packages

코드 한 줄에서 여러 줄 기능, 독립 실행형 프로그램, 동일한 디렉토리에 있는 여러 모듈로 이동했습니다. Python 응용 프로그램을 더 많이 확장할 수 있도록 모듈을 패키지라는 파일 계층으로 구성할 수 있습니다.

아마도 우리는 다음 날과 다음 주에 각각 다른 유형의 문자 예보를 원하는 것 같습니다. 이를 구조화하는 한 가지 방법은 소스라는 이름의 디렉터리를 만들고 그 안에 daily.py과 weekly.py이라는 두 개의 모듈을 만드는 것입니다. 각각은 예측이라는 기능을 가지고 있다. 일별 버전은 문자열을 반환하고 주별 버전은 7개 문자열 목록을 반환합니다.

여기 메인 프로그램과 두 개의 모듈이 있습니다. (enumerate() 함수는 목록을 분해하여 목록의 각 항목을 for 루프에 공급하여 각 항목에 숫자를 조금 더 추가합니다.)

주 프로그램: box/weather.py.

from sources import daily, weekly

print("Daily forecast:", daily.forecast()) print("Weekly forecast:")
for number, outlook in enumerate(weekly.forecast(), 1):

print(number, outlook)

모듈 1: box/box/daily.py.

def forecast():
'fake daily forecast' return 'like yesterday'

모듈 2: box/box/weekly.py.

def forecast():
"""Fake weekly forecast"""
return ['snow', 'more snow', 'sleet',

'freezing rain', 'rain', 'fog', 'hail']

원본 디렉토리에 __init_.py라는 파일이 하나 더 필요합니다. 이 캔

비어 있지만 Python은 이 디렉터리를 패키지로 처리하려면 이 디렉터리가 필요합니다. 메인 weather.py 프로그램을 실행하여 다음 작업을 확인합니다.

$ python weather.py
Daily forecast: like yesterday Weekly forecast:
1 snow
2 more snow
3 sleet
4 freezing rain
5 rain
6 fog
7 hail

The Python Standard Library

Python의 주요 주장 중 하나는 Python이 많은 유용한 작업을 수행하는 대규모 표준 모듈 라이브러리인 "배터리 포함"을 가지고 있으며 핵심 언어가 과장되지 않도록 별도로 보관하고 있다는 것입니다. 일부 Python 코드를 작성하려고 할 때 먼저 원하는 작업을 이미 수행하는 표준 모듈이 있는지 확인하는 것이 좋습니다. 표준 도서관에서 작은 보석들을 자주 접하는 것은 놀라운 일입니다. Python은 또한 튜토리얼과 함께 모듈에 대한 권위 있는 설명서를 제공합니다. Doug Hellmann의 웹 사이트 Python Module of the Week와 그의 저서 The Python Standard Li bybrary by 예제(Addison-Wesley Professional)도 매우 유용한 가이드입니다.

이 책의 다음 장에서는 웹, 시스템, 데이터베이스 등과 관련된 많은 표준 모듈을 다룹니다. 이 섹션에서는 일반적인 용도가 있는 몇 가지 표준 모듈에 대해 설명하겠습니다.

파이썬코드구조 closures

&$#@ — Sun, 5 Sep 2021 22:31:55 +0900

Closures

내부 기능이 폐쇄 역할을 할 수 있습니다. 다른 함수에 의해 동적으로 생성되는 함수로, 함수 외부에서 생성된 변수의 값을 변경하고 기억할 수 있습니다.

다음 예제는 이전 기사() 예제를 기반으로 합니다. 우리는 상상력이 없기 때문에 새로운 기사2()라고 부르고, 내부() 기능을 내부2()라고 하는 폐쇄 기능으로 바꾸자. 차이점은 다음과 같습니다.

• inner2는 외부말 매개변수를 인수로 얻는 대신 직접 사용합니다.

• nights2px는 내부 2 함수 이름을 호출하는 대신 반환합니다.

>>> def knights2(saying):

def inner2():
return "We are the knights who say: '%s'" % saying

return inner2

내부2() 함수는 전달된 말의 가치를 알고 기억합니다. line return inner2는 inner2 함수의 이 특수 복사본을 반환합니다(하지만 호출하지는 않음). 이것은 폐쇄입니다. 어디서 왔는지 기억하는 동적으로 만들어진 함수입니다.

다른 인수를 사용하여 기사 2()를 두 번 호출합니다.

>>> a = knights2('Duck')

>>> b = knights2('Hasenpfeffer')

좋아, 그럼 A와 B는 뭐야?

>>> type(a) <class 'function'> >>> type(b) <class 'function'>

기능이지만 폐쇄이기도 합니다.

>>> a

<function knights2.<locals>.inner2 at 0x10193e158>

>>> b

<function knights2.<locals>.inner2 at 0x10193e1e0>

우리가 그들을 부른다면, 그들은 그들이 기사2에 의해 창조되었을 때 사용되었던 속담을 기억한다:

>>> a()

"We are the knights who say: 'Duck'"

>>> b()

"We are the knights who say: 'Hasenpfeffer'"

Anonymous Functions: the lambda() Function

Python에서 람다 함수는 단일 문장으로 표현되는 익명 함수입니다. 일반적인 작은 기능 대신 사용할 수 있습니다.

이를 설명하기 위해 먼저 정규 함수를 사용하는 예를 만들어 보겠습니다. 먼저 edit_story() 함수를 정의하겠습니다. 그 주장은 다음과 같다.

• 단어—단어 목록

• func—단어의 각 단어에 적용하는 기능

>>> def edit_story(words, func): ... for word in words:
... print(func(word))

이제 단어 목록과 각 단어에 적용할 기능이 필요합니다. 여기 제 고양이가 계단 하나를 놓쳤을 때 내는 (가정적인) 소리 목록이 있습니다.

>>> stairs = ['thud', 'meow', 'thud', 'hiss']

그리고 함수의 경우, 각 단어를 대문자로 쓰고 느낌표를 붙입니다.

고양이 타블로이드 신문 헤드라인에 적합:

>>> def enliven(word): # give that prose more punch ... return word.capitalize() + '!'

재료 혼합:

>>> edit_story(stairs, enliven)

Thud!

Meow!

Thud!

Hiss!

드디어 람다에 도착했군. 활성화() 기능이 너무 짧아서 대체할 수 있었습니다.

람다와 함께:

>>>
>>> edit_story(stairs, lambda word: word.capitalize() + '!') Thud!
Meow!
Thud!
Hiss!
>>>

람다는 하나의 주장을 받아들입니다. 여기서 우리는 그것을 단어라고 부릅니다. 대장과 끝 괄호 사이의 모든 것이 함수의 정의입니다.

종종 람다를 사용하는 것보다 활력()과 같은 실제 기능을 사용하는 것이 훨씬 더 명확합니다. 람다는 그렇지 않으면 많은 작은 함수들을 정의해야 할 경우에 가장 유용합니다. 그리고 그것들을 모두 기억해야 합니다. 특히 그래픽 사용자 인터페이스에서 람다를 사용하여 콜백 함수를 정의할 수 있습니다. 예는 부록 A를 참조하십시오.

Generators

생성기는 Python 시퀀스 생성 개체입니다. 이 기능을 사용하면 전체 시퀀스를 한 번에 만들고 메모리에 저장하지 않고도 잠재적으로 큰 시퀀스를 반복할 수 있습니다. 생성기는 반복측정기의 데이터 원본인 경우가 많습니다. 이전 코드 예제에서는 이미 범위()라는 이름을 사용하여 일련의 정수를 생성했습니다. Python 2에서 range()는 목록을 반환하여 메모리에 맞도록 제한합니다. Python 2에는 생성기 xrange()도 있으며, 이는 Python 3에서 일반 범위()가 되었다. 이 예제에서는 1에서 100까지의 모든 정수를 추가합니다.

>>> sum(range(1, 101))

5050

생성기를 통해 반복할 때마다 마지막으로 호출된 시간을 추적하고 다음 값을 반환합니다. 이는 이전 통화에 대한 메모리가 없고 항상 동일한 상태의 첫 회선에서 시작되는 일반 함수와는 다릅니다.

잠재적으로 큰 시퀀스를 만들고 코드가 너무 커서 제너레이터를 이해할 수 없는 경우 제너레이터 함수를 작성합니다. 정상 함수이지만 반환이 아닌 항복문으로 값을 반환합니다. 고유한 범위 버전()을 작성해 보겠습니다.

>>> def my_range(first=0, last=10, step=1):

number = first while number < last:

yield number number += step

정상적인 기능입니다.

>>> my_range

생성기 개체를 반환합니다.

>>> ranger = my_range(1, 5)

>>> ranger

이 생성기 개체에 대해 반복할 수 있습니다.

>>> for x in ranger: ... print(x) ...
1

2 3 4

Decorators

경우에 따라 소스 코드를 변경하지 않고 기존 함수를 수정하려고 할 수 있습니다. 일반적인 예는 전달된 인수를 확인하기 위해 디버깅 문을 추가하는 것입니다.

데코레이터는 한 함수를 입력으로 사용하고 다른 함수를 반환하는 함수입니다. Python 트릭 백을 자세히 살펴보고 다음을 사용합니다.

• *병력 및 **왜성

• 내부 기능

• 인수로서의 함수

document_it() 함수는 다음 작업을 수행할 장식자를 정의합니다.

• 함수의 이름과 인수 값을 인쇄합니다.

• 인수를 사용하여 함수 실행

• 결과 인쇄

• 수정된 기능을 사용할 수 있도록 반환

코드는 다음과 같습니다.

>>> def document_it(func):

document_it()에 전달하는 함수는 document_it()가 추가하는 추가 문을 포함하는 새 함수를 제공합니다. 데코레이터는 실제로 func에서 코드를 실행할 필요가 없지만 document_it()는 func를 호출하여 func뿐만 아니라 모든 추가 결과를 얻을 수 있도록 합니다.

그래서 이걸 어떻게 사용하죠? 장식자를 수동으로 적용할 수 있습니다

>>> def add_ints(a, b):
... returna+b ...
>>> add_ints(3, 5)
8
>>> cooler_add_ints = document_it(add_ints) # manual decorator assignment >>> cooler_add_ints(3, 5)
Running function: add_ints
Positional arguments: (3, 5)
Keyword arguments: {}
Result: 8
8
위의 수동 데코레이터 할당 대신, 꾸미려는 함수 앞에 @decorator_name을 추가하십시오.

>>> @document_it
... def add_ints(a, b):
... returna+b
...
>>> add_ints(3, 5)
Start function add_ints Positional arguments: (3, 5) Keyword arguments: {} Result: 8
8

기능별로 둘 이상의 데코레이터를 둘 수 있습니다. 결과를 제곱하는 square_it()라는 다른 장식가를 작성해 보겠습니다.

...

def new_function(*args, **kwargs): result = func(*args, **kwargs) return result * result

return new_function

함수에 가장 근접하게 사용된 데코레이터(decorator, 정의 바로 위)가 먼저 실행된 다음 그 위에 있는 데코레이터가 실행됩니다. 두 순서 모두 동일한 최종 결과를 제공하지만 중간 단계가 어떻게 변하는지 확인할 수 있습니다.

>>> @document_it
... @square_it
... def add_ints(a, b):
... returna+b
...
>>> add_ints(3, 5)
Running function: new_function Positional arguments: (3, 5) Keyword arguments: {}
Result: 64
64

데코레이터 순서를 반대로 해 보겠습니다.

>>> @square_it
... @document_it
... def add_ints(a, b): ... returna+b
...
>>> add_ints(3, 5) Running function: add_ints

Positional arguments: (3, 5)

Keyword arguments: {}

Result: 8

Namespaces and Scope

이름은 어디에 쓰이느냐에 따라 다른 것을 가리킬 수 있다. Python 프로그램에는 특정 이름이 고유하고 다른 네임스페이스의 동일한 이름과 관련이 없는 섹션 등 다양한 네임스페이스가 있습니다.

각 함수는 고유한 네임스페이스를 정의합니다. 주 프로그램에서 x라는 변수를 정의하고 함수에서 x라는 다른 변수를 정의하면 다른 변수를 나타냅니다. 그러나 벽을 뚫을 수 있습니다. 필요한 경우 다양한 방법으로 다른 네임스페이스의 이름에 액세스할 수 있습니다.

프로그램의 주요 부분은 글로벌 네임스페이스를 정의하므로 해당 네임스페이스의 변수는 글로벌 변수입니다.

함수 내에서 전역 변수의 값을 가져올 수 있습니다.

>>> animal = 'fruitbat'
>>> def print_global():
... print('inside print_global:', animal) ...
>>> print('at the top level:', animal)
at the top level: fruitbat
>>> print_global()
inside print_global: fruitbat

그러나 전역 변수의 값을 가져와 함수 내에서 변경하려고 하면 다음 오류가 발생합니다.

>>> def change_and_print_global():

... print('inside change_and_print_global:', animal)
... animal = 'wombat'
... print('after the change:', animal) ...
>>> change_and_print_global()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in change_and_report_it
UnboundLocalError: local variable 'animal' referenced before assignment

이 변수를 변경하면 이름이 동물인 다른 변수도 변경되지만 이 변수는 함수 내부에 있습니다.

>>> def change_local():

>>> change_local()

inside change_local: wombat 4330406160

>>> animal

'fruitbat'

>>> id(animal)

4330390832

이게 어찌된 일이냐? 첫 번째 줄은 동물이라는 글로벌 변수에 '과일배트' 문자열을 할당했습니다. change_local() 함수에도 animal이라는 변수가 있지만, 이 변수는 로컬 네임스페이스에 있습니다.

여기서는 Python 함수 ID()를 사용하여 각 객체에 대한 고유한 값을 인쇄하고 change_local() 내부의 변수 동물이 프로그램의 메인 레벨에서 동물과 같지 않음을 증명했습니다.

함수 내의 로컬 변수가 아닌 전역 변수에 액세스하려면 글로벌 키워드를 사용해야 합니다(이것이 올 것임을 알고 있었음: expiritive is been implicit):

>>> animal = 'fruitbat'
>>> def change_and_print_global():

... global animal
... animal = 'wombat'
... print('inside change_and_print_global:', animal) ...
>>> animal
'fruitbat'
>>> change_and_print_global()
inside change_and_print_global: wombat
>>> animal
'wombat'

함수 내에서 전역이라고 말하지 않으면 Python은 로컬 네임스페이스를 사용하며 변수는 로컬입니다. 기능이 완료되면 사라집니다.

Python은 네임스페이스의 내용에 액세스할 수 있는 두 가지 기능을 제공합니다. • locals()는 로컬 네임스페이스의 콘텐츠 사전을 반환합니다.

• globalsyspace는 글로벌 네임스페이스의 내용에 대한 사전을 반환합니다. 그리고 여기서 사용되고 있습니다.

>>> animal = 'fruitbat' >>> def change_local():

>>> print('globals:', globals()) # reformatted a little for presentation globals: {'animal': 'fruitbat',
'__doc__': None,
'change_local': <function change_it at 0x1006c0170>,

'__package__': None,
'__name__': '__main__',
'__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__builtins__': <module 'builtins'>}
>>> animal
'fruitbat'

change_local() 내의 로컬 네임스페이스에는 로컬 변수 동물만 포함되어 있습니다. 글로벌 네임스페이스에는 별도의 글로벌 변수 동물과 여러 가지가 포함되어 있습니다.

Uses of _ and __ in Names

두 개의 밑줄(__)로 시작하고 끝나는 이름은 Python 내에서 사용할 수 있도록 예약되어 있으므로 자신의 변수와 함께 사용하면 안 됩니다. 이 이름 지정 패턴은 응용 프로그램 개발자가 자체 변수에 대해 선택할 가능성이 낮기 때문에 선택되었습니다.

예를 들어, 함수의 이름은 시스템 변수 함수 ._name__에 있으며 문서화 문자열은 함수입니다.__doc__:

>>> def amazing():

... '''This is the amazing function.
... Want to see it again?'''
... print('This function is named:', amazing.__name__)
... print('And its docstring is:', amazing.__doc__) ...
>>> amazing()
This function is named: amazing
And its docstring is: This is the amazing function.
Want to see it again?

앞서 글로벌 인쇄물에서 보셨듯이, 메인 프로그램에는 특별 프로그램이 할당되어 있습니다.

이름 __main_.

Handle Errors with try and except
일부 언어에서는 오류가 특수 함수 반환 값으로 표시됩니다. Python은 관련 오류가 발생할 때 실행되는 코드: 예외를 사용합니다.
위치를 벗어난 목록이나 튜플 또는 존재하지 않는 키를 가진 사전 액세스와 같은 일부 항목이 이미 있습니다. 경우에 따라 실패할 수 있는 코드를 실행하는 경우 잠재적인 오류를 차단하기 위해 적절한 예외 처리기도 필요합니다.
예외가 발생할 수 있는 모든 위치에 예외 처리를 추가하여 사용자에게 상황을 알리는 것이 좋습니다. 문제를 해결하지 못할 수도 있지만 최소한 상황을 확인하고 프로그램을 정상적으로 종료할 수는 있습니다. 일부 기능에서 예외가 발생했지만 해당 기능에서 잡히지 않으면 일부 호출 기능에서 일치하는 핸들러에 잡힐 때까지 거품이 발생합니다. 사용자 고유의 예외 처리기를 제공하지 않는 경우 Python은 오류 메시지와 오류가 발생한 위치에 대한 일부 정보를 인쇄한 후 프로그램을 종료합니다.
>>> short_list = [1, 2, 3]
>>> position = 5
>>> short_list[position]
Traceback (most recent call last):
File "<stdin>", line 1, in <module> IndexError: list index out of range

코드를 운에 맡기지 말고 코드를 래핑해 보십시오. 오류 처리 기능은 예외입니다.

>>> short_list = [1, 2, 3] >>> position = 5
>>> try:
... short_list[position] ... except:

... print('Need a position between 0 and', len(short_list)-1, ' but got', ... position)
...
Need a position between 0 and 2 but got 5

시도 블록 내부의 코드가 실행됩니다. 오류가 발생하면 예외가 발생하고 예외 블록 내부의 코드가 실행됩니다. 오류가 없으면 예외 블록을 건너뜁니다.

여기서처럼 인수가 없는 경우를 제외하고 평면을 지정하는 것은 모든 예외 유형에 대한 캐치올입니다. 둘 이상의 예외 유형이 발생할 수 있는 경우 각 예외 처리기를 별도로 제공하는 것이 가장 좋습니다. 이렇게 하도록 강요하는 사람은 없습니다. 모든 예외를 포착하는 것 외에는 베어(Bare)를 사용할 수 있지만 이러한 예외에 대한 처리가 일반적일 수 있습니다(일부 인쇄 오류가 발생했습니다). 원하는 수의 특정 예외 처리기를 사용할 수 있습니다.

때로는 유형을 벗어난 예외 세부 정보를 원할 수 있습니다. 다음 형식을 사용하는 경우 변수 이름에 전체 예외 개체가 표시됩니다.

except exceptiontype as name

다음 예제에서는 시퀀스에 잘못된 위치를 제공할 때 IndexError가 발생하는 예외 유형이기 때문에 먼저 IndexError를 찾습니다. IndexError 예외는 변수에 저장하고 다른 예외는 변수에 저장합니다. 이 예에서는 다른 항목에 저장된 모든 내용을 인쇄하여 해당 개체에 있는 내용을 보여 줍니다.

>>> short_list = [1, 2, 3] >>> while True:

...
...
...
... try:

value = input('Position [q to quit]? ') if value == 'q':

break

...

Position [q to quit]? 1

Position [q to quit]? 0

Position [q to quit]? 2

Position [q to quit]? 3

Bad index: 3

Position [q to quit]? 2

Position [q to quit]? two
Something else broke: invalid literal for int() with base 10: 'two' Position [q to quit]? q

위치 3을 입력하면 예상대로 인덱스 오류가 발생했습니다. 두 개를 입력하면 두 번째에 처리한 int() 함수가 코드만 제외하고 모두 잡힙니다.

Make Your Own Exceptions

이전 섹션에서는 처리 예외에 대해 설명했지만, 모든 예외(예: IndexError)는 Python 또는 표준 라이브러리에 미리 정의되어 있습니다. 원하는 용도로 사용할 수 있습니다. 또한 프로그램에서 발생할 수 있는 특수한 상황을 처리하기 위해 고유한 예외 유형을 정의할 수도 있습니다.

예외는 수업이다. 예외 클래스의 하위 항목입니다. 대문자라는 예외를 만들자.문자열에 대문자가 있을 경우 예외로 올리고 대문자로 표시합니다.

>>> class UppercaseException(Exception): ... pass
>>> words = ['eeenie', 'meenie', 'miny', 'MO'] >>> for word in words:
... if word.isupper():
... raise UppercaseException(word) ...

Traceback (most recent call last): File "<stdin>", line 3, in <module>

__main__.UppercaseException: MO

대문자에 대한 동작도 정의하지 않았습니다.예외(방금 통과를 사용함)를 통해 상위 클래스인 예외(Exception)가 예외가 발생했을 때 인쇄할 내용을 파악할 수 있습니다.

예외 개체 자체에 액세스하여 인쇄할 수 있습니다.

>>> try:
... raise OopsException('panic') ... except OopsException as exc: ... print(exc)
...
panic

Things to Do

4.1 guess_me 변수에 값 7을 할당합니다. 그런 다음 guess_me가 7보다 작으면 'too low', 7보다 크면 'too high', 7보다 크면 'just right' 문자열을 인쇄하는 조건부 테스트(if, elif)를 작성합니다.

4.2 변수 guess_me에 값 7을, 변수 시작에 값 1을 할당합니다. guess_me와 시작을 비교하는 시간 루프를 작성합니다. 시작이 내 짐작보다 작으면 너무 낮게 인쇄합니다. 시작이 guess_me이면 '찾았다!'를 인쇄하고 루프를 종료합니다. 시작할 경우

루프가 더 크죠

4.3 4.4 사용

4.5 반품 시 a 사용

4.6 사용

4.9 범위(10)에서 홀수를 반환하는 get_odds라는 생성기 함수를 정의합니다. 반환된 세 번째 값을 찾아 인쇄하려면 for 루프를 사용하십시오.

than guess_me, 'oops'를 인쇄하고 루프를 종료합니다. 끝에서 시작 증분

루프에서 목록 값을 인쇄합니다 [3, 2, 1, 0].

(10) 범위의 짝수 목록을 작성하기 위해 이해 목록을 작성합니다.

사전 정사각형을 만들기 위한 사전 이해. 범위(10) 키를 사용하고 각 키의 정사각형을 값으로 사용합니다.

범위(10)의 홀수에서 홀수 집합을 생성하도록 이해를 설정합니다. 발생기 이해는 문자열 'Got'을 반환하고, 값은 값을 반환합니다.

범위(10). for 루프를 사용하여 이 과정을 반복합니다.

4.8 목록을 반환하는 good라는 함수를 정의합니다 ['해리', '론', '헤르미온느'.

4.7 숫자 사용

4.10 함수를 호출할 때 '시작'을 인쇄하고 종료할 때 '끝'을 인쇄하는 테스트라는 데코레이터를 정의합니다.

4.11 OopsException이라는 예외를 정의합니다. 무슨 일이 일어나는지 보려면 이 예외를 제기하십시오. 그런 다음 이 예외를 잡기 위한 코드를 작성하고 'Caught a oops'를 인쇄합니다.

4.12 zipcope을 사용하여 제목 = [습관의 창조물', [크루웰 페이트] 및 플롯 = [수녀가 괴물로 변한다', [유령 실 가게] 목록과 짝을 이루는 영화라는 사전을 만듭니다.

파이썬코드 functions

&$#@ — Sat, 4 Sep 2021 16:58:09 +0900

Functions

지금까지 Python 코드 예는 모두 작은 조각이었습니다. 이러한 기능은 소규모 작업에 유용하지만 항상 조각을 다시 입력하려는 사람은 없습니다. 우리는 더 큰 코드를 관리할 수 있는 조각으로 정리할 수 있는 방법이 필요합니다.

코드 재사용을 위한 첫 번째 단계는 다른 모든 코드와 별도로 명명된 코드 조각입니다. 함수는 임의의 숫자와 유형의 입력 매개 변수를 사용하고 임의의 숫자와 유형의 출력 결과를 반환할 수 있습니다.

기능을 사용하여 두 가지 작업을 수행할 수 있습니다.

• Defineit • Callit

Python 함수를 정의하려면 함수에 대한 입력 매개 변수를 포함하는 함수 이름인 def를 입력하고 마지막으로 콜론(:)을 입력합니다. 함수 이름은 변수 이름과 동일한 규칙을 가집니다(문자 또는 _로 시작하고 문자, 숫자 또는 _만 포함해야 함).

한 번에 한 단계씩 진행하고 먼저 파라미터가 없는 함수를 정의하고 호출합니다. 가장 간단한 Python 함수는 다음과 같습니다.

>>> def do_nothing(): ... pass

이러한 매개변수가 없는 함수의 경우에도 정의에 괄호와 콜론이 필요합니다. if 문장으로 코드를 들여쓰는 것처럼 다음 줄을 들여써야 합니다. Python은 이 기능이 아무것도 하지 않는다는 것을 보여주기 위해 패스 문이 필요합니다. 이 페이지는 더 이상 표시되지 않더라도 일부러 비워둔 페이지와 같습니다.

이름과 괄호를 입력하기만 하면 이 기능을 호출할 수 있습니다. 광고된 대로 작동하며 제대로 작동하는 것은 없습니다.

>>> do_nothing()

>>>

이제 매개 변수는 없지만 단어 하나를 인쇄하는 다른 함수를 정의하여 호출하겠습니다.

>>> def make_a_sound(): ... print('quack') ...
>>> make_a_sound() quack

make_a_sound() 함수를 호출했을 때, Python은 정의 내에서 코드를 실행했습니다. 이 경우, 한 단어를 인쇄하고 메인 프로그램으로 돌아갑니다.

매개 변수는 없지만 값을 반환하는 함수를 시도해 보겠습니다.

>>> def agree(): ... return True ...

다음과 같은 경우 이 함수를 호출하고 반환된 값을 테스트할 수 있습니다.

>>> if agree():
... print('Splendid!')
... else:
... print('That was unexpected.') ...
Splendid!

당신은 방금 큰 발걸음을 내디뎠어요. if 및 loop과 같은 테스트와 함수의 조합은 이전에 할 수 없었던 것을 가능하게 합니다.

이쯤에서 괄호 사이에 무언가를 넣어야 할 때입니다. echo() 함수를 anything 매개 변수 하나로 정의하겠습니다. 반환 문을 사용하여 호출자에게 다음 사이의 공백을 사용하여 값을 두 번 보냅니다.

>>> def echo(anything):
... return anything + ' ' + anything ...
>>>

이제 'Rumplestiltskin' 문자열로 echo()를 호출하겠습니다.

>>> echo('Rumplestiltskin')

'Rumplestiltskin Rumplestiltskin'

함수를 호출할 때 함수에 전달되는 값을 인수라고 합니다. 인수를 사용하여 함수를 호출하면 해당 인수 값이 함수 내부의 해당 매개 변수에 복사됩니다. 이전 예에서는 echo() 함수를 'Rumplestiltskin' 인수 문자열로 호출했습니다. 이 값은 echo() 내에서 매개 변수에 복사된 다음 호출자에게 (이 경우 공백이 두 배로) 반환되었습니다.

이러한 기능 예는 매우 기초적이었다. 입력 인수를 사용하여 실제로 수행하는 함수를 작성해 보겠습니다. 색상에 대한 코멘트가 있는 이전 코드 조각을 수정하겠습니다. 주석이라고 하고 color라는 입력 문자열 매개변수를 사용하도록 합니다. 문자열 설명을 호출자에게 반환하고 호출자는 문자열로 수행할 작업을 결정합니다.

>>> def commentary(color):

...
...
...
...
...
...
... else:
... return "I've never heard of the color " + color + "." ...

>>>

문자열 인수가 'blue'인 함수 주석()을 호출합니다.

>>> comment = commentary('blue')

이 기능은 다음을 수행합니다.

• 함수의 내부 색상 매개변수에 '파란색' 값을 할당합니다

• if-elife-elife 논리 체인을 통해 실행

• 문자열을 반환합니다.

• 변수 설명에 문자열을 할당합니다. 무엇을 다시 얻을 수 있습니까?

>>> print(comment)
I've never heard of the color blue.

함수는 모든 유형의 입력 인수(0 포함)를 수에 제한 없이 사용할 수 있습니다. 모든 유형의 출력 결과(0 포함)를 원하는 수만큼 반환할 수 있습니다. 함수가 명시적으로 호출되지 않으면 호출자는 없음 결과를 얻습니다.

>>> print(do_nothing()) None

None Is Useful

None은 할 말이 없을 때 자리를 유지하는 특별한 Python 값입니다. 부울 값으로 평가하면 거짓으로 표시되지만 부울 값 False와 동일하지는 않습니다. 예는 다음과 같습니다.

>>> thing = None
>>> if thing:
... print("It's some thing") ... else:
... print("It's no thing") ...
It's no thing

없음과 부울 False 값을 구분하려면 Python의 is 연산자를 사용합니다.

>>> if thing is None:
... print("It's nothing") ... else:
... print("It's something") ...
It's nothing

이것은 미묘한 구별처럼 보이지만 Python에서는 중요합니다. 결측값과 빈 값을 구분하려면 없음을 입력해야 합니다. 0 값 정수 또는 부동 소수, 빈 문자열(''), 목록([]), 튜플( (, )), 사전({}) 및 집합( )은 모두 False이지만 없음과 같지는 않습니다.

해당 인수가 없음인지 여부를 인쇄하는 빠른 함수를 작성하겠습니다.

>>> is_none(None)

It's None

>>> is_none(True)

It's True

>>> is_none(False)

It's False

>>> is_none(0)

It's False

>>> is_none(0.0)

It's False

>>> is_none(())

It's False

>>> is_none([])

It's False

>>> is_none({})

It's False

>>> is_none(set())

It's False

위치 인수

Python은 많은 언어에 비해 매우 유연한 방식으로 함수 인수를 처리합니다. 가장 친숙한 인수 유형은 위치 인수이며, 위치 인수의 값은 순서대로 해당 매개 변수에 복사됩니다.

이 함수는 위치 입력 인수를 사용하여 사전을 만들고 다음을 반환합니다.

>>> def menu(wine, entree, dessert):
... return {'wine': wine, 'entree': entree, 'dessert': dessert} ...
>>> menu('chardonnay', 'chicken', 'cake')
{'dessert': 'cake', 'wine': 'chardonnay', 'entree': 'chicken'}

매우 흔하지만, 위치 논쟁의 단점은 각 위치의 의미를 다시 기억할 필요가 있다는 것입니다. 만약 우리가 잊고 와인과 함께 메뉴()를 첫 번째가 아닌 마지막 논쟁으로 부른다면, 식사는 매우 달라질 것이다.

>>> menu('beef', 'bagel', 'bordeaux')

{'dessert': 'bordeaux', 'wine': 'beef', 'entree': 'bagel'}

키워드 인수

위치 인수의 혼동을 방지하기 위해 함수의 정의와 다른 순서로 인수를 해당 매개 변수의 이름으로 지정할 수 있습니다.

>>> menu(entree='beef', dessert='bagel', wine='bordeaux')

{'dessert': 'bagel', 'wine': 'bordeaux', 'entree': 'beef'}

위치 인수와 키워드 인수를 혼합할 수 있습니다. 와인을 먼저 지정하고, 메뉴와 디저트에 키워드 인수를 사용합니다.

>>> menu('frontenac', dessert='flan', entree='fish')

{'entree': 'fish', 'dessert': 'flan', 'wine': 'frontenac'}

위치 인수와 키워드 인수가 모두 포함된 함수를 호출할 경우 위치 인수가 먼저 와야 합니다.

기본 매개변수 값 지정

매개변수에 대한 기본값을 지정할 수 있습니다. 호출자가 해당 인수를 제공하지 않는 경우 기본값이 사용됩니다. 이 싱겁게 들리는 기능은 실제로 매우 유용할 수 있습니다. 이전 예제를 사용하여:

>>> def menu(wine, entree, dessert='pudding'):
... return {'wine': wine, 'entree': entree, 'dessert': dessert}

이번에는 디저트 인수 없이 메뉴()를 호출해 보십시오.

>>> menu('chardonnay', 'chicken')

{'dessert': 'pudding', 'wine': 'chardonnay', 'entree': 'chicken'}

인수를 제공하면 기본값 대신 사용됩니다.

>>> menu('dunkelfelder', 'duck', 'doughnut')

{'dessert': 'doughnut', 'wine': 'dunkelfelder', 'entree': 'duck'}

기본 인수 값은 함수를 실행할 때가 아니라 함수를 정의할 때 계산됩니다. 새로운 Python 프로그래머의 일반적인 오류는 목록이나 사전과 같은 가변 데이터 유형을 기본 인수로 사용하는 것입니다.

다음 테스트에서 buggy() 함수는 매번 빈 결과 목록과 함께 실행되고 arg 인수를 추가한 다음 단일 항목 목록을 인쇄해야 합니다. 하지만 버그가 있습니다. 처음 호출했을 때만 비어 있습니다. 두 번째로, 결과는 여전히 이전 통화의 항목 하나를 가지고 있습니다.

>>> def buggy(arg, result=[]): ... result.append(arg) ... print(result)
...

>>> buggy('a')
['a']
>>> buggy('b') # expect ['b'] ['a', 'b']

다음과 같이 작성되었더라면 작동했을 것입니다.

>>> def works(arg):
... result = []
... result.append(arg) ... return result
...
>>> works('a')
['a']
>>> works('b')
['b']

수정 사항은 다른 정보를 전달하여 첫 번째 통화를 나타내는 것입니다.

>>> def nonbuggy(arg, result=None): ... if result is None:
... result = []
... result.append(arg)

... print(result) ...
>>> nonbuggy('a') ['a']

>>> nonbuggy('b')

['b']

*를 사용하여 위치 인수 수집

C 또는 C++에서 프로그래밍한 경우 Python 프로그램의 별표(*)가 포인터와 관련이 있다고 가정할 수 있습니다. 아니요, Python은 포인터가 없습니다.

함수 내부에서 매개변수와 함께 사용할 경우 별표는 변수 개수의 위치 인수를 매개변수 값의 튜플로 그룹화합니다. 다음 예에서 args는 print_args() 함수에 전달된 인수에서 비롯된 매개 변수 튜플입니다.

>>> def print_args(*args):
... print('Positional argument tuple:', args) ...

인수를 사용하지 않고 호출하면 *args에서 아무 것도 얻을 수 없습니다.

>>> print_args()

Positional argument tuple: ()

무엇을 주든 인수 튜플로 인쇄됩니다.

>>> print_args(3, 2, 1, 'wait!', 'uh...')

Positional argument tuple: (3, 2, 1, 'wait!', 'uh...')

이는 변수 개수의 인수를 허용하는 print()와 같은 함수를 작성할 때 유용합니다. 함수에 필요한 위치 인수도 있는 경우 *args는 끝에 가서 나머지 항목을 모두 잡습니다.

>>> def print_more(required1, required2, *args): ... print('Need this one:', required1)

... print('Need this one too:', required2)
... print('All the rest:', args)
...
>>> print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax') Need this one: cap
Need this one too: gloves
All the rest: ('scarf', 'monocle', 'mustache wax')

*를 사용할 때 tuple 매개 변수 args를 호출할 필요는 없지만 Python에서는 일반적인 관용어입니다.

**를 사용하여 키워드 인수 수집

두 개의 별표(**)를 사용하여 키워드 인수를 사전으로 그룹화할 수 있습니다. 여기서 인수 이름은 키이고 값은 해당 사전 값입니다. 다음은 키워드 인수를 인쇄하는 print_kwargs() 함수를 정의하는 예제입니다.

>>> def print_kwargs(**kwargs):
... print('Keyword arguments:', kwargs) ...

이제 키워드 인수를 사용하여 호출해 보십시오.

>>> print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')

Keyword arguments: {'dessert': 'macaroon', 'wine': 'merlot', 'entree': 'mutton'}

함수에 들어 있는 콰르그스는 사전입니다.

위치 매개변수를 *args 및 **kwargs와 혼합할 경우 해당 순서에 따라 발생해야 합니다. args와 마찬가지로 이 키워드 매개 변수를 kwargs라고 할 필요는 없지만 일반적으로 사용됩니다.

문서 문자열

Python의 Zen은 가독성이 중요하다고 말합니다. 함수 본문 시작 부분에 문자열을 포함시켜 설명서를 함수 정의에 첨부할 수 있습니다. 다음은 함수의 docstring입니다.

>>> def echo(anything):

... 'echo returns its input argument'
... return anything

원하는 경우 다음과 같이 문서 문자열을 상당히 길게 만들고 리치 형식을 추가할 수도 있습니다.

def print_if_true(thing, check): '''
Prints the first argument if a second argument is true.
The operation is:
1. Check whether the *second* argument is true.

2. If it is, print the *first* argument.

'''

if check: print(thing)

함수의 docstring을 인쇄하려면 Python help() 함수를 호출합니다. 함수의 이름을 전달하여 멋진 형식의 docstring과 함께 인수 목록을 가져옵니다.

>>> help(echo)
Help on function echo in module __main__:

echo(anything)

echo returns its input argument

형식을 사용하지 않고 원시 문서 문자열만 보려면:

>>> print(echo.__doc__)
echo returns its input argument

이상하게 생긴 __doc__은(는) 함수 내에서 변수로서 docstring의 내부 이름입니다. 103페이지의 "이름에서 _ 및 __의 사용"은 이 모든 밑줄 뒤에 숨겨진 이유를 설명합니다.

Functions Are First-Class Citizens

파이썬의 모토를 언급했는데, 모든 것은 객체입니다. 여기에는 숫자, 문자열, 튜플, 목록, 사전 및 함수가 포함됩니다. 함수는 Python의 일급 시민권입니다. 변수를 변수에 할당하고 다른 함수에 인수로 사용하고 함수에서 반환할 수 있습니다. 이를 통해 다른 많은 언어로 수행하기가 어려운 Python에서 몇 가지 작업을 수행할 수 있습니다.

이를 테스트하기 위해 인수 없이 42만 인쇄하는 answer()라는 간단한 함수를 정의하겠습니다.

>>> def answer(): ... print(42)

이 기능을 실행하면 다음과 같은 결과를 얻을 수 있습니다.

>>> answer()

이제 run_something이라는 다른 함수를 정의하겠습니다. 실행할 함수인 func라는 인수가 하나 있습니다. 일단 안으로 들어가면, 기능을 호출할 뿐입니다.

>>> def run_something(func): ... func()

run_something()에 대한 답변을 전달하면 다른 thing와 마찬가지로 함수를 데이터로 사용합니다.

>>> run_something(answer)

답변()이 아닌 답변을 전달했습니다. Python에서 이 괄호는 이 함수를 호출하는 것을 의미합니다. 괄호 없이 Python은 다른 객체처럼 함수를 처리합니다. 다른 모든 Python과 마찬가지로 Python도 객체이기 때문입니다.

>>> type(run_something) <class 'function'>

인수를 사용하여 함수를 실행해 보겠습니다. arg1과 arg2 두 숫자 인수의 합을 인쇄하는 add_args() 함수를 정의합니다.

>>> def add_args(arg1, arg2): ... print(arg1 + arg2)

add_args()는 무엇입니까?

>>> type(add_args)

이 시점에서 run_something_with_args()라는 함수를 정의하자.

인수:

• 기능—실행 기능

• arg1—펑크의 첫 번째 인수

• arg2—함수에 대한 두 번째 인수

>>> def run_something_with_args(func, arg1, arg2): ... func(arg1, arg2)

run_something_with_args()를 호출할 때 호출자가 전달한 함수는 func 매개 변수에 할당되고 arg1과 arg2는 인수 목록에 이어지는 값을 가져옵니다. 그런 다음 괄호가 Python에게 명령했기 때문에 실행 중인 func(arg1, arg2)는 이러한 인수를 사용하여 해당 함수를 실행합니다.

function name add_args와 un_something_with_args() 인수 5와 9를 전달하여 테스트해 봅시다.

>>> run_something_with_args(add_args, 5, 9)

run_something_with_args() 함수 내에서 add_args 함수는 func 매개 변수에 할당되었고, 5는 arg1에 할당되었으며, 9는 arg2에 할당되었습니다. 이 작업은 실행되었습니다.

add_args(5, 9)

이를 *args 및 **kwargs 기법과 결합할 수 있습니다.

임의의 수의 위치 인수를 사용하고 합() 함수를 사용하여 합계를 계산한 다음 합계를 반환하는 검정 함수를 정의하겠습니다.

>>> def sum_args(*args): ... return sum(args)

나는 이전에 합계를 언급한 적이 없다. 이 함수는 기본 제공 Python 함수로, int 또는 float 인수의 값 합계를 계산합니다.

함수와 이 함수에 전달하기 위한 임의의 수의 위치 인수를 사용하는 새 함수 run_with_positional_args()를 정의합니다.

>>> def run_with_positional_args(func, *args): ... return func(*args)

자, 어서 불러봐:

>>> run_with_positional_args(sum_args, 1, 2, 3, 4)

Inner Functions

다른 함수 내에서 함수를 정의할 수 있습니다.

>>> def outer(a, b):

...

>>>

>>> outer(4, 7)

내부 기능은 루프 또는 코드 중복을 방지하기 위해 다른 기능 내에서 복잡한 작업을 두 번 이상 수행할 때 유용합니다. 문자열 예제의 경우 이 내부 함수는 인수에 일부 텍스트를 추가합니다.

파이썬코드 Iterate Multiple Sequences with zip()

&$#@ — Fri, 3 Sep 2021 21:48:12 +0900

Iterate Multiple Sequences with zip()

zip() 함수를 사용하여 여러 시퀀스에 걸쳐 병렬로 반복하는 멋진 반복 트릭이 하나 더 있습니다

.>>> days = ['Monday', 'Tuesday', 'Wednesday']
>>> fruits = ['banana', 'orange', 'peach']
>>> drinks = ['coffee', 'tea', 'beer']
>>> desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']
>>> for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts): ... print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert) ...

Monday : drink coffee - eat banana - enjoy tiramisu

Tuesday : drink tea - eat orange - enjoy ice cream

Wednesday : drink beer - eat peach - enjoy pie

최단 시퀀스가 완료되면 zip이 중지됩니다. 목록(후식) 중 하나가 다른 목록보다 길어서 다른 목록을 확장하지 않으면 푸딩을 받을 수 없습니다.

이전포스팅의 "사전"은 딕트() 함수가 튜플, 목록 또는 문자열과 같은 두 항목 시퀀스에서 사전을 작성하는 방법을 보여줍니다. zip()을 사용하여 여러 시퀀스를 거닐고 동일한 간격띄우기에 있는 항목에서 튜플을 만들 수 있습니다. 해당하는 영어 단어와 프랑스어 단어 두 튜플을 만들어 봅시다.

>>> english = 'Monday', 'Tuesday', 'Wednesday'

>>> french = 'Lundi', 'Mardi', 'Mercredi'

이제 zip()을 사용하여 이 튜플을 페어링합니다. zip()으로 반환되는 값 자체는 튜플이나 목록이 아니라 다음 중 하나로 변환될 수 있는 테이블 값입니다.

>>> list( zip(english, french) )

[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]

zip()의 결과를 dict()에 직접 입력하고 voilà: 작은 영어-프랑스어 사전!

>>> dict( zip(english, french) )

{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}

Generate Number Sequences with range()

range() 함수는 지정된 범위 내의 숫자 스트림을 반환합니다. 먼저 목록이나 튜플과 같은 큰 데이터 구조를 만들고 저장할 필요가 없습니다. 이렇게 하면 컴퓨터의 모든 메모리를 사용하지 않고 프로그램을 손상시키지 않고도 큰 범위를 만들 수 있습니다.

범위()는 슬라이스를 사용하는 방법과 유사하게 사용합니다. 범위(시작, 중지, 단계) 시작을 생략하면 범위는 0에서 시작됩니다. 필요한 값은 중지뿐이며, 슬라이스와 마찬가지로 마지막으로 생성된 값은 중지 직전입니다. 스텝의 기본값은 1이지만 -1로 뒤로 돌아갈 수 있습니다.

zip()과 마찬가지로 range()는 테이블 가능한 개체를 반환하므로 ...에 대한 값을 단계별로 이동하거나 개체를 목록과 같은 시퀀스로 변환해야 합니다. 범위를 0, 1, 2로 설정합니다.

>>> for x in range(0,3): ... print(x)
...
0

>>> list( range(0, 3) )

[0, 1, 2]

다음은 2 ~ 0 범위를 만드는 방법입니다.

>>> for x in range(2, -1, -1): ... print(x)
...
2

>>> list( range(2, -1, -1) )

[2, 1, 0]

다음은 스텝 크기 2를 사용하여 0에서 10 사이의 짝수를 가져옵니다.

>>> list( range(0, 11, 2) )

[0,2,4,6,8,10]

Other Iterators

다음포스팅에서는 파일에 대한 반복을 보여줍니다. 이전포스팅에서는 사용자가 직접 정의한 객체 위에 반복을 설정하는 방법을 볼 수 있습니다.

Comprehensions

이해는 한 명 이상의 반복기에서 Python 데이터 구조를 만드는 간단한 방법입니다. 이해를 통해 루프와 조건부 테스트를 세부 구문을 적게 조합할 수 있습니다. 이해력을 사용하는 것은 때때로 당신이 파이썬을 초보자 이상 알고 있다는 신호로 받아들여집니다. 다시 말해, 피토닉에 가깝죠.

List Comprehensions

이렇게 한 번에 한 항목씩 1부터 5까지의 정수 목록을 작성할 수 있습니다.

>>> number_list = []
>>> number_list.append(1) >>> number_list.append(2) >>> number_list.append(3) >>> number_list.append(4) >>> number_list.append(5) >>> number_list [1,2,3,4,5]

또는 반복기와 범위() 함수를 사용할 수도 있습니다.

>>> number_list = []
>>> for number in range(1, 6): ... number_list.append(number) ...
>>> number_list
[1,2,3,4,5]

또는 범위()의 출력을 목록으로 직접 변환할 수 있습니다.

>>> number_list = list(range(1, 6)) >>> number_list
[1,2,3,4,5]

이러한 접근 방식은 모두 유효한 Python 코드이며 동일한 결과를 생성합니다. 그러나 목록을 작성하는 더 많은 피토닉 방법은 목록 이해를 사용하는 것입니다. 목록 이해의 가장 간단한 형태는 다음과 같습니다.

[ 아이템에 대한 식을(를) 반복할 수 없습니다.

다음은 목록 이해에서 정수 목록을 작성하는 방법입니다.

>>> number_list = [number for number in range(1,6)] >>> number_list
[1,2,3,4,5]

첫 번째 행에서 목록의 값을 생성하기 위한 첫 번째 숫자 변수가 필요합니다. 즉, 루프 결과를 number_list에 넣습니다. 두 번째 숫자는 for 루프의 일부입니다. 첫 번째 숫자가 식임을 표시하려면 다음 변형을 시도해 보십시오.

>>> number_list = [number-1 for number in range(1,6)] >>> number_list
[0,1,2,3,4]

목록 이해에 따라 대괄호 안의 루프가 이동합니다. 이 이해 예시는 이전 예보다 간단하지 않지만, 더 있습니다. list comà 이해에는 다음과 같은 조건식이 포함될 수 있습니다.

[ 조건일 경우 반복할 수 없는 항목에 대한 표현식 ]

1과 5 사이의 홀수 목록만 작성하는 새로운 이해를 만들어 봅시다(홀수일 경우 %2이 참이고 짝수일 경우 거짓임을 기억하십시오.

>>> a_list = [number for number in range(1,6) if number % 2 == 1] >>> a_list
[1, 3, 5]

이제, 이해는 전통적인 이해 방식보다 조금 더 좁습니다.

>>> a_list = []
>>> for number in range(1,6): ... ifnumber%2==1:

...

>>> a_list

[1, 3, 5]

a_list.append(number)

마지막으로, 내포된 루프가 있을 수 있는 것처럼, 해당 이해에 ...용 절이 두 개 이상 있을 수 있습니다. 먼저 일반 중첩 루프를 사용해 결과를 인쇄해 보겠습니다.

>>> rows = range(1,4) >>> cols = range(1,3) >>> for row in rows:

... for col in cols:
... print(row, col)

...

11 12 21 22 31 32

이제 이해를 사용하여 변수 셀에 할당하여 (행, 콜) 튜플 목록을 만듭니다.

>>> rows = range(1,4)
>>> cols = range(1,3)
>>> cells = [(row, col) for row in rows for col in cols] >>> for cell in cells:
... print(cell)
...
(1, 1)
(1, 2)
(2, 1)
(2, 2)
(3, 1)
(3, 2)

또한 튜플 언팩을 사용하여 셀 목록에서 반복하면서 각 튜플의 행 및 col 값을 유크할 수 있습니다.

>>> for row, col in cells: ... print(row, col) ...
11

12 21 22 31 32

앞줄과 뒷줄에 대한 이해도의 파편도 만약 테스트를 했다면 그들만의 파편을 가질 수 있었을 것이다.

Dictionary Comprehensions

단순히 목록만으로 뒤지지 않기 위해 사전도 이해력이 있다. 가장 간단한 양식은 친숙해 보입니다.

{key_expression : interitable 식에 대한 value_expression}

목록 이해와 마찬가지로 사전 이해도 테스트와 사전 이해도 함께 가질 수 있습니다.

절의 경우 다중:

>>> word = 'letters'

>>> letter_counts = {letter: word.count(letter) for letter in word}

>>> letter_counts

{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

우리는 '문자' 문자열의 일곱 글자 각각에 루프를 돌리고 그 글자가 몇 번 표시되는지 세고 있습니다. 우리가 사용하는 단어 중 두 개는 모든 e와 모든 t를 두 번 세야 하기 때문에 시간 낭비입니다. 하지만, 우리가 e를 두 번째로 셀 때, 우리는 이미 있던 사전의 항목을 교체하기 때문에 해를 끼치지 않습니다; t를 셀 때도 마찬가지입니다. 그래서, 다음은 조금 더 피토닉했을 것이다.

>>> word = 'letters'
>>> letter_counts = {letter: word.count(letter) for letter in set(word)} >>> letter_counts
{'t': 2, 'l': 1, 'e': 2, 'r': 1, 's': 1}

집합(워드)을 반복하면 문자열 단어를 반복하는 순서와 다른 순서로 문자가 반환되기 때문에 사전의 키는 이전 예와 다른 순서로 정렬됩니다.

Set Comprehensions

누구도 소외되고 싶어하지 않기 때문에 세트도 이해력이 있다. 가장 간단한 버전은 방금 본 목록과 사전 이해도처럼 보입니다.

{식 interitable}

긴 버전(테스트의 경우 절에 대해 여러 개)도 다음 집합에 대해 유효합니다.

>>> a_set = {number for number in range(1,6) if number % 3 == 1} >>> a_set
{1, 4}

Generator Comprehensions

튜플은 이해력이 없습니다! 목록 이해의 대괄호를 괄호로 변경하면 튜플 이해가 생성된다고 생각했을 수 있습니다. 그리고 다음과 같이 입력하면 예외가 없기 때문에 작동하는 것으로 보입니다.

>>> number_thing = (number for number in range(1, 6))

괄호 사이에 있는 것은 발전기 이해이며, 그것은 gen‐를 반환한다.

연산자 객체:

>>> type(number_thing)

<class 'generator'>

발전기에 대해 더 자세히 알아보겠습니다(98페이지의 "발전기"). 발전기는 한 가지 방법이다.

반복자에게 데이터를 제공합니다.

다음 그림과 같이 이 생성기 개체에 대해 직접 반복할 수 있습니다.

>>> for number in number_thing: ... print(number)
...
1

2 3 4 5

또는 생성기 이해에 목록() 통화를 줄여서 목록 이해처럼 작동할 수 있습니다.

>>> number_list = list(number_thing) >>> number_list
[1,2,3,4,5]

생성기는 한 번만 실행할 수 있습니다. 목록, 세트, 문자열 및 사전은 메모리에 존재하지만 생성기는 즉시 값을 생성하여 반복기를 통해 한 번에 하나씩 전달합니다. 이러한 구성 요소를 기억하지 못하므로 생성기를 다시 시작하거나 백업할 수 없습니다.

이 제너레이터를 다시 반복하려고 하면 다음과 같이 탭이 되어 있습니다.

>>> try_again = list(number_thing)

>>> try_again

[]

여기서와 같이 발전기를 이해하거나 발전기 기능을 통해 발전기를 만들 수 있습니다. 먼저 일반적인 기능에 대해 이야기한 후 발전기 기능의 특수한 사례에 대해 알아보겠습니다.

파이썬코드구조

&$#@ — Fri, 3 Sep 2021 02:54:38 +0900

대부분의 코드 예제는 대화형 인터프리터를 사용했으며 짧았습니다. 이제 데이터뿐만 아니라 Python 코드 구조화 방법에 대해 알아보겠습니다.

많은 컴퓨터 언어는 코드 섹션을 표시하기 위해 중괄호({ 및 })와 같은 문자 또는 시작 및 끝과 같은 키워드를 사용합니다. 이러한 언어에서는 일관된 들여쓰기를 사용하여 자신과 다른 사용자가 프로그램을 더 잘 읽을 수 있도록 하는 것이 좋습니다. 코드 라인업을 깔끔하게 할 수 있는 도구도 있습니다.

그가 파이썬이 된 언어를 디자인할 때 Guido van Rossum은 들여쓰기 자체만으로도 프로그램의 구조를 정의하기에 충분하다고 판단하고 모든 괄호와 곱슬곱슬한 중괄호를 입력하는 것을 피했다. Python은 프로그램 구조를 정의하기 위해 이렇게 공간을 사용하는 경우는 흔하지 않습니다. 신입들이 가장 먼저 주목하는 부분 중 하나이며, 다른 언어를 접해본 경험이 있는 사람들에게는 이상하게 보일 수 있다. 알고 보니 Python을 잠시 쓰고 나면 자연스럽고 더 이상 눈치채지 못하게 된다. 더 적게 타이핑하면서 더 많은 것을 하는 것에 익숙해지기도 합니다.

Comment with #

주석은 프로그램에서 Python 해석기에서 무시되는 텍스트입니다. 주석을 사용하여 근처의 Python 코드를 명확히 하거나, 언젠가 수정하기 위해 스스로 메모를 하거나, 원하는 목적을 위해 메모를 할 수 있습니다. # 문자를 사용하여 설명을 표시하면 해당 시점부터 현재 줄 끝까지 모두 설명의 일부입니다. 일반적으로 다음과 같이 줄 자체에 설명이 표시됩니다.

>>> # 60 sec/min * 60 min/hr * 24 hr/day

>>> seconds_per_day = 86400

또는 코드와 같은 줄에 다음과 같이 언급합니다.

>>> seconds_per_day = 86400 # 60 sec/min * 60 min/hr * 24 hr/day

캐릭터는 해시, 샤프, 파운드 또는 사악한 옥토 소프의 여러 이름을 가집니다.1 당신이 뭐라고 부르든, 2의 효과는 그것이 나타나는 선의 끝까지만 지속됩니다.

Python에는 여러 줄의 설명이 없습니다. #로 각 주석 줄 또는 섹션을 명시적으로 시작해야 합니다.

>>> # I can say anything here, even if Python doesn't like it, ... # because I'm protected by the awesome
... # octothorpe.
...

>>>

그러나 텍스트 문자열에 있는 경우 강력한 옥토소프는 일반 # 문자 역할로 돌아갑니다.

>>> print("No comment: quotes make the # harmless.") No comment: quotes make the # harmless.

Continue Lines with \

줄이 상당히 짧을 때 프로그램을 더 잘 읽을 수 있습니다. 권장(필수는 아님) 최대 행 길이는 80자입니다. 하고 싶은 말을 다 할 수 없는 경우에는 연속 문자 \(백슬래시)를 사용할 수 있습니다. 줄 끝에 \를 붙이면 Python이 갑자기 같은 줄에 서 있는 것처럼 행동합니다.

예를 들어, 작은 문자열로 긴 문자열을 작성하려면 다음과 같은 단계를 거치면 됩니다.

>>> alphabet = ''

>>> alphabet += 'abcdefg'

>>> alphabet += 'hijklmnop'

>>> alphabet += 'qrstuv'

>>> alphabet += 'wxyz'

또는 연속 문자를 사용하여 한 번에 수행할 수 있습니다.

>>> alphabet = 'abcdefg' + \

... 'hijklmnop' + \
... 'qrstuv' + \
... 'wxyz'

Python 식이 여러 줄로 확장되는 경우에도 줄 연속성이 필요합니다.

>>>1+2+
File "<stdin>", line 1

1+2+ ^

SyntaxError: invalid syntax >>>1+2+\
... 3
6

>>>

Compare with if, elif, and else

지금까지 포스팅에서 우리는 거의 전적으로 데이터 구조에 대해 이야기했습니다. 이제 데이터를 프로그램으로 엮는 코드 구조에 첫 발을 내디뎠습니다(세트에 관한 이전 장의 섹션에서 이러한 내용을 미리 볼 수 있습니다). 지속적인 피해가 없었으면 좋겠다.) 첫 번째 예는 부울 변수 재해의 값을 확인하고 적절한 주석을 인쇄하는 작은 Python 프로그램입니다.

>>> disaster = True >>> if disaster:
... print("Woe!") ... else:

... print("Whee!") ...
Woe!
>>>

if 및 else 행은 조건(여기서 재해 값)이 True인지 여부를 확인하는 Python 문입니다. Print()는 일반적으로 화면에 인쇄하는 Python의 내장 기능입니다.

다른 언어로 프로그래밍한 경우에는 if 테스트에 괄호가 필요하지 않습니다. 만약(재앙 == 진실) 같은 말은 하지 마라. 끝에 콜론(:)이 필요합니다. 나처럼 가끔 콜론을 입력하지 않으면 Python이 오류 메시지를 표시합니다.

각 인쇄() 라인은 테스트 아래에 들여씁니다. 네 칸을 이용해서 각 부문을 들여보냈지 원하는 모든 들여쓰기를 사용할 수 있지만 Python은 섹션 내의 코드에 일관성을 유지해야 합니다. 왼쪽 줄에 있는 줄에 같은 양을 들여써야 합니다. PEP-8이라고 불리는 권장 스타일은 네 개의 공간을 사용하는 것입니다. 탭을 사용하거나 탭과 공백을 섞지 마십시오. 들여쓰기 카운트를 망칩니다.

여기서는 여러 가지 작업을 수행했습니다. 챕터가 진행됨에 따라 자세히 설명하겠습니다.

• Disaster라는 변수에 True 부울 값 할당

• 재해의 가치에 따라 다른 코드를 실행하고 if와 other를 사용하여 조건부 비교 수행

• 일부 텍스트를 인쇄하기 위해 인쇄() 함수 호출

필요한 만큼 깊이 있는 테스트를 테스트 내에서 수행할 수 있습니다.

>>> furry = True
>>> small = True
>>> if furry:
... if small:
... print("It's a cat.") ... else:
... print("It's a bear!") ... else:
... if small:
... print("It's a skink!") ... else:
... print("It's a human. Or a hairless bear.") ...
It's a cat.

Python에서 들여쓰기는 if 섹션과 다른 섹션의 쌍을 지정하는 방법을 결정합니다. 우리의 첫 번째 테스트는 털을 확인하는 것이었다. 털북숭이가 사실이기 때문에, Python은 작으면 움푹 들어간 곳으로 간다. 작으면 True로 설정했기 때문에 작으면 True로 평가됩니다. 그래서 Python은 다음 줄을 실행시켜서 인쇄하게 됩니다. 고양이입니다.

테스트할 수 있는 가능성이 세 개 이상인 경우, elif(다른 경우 의미) 및 다음을 사용합니다.를 사용합니다.

>>> color = "puce"
>>> if color == "red":
... print("It's a tomato")
... elif color == "green":
... print("It's a green pepper")
... elif color == "bee purple":
... print("I don't know what it is, but only bees can see it") ... else:
... print("I've never heard of the color", color)
...
I've never heard of the color puce

앞의 예에서는 == 연산자와 동일한지 테스트했습니다. Python의 비교 연산자는 다음과 같습니다.

equality == inequality != less than <

less than or equal <= greater than > greater than or equal >= membership in ...

그러면 부울 값이 True 또는 False로 반환됩니다. 이 모든 기능이 어떻게 작동하는지 살펴보겠습니다. 먼저 x에 값을 할당합니다.

>>>x=7

이제 몇 가지 테스트를 해보겠습니다.

>>>x==5 False >>>x==7 True >>>5<x True >>>x<10 True

동일성을 검정하는 데 두 등호(==)가 사용됩니다. 단일 등호(=)는 변수에 값을 할당하는 데 사용됩니다.

동시에 여러 번 비교해야 하는 경우 부울 연산자를 사용하고 최종 부울 결과를 결정하지 않습니다.

부울 연산자는 비교 중인 코드 청크보다 우선 순위가 낮습니다. 즉, 덩어리를 먼저 계산한 다음 비교한다는 뜻입니다. 이 예에서는 xx를 7,5 < x로 설정하고 x < 10도 True로 계산하기 때문에 최종적으로 True와 True를 사용합니다.

>>>5<xandx<10 True

이전내용의 "우선 순위"가 지적하듯이, 우선순위에 대한 혼란을 피하는 가장 쉬운 방법은 괄호를 추가하는 것입니다.

>>>(5<x)and(x<10) True

다음은 몇 가지 다른 테스트입니다.

>>>5<xorx<10 True >>>5<xandx>10 False >>>5<xandnotx>10 True

하나의 변수를 사용하여 다중 비교를 수행하는 경우 Python을 사용하면 다음과 같은 작업을 수행할 수 있습니다.

>>>5<x<10 True

5<x>와 10<x>와 같습니다. 더 긴 비교를 작성할 수도 있습니다.

>>>5<x<10<999

True

무엇이 진실인가?

우리가 검사하는 요소가 부울이 아니라면요? Python에서 True와 False로 간주하는 것은 무엇입니까?

거짓 값이 반드시 False일 필요는 없습니다. 예를 들어, 다음 항목은 모두 False로 간주됩니다.

boolean False null None zero integer 0
zero float 0.0 empty string '' empty list [] empty tuple () empty dict {} empty set set()

다른 모든 것은 사실로 간주됩니다. Python 프로그램은 이 "truthiness"(또는 이 경우 "false") 정의를 사용하여 빈 데이터 구조와 False 조건을 확인합니다.

>>> some_list = []
>>> if some_list:
... print("There's something in here") ... else:
... print("Hey, it's empty!")
...
Hey, it's empty!

테스트하는 것이 단순 변수가 아닌 표현식인 경우 Python은 표현식을 평가하고 부울 결과를 반환합니다. 따라서 다음을 입력하면 됩니다.

if color == "red":

Python은 색상 == "빨간색"을 평가합니다. 이 예에서는 puce라는 문자열을

color == "red"는 False이고 Python은 다음 테스트로 이동합니다.

elif color == "green":

Repeat with while

위에서 아래로 실행되는지, 엘프 또는 다른지를 사용하여 테스트합니다. 가끔, 우리는 한 번 이상 무언가를 해야 합니다. 우리는 루프가 필요합니다. 파이썬의 가장 간단한 루핑 메커니즘은 while입니다. 대화형 인터프리터를 사용하여 다음 예제를 시도해 보십시오. 1에서 5까지의 숫자를 인쇄하는 간단한 루프입니다.

>>> count = 1
>>> while count <= 5: ... print(count) ... count += 1 ...
1
2
3
4
5
>>>

우리는 먼저 셀 값 1을 할당했습니다. 반면 루프는 카운트의 값을 5와 비교하고 카운트가 5보다 작거나 같으면 계속했습니다. 루프 내부에서 count 값을 출력한 다음 count + = 1 문장으로 값을 1씩 증가시켰습니다. Python은 루프의 맨 위로 돌아가서 카운트를 다시 5와 비교합니다. count 값이 2가 되므로 while loop의 내용이 다시 실행되어 count가 3으로 증가합니다.

이는 루프 하단에서 카운트가 5에서 6으로 증가할 때까지 계속됩니다. 다음 번에 맨 위로 이동할 때 카운트 = 5가 이제 False가 되고 while 루프가 종료됩니다. Python은 다음 행으로 넘어갑니다.

Cancel with break

문제가 발생할 때까지 루프를 수행하려고 하지만 언제 발생할지 확신할 수 없는 경우 중단 문과 함께 무한 루프를 사용할 수 있습니다. 이번에는 Python의 입력() 함수를 통해 키보드의 입력 줄을 읽고 첫 글자를 대문자로 인쇄하겠습니다. 문자 q만 포함된 줄을 입력하면 루프가 해제됩니다.

>>> while True:

… stuff = input(“string to capitalize [Type q quit]: “)

... it stuff == “q” :

... brake

... print(stuff.capitalize())

String to capitalize [type q to quit]: test

Test

String to capitalize [type q to quit]: hey, it works

Hey, it works

String to capitalize [type q to quit]: q

>>>

stuff = input("String to capitalize [type q to quit]: ")

Skip Ahead with continue

때로는 루프에서 벗어나고 싶지 않고 어떤 이유로든 다음 반복으로 건너뛰고 싶을 때가 있습니다. 다음은 계획된 예입니다. 정수를 읽고, 정사각형이 홀수이면 인쇄하고, 짝수이면 건너뜁시다. 댓글 몇 개 달았어요. 다시 q를 사용하여 루프를 중지합니다.

>>> while True:
Integer, please [q to quit]: 1 1 squared is 1

value = input("Integer, please [q to quit]: ") if value == 'q': # quit

break

number = int(value)
if number % 2 == 0: # an even number

continue
print(number, "squared is", number*number)

Integer, please [q to quit]: 2 Integer, please [q to quit]: 3 3 squared is 9
Integer, please [q to quit]: 4 Integer, please [q to quit]: 5 5 squared is 25

Integer, please [q to quit]: q

>>>

Iterate with for

Python은 그럴듯한 이유로 반복기를 자주 사용합니다. 데이터 구조의 크기나 구현 방법을 알지 못한 채 데이터 구조를 이동할 수 있습니다. 즉석에서 생성된 데이터 위에 반복할 수도 있으므로, 그렇지 않으면 컴퓨터 메모리에 맞지 않는 데이터 스트림을 한 번에 처리할 수 있습니다.

다음과 같은 시퀀스를 밟는 것은 합법적인 Python입니다.

>>> rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter'] >>> current = 0
>>> while current < len(rabbits):
... print(rabbits[current])

... current += 1

...

Flopsy

Mopsy

Cottontail

Peter

하지만 더 좋은, 더 피토닉한 방법이 있다.

>>> for rabbit in rabbits: ... print(rabbit)
...
Flopsy

Mopsy

Cottontail

Peter

토끼와 같은 목록은 문자열, 튜플, 사전, 세트 및 기타 일부 요소와 함께 Python에서 쉽게 사용할 수 있는 개체 중 하나입니다. 튜플 또는 목록 반복은 한 번에 항목을 생성합니다. 문자열 반복은 다음과 같이 한 번에 문자를 생성합니다.

>>> word = 'cat'
>>> for letter in word: ... print(letter) ...
c
a
t

사전(또는 해당 키() 함수) 위에 반복하면 키가 반환됩니다. 이 예제에서 키는 보드 게임 Clou(북미 이외의 클루도)에 있는 카드 유형입니다.

>>> accusation = {'room': 'ballroom', 'weapon': 'lead pipe',

'person': 'Col. Mustard'}

>>> for card in accusation: # or, for card in accusation.keys(): ... print(card)
...
room

weapon

person

키 대신 값을 반복하려면 사전의 값() 함수를 사용합니다.

>>> for value in accusation.values(): ... print(value)
...
ballroom

lead pipe

Col. Mustard

튜플의 키와 값을 모두 반환하려면 다음과 같은 항목() 함수를 사용합니다.

>>> for item in accusation.items(): ... print(item)
...
('room', 'ballroom')

('weapon', 'lead pipe')

('person', 'Col. Mustard')

한 번에 튜플에 할당할 수 있습니다. 항목()으로 반환되는 각 튜플에 대해 첫 번째 값(키)을 카드에 할당하고 두 번째 값(값)을 내용에 할당합니다.

>>> for card, contents in accusation.items():
... print('Card', card, 'has the contents', contents) ...
Card weapon has the contents lead pipe
Card person has the contents Col. Mustard
Card room has the contents ballroom

Cancel with break

잠시 동안처럼 a 루프의 중단이 루프를 벗어나게 됩니다.

Skip with continue

for 루프에 계속을 삽입하면 잠시 동안처럼 루프의 다음 반복으로 점프합니다.

Check break Use with else

for에는 정상적으로 완료되었는지 여부를 확인하는 다른 옵션이 있습니다. break가 호출되지 않은 경우 다른 문이 실행됩니다.

이 기능은 루프의 이전 항목이 중단으로 조기에 중지되는 대신 완료로 실행되었는지 확인하려는 경우에 유용합니다. 다음 예제의 for 루프에는 치즈의 이름이 인쇄되어 있으며 치즈 가게에서 치즈가 발견되면 파손됩니다.

>>> cheeses = []
>>> for cheese in cheeses:
... print('This shop has some lovely', cheese)
... break
... else: # no break means no cheese
... print('This is not much of a cheese shop, is it?') ...
This is not much of a cheese shop, is it?