Python 에서 None True False 의 차이 점 에 대해 서 말씀 드 리 겠 습 니 다.

None 는 True False 와 마찬가지 로 불 값 이지 만
None 은 어떤 데이터 도 표시 하지 않 지만 중요 한 역할 을 한다.
그것 과 False 사이 의 차 이 는 여전히 매우 크다!
예:

>>> t = None
>>> if t:
... print("something")
... else:
... print("nothing")
...
nothing

None 와 False 를 구분 합 니 다.is 를 사용 하여 조작 합 니 다!

>>> if t is None:
... print("this is None!")
... else:
... print("this is ELSE!")
...
this is None!
>>>

작은 차이 지만!하지만 파 이 썬 에 서 는 중요 합 니 다.None 와 값 이 없 는 빈 데이터 구 조 를 분리 해 야 합 니 다.
0 값 의 정형/부동 소수점 형,빈 문자열('),빈 목록([]),빈 원본 그룹({}),빈 집합(set()은 모두 false 와 같 지만 None 와 같 지 않 습 니 다.
이제 함수 쓰기:

>>> def oj(t):
... if t is None:
... print("this is None")
... elif t:
... print("this is True")
... else:
... print("this is False")
...

데이터 테스트 진행:

>>> oj(None)
this is None
>>> oj(True)
this is True
>>> oj(False)
this is False
>>> oj(0)
this is False
>>> oj(0.0)
this is False
>>> oj([])
this is False
>>> oj(())
this is False
>>> oj({})
this is False

이상 설명,None,False,True 는 많이 다 릅 니 다~
python"0.3==3*0.1"이 False 인 이유
도입
해석 기 에 다음 첫 번 째 줄 코드 를 입력 하면:
>>> 0.3 == 3 * 0.1
False
출력 이 False 라 는 것 을 알 게 될 것 입 니 다.
CS 소 백 으로 서 는 이해 하기 어렵다.
그래서 나 는 관련 자 료 를 찾 아 총 결 을 했다.
2.부동 소수점 알고리즘 의 문제 와 한계
1.컴퓨터 하드웨어 의 부동 소수점 처리 방식
우선,우 리 는 한 가지 일 을 알 아야 한다.부동 소수점 은 컴퓨터 하드웨어 에서 기수 2(이 진)의 점 수 를 나타 낸다.
예 를 들 면:
0.125(10) == 1/10 + 2/100 + 5/1000
0.001(2) == 0/2 + 0/4 + 0/8
이 두 점 수 는 같은 값 을 가지 고 있 으 며,유일한 실제 차 이 는 첫 번 째 점 수 는 10 을 기수 로 하고,두 번 째 점 수 는 2 를 기수 로 하 는 것 이다.우리 가 0.125 를 입력 할 때 컴퓨터 하드웨어 는 첫 번 째 가 아니 라 두 번 째 방식 으로 표시 된다.
그러나 불 행 히 도 대부분의 10 진법 점 수 는 2 진법 점수 로 완전히 표시 되 지 않 는 다.
결 과 는 일반적으로 우리 가 입력 하 는 10 진 부동 소수점 은 컴퓨터 에 실제 저 장 된 2 진 부동 소수점 에 불과 하 다 는 것 이다.
근사 하 다.그러나 10 진법 이 2 진법 점수 로 완전히 표시 되 지 않 는 상황 에서 아무리 비슷 해도 정확 한 값 은 아니다.
2.예:0.1 의 처리
예 를 들 어 0.1(10)은 우리 가 몇 개의 2 자리 숫자 를 사용 하 든 10 진법 값 0.1 은 2 진법 소수,즉 2 를 밑 으로 하 는 1/10 은 무한 중복 점수 로 정확하게 표시 할 수 없다.
0.1(10) == 0.0001100110011001100110011001100110011001100110011...(2)
우리 가 그것 을 한 정 된 자릿수 에 멈 추 게 하면 유사 치 를 얻 을 수 있다.
Python 부동 소수점 은 53 비트 정밀 도 를 사용 할 수 있 기 때문에,
따라서 10 진 수 를 입력 할 때 컴퓨터 내부 에 저 장 된 값 은 0.1 입 니 다.
0.00011001100110011001100110011001100110011001100110011010(2)
이 값 은 비슷 하지만 1/10 은 아니다.
print(0.3===3*0.1)출력 을 False 로 만 든 이유 다.
python 출력 컴퓨터 에 저 장 된 0.1 의 실제 10 진 값 을 강제로 사용 하려 면
>>> 0.1
0.1000000000000000055511151231257827021181583404541015625
이 숫자 는 너무 길 기 때문에 Python 은 반올림 값 을 표시 함으로써 숫자의 관리 성 을 유지 합 니 다.그래서 실제로 우리 가 본 것 은:
>>> 0.1
0.1
그러나 우 리 는 기계 의 값 이 완전히 1/10 이 아니 라 실제 기계 값 의 표시 일 뿐 이라는 것 을 알 아야 한다.
3.재 미 있 는 것들
위 에서 언급 한 바 와 같이 Python 은 반올림 값 을 표시 함으로써 숫자의 관리 성 을 유지 합 니 다.우리 가 본 것 은 실제 기계 값 의 표시 만 반올림 한 것 입 니 다.아래 의 예 를 통 해 우 리 는 이 사실 을 더욱 잘 알 수 있다.
우리 가 python 으로 아래 의 코드 를 썼 을 때,이 신기 한 현상 을 발견 할 수 있 을 것 이다.
이것 은 본질 적 으로 이 진 부동 소수점 입 니 다.이것 은 Python 의 bug 도 아니 고 코드 의 bug 도 아 닙 니 다.하드웨어 부동 소수점 산술 을 지원 하 는 모든 언어 에서 같은 것 을 볼 수 있 습 니 다.
1）0.1+0.2
>>> 0.1 + 0.2
0.30000000000000004
2）round(2.675， 2)
i)round(x[,n])의 용법
역할:부동 소수점 x 의 반올림 값 을 되 돌려 줍 니 다.
인자:
x C 수치/수치 표현 식.
n.C 가 유지 할 소수 자릿수 는 생략 할 수 있 습 니 다.생략 하면 n 은 기본 값 이 0,즉 반올림 에서 정수 로 들 어 갑 니 다.
ii)round( 2.675, 2)
우리 의 논리 에 따 르 면 round(2.675,2)를 입력 하면 출력 은 2.68 이 어야 한다.하지만 사실은:
>>> round(2.675, 2)
2.67
3.오류 표시(선택)
여기 서 우 리 는'0.1'예 시 를 상세 하 게 설명 하고 우리 가 어떻게 이런 상황 에 대해 정확 한 분석 을 하 는 지 설명 한다.만약 네가 그 배후 의 원인 을 깊이 연구 하고 싶 지 않다 면,아래 의 것 은 소홀히 해도 된다.
1.잘못된 개념,영향 과 원인 을 나타 낸다.
(1)개념
오 류 를 나타 내 는 것 은 일부(실제 에서 대부분)소수 부분 이 바 이 너 리(기수 2)점 수 를 완전히 표시 하지 못 하 는 것 을 말한다.
(2)영향
Python(또는 Perl,C,C++,자바,Fortran 및 기타 많은 언어)은 우리 가 원 하 는 정확 한 십 진법 숫자 를 자주 표시 하지 않 습 니 다.
(3)원인
현재 거의 모든 기계 가 IEEE-754 부동 소수점 알고리즘 을 사용 하고 거의 모든 플랫폼 이 Python 부동 소수점 을 IEEE-754'쌍 정밀도'에 투사 합 니 다.754 개의 double 은 53 비트 의 정 도 를 포함 하기 때문에 입력 할 때 컴퓨터 는 부동 소수점 을 J/2**N 형식의 가장 가 까 운 점수 로 바 꾸 려 고 노력 하 는데 그 중에서 J 는 53 비트 를 딱 포함 하 는 정수 이다.
2.'0.1'의 구체 적 인 분석
전환 목표:1/10~=J/(2**N)
그래서:J~=2**N/10
1)구 해 N
J 는 53 비트 를 딱 포함 하 는 정수(그러나 실제로 마지막 으로 우리 가 사용 하 는 것 은 J 의 근사치(>=2**52 and<2**53)이 고 N 은 하나의 정수 이기 때문에 우 리 는 N 의 최 적 치 는 56 이다.

>>> 2**52
4503599627370496
>>> 2**53
9007199254740992
>>> 2**56/10
7205759403792793

2)우리 가 쓸 J 의 근사 치 를 구한다
우 리 는 N 을 통 해 실제 J 를 구한다.우리 가 실제로 사용 하 는 J 는 사실(2**N/10)반올림 후의 값 이다.
i)divmod(a, b)
기능:두 개의 숫자 형식(비 복수)인 자 를 받 고 상과 나머지 를 포함 하 는 원 그룹(a//b,a%b)을 되 돌려 줍 니 다.
인자:
a C 피제수
b.C 나 누 기
ii)구 해 J 근사 값

