本文目录一览：

1. python中set的用法小结
2. Python中的几种特殊数据类型小结
3. 我执行一段python脚本报错了，怎么解决
4. Python浅薄的基础小结上
5. requests模块错误总结

python中set的用法小结

Python提供了常用的数据结构，其中之一就是set，Python中的set是不支持索引的、值不能重复、无需插入的容器。 简单记录下set常用的操作函数：

1. 新建一个set：
   • set("Hello")：这样会转成单个字符的值进行插入，结果是'H', 'e', 'l', 'o'，'l'因为重复只能插入一次。
2. 增加一个元素：
   • add()：用于增加一个元素值。
   • update([])：用于增加多个元素值，参数为list，注意如果用add增加多个值，会报参数类型错误。
3. 删除一个元素：
   • remove()：用于删除一个set中的元素，这个值在set中必须存在，如果不存在的话，会引发KeyError错误。
   • discard()：用于删除一个set中的元素，这个值不必一定存在，不存在的情况下删除也不会触发错误。
4. 随机删除函数：
   • pop()：这个函数随机返回一个元素值，然后把这个值删除，如果set为空，调用这个函数会返回Key错误。
5. 清空函数：
   • clear()：将set全部清空。
6. 测试单个元素在集合内是否存在：
   • in 或者 not in：如果需要判断一个值在集合内是否存在，in就能满足要求，例如2 in set_num如果存在则返回True，否则返回False。
7. 测试两个集合是否包含，子集操作：
   • issubset 和 issuperset：
     • s1.issubset(s2)：测试是否s1中的每一个元素都在s2中，运算符操作为s1 <= s2。
     • s2.issuperset(s1)：测试是否s1中的每一个元素都在s2中，运算符操作为s1 <= s2（注意是s2调用，参数为s1）。
8. 集合的并集：
   • union：s1.union(s2)返回一个新集合，新集合包含s1和s2的所有元素，等价的运算符为|。
9. 集合的交集：
   • intersection：s1.intersection(s2)返回s1和s2中相同部分。
10. 其他操作：
    • s1.difference(s2)：包含s1中有，但是s2没有的元素的集合。
    • s1.symmetric_difference(s2)：包含s1和s2中不相同的元素的集合。 以上只是一部分操作的描述，如果有错误，敬请指正。

Python中的几种特殊数据类型小结

下面介绍了Python中的6种特殊数据类型：

1. list：列表
   • 是一种有序的数据集合，在列表数据结构中的类型并不唯一。
   • 定义形式：L = ['Micha', 100, True]
   • 输出整个列表的时候显示为['Micha', 100, True]
   • 输出单个的数值则为：Micha
   • a. 访问：直接使用L[0]表示第一个元素或者使用L[-1]表示最后一个数据，以此类推，但是注意访问不能越界（访问的序号不能超过元素的总数）。
   • b. 添加新元素：使用L.append(100)直接将100加入列表末尾，或者使用L.insert(0, 'paul')将paul插入任意位置。
   • c. 删除元素：L.pop()删除最后一个元素，或者L.pop(2)删除第2个位置的元素。
   • d. 替换元素：直接赋值就可以了L[2] = 100
2. tuple：元组
   • 是一种有序的列表，但是其一旦创立完毕就不能够更改，即不能插入，删除里面的元素，访问的方式跟List结构一致。
   • a. t = ()其打印后输出的形式是()。
   • b. 若t中的数据为一个数字则需要在后面加逗号，以区分普通数字，如t = (1,)，打印出(1,)而非1，多元素的话则没有这个要求。
   • c. 可以在不变的tuple中加入可变的List如t = ('a', 'b', ['A', 'B'])
