python 语法回顾总结

定义变量 + 打印输出

price = 8.5
weight = 1
money = price * weight
print(money)


直接输出
print(520)
print(98.5)
print(3 * 1)

if else 条件

import keyword

print(keyword.kwlist)

if True:
    print("True")
else:
    print("False")

数字类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

count = 100
miles = 100.0
name = "zzz"

print(count)
print(miles) 
print(name)

多变量赋值

a  = b = c = 1

print(a)
print(b)
print(c)

a, b, c = 1,2, 'zz'
print(a)
print(b)
print(c)

标准数据类型

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

三个不可变数据

number 数字

int float bool complex

a, b, c, d = 20,5.5, True, 4 + 3j

print(a)
print(b)
print(c)
print(d)

print(type(a))
print(type(b))
print(type(c))
print(type(d))

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>

a = 20
print(isinstance(a, int)) # True

运算

print(5 + 4) # 9 加法
print(3.3 - 1) # 2.3 # 减法
print(3 * 7) # 21 # 加法
print(2 / 4) # 0.5 # 除法
print(7 // 4) # 1 # 取mod
print(7 % 4) # 3 # 取余
print(2 ** 2) # 4 # 次方

string 字符串

tuple 元组

字符串裁剪

str = "0123456789"


# 0 到 最后倒数第一个
print(str[0:-1]) # 01234567
print(str[0]) # 0
print(str[2:5]) # 234

print(str[2:]) # 2345678

# 字符串间隔
print(str[1:5:1])
print(str[1:5:2]) # 从index2开始 到 index4 每隔1个字符


print(str * 2) # 01234567890123456789

print("——"* 10) # ————————————————————

print('hello\nworld')
'''
hello
world
'''

print('\n') # empnty row 空行
print(r'\n') # 输出 \n




## 字符串 取字符
word = "Python"

print(word[0]) # P
print(word[-1]) # n

print(word[0],word[1],word[2]) # P y t

List

t = ['a','b','c','d','e']
print(t) # 打印列表
print(t[0]) # 输出列表第一个元素
print(t[1:4]) # index1开始 到 index3
print(t * 2) # 列表 两次 扩容 ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']

t2 = [123,'abc']
print(t + t2) # ['a', 'b', 'c', 'd', 'e', 123, 'abc']

#  修改列表中元素
a = [1,2,3,4,5,6]
# print(a[0]) # 1

# a[0] = 2
# print(a[0]) # 2
# print(a) # [2, 2, 3, 4, 5, 6]

a[2:5] = [11,12,13]
print(a) # [1, 2, 11, 12, 13, 6]

a[2: 5] = []
print(a) # [1, 2, 6]

append 和 del

l = ['a','b','c']

l.append('b')

print(l) # ['a', 'b', 'c', 'b']

l2 = ['c', 'e', 'f']
l.append(l2[0])  # ['a', 'b', 'c', 'b', 'c']
print(l)

l.append(l2) # ['a', 'b', 'c', 'b', 'c', ['c', 'e', 'f']]
print(l)

del l[0] # 删除第一个元素 ['b', 'c', 'b', 'c', ['c', 'e', 'f']]
print(l)
# del l[4] # 删除第四个元素
del l[-1] # 删除第四个元素
print(l)

列表直接 +

l1 = [1,2,3,4]
l2 = [3,2,3]
print(l1 + l2) # [1, 2, 3, 4, 3, 2, 3]

list嵌套

a = [1,2,3]
b = ['1','2','3'] 
c = [a, b] # [[1, 2, 3], ['1', '2', '3']]
print(c)

print(c[0][0]) # 1

operator.eq 列表比较

import operator

a = [1,2,3]
b = ['1','2','3']
c = [1,2,3]


print(operator.eq(a,b)) # False
print(operator.eq(a,c)) # True

常用list命令

sum max list len

a = {12, 12321, 31, 12, 213, 212, 23, 3, 2, 1}
n = max(a)
print(n) # a中最大值 12321

a = {12, 12321, 31, 12, 12, 213, 212, 23, 3, 2, 1}
b = list(a)
print(a) # {12321, 2, 3, 1, 12, 212, 213, 23, 31}
print(b) # [12321, 2, 3, 1, 12, 212, 213, 23, 31]

count（）

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
n = a.count(12) 
print(n) # 统计12在 a中出现次数

a = (12, 12321, 31, 12, 213, 212, 23, 3, 2, 1)
n = a.count(12)
print(n) # 统计12在 a中出现次数

extend()

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

区别 append

```python
a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a.append(b)
print(a) # [[12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, [1, 2, 3]]

同[] 可以用+代替

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a = a+b
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

```python
a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = (1,2,3)
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = {1,2,3}
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

sort

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
a.sort() 
print(a) # [1, 2, 3, 12, 12, 23, 31, 212, 213, 12321]

remove

a = [1,2,3,23,212,213,12,31,12321,12]

a.remove(12) # 删除第一个12 [1, 2, 3, 23, 212, 213, 31, 12321]
print(a)

pop

a = [1,2,3,23,212,213,12,31,12321,12]

c = a.pop() # 尾部删除元素
print(a) # [1, 2, 3, 23, 212, 213, 12, 31, 12321]
print(c) # 12

insert

a = [1,2,3,23,212,213,12,31,12321,12]

a.insert(-1,"asd") # 在指定 的index 前面插入
print(a) # [1, 2, 3, 23, 212, 213, 12, 31, 12321, 'asd', 12]

reverse

a = [1,2,3,23,212,213,12,31,12321,12]

a.reverse() # 自身反转， 前面不接参数
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]

