day8笔记

一、上节回顾

1，id() 内存地址
2， == 比较的是值
is 比较的是内存地址
数字，字符串，有小数据池，
#内存地址一样的
int -5--256
str：1，不能有空格。
2，长度不能超过20。
3，不能有特殊字符如：#@.....
列表元组字典这些除了赋值的都是内存地址不一样的
py3:
str：表现形式：s = 'alex' 实际编码方式：unicode
bytes：表现形式：s = b'alex' 实际编码方式：utf-8,gbk,gb2312...
s = b'\x2e\x2e\x2e\x2e\x2e\x2e'
unicode:所有字符（无论英文，中文等） 1个字符：4个字节
gbk：一个字符，英文1个字节，中文两个字节。
utf-8:英文 1 个字节，欧洲：2个字节，亚洲：3个字节。

二、数据类型补充

　　1.元组

    tu = (1)
    tu1 = ('name',)
    print(tu,type(tu))  # 1 <class 'int'>
    print(tu1,type(tu1))

    tu = ('dfas')
    tu1 = ('name',)
    print(tu,type(tu))  # dfas <class 'str'>
    print(tu1,type(tu1))

    tu = (True)
    tu1 = ('name',)
    print(tu,type(tu))  # True <class 'bool'>
    print(tu1,type(tu1))

    tu = ([1,2,3])
    tu1 = ('name',)
    print(tu,type(tu))  # [1, 2, 3] <class 'list'>
    print(tu1,type(tu1))
    #当数据类型外边只加括号的时候。这个数据类型还是自己本身，如果想变为元组。那么后边加一个,号

2.,列表当循环列表时，如果在循环中删除某个或者某些元素，列表元素个数改变，索引改变，容易出错。

# #删除奇数位索引值
#方一：
a = [1,2,3,4,5,6,7]
del a[1::2]
print(a)
#方法二
a = [1,2,3,4,5,6,7]
a = a[0::2]
print(a)
#方法三(不建议使用此方法，如果有两个相同的元素可能会出错)
a = [1,2,3,4,5,6,7]
b = a.copy()
for i in range(len(b)):
    if i%2==1:
        a.remove(b[i])
