python基础

Python学习笔记

多版本共存

注意

# python无";"
# Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变，表子代码
# python 有冒号 下一行缩进
# Python 中没有数组，而是加入了功能更强大的列表（list），列表可以存储任何类型的数据，同一个列表中的数据类型还可以不同；列表是序列结构，可以进行序列结构的基本操作：索引、切片、加、乘、检查成员。

注释

# 单行注释
'''
多行
'''
"""
多行
"""
pycharm单行注释快捷键ctrl+？
"""
python代码的编写规范>>>:PEP8
	1.单行注释如果在代码上方 #和内容之间空一格
	2.单行注释在代码后面 需要先空两格在 #和内容之间空一格
	3.元素后逗号空一格
	ctrl+alt+L
"""

缩进

# Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变
if True:
    print(True)
else:
    print(False)

一、数据类型

# 整数int：可以为任意大小、包含负数  
	## year = 2000
# 浮点数float：就是小数 
	## salary = 3.1
# 字符串str：以单引号 '、双引号"、三引号 ''' 或 """括起来的文本 
	## username = 'andyli'
    ## username = "andyli"
    ## username = """andyli"""
    ## username = '''andyli'''
# 字典dict
# 集合set
# 元组tuple
# 布尔bool：只有 True、False 两种值
# 空值：用 None 表示
# 变量：是可变的
# 常量：不可变
	# 约定俗成，用大写字母表示 PI = 3.14

1.打印数据类型

print(type(num))

2.字符串

2.1 访问

• 访问单个字符

  s = 'Python'
  # 访问第一个字符 P
  print(s[0])
  

• 访问范围内字符

  s = 'Python'
  # 访问 yt
  print(s[1:3])
  # 访问 Pyt
  print(s[:3])
  # 访问 hon
  print(s[3:])
  

2.2 单个字符编码

# ord() 函数返回单个字符的编码
# chr() 函数把编码转成相应字符。
s = 'A'
print(ord(s))
print(chr(65))

2.3 转义符

转义字符	描述
\	在行尾使用时，用作续行符
\b	退格（Backspace）
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符

2.4 字符串运算符

运算符	描述
+	连接符
*	重复输出
[]	通过索引获取字符串中字符
[ : ]	获取字符串中的一部分
in	字符串中是否包含指定字符
not in	字符串中是否不包含指定字符
r/R	字符串原样输出

s1 = 'Hello'
s2 = 'Python'
print('s1 + s2 -->', s1 + s2)
print('s1 * 2 -->', s1 * 2)
print('s1[0] -->', s1[0])
print('s1[0:2] -->',s1[0:2])
print('"H" in s1 -->','H' in s1)
print('"H" not in s1 -->','H' not in s1)
print('\\r -->', R'\r')
#输出结果
s1 + s2 --> HelloPython
s1 * 2 --> HelloHello
s1[0] --> H
s1[0:2] --> He
"H" in s1 --> True
"H" not in s1 --> False
\r --> \r

2.5 格式化

# 使用字符串的 format() 方法进行格式化
print('{0} {1}'.format('Hello', 'Python'))
"""用传入的参数依次替换字符串内的占位符{0}、{1} ..."""

2.6 strip移除字符串首尾指定的字符(默认移除空格)

>>> str1 = '**tony***'
>>> str1.strip('*')  # 移除左右两边的指定字符
'tony'
>>> str1.lstrip('*')  # 只移除左边的指定字符
tony***
>>> str1.rstrip('*')  # 只移除右边的指定字符
**tony

2.7 lower()、upper()

>>> str2 = 'My nAme is tonY！'
>>> str2.lower()  # 将英文字符串全部变小写
my name is tony！
>>> str2.upper()  # 将英文字符串全部变大写
MY NAME IS TONY！

2.8 startswith,endswith

>>> str3 = 'tony jam'

# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
>>> str3.startswith('t') 
True
>>> str3.startswith('j')
False
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')  
False

2.9 split，rsplit可指定切割次数

# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']  
# rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']

2.10 join

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'

2.11 replace

# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73')  # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!

# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'

2.12 isdigit

# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True

>>> str8 = '123g123'
>>> str8.isdigit()
False

2.13 其他操作

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1

# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
>>> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony

# 3.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello

# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 

# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字

#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False

#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False

#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True

# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False

