Python으로 코딩할 때 주의해야 할 사항을 요약합니다.

1. map, filter, Reduce
1) map(func, input_list)
다음과 같이 입력 목록의 각 요소에 함수를 적용합니다.
input_list = [1, 2, 3, 4, 5]

def pow_elem(x):
"""
x
의 전원 연산을 수행합니다 :param x:
:return:
"""
return x * x

def multi_x_y(x, y):
return x * y

print map(pow_elem, input_list) # 출력:[1, 4, 9, 16, 25]

print map(multi_x_y, input_list, input_list) # 출력:[1, 4, 9, 16, 25]

2) filter(func_or_none, 시퀀스)
함수 반환 True를 만족하는 시퀀스의 값을 필터링하고 다음과 같은 새 시퀀스 반환을 형성합니다.
def is_odd(x):
"""
여부를 결정합니다. x는 홀수입니다
: param x:
:return:
"""
return True if x % 2 > 0 else False

print filter(is_odd, input_list) # 출력: [1, 3, 5]

3) Reduce(함수, 시퀀스)
reduce() 함수가 전달하는 매개변수는 map(), 함수 f 및 리스트와 유사하지만, 행위는 map()과 다릅니다. ()는 두 개의 매개변수를 받아야 합니다. 각 요소에 대해 함수 f를 반복적으로 호출하고 최종 결과 값을 반환해야 합니다. 예를 들어, Reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])는 ((((1+2)+3)+4)+5)
print 감소( lambda x, y: x * y, input_list) # 출력: 120

2. 삼항 연산
다음 두 가지 작성 방법은 동일합니다:
"Yes" if 2==2 else "No"
("No", "예")[2==2]
즉:
1) 조건_is_true if 조건 else 조건_is_false
2) (if_test_is_false, if_test_is_true)[test]
1) 및 2) 둘 다 삼항 연산을 구현할 수 있지만 2)는 상대적입니다. 희귀하고 매우 우아하지 않으며 2) 다음과 같이 단락 연산이 아닙니다.
5 if True else 5/0 # 출력: 5
(1/0, 5)[True] # 예외 발생-> ZeroDivisionError: 0으로 정수 나누기 또는 모듈로

3. Decorator
1) Python에서는 다음과 같이 함수를 정의하고 함수 내에서 호출할 수 있습니다.
def hi(name="patty"):
print("now you hi() 함수 내부에 있습니다. ") GDef Greet ():

Return" 이제 Greeting() 함수 "

def Welcome ():

Return"에 있습니다. 이제 Welcome() 함수에 있습니다. "

Print (GREET ())

print(welcome())

print("이제 hi() 함수로 돌아왔습니다.")
출력 결과는 다음과 같습니다:
이제 hi() 함수 안에 있습니다
이제 당신은 Greeting() 함수
이제 Welcome() 함수에 있습니다
이제 hi() 함수로 돌아왔습니다

2) 내부 함수를 반환하고 외부 함수를 사용하여 호출할 수도 있습니다. 예를 들면 다음과 같습니다.

def hi(name="patty"):

def Greeting():
                                                                                                사용   def        using using using   def        using using  ‐               ‐                                   through   through through through through through through through through through through through out through off ‐ ‐ return ‐ return "이제 당신은 be in the Greeting() function"

def Welcome():

           welcome

print hi() #

print hi()() # 이제 당신은 Greeting() 함수에 있습니다

위 코드에서 hi() 호출은 함수 객체를 반환하는데, 이는 if/else 문을 통해 hi()() 호출 시 실제로 내부 함수를 호출하는 것으로 판단할 수 있습니다. 환영하다().

3) 함수를 다른 함수에 매개변수로 전달합니다. 예:
def hi():
return "hi patty!"

def doSomethingBeforeHi(func):
print("실행하기 전에 지루한 작업을 하고 있습니다. hi ()")
print(func())

doSomethingBeforeHi(hi)
출력 결과:
hi()를 실행하기 전에 지루한 작업을 하고 있습니다

hi patty!

이 시점에서 간단한 데코레이터를 구현했습니다. hi() 함수를 호출하기 전에 한 줄을 출력합니다. 실제 응용 프로그램에서는 일부 전처리 작업이 있을 수 있습니다. 실제로 데코레이터의 기능은 핵심 로직이 실행되기 전후에 몇 가지 공통 기능을 추가하는 것입니다.

4) 간단한 데코레이터 구현
def a_new_decator(a_func):

def WrapTheFunction():

print("a_func()를 실행하기 전에 지루한 작업을 하고 있습니다.")

