python Crown Sports Football Game Source Download Reference and Object Details

Posted by bugcoder on Mon, 20 May 2019 01:25:35 +0200

The variable name and object in python are separated from the source code of Crown Sports Football Guess Download dsluntan.com Enterprise E 3393756370 Crown Sports Football Guess Download

Example 1:

a = 1
This is a simple assignment statement, integer 1 is an object, A is a reference, using the assignment statement, reference a points to object 1.

Example 2:

>>> a = 1
>>> id(a)
24834392
>>> a = 'banana'
>>> id(a)
139990659655312

In the first statement, 2 is an integer object stored in memory, pointing to object 1 by assignment reference a
In the second statement, a string object `banana'is created in memory. By assigning a reference a to `banana', while object 1 does not have a reference to it, it will be given by python's memory processing mechanism when I garbage collect and release memory.

Example 3:

>>> a = 3
>>> b = 3
>>> id(a)
10289448
>>> id(b)
10289448

Here you can see that these two references point to the same object. Why? This has something to do with python's memory mechanism, because for languages, frequent object destruction and establishment wastes performance. So in Python, integers and short characters, Python caches these objects for reuse.

Example 4:

>>> a = 4
>>> b = a
>>> id(a)
36151568
>>> id(b)
36151568
>>> a = a+2
>>> id(a)
36151520
>>> id(b)
36151568

You can see that the reference of a has changed, but the reference of b has not changed; A and b point to different objects; the third sentence re-assigns a to point to a new object 6; even if multiple references point to the same object, if a reference value changes, it is actually to make the reference point to a new reference without affecting the pointing of other references. . In effect, each quotation is independent and does not affect each other.

Example 5:

>>> L1 = [1,2,3]
>>> L2 = L1
>>> id(L1)
139643051219496
>>> id(L2)
139643051219496

>>> L1[0] = 10
>>> id(L1)
139643051219496
>>> id(L2)
139643051219496
>>> L2
[10, 2, 3]

Similarly, as in the fourth example, the value of one of the objects was modified, but the result was not the same as that of the fourth chestnut. In this experiment, the reference of L 1 and L 2 did not change, but the value of list object [1, 2, 3] changed to [10, 2, 3] (list object changed).
　
In this case, instead of assigning a reference to L1, we assign an element to the table to which L1 refers. As a result, L2 changes at the same time.
Why? Because the direction of L1 and L2 has not changed, they still point to that table. Tables actually contain objects with multiple references (each reference is an element, such as L1[0], L1[1]..., and each reference points to an object, such as 1, 2, 3). The assignment operation L1[0] = 10 does not change the direction of L1, but operates on L1[0], which is a part of the table object (an element), so all references to that object are affected.

(By contrast, none of our previous assignments had any effect on the object itself, just changing the reference pointing.)
Lists can change the object itself (in-place change) by referring to its elements. This type of object is called mutable object, and dictionaries are the same type of data.

Like previous numbers and strings, it can not change the object itself, only the direction of reference, called immutable object.
The tuple we learned before, although it can call reference elements, can not assign values, so it can not change the object itself, so it is also called immutable object.

Example 6:

l = [1,2,3]
for item in l:
    item = 8
    # Here we just let item point to the object that l[i] points to, item = 8, then item points to the new object 8, without changing l[i]
print(l) # [1,2,3]
for i in range(len(l)):
    l[i] = 8
    # Here let l[i] point to the new object 8
print(l) # [8,8,8]

Example 7:

l1 = []
a = 0
for i in range(1,5):
    a = i
    l1.append(a) # What's added is the object pointed to by a
print(l1) # [1, 2, 3, 4]

l2 = []
b = [1,2,3]
for i in range(1,5):
    b[1] = i
    l2.append(b) # The object pointed to by b is added, which includes the reference of list elements. The list itself has not changed, but the object pointed to by list item [1] has changed.
print(l2) # [[1, 4, 3], [1, 4, 3], [1, 4, 3], [1, 4, 3]]
# Not expected [[1, 1, 3], [1, 2, 3], [1, 3, 3], [1, 4, 3]]

Refer to Example 5. So, each list actually adds the same object.

l2 = []
b = [1,2,3]
for i in range(1,5):
    b[1] = i
    l2.append(copy.copy(b))
    # l2.append(copy.deepcopy(b)) and copy.copy() have the same results
print(l2) # [[1, 1, 3], [1, 2, 3], [1, 3, 3], [1, 4, 3]]

copy.copy() shallow copy. Copy only the parent object, not the child object inside the object.

So what's the difference between copy.copy() and copy.deepcopy()?

l2 = []
b = [1,[4,5],3]
for i in range(1,5):
    b[1][0] = i
    l2.append(copy.copy(b)) # [[1, [4, 5], 3], [1, [4, 5], 3], [1, [4, 5], 3], [1, [4, 5], 3]]
    # l2.append(copy.deepcopy(b)) # [[1, [1, 5], 3], [1, [2, 5], 3], [1, [3, 5], 3], [1, [4, 5], 3]]
print(l2)

copy.deepcopy() deep copy object and its sub-objects

Example 8:

Research on the Parametric Transfer of Functions

def testPara(aList):
    aList[0] = 8
    print("inside function",aList) # [8, 2, 3]

if __name__ == '__main__':
    l1 = [1,2,3]
    testPara(l1)
    print(l1) # [8, 2, 3]

def testPara(aList):
    aList = [1,2]
    print("inside function",aList) # [1,2] aList redirects to a new object

if __name__ == '__main__':
    l1 = [1,2,3]
    testPara(l1)
    print(l1) # [1, 2, 3]

If you want to change l1 directly in a function, you can return l1 in a function.

def test(l:list):
    l.pop(0)

if __name__ == '__main__':
    l = [1,2,3]
    test(l)
    print(l) # [2,3]
Crown Sports Football Game Guess Source Download dsluntan.com Queen'e 3393756370 Crown Sports Football Game Guess Source Download


        Topics:
            Python

Programmer Think