'''
总结:
	最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
	如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''

# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

---

3.序列

一块可存放多个值的连续内存空间

3.1 基本使用

# 索引值
0..n-1
-n..-1
# 切片
sname[start : end : step]
sname：表示序列的名称；
start：开始索引位置（包括该位置），默认为 0；
end：表示切片的结束索引位置（不包括该位置），默认为序列的长度；
step：步长。
# 相加
# 相乘
str = 'Python'
print('2 * str --> ',2 * str)
result: 2 * str -->  PythonPython
# 元素是否在序列中
使用 in 关键字检查某元素是否为序列的成员
str = 'Python'
print('on'in str)
result: True

3.2 内置函数

函数	描述
len()	计算序列的长度
max()	找出序列中的最大元素
min()	找出序列中的最小元素
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素的和
sorted()	对元素进行排序
enumerate()	将序列组合为一个索引序列，多用在 for 循环中

str = 'dbcae'
print('len -->', len(str))
print('max -->', max(str))
print('sorted -->', sorted(str))
# result: 
len --> 5
max --> e
sorted --> ['a', 'b', 'c', 'd', 'e']

---

4.列表-[ ]

无法明确的标明数据的指向

user_list = ['a', 'b', 'c']
# 元素可为任意类型
user_list1 = ['a', 'b', 1.1, 2, [3, 4, 5, ['haha', 'heihei', ['我'，'你']]]]
print(user_list1[4][4][1])
# 你

4.1 访问-见上字符串访问

4.2 更新-append()、extend()

# append() 向列表中添加新元素
l = [1024, 0.5, 'Python']
# 修改列表中第二个元素
l[1] = 5
# 向列表中添加新元素
l.append('Hello')
print('l[1] -->', l[1])
print('l -->', l)
# result:
l[1] --> 5
l --> [1024, 5, 'Python', 'Hello']
# extend()一次性在列表尾部添加多个元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']

4.3 删除-del()

l = [1024, 0.5, 'Python']
# 删除列表中第二个元素
del l[1]
print('l -->', l)
# result:
l --> [1024, 'Python']

4.4 类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"jason","age":18}) #结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

5.常用方法

1.count()-统计列表中某个元素出现的次数

l = ['d', 'b', 'a', 'f', 'd']
print("l.count('d') -->", l.count('d'))
输出结果：
l.count('d') --> 2

2.index()-查找某个元素在列表中首次出现的位置（即索引）

3.remove()-移除列表中某个值的首次匹配项

l = ['d', 'b', 'a', 'f', 'd']
l.remove('d')
print("l -->", l)
输出结果：
l --> ['b', 'a', 'f', 'd']

4.sort()-对列表中元素进行排序

5.copy()-复制列表

6.reverse()

>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]
>>> l=[1,2,3,4,5,6]
>>> l[0:3:1] 
[1, 2, 3]  # 正向步长
>>> l[2::-1] 
[3, 2, 1]  # 反向步长

# 通过索引取值实现列表翻转
>>> l[::-1]
[6, 5, 4, 3, 2, 1]

---

6.元组( )tuple、不可变

# 元组中元素不能被修改，但可以重新赋值
# 元组中元素不能被删除，但可删除整个元组
t = (1024, 0.5, 'Python')
del t
print('t -->', t)
# result:
NameError: name 't' is not defined
# 常用方法
len()、max()、min()、tuple():列表转换为元组

7.字典(无索引值)-{ }

能够精准存储信息

"""
大括号括起来 内存存放多个元素 元素与元素之间用逗号隔开
元素以k:v键值对形式存在
"""
user_info = {
    'username':'andyli',
    'age':999,
    'hobby':'read',
    'year':2022
}

7.1 字典循环

# 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

7.2 操作

(1) get(‘xxx’) 获取key’xxx’对应的键值

(2) pop()删除指定的key对应的键值对,并返回值

(3) popitem() 随机删除一组键值对,并将删除的键值放到元组内返回

(4) update()

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

(5) fromkeys()

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

(6) setdefault()

# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

8.集合{ }set-冷门使用

功能单一、用于去重、关系运算
s = {1,2,3,4,5}
{}内定义空的数据，默认为字典
集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数
s = {'a', 'b', 'c'}
# 使用 set 函数
s = set(['a', 'b', 'c'])
# 空集合
s = set()
# 集合中重复的元素会被自动过滤掉
# 清空集合使用 clear 方法

8.1 去重

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'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'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

---

二、运算符

# /:除法
# //:整除
# **：幂
# 赋值符：1.链式赋值 x=y=z=10
#		 2.交叉赋值 m,n=n,m  # 交叉赋值
#         3.解压赋值 nums=[11,22,33,44,55]
#                   a,b,c,d,e=nums  # nums包含多个值，就好比一个压缩包，解压赋值因此得名
#                   a, b, *c = nums
#				   a, b, _ = nums
# 字符串、字典、元组、集合类型都支持解压赋值 
# is：判断两个标识符是否引用同一个对象	a is b 身份运算符 vs ==：比较的是value
# is not：判断两个标识符是否引用不同对象	a is not b
# abs(x):x的绝对值
# int(x):将x转换为整数
# float(x):将x转换为浮点数
# complex(x, y):一个带有实部 x 和虚部 y 的复数，y 默认为 0。
# divmod(x, y):(x // y, x % y)
# pow(x, y):x 的 y 次幂
# x ** y: x 的 y 次幂

三、数学函数

import math
math.函数名(x)

函数	描述
abs(x)	返回 x 的绝对值
ceil(x)	返回 x 的上入整数，如：math.ceil(1.1) 返回 2
floor(x)	返回 x 的下舍整数，如：math.floor(1.1) 返回 1
exp(x)	返回 e 的 x 次幂
log(x)	返回以 e 为底 x 的对数
log10(x)	返回以 10 为底 x 的对数
pow(x, y)	返回 x 的 y 次幂
sqrt(x)	返回 x 的平方根
factorial(x)	返回 x 的阶乘

四、随机函数

import random
random.random()  # 随机生成一个 0 到 1 范围内的实数。
random.uniform(1,10)  # 随机生成一个 x 到 y 范围内的实数。

五、基本语句

1.if-elif-else

if 判断条件1:
    执行语句1...
elif 判断条件2:
    执行语句2...
elif 判断条件3:
    执行语句3...
else:
    执行语句4...

2.循环语句

2.1 for循环

# for循环可以遍历任何序列
str = 'Python'
for s in str:
    print(s)
# 结果：P y t h o n

2.2 while循环

# while 循环，满足条件时进行循环，不满足条件时退出循环
sum = 0
m = 10
while m > 0:
    sum = sum + m
    m = m - 1
print(sum)
# result:55

2.3 break

# break 用在 for 循环和 while 循环语句中，用来终止整个循环。
str = 'Python'
for s in str:
    if s == 'o':
        break
    print(s)
# result:P y t h

2.4 continue

# continue 用在 for 循环和 while 循环语句中，用来终止本次循环
str = 'Python'
for s in str:
    if s == 'o':
        continue
    print(s)
# result: P y t h n

2.5 while循环案例

(1) 用户认证程序

#用户认证程序的基本逻辑就是接收用户输入的用户名密码然后与程序中存放的用户名密码进行判断，判断成功则登陆成功，判断失败则输出账号或密码错误
username = "jason"
pwd = "123"

inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == pwd:
    print("登陆成功")
else:
    print("输入的用户名或密码错误！")
#通常认证失败的情况下，会要求用户重新输入用户名和密码进行验证，如果我们想给用户三次试错机会，本质就是将上述代码重复运行三遍，你总不会想着把代码复制3次吧。。。。
username = "jason"
pwd = "123"

# 第一次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == pwd:
    print("登陆成功")
else:
    print("输入的用户名或密码错误！")

# 第二次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == pwd:
    print("登陆成功")
else:
    print("输入的用户名或密码错误！")
    
# 第三次验证
inp_name =  input("请输入用户名：")
inp_pwd =  input("请输入密码：")
if inp_name == username and inp_pwd == pwd:
    print("登陆成功")
else:
    print("输入的用户名或密码错误！")

#即使是小白的你，也觉得的太low了是不是，以后要修改功能还得修改3次，因此记住，写重复的代码是程序员最不耻的行为。
#那么如何做到不用写重复代码又能让程序重复一段代码多次呢？ 循环语句就派上用场啦（使用while循环实现）

username = "jason"
pwd = "123"
# 记录错误验证的次数
count = 0
while count < 3:
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == pwd:
        print("登陆成功")
    else:
        print("输入的用户名或密码错误！")
        count += 1

(2) while+break使用

username = "jason"
pwd = "123"
# 记录错误验证的次数
count = 0
while count < 3:
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == pwd:
        print("登陆成功")
        break # 用于结束本层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

(3) while循环嵌套+break

username = "jason"
pwd = "123"
count = 0
while count < 3:  # 第一层循环
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        print("登陆成功")
        while True:  # 第二层循环
            cmd = input('>>: ')
            if cmd == 'quit':
                break  # 用于结束本层循环，即第二层循环
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

(4) while循环嵌套+tag的使用

username = "jason"
pwd = "123"
count = 0

tag = True
while tag: 
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == pwd:
        print("登陆成功")
        while tag:  
            cmd = input('>>: ')
            if cmd == 'quit':
                tag = False  # tag变为False， 所有while循环的条件都变为False 
                break
            print('run <%s>' % cmd)
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

(5) while+continue的使用

# 打印1到10之间，除7以外的所有数字
number=11
while number>1:
    number -= 1
    if number==7:
        continue # 结束掉本次循环，即本次循环continue之后的代码都不会运行了，而是直接进入下一次循环
    print(number)

(6) while+else的使用

# 在while循环的后面，我们可以跟else语句，当while 循环正常执行完并且中间没有被break 中止的话，就会执行else后面的语句，所以我们可以用else来验证，循环是否正常结束 
count = 0
while count <= 5 :
    count += 1
    print("Loop",count)
else:
    print("循环正常执行完啦")
print("-----out of while loop ------")
输出
Loop 1
Loop 2
Loop 3
Loop 4
Loop 5
Loop 6
循环正常执行完啦   #没有被break打断，所以执行了该行代码
-----out of while loop ------

3.pass语句

# pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。
if True:
    pass

六、与用户交互

1.获取用户输入input(’ ')

usrname = input('请输入您的用户名>>>:')
# input获取到的用户输入都会转成字符串类型

2.输出内部数据print()

1.先写print括号内写需要的打印的东西
2.先写需要打印的东西之后使用句点符跟print之后tab键即可

七、垃圾回收机制

1.引用计数

# python会将引用计数为0的数据清除

2.标记清除

# 当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除

3.分代回收

# 分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低