3. dict：字典
   • d = {
     • 'Adam': 95,
     • 'Lisa': 85,
     • 'Bart': 59
     • }
   • len()函数可以计算任意集合的大小。
   • 其中可以简单地使用d[key]的形式来查找对应的value，这和list很像，不同之处是，list必须使用索引返回对应的元素，而dict使用key，当key不存在的时候，使用该key可能出现错误，因此：
     • 一是先判断一下key是否存在，用in操作符：
       • if 'Paul' in d:
         • print d['Paul']
       • 如果'Paul'不存在，if语句判断为False，自然不会执行print d['Paul']，从而避免了错误。
     • 二是使用dict本身提供的一个get方法，在Key不存在的时候，返回None：
       • print d.get('Bart')
       • 59
   • a. dict中的key不能重复，且dict中的存储的对应值没有顺序，打印出的东西可能是无序的。
   • b. dict的更新：使用d['paul'] = 72求解。
   • c. dict遍历：
     • d = {'Adam': 95, 'Lisa': 85, 'Bart': 59}
     • for key in d:
       • ... print key
     • 遍历只能获得key的值，需要通过key值获得对应的value。
4. set：集合
   • 无序但是所有元素唯一，不重复。
   • a. 定义：s = set(['A', 'B', 'C'])，查看set的内容：
     • print s
     • set(['A', 'C', 'B'])
   • 可以用in来判断是否存在于集合中。
   • b. 遍历：
     • s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
     • for x in s:
       • print x[0] + ':', x[1]
   • c. 添加元素到集合中：
     • s.add(4)
   • d. 删除元素：
     • s.remove(4)若该元素不在集合中将会报错。
