Python全栈day 06

Python全栈day 06

一、数据类型补充完整

1. 列表(list)

• 反转reverse

  list1 = [1,2,3,4,5,6,7,8,9]
  list1.reverse()
  print(list1)        #  将list1中元素相反排列[9, 8, 7, 6, 5, 4, 3, 2, 1]

• sort

  list1 = [1,5,9,7,88,22,55,44,77,99]
  list1.sort()    # 默认从小到大排序  相当于括号内有'reverse = False'  ,不填的时候默认reverse = False
  print(list1)
  list1.sort(reverse = True)
  Print(list1)

2. 字典(dict)

• 回顾:dict.keys() / .values() / .items()

• get(key, default=None)，指定返回键的值，如果字典中不包含该键，就返回得到None

  info = {'k1':'v1','k2':'v2'}
  v1 = info.get('k1')       #   v1
  v2 = info.get('k123456')    #  None,数据类型，该类型表示空（无任何功能，专门用于提供空值）
  v3 = info.get('k124563','自定义内容')  # v3 = '自定义内容',如果键不存在,则返回"自定义内容"给v3.

• .pop(key),如果字典中没有该键，会报错。返回值为该键对应的得值

  info = {'k1':'v1','k2':'v2'}
  result = info.pop('k1')      #返回得到  'v1'
  print(info)                #{'k2':'v2'}

• .update(), 括号内只能跟字典,给字典添加键值对.

  info = {'k1':'v1','k2':'v2'}
  info.update({22:33})
  info.update({'k1':'123456'})   #  没有的键，键值对就添加进去，有的键，键对应的值就更新
  print(info)   #  {'k1': '123456', 'k2': 'v2', 22: 33}

3. 判断敏感字符

• str： 使用in 即可判断

• list/tuple

  list1 = ['alex','oldboy','deng','xin']
  if 'deng' in list1：
    print('含敏感字符')   #  同样，对于元组也是这样
  

• dict

  dict1 = {'k1':'v1','k2':'v2','k3':'v3'}
  #默认按照键判断
  if 'x' in dict1 ：     #  判断x是否是字典的键。
    print('dict1的键包含x')
  
  #判断字典的值x   #第一种
  dict1 = {'k1':'v1','k2':'v2','k3':'v3'}
  if 'x' in list(dict1.values()）:    #  ，强制转化为list判断x是否是字典的值。
      print('dict1的值包含x')   
  
  #判断字典的值v2   #第二种循环
  for v in dict1.values()：
    if v == 'v2'
      print('存在')
  
  #判断字典的键值对 k2:v2 是否在其中
  value = list1.get('k2')
  if value == 'v2':
    print('包含')   

二、集合(set)

1. 特点：

• 无序，元素唯一，不允许重复，

• 注意，和字典同样的大括号 {}

  v = {}    # 空字典
  v = set{}   # 空集合，同样的int、str、list、tuple、dict也有一样的用法
  v = int()
  v = str()
  v = bool()   # 默认False
  v= list()
  v = tuple()
  v = dict()   

2. 独有方法

• .add(x),为集合添加元素，若有x元素，保持不变,只能单个元素。

• .update(x), x 可以是列表，元组，字典

  tiboy = set()
  tiboy.add('boy')
  tiboy = {1,2,3,4,56,7,8,9,'boy'}
  tiboy.add('boy')
  print(tiboy)
  
  print(tiboy)    #  update  x 可以是列表，元组，字典。
  tiboy.update([(1,2,3,4,5,6,7),'deng','yi','xin',1,2,3])
  print(tiboy)
  #  {1, 2, 3, 4, 7, 8, 9, 'xin', 'deng', 'yi', 56, (1, 2, 3, 4, 5, 6, 7), 'boy'}   列表/字典/集合不能放在集合中，但元组可以。

• .discard(x) ,移除集合的元素x，若集合没有x，返回值为None，区别于.remove(x) ,若集合没有x,则会报错。.clear() 清除集合所有元素。

  tiboy = {1,2,3,4,56,7,8,9,'boy'}
  t = tiboy.discard(1)
  print(tiboy,t)   # {2, 3, 4, 7, 8, 9, 'boy', 56} None

• .intersection() / .union( ) / .difference() /.symmetric_difference（求交集，并集 差集)

  A = {1,2,3,4,5,6}
  B = {5,6,7,8,9,10}
  集合1和2的并集 =  A.union(B)
  print(集合1和2的并集)    #A∪B
  集合1减去2的差集 = A.difference(B)
  print(集合1减去2的差集)    # 集合A-B
  集合1和2的交集 = A.intersection(B)
  print(集合1和2的交集)    #A∩B
  deng123 = A.symmetric_difference(B)
  print(deng123)      #  A∪B-A∩B

