Python常见部分内置方法与操作

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  # 重新赋值，内存地址肯定会发生改变