a_func() # 이 함수 호출

print("a_func()를 실행한 후 지루한 작업을 하고 있습니다.")

return WrapTheFunction

def a_function_requiring_장식():

print("나는 고약한 냄새를 제거하기 위해 장식이 필요한 함수입니다.")

a_function_requiring_장식( )

#outputs: "나는 내 더러운 냄새를 제거하기 위해 장식이 필요한 함수입니다."

a_function_requiring_장식 = a_new_ decorator(a_function_requiring_장식)

#이제 a_function_requiring_장식은 WrapTheFunction()으로 래핑됩니다

a_function_requiring_장식()
# a_func()을 실행하기 전에 지루한 작업을 하고 있습니다
# 악취를 제거하기 위해 장식이 필요한 함수입니다
# a_func()를 실행한 후 지루한 작업을 하고 있습니다

5) 참고 Form
@a_new_ decorator
def b_function_requiring_장식():
print("나는 내 더러운 냄새를 제거하기 위해 장식이 필요한 또 다른 함수입니다.")

b_function_requiring_장식()
# a_func()을 실행하기 전에 지루한 작업을 하고 있습니다
# 나는 고약한 냄새를 제거하기 위해 장식이 필요한 또 다른 함수입니다
# a_func()를 실행한 후 지루한 작업을 하고 있습니다
여기서 @a_new_designator는 a_new_ decorator(b_function_requiring_장식)

6) 이름 가져오기
for 4) a_function_requiring_장식에서 , print(a_function_requiring_장식.__name__)을 인쇄하고 결과는 WrapTheFunction입니다. 실제로 우리가 얻고자 하는 것은 a_func에 해당하는 a_function_requiring_장식 함수 이름입니다. Python은 이 문제를 해결하기 위해 랩을 제공합니다.
from functools import Wraps
def a_new_decator(a_func):
@wraps(a_func)
def WrapTheFunction():
print("a_func()를 실행하기 전에 지루한 작업을 하고 있습니다.")

a_func()

print( "a_func()를 실행한 후 지루한 작업을 하고 있습니다.")

return WrapTheFunction

7) 데코레이터의 일부 응용 시나리오
사용자 인증
def require_auth(f):
@wraps(f)
def Decorated(*args , **kwargs):
auth = {"username": "patty", "password": "123456"}
그렇지 않은 경우 check_auth(auth['username'], auth['password']):
authenticate()
return f(*args, **kwargs)

def check_auth(사용자 이름, 비밀번호):
                                                                                off else False

def authenticate():
print "이미 인증됨"
return decorated

@requires_auth

def Welcome() :
return "패티를 환영합니다!"

print Welcome()

logging

def logit( func):
@wraps(func)
def with_logging(*args, **kwargs):
print(func.__name__ + " 호출됨")
return func(*args, **kwargs)
return with_logging

@ logit

def added_func(x):
"""수학을 좀 해보세요."""
return x + x

result = 추가_func(4)
이 인쇄됩니다: 추가_func가 호출되었습니다

8) 매개변수가 있는 데코레이터

from functools import Wraps

def logit(logfile='out.log'):

def 로깅_장식자(func):
@wraps(func)
def Wrapped_function(*args, **kwargs):
log_string = func.__name__ + "가 호출되었습니다."
                                                      인쇄(log_string)                  Opened_file.write(log_string + 'n') W Wrapped_function
return login_Decorator

@logit()을 반환합니다.
Def myfunc1 ():
Pass

myfunc1 ()

# OUNC1 WAS Called

# OU T.LOG NOW라는 파일이 존재하며 위의 문자열

@@@@ t logit(logfile='func2.log' )

def myfunc2():

pass

myfunc2()

9) 클래스를 데코레이터로 사용
import os
class Logit(object):

def __init__(self, log_file) ; (log_msg) R Fout.write (OS .LINESEP)

# 이제 알림 보내기

Self.notify ()

Def Notify (Self):
# 로그만 기록하고 더 이상
패스하지 마세요

class EmailLogit(Logit):
'''
함수가 호출될 때 관리자
에게 이메일을 보내기 위한 logit 구현입니다.
''''
def __init__(self, log_file, email='admin@myproject.com') :
                                                                                                                                , 'a') f:
                  f.write("뭔가를 하세요....")

               f.write(os.linesep)

                 |

@로짓( "log1.txt")
def myfunc3():
pass

@EmailLogit("log2.txt")
def myfunc4():

pass

클래스를 데코레이터로 사용하면 코드가 더 간결해 보이고 다음을 달성할 수도 있습니다. 상속을 통한 기능의 개인화 및 재사용.

