码农学技术————六个月学习python全栈【Day08】

今日学习目标：

• 理解运用字典的内置方法
• 理解运用元组的内置方法
• 理解运用集合的内置方法
• 理解补充知识点

---

今日学习内容：

内容简要：

• 字典的内置方法
• 元组的内置方法
• 集合的内置方法
• 补充知识点

---

内容详细：

字典的内置方法

• 1.类型转换

  用法举例

  
  # 转换1:
  info=dict([['name','tony'],('age',18)])
  print(info)
  
  # 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
  print({}.fromkeys(('name', 'age', 'sex'), None))
  
  

  运行结果
  

• 2.按key取值
  方式1：字典[k键值]

  用法举例

  d1 = {
   	'name': 'jason',
   	'age': 18,
  	'hobbies': ['play game', 'basketball']
  }
   print(d1['name'])  # jason  键存在
   print(d1['adess'])  # 键不存在直接报错
  

  运行结果
  
  方式2：字典.get(k键值)

  用法举例

  	d1 = {
   		'name': 'jason',
   		'age': 18,
  		'hobbies': ['play game', 'basketball']
  	}
  print(d1.get('name'))  # jason  键存在
  print(d1.get('add'))  # None  键不存在不会报错 而是返回None
  print(d1.get('add', '这个键不存在'))  # 第二个参数不写默认返回None 写了则返回写了的
  print(d1.get('name', '这个键不存在'))  # 如果键存在 则不需要使用到第二个参数
  

  运行结果
  

• 3.修改值 字典也是可变类型

  用法举例

  d1 = {
  	'name': 'jason',
  	'age': 18,
  	'hobbies': ['play game', 'basketball']
  }
  print(id(d1))
  d1['name'] = 'jasonDSB'  # 键存在是修改值,不会更改内存地址
  print(d1, id(d1))
  
  

  运行结果
  

• 4.添加键值对

  用法举例

  d1 = {
  	'name': 'jason',
   	'age': 18,
  	'hobbies': ['play game', 'basketball']
  }
  d1['pwd'] = 123  # 键不存在则是新增一个键值对
  print(d1)
  
  

  运行结果
  

• 5.统计字典中键值对的个数 len

  用法举例

  d1 = {
  	'name': 'jason',
   	'age': 18,
  	'hobbies': ['play game', 'basketball']
  }
  print(len(d1))  # 3
  

  运行结果
  

• 6.成员运算 也只能判断key而已

  用法举例

  d1 = {
  	 'name': 'jason',
  	 'age': 18,
  	'hobbies': ['play game', 'basketball']
  }
  print('jason' in d1)  # False
  print('name' in d1)  # True
  

  运行结果
  

• 7.删除键值对

  方法	语法
  通用的删除方式	del 字典[k值]
  pop()	字典.pop(字典)
  popitem()	字典.popitem(字典)

  用法举例

  d1 = {
  	'name': 'jason',
  	'age': 18,
  	 'hobbies': ['play game', 'basketball']
  }
  del d1['name']  # 通用的删除方式
  print(d1)
  print(d1.pop('age'))  # 弹出
  print(d1)
  print(d1.popitem())  # 随机弹出一个(使用频率很低 可以忽略)
  
  

  运行结果
  

• 8.获取所有的键 所有的值 所有的键值对

  种类	语法
  获取所有的键	字典.keys()
  获取所有的值	字典.values()
  获取所有的键值对	字典.items()

  用法举例

  d1 = {
  	 'name': 'jason',
  	 'age': 18,
  	 'hobbies': ['play game', 'basketball']
  }
  print(d1.keys())
  print(d1.values())
  print(d1.items())
  

  运行结果
  

  在python2中上述三个方法就是直接返回一个列表

---

下面方法使用频率低，只做了解

• 1.update更新字典

  用法举例

  dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
  dic.update({'k1': 'JN', 'k4': 'xxx'})
  print(dic)  # 键存在则修改 键不存在则新增 
  
  

  运行结果
  

• 2.fromkeys()快速生成字典

  用法举例

  dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
  print(dic)  # {'k1': [], 'k2': [], 'k3': []}
  

  运行结果
  

