Python常见内置方法与操作
整型int
- 类型转换
int(其它数据类型)，但只支持数字类型和小数类型
>>> num1 = input('Your age>>>:')
Your age>>>:18
>>> print(type(num1))
<class 'str'> # 可以看到输入的类型为字符串类型
>>> num1 = int(num1)
>>> print(type(num1))
<class 'int'> # 可以看到转换后的类型
- 进制数转换
将10进制转换为2、8、16进制数，根据下面的代码可以看到，2进制的以0b开头，8进制以0o开头，16进制以0x开头。
>>> print(bin(100)) # 转换为2进制
0b1100100 # 转换后的2进制数据值
>>> print(oct(100)) # 转换为8进制
0o144 # 转换后的8进制数据值
>>> print(hex(100)) # 转换为16进制
0x64 # 转换后的16进制数据值
将2、8、16进制数转换为10进制
>>> print(int(0b1100100))
100
>>> print(int(0o144))
100
>>> print(int(0x64))
100
如果转换的内容带有引号，需要告诉解释器进制数
>>> print(int('0b1100100'))# 加上引号后直接输出会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '0b1100100'
# 告诉解释器你的进制数就可以输出了
>>> print(int('0b1100100',2))
100
>>> print(int('0o144',8))
100
>>> print(int('0x64',16))
100
浮点型float
- 类型转换
float(其它数据类型)，转换内容中只能出现纯数字，外加一个小数点。
>>> num1 = 10
>>> print(type(num1))
<class 'int'> # 数据整形为int
>>> num1 = float(num1) # 转换数据类型
>>> print(type(num1))
<class 'float'> # 数据类型为float
>>> print(num1)
10.0 # 可以看到转换后的结果加上了小数
字符串str
- 类型转换
str(其它数据类型)，可以转换任意数据类型，只需要在数据值的前后添加引号即可。
>>> num1 = 10
>>> print(type(num1))
<class 'int'>
>>> print(num1)
10
>>> num1 = '10'
>>> print(type(num1))
<class 'str'> # 数据类型为str
>>> print(num1)
10 # 虽然值也为10，但数据类型为str，这时是不可以作运算的。
>>> num2 = 5 # 定义一个num2
>>> print(num1 - num2) # 使两个值相减，此时的num1的值为str类型的10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'int' #直接报错
- 操作与方法
索引取值
取索引值为1的对应的数据值
>>> s1 = 'abcde'
>>> print(s1[1])
b
取倒数第一个数据值
>>> s1 = 'abcde'
>>> print(s1[-1])
e
取出所有数据值
>>> s1 = 'abcde'
>>> print(s1[:])
abcde
>>> print(s1[::])
abcde
切片操作
注意，切片操作取值顾头不顾尾，默认顺序为从左到右取值。
取索引1至5（不包含5）对应的数据值
>>> s1 = 'abcde'
>>> print(s1[1:5])
bcde
从倒数第5个值开始，取到倒数第2个值
>>> s1 = 'abcde'
>>> print(s1[-5:-1])
abcd
输出从索引2开始所有的数值
>>> s1 = 'abcde'
>>> print(s1[2:])
cde
从索引0开始输出，直到索引4结束
>>> s1 = 'abcdefghijk'
>>> print(s1[:5])
abcde
从索引0开始输出，之后每隔一个索引输出一次数据（因为最后一个值默认是1，所以2只是增加1个数，所以是每隔一个索引输出一次）
>>> s1 = 'abcdefghijk'
>>> print(s1[::2])
acegik
修改切片方向与间隔取值
先输出索引1的值后，每间隔2个索引值输出一个值。
>>> s1 = 'abcdefghijk'
>>> print(s1[1:5:2])
bd
正常取值是从左向右，通过最后一个键值改为-1时，取值顺序变为从右向左
>>> s1 = 'abcdefghijk'
>>> print(s1[-1:-5:-1])
kjih
统计字符串的个数
对应方法：len()
>>> s1 = 'abcdefghijk'
>>> print(len(s1))
11
移除字符串首尾指定的字符
对应方法：strip()
使用场景：用户在输入用户名、验证码等信息时容易多输入空格，这时候就需要把空格去除，让用户体验更好。
username = input('username >>>:').strip()
# 使用strip后，在输入用户名的时候，输入'abc '的话，也会判定成功。
if username == 'abc':
print('success!!!')
如果想要指定去除开头结尾的指定字符的话也可以
>>> '$$abc$$'.strip('$') # 指定去除的字符串为'$'
'abc'
如果只想去除开头或者结尾其中一个地方的字符串可以使用
去除开头也就是左侧指定字符串：lstrip（第一个字母l其实是left的开头字母）
去除结尾也就是右侧指定字符串：rstrip（第一个字母r其实是right的开头字母）
>>> '$$abc$$'.lstrip('$')
'abc$$'
>>> '$$abc$$'.rstrip('$')
'$$abc'
切割字符串中指定的字符
切割字符串：split()
被切割后的字符串以列表的形式展现
>>> 'jack,18,teacher'.split(',')
['jack', '18', 'teacher']
# 使用变量的方式调用此方法
>>> s1 = 'jack,18,teacher'
>>> s1.split(',')
['jack', '18', 'teacher']
也可以为各个数据值指定变量
>>> s1 = 'jack,18,teacher'
>>> name, age, job = s1.split(',')
>>> print(name, age, job)
jack 18 teacher
指定切割对象数量，使用maxsplit参数
>>> s1 = 'jack,18,teacher'
>>> print(s1.split(',',maxsplit=1))
['jack', '18,teacher'] # 可以看到切割成了两份
指定切割对象数量，并进行反向切割：rsplit()
>>> s1 = 'jack,18,teacher'
>>> print(s1.rsplit(',',maxsplit=1))
['jack,18', 'teacher']
字符串格式化输出
格式化输出：format()
第一种使用方法：当作占位符使用，与%s类似的使用方法
>>> res = 'The IP address is {}, Port is {}'.format('1.1.1.1','3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389
第二种，根据索引取值，可以反复使用
>>> res = 'The IP address is {0}, Port is {1}, The{0} cannot conmunicate!'.format('1.1.1.1','3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389, The1.1.1.1 cannot conmunicate!
第三种，类似于字典形式调用，见名知意
>>> res = 'The IP address is {addr}, Port is {port}, The{addr} cannot conmunicate!'.format(addr='1.1.1.1',port='3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389, The1.1.1.1 cannot conmunicate!
第四种，先指定变量，再进行调用
>>> name = input('username >>>:') # 搭配input使用，直接给变量赋值
username >>>:abcde # 输入用户名
>>> age = input('age >>>:') # 输入用户年龄
age >>>:18 # 年龄为18
>>> res = f'my name is {name},age is {age}' # 开头加一个f，并将内容使用引号引起来进行调用
>>> print(res)
my name is abcde,age is 18 # 可以看到调用成功
额外知识，可以让变量补全空位，达到对齐的效果，在调用变量值的时候，加上 X:>N 表示向右缩进N个字符并且使用X补齐，不输入X则默认使用空格。如果加上 X:<N表示左侧的N个字符使用X补齐。
# 可以看到，输出结果的年龄不对齐，有时候想要输出好看一些的时候，就可以定义缩进值了。
>>> jack_age = 29
>>> jason_age = 18
>>> john_green_age = 15
>>> print(f'''jack is {jack_age} years old,
... jason is {jason_age} years old
... john green is {john_green_age} years old''')
jack is 29 years old,
jason is 18 years old
john green is 15 years old
# 不指定字符补齐
>>> jack_age = 29
>>> jason_age = 18
>>> john_green_age = 15
>>> print(f'''jack is {jack_age:>8} years old,
... jason is {jason_age:>7} years old,
... john green is {john_green_age:>2} years old.''')
jack is 29 years old, # 变量值的左侧被空格补齐
jason is18 years old,
john green is 15 years old.
# 也可以指定字符补全
>>> print(f'''jack is {jack_age:$<8} years old,
... jason is {jason_age:$<7} years old,
... john green is {john_green_age:$<2} years old.''')
jack is 29$$$$$$ years old, # 变量值的右侧被指定的$补齐
jason is 18$$$$$ years old,
john green is 15 years old.
大小写相关
将字符串中的字母，全部变为大写：upper()
将字符串中的字母，全部变为小写：lower()
使用场景：用户输入验证码等场景时，可以忽略大小写，让用户体验更好。
>>> s1 = 'aAbBcC2333'
>>> s1.upper()
'AABBCC2333'
>>> s1.lower()
'aabbcc2333'
判断字符串中是否为纯数字
使用方法：isdigit()
>>> s1 = 'aAbBcC2333'
>>> s1.isdigit()
False
>>> s2 = '123456'
>>> s2.isdigit()
True
>>> s3 = '123.456' # 注意，在引号里面的小数点也是字符串，所以是False
>>> s3.isdigit()
False
替换字符串中指定的内容
>>> s1 = 'aAbBcC2333'
>>> s1.replace('a','G')
'GAbBcC2333' # 将a替换为G并输出
>>> print(s1)
aAbBcC2333 # 注意，原来的值没有改变，如果想要改变，需要重新赋值
字符串的拼接
使用print拼接
>>> s1 = 'Hello'
>>> s2 = 'World'
>>> print(s1 + s2)
HelloWorld
>>> print(s1 * 5) # 也支持乘法，多次输出
HelloHelloHelloHelloHello
使用join拼接
>>> print('|'.join(['Hello','World','Welcome']))
Hello|World|Welcome
# 注意，拼接内容必须使用str类型
>>> print('|'.join(['Hello','World',12]))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sequence item 2: expected str instance, int found
统计指定字符出现的次数
使用方法：count()
>>> s1 = 'aaaWorld'
>>> s1.count('a')
3
判断字符串开头或者结尾
判断开头：startswith
判断结尾：endswith
>>> s1 = 'aaaWorld'
>>> s1.startswith('a')
True # 判断成功则为真
>>> s1.startswith('b')
False # 判断失败则为假
>>> s1.endswith('d')
True
>>> s1.endswith('l')
False
开头字母大写，其余小写
方法：title()
>>> s1 = 'hello world'
>>> s1.title()
'Hello World'
>>> s1 = 'helloworld'
>>> s1.title()
'Helloworld' # 注意使用空格、标点等进行判断
>>> s1 = 'hello world,welcome you'
>>> s1.title()
'Hello World,Welcome You'
一句话中第一个单词的开头字母大写，其余小写
方法：capitalize()
>>> s1 = 'hello world,welcome you'
>>> s1.capitalize()
'Hello world,welcome you'
大小写转换
>>> s1 = 'aAbBcCdD123'
>>> s1.swapcase()
'AaBbCcDd123'
查找关键字第一次出现在第几个字符（注意从0开始）
方法1：index （如果没有值会报错）
方法2：find （如果没有值会返回 -1）
>>> s1 = 'cccabacd'
>>> s1.index('a') # 数据值在索引3的位置
3
>>> s1.find('a') # 数据值在索引3的位置
3
>>> s1.index('e') # 数据值中没有e，报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> s1.find('e') # 数据值中没有e，返回 -1
-1
列表类型
- 类型转换
list(其它数据类型)，通俗来说，能被for循环的都可以转换成列表。
- 操作与方法
列表之索引取值
>>> l1 = [1, 2, 3]
>>> print(l1[0])
1
列表之切片操作
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[0:5])
['a', 'b', 'c', 'd', 'e']
>>> print(l1[-5:-1])
['b', 'c', 'd', 'e']
列表之间隔取值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[0:5:2])
['a', 'c', 'e']
列表之反向取值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[::-1])
['f', 'e', 'd', 'c', 'b', 'a']
>>> print(l1[-1:-3:-1])
['f', 'e']
列表之统计列表中数据值的个数
使用方法：len()
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(len(l1))
6
列表之修改列表中的值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1[0] = '666'
>>> print(l1)
['666', 'b', 'c', 'd', 'e', 'f']
列表之在列表结尾添加追加数据值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.append('666')
>>> print(l1)
['a', 'b', 'c', 'd', 'e', 'f', '666']
列表之在列表任意位置添加新的数据值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.insert(3,'new') # 在索引3的位置增加new字符，原来的数据索引值顺延。
>>> print(l1)
['a', 'b', 'c', 'new', 'd', 'e', 'f']
列表之扩展列表 或 合并列表
>>> l1 = [1, 2, 3]
>>> l2 = [3, 4, 5]
>>> print(l1 + l2) # 只是打印，并不修改原数据值
[1, 2, 3, 3, 4, 5]
>>> l1.extend(l2) # 将l2中的数据追加到l1列表中
>>> print(l1)
[1, 2, 3, 3, 4, 5]
>>> print(l2) # 列表l2值不变
[3, 4, 5]
列表之删除表数据
方法1：del() 在内存中删除数据值
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> del(l1[0])
>>> print(l1)
['b', 'c', 'd', 'e', 'f']
方法2：remove() 在内存中删除数据值，并且使用数据值，不使用索引。
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.remove('a') # 将数据值为a的删除了
>>> print(l1)
['b', 'c', 'd', 'e', 'f']
# 问题，如果有多个a，会如何删除？
>>> l1 = ['a', 'b', 'c', 'd', 'a', 'e', 'f', 'a']
>>> l1.remove('a')
>>> print(l1)
['b', 'c', 'd', 'a', 'e', 'f', 'a'] # 只清理了按从左到右的顺序第一个a
方法3：pop() 将数据弹出，可以将弹出的数据赋值给其它变量
>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.pop(0)
'a' # 这里会输出你要弹出的数据值，如果指定了变量，则可以赋值
>>> print(l1)
['b', 'c', 'd', 'e', 'f'] # 原列表中的a被弹出
列表之列表的排序
使用方法：sort()
>>> l1 = ['d', 'c', 'b', 'a']
>>> l1.sort()
>>> print(l1)
['a', 'b', 'c', 'd']
>>> l2 = [5, 2, 1, 6, 9]
>>> l2.sort()
>>> print(l2)
[1, 2, 5, 6, 9]
倒序排序，加参数reverse（翻译为中文：相反、颠倒等意思）
>>> l1 = ['a', 'b', 'c', 'd']
>>> l2 = [5, 2, 1, 6, 9]
>>> l1.sort(reverse = True)
>>> l2.sort(reverse = True)
>>> print(l1)
['d', 'c', 'b', 'a']
>>> print(l2)
[9, 6, 5, 2, 1]
列表之统计列表中的数据值出现的次数
使用方法：count()
>>> l1 = ['aa', 'bc', 'cd', 'd']
>>> l1.count('d') # 注意，是按整个字符串进行匹配的，不是单个字母
1
>>> l1.count('cd')
1
列表之列表倒序输出
>>> l2 = [5, 2, 1, 6, 9]
>>> l2.reverse()
>>> print(l2)
[9, 6, 1, 2, 5] # 注意，只是反着输出，并不是反向排序
字典类型
- 类型转换
使用dict()，但是dict非常麻烦，一般不会使用这种方法进行转换，不如直接手写。
>>> print(dict([('name','pwd'),('jason',123)]))
{'name': 'pwd', 'jason': 123}
- 操作与方法
字典之查询
按键取值，但有一个缺点，如果键在字典中不存在，则会报错。
>>> d1 = {'username': 'jack', 'age': 18}
>>> print(d1['username'])
jack
>>> print(d1['job'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'job'
使用方法：get()
推荐使用，如果键在字典中不存在，只会返回None或指定的值。
>>> d1 = {'username': 'jack', 'age': 18}
>>> print(d1.get('username'))
jack
>>> print(d1.get('job')) # 默认返回None，不会报错
None
>>> print(d1.get('job', 'error!!!!')) # 第二个值定义返回的值
error!!!!
字典之修改值
通过键进行修改，注意，如果键在字典中不存在，则修改会变为增加键值。
>>> d1 = {'username': 'jack', 'age': 18}
>>> d1['age'] = 99
>>> print(d1)
{'username': 'jack', 'age': 99}
字典之增加值
只要字典中键不存在，则使用修改的方法就会变为增加键值。
>>> d1 = {'username': 'jack', 'age': 18}
>>> d1['job'] = 'Caption'
>>> print(d1)
{'username': 'jack', 'age': 18, 'job': 'Caption'}
字典之删除键值
方法一：del()
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> del d1['job']
>>> print(d1)
{'username': 'jason', 'age': 18}
方法二：pop() 注意：此方法与列表中的pop方法一样，可以将弹出（删除）的值赋值给新的变量
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.pop('job')
'Caption' # 此时可以将这个'Caption'赋值给新的变量
>>> print(d1)
{'username': 'jason', 'age': 18}
方法三：popitem 注意：此方法只能删除最后一个加入字典的键值对，无法指定删除哪个
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.popitem() # 将最后一个加入字典的键值删除
('age', 18)
>>> print(d1)
{'username': 'jason', 'job': 'Caption'}
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.popitem('username') # 可以看到，不可以指定删除哪个键值
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: popitem() takes no arguments (1 given)
字典之统计键值对的个数
使用方法：len()
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> print(len(d1))
3
字典之获取字典中所有键
使用方法：keys()
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.keys()
dict_keys(['username', 'job', 'age'])
字典之获取字典中所有值
使用方法：values()
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.values()
dict_values(['jason', 'Caption', 18])
字典之获取字典中键值对数据
使用方法：items()
>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.items()
dict_items([('username', 'jason'), ('job', 'Caption'), ('age', 18)])
字典之快速生成值相同的字典
使用方法：dict.fromkeys() 注意：值为三个键共享，所以无论为哪一个键增加值，其它键都会看到。
>>> print(dict.fromkeys(['name', 'job', 'age'], 123))
{'name': 123, 'job': 123, 'age': 123}
>>> d1 = dict.fromkeys(['name', 'job', 'age'], [])
>>> d1['name'].append('jason') # 为name 增加一个值'jason'
>>> d1['job'].append('Caption') # 为job 增加一个值'Caption'
>>> d1['age'].append(18) # 为age 增加一个值18
>>> print(d1) # 我们想要的结果应该是{'name': 'jason', 'job': 'Caption', 'age': 18}，但请看输出的结果
{'name': ['jason', 'Caption', 18], 'job': ['jason', 'Caption', 18], 'age': ['jason', 'Caption', 18]}
元组类型
- 类型转换
tuple(数据值) 说明：可以被for循环的数据值都可以转换为tuple
>>> s1 = 'abcde'
>>> tuple(s1)
('a', 'b', 'c', 'd', 'e')
- 方法与操作
索引取值
>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0])
a
切片取值
>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0:1])
('a',) # 注意取一个值的时候会有一个逗号，指定变量的时候也一样，结尾加上逗号才算是元组，否则算是其它数据类型
间隔取值
>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0:4:2])
('a', 'c')
反向取值等都与列表相同
>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[-1:-3:-1])
('e', 'd')
元组之统计元组中数据值的个数
使用方法：len()
>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(len(s1))
5
元组之统计一个数据值出现的次数
使用方法：count()
>>> s1 = ('a', 'b', 'c', 'd', 'e', 'a')
>>> s1.count('a')
2
元组之查看一个数据值对应的索引值
使用方法：index() 注意：如果数据值重复的话，只能看到从左向右第一个数据值的对应索引值
>>> s1 = ('a', 'b', 'c', 'c', 'd')
>>> print(s1.index('c'))
2
集合类型
- 类型转换
set(数据值)
注意： 集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
集合内的数据也是无序的，没有索引的概念
- 操作与方法
集合之去重
去掉数据值内重复的值，只要将数据类型转换为set就会自动去重，但是注意：集合去重无法保留原先数据的排序顺序
>>> l1 = [11, 22, 33, 11, 22, 55, 66]
>>> s1 = {11, 33, 55, 22, 99, 77, 11, 33, 22}
>>> print(set(s1))
{33, 99, 22, 55, 11, 77}
>>> print(set(l1))
{33, 66, 11, 22, 55}
集合之取两个元组中相同的值
使用方法：两个值之间使用'&' 或者使用方法intersection （& 等同于 intersection）
>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 & s2)
{'qqq', 'ccc', 'ddd'}
>>> print(s1.intersection(s2))
{'qqq', 'ccc', 'ddd'}
集合之取前面集合有，后面集合没有的值
使用方法：两个值之间使用'-' 或者使用方法difference （- 等同于 difference）
>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 - s2)
{'lll', 'abc'}
>>> print(s1.difference(s2))
{'lll', 'abc'}
集合之取两个元组中所有的值，且去掉重复值
使用方法：两个值之间使用 '|' 或者使用方法union （｜ 等同于 union）
>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 | s2)
{'cba', 'lll', 'bbb', 'ccc', 'ddd', 'abc', 'qqq'}
>>> print(s1.union(s2))
{'cba', 'lll', 'bbb', 'ccc', 'ddd', 'abc', 'qqq'}
元组之取两个元组中，独有的值（就是去掉相同的部分，输出不同的部分）
使用方法：两个值之间使用 '^' 或者使用方法 symmetric_difference (^ 等同于 symmetric_difference)
>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 ^ s2)
{'cba', 'abc', 'lll', 'bbb'}
>>> print(s1.symmetric_difference(s2))
{'cba', 'abc', 'lll', 'bbb'}
可变类型与不可变类型
- 可变类型的特点：
- 列表在调用内置方法之后修改的就是自身，并没有产生一个新的结果。
- 变量的值改变，内存地址不会改变
>>> l1 = [1, 2]
>>> id(l1)
2242835102344
>>> l1.append(3) # 修改的是自身，并没有产生一个新的结果
>>> id(l1)
2242835102344 # 内存不变
>>> print(l1)
[1, 2, 3] # 在内存不变的情况下，数据值发生了改变
- 不可变类型的特点：
- 字符串在调用内置方法之后并不会修改自己，而是产生了一个新的结果。
- 变量的值改变，内存地址肯定会发生改变。
>>> s1 = '$$$abc$$$'
>>> id(s1)
2242835110960
>>> s1.strip('$')
'abc' # 产生了一个新的结果
>>> print(s1)
$$$abc$$$ # 数据值并不会改变
>>> id(s1)
2242835110960 # 内存地址没有变化
# 这个时候，如果想要改变结果，需要对变量重新赋值
>>> s1 = s1.strip('$')
>>> print(s1)
abc
>>> id(s1)
2242835112768 # 重新赋值，内存地址肯定会发生改变