4. 변수 유형
Python의 변수 유형에는 목록과 사전이 포함됩니다. 예:

>>> foo = ['hi']

>> ['패티']
>>> foo
['안녕', '패티']
>>> foo[0]='hello'

>> ', 'patty']

>>fdict = {"name":"patty"}
>>> fdict.update({"age":"23"})
>> ;>fdict
{'age': '23', 'name': 'patty'}
>>> fdict.update({"age":"25"})>> fdict
{'age': '25', 'name': 'patty'}

메서드에서 들어오는 매개변수가 변수 유형이고 기본값이 할당된 경우 다음과 같은 상황이 발생하므로 주의하세요.

> ;>> def add_to(num, target=[]):

... target.append(num)
... return target
...
>>> add_to(1)
[1 ]
>>> add_to(2)
[1, 2]

>>> add_to(3)

[1, 2, 3]
기본 매개변수가 Calculated 메소드에 정의되어 있기 때문입니다. 호출할 때마다 다시 계산하는 대신 호출할 때 따라서 위의 상황을 피하기 위해 메소드가 호출될 때마다 새로운 빈 목록으로 계산할 것으로 예상되는 경우 다음과 같이 작성할 수 있습니다.
>>> def add_to(num, target=None) :
... 대상이 없음인 경우:
... target = []
... target.append(num)
... return target
...
>>> add_to(1)
[1]
>>> add_to(2)
[2]

5. 얕은 복사와 깊은 복사
Python에서는 객체 할당과 복사(깊은/얕은 복사)에 차이가 있습니다. 사용시 주의하지 마세요. 예상치 못한 결과가 발생할 수 있습니다.
1) Python의 기본 얕은 복사 방법
>>> foo = ['hi']
>> bar = foo
>> id(foo)
4458211232
> >> id(bar)
4458211232

>>> bar.append("patty")

>>bar
['hi', 'patty']
>> foo
['hi', 'patty']
참고: id(foo)==id(bar), foo와 bar가 동일한 객체를 참조함을 나타냅니다. bar 참조를 통해 목록에 추가 작업이 수행되면, 지적된 메모리 공간은 동일하고 foo의 출력은 bar의 출력과 일치합니다.

2) 딥 카피
>>foo
['hi', {'age': 20, 'name': 'patty'}]
>>> > 느림 = copy.deepcopy(foo)
>>> 느림
['hi', {'age': 20, 'name': 'patty'}]
>>> ]='hello'
>>> 느림
['hello', {'age': 20, 'name': 'patty'}]

>>> foo

['hi', { 'age': 20, 'name': 'patty'}]
참고: Slow는 foo의 전체 복사본이므로 실제로 메모리에 새 공간을 열고 foo 객체가 참조하는 콘텐츠를 foo의 새 공간에 복사합니다. 메모리 공간이므로 느린 객체가 참조하는 내용이 업데이트되면 변경 사항은 느린 객체의 참조에만 반영되고 foo 객체가 참조하는 내용은 변경되지 않습니다.

6.Collection
1) defaultdict
일반 dict의 경우 존재하지 않는 키를 얻으면 다음과 같이 KeyError가 발생합니다.
some_dict = {}
some_dict['colours']['favourite'] = " yellow"
#Raises KeyError: 'colours'
하지만 defaultdict를 통해 다음과 같이 이 상황을 피할 수 있습니다:
import collections
import json
tree = Lambda: collections.defaultdict(tree)
some_dict = tree()
some_dict[ 'colours']['favourite'] = "yellow"
print json.dumps(some_dict)
# 잘 작동하고 출력: {"colours": {"favourite": "yellow"}}

2) OrderedDict
OrderedDict 사전을 정의할 때 키 순서대로 사전을 인쇄할 수 있습니다. value 값을 변경해도 키 순서는 변경되지 않습니다. 그러나 키를 삭제하고 다시 삽입하면 키 순서가 변경됩니다. 딕셔너리 끝.
from collections import OrderedDict

colours = OrderedDict([("Red", 198), ("Green", 170), ("Blue", 160)])
for 키, 값 colors.items():
print(key, value)

3) Counter
Counter를 사용하여 다음과 같은 특정 항목의 발생 횟수를 계산합니다.
from collections import Counter

colours = (
('Yasoob', 'Yellow'),
( '알리', '블루'),
('아르함', '그린'),
('알리', '블랙'),
('야수브', '레드'),
('아메드', '실버') ') ,
)

