python 的基础 学习 第八天数据类型的补充 ，集合和深浅copy

时间：2022-12-01 15:41:17

1，数据类型的补充：

  1. 元组()tuple，如果只有元素，并且没有逗号，此元素是什么数据类型，该表达式就是什么数据类型。 
    tu = ('rwr')
    
print(tu,type(tu))
    tu = ('rwr',)#('rwr',) <class 'tuple'>
    
print(tu,type(tu))
  2. list列表，在循环一个列表时，最好不要进行删除动作，一旦删除，索引就会随之改变，容易出错。 
    li = ['老男孩','alex','拉黑米','老男孩','老男孩','天上人间']
    
#删除索引为奇数的元素
    
# del li[1::2]
    
# print(li)
    
for i in range(len(li)-1,-1,-1):#可以倒序删除
    
    if i %2== 1:
    
        del li[i]
    
print(li)
    li = ['老男孩','alex','拉黑米','老男孩','老男孩','天上人间']
    
ls = []#建一个空列表，先把需要留着的元素加进列表
    
for i in range(len(li)):
    
    if i %2 == 0:
    
        ls.append(li[i])
    
li = ls#再把ls赋值给li
    
print(li)
  3. dic的formkeys的操作，存在于同一个内存地址 
    # dic= dict.fromkeys([1,2,3],[])
    
# print(dic)#{1: [], 2: [], 3: []}
    
# dic[2].append('老男孩')
    
# print(dic)#{1: ['老男孩'], 2: ['老男孩'], 3: ['老男孩']}
    
dic = dict.fromkeys(['w','tt'],['oror','uyu'])
    
dic['w'].append('lsn')
    
print(dic)#{'w': ['oror', 'uyu', 'lsn'], 'tt': ['oror', 'uyu', 'lsn']}

    dic字典，在循环字典中，不能增加或删除此字典的键值对，容易报错。

    #删除字典中含有k的元素
    
dic = {'k1':'value1','k2':'value2','name':'wusir'}
    
li = []
    
for i in dic:
    
    if 'k'in i:
    
        li.append(i)
    
for i in li:
    
    del dic[i]
    
print(dic)

    元组直接转化列表：

    s = 'rkrkkr'
    
tu = ('skdff')
    
s2=list(tu)#直接加list转化
    
print(s2,type(s2))

3，set集合数据类型，不重复，无序，不能改，只能查增删，它里面的元素是可哈希，它本身是不可哈希的，集合不能作为字典的键。

主要有两个作用：1，去重。2，数据关系的测试。

li = [11,33,22,22,11,33,11]

set = set(li)

print(set)#取重{33, 11, 22}

4，set 的增

set（add,update）

set ={'那好','ji手机','孩子'}

set.add('好女孩')

print(set)#{'孩子', 'ji手机', '那好', '好女孩'}

set.update([1,233,3])#迭代添加

print(set)#{'孩子', 1, '那好', 3, '好女孩', 233, 'ji手机'

5,删除，remove,pop,clear,del

set ={'那好','ji手机','孩子'}

#set.remove('那好')#按元素删除

set.pop()#随机删除

set.clear()#清空集合

del set #删除集合

print(set)

查看

set ={'那好','ji手机','孩子'}

for i in set:

    print(i)

2,关系测试：

交集

set ={'','','',''}

set1 = {'','','',''}

print(set&set1)查看交集
print(set.intersection(set1))交集

并集

set ={'','',''}

set1 = {'','','',''}

print(set|set1)#求并集

print(set.union(set1))#求并集

反交集

set ={'','',''}

set1 = {'','','',''}

print(set^set1)#反交集

print(set.symmetric_difference(set1))#反交集

差集

set ={'','',''}

set1 = {'','','',''}

print(set-set1)#求差集

子集

set1 = {1,2,3}

set2 = {1,2,3,4,5,6}

print(set1 < set2)#True

print(set1.issubset(set2))#True  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)#返回True

print(set2.issuperset(set1))  #True 这两个

frozenset不可变集合，让集合变成不可变类型。

s = frozenset('hobby')
print(s)#frozenset({'h', 'b', 'o', 'y'})

深浅copy

1,对于赋值运算指向的是同一个内存地址，字典，列表，集合都一样。

ls = [1,2,3]

ls1 = ls

ls1.append(11)

print(ls,ls1)

copy,不是指向一个内存地址，在内存中开辟了一个内存空间。

对于浅copy来说，第一层创建新的内存地址，而从第二层开始，指向都是同一个内存地址，所以，对于第二层以及更深层数来说，保持一致性。

切片属于浅copy。

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048

l1[1] = 222

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896

l1[3][0] = 'wusir'

print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

import copy

l1 = [1,2,3,['barry','alex']]

l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'

print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240

print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变

相关文章