python基础 Day6

python Day6

• id 可以获得python的内存地址

  • id的举例子

    a=100
    print(id(a))
    #140712544153072  这里就是该对象的内存地址
    

  • is 判断的是比较内存地址是否相同

    #zhuxiayu
    ls=[1,2,3]
    ls1=[1,2,3]
    print(ls is ls1)
    str="zhuxiayu"
    str1="zhuxiayu"
    print(str is str1)
    #False
    #True
    

    • id相同，值一定相同
    • 值相同，id不一定相同

• 代码块

  • 我们所有的代码都要依赖代码块执行。

  • 一个文件就是一个代码块

  • 交互式命令下一行就是一个代码块

  • 代码块的两个机制，同一个代码块下遵循同一个机制，不同的代码块下遵循的同一个机制。

  • 在同一个代码块内的缓存机制(字符串的驻留机制)

    • 

      目的：节省内存，提升性能。

    • 机制适用的对象：int bool str

    • 具体细则：所有的数字，bool值，几乎所有的字符串

    • 优点：提升性能，节省内存。

  • 不同代码块的缓存机制:小数据池

    

    • 前提条件：不同代码块
    • 适用对象: int bool str
    • 具体细则：-5~256的数字，bool,满足规则的字符串

• python基本数据类型之:集合（容器型数据类型，它要求它里面的元素是不可变的）

  • 其本身是可变的数据类型。集合是无序的。

  • 集合的作用

    • 列表的去重

    • 关系测试：交集，并集，差集，.....

    • 空集合

      Set1=set()
      

    • 集合里面的元素必须是不可变的

  • 集合的增

    • add

      set1={1,4,"zhuxayu","ds"}
      set1.add("weew")
      print(set1)
      #{1, 4, 'ds', 'zhuxayu', 'weew'}
      

    • update

      #zhuxiayu
      set1={1,4,"zhuxayu","ds"}
      set1.update("weew")
      print(set1)
      #{1, 4, 'zhuxayu', 'e', 'w', 'ds'}
      #其可迭代的
      

  • 集合的删除-remove

    • pop随机删除

  • 集合的应用

    • 遇到取交集并集什么的（关系测试）

      #zhuxiayu
      #交集
      set1={1,2,3,4,5}
      set2={4,5,6,7,8}
      print(set1&set2)
      #并集
      print(set1|set2)
      #差集
      print(set1-set2)
      

    • 列表的去重

      #zhuxiayu
      li=[1,2,34,567,8,1,1,2,1,2,2]
      li1=set(li)
      li=list(li1)
      print(li)
      

• 深浅copy

  • 浅copy（在拷贝的时候形成了两个地址）——全部切片属于浅copy

    l1=[1,2,34,567,8,1,1,2,1,2,2]
    l2=l1.copy()
    l1.append(66)
    print(l1)
    print(l2)
    #结果
    [1, 2, 34, 567, 8, 1, 1, 2, 1, 2, 2, 66]
    [1, 2, 34, 567, 8, 1, 1, 2, 1, 2, 2]
    

    • 注意在列表拷贝的时候大列表的地址是不一样的，但是里面的小列表的地址是一样的
    • 
    • 浅copy会在内存中新开辟一个空间，存放这个copy的列表，但是列表里面的内容还是沿用之前对象的内存地址l1，l2的id不同但是内容id相同

  • 深copy

    l1=[1,2,3,[1,2,2]]
    l2=copy.deepcopy(l1)
    这里的l1,l2是完全两个不同的地址了
    

    • python对copy做了一个优化，对可变的数据类型在内存中重新创建一份，而不可变的数据类型沿用之前的。

  • 浅copy：list,dict：嵌套的可变数据类型是同一个，深copy:list,dict嵌套的可变类型不是同一个

• 作业

  • 作业1需求：

    • 页面显示序号+商品名称+商品价格
    • 用户如果输入选择的商品序号，然后打印商品名称及商品价格
    • 如果用户输入的商品序号有误，则提示输入有误，并重新输入
    • 用户输入Q,或者q,退出程序

    server = [
      {"name": "服务器1", "price": 10000},
      {"name": "服务器2", "price": 10500},
      {"name": "服务器3", "price": 10700},
      {"name": "服务器4", "price": 10800},
    ]
    while True:
    
      for index,dic in enumerate(server):
          print(index,dic["name"],dic["price"])
      number=input("请输入商品序号:").strip()
      if number.isdecimal():
          number=int(number)
          if 0<number<len(server):
              print(server[number-1]["name"],server[number-1]["price"])
          else:
              print("你输入的超出了范围")
      elif number.upper()=="Q": break
      else:
          print("你输入的为非法字典")
    
    

• • 作业2需求

    • dict={"name":"zhu","time":"fdsf",.}判断dict中“name"值是否在字典中

      dict={"name":"zhu","time":"fdsf"}
      print("name" in dict.keys())
      

  • 作业3需求

    • 循环提示用户，并将输入内容追加到列表中(如果输入N或n则停止循环)

      list=[]
      while 1:
          username=input("请输入用户名：")
          if username.upper()=="Q":break
          else:
              password=input("输入密码：")
              dic={}
              dic["name"]=username
              dic["password"]=password
              list.append(dic)
      print(list)
      

  • 作业4需求

    • 读出下列程序结果

      v1={"k1":"v1","k2":[1,2,3]}
      v2={"k1":"v1","k2":[1,2,3]}
      result=v1==v2
      result1=v1 is v2
      print(result,result1)
      #结果True False
      #因为不论是同代码的缓存机制还是小数据池缓存机制都只只用于bool int str三种数据类型
      

    • 读出下列的程序结果

      v1="dfsfsf"
      v2=[1,2,4,v1]
      v1="fsfdfsfsdfs"
      print(v2)
      #结果[1, 2, 4, 'dfsfsf']
      

      • 原因解释是这里是字符串，不可以变得数据结构，然后在V1赋值的时候相当于开辟了一个新的数值地址，因为不可变还是V2还是指向了v1运来值的地址

    • 读出下列的程序结果

      list=[]
      dict={}
      for i in range(10):
          dict["user"]=i
          list.append(dict)
      print(list)
      #结果[{'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}, {'user': 9}]
      list=[]
      for i in range(10):
          dict = {}
          dict["user"]=i
          list.append(dict)
      print(list)
      #结果[{'user': 0}, {'user': 1}, {'user': 2}, {'user': 3}, {'user': 4}, {'user': 5}, {'user': 6}, {'user': 7}, {'user': 8}, {'user': 9}]
      

      • 解释，前面因为最后一步对字典进行了更改，后面因为每次添加的列表都是一个新的字典，所以数字不是重复的

​