copy

a = [1,2,3,23,212,213,12,31,12321,12]

b = a.copy() # 复制a
print(b) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]

clear

a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
a.clear() # 清空
print(a) # []

翻转字符串

# 字符串分割 和 字符串连接
def reverseWord(intput):
    inputWords = input.split(" ")

    # 第一个-1 表示 初始位置 为 最后一个位置
    # 第二个参数 为空 表示 移动到末尾
    # 第三个参数 步长 表示 逆向
    inputWords = inputWords[-1::-1]
    print(inputWords)


if __name__ == "__main__":
    input = 'i love python'
    rw = reverseWord(input)
    print(rw) # ['python', 'love', 'i']

Tuple 元组

元组 和 list一样 不同支出 在于 元组内的元素不可以修改
元组 写在() 里面， 元素之间 用 , 隔开

tuple = ('abc',768,'runoob',70.2)
tinytuple = (123, 'nb')

print(tuple) # ('abc', 768, 'runoob', 70.2)
print(tuple[0]) # abc
print(tuple[1:3]) # (768, 'runoob')
print(tuple[2:]) # ('runoob', 70.2)
print(tuple * 2) # ('abc', 768, 'runoob', 70.2, 'abc', 768, 'runoob', 70.2)
print(tuple  + tinytuple) # ('abc', 768, 'runoob', 70.2, 123, 'nb')

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

tuple = (1,2,3,4,5,6)

print(tuple[0]) # 1
print(tuple[1:5]) # (2, 3, 4, 5)

# 不可以修改tuple元素
# tuple(0) = 1 # error
list = [1,2,3,4,5]
list[0] = 11 # 可以修改
print(list)

t1 = ()  # 空元组
t2 = (1,)  # 一个元素，需要在元素后添加逗号
t3 = (1)
print(type(t2)) # <class 'tuple'>
print(type(t3)) # <class 'int'>

l1 = []
l2 = [1]
l3 = [1,]
print(type(l2))
print(type(l3))

元组常用命令

tuple也可以截取中间元素

tp1 = ('G', 'R', 1997, 2000)
tp2 = (1, 2, 3, 4, 5, 6, 7, 8)
print("tuple1[0]: ", tp1[0]) # tuple1[0]:  G
print("tuple2[1:5]: ", tp2[1:5]) # tuple2[1:5]:  (2, 3, 4, 5)

tuple可以合并两个

tp1 = ('G', 'R', 1997, 2000)
tp3 = ('G', 'R', 1997, 2000)
tp2 = (1, 2, 3, 4, 5, 6, 7, 8)
tp4 = tp1 + tp2 + tp3
print(tp4) # ('G', 'R', 1997, 2000, 1, 2, 3, 4, 5, 6, 7, 8, 'G', 'R', 1997, 2000)

tuple 删除

tup = ('Google', 'Runoob', 1997, 2000)

print(tup) # ('Google', 'Runoob', 1997, 2000)

del tup
print("删除后的元组 tup : ")
print(tup) # error: name 'tup' is not defined

