Python作业--2

前提知识

一些英文的生词

guaranteed 有保证的

non-overlapping 非重叠的

下面是官方对于id的定义

就是一个对象的地址,不同的对象地址不同

Return the “identity” of an object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.

CPython implementation detail: This is the address of the object in memory.

老师提出的问题

第一个

请编写用例并加以说明，解释Python中赋值拷贝、深拷贝与浅拷贝的区别

赋值拷贝,就相当于一个引用,其实对象都还是一个对象,他们的地址都是一样的

赋值拷贝

代码如下

a=1
b=a
print(id(a))
print( id(b))

c=[1,2,3]
d=c
print("")
print(id(c))
print(id(d))

e="Hello"
f=e
print("")
print(id(e))
print(id(f))

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = tup1
print("")
print(id(tup1))
print(id(tup2))

dict1 = {'abc': 456}
dict2 = dict1
print("")
print(id(dict1))
print(id(dict2))

a1 = set('abracadabra')
b1 = a1
print("")
print(id(a1))
print(id(b1))

上面的代码,他们的地址都是一样的.

但是如果,改变他们的值呢

数字

a=1
b=a
print(id(a))
print(id(b))
a=2
print(b)
print(id(a))
print(id(b))

这时候可以看到,他们的值发生了变化,但是如果是列表,等其他的形式呢

字符串

var1 = 'Hello World!'
var2 = var1
print(id(var1))
var1="NiHac"
print(id(var1))
print(id(var2))
print("")
print(var1)
print(var2)

列表

list1 = ['Google', 'Runoob', 1997, 2000]
list2 =list1
print(id(list1))
print(id(list2))
print(list1)
print(list2)
list1.append('俺是添加的元素')
print(id(list1))
print(id(list2))
print(list1)
print(list2)

元组

因为元组不可以修改,只能连接,所以,这个算了

tup1 = (12, 34.56)
tup2 = tup1

# 创建一个新的元组
tup3 = tup1 + tup2
print(id(tup1))
print(id(tup2))
print(id(tup3))
print(tup3)

字典

dict1 = { 'abc': 456 }
dict2 = dict1
print(id(dict1))
print(id(dict2))
dict1['School'] = "菜鸟教程"  # 添加信息
print(id(dict1))
print(id(dict2))

截图

集合

basket = {'apple', 'orange','banana'}
basket1=basket
print(id(basket))
print(id(basket1))
basket.add('波罗蜜')
print(id(basket))
print(id(basket1))
print(basket)
print(basket1)

总结

赋值就是相当于引用,数字的改变和字符串的都是重新赋值了,所以地址都一起变了,而其他的,用函数添加的,他们的地址都没有变。b就还是那么a。

浅拷贝

代码如下

import copy
a = [1, 2, 3, 4, ['a', 'b'],['c','d']]  # 原始对象
c = copy.copy(a)  # 对象拷贝，浅拷贝
a.append(5)  # 修改对象a
a[4].append('c')  # 修改对象a中的['c', 'd']数组对象
a[5].append('e')
print(id(a))
print(id(c))
print(id(a[4]))
print(id(c[4]))
print(id(a[5]))
print(id(c[5]))
print('a = ', a)
print('c = ', c)

浅拷贝拷贝的是父对象中的子对象

可以看出,a和c的地址,不同,但是a的子对象和b的子对象的地址相同

深拷贝

import copy
a = [1, 2, 3, 4, ['a', 'b']]  # 原始对象
d = copy.deepcopy(a)  # 对象拷贝，深拷贝
a.append(5)  # 修改对象a
a[4].append('c')  # 修改对象a中的['a', 'b']数组对象
print(id(a))
print(id(d))
print(id(a[4]))
print(id(d[4]))
print('a = ', a)
print('d = ', d)

深拷贝就相当于知识拷贝了一下值,里面的所有的地址都是新的,和原来的不一样的

总结：

赋值就是引用,6个元素都有的

浅拷贝和深拷贝:只有组合对象有

浅拷贝拷贝子对象的地址

深拷贝的地址都是全新的,只是用了一下值

第二题

编写函数实现指定个数的元素翻转到数组的尾部。
例如：arr = [1,2,3,4,5,6] 将长度为 6 的 数组 arr 的前面 2 个元素翻转到数组尾部。
得到： arr = [3,4,5,6,1,2]

arr = [1,2,3,4,5,6]
a=input()
b=[]
def jud(b,a):
    for i in range(int(a), len(arr)):
        b.append(arr[i])
    for i in range(0,int(a)):
        b.append(arr[i])
        print(arr[i])
jud(b,a)
print(b)

第三题

编写程序实现给定一个字符串，然后判断指定的子字符串是否存在于该字符串中。

var1=input()
var2=input()
i=var2.find(var1,0,len(var2))
if(i>=0):
    print("有这个字符串")
else:
    print("没有这个字符串")
print(i)

第三题

编写程序实现给定一个字典，计算所有键值为数字值的乘积。

dict = {'12': '2341', 1: '9102', 10.5: '3258'}
sum=1;
for key in dict:
    if (isinstance(key,int)):
        sum=sum*key;
    if(isinstance(key,float)):
        sum = sum * key;
print(sum)