favs = Counter(이름 이름, 색상 색상)
print(favs)
# Counter({'Yasoob': 2, 'Ali': 2, 'Arham': 1, 'Ahmed' : 1 })

4) deque
deque는 다음과 같이 헤드와 테일에 각각 삽입하고 삭제할 수 있는 양방향 큐입니다.
from collections import deque
queue_d = deque()
queue_d.append( 1)
queue_d.append (2)
print queue_d # deque([1, 2])
queue_d.appendleft(3)
print queue_d # deque([3, 1, 2])

queue_d.pop()
print queue_d # deque([ 3, 1])
queue_d.popleft()
print queue_d # deque([1])

deque는 요소 수가 최대 길이를 초과하는 경우 대기열의 최대 길이를 설정할 수 있습니다. 해당 요소는 현재 삽입 방향의 반대 방향에서 삭제됩니다. 요소 수는 다음과 같습니다.
queue_c = deque(maxlen=5, iterable=[2, 4, 6])
queue_c.extend([7, 8])
print queue_c # deque([2, 4, 6, 7 , 8], maxlen=5)
queue_c.extend([10, 12])
print(queue_c) # deque([6, 7, 8 , 10, 12], maxlen=5)
queue_c.extendleft([18 ])
print(queue_c) # deque([18, 6, 7, 8, 10], maxlen=5)

5) nametuple
tuple 불변 목록이며 튜플의 요소는 재할당될 수 없습니다. 튜플의 요소는 인덱스를 통해서만 액세스할 수 있습니다. 네임튜플은 불변의 사전으로 간주될 수 있으며, 튜플의 요소는 이름을 통해 액세스할 수 있습니다. 예:
from collections import namestuple

Animal =namedtuple('동물', '이름 연령 유형')
perry = Animal(name="perry", age=31, type="cat")

print(perry )
# 출력: Animal(name='perry', age=31, type='cat')

print(perry.name)
# 출력: 'perry'

print(perry[0])
# 출력 : 'perry'

print(perry._asdict())
# 출력: OrderedDict([('name', 'perry'), ('age', 31), ('type', 'cat')])

7. 객체 내부 검사
1) dir: 객체의 모든 메소드 나열
2) type: 객체의 유형 반환
3) id: 객체의 ID 반환

8) list
> ;>> 제곱 = [범위(10) 내 x의 경우 x**2]
>>>
2) dict
{v: k for k, v in some_dict.items()}
3) set
>>> squared = {x**2 for x in range(10)}
>> ;> 제곱
set([0, 1, 4, 81, 64, 9, 16, 49, 25, 36])

9. 예외 처리

try:

print('예외가 없을 것이라고 확신합니다. 발생!')
제외 예외:
print('예외')
else:
# try에서 예외가 발생하지 않은 경우에만 실행해야 하는 코드,
# 예외가 포착되지 않아야 하는 코드
print('이것은 예외가 발생하지 않는 경우에만 실행하세요. 그리고 여기에 '
'가 포착되지 않을 것입니다.')
finally:
print('이것은 모든 경우에 인쇄됩니다.')

# 출력: 예외가 발생하지 않을 것이라고 확신합니다.

# 예외가 발생하지 않는 경우에만 실행됩니다.

# 모든 ​​경우에 인쇄됩니다.
else의 문은 finally 전에 실행됩니다.

10. 내장 메소드

a_list = [[1, 2], [3, 4], [5, 6]]

print(list(itertools.chain.from_iterable(a_list)))
# 출력: [ 1, 2, 3, 4, 5, 6]

# 또는

print(list(itertools.chain(*a_list)))

# 출력: [1, 2, 3, 4, 5, 6]

클래스 A(객체):
def __init__(self, a, b, c, d, e, f):
self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})

11. for-else 문
for 문을 종료하는 일반적인 방법에는 두 가지가 있습니다. 하나는 특정 조건이 충족될 때 루프에서 벗어나는 것이고, 다른 하나는 모든 것을 종료하는 것입니다. 조건부 루프. for-else의 else 문은 다음과 같이 모든 조건이 판단되고 for 루프가 정상적으로 끝나는 경우에만 실행됩니다.
for x in range(1, 10, 2):
if x % 2 == 0 ; 모듈은 Python 2+ 환경에서 Python 3+ 모듈을 참조합니다
2) 호환 가능한 모듈 가져오기 방법
try:
import urllib.request as urllib_request #(Python 3의 경우)
importError:
import urllib2 as urllib_request #(Python 2

)
참조:

위 내용은 Python으로 코딩할 때 주의해야 할 사항을 요약합니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!