print(len((1, 2, 3))) # 3

print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

print(('Hi',) * 4) # ('Hi', 'Hi', 'Hi', 'Hi')

print(3 in (1 ,2 ,3)) # True


for x in (1, 2, 3):  # 1 2 3
    print(x, end = " ")

字典

d = {key1: value1, key2: value2, key3: value3}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

print(tinydict)


d = dict()
print(d) # {}
print(len(d)) # 0
print(type(d)) # <class 'dict'>

# 通过key获取value
print(tinydict['name']) # runnoob
print(tinydict['likes']) # 123

# 修改字典值
tinydict['name'] = 213
print(tinydict['name']) # 213

删除

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

print(tinydict)
# 删除某个键值对
del tinydict['name']
print(tinydict) # {'likes': 123, 'url': 'www.runoob.com'}

# 清空 tinydict
tinydict.clear()
print(tinydict) # {}

# 删除 字典
del tinydict
# print(tinydict) # NameError: name 'tinydict' is not defined

键必须不可变，所以可以用数字，字符串或元组充当

常用命令

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(len(tinydict)) # 3
print(str(tinydict)) # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(tinydict.keys()) # dict_keys(['Name', 'Age', 'Class'])

for x in tinydict.keys(): # Name Age Class
    print(x, end = " ")

print()

for v in tinydict.values(): #  Runoob 7 First
    print(v, end = " ")

常用命令进阶

def f():
    tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

    if ("Name" in tinydict):
        return True
    else:
        return False

if __name__ == '__main__':
    print(f()) # True

get(key, 默认值)

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(tinydict.get("Name")) # Runoob
print(tinydict.get("name",1)) # 1

获取所有键值对

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(tinydict.items()) # dict_items([('Name', 'Runoob'), ('Age', 7), ('Class', 'First')])

创建 字典对

d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(d)

# 获取name的value，没有的话，就返回test
c = d.get("name", "test")
print(c)
print(d)

# 获取name的value，没有的话，返回123123 同时 捏一个 key-value放入字典
b = d.setdefault("name",123123)
print(d)
print(b)

添加新的键值对到字典

d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(d)

d.update({123 : 123})
print()

删除 并返回 字典键值对

d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
a = d.pop('Name')
print(a) # Runoob
print(d) # {'Age': 7, 'Class': 'First'}

弹出字典的最后一组键值对

d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
a = d.popitem()
print(a) # ('Class', 'First')
print(d) # {'Age': 7, 'Class': 'First'}

Set 集合

通常用 {} 或者 set() 创建
parame = {value01,value02,…}
或者
set(value)

集合创建

b = {'apple','apple','orange','candle'}
print(b) # {'orange', 'apple', 'candle'}

print('apple' in b) # True
print(1 in b) # False

set创建

a = set('asdasdasdasdasd')
print(a) # {'d', 'a', 's'}
b = set('aaaaaaaaccc')
print(b) # {'a', 'c'}

print(a - b) # {'s', 'd'} # 差集 a有 b无
print(a | b) # {'c', 's', 'a', 'd'} # 并集
print(a & b) # {'a'}  公共交集
print(a ^ b) # {'c', 's', 'd'} a 和 b 独有

s = {'123',123}

if '123' in s:
    print(True)

t = {'zz','zzz','zz'}
print(t) # 重复元素 会被自动去掉 {'zzz', 'zz'}

a = set('abbbbbbbbbc') # {'c', 'b', 'a'}
b = set('bc') # {'c', 'b'}

print(a)
print(b)

t = {'zz','zzz','zz'}
print(t) # 重复元素 会被自动去掉 {'zzz', 'zz'}

a = set('abbbbbbbbbc') # {'c', 'b', 'a'}
b = set('bcd') # {'c', 'b'}

print(a - b) # a 和 b 的差集 {'a'}
print(a | b) # a 和 b 的并集 {'c', 'a', 'd', 'b'}
print(a & b) # a 和 b 的 交集 {'c', 'b'}
print(a ^ b) # a 和 b 的不同时 存在的元素 {'d', 'a'}

添加元素 add 和 update方法

t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.add('facebook')
print(t) # {'facebook', 'Taobao', 'Google', 'Runoob'}


t.update('www') # {'Taobao', 'Runoob', 'Google', 'w', 'facebook'}
print(t)

