Python 5.垃圾回收机制与运算符

标签：10 Python 18 age salaries 运算符 垃圾 print my

一、垃圾回收机制

1. 定义

• 垃圾回收机制（简称GC）是Python解释器自带一种机，专门用来回收不可用的变量值所占用的内存空间。

 

2.为什么要有垃圾回收机制

• 程序运行过程中会申请大量的内存空间，而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），导致程序崩溃，因此管理内存是一件重要且繁杂的事情，而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。

 

3. 垃圾回收机制原理

3.1 引用计数

• 引用计数就是：变量值被变量名关联的次数。

   x = 10          # 直接引用
   y = x
   z = x           # 10被引用了3次
   print(x.y,z)    # 2342611845648 2342611845648   2342611845648
   ​
   list1 = ['a','b',x]     # 间接引用，只有容器类型有。
   print(list1[2])         # 2342611845648
   ​
   d = {"mmm":x}
   print(id(d["mmm"]))     # 2342611845648
  

  　　

   x = 10
   list1 = ['a','b',x]     # 底层原理：list1 = ['a'内存地址，'b'内存地址,10的内存地址]
   x = 123
   print(list1[2])         # 输出的是10
  

  　　

   

 

3.2 标记清除

• 容器对象（比如：list，set，dict，class，instance）都可以包含对其他对象的引用，所以都可能产生循环引用。而“标记-清除”计数就是为了解决循环引用的问题。

   # 循环引用=>导致内存泄漏
   l1 = [111,]
   l2 = [222,]
   ​
   l1.append(l2)       # 底层：l1 = [值111的内存地址，l2列表的内存地址]
   li.append(l1)       # 底层：l2 = [值222的内存地址，l1列表的内存地址]
   ​
   del li
   del l2
   ​
   此时，l1、l2相互间接引用，无直接引用，是垃圾，但是无法通过引用计数清除。

   

   

• 在了解标记清除算法前，我们需要明确一点，关于变量的存储，内存中有两块区域：堆区与栈区，在定义变量时，变量名与值内存地址的关联关系存放于栈区，变量值存放于堆区，内存管理回收的则是堆区的内容。

  • 栈区储存变量名和值得内存地址

  • 堆区储存值

 

3.3 分带回收

分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）

新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，接下来，青春代中的对象，也会以同样的方式被移动到老年代中。也就是等级（代）越高，被垃圾回收机制扫描的频率越低。

 

 

 

二、与用户交互

1. 接收用户的输入

• 在Python3zhong ,input会将用户输入的所有内容都存成字符串类型

   username = input("请输入您的账号")
   print(username,type(username))
   age  = input("请输入你的年龄：")    # age = "18"
   print(age,type(age))
   age = int(age)      # int只能将纯数字的字符串转成整形
   age > 16

   

   

2. 字符串的格式化输出

2.1 %

• 值安装位置与%一一对应，多一个不行，少一个也不行

 res = 'my name is %s my age is %s' %('David','18')
 res = "my name is %s my age is %s" %("18","egon")
 res = "my name is %s my age is %s" %"egon"

 

• 以字典形式传值，打破位置的限制

 res = '我的名字是%(name)s，我的年龄是%(age)s' %{"name":"Davdi","age":18}

 

• %s可以接收任意类型数据

 print("my age is %s" %18)
 print("my age is %s" %[1,23])
 print("my age is %s" %{"a":333})
 print("my age is %s" %{"a":333})

 

2.2 format(兼容性好)

• 按照位置传值

   res = "我的名字是{},我的年龄是{}".format("David",18)
   res = "我的名字是{0}{0},我的年龄是{1}{1}".format("David",18)

• 打破位置限制，按照key = value传值

  1  res = "我的名字是{name},我的年龄是{age}".format(age=18,name="David")

   

2.3 f，python3.5以后

1  x = input("your name:")
2  y = input("your age:")
3  res = f"我的名字是{x},我的年龄是{y}"

 

速度：f>format>%

 

三、运算符

1. 算数运算符

1  # print(1+3.1)
2  ​
3  # print(10/3)     # 结果带小数
4  # print(10//3)    # 整除，只保留整数部分
5  # print(10 % 3)     # 取模，取余数
6  # print(10**3)    # 10的3次方
7  

 

2. 比较运算符：>、>=、<、<=、==、!=

1  # print(10 > 3)
2  # print(10 == 10)
3  ​
4  # print(10 >= 10)
5  # print(10 <= 3)
6  ​
7  # name = input('your name')
8  # print(name == 'egon')

 

3. 赋值运算符

3.1 变量的赋值

1  x = 10

 

3.2 增量赋值

1  age = 18
2  age = age + 1
3  ​
4  age += 1    # 等于age = age + 1
5  ​
6  # age *= 3
7  # age /= 3
8  # age %= 3
9  # age **= 3

 

3.3 链式运算符

1  x = 10
2  y = x
3  z = x
4  ​
5  # 可以写成
6  z = y = x = 10
7  print(x, y, z)
8  print(id(x), id(y), id(z))

 

3.4 交叉赋值

 1  m = 10
 2  n = 20
 3  ​
 4  # m、n的值交换
 5  # 方法1
 6  temp = m
 7  n = temp
 8  ​
 9  # 方法2 交叉赋值
10  m,n = n,m

 

3.5 解压赋值

 1  salaries = [111,222,333,444,555]
 2  # 把salaries中的五个值赋值给不同的变量名
 3  ​
 4  # 方法1
 5  mon0 = salaries[0]
 6  mon1 = salaries[1]
 7  mon2 = salaries[2]
 8  mon3 = salaries[3]
 9  mon4 = salaries[4]
10  ​
11  # 方法2
12  mon0,mon1,mon2,mon3,mon4 = salaries # 对应变量名，多一个不行，少一个也不行

 

1  # 引入*，可以帮助我们取两头的值，无法取中间值
2  ​
3  # 取前三个值
4  x,y,z,*_ = salaries     # *会将没有对应关系的值存成类比然后赋值给紧跟其后的那个变量名，此处的变量名为下划线
5  ​
6  # 取后三个值
7  *_,x,y,z

解压字典默认解压出来的是字典的key

1  x,y,z = dic = {"a": 1, "b": 2, "c": 3}
2  print(x,y,z)        # a b c

 

 

标签：10,Python,18,age,salaries,运算符,垃圾,print,my
From： https://www.cnblogs.com/Bayful/p/17107031.html