3.公共功能

1. len，长度，返回值为集合元素个数

2. for 循环

   A = {1,2,6,3,4,5}
   for item in A :
       print(item)    # 竖向打印1,2,3,4,5,6，集合是无序的

3.集合无序，故没有索引、步长、切片、删除、修改的公共功能

4. 关于嵌套（重点）

• 列表/字典/集合（可变类型） -> 不能放在集合中+不能作为字典的key（unhashable）

• hash函数，在内部会将值进行哈希算法并得到一个数值（对应内存地址），以后用于快速查找。值必须不可变。

• 特殊情况，True和False在集合和字典可能会和0， 1 重复。hash函数对2者得到一样的值。如：

  info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}
  print(info)  # {0, 2, 3, 4, "国风", None, (1, 2, 3)}
  
  info1 = {
       True:'alex',
       1:'oldboy'
   }
  print(info1)      #  {True:'oldboy'}

三、内存问题

• 变量

  1. 第一次赋值时，即创建它，之后赋值将会改变变量的值。
  2. 变量名本身是没有类型的，类型只存在对象中，变量只是引用了对象而已。

• 对象

  1. 对象是有类型的，例如各种数据类型。
  2. 对象是分配的一块内存空间，来表示它的值。

• 引用

  在Python中从变量到对象的连接称作引用。
  引用是一种关系，以内存中的指针的形式实现。

  1. 简单引用

     v1 = [11,22,33]  #解释器创建了一块内存空间（地址），v1指向这里，v1引用此内存位置
     v1 = [44,55,66]
     v1 = [1,2,3]    # v1被多次赋值，即修改了v1的引用，把v1的指向关系变了，指向改为另一块内存地址。
     v2 = [1,2,3]   #解释器创建了另一块内存空间（地址），v2指向这里。
     v1 = 666   # 同理，v1，v2指向不同的内存地址
     v2 = 666
     v1 = "asdf"   # 特殊，对于赋值给字符串，v1，v2指向一个内存地址                  （字符串不可变）
     v2 = "asdf"
     
     v1 = 1
     v2 = 1   #特殊：v1，v2指向相同的内存地址
              #解释：1. 整型：  -5 ~ 256 ，py认为它是常用的，有缓存机制，就把v1和v2指向相同的内存地址，以节省内存。
              #####  2. 字符串："alex",'asfasd asdf asdf d_asd'（字符串不可变 ），指向同一内存地址
              #####  3."f_*" * 3  - 重新开辟内存,一旦字符串有其他运算，就重新开辟内存空间

  2. 共享引用

     #示例一
     a = 3  #解释器创建了一块内存空间（地址），a指向此处
     b = a  # b也指向次内存地址
     #示例二(内部修改)
     v1 = [11,22,33]   #解释器创建了一块内存空间（地址），v1指向此处
     v2 = v1  #v2也指向这里，如果语句为：v2 = [11,22,33]，则是解释器创建了另一块内存空间（地址），v2指向这里。只是v1和v2的值相同。
     v1.append(123) #v1指向的内存地址添加上来元素666，v2跟着变更。
     print(v2)     # [11,22,33,123]
     #示例三（赋值）
     v1 = [11,22,33]
     v2 = [11,22,33]
     v1.append(123)
     print(v2)     #  [11,22,33]
     #示例四（重新赋值）
     v1 = [11,22,33]  # v1指向一个内存地址
     v2 = v1  # v2指向同一个内存地址
     v1 = [44,55,66,77]  #v1的指向关系改变，解释器创建了内存地址，并将v1的指向改为指向它。
     print(v2)  # v2的指向没有变化，输出[11,22,33]

  3. == 和 is d的区别

     • == 用于比较值是否相等

     • is 用于比较内存地址是否相等/比较指向关系是否相同/比较指向的内存空间是否是同一个。

       id(v1)   # 返回得到 变量名v1指向的内存地址

     • 小总结

       • 变量是一个系统表的元素，拥有指向对象的连接的空间。
       • 对象是分配的一块内存，有足够的空间去表示它们所代表的值。
       • 引用是自动形成的从变量到对象的指针