python全栈-Day 7

一、基础数据类型汇总补充

int、str

s = '    '
print(s.isspace())  #判断字符串是否全部由空格组成

 查看某个数据类型的全部方法：

list

l = [11,22,33,44]
for i in l:
    del l[l.index(i)]  #按照索引删除
print(l)  #[22, 44],del会让元素个数减少，但是索引值是从0、1、2、3，没有按照元素的个数变化


l = [11,22,33,44]
for i in range(len(l)):
    del l[i]  #按照元素删除
    print(l)  #报错，数组超出范围

bool

转化为bool值为false为空的元素：0，''，[]，()，{}，set()

dict

dic = {'k1':'v1','k2':'v2','a1':'b1'}
for k in dic.keys():  #报错，在循环一个字典中不能删除键值对
    if k.find('k') >= 0:
        dic.pop(k)
print(dic) 

#删除字典中键值包含'k'的键值对
#方法1
dic = {'k1':'v1','k2':'v2','a1':'b1'}
l = []
for k in dic.keys():  #报错，在循环一个字典中不能删除键值对
    if 'k' in k:
        l.append(k)
for i in l:
    dic.pop(i)
print(dic)

#方法2
dic = {'k1':'v1','k2':'v2','a1':'b1'}
dic1 = {}
for k in dic.keys():  #报错，在循环一个字典中不能删除键值对
    if 'k' not in k:
        dic1.setdefault(k,dic[k])
dic = dic1
print(dic)

tuple

tu1 = (1)
tu2 = (1,)
print(tu1,type(tu1))  #1 <class 'int'>元组里面如果只有一个元素，且没有逗号，则其数据类型不为元组，同该元素的类型
print(tu2,type(tu2))  #(1,) <class 'tuple'>

二、集合set

1、集合是一个可变的数据类型，集合的元素必须是不可变的数据类型（str、int、bool、tuple）

2、集合几个是无序的，集合是不可重复的（列表转化为集合可去重）

3、集合的创建

set1 = set([2,3])  #集合可以通过set（）的方法创建，且只能有一个参数，可以是列表/字典
set2 = set({'name':'jingjing','age':18})
set3 = {1,2,3,'sss'}
#set4 = {1,2,3,[2,3],{'name':'jingjing'}}  #列表和字典是可变数据类型，不能作为集合的元素
print(set1,set2,set3)

4、集合的增删改查

#集合的增
set1 = {'alex','wusir',1,3}
set1.add('女神')
print(set1)  #无可以多次打印查看无序的结果

set1.update('汪晓')  #将参数的每个最小单元查分，插入集合
print(set1)

#集合的删
set1 = {'alex','wusir',1,3,(1,2)}
set1.pop()  #随机删除一个元素
print(set1.pop())  #返回值为被删除的元素
#set1.pop('汪晓')  #元素不存在会报错
print(set1)

set1 = {'alex','wusir',1,3,(1,2)}
set1.remove('alex')  #按照元素删除，元素不存在或者没有参数则会报错
print(set1)

del set1  #删除整个集合

#集合的改，集合没有改


#集合的查
set1 = {'alex','wusir',1,3,(1,2)}
for i in set1:
    print(i)

5、集合的其他方法

#求合集的交集、并集、反交集、差集、子集、超集
set1 = {1,2,3,4}
set2 = {3,4,5,6}
print(set1.intersection(set2))  #求合集的交集，{3, 4}
print(set1 & set2)  #求合集的交集，{3, 4}
print(set1.union(set2))  #求合集的并集，{1, 2, 3, 4, 5, 6}
print(set1 ^ set2)  #求合集的反交集，{1, 2, 5, 6}
print(set1 - set2)  #求合集的差集，{1, 2}，set1独有的

set1 = {3,4}
set2 = {3,4,5,6}
print(set1 < set2)  #判断set1是否为set2的子集
print(set1 > set2)  #判断set1是否为set2的超集

 6、集合的特殊应用

#列表去重
#方法1
li = [1,2,33,33,2,1,4,5,6,6]
print(list(set(li)))

tu = (1,2,3)
print(type(tu))
set1 = frozenset([1,2,3])  #将任意可变或不可变数据类型 转化为 不可变数据类型
print(set1,type(set1))  #<class 'frozenset'>，可查，可增加，不可修改

三、Python 直接赋值、浅拷贝和深度拷贝解析

http://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html

 1、直接赋值：其实就是对象的引用（别名）。a 和 b 都指向内存中的同一个对象，修改其一会修改该内存对象的值，此时会同步修改

#赋值
a = {1:[1,2,3]}
b = a
a[1].append(4)
print(a,b,a == b,a is b)  #赋值，修改a，a、b值相等，对象相等

a = 1
b = a
a = 2
print(a,b,a == b,a is b)  #赋值，修改a，a、b值不相等，对象不相等？？？？？

2、浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。a 和 b 指向内存中不同的对象，但是两个对象指向的是同一个值（是引用）。此时如果修改a本身做操作，a会指向另外一个值，b不会同步修改；如果对a的某个元素做操作，则会更新内存中的该值，b会同步修改

#浅拷贝
a = {1:[1,2,3]}
b = a.copy()  #int、str没有copy方法
a[1].append(4)
print(a,b,a == b,a is b)  #浅拷贝，修改a，a、b值相等，对象不相等

3、深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象，两者对应的内存对象及其指向的值都是完全独立的

#深拷贝
import copy
a = {1:[1,2,3]}
b = copy.deepcopy(a)  #int、str、list、dict
a[1].append(4)
print(a,b,a == b,a is b)  #深拷贝，修改a，a、b值不相等，对象不相等

import copy
a = [1, 2, 3, 4, ['a', 'b']]  # 原始对象

b = a  # 赋值，传对象的引用
c = copy.copy(a)  # 对象拷贝，浅拷贝--可同步对象的值，不能同步对象
d = copy.deepcopy(a)  # 对象拷贝，深拷贝

a.append(5)  # 修改对象a
a[4].append('c')  # 修改对象a中的['a', 'b']数组对象

print('a = ', a)  #a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print('b = ', b)  #b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
print('c = ', c)  #c =  [1, 2, 3, 4, ['a', 'b', 'c']]
print('d = ', d)  #d =  [1, 2, 3, 4, ['a', 'b']]