整型内置方法

定义

int()函数将一个字符串或数字转换为整型

语法

  1. class int(x, base=10)
  2. # x --字符串或数字
  3. # base --进制数，默认十进制

类型转换

  1. a = int('1')
  2. print(a, type(a))
  3. # 1 <class 'int'>

补充:

将十进制转换成其他机制

  1. print(bin(100))  # 0b1100100    二进制(0b开头)
  2. print(oct(100))  # 0o144        八进制(0o开头)
  3. print(hex(100))  # 0x64         十六机制(0x开头)
  4. # 将其他机制转换成十进制
  5. print(int('0b1100100', 2))  # 100
  6. print(int('0o144', 8))  # 100
  7. print(int('0x64', 16))  # 100

浮点型内置方法

定义

float()函数用于将整数和字符串转换成浮点数。

语法

  1. class float([x])
  2. # x --整数或字符串

类型转换

  1. a = float('1.1')
  2. b = float('1')
  3. print(a, b, type(a), type(b))
  4. # 1.1 1.0 <class 'float'> <class 'float'>

字符串内置方法（常用）

定义

str()函数可以转换所有基本数据类型

语法

  1. class str(object='')
  2. #  object --对象

类型转换

  1. a = str(1)
  2. b = str(1.1)
  3. c = str([1, 2, 3])
  4. d = str({'name': 'kevin'})
  5. e = str((1, 2, 3))
  6. f = str({1, 2, 3})
  7. print(a, type(a), '\n', b, type(b), '\n', c, type(c), '\n', d, type(d), '\n', e, type(e), '\n', f, type(f))
  8. #  1 <class 'str'> 
  9. #  1.1 <class 'str'> 
  10. #  [1, 2, 3] <class 'str'> 
  11. #  {'name': 'kevin'} <class 'str'> 
  12. #  (1, 2, 3) <class 'str'> 
  13. #  {1, 2, 3} <class 'str'>

基本操作

索引取值

使用

  1. s = "hello world"
  2. print(s[0])
  3. # h

切片操作

使用

  1. s = "hello world"
  2. print(s[2:4])  # 从索引2（包含2）取到索引4（不包含4）
  3. # ll
  4. print(s[2:9:2])  # 从索引2开始（包含2）取到索引9（不包含9），步长为2（默认是1）
  5. # llowr

统计字符串中字符的个数

定义

len() 函数返回对象（字符、列表、元组等）长度或个数

语法

  1. len( s )
  2. # s --对象

使用

  1. s = "hello world"
  2. print(len(s))
  3. # 11 (其中空格也算字符)

成员运算

定义

in判断是否存在，返回True或False

使用

  1. s = "hello world"
  2. print('ll' in s)
  3. # True

移除字符串指定的字符（频率高）

定义

strip() 去除首尾匹配的字符，默认空格

lstrip() 去除左侧匹配的字符，默认空格

rstrip() 去除右侧匹配的字符，默认空格

语法

  1. str.strip([chars])
  2. # chars --移除字符串头尾指定的字符序列

使用

  1. s = "   hello   "
  2. print(s.strip())  # 默认移除字符串首尾的空格
  3. # hello
  4. s = "%%%hell%o%%%"
  5. print(s.strip('%'))
  6. # hell%o
  7. print(s.lstrip('%'))
  8. # hell%o%%%
  9. print(s.rstrip('%'))
  10. # %%%hell%o

按照指定的字符切割字符串

定义

split() 从左开始切割匹配的字符，返回列表

rsplit() 从右开始切割匹配的字符，返回列表

语法

  1. str.split(str="", num=string.count(str))
  2. # str --分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
  3. # num --分割次数，默认为 -1, 即分隔所有

使用

  1. data = 'kevin|male|22'
  2. print(data.split('|')) 
  3. # ['kevin', 'male', '22']
  4. name, gender, age = data.split('|')  # 解压赋值
  5. print(name, gender, age)
  6. # kevin male 22
  7. print(data.split('|', maxsplit=1))  # maxsplit代表切割几次
  8. # ['kevin', 'male|22']
  9. print(data.rsplit('|', maxsplit=1))  # 从右开始切割
  10. # ['kevin|male', '22']

指定字符串进行大小写转换（常用验证码）

定义