# 添加2个
t.update((1,2))  # {1, 2, 'Taobao', 'facebook', 'Runoob', 'Google', 'w'}
print(t)

t.update([3,4,5]) # {'Taobao', 1, 2, 3, 4, 5, 'Runoob', 'Google', 'w', 'facebook'}
print(t)

# 添加 多个
t.update([88,99,10],[122312,1231231])
print(t) # {1, 'facebook', 2, 3, 4, 5, 99, 122312, 'Taobao', 10, 1231231, 'Google', 88, 'Runoob', 'w'}

d = {}

d['one'] = 1
d[2] = 2

print(d)
print(d['one'])
print(d[2])

tdic = {'name':'run', 'code':1, "asd":"vce"}

print(tdic.keys()) # dict_keys(['name', 'code', 'asd'])
print(tdic.values()) # dict_values(['run', 1, 'vce'])


a = dict([('R',1),('G',2),(1,1)])
print(a) # {'R': 1, 'G': 2, 1: 1}


b = {x: x**2 for x in (2, 4 , 6)} # {2: 4, 4: 16, 6: 36}
print(b)

c = dict(a=1, b=2, c = 3) # {'a': 1, 'b': 2, 'c': 3}
print(c)

set 和 add添加是不一样的

t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.add((1,2))
print(t) # {'Google', (1, 2), 'Taobao', 'Runoob'}

t.update((1,2)) # {1, 2, (1, 2), 'Taobao', 'Google', 'Runoob'}
print(t)

set 删除 discard方法

t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

# 这个删除方法 如果 元素 在set中 不存在会报错
t.remove('Google')
print(t) # {'Taobao', 'Runoob'}

# 这个方法 不会报错
t.discard(123) # {'Runoob', 'Taobao'}
print(t)

随机删除

t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.pop() # 随机删除 因为set中元素无序
print(t)

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

数据类型转换

int()

x = int(1)
x2 = int(2.2)
x3 = int("3")

print(x)
print(x2)
print(x3)

float()

x = float(1) # 1.0
x2 = float(2.8) # 2.8
x3 = float("3") # 3.0
x4 = float("4.2") # 4.2

print(x)
print(x2)
print(x3)
print(x4)

str()

x = str("s1") # s1

x1 = str(2) # 2

x2 = str(3.0) # 3.0

print(x)
print(x1)
print(x2)

推导式

list推导式

[表达式 for 变量 in 列表]

[表达式 for 变量 in 列表 if 条件]

names = ["alex", "stephow", "asd", "qwe","zzzzzz"]

names2 = [name.upper() for name in names ] 

print(names2) #['ALEX', 'STEPHOW', 'ASD', 'QWE', 'ZZZZZZ']

# 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
names = ["alex", "stephow", "asd", "qwe","zzzzzz"]

print(names) # ['alex', 'stephow', 'asd', 'qwe', 'zzzzzz']

names2 = [name.upper() for name in names if len(name) > 3]

print(names2) # ['ALEX', 'STEPHOW', 'ZZZZZZ']

#计算 30及以内可以被 3 整除的整数
num = [i for i in range(31) if i % 3 == 0]
print(num) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

dict推导式

{ key_expr: value_expr for value in collection }

{ key_expr: value_expr for value in collection if condition }

list = ['GAT', 'A', 'TQWEQWE']
dic = {key: len(key) for key in list} # {'GAT': 3, 'A': 1, 'TQWEQWE': 7}
print(dic) 

set 推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

s1 = {i ** 2 for i in range(3)} # {0, 1, 4}
print(s1)

s2 = {i ** 2 for i in {1, 2, 3}} # {1, 4, 9}
print(s2)

#判断不是 d c 的字母并输出
s3 = {x for x in 'asdasdasdaasdas' if x not in 'dc'} # {'s', 'a'}
print(s3)

元组

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

a = (x for x in range(1, 10))
print(a) # <generator object <genexpr> at 0x1084b5740>
print(tuple(a)) # (1, 2, 3, 4, 5, 6, 7, 8, 9)

b = (1,2)
print(b) # (1, 2)

双重判断

结果值1 if 判断条件 else 结果2 for 变量名 in 原列表

w = 'asd'
print(w.title()) # 首字符变大写 Asd
print(w.upper()) # 全部变大写 ASD

list1 = ['asdas', ' test1', 'test']

