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 内层的非容器元素地址相同，内层的容器元素地址不同

深拷贝

巴特西

day8笔记

最新文章

热门文章