lower() 将字符串的里的所有英文字母转换为小写

upper() 将字符串的里的所有英文字母转换为大写

islower() 判断字符串里的所有英文字母，是否为小写

issuper() 判断字符串里的所有英文字母，是否为大写

语法

  1. str.lower()
  2. str.upper()
  3. str.islower()
  4. str.isupper()
  5. # str --检测的字符串

使用

  1. s1 = 'KEVIN123'
  2. s2 = 'kevin123'
  3. print(s1.lower())
  4. # kevin123
  5. print(s2.upper())
  6. # KEVIN123
  7. print(s1.islower())
  8. # False
  9. print(s2.isupper())
  10. # False

判断字符串的首尾指定字符

定义

startswith 判断字符串的开头是否为指定字符

endswith 判断字符串的结尾是否为指定字符

语法

  1. str.startswith(substr, start, end)
  2. str.endswith(substr, start ,end)
  3. # str --检测的字符串
  4. # substr  --指定的子字符串
  5. # start --可选参数用于设置字符串检测的起始位置
  6. # end --可选参数用于设置字符串检测的结束位置

使用

  1. s = 'kevin'
  2. print(s.startswith('k'))
  3. # True
  4. print(s.endswith('i'))
  5. # False

格式化输出

定义

format() 通过{}来占位，代替%s

使用

  1. # 1.通过 {} 占位符直接输出
  2. print("My name is {} my age is {}".format('kevin', 22))
  3. # My name is kevin my age is 22
  5. # 2.通过索引取值
  6. print("My name is {0} my age is {3}".format('kevin', 'tony', 18, 22))
  7. # My name is kevin my age is 22
  9. # 3.通过“指名道姓”方式取值
  10. print("My name is {name} my age is {age}".format(name='kevin', age=22))
  11. # My name is kevin my age is 22
  13. # 4.直接使用已经出现过的常量（常用）
  14. name = 'kevin'
  15. age = 22
  16. # 要在前面加f!!!
  17. print(f"My name is {name} my age is {age}")
  18. # My name is kevin my age is 22

拼接字符串

使用

  1. s1 = '好好学习'
  2. s2 = '天天向上'
  3. print(s1 + s2)
  4. # 好好学习天天向上
  5. print((s1 + s2 + '\n') * 5)
  6. # 好好学习天天向上
  7. # 好好学习天天向上
  8. # 好好学习天天向上
  9. # 好好学习天天向上
  10. # 好好学习天天向上

替换字符串

定义

join() 将序列中的元素以指定的字符连接生成一个新的字符串

语法

  1. str.join(sequence)
  2. # str --检测的字符串
  3. # sequence --要连接的元素序列

使用

  1. s = 'kevin'
  2. print('|'.join(s))  # 相当于将括号里的元素进行for循环
  3. # k|e|v|i|n
  4. s = '|'
  5. print(s.join(['k', 'e', 'v', 'i', 'n']))
  6. # k|e|v|i|n

补充：join方法相当于是将括号内的元素进行for循环

替换字符串 （常用编辑器替换）

定义

replace() 函数是把字符串中的旧字符串，替换成新字符串，如果指定第三个参数max，则替换不超过 max 次

语法

  1. str.replace(old, new, max)
  2. # old --将被替换的子字符串
  3. # new --新字符串，用于替换old子字符串
  4. # max --可选字符串, 替换不超过 max 次

使用

  1. s = 'tony|tony|tony|tony|tony'
  2. print(s.replace('tony', 'kevin'))
  3. # kevin|kevin|kevin|kevin|kevin
  4. print(s.replace('tony', 'kevin', 2))  # 从左向右替换
  5. # kevin|kevin|tony|tony|tony

补充：很多文本编辑器里面的替换功能 就可以使用replace完成

判断字符串是否为纯整数

定义

isdigit() 判断字符串是否为纯整数

语法

  1. str.isdigit()

使用

  1. s = '1'
  2. print(s.isdigit())
  3. # True
  4. s = '0'
  5. print(s.isdigit())
  6. # True
  7. s = 'kevin'
  8. print(s.isdigit())
  9. # False
  10. s = '-1'
  11. print(s.isdigit())
  12. # False

查找指定字符

定义

find() 检测字符串中是否包含子字符串