5. Unicode编码
   • Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：
     • print u'中文'
   • 注意：不加u，中文就不能正常显示中文。
   • a. 转义形式：u'中文\n日文\n韩文'
   • b. 输出多行：
     • u'''第一行
     • 第二行'''`
   • c. raw+多行的形式：
     • ur'''Python的Unicode字符串支持"中文",
     • "日文",
     • "韩文"等多种语言'''
   • 如果中文字符串在Python环境下遇到UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释：
     • # -*- coding: utf-8 -*-
     • 目的是告诉Python解释器，用UTF-8编码读取源代码。然后用Notepad++另存为，并选择UTF-8格式保存。
6. raw的作用
   • 如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个“raw”字符串，里面的字符就不需要转义了。例如：
     • r'\(~_~)//'
   • 但是r'...'表示法不能表示多行字符串，也不能表示包含'和"的字符串，如果要表示多行字符串。

我执行一段python脚本报错了，怎么解决

在程序运行的过程中，如果发生了错误，可以事先约定返回一个错误代码，这样，就可以知道是否有错，以及出错的原因。在操作系统提供的调用中，返回错误码非常常见。比如打开文件的函数open()，成功时返回文件描述符（就是一个整数），出错时返回-1。 用错误码来表示是否出错十分不便，因为函数本身应该返回的正常结果和错误码混在一起，造成调用者必须用大量的代码来判断是否出错：

def foo():
    r = some_function()
    if r == (-1):
        return (-1)
    # do something
    return r
def bar():
    r = foo()
    if r == (-1):
        print 'Error'
    else:
        pass

一旦出错，还要一级一级上报，直到某个函数可以处理该错误（比如，给用户输出一个错误信息）。 所以高级语言通常都内置了一套try...except...finally...的错误处理机制，Python也不例外。

try

让我们用一个例子来看看try的机制：

try:
    print 'try...'
    r = 10 / 0
    print 'result:', r
except ZeroDivisionError, e:
    print 'except:', e
finally:
    print 'finally...'
print 'END'

当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。 上面的代码在计算10 / 0时会产生一个除法运算错误：

try...
except: integer division or modulo by zero
finally...
END

从输出可以看到，当错误发生时，后续语句print 'result:', r不会被执行，except由于捕获到ZeroDivisionError，因此被执行。最后，finally语句被执行。然后，程序继续按照流程往下走。 如果把除数0改成2，则执行结果如下：

try...
result: 5
finally...
END

由于没有错误发生，所以except语句块不会被执行，但是finally如果有，则一定会被执行（可以没有finally语句）。 你还可以猜测，错误应该有很多种类，如果发生了不同类型的错误，应该由不同的except语句块处理。没错，可以有多个except来捕获不同类型的错误：

try:
    print 'try...'
    r = 10 / int('a')
    print 'result:', r
except ValueError, e:
    print 'ValueError:', e
except ZeroDivisionError, e:
    print 'ZeroDivisionError:', e
finally:
    print 'finally...'
print 'END'

int()函数可能会抛出ValueError，所以我们用一个except捕获ValueError，用另一个except捕获ZeroDivisionError。 此外，如果没有错误发生，可以在except语句块后面加一个else，当没有错误发生时，会自动执行else语句：

try:
    print 'try...'
    r = 10 / int('a')
    print 'result:', r
except ValueError, e:
    print 'ValueError:', e
except ZeroDivisionError, e:
    print 'ZeroDivisionError:', e
else:
    print 'no error!'
finally:
    print 'finally...'
print 'END'

Python的错误其实也是class，所有的错误类型都继承自BaseException，所以在使用except时需要注意的是，它不但捕获该类型的错误，还把其子类也“一网打尽”。比如：

try:
    foo()
except StandardError, e:
    print 'StandardError'
except ValueError, e:
    print 'ValueError'

第二个except永远也捕获不到ValueError，因为ValueError是StandardError的子类，如果有，也被第一个except给捕获了。 Python所有的错误都是从BaseException类派生的。 使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用foo()，foo()调用bar()，结果bar()出错了，这时，只要main()捕获到了，就可以处理：

def foo(s):
    return 10 / int(s)
def bar(s):
    return foo(s) * 2
def main():
    try:
        bar('0')
    except StandardError, e:
        print 'Error!'
    finally:
        print 'finally...'

也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。

调用堆栈

如果错误没有被捕获，它就会一直往上抛，最后被Python解释器捕获，打印一个错误信息，然后程序退出。来看看err.py：

# err.py:
def foo(s):
    return 10 / int(s)
def bar(s):
    return foo(s) * 2
def main():
    bar('0')
main()

执行，结果如下：

$ python err.py
Traceback (most recent call last):
  File "err.py", line 11, in module
    main()
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in bar
    return foo(s) * 2
  File "err.py", line 3, in foo
    return 10 / int(s)
ZeroDivisionError: integer division or modulo by zero

出错并不可怕，可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链： 错误信息第1行：

Traceback (most recent call last):

告诉我们这是错误的跟踪信息。 第2行：

File "err.py", line 11, in module
main()

调用main()出错了，在代码文件err.py的第11行代码，但原因是第9行：

File "err.py", line 9, in main
bar('0')

调用bar('0')出错了，在代码文件err.py的第9行代码，但原因是第6行：

File "err.py", line 6, in bar
return foo(s) * 2

原因是return foo(s) * 2这个语句出错了，但这还不是最终原因，继续往下看：

File "err.py", line 3, in foo
return 10 / int(s)

原因是return 10 / int(s)这个语句出错了，这是错误产生的源头，因为下面打印了：

ZeroDivisionError: integer division or modulo by zero

根据错误类型ZeroDivisionError，我们判断，int(s)本身并没有出错，但是int(s)返回0，在计算10 / 0时出错，至此，找到错误源头。

记录错误

如果不捕获错误，自然可以让Python解释器来打印出错误堆栈，但程序也被结束了。既然我们能捕获错误，就可以把错误堆栈打印出来，然后分析错误原因，同时，让程序继续执行下去。 Python内置的logging模块可以非常容易地记录错误信息：

# err.py
import logging
def foo(s):
    return 10 / int(s)
def bar(s):
    return foo(s) * 2
def main():
    try:
        bar('0')
    except StandardError, e:
        logging.exception(e)
main()
print 'END'

同样是出错，但程序打印完错误信息后会继续执行，并正常退出：

$ python err.py
ERROR:root:integer division or modulo by zero
Traceback (most recent call last):
  File "err.py", line 12, in main
    bar('0')
  File "err.py", line 8, in bar
    return foo(s) * 2
  File "err.py", line 5, in foo
    return 10 / int(s)
ZeroDivisionError: integer division or modulo by zero
END

通过配置，logging还可以把错误记录到日志文件里，方便事后排查。

抛出错误

因为错误是class，捕获一个错误就是捕获到该class的一个实例。因此，错误并不是凭空产生的，而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误，我们自己编写的函数也可以抛出错误。 如果要抛出错误，首先根据需要，可以定义一个错误的class，选择好继承关系，然后，用raise语句抛出一个错误的实例：

# err.py
class FooError(StandardError):
    pass
def foo(s):
    n = int(s)
    if n == 0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

执行，可以最后跟踪到我们自己定义的错误：

$ python err.py
Traceback (most recent call last):
  ...
__main__.FooError: invalid value: 0

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型（比如ValueError，TypeError），尽量使用Python内置的错误类型。 最后，我们来看另一种错误处理的方式：

# err.py
def foo(s):
    n = int(s)
    return 10 / n
def bar(s):
    try:
        return foo(s) * 2
    except StandardError, e:
        print 'Error!'
        raise
def main():
    bar('0')
main()

在bar()函数中，我们明明已经捕获了错误，但是，打印一个Error!后，又把错误通过raise语句抛出去了，这不有病么？ 其实这种错误处理方式不但没病，而且相当常见。捕获错误目的只是记录一下，便于后续追踪。但是，由于当前函数不知道应该怎么处理该错误，所以，最恰当的方式是继续往上抛，让顶层调用者去处理。 raise语句如果不带参数，就会把当前错误原样抛出。此外，在except中raise一个Error，还可以把一种类型的错误转化成另一种类型：

try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')

只要是合理的转换逻辑就可以，但是，决不应该把一个IOError转换成毫不相干的ValueError。

小结

Python内置的try...except...finally用来处理错误十分方便。出错时，会分析错误信息并定位错误发生的代码位置才是最关键的。 程序也可以主动抛出错误，让调用者来处理相应的错误。但是，应该在文档中写清楚可能会抛出哪些错误，以及错误产生的原因。

Python浅薄的基础小结上

Python 支持四种不同的数值类型：

• 整型（Int）：通常被称为是整型或整数，是正或负整数，不带小数点。
• 长整型（long integers）：无限大小的整数，整数最后是一个大写或小写的L。
• 浮点型（floating point real values）：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）。
• 复数（complex numbers）：复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a, b)表示，复数的实部a和虚部b都是浮点型。 在Python中常见的运算加、减、乘、除、求余、幂指数等，同现实生活中的遵循一样的优先级。即，乘除运算高于加减运算。例如： Python内置复数的计算支持所有常见复数的计算，对复数处理的数学函数在模块cmath中： 字符串或串（String）是由数字、字母、下划线组成的一串字符。Python字符串最大的特点是不可修改，只能生成新的字符串，用双引号或单引号都可以表示字符串，多行字符串用三个连续单引号表示，特殊字符用转义符“\”表示如：制表符“\t”，换行符“\n”。

str = 'Hello World!'
print str * 2  # 输出字符串两次
# Hello World!Hello World!
print str + "TEST"  # 输出连接的字符串
# Hello World!TEST
len('str')  # 输出字符串的长度
# 12

Python的字串列表有两种取值顺序：

• 从左到右索引默认0开始的，最大范围是字符串长度少1。
• 从右到左索引默认-1开始的，最大范围是字符串开头。 如果你要实现从字符串中获取一段子字符串的话，可以使用变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。比如：

s = 'ilovepython'
s[1:5] 的结果是 love。

当使用以冒号分隔的字符串，Python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。 上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。

'abcd'[3:1:-1]  # 从右到左
# 'dc'

一些高级操作：

s = 'You are my sunshine'
s.split(' ')
# ['You', 'are', 'my', 'sunshine']
t = ['one', 'for', 'two']
' '.join(t)
# 'one for two'
t = 'Mike and Tom'
t.replace('Tom', 'jane')
# 'Mike and jane'

Python变量的概念和初中代数的方程变量一致，变量就像贴在东西上的标签，命名规则：大小写英文、数字和下划线，且不能用数字开头，变量可以反复赋值，而且可以是不同类型的变量。 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。 Python有6个序列的内置类型，但最常见的是列表和元组。 序列都可以进行的操作包括索引，切片，加，乘，检查成员。 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。 列表的数据项不需要具有相同的类型。 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

[]  # 创建空的列表
# []
list()  # 创建空的列表
# []
alist = ['physics', 'chemistry', 1997, 2000]
# ['physics', 'chemistry', 1997, 2000]

列表是Python中使用最频繁的数据类型。 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。 列表用[]标识，是Python最通用的复合数据类型。 列表中值的切割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

list = ['runoob', 786, 2.23, 'john', 70.2]
tinylist = [123, 'john']
print list  # 输出完整列表
# ['runoob', 786, 2.23, 'john', 70.2]
'runoob' in alist  # 某个元素是否存在
# True
print list[0]  # 输出列表的第一个元素
# runoob
print list[1:3]  # 输出第二个至第三个元素
# [786, 2.23]
print list[2:]  # 输出从第三个开始至列表末尾的所有元素
# [2.23, 'john', 70.2]
print tinylist * 2  # 输出列表两次
# [123, 'john', 123, 'john']
print list + tinylist  # 打印组合的列表
# ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python的元组与列表类似，不同之处在于元组的元素不能修改。 元组使用小括号，列表使用方括号。 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

()  # 创建空的元组
# ()
tuple()  # 创建空的元组
# ()

元组中只包含一个元素时，需要在元素后面添加逗号如：tup1 = (50,)。

tup = (1, True, 0.234, "holle")

同列表相似，元组适用：

• +：链接两个元组。
• *：复制n次，生成新的元组。
• in：某个元素是否存在。
• [start:end:step]：切片。 值得注意的是元组是不可以更新的（不可变）序列，但我们可以对元组进行连接组合生成新的元组如：

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print tup3
# (12, 34.56, 'abc', 'xyz')

任意无符号的对象，以逗号隔开，默认为元组。 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值（key=value）对用冒号（:）分割，每个对之间用逗号（,）分割，整个字典包括在花括号（{}）中，格式如下所示：

d = {key1: value1, key2: value2}

键必须是唯一的，但值则不必。 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 字典是可变类型，可以添加，删除，替换。

requests模块错误总结

1. url中有端口号导致了以下的错误

C:\Users\lenovo\AppData\Local\Programs\Python\Python37\python.exe D:/Pycharm/lemon/task_0525.py
Traceback (most recent call last):
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 603, in urlopen
    chunked=chunked)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 387, in _make_request
    six.raise_from(e, None)
  File "string", line 2, in raise_from
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 383, in _make_request
    httplib_response = conn.getresponse()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 1321, in getresponse
    response.begin()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 296, in begin
    version, status, reason = self._read_status()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 278, in _read_status
    raise BadStatusLine(line)
http.client.BadStatusLine: 4
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\adapters.py", line 449, in send
    timeout=timeout
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 641, in urlopen
    _stacktrace=sys.exc_info()[2])
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\util\retry.py", line 368, in increment
    raise six.reraise(type(error), error, _stacktrace)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\packages\six.py", line 685, in reraise
    raise value.with_traceback(tb)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 603, in urlopen
    chunked=chunked)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 387, in _make_request
    six.raise_from(e, None)
  File "string", line 2, in raise_from
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\urllib3\connectionpool.py", line 383, in _make_request
    httplib_response = conn.getresponse()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 1321, in getresponse
    response.begin()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 296, in begin
    version, status, reason = self._read_status()
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\http\client.py", line 278, in _read_status
    raise BadStatusLine(line)
urllib3.exceptions.ProtocolError: ('Connection aborted.', BadStatusLine('4\x00\x00\x00\n'))
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
  File "D:/Pycharm/lemon/task_0525.py", line 10, in module
    resp1 = requests.get(url, params=data)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\api.py", line 75, in get
    return request('get', url, params=params, **kwargs)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\api.py", line 60, in request
    return session.request(method=method, url=url, **kwargs)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\sessions.py", line 533, in request
    resp = self.send(prep, **send_kwargs)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\sessions.py", line 646, in send
    r = adapter.send(request, **kwargs)
  File "C:\Users\lenovo\AppData\Local\Programs\Python\Python37\lib\site-packages\requests\adapters.py", line 498, in send
    raise ConnectionError(err, request=request)
requests.exceptions.ConnectionError: ('Connection aborted.', BadStatusLine('4\x00\x00\x00\n'))
Process finished with exit code 1