巨蟒python全栈开发-第7天 基本数据类型补充&深浅拷贝

1.基本数据类型补充

2.深浅拷贝

DAY7-基本数据类型(基本数据类型补充&深浅拷贝)

本节主要内容:

1.补充基础数据类型

(1)join方法

(2)split方法

(3)列表不能在循环时删除,因为索引会发生改变

(4)字典不能直接删除,要把删除的内容先记录在列表中,循环列表,删除字典中的数据

(5)fromekeys()不会对原来的字典产生影响,面试常考题(巨坑)

2.深浅拷贝部分

(1)=从上到下只有一个列表创建

(2)copy 等价于[:]切割

(3)引入一个模块:import copy

(4)为什么要深浅拷贝?

1.(1)join()方法把列表,变成字符串
字符串是不可变的数据类型

lst=['alex','dsb','wusir','xsb']#大烧饼,小烧饼
s='_'.join(lst) #使用前面的字符串,对后面的列表进行拼接,拼接的结果是一个字符串
print(s)      #结果:alex_dsb_wusir_xsb

(2) split() 根据你给的参数进行切割,切割的结果是列表

s='alex_dbs_wusir_xsb'
lst=s.split("_")   #列表
print(lst)   #结果:['alex', 'dbs', 'wusir', 'xsb']

总结:
　　需要把字符串转化成列表:split()
　　需要把列表转化成字符串:join()

练习
print("*".join('周润发'))   #中间有个迭代器,用迭代的方式进行的拼接
结果:
　　周*润*发

(3)列表不能直接删除,把要删除的内容记录在列表中.循环新列表,再删除原列表
　　列表不能在循环的时候删除,因为索引会随着循环发生改变.

lst=['篮球','足球','乒乓球','电子竞技','台球']
lst.remove()   #第一种方法
print(lst)
for el in lst:
    lst.remove(el)    #第二种方法:错误写法
print(lst)
#删不干净,原因分析:删除一个,元素的索引需要重新排序,for循环向后走一个,差一个

for i in range(len(lst)):  #0 1 2 3 4
    lst.pop(i)
print(lst)        #第三种方法:报错(超过范围):pop index out of range

for i in range(len(lst)):  #0 1 2 3 4
    lst.pop()
print(lst)        #第四种方法:正确(依次删除列表中最后一个)

for i in range(len(lst)):  #0 1 2 3 4
    lst.pop(0)
print(lst)          #第五种方法:正确(依次删除列表中索引时0的元素)

练习:
最合理的删除方式
　　1.把要删除的内容写在新列表中
　　2.循环这个新列表,删除老列表
　　需求:删除列表中带球字的运动项目

new_lst=[]
　 for el in lst:
       if '球' in el:
　　       new_lst.append(el)   #new_lst记录要删除的内容
　　#要删除的列表
　print(new_lst)
　#循环新列表,删除老列表
 for el in new_lst:      #['篮球','排球','足球','台球']
      lst.remove(el)
  print(lst)

(4)字典不能直接删除,把要删除的内容记录在列表中.循环新列表,再删除字典中要删除的信息

字典在被循环的时候是不能删除的(Day6作业中有详解)
dic={'张无忌':'乾坤大挪移','周芷若':'哭','赵敏':'闹'}


s={'杨逍','范瑶','韦一笑','谢逊'}   #set集合
for el in s:
    s.remove(el)    #报错:Set changed size during iteration

小结:
集合和字典是一家人
字典:key的键必须是不可变的,可哈希的,不重复的
集合:元素必须是不可变的,可哈希的,不重复的
集合相当于只存了key的字典

dic={'韦一笑':'青翼蝠王','韦一笑':'张无忌'}#后面覆盖前面的
dic['韦一笑']='殷天正'   #修改
print(dic)

(5)fromkeys(),不会对原来的字典产生影响,产生新字典(坑:大坑,神坑)

面试项目经理,常考题目(面试题):
fromkeys()  帮助我们创建字典用的
把第一个参数进行迭代,拿到每一项作为key和后面的value组合成字典

dict={}
d=dict.fromkeys('张无忌','赵敏')#创建字典
print(dict)　　#{}
print(d)   　　#{'张': '赵敏', '无': '赵敏', '忌': '赵敏'}

