불변형 및 가변형

불변형 및 가변형

나는 불변의 유형이 무엇인지 혼란스럽다. i i i i i i ifloat이치노제 책의 예를 들어 다음과 같습니다.

class RoundFloat(float):
    def __new__(cls, val):
        return float.__new__(cls, round(val, 2))

은 클래스 구조 구조 즉, '클래스 구조/계층'은 불변으로 간주됩니까?float는 클래스 최상위이며 자체 메서드 호출입니다.내에는 비록 ).dict（ ） :

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

한편, 다음과 같은 유형의 예와 같이 클래스 내에 메서드가 있습니다.

class SortedKeyDict_a(dict):
    def example(self):
        return self.keys()

---

마지막 ★★★★★★★★★★★★★★★★★★★★★★★★★★★」class(SortedKeyDict_a) 「」, 「 」 」, 「 」, 「 」, 「 」, 「 」, 「 」, 「 」, 「 」, 「 」, 「 」, 「 」

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

하지 않고example사전을 SortedKeyDict__new__이치노.RoundFloat의 __new__에러 플래그가 붙어 있지 않습니다.

뭐? 플로트는 불변의 존재라고?하지만 난 할 수 없어

x = 5.0
x += 7.0
print x # 12.0

X가 "변형"되지 않나요?

끈은 불변의 것이라는 데 동의하죠?하지만 너도 똑같이 할 수 있어.

s = 'foo'
s += 'bar'
print s # foobar

변수 값은 변경되지만 변수가 참조하는 내용을 변경함으로써 변경됩니다.가변 유형은 이러한 방식으로 변경될 수 있으며 "적합"할 수도 있습니다.

여기 그 차액입니다.

x = something # immutable type
print x
func(x)
print x # prints the same thing

x = something # mutable type
print x
func(x)
print x # might print something different

x = something # immutable type
y = x
print x
# some statement that operates on y
print x # prints the same thing

x = something # mutable type
y = x
print x
# some statement that operates on y
print x # might print something different

구체적인 예

x = 'foo'
y = x
print x # foo
y += 'bar'
print x # foo

x = [1, 2, 3]
y = x
print x # [1, 2, 3]
y += [3, 2, 1]
print x # [1, 2, 3, 3, 2, 1]

def func(val):
    val += 'bar'

x = 'foo'
print x # foo
func(x)
print x # foo

def func(val):
    val += [3, 2, 1]

x = [1, 2, 3]
print x # [1, 2, 3]
func(x)
print x # [1, 2, 3, 3, 2, 1]

Python은 모든 데이터를 개체로 나타낸다는 것을 이해해야 합니다.목록 및 사전과 같은 이러한 개체 중 일부는 변경할 수 있습니다. 즉, ID를 변경하지 않고도 컨텐츠를 변경할 수 있습니다.정수, 플로트, 문자열 및 튜플과 같은 다른 개체는 변경할 수 없습니다.쉽게 이해할 수 있는 방법은 오브젝트 ID를 확인하는 것입니다.

이치노그 내용은 변경할 수 없습니다. 이이가 .TypeError바꾸려고 하면.또한 새로운 콘텐츠를 할당하면 콘텐츠가 수정되는 대신 새로운 오브젝트가 생성됩니다.

>>> s = "abc"
>>> id(s)
4702124
>>> s[0] 
'a'
>>> s[0] = "o"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = "xyz"
>>> id(s)
4800100
>>> s += "uvw"
>>> id(s)
4800500

이 작업은 목록을 사용하여 수행할 수 있으며 개체 ID는 변경되지 않습니다.

>>> i = [1,2,3]
>>> id(i)
2146718700
>>> i[0] 
1
>>> i[0] = 7
>>> id(i)
2146718700

Python의 데이터 모델에 대한 자세한 내용은 Python 언어 참조를 참조하십시오.

• Python 2 데이터 모델
• Python 3 데이터 모델

공통 불변 유형:

1. ★★★★★★★int(),float(),complex()
2. 의 시퀀스: " " " " "str(),tuple(),frozenset(),bytes()

일반적인 가변 유형(기타 거의 모든 것):

1. 시퀀스: " " " "list(),bytearray()
2. type: " " " " " 입니다.set()
3. 유형: " " " " :dict()
4. 클래스, 클래스 인스턴스
5. 기타.