语法

  1. str.find(str, start, end)
  2. # str --指定检索的字符串
  3. # start --开始索引，默认为0
  4. # end --结束索引，默认为字符串的长度

使用

  1. s = 'kevin|kevin'
  2. print(s.find('i'))
  3. # 3
  4. print(s.find('n'))
  5. # 4
  6. print(s.find('n', 6, 11))
  7. # 10
  8. print(s.index('o'))  # 使用index()会报错，不推荐使用

改变文本位置

定义

center()指定宽度居中的字符串，可选填充的字符，默认为空格

ljust() 指定宽度向左对齐的字符串，可选填充的字符，默认为空格

rjust() 指定宽度向右对齐的字符串，可选填充的字符，默认为空格

语法

  1. str.center(width, fillchar)
  2. str.ljust(width, fillchar)
  3. str.rjust(width, fillchar)
  4. # width --字符串的总宽度
  5. # fillchar --填充字符

使用

  1. s = 'kevin'
  2. print(s.center(20,'-'))
  3. # -------kevin--------
  4. print(s.ljust(20, '-'))
  5. # kevin---------------
  6. print(s.rjust(20, '-'))
  7. # ---------------kevin

特殊符号

斜杠与一些英文字母组合会产生特殊的含义

使用

  1. print('hello\nkevin')  # \n 表示换行
  2. print('hello\tkevin')  # \t 表示制表符
  3. print('hello\akevin')  # \a 表示特殊符号
  5. # 如果想取消它们的特殊含义 可以在字符串的前面加一个字母r
  6. print(r'hello\nkevin') 
  7. # hello\nkevin

首字母大写

使用

  1. msg = 'hello,my name is kevin'
  2. print(msg.capitalize)
  3. # Hello,my name is kevin

大小写翻转

使用

  1. msg = 'hello,my name is kevin'
  2. print(msg.swapcase())
  3. # HELLO,MY NAME IS KEVIN

每个单词的首字母大写

使用

  1. msg = 'hello,my name is kevin'
  2. print(msg.title())
  3. # Hello,My Name Is Kevin

列表内置方法

定义

list() 用于将 字符串、列表、字典、元组、集合，转换为列表

语法

  1. list( seq )
  2. # seq -- 要转换为列表的字符串、列表、字典、元组、集合

类型转换

  1. print(list(1))
  2. # 报错
  3. print(list(1.1))
  4. # 报错
  5. print(list('kevin'))  # 字符串
  6. # ['k', 'e', 'v', 'i', 'n']
  7. print(list([1, 2, 3]))  # 列表
  8. # [1, 2, 3]
  9. print(list({'name': 'kevin'}))  # 字典
  10. # ['name']
  11. print(list((1, 2, 3,)))  # 元祖
  12. # [1, 2, 3]
  13. print(list({1, 2, 3}))  # 集合
  14. # [1, 2, 3]

基本操作

索引取值

使用

  1. name_list = ['kevin', 'tony', 'jerry']
  2. print(name_list[0])
  3. # kevin
  4. print(name_list[-1])
  5. # jerry

切片操作

使用

  1. name_list = ['kevin', 'tony', 'jerry']
  2. print(name_list[0:4])
  3. # ['kevin', 'tony', 'jerry']
  4. print(name_list[-4:0])
  5. # ['kevin', 'tony']
  6. print(name_list[-1:-4:-1])
  7. # ['jerry', 'tony', 'kevin']

统计列表中元素的个数

使用

  1. name_list = ['kevin', 'tony', 'jerry']
  2. print(len(name_list))
  3. # 3

成员运算

使用

  1. name_list = ['kevin', 'tony', 'jerry']
  2. print('kevin' in name_list)
  3. # True
  4. print('jason' in name_list )
  5. # False

列表添加元素

使用

  1. # 1.尾部追加'单个'元素
  2. name_list = ['kevin', 'tony', 'jerry']
  3. name_list.append('jason')
  4. print(name_list)
  5. # ['kevin', 'tony', 'jerry', 'jason']
  7. # 2.指定位置插入'单个'元素
  8. name_list.insert(2, '插入的元素')
  9. print(name_list)
  10. # ['kevin', 'tony', '插入的元素', 'jerry', 'jason']
  12. # 3.合并列表
  13. name_list.extend([1,2,3])  # extend其实可以看成是for循环+append
  14. print(name_list)
  15. # ['kevin', 'tony', '插入的元素', 'jerry', 'jason', 1, 2, 3]
  17. name_list += [1,2,3]  # 效率不高
  18. print(name_list) 
  19. #['kevin', 'tony', '插入的元素', 'jerry', 'jason', 1, 2, 3, 1, 2, 3]