d=dict.fromkeys('abc','赵敏')#创建字典
print(d)      #{'a': '赵敏', 'b': '赵敏', 'c': '赵敏'}

坑1:返回新字典,和原来的字典没有关系 //dic代表原来的字典

dic={}
d=dic.fromkeys('风扇哥','很困')
print(dic)    #{}
print(d)      #{'风': '很困', '扇': '很困', '哥': '很困'}

坑2:如果value是可变的数据类型
产生了三个键值对,是一个列表

d=dict.fromkeys('胡辣汤',[])
print(d)    #{'胡': [], '辣': [], '汤': []}

d['胡'].append('河南特色')  #不论动谁,三个键对应的值都会变
print(d)    #{'胡': ['河南特色'], '辣': ['河南特色'], '汤': ['河南特色']}

练习:

dic=dict.fromkeys(['alex','wusir'],['太白','姗姗'])
print(dic)   #{'alex': ['太白', '姗姗'], 'wusir': ['太白', '姗姗']}

dic['alex'].append('老村长')　　#动一发而牵全身
print(dic)          　　　　　　#{'alex': ['太白', '姗姗', '老村长'], 'wusir': ['太白', '姗姗', '老村长']}
#上边的例子说明,只要创建的键不同,但是用的值是一样的内存地址,增删都是一个操作

print(id(dic['alex']))      #
print(id(dic['wusir']))     #

2.深浅拷贝部分

lst=[1,3,[5,7],9]
lst1=lst
lst2=lst[:]
lst[-2].append(9)
lst.append(4)
print(lst)        #[1, 3, [5, 7, 9], 9, 4]
print(lst1)       #[1, 3, [5, 7, 9], 9, 4]
print(lst2)       #[1, 3, [5, 7, 9], 9]

(1)从上到下只有一个列表被创建

lst1=['胡辣汤','灌汤包','油泼面','麻辣香锅']
lst2=lst1
print(id(lst1))     #
print(id(lst2))     #

lst1.append('胡辣汤')
print(lst1)         #['胡辣汤', '灌汤包', '油泼面', '麻辣香锅', '胡辣汤']
print(lst2)         #['胡辣汤', '灌汤包', '油泼面', '麻辣香锅', '胡辣汤']

(2)copy  等价于[:]切割

lst1=['胡辣汤','灌汤包','油泼面','麻辣香锅']
lst2=lst1.copy()        #拷贝,抄作业,可以帮我们创建新的对象

#copy之后,内存地址会不一样
print(id(lst1))         #
print(id(lst2))         #

lst1.append('胡辣汤')
print(lst1)         #['胡辣汤', '灌汤包', '油泼面', '麻辣香锅', '胡辣汤']
print(lst2)         #['胡辣汤', '灌汤包', '油泼面', '麻辣香锅']

lst1=[[1,2],'胡辣汤','灌汤包','油泼面','麻辣香锅']
lst2=lst1.copy()        #拷贝,抄作业,可以帮我们创建新的对象,和原来长的一模一样,浅拷贝

lst1.append('胡辣汤')　　#在后边追加,lst1会添加,lst2不会添加
lst1[0].append('')　　 #在存在的,第一层是列表里边添加,lst1和lst2都会添加
print(lst1)         #[[1, 2, '1'], '胡辣汤', '灌汤包', '油泼面', '麻辣香锅', '胡辣汤']
print(lst2)         #[[1, 2, '1'], '胡辣汤', '灌汤包', '油泼面', '麻辣香锅']

(3)#引入一个模块

import copy
lst1=[[1,2],'胡辣汤','灌汤包','油泼面','麻辣香锅',['长白山','白洋淀','黄鹤楼']]
lst2=copy.deepcopy(lst1)        #深拷贝,对象内部的所有内容都要复制一份,深度克隆(java中),原型模式(设计模式中)

print(id(lst1))             #
print(id(lst2))             #

lst1[5].append('葫芦娃')
print(lst1)         #[[1, 2], '胡辣汤', '灌汤包', '油泼面', '麻辣香锅', ['长白山', '白洋淀', '黄鹤楼', '葫芦娃']]
print(lst2)         #[[1, 2], '胡辣汤', '灌汤包', '油泼面', '麻辣香锅', ['长白山', '白洋淀', '黄鹤楼']]