• 3.setdefault()

  用法举例

  dic = {'k1': 111, 'k2': 222}
  print(dic.setdefault('k3', 333))  # 键不存在则新增键值对 并且有返回结果是新增的v
  print(dic)
  print(dic.setdefault('k1', '嘿嘿嘿'))  # 键存在 则返回对应的值 不做修改
  print(dic)
  

  运行结果
  

---

元组的内置方法

• 1.类型转换

  其用法和列表一致，仅支持for循环的数据类型都可以转成元组

  用法举例

  
  # print(tuple(11))  # 报错
  # print(tuple(11.11))  # 报错
  print(tuple('jason'))
  print(tuple([11, 22, 33, 44]))
  print(tuple({'name': 'jason'}))
  print(tuple({11, 22, 33, 44}))
  # print(tuple(True))  # 报错
  
  

  运行结果
  

  小知识点扩展
  用法举例

  元组内只有一个元素的时候 一定要在元素的后面加上逗号，否则会出错

  t1 = (11, 22, 33, 44)
  print(type(t1))  # <class 'tuple'>
  t2 = (11)
  print(type(t2))  # int
  t2 = (11.11)
  print(type(t2))  # float
  t2 = ('jason')
  print(type(t2))  # str
  """当元组内只有一个元素的时候 一定要在元素的后面加上逗号"""
  t2 = (11,)
  print(type(t2))  # tuple
  t2 = (11.11,)
  print(type(t2))  # tuple
  t2 = ('jason',)
  print(type(t2))  # tuple
  

  运行结果
  

  一般情况下 我们会习惯性的将所有可以存储多个数据的类型的数据
  如果内部只有一个元素 也会加逗号
  (1,)
  [1,]
  {1,}
  {‘name’:‘jason’,}

---

• 2.索引取值

  用法举例

  '''
  元组[索引值]
  '''
  t1 = (11, 22, 33, 44, 55, 66)
  print(t1[0])  # 11
  print(t1[-1])  # 66
  

---

• 3.切片操作

  用法举例

  '''
  元组[起始索引值：结束索引值] # 索引值范围是顾头不顾尾
  '''
  t1 = (11, 22, 33, 44, 55, 66)
  print(t1[1:4])  # (22, 33, 44)
  print(t1[-1:-4:-1])  # (66, 55, 44)
  print(t1[-4:-1])  # (33, 44, 55)
  

---

• 4.步长

  用法举例

  '''
  元组[起始索引值：结束索引值：步长] # 索引值范围是顾头不顾尾
  '''
  t1 = (11, 22, 33, 44, 55, 66)
  print(t1[1:4:2])  # (22, 44)
  

---

• 5.统计列表中元素的个数

  用法举例

  t1 = (11, 22, 33, 44, 55, 66)
  print(len(t1))  # 6
  

---

• 6.成员运算 最小判断单位是元素不是元素里面的单个字符

  用法举例

  t1 = (11, 22, 33, 44, 55, 66)
  print(11 in t1)  # True
  

---

• 7.统计某个元素出现的次数

  用法举例

  t1 = (11, 22, 33, 44, 55, 66)
  print(t1.count(22))  # 1
  

---

• 7.元组内元素不能"修改": 元组内各个索引值指向的内存地址不能修改

  用法举例

  t1 = (11, 22, 33, 44, 55, 66)
  t1[0] = 111  # 报错
  

  运行结果
  

---

集合的内置方法

• 1.类型转换

  其用法和列表一致，仅支持for循环的数据类型都可以转成元组

  # print(set(11))  # 报错
  # print(set(11.11))  # 报错
  print(set('jason'))
  print(set([11,22,33,44]))
  print(set({'name':'jason'}))
  print(set((11,22,33)))
  # print(set(True))  # 报错
  
  

  运行结果
  

  集合内元素只能是不可变类型

---