>>> q, r = divmod(2**56, 10)
>>> r
6

나머지 는 6>5 이기 때문에 우리 가 사용 하 는 J 의 유사 치 는?
>>> q+1
7205759403792794
3)"0.1"의 근사치 풀이
따라서 754 배 정밀도 중 1/10 에 가장 가 까 운 가장 좋 은 유사 치 는?
7205759403792794 / 72057594037927936
[주]우 리 는 반올림 하기 때문에 실제로 1/10 보다 조금 크다.만약 우리 가 반올림 을 하지 않 는 다 면,상 사 는 1/10 보다 작 을 것 이다.하지만 어떤 상황 에서 도 1/10 이 될 수 는 없다!
4)컴퓨터 메모리 값 가 져 오기
위의 분석 을 통 해 우 리 는 컴퓨터 가 1/10 을 영원히 볼 수 없다 는 것 을 알 수 있다.그것 은 위 에서 제시 한 정확 한 점 수 를 볼 수 있 고 가장 좋 은 754 배 유사 치(즉,J 의 유사 치)를 얻 을 수 있다.
>>> .1 * 2**56
7205759403792794.0
만약 우리 가 이 점 수 를 10**30 으로 곱 하면,우 리 는 그 30 개의 최고 유효 10 진 숫자의(절단)값 을 볼 수 있다.
>>> 7205759403792794 * 10**30 // 2**56
100000000000000005551115123125L
Python 2.7 과 Python 3.1 이전 버 전에 서 Python 은 이 값 을 반올림 하여 17 개의 유효 숫자,즉'0.1000000000000001'로 합 쳤 다.
최신 버 전에 서 Python 은 가장 짧 은 10 진법 점수 에 따라 값 을 표시 합 니 다.이 값 은 실제 바 이 너 리 값 으로 정확하게 반올림 되 고'0.1'만 얻 을 수 있 습 니 다.
위 에서 언급 한 Python 에서 None True False 의 차이 점 은 바로 편집장 이 여러분 에 게 공유 한 모든 내용 입 니 다.여러분 께 참고 가 되 었 으 면 좋 겠 습 니 다.여러분 들 도 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.