(4)为什么要有深浅拷贝？
提升创建对象的速度
计算机中最慢的,就是创建对象,需要分配内存
最快的方式就是二进制流的形式进行赋值,速度最快(没有之一)

理解深浅copy案例:做作业?  抄作业

以后学习的各种设计模式,就是为了提高速度
clone:克隆

作业:

1.判断一个数是否是水仙花数, 水仙花数是一个三位数, 三位数的每一位的三次方的和还等于这个数. 
那这个数就是一个水仙花数, 例如: 153 = 1**3 + 5**3 + 3**3  

sum=0
while 1:
    s = input('请输入一个数字:')
    if s.isdigit():
        for i in s:
            sum += (int(i))**3
        if sum == int(s):
            print('这是一个水仙花数:')
            sum=0        #目的是为了下次计算不受影响
            break
        else:
            print('这不是一个水仙花数:')
            sum=0        #目的是为了下次计算不受影响
    else:
        print('输入错误,请输入数字')

2.给出一个纯数字列表. 请对列表进行排序(升级题, 难度系数很高. 最后再做这个). 
思路: 
(1)完成a和b的数据交换. 例如, a = 10, b = 24 交换之后, a = 24, b = 10
(2)循环列表. 判断a[i]和a[i+1]之间的大小关系, 如果a[i]比a[i+1]大. 则进行互换. 
循环结束的时候. 当前列表中最大的数据就会被移动到最右端. 
(3)想一想, 如果再次执行一次上面的操作. 最终第二大的数据就移动到了右端. 
以此类推. 如果反复的进行执行相应的操作. 那这个列表就变成了一个有序列表.

#方法一:

li=[10,9,8,7,6,5,4,3,2,1]
for k in range(1,len(li)):
    for i in range(0,len(li)-k):
        if li[i]>li[i+1]:
            li[i],li[i+1]=li[i+1],li[i]
print(li)

#方法二:最精简的方法

li=[10,9,8,7,6,5,4,3,2,1]
for k in range(1,len(li)):
    for i in range(len(li)-k):
        if li[i]>li[i+1]:
            li[i],li[i+1]=li[i+1],li[i]
print(li)

#方法三:

li=[10,9,8,7,6,5,4,3,2,1]
for k in li:
    for i in range(len(li)-1):
        if li[i]>li[i+1]:
            li[i],li[i+1]=li[i+1],li[i]
print(li)

3. 税务部门征收所得税. 规定如下: 
1). 收入在2000以下的. 免征.
2). 收入在2000-4000的, 超过2000部分要征收3%的税. 
3). 收入在4000-6000的, 超过4000部分要征收5%的税.
4). 收入在6000-10000的, 超过6000部分要征收8%的税.  
5). 收入在10000以上的, 超过部分征收20%的税. 

注, 如果一个人的收入是8000, 那么他要交2000到4000的税加上4000到6000的税加上6000到8000的税.
收入= 8000-(4000-2000)*3%-(6000-4000)*4%-(8000-6000)*8%
让用户输入它的工资, 计算最终用户拿到手是多少钱.
#方法一:

while 1:
    salary=int(input('请输入你的工资'))
    if salary<=2000:
        money=salary
    elif 2000<salary<=4000:
        money=2000+(salary-2000)*(1-0.03)
    elif 4000<salary<=6000:
        money=2000+(4000-2000)*(1-0.03)+(salary-4000)*(1-0.05)
    elif 6000<salary<=10000:
        money=2000+(4000-2000)*(1-0.03)+(6000-4000)*(1-0.05)+(salary-6000)*(1-0.08)
    else:
        money = 2000 + (4000 - 2000) * (1 - 0.03) + (6000 - 4000) * (1 - 0.05) + (10000 - 6000) * (1 - 0.08)+(salary-10000)*(1-0.2)
    print("到手的钱是:",money)
    break

#方法二:

bobo的思路:从最大的工资开始计算if

默写:

简述什么是深浅拷贝.
删除列表中姓周的人的信息

lst = ['周芷若', '周伯通', '王重阳','周葫芦娃']
li=[]
for i in lst:
    if '周' in i:
        li.append(i)
# print(li)
for i in li:
    lst.remove(i)
print(lst)