• 2.两大功能

  方法	详情
  去重	集合内不能出现重复的元素(自带去重特性)如果出现了 会被集合自动去重
  关系运算	判断两个群体内的差异

  1.去重
  用法举例

  s1 = {1, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 3, 2, 3, 4, 3, 2, 3}
  print(s1)
  l = ['a', 'b', 1, 'a', 'a']
  s1 = set(l)
  l = list(s1)
  print(l)
  

  运行结果
  

  1.关系运算
  用法举例

  f1 = {'jason', 'kevin', 'tony', 'jerry'}  # 小李的好友列表
  f2 = {'jason', 'tom', 'jerry', 'jack'}  # 小王的好友列表
  # 1.求两个人的共同好友
  print(f1 & f2)
  # 2.求小李的单独好友
  print(f1 - f2)
  # 3.求两个人所有的好友
  print(f1 | f2)
  # 4.求两个人各自的好友
  print(f1 ^ f2)
  
  

  运行结果
  

---

补充知识点

垃圾回收机制

解释器在执行到定义变量的语法时，会申请内存空间来存放变量的值，而内存的容量是有限的，这就涉及到变量值所占用内存空间的回收问题，当一个变量值没有用了（简称垃圾）就应该将其占用的内存给回收掉，那什么样的变量值是没有用的呢？
单从逻辑层面分析，我们定义变量将变量值存起来的目的是为了以后取出来使用，而取得变量值需要通过其绑定的直接引用（如x=10，10被x直接引用）或间接引用（如l=[x,]，x=10，10被x直接引用，而被容器类型l间接引用），所以当一个变量值不再绑定任何引用时，我们就无法再访问到该变量值了，该变量值自然就是没有用的，就应该被当成一个垃圾回收。

• 垃圾回收机制原理分析

Python的GC模块主要运用了“引用计数”（reference counting）来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用的问题，并且通过“分代回收”（generation collection）以空间换取时间的方式来进一步提高垃圾回收的效率

一、引用计数

引用计数：内存中的值被引用的次数，当计数为0时，该变量值就成为了垃圾，就会被回收。

• 下述情况计数会加1:

  • 对象被创建  a=14
  • 对象被引用  b=a
  • 对象被作为参数,传到函数中   func(a)
  • 对象作为一个元素，存储在容器（比如数组、列表、元组）中   List={a,“a”,“b”,2}

• 与上述情况相对应，当发生以下四种情况时，计数器-1

  • 当该对象的别名被显式销毁时  del a
  • 当该对象的引别名被赋予新的对象   a=26
  • 一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）
  • 将该元素从容器中删除时，或者容器被销毁时。

二、标记清除

当内存空间即将溢出(满了)的时候 python会自动启动应急机制
停止程序的运行 挨个检查值的引用计数并给计数为0的数据打上标记
然后一次性清理掉

三、分代回收

• 分代：

  • 分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低，具体实现原理如下：
  • 分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）

• 回收：

  • 回收依然是使用引用计数作为回收的依据
    

---

今日学习时间：

这里统计计划学习的时间

1、 上午8：30~12：30
2、 下午2：30~5：30
3、 晚上6：30~9：30

---

今日学习产出：

这里统计学习计划的总量

• 1、 技术笔记 1遍
• 2、CSDN 技术博客 1篇
• 3、每日录音
• 4、课后作业
  2.去重列表元素并保留原来的顺序
  l = [‘a’, ‘b’, 1, ‘a’, ‘a’]

l1 = ['a', 'b', 1, 'a', 'a']
l2 = []
for i in l1:
    if i in l2:
        continue
    else:
         l2.append(i)
  
print(l2)

3.去重下列数据字典并保留原来的顺序

 # 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
    l2=[
        {'name':'lili','age':18,'sex':'male'},
        {'name':'jack','age':73,'sex':'male'},
        {'name':'tom','age':20,'sex':'female'},
        {'name':'lili','age':18,'sex':'male'},
        {'name':'lili','age':18,'sex':'male'},
    ]


l3 = []
for i in l2:
    if i not in l3:
        l3.append(i)
print(l3)

4.一.关系运算

# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons = {'jason', 'oscar', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'oscar', 'tony', 'gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# #4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)