删除列表元素

使用

  1. # 1. 通用删除方式（没有会报错）
  2. name_list = ['kevin', 'tony', 'jerry']
  3. del name_list[0]
  4. print(name_list)
  5. # ['tony', 'jerry']
  7. # 2."指名道姓"删除
  8. name_list = ['kevin', 'tony', 'jerry']
  9. print(name_list.remove('kevin'))
  10. # None
  11. print(name_list)
  12. # ['tony', 'jerry']
  14. # 3.延迟删除
  15. name_list = ['kevin', 'tony', 'jerry']
  16. print(name_list.pop())
  17. # jerry
  18. print(name_list)
  19. # ['kevin', 'tony']
  20. print(name_list.pop(1))  # 支持索引
  21. # tony
  22. print(name_list)
  23. # ['kevin']

修改列表元素

使用

  1. name_list = ['kevin', 'tony', 'jerry']
  2. print(id(name_list[0]))
  3. # 140594414712680
  4. name_list[0] = 'kevinNB'
  5. print(id(name_list[0]))
  6. # 140594417263368

排序

使用

  1. s = [9, 4, 1, 8, 5, 6, 2, 7, 3]
  2. s.sort()
  3. print(s)
  4. # [1, 2, 3, 4, 5, 6, 7, 8, 9]
  5. s.sort(reverse=True)  # 可以修改尾降序
  6. print(s)
  7. # [9, 8, 7, 6, 5, 4, 3, 2, 1]

列表比较运算

使用

  1. s1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
  2. s2 = [11, 22, 33, 44]
  3. print(s1 > s2)  # 列表在做比较的时候 其实比的是对应索引位置上的元素
  4. # False
  5. s1 = ['A', 'B', 'C']  # A对应ASCII是65
  6. s2 = ['a', 'b', 'c']  # a对应ASCII是97
  7. print(s1 > s2)
  8. # False

统计列表中某个元素出现的次数

使用

  1. s = [1, 2, 3, 1, 4, 5, 2, 3, 2, 1, 3, 2, 1, 1, 1, 3, 2, 5, 6, 1, 3]
  2. print(s.count(1))
  3. # 7

清空列表

使用

  1. s = [1, 2, 3, 1, 4, 5, 2, 3, 2, 1, 3, 2, 1, 1, 1, 3, 2, 5, 6, 1, 3]
  2. s.clear()
  3. print(s)
  4. # []

字典内置方法

定义

dict()函数用于创建一个字典

语法

  1. class dict(**kwarg)
  2. class dict(mapping, **kwarg)
  3. class dict(iterable, **kwarg)
  4. # **kwargs -- 关键字。
  5. # mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
  6. # iterable -- 可迭代对象。

类型转换

  1. print(dict(a='a', b='b', c='c'))
  2. # {'a': 'a', 'b': 'b', 'c': 'c'}
  3. print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))  # 映射函数方式来创造字典
  4. # {'oen': 1, 'two': 2, 'three': 3}
  5. print(dict([('one', 1), ('two', 2), ('three', 3)]))
  6. # {'one': 1, 'two': 2, 'three': 3}
  8. # 取值方法
  10. # 1.按key值取（不推荐）
  11. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  12. print(d['name'])
  13. # kevin
  14. print(d[xxx])  # 报错

基本操作

取值方法

使用

  1. # get() 取值（推荐）
  2. # dict.get(key[, value]) 
  3. # key -- 字典中要查找的键。
  4. # value -- 可选，如果指定键的值不存在时，返回该默认值
  5. print(d.get('name'))
  6. # kevin
  7. print(d.get('xxx'))
  8. # None
  9. print(d.get('xxx', '这个键值不存在，可以是任何数据类型'))
  10. # 这个键值不存在，可以是任何数据类