print(a)
#方法四
a = [1,2,3,4,5,6,7]
for i in range(0,len(a)):
    if i%2==1:
        del a[(i+1)//2]
print(a)
#方法五
a = [1,2,3,4,5,6,7]
b = []
for i in range(len(a)):
    if i%2 ==0:
        b.append(a[i])
a = b
#方法五
a = [1,2,3,4,5,6,7]
b = []
for i in range(len(a)):
    if i%2 ==0:
        b.append(a[i])
a = b
print(a)'''
e = {1:2,3:4}
e.pop(1)
print(e)

# 方法6
a = [1, 2, 3, 4, 5, 6, 7]
for i in range(len(a)-1,-1,-1):
    if i % 2 == 1:
       del a[i]
print(a)

列表中奇数位索引元素删除

3,字典
当循环字典时，如果在循环中删除某个或者某些键值对，字典的键值对个数改变，长度改变，容易出错。

#删除列表中带K的键值对 l1={'k1':'v1','k2':'v2','k3':'v3','n1':'m1'}
#方法一
l1={'k1':'v1','k2':'v2','k3':'v3','n1':'m1'}
l2 = {}
for i,k in l1.items():
    if 'k' not in i:
        l2[i] = k
l1 = l2
print(l1)
#方法二
l1={'k1':'v1','k2':'v2','k3':'v3','n1':'m1'}
l2 = []
for i in l1:
    if 'k' in i:
        l2.append(i)
for i in l2:
    del l1[i]
print(l1)
#方法三
l1={'k1':'v1','k2':'v2','k3':'v3','n1':'m1'}
l2 = list(l1.keys())
for i in l2:
    if 'k' in i:
        del l1[i]
print(l1)

#方法四
l1={'k1':'v1','k2':'v2','k3':'v3','n1':'m1'}
l2 = l1.copy()
for i in l2:
    if 'k' in i:
        del l1[i]
print(l1)

字典的循环删除

4.转化：

1，int --> str :str(int)
2, str ---> int:int(str) 字符串必须全部由数字组成
3，bool ---> str:str(bool)
4,str ----> bool(str)    除了空字符串，剩下的都是True
5，int ---> bool  除了0，剩下的全是True
6，bool ---> int  True ---> 1 False ----> 0
7,str ---> list  split
8,list ---> str() join
9,元祖列表：
tu = (1,2,3)
l = list(tu)
print(l,type(l))

li = [4,5,6]
print(tuple(li),type(tuple(li)))

#str ---> list
print(list('ab_c'))

#str ---> list
print(tuple('ab_c'))

# 0,"",{},[],(),set()   ---->False

a='a'
b =  1
d = 1,
f = ''
g = ()
h = list(g)
e = list(f)
# c = list(1,)    报错
c = list(d)
print(c)
print (d,type(d))  # 一个字母可以通过工厂函数转化
print(e)       #  空字符串也可以
print(h)      # 空元组也可以

5、列表转化为字典：fromkeys

dic = dict.fromkeys([1,2,3])
# dic1 = dict.fromkeys('abc','杨杰')
print(dic)  # 如果单独的一个列表，后边没有参数，那么返回的是三个值为None的字典
dic[4] = 'dfdsa'
print(dic)  # {1: None, 2: None, 3: None, 4: 'dfdsa'}
dic = dict.fromkeys(['barry','alex',],[])
dic['ritian'] = []
dic['barry'] = []
dic['barry'].append(11)
print(dic)  # # {'barry': [11], 'alex': [], 'ritian': []}    如果后边的参数是一个列表（或元组或），那么所有的键值对的值都指向该列表
                                                          #即内存地址一样，其中一个列表变化所有值都变化

6、集合

# ①集合的元素是可哈希的，不可变的。②集合本身是不可哈希。列表，字典不能出现，集合也不行③集合是无序的 ④值是唯一的

内建函数创建set代码如下:

   se1 = set([1, 2, 3, 4])

se1 = {1,2,3,4,5}
print(se1,type(se1)) # {1, 2, 3, 4, 5} <class 'set'>
#se2 = {1,'a',2,3,{1,2,3}}    报错
#se2 = {1,'a',2,3,{1,2,3,[1]}} 报错
se2 = {1,'a',2,3,(1,2,3)}
print(se2)   #  集合是无序的  但是可迭代 可遍历

增：

se1 = {1,2,3,4,5}
a = se1.add('老王')
#print(a,se1)  #集合是可以增的   None {1, 2, 3, 4, 5, '老王'}
#update
#se1.update('abc')  #{1, 2, 3, 4, 5, '老王', 'a', 'b', 'c'}迭代增加
#se1.update((11,22)) # {1, 2, 3, 4, 5, '老王', 11, 22}
# se1.update({11,22})
# print(se1)   #{1, 2, 3, 4, 5, 11, '老王', 22}  也可以增加集合

删：

se1 = {1,2,3,4,5}
# a = se1.remove(1)
# print(a,se1)  # None {2, 3, 4, 5} 删除指定源元素，没有返回值 没有参数会报错
# a = se1.pop(1)
# print(a,se1)  #1 {2, 3, 4, 5}  有返回值  随机删除一个元素返回值是该元素 无索引故无参数
# se1.clear() # 清空集合
# print(se1) # set()  这就是空集合
del se1
print(se1) #: name 'se1' is not defined  删除集合

改：

#冻结集合frozenset 它是不可变的，可哈希的。set 是可变的 set中可以包含frozenset
# s = frozenset([1,2,33,33,4])
# print(s,type(s))
# se1.add(s)
# print(se1)
s1 = frozenset(se1)
print(s1) # frozenset({1, 2, 3, 4, 5})  集合也可以转变为冻结集合
s2 = set(s1)
print(s2)  # {1, 2, 3, 4, 5} 冻结集合可以转变为集合

查：

# 查 由于是可迭代的，故可以用for 循环将其遍历
for i in se1:
    print(i)

附加功能

t.add('x')            # 添加一项
s.update([10,37,42])  # 在s中添加多项
t.remove('H') # 删除一项
len(s)  # set 的长度
x in s # 测试 x 是否是 s 的成员
x not in s   # 测试 x 是否不是 s 的成员
s.issubset(t)
s <= t  # 测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s >= t  # 测试是否 t 中的每一个元素都在 s 中
s.union(t)
s | t  # 返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)
s & t  # 返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t)
s - t  # 返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t)
s ^ t  # 返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()  # 返回 set “s”的一个浅复制  

#
#交集  &  intersection
# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# print(set1 & set2)  # {4, 5}
# print(set1.intersection(set2))  # {4, 5}

# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}
# print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# print(set1 - set2)  # {1, 2, 3}  set1独有
# print(set1.difference(set2))  # {1, 2, 3}
# print(set2 - set1)

# set1 = {1,2,3,4,5}
# set2 = {4,5,6,7,8}
# print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
# print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}
set1 = {1,2,3,4}
set2 = {1,2,3,4,5}
set3 = frozenset({1,2})
a = (1,)
print(set3 < set1)  # set3是set1的子集
print(set1.issubset(set2)) # set1<= set2  # set1是set2的子集
print(set2 > set1)  # set2 是set1 的超集
print(set2.issuperset(set1)) # set2 >=set1   # 这两个相同，都是说明set2是set1超集。
print(set1.issuperset(a) )
# 符号形式不能和集合外的比较     函数形式的可以和可迭代对象比较

详细举例

作用：去重

#去重
lst = [1,2,3,4,1]
print (list(set(lst))) # [1, 2, 3, 4]

四、赋值和深浅拷贝

将某一数值赋给某个变量的过程，或者将某一变量赋值给另一变量的过程。称为赋值。

l1 = [1,2,3]
l2 = l1
l1.append('barry')
print(l1)  # [1,2,3,'barry']
print(l2)  # [1,2,3,'barry']

dic = {'name':'barry'}
dic1 = dic
dic['age'] = 18
print(dic) # {'name': 'barry', 'age': 18}
print(dic1) # {'name': 'barry', 'age': 18}
s = 'alex'
s1 = s
s3 = s.replace('e','E')
print(s)   # alex
print(s1)  # alex
print(s3)  # alEx
s1 = s
print(id(s),id(s1))  # 相同
s = 'alex '
s1 = 'alex '
print(id(s),id(s1)) # 相同
# 赋值时候，两个变量指向了同一个内存空间，并没有开辟新的空间来
# lst = [1,2,3,4,1]
# print (list(set(lst))) # [1, 2, 3, 4]
l1 = [288,1,2,3]
l2 = l1
l1.append('barry')
print(l1[0] is l2[0] ) #   True 内层也一样

浅拷贝：创建一个新的对象，其元素是对原对象元素的引用。实现方法：（切片操作、工厂函数、对象的copy方法、模块中的copy函数。）

三

>>> ssw ='bangzi'
>>> ssb =list(ssw)  #ssb是通过工厂函数浅拷贝过来的一个新的对象
>>> ssw
'bangzi'
>>> ssb
['b', 'a', 'n', 'g', 'z', 'i']

>>> id(ssw),id(ssb)
(139798160206232, 139798160220040)  #两个对象的内存地址不一样
>>> for x,y in zip(ssw,ssb):    #针对于对象中的元素来说，两个对象中的每个元素指向的都是一个元对象。
...     print(id(x),id(y))
...
139798160566736
139798160335792
139798160718736
139798160372040
139798160206512
139798160567856

通过工厂函数所得到的对象：工厂函数有：list()、tuple()、dict()、str()。
>>> YY1 = [1,2,3,4,5,6]
>>> YY2 =tuple(YY1)    #序列变元祖
>>> YY2
(1, 2, 3, 4, 5, 6)
>>> id(YY1),id(YY2)
(139798032994568, 139798159622216)
>>> for x,y in zip(YY1,YY2):
...     print(id(x),id(y))
...
9323200 9323200   #对象中的元素与原对象中的元素id号一致。
9323232 9323232
9323264 9323264
9323296 9323296
9323328 9323328
9323360 9323360
通过切片操作得到的对象
>>> a = [1,2,3,4,5]
>>> b = a[:3]
>>> id(a)

>>> id(b)

>>> id(b[0])      #对原对象元素的引用。

>>> id(a[0])

>>> id(b[1])

>>> id(a[1])
通过copy函数得到的对象也是浅拷贝
>>> info = {'name':'kebi','age':''}
>>> INFO = info.copy()
>>> INFO
{'name': 'kebi', 'age': ''}

>>> id(info)    #内存地址虽然不同

>>> id(INFO)

>>> id(info['name'])   #元素都指向一个地方，明显的浅拷贝。

>>> id(INFO['name'])

种浅拷贝

深拷贝：创建一个新的对象，然后递归拷贝原对象所包含的子对象。深拷贝出来的对象和元对象没有关联。

深拷贝和浅拷贝的区别仅仅是对组合对象来所。所谓的组合对象就是包含了其它对象的对象，例如列表、元祖等数据容器。

对于非容器类型（例如：字符串、数字和其他原子类型）来说，没有拷贝一说，产生的对象都是对原对象的应用。

区别在于新对象中的元素与原对象中的元素是否存在联系。如果有联系则属于浅拷贝，否则属于深拷贝。

import copy
l1 = [258,[258,33,44],3,4,]
l2 = copy.deepcopy(l1)

l1[0] = 111
print(l1,l2)

l1[1].append('barry')
print(l1,l2)    # [111, [22, 33, 44], 3, 4] [1, [22, 33, 44], 3, 4]  [111, [22, 33, 44, 'barry'], 3, 4] [1, [22, 33, 44], 3, 4]
print(l1[1][0] is l2[1][0]) # True 内层的非容器元素地址相同，内层的容器元素地址不同

深拷贝