list2 = [w.title() if w.startswith('t') else w.upper() for w in list1] # ['ASDAS', ' TEST1', 'Test']

print(list2)

输入

input("请输入:")

打印 数

a = input()

print(a)

for 循环

sites = ["baidu", "google", "runoob"]
for s in sites:
    if s == "R":
        print(123213)

    elif s == "baidu":
        print("2")
    else:
        print("ok")
'''
2
ok
ok
'''

for i in range(x) 循环

# 0 - 4
for i in range(5):
    print(i)
# 1 - 4
for i in range(1, 5):
    print(i)

步长

# 0 - 4 只打印 步长为 2的数字
for i in range(0,5,2):
    print(i)
# 0 2 4

# -1 到 -9
for i in range(-1, -10, - 1):
    print(i)

结合len的用法

a = [1, 2, 3, 4, 5]

for i in range(len(a)):
    print(a[i])

range（x） 转化

print(range(5)) # range(0, 5)
print(list(range(5))) # [0, 1, 2, 3, 4]
print(set(range(5))) # {0, 1, 2, 3, 4}
print({range(5)}) # {range(0, 5)}
print(tuple(range(5))) # (0, 1, 2, 3, 4)

Steak 栈

定义

栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。

特点

先进后出
last-in first-out

基本操作

进栈 push
出栈 pop
取栈顶 gettop

图

栈的实现

li  = []
# 进栈 push
li.append(1)
# 出栈 pop
li.pop()
# 取栈顶 li[-1]
li[-1]

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    def get_top(self):

        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print(stack.pop())
print(stack.pop())
print(stack.pop())

例子应用 括号匹配

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    def get_top(self):

        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

    def is_empty(self):
        return len(self.stack) == 0

def brace_match(s):
    stack = Stack();

    math = {'}':'{',']':'[', ')':'('}

    for ch in s:
        if ch in {'(','{','['}:
            stack.push(ch)
        else:
            if stack.is_empty():
                return False
            elif stack.get_top() == math[ch]:
                stack.pop()
            else:
                return False

    return stack.is_empty()

print(brace_match('[][][][]()(){}{}'))

Queue队列 使用总结

定义

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

插入 rear 队尾
删除 front 队首

图

先进先出
First in First out

队列实现底层

当队尾指针front == Maxsize +1时，再前进一个位置就自动到O。

队首指针前进1:front = (front + 1 % MaxSize
队尾指针前进1: rear = (rear + 1 % MaxSize

队空条件:rear == front
队满条件:(rear + 1) % MaxSize 二二 front

自己写一个队列

class Queue:
    def __init__(self, size):
        self.queue = [0 for _ in range(size)]
        self.size = size
        self.rear = 0 #队尾 指针
        self.front = 0 # 队首 指针

    def push(self, element):

        if not self.is_filled():
            self.rear = (self.rear + 1) % self.size
            self.queue[self.rear] = element
        else:
            raise IndexError("Queue is filled!")

    def pop(self):

        if not self.is_empty():
            self.front = (self.front + 1) % self.size
            return self.queue[self.front]
        else:
            raise IndexError("Queue is empty!")

    def is_empty(self):
        return self.rear == self.front


    def is_filled(self):
        return (self.rear + 1) % self.size == self.front


q = Queue(6)
for i in range(5):
    q.push(i)

print(q.is_filled())
print(q.is_empty())
print(q.pop())
q.push(4)

常用方法

创建Queue

from collections import deque
q = deque() # 建空队列


q = deque([1,2,3]) # 建非空队列

q = deque([1,2,3], 5) # 第二参数设置queue的大小， 队伍满了之后，从前面开始出队

队尾添加元素

q.append(1) # rear队尾进队

队首出元素

q.popleft()

双向队列

队尾添加
q.append(1)
队首添加
q.appendleft(1)
队首删除
q.popleft()
队尾删除
q.pop()

队伍满了之后，从前面开始出队

q = deque([1,2,3,4,5,6], 5) # 第二参数设置q的大小， 队伍满了之后，从前面开始出队
print(q.popleft()) # 2

利用这个机制 可以实现 只读取 text文档的后5行

# 双向队列
from collections import deque

def tail(n):
    with open('test.txt', 'r') as f:
        q = deque(f, n)
        return q


## 只读取text文档的5行
for line in tail(5):
    print(line, end = '')