修改值

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  3. print(d['name'], id(d))
  4. # kevin 140553714244056
  5. d['name'] = 'kevin666'
  6. print(d['name'], id(d))
  7. # kevin666 140553714244056

添加键值对

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  3. d['pwd'] = 123  # 键不存在则是新增一个键值对
  4. print(d)
  5. # {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'pwd': 123}

成员运算（只能判断key）

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  3. print('name' in d)
  4. # True
  5. print('kevin' in d)
  6. # False

删除键值对

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  3. del d['hobby']
  4. print d
  5. # {'name': 'kevin', 'age': '22'}
  7. print(d.pop('age'))
  8. # 22
  9. print(d)
  10. # {'name': 'kevin'}
  12. d.popitem() # 随机弹出一个(使用频率很低 可以忽略)

获取所有键、值、和键值对

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  3. print(d.keys())
  4. # dict_keys(['name', 'age', 'hobby'])
  5. print(d.values())
  6. # dict_values(['kevin', '22', ['run', 'cs']])
  7. print(d.items())  # 可以看成列表套元组
  8. # dict_items([('name', 'kevin'), ('age', '22'), ('hobby', ['run', 'cs'])]
  10. for i in d.values():
  11.     print(i)

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

更新字典

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  2. d.update({'name': 'tony', 'k4': 'xxx'})
  3. print(d)  #  键存在则修改 键不存在则新增
  4. # {'name': 'tony', 'age': '22', 'hobby': ['run', 'cs'], 'k4': 'xxx'}

快速生成字典

使用

  1. d = dict.fromkeys(['name', 'age', 'hobby'], [])
  2. print(d)
  3. # {'name': [], 'age': [], 'hobby': []}

更多操作

setdefault() 如果键不存在于字典中，将会添加键并将值设为默认值

语法

  1. dict.setdefault(key, default=None)
  2. # key -- 查找的键值
  3. # default -- 键不存在时，设置的默认键值