테스트하기 중 는 '변환 가능을 사용하는 입니다.id()내장 기능.

예를 들어, 정수에서 사용하는 경우,

>>> i = 1
>>> id(i)
***704
>>> i += 1
>>> i
2
>>> id(i)
***736 (different from ***704)

목록에 사용,

>>> a = [1]
>>> id(a)
***416
>>> a.append(2)
>>> a
[1, 2]
>>> id(a)
***416 (same with the above id)

우선 클래스에 메서드가 있는지 또는 클래스 구조가 무엇인지 여부는 변동성과 무관합니다.

int §float는 불변합니다.내가 하면

a = 1
a += 5

은 이름을 있습니다.a1에는 '''가 표시되어 .1 , 를 합니다.5 취득, 취득6, 으로 포인트, 포인트, 포인트, "a 때6기억 속에서 --그것은 그 기억의 변화시키지 않았다.1 a까지6어떤 식으로든.다른 불변의 유형을 사용하여 다음 예에도 동일한 논리가 적용됩니다.

b = 'some string'
b += 'some other string'
c = ('some', 'tuple')
c += ('some', 'other', 'tuple')

가변 타입의 경우 메모리에 저장되는 값을 실질적으로 변경하는 작업을 수행할 수 있습니다.포함:

d = [1, 2, 3]

그 장소의 리스트를 작성했습니다1,2 , , , , 입니다.3 가 한다면

e = d

그냥 가리키기만 하면 돼e똑같이 d츠키다을 사용하다

e += [4, 5]

둘 다 e ★★★★★★★★★★★★★★★★★」d of of of of points points 、 、 will points points points points points points points 。4 ★★★★★★★★★★★★★★★★★」5기억 속에.

내가 불변의 타입으로 돌아가면tuple::

f = (1, 2, 3)
g = f
g += (4, 5)

그리고 그리고나서f여전히 원본만 가리키고 있습니다.g전혀 새로운 곳에서

이제 예를 들어

class SortedKeyDict(dict):
    def __new__(cls, val):
        return dict.__new__(cls, val.clear())

네가 지나가는 곳

d = (('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2))

( 있는(이것은tuple의의tuples)로 계산 로서val왜냐하면에러가 발생하는다음과 같습니다 이유는으면 오류가 발생하고 있다.tupleS는에는 없습니다가 없어요..clear()방법, 방법, 즉합격해야 합니다를 통과할 수 있어요.dict(d)~하듯이로val이 작업이 제대로 되려면, 그 경우에는, 여러분이생기게 됩니다 빈자리가 빈 이 경울 거예요.SortedKeyDict결과적으로.결과적으로.

Python을 다른 언어(Python이나 Ruby와 비슷한 언어 제외)에서 사용하는 경우, 다른 언어로 이해하기를 고집하는 경우, 사람들은 보통 다음과 같이 혼동한다.

>>> a = 1
>>> a = 2 # I thought int was immutable, but I just changed it?!

Python에서 할당은 Python에서 변환이 아닙니다.

C++에 혹시 C++로 쓰면 쓴다.a = 2,, 당신이전화하고 있다에게 전화하고 있다.a.operator=(2) , , , , , , , in in in , , , , , ,에 저장되어 있는 합니다.a. (또한 에 저장되어 있는 객체가 없는 경우)a에러입니다).

Python, Python의 a = 2에 저장되어 있는 것은 아무것도 하지 않는다.a 을 뜻합니다2 is is is is is is in in in in in in in in in in in in에 저장되어 있습니다.a대신. (또한 에 저장되어 있는 객체가 없는 경우)a(미국의)

---

궁극적으로, 이것은 더 깊은 구별의 일부입니다.

C++와 같은 언어의 변수는 메모리의 입력된 위치입니다. ifa는 입니다.int, 「」, 「4 바이트」로int할 때, 할 때, 할 때, 할 때, 할 때a = 2되어 있는 내용을 4바이트로 합니다.0, 0, 0, 1로로 합니다.0, 0, 0, 2다른 곳에 다른 int 변수가 있는 경우 자체 4바이트가 있습니다.

Python과 같은 언어의 변수는 자신의 수명을 가진 개체의 이름입니다.1 오브젝트, 즉 '하다'입니다.2a4바이트로 되는 것이 아닙니다.int1이치에 맞지않다a = 22로 것 큰 , Python은 을 2로 만드는 입니다.a1과 2대신 이의를 제기합니다.

---

그럼, 할당이 돌연변이가 아니라면, 돌연변이란 무엇일까요?

• 예: 변환한다).a.append(b)됩니다).None불변형에는 이러한 메서드가 없습니다.이치노
• 「」등)a.spam = b ★★★★★★★★★★★★★★★★★」a[0] = b. 대한 하지 않으며, 가변 은 보통 둘 중 불변의 유형은 속성이나 요소에 대한 할당을 허용하지 않습니다.변환 가능한 유형은 보통 둘 중 하나를 허용합니다.
• '증강'을. 를 들어 '증강'을 사용하기도 .a += b될 도 있고, 안 될 때도 있어요.으로 변환 가능한 의 유형은 값을 합니다(변환 한 유형은 을 계산합니다). 불변의 유형은 값을 변환하지 않고 대신 복사본을 제공합니다(계산).a + b다음으로 결과를 에 할당합니다.a를 참조해 주세요.

하지만 할당이 돌연변이가 아니라면 개체 돌연변이의 일부에 할당하는 방법은 무엇일까요?★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★ a[0] = b변이하지 않다a[0](이것도 C++와는 달리) 단, 변이합니다.a(C++는 C++입니다).

이 모든 것이 Python의 시멘틱스를 익숙한 언어로 표현하지 말고 Python의 시멘틱스를 익히는 것이 좋은 이유다.

가변 객체와 불변 객체의 차이

정의들

가변 객체:개체를 만든 후 변경할 수 있습니다.
불변의 객체:개체를 만든 후 변경할 수 없습니다.

Python에서는 불변 객체의 값을 변경하면 새로운 객체가 생성됩니다.

가변 객체

파이톤

1. list
2. Dictionary
3. Set
4. bytearray
5. user defined classes

불변의 객체

파이톤

1. int
2. float
3. decimal
4. complex
5. bool
6. string
7. tuple
8. range
9. frozenset
10. bytes

답변되지 않은 질문

질문:문자열은 불변의 유형입니까?
답변: 그렇습니다만, 이것을 설명할 수 있습니까?증거 1:

a = "Hello"
a +=" World"
print a

산출량

'헬로 월드'

위의 예에서는 문자열이 일단 "Hello"로 작성되고 나서 "Hello World"로 변경되었습니다.이는 문자열이 가변 유형임을 의미합니다.그러나 그것이 변이형인지 아닌지를 확인하기 위해 그것의 정체성을 확인할 때는 아니다.

a = "Hello"
identity_a = id(a)
a += " World"
new_identity_a = id(a)
if identity_a != new_identity_a:
    print "String is Immutable"

산출량

문자열은 불변

실증 2:

a = "Hello World"
a[0] = "M"

산출량

TypeError 'str' 개체가 항목 할당을 지원하지 않습니다.

질문: Tuple은 불변의 타입입니까?
답변: 네, 그렇습니다.실증 1:

tuple_a = (1,)
tuple_a[0] = (2,)
print a

산출량

'태플' 개체가 품목 할당을 지원하지 않습니다.

객체의 가변 여부는 객체의 유형에 따라 달라집니다.이것은 특정 메서드가 있는지 여부나 클래스 계층의 구조에 따라 달라지지 않습니다.

사용자 정의 유형(예: 클래스)은 일반적으로 변동 가능합니다.불변 유형의 단순 하위 클래스와 같은 몇 가지 예외가 있습니다.기타 불변의 타입에는 다음과 같은 내장 타입이 있습니다.int,float,tuple ★★★★★★★★★★★★★★★★★」strC 에 Python 。

Python Language Reference의 "Data Model" 장의 일반적인 설명:

일부 개체의 값은 변경될 수 있습니다.값이 변경될 수 있는 오브젝트를 가변 객체라고 합니다.한 번 생성되면 값이 변경되지 않는 오브젝트를 불변 객체라고 합니다.

(변환 가능한 객체에 대한 참조를 포함하는 불변 컨테이너 객체의 값은 변경 시 변경될 수 있지만 컨테이너에 포함된 객체의 컬렉션은 변경할 수 없기 때문에 여전히 불변으로 간주됩니다.따라서 불변성은 엄밀하게는 변하지 않는 가치를 갖는 것과 같지 않습니다. 더 미묘합니다.)

객체의 가변성은 객체의 유형에 따라 결정됩니다. 예를 들어 숫자, 문자열 및 튜플은 불변하는 반면 사전 및 목록은 불변합니다.

가변 객체에는 적어도 객체를 변환시킬 수 있는 메서드가 있어야 합니다.를 들면, 「」는,list에는 「」가 있습니다.append합니다.

>>> a = [1,2,3]
>>> a.append('hello') # `a` has mutated but is still the same object
>>> a
[1, 2, 3, 'hello']

, 클래스 「」는float에는 플로트 개체를 변환하는 메서드가 없습니다.을 사용하다

>>> b = 5.0 
>>> b = b + 0.1
>>> b
5.1

, ★★★★★★★★★★★★★★★★.=오퍼랜드가 메서드가 아닙니다.변수와 오른쪽에 있는 변수 사이를 묶을 뿐이지 다른 건 아무것도 없습니다.이치노지금부터 변수가 무엇을 가리킬지에 대한 선언입니다.

때 ★★★★b = b + 0.1=이는 "te te"의 결과로 됩니다.5 + 0.1.

객체에가 나타납니다.=object.operand에 . 더 이상 도 일어나지 않는다.

경우든, 「」는= 해서 오브젝트를하지 않습니다이치노

때 ★★★★a = 1.0 , . . . . . . . .= float를 작성하는 입니다.1.0라인의 일부입니다. 이 을 쓸 는요.1.0float(1.0)그 에, (을) 입력하면,1.0 키를 " Enter" 가 .1.0아래에 출력됩니다.이것은 호출한 컨스트럭터 함수의 반환값입니다.)

만약 ,, 약b입니다. (float)를 합니다.a = b가 같은수 왜냐하면 수 없기 경우에는 변수 자체를 일치시킬 수 . 왜냐하면 개체는 변환할 수 없기 때문입니다.b += 1 이제b오브젝트를 , 「」를 참조해 주세요.a 것을 있기 에 무엇을 있는지 알 수 없습니다.b을 사용하다

, 만약c를 들어,를 들면,list 해서 이렇게 배정합니다.a = c 이제a ★★★★★★★★★★★★★★★★★」c수 list수 있고, 수 있다.c.append('msg')만 하면 됩니다.a슨슨말 인인?

어소시에이트된 번호가 , 는 (ID)로 할 수 있습니다id(x)오브젝트가 동일한지 아닌지를 확인할 수 있습니다.)

인스턴스화 시 해당 클래스의 각 개체에 나중에 변경할 수 없는 고정 값이 있는 경우 클래스는 불변입니다.

, 변수 , 수, 변, 변, 의 값 전체를 합니다.(name)그냥 놔둬도 돼

예:

my_string = "Hello world" 
my_string[0] = "h"
print my_string 

이것이 동작하여 hello world가 인쇄될 것으로 예상했지만 다음과 같은 오류가 발생합니다.

Traceback (most recent call last):
File "test.py", line 4, in <module>
my_string[0] = "h"
TypeError: 'str' object does not support item assignment

인터프리터가 다음과 같이 말합니다: 이 문자열의 첫 번째 문자를 변경할 수 없습니다.

로 할 string동시키 시해동 :

my_string = "Hello World" 
my_string = "hello world"
print my_string #hello world

다음 표를 확인합니다.

원천

내가 보기에 당신은 실제로 변이/불변의 의미와 싸우고 있는 것 같습니다.간단한 설명은 다음과 같습니다.

우선 우리는 그 설명의 근거가 되는 기초가 필요하다.

가상 객체나 컴퓨터 메모리에 저장되는 바이너리 숫자의 연속이라고 생각하시면 됩니다(단, 너무 어렵게 생각하지 마세요).^^) 대부분의 컴퓨터 언어에서는 이러한 이진수를 직접 사용하지 않고 이진수 해석을 사용합니다.

예를 들어 0x110, 0xaf0278297319와 같은 숫자를 생각하지 않고 6과 같은 숫자나 "Hello, world"와 같은 문자열을 생각합니다.이 숫자나 문자열은 컴퓨터 메모리의 이진수 해석입니다.변수의 모든 값에 대해서도 마찬가지입니다.

요약: 실제 값을 사용하여 프로그래밍하지 않고 실제 이진수 값을 해석합니다.

이제 우리는 논리와 다른 "귀찮은 것"을 위해 바뀌어서는 안 되는 해석을 가지고 있는 반면, 충분히 바뀔 수 있는 해석도 있다.예를 들어 도시의 시뮬레이션, 즉 가상 객체가 많고 그 중 일부는 집인 프로그램을 생각해 보십시오.이러한 가상 객체(주택)는 변경되어도 같은 주택으로 간주할 수 있습니까?물론 그들은 할 수 있다.즉, 다음과 같이 가변성이 있습니다."완전히" 다른 객체가 되지 않고 변경할 수 있습니다.

이제 정수를 생각해 봅시다.이것들은 가상 오브젝트(컴퓨터 메모리에 있는 바이너리 숫자의 시퀀스)이기도 합니다.그 중 하나를 변경해도 값이 6씩 증가하는 것처럼 6이 되는 건가요?물론 아니지.따라서 어떤 정수라도 불변합니다.

즉, 가상 객체의 변경이 실제로 다른 가상 객체가 되는 것을 의미하는 경우, 이를 불변이라고 합니다.

최종 발언:

(1) 실제 환경에서의 가변성과 불변의 경험을 특정 언어의 프로그래밍과 혼동하지 마십시오.

모든 프로그래밍 언어에는 음소거할 수 있는 객체와 음소거할 수 없는 객체의 정의가 있습니다.

그 때문에, 의미의 차이는 이해하실 수 있습니다만, 각 프로그래밍 언어의 실제 실장을 학습할 필요가 있습니다.실제로 6이 음소거되어 7이 되는 언어의 목적이 있을 수 있습니다.한편, 이것은 평행우주의 시뮬레이션과 같은 꽤 이상하거나 흥미로운 것들이 될 것입니다.^^

(2) 이 설명은 확실히 과학적이지 않습니다.변화와 불변의 차이를 이해하는 데 도움이 됩니다.

이 답변의 목표는 변이/비변이(불변/변이)에 대처하고 있는지, 그리고 가능하면 어떻게 대처해야 하는지에 대한 모든 좋은 아이디어를 찾을 수 있는 단일 장소를 만드는 것입니다.돌연변이가 바람직하지 않을 때가 있고, 이 점에서 비단뱀의 행동은 다른 언어에서 코더로 들어오는 것과 반직관적으로 느껴질 수 있습니다.

@mina-gabriel의 유용한 게시물에 따르면:

• 참고 자료: "Python의 데이터 구조와 알고리즘"
• 이 책에서 발췌한 가변/불변 유형: 가변/불변 유형 이미지

위의 내용을 분석하여 @arakén의 투고를 조합합니다.

예기치 않게 변경될 수 있는 것은 무엇입니까?

• 스칼라(단일값을 저장하는 타입)는 예기치 않게 변경되지 않는다.
  • 수치 예: int'float complex()
• 몇 가지 "변환 시퀀스"가 있습니다.
  • str' tuple' frozenset' bytes()

뭘 할 수 있는데?

• 목록과 같은 개체(목록, 사전, 세트, byearray())
• 여기에 있는 게시물에는 클래스 및 클래스 인스턴스도 기재되어 있지만, 이는 클래스가 무엇으로부터 상속받는지 및/또는 어떻게 구축되었는지에 따라 달라질 수 있습니다.

'뜻밖의'이란 다른 언어의 프로그래머들이 (예외나 루비, 그리고 아마도 몇몇 다른 '피스톤라이크' 언어들을 제외하고) 이 동작을 예상하지 못할 수도 있다는 것을 의미합니다.

이 토론에 추가:

이 동작은 메모리를 많이 사용하는 대용량 데이터 구조의 여러 복사본으로 코드를 잘못 채우는 것을 방지하는 데 도움이 됩니다.하지만 이것이 바람직하지 않을 때, 우리는 어떻게 그것을 피할 수 있을까요?

목록을 사용하면 다음과 같은 새로운 목록을 작성하는 것이 간단한 솔루션입니다.

list2 = list(list1)

다른 구조물과 함께...솔루션은 더 까다로울 수 있습니다.한 가지 방법은 요소를 루프하여 새로운 빈 데이터 구조(같은 유형의)에 추가하는 것입니다.

함수는 사용자가 가변 구조를 통과할 때 원본을 변환시킬 수 있습니다.어떻게 알아?

• 이 스레드의 다른 코멘트에 대해 몇 가지 테스트가 제공되고 있지만, 이러한 테스트가 완전한 증거가 아니라는 코멘트가 있습니다.
• object.function()은 원래 객체의 메서드이지만 이들 중 일부만 변환됩니다.아무것도 돌려주지 않으면 돌려주지 않을 거야이름을 지정하면 .append()가 테스트 없이 변환됩니다. .union()은 set1.union(set2)의 결합을 반환하고 변환하지 않습니다.의심스러운 경우 함수의 반환 값을 확인할 수 있습니다.반환되는 경우 = 없음은 변환되지 않습니다.
• sorted()는 경우에 따라 회피책이 될 수 있습니다.원본의 정렬된 버전을 반환하므로 다른 방법으로 원본 작업을 시작하기 전에 변환되지 않은 복사본을 저장할 수 있습니다.그러나 이 옵션은 원래 요소의 순서에 신경 쓰지 않는 것으로 가정합니다(다른 방법을 찾아야 합니다).이와는 대조적으로 .sort()는 원본(예상대로)을 변환합니다.

비표준 접근법(유효한 경우):MIT 라이선스로 발행된 github에서 다음을 발견했습니다.

• 아래 github 저장소: tobgu 이름: pyrsegu
• 무엇인가: 변환이 바람직하지 않을 때 핵심 데이터 구조 대신 사용하도록 작성된 Python 영구 데이터 구조 코드

클래스의 @@semicolon이 있는지 .__hash__는 반적적 should음음음음음음음음음음음음음음음음음음음음음 function function function function function function function function function function function function function function function function function 가 없어야 하기 때문에 합니다.__hash__()★★★★★★ 。

지금까지 이 주제에 대해 내가 축적한 것은 이것뿐입니다.다른 아이디어, 수정사항 등을 환영합니다.감사해요.

차이점에 대한 한 가지 견해:

python의 불변 객체에 대한 할당은 딥 복사본으로 간주할 수 있지만, 가변 객체에 대한 할당은 얕습니다.

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

가변변수는 값이 제자리걸음을 할 수 있는 변수이지만, 불변의 변수에서는 값이 제자리걸음을 하지 않습니다.불변 변수를 수정하면 동일한 변수가 재구축됩니다.

예:

>>>x = 5

x가 참조하는 값 5를 만듭니다.

x -> 5

>>>y = x

이 문장은 y가 5/x를 참조하도록 합니다.

x -------------------------------------y

>>>x = x + y

x가 정수(불변형)이므로 재구축되었습니다.

이 스테이트먼트에서는 RHS에 대한 표현은 값 10이 됩니다.이 값이 LHS(x)에 할당되면 x는 10으로 재구축됩니다.그래서 지금

x-----------> 10

y-----------> 5

'변환가능'이란 변화/변환할 수 있음을 의미합니다.그 반대는 불변의 것이다.

일부 Python 데이터 유형은 변경 가능하며 다른 데이터 유형은 변경되지 않습니다.

각 카테고리에 맞는 유형을 찾아 몇 가지 예를 들어 보겠습니다.

---

변이 가능

Python 에는 다양한 가변 타입이 있습니다.

• 리스트

• 받아쓰다

• 세트

다음 lists.

list = [1, 2, 3, 4, 5]

다음을 수행하여 첫 번째 요소를 변경할 경우

list[0] = '!'
#['!', '2', '3', '4', '5']

리스트는 변경할 수 있기 때문에, 정상적으로 동작합니다.

이 목록을 검토하면 해당 목록이 변경되어 변수가 할당됩니다.

y = list

목록에서 요소를 변경하면 다음과 같이 됩니다.

list[0] = 'Hello'
#['Hello', '2', '3', '4', '5']

인쇄한다면y 된다

['Hello', '2', '3', '4', '5']

다 그렇듯이list ★★★★★★★★★★★★★★★★★」y같은 리스트를 참조하고 있기 때문에, 리스트를 변경했습니다.

---

불변의

일부 프로그래밍 언어에서는 다음과 같은 상수를 정의할 수 있습니다.

const a = 10

그리고 누군가 전화를 걸면 에러가 날 것이다.

a = 20

그러나 Python에는 존재하지 않습니다.

그러나 Python에는 다양한 불변의 유형이 있습니다.

• 없음.

• 부울

• 인트

• 흘러가다

• 스트레이트

• 태플

다음 strings.

을 잡다a

a = 'abcd'

첫 번째 요소는

a[0]
#'a'

첫 번째 위치에 있는 요소에 새 값을 할당하려고 할 경우

a[0] = '!'

그러면 오류가 발생합니다.

'str' 개체가 품목 할당을 지원하지 않습니다.

문자열에 +=를 말하면 다음과 같이 됩니다.

a += 'e'
#'abcde'

는 '가 아니라 ''를 가리키고 있기 때문에 오차는 .이치노a하다

다음과 같습니다.

a = a + 'f'

그리고 끈을 바꾸지 않는 것.

불변의 장단점

• 메모리의 공간은 처음부터 알고 있습니다.여분의 공간이 필요하지 않습니다.

· 상, 보, ·, ·, ·, ·, · 「 」를 검색하면len()문자열 객체의 일부이므로 문자열의 속도가 훨씬 빠릅니다.

제가 모든 답을 읽은 것은 아니지만, 선택된 답변은 정확하지 않고, 작성자는 변수를 재할당할 수 있다는 것은 어떤 데이터형이든 변형이 가능하다는 것을 의미한다는 생각을 가지고 있다고 생각합니다.그렇지 않아요.가변성은 값으로 전달하는 것이 아니라 참조로 전달하는 것과 관련이 있습니다.

목록을 작성했다고 가정합니다.

a = [1,2]

만약 당신이 말한다면:

b = a
b[1] = 3

B에 값을 재할당했는데도 A에도 값이 재할당됩니다.왜냐하면 "b = a"를 할당할 때 입니다.값의 복사본이 아닌 "참조"를 개체로 전달합니다.이것은 현, 플로트 등은 해당되지 않습니다.이로 인해 목록, 사전 등은 변하기 쉬우나, 불란, 플로트 등은 불변합니다.

Python에서는 다음과 같이 쉽게 알 수 있습니다.

불변:

    >>> s='asd'
    >>> s is 'asd'
    True
    >>> s=None
    >>> s is None
    True
    >>> s=123
    >>> s is 123
    True

가변:

>>> s={}
>>> s is {}
False
>>> {} is {}
Flase
>>> s=[1,2]
>>> s is [1,2]
False
>>> s=(1,2)
>>> s is (1,2)
False

그리고:

>>> s=abs
>>> s is abs
True

그래서 내장 기능도 Python에서는 불변이라고 생각합니다.

하지만 플로트가 어떻게 작동하는지는 정말 이해할 수 없습니다.

>>> s=12.3
>>> s is 12.3
False
>>> 12.3 is 12.3
True
>>> s == 12.3
True
>>> id(12.3)
140241478380112
>>> id(s)
140241478380256
>>> s=12.3
>>> id(s)
140241478380112
>>> id(12.3)
140241478380256
>>> id(12.3)
140241478380256

너무 이상하네요.

예를 들어, 불변 객체의 경우 할당에 의해 값의 새 복사본이 생성됩니다.

x=7
y=x
print(x,y)
x=10 # so for immutable objects this creates a new copy so that it doesnot 
#effect the value of y
print(x,y)

가변 객체의 경우 할당에 따라 값의 복사본이 생성되지 않습니다.예를들면,

x=[1,2,3,4]
print(x)
y=x #for immutable objects assignment doesn't create new copy 
x[2]=5
print(x,y) # both x&y holds the same list

언급URL : https://stackoverflow.com/questions/8056130/immutable-vs-mutable-types