python笔记-基础6

python基础6

1. 内存地址

1.python的变量指向的是数据的内存地址使用id()可以查看内存地址
var = 1
print(id(var))
print(id(1))
结果：
4469692464
4469692464

2. == 与 is的区别

1.==用来判断数值是否相等
2.is则是用来判断内存地址是否相同
var = 1
var2 = 1
print(id(var))
print(id(var2))
print(var is var2)
结果：
4547663920
4547663920
True
--------------------
>>> a = 4545
>>> b = 4545
>>> id(a)
140620556436392
>>> id(b)
140620556436416
>>> a is b
False
>>> a == b
True

3. 总结
   1. 两个变量的内存地址相同，值一定相同
   2. 两个变量的值相同，内存地址不一定相同
4. 代码块
   Python代码是由代码块组成的，在命令行终端下，每一行代码就是一个代码块，在Python文件中，一个文件为一个代码块。
5. Python代码块的两种机制
   1. 在同一代码块下的缓存机制：在同一代码块下会存在一个存储数据的字典，当进行初始化命令时，会将数据记录在这个字典中，当进行下一次初始化命令时，会先去检索字典中是否存在这个数据，如果有就是复用同一个，如果没有会新建，之后继续向字典中添加
   2. 在不同代码块下的缓存机制：在不同代码块下，会开辟出两块内存，一块用于存放-5~256的所有数字，一块存有满足一定规则的字符串，当进行初始化命令时，满足以上两个规则的复用同一个，不满足的则不会复用。
   3. 两个机制适用的数据类型：int、str、bool
   4. 具体细则：
      1. 同一代码块下，可以缓存几乎所有int、str、bool
      2. 在不同代码块下，int只能缓存-5~256，以及满足一定规则的字符串。
6. set集合
   1. 集合是容器型数据类型，他要求内部的元素是可哈希数据类型，但集合本身是可变的数据类型，同时集合是无序的。
   2. 集合的两大作用：
      1. 列表去重
      2. 关系测试
7. 集合的操作

1. 集合的创建
name = set({1, 2, 3, 4, 5})
name = {v1,v2,v3......}
**空集合：name = set()
2. 增
set.add(value)
----------------------------
s = {1, 2, 3, 4, 'alex'}
s.add('jack')
print(s)
结果：
{1, 2, 3, 4, 'jack', 'alex'}
----------------------------
set.update(interable)
s = {1, 2, 3, 4, 'alex'}
s.update('alex')
print(s)
结果：
{'alex', 1, 2, 3, 4, 'a', 'l', 'e', 'x'}
3.删
set.remove(value)
-----------------------------
s = {1, 2, 3, 4, 'alex'}
s.update('alex')
s.remove('x')
print(s)
结果：
{1, 2, 3, 4, 'a', 'l', 'e', 'alex'}
-----------------------------
set.pop() #随机删除
s = {1, 2, 3, 4, 'alex'}
s.pop()
4.改
变相修改：先删除后增加

8. 集合关系

s = {1, 2, 3, 4, 5}
s2 = {2, 3, 4, 6, 7, 8}
print(s & s2) #交集
print(s | s2) #并集
print(s - s2) #差集
print(s ^ s2) #反交集
结果：
{2, 3, 4}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 5}
{1, 5, 6, 7, 8}

9. 关系测试

s = {1, 2, 3}
s2 = {1, 2, 3, 4, 5, 6}
print(s < s2) #判断s是否是s2的子集
print(s2 > s) #判断s2是否是s的父集
结果：
True
True

10. 列表去重

1.先将列表转换成集合
2.再将集合转换为列表
l = [1, 2, 1, 1, 3, 4, 4, 5, 6, 6]
l = set(l) #将l转换为集合l
print(l)
l = list(l) #将集合l转换为列表l
print(l)
结果：
{1, 2, 3, 4, 5, 6}
[1, 2, 3, 4, 5, 6]

11. 深浅copy
    1. 浅copy：只复制了一部分

    l1 = [1, 2, 3, [22,33]]
    l2 = l1.copy()
    or
    l2 = l1
    --------------------------
    l1 = [1, 2, 3, [22, 33]]
    l2 = l1.copy()
    print(id(l1))
    print(id(l2))
    l1[-1].append('44')
    print(l1)
    print(l2)
    print(id(l1[-1]))
    print(id(l2[-1]))
    结果：
    4450178568
    4450189768
    [1, 2, 3, [22, 33, 44]]
    [1, 2, 3, [22, 33, 44]]
    4435180424
    4435180424
    #l2只复制了l1的表层元素，但嵌套的可变元素一旦被修改，两个列表都会发生变化
    

    2. 深copy：全部复制

    深copy要调用copy模块中的deepcopy()
    --------------------------
    l1 = [1, 2, 3, [22, 33]]
    import copy
    l2 = copy.deepcopy(l1)
    print(id(l1))
    print(id(l2))
    l1[-1].append(44)
    print(l1)
    print(l2)
    print(id(l1[-1]))
    print(id(l2[-1]))
    结果：
    4515227144
    4515238408
    [1, 2, 3, [22, 33, 44]]
    [1, 2, 3, [22, 33]]
    4463668104
    4463679176
    #Python对深copy做了一定的优化，现在是不可变的数据类型可以复用
    #可变的数据类型是完全独立的