使用

  1. d = {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs']}
  2. print(d.setdefault('xxx', 'xxx')) # # 键不存在则新增键值对 并且有返回结果是新增的value
  3. # xxx
  4. print(d)  
  5. # {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'xxx': 'xxx'}
  7. print(d.setdefault('name', 'tony'))  # 键存在 则返回对应的值 但不做修改
  8. # kevin
  9. print(d)
  10. # {'name': 'kevin', 'age': '22', 'hobby': ['run', 'cs'], 'xxx': 'xxx'}

笔试题

  1. d = dict.fromkeys(['name', 'age', 'hobby'], [])
  2. print(d)
  3. # {'name': [], 'age': [], 'hobby': []}
  4. d['name'].append(123)
  5. print(d)
  6. # {'name': [123], 'age': [123], 'hobby': [123]}

元组内置方法

定义

tuple 函数将可迭代系列（如列表）转换为元组

语法

  1. tuple(iterable)
  2. # iterable -- 要转换为元组的可迭代序列。

类型转换

  1. print(tuple(1))  #报错
  2. print(tuple(1.1))  # 报错
  3. print(tuple('kevin'))
  4. # ('k', 'e', 'v', 'i', 'n')
  5. print(tuple([1, 2, 3]))
  6. # (1, 2, 3)
  7. print(tuple({'name': 'kevin'}))
  8. # ('name',)
  9. print(tuple({1, 2, 3}))
  10. # (1, 2, 3)

特性

  1. t = (1, 1.11, 'kevin')
  2. print(type(t))
  3. # <class 'tuple'>
  4. t = (1)
  5. print(type(t))
  6. # <class 'int'>
  7. t = (1.11)
  8. print(type(t))
  9. # <class 'float'>
  10. t =('kevin')
  11. print(type(t))
  12. # <class 'str'>

知识点：当元组内只有一个元素的时候 一定要在元素的后面加上逗号 a = (1,2,3,)。一般情况下 我们会习惯性的将所有可以存储多个数据的类型的数据，如果内部只有一个元素 也会加逗号。

  1. t = (1,)
  2. print(type(t))
  3. # <class 'tuple'>
  4. t = (1.11,)
  5. print(type(t))
  6. # <class 'tuple'>
  7. t =('kevin',)
  8. print(type(t))
  9. # <class 'tuple'>

基本操作

索引取值

使用

  1. t = (1, 2, 3)
  2. print(t[0])
  3. # 1

切片操作

使用

  1. t = (1, 2, 3, 4, 5, 6, 7, 8)
  2. print(t[2:5:2])
  3. # (3, 5)

统计元素个数

使用

  1. t = (1, 2, 3, 4, 5, 6, 7, 8)
  2. print(len(t))
  3. # 8

成员运算

使用

  1. t = (1, 2, 3, 4, 5, 6, 7, 8, 3, 3)
  2. print(2 in t)
  3. # True
  4. print(9 in t)
  5. # False

某元素统计出现次数

使用

  1. t = (1, 2, 3, 4, 5, 6, 7, 8, 3, 3)
  2. print(t.count(3))
  3. # 3

补充：元组内元素不能”修改”: 元组内各个索引值指向的内存地址不能修改

笔试题

  1. t = (1, 2, 3, 4, [1, 2])
  2. print(id(t[-1]))
  3. # 140252689809480
  4. t[-1].append('kevin')
  5. print(t)
  6. # (1, 2, 3, 4, [1, 2, 'kevin'])
  7. print(id(t[-1]))
  8. # 140252689809480

集合内置方法

定义

set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

语法

  1. class set([iterable])
  2. # iterable -- 可迭代对象对象

类型转换

  1. # print(set(11))  # 报错
  2. # print(set(11.11))  # 报错
  3. print(set('kevin'))
  4. # {'k', 'e', 'v', 'n', 'i'}
  5. print(set([11, 22, 33, 44]))
  6. # {33, 11, 44, 22}
  7. print(set({'name': 'kevin'}))
  8. # {'name'}
  9. print(set((11, 22, 33)))
  10. # {33, 11, 22}
  11. # print(set(True))  # 报错

基本操作

去重

集合内出现重复的元素，会被集合自动去重(自带去重特性)但是是输出无序的

  1. s = set('kevinkevinkevinkevin')
  2. print(s)
  3. # {'e', 'v', 'n', 'i', 'k'}

关系运算

判断两个群体内的差异

  1. s1 = {'jason', 'kevin', 'tony', 'jerry'}
  2. s2 = {'jason', 'tom', 'jerry', 'jack'}
  3. print(s1 & s2)  # 交集
  4. # {'jason', 'jerry'}
  5. print(s1 - s2)  # 差集
  6. # {'tony', 'kevin'}
  7. print(s1 | s2)  # 并集
  8. # {'tony', 'jason', 'jerry', 'kevin', 'tom', 'jack'}
  9. print(s1 ^ s2)  # 补集
  10. # {'tony', 'kevin', 'tom', 'jack'}

可变类型与不可变类型

可变类型

值发生改变时，内存地址不变，修改的是本身

list（列表）、dict（字典），set（集合），是可变类型

数据类型内置方法 - 图1

不可变类型

值发生改变时，内存地址也发生改变，在改变原值，是产生了新的值

数值型（int、string、bool）、string（字符串）、tuple（元组）都是不可变类型

数据类型内置方法 - 图2

队列与堆栈

队列

先进先出

  1. new_list = []
  2. # 先进
  3. new_list.append(1)
  4. new_list.append(2)
  5. new_list.append(3)
  6. # 先出
  7. print(new_list.pop(0))
  8. # 1
  9. print(new_list.pop(0))
  10. # 2
  11. print(new_list.pop(0))
  12. # 3

堆栈

先进后出

  1. new_list = []
  2. # 先进
  3. new_list.append(1)
  4. new_list.append(2)
  5. new_list.append(3)
  6. # 后出
  7. print(new_list.pop())
  8. # 3
  9. print(new_list.pop())
  10. # 2
  11. print(new_list.pop())
  12. # 1

垃圾回收机制

引用计数

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

  1. name = 'kevin'  # kevin引用计数为1
  2. a = name        # kevin引用计数为2
  3. # 内存中数据身上绑定的变量名的个数
  4. # ps:还可以了解一下循环引用的情况

标记清除

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

分代回收

根据值存在的时间长短 将值划分为三个等级(1,2,3)

等级1 检测机制每隔5s来一次
等级2 检测机制每隔1min来一次
等级3 检测机制每隔5min来一次