Python 学习

基础知识

语法特性

• ** => 取幂

• // => 整除（舍余）

• 赋值 => x=y=z=1 a,b=1,2

• 没有自增、自减的写法（如：i++）

• 数据结构 => list、tuple、set、dict

  • 不可变数据类型（值变地址变）：整数（-5到256之间不改变地址）、字符串、元组

  • 可变数据类型（值变地址不变）：列表、字典

• 忽略转义符 => <str> = r'xxx\nxxx'

• 作用域：函数内部使用 global 声明全局变量，使用 nonlocal 声明闭包上一层的函数变量

• 匿名函数：add = lambda x,y:x+y add(1,2)

• 异常处理：

  • try => 可能出现异常的代码

  • except => 发生异常时执行的代码

  • else => 没有异常时执行的代码

  • finally => 不管有无异常都会执行的代码

  • assert => 断言

  • raise => 手动抛异常

常用函数

# list
<list>.append(n)
<list>.extend(<list2>)
<list>.insert(index,n)
<list>.sort([reverse=True])
<list>.reverse()
zip(<list>,<list2>)		# 返回 [(x1,y1),(x2,y2),(x3,y3)...]
enumerate(<list>)		# for 循环遍历可接收 index 和 值

# dict
<dict>.get(key,value)		# 若 dict 无 key，则返回 value
pop()
clear()
<dict>.keys()
<dict>.values()
<dict>.items()			# 返回 [(key,vaule),(key,vaule),(key,vaule)...]

# set
<set>.add(n)
<set>.remove(n)
<set>.clear()
<set>.difference(<set2>)
<set>.intersection(<set2>)	# 交集
<set>.union(<set2>)		# 并集

# str
<str>.find(<str2>, beg=0, end=len(<str>))	# 返回 index 或 -1
<str>.count(<str2>, start=0, end=len(<str>))
<str>.replace(<old_str>, <new_str>, <time>)
<str>.split(str="<分隔符>", num=<time>)
<str>.strip(<str>)				# 去除首尾指定 <str>

# obj
repr(<obj>)					# 对象转字符串

# file
f = open('<文件名>','<访问模式>')
f.write('<内容>')
content = f.read([字节数]) # 默认读取所有字节
content = f.readline() # 读取一行
content = f.readlines() # 读取每一行
f.close()
with open('<文件名>','<访问模式>') as f # 结束后自动关闭文件

文件访问模式

模式	描述
t	文本模式 (默认)
x	写模式，新建一个文件，如果该文件已存在则会报错
b	二进制模式
+	更新(读写)
U	通用换行模式（不推荐）
r	只读（默认模式），指针在开头
rb	二进制只读（默认模式），指针在开头（一般用于非文本文件如图片等）
r+	读写，指针在开头
rb+	二进制读写，指针在开头（一般用于非文本文件如图片等）
w	只写，覆盖，新建
wb	二进制只写，覆盖，新建（一般用于非文本文件如图片等）
w+	读写，覆盖，新建
wb+	二进制读写，覆盖，新建（一般用于非文本文件如图片等）
a	追加，指针在结尾，新建
ab	二进制追加，指针在结尾，新建（一般用于非文本文件如图片等）
a+	读写，指针在结尾，追加，新建
ab+	二进制读写，指针在结尾，追加，新建（一般用于非文本文件如图片等）

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

不定参数

arg、*args、**kwargs

def function(*args):
    print(args, type(args))
function(1) 				# 输出：(1,) <class 'tuple'>

def function(x, y, *args):
    print(x, y, args)
function(1, 2, 3, 4, 5) 		# 输出：1 2 (3, 4, 5)

def function(**kwargs):
    print( kwargs, type(kwargs))
function(a=2) 				# 输出：{'a': 2} <class 'dict'>

def function(**kwargs):
    print(kwargs)
function(a=1, b=2, c=3) 		# 输出：{'a': 1, 'b': 2, 'c:' 3}

def function(arg,*args,**kwargs):
    print(arg,args,kwargs)
function(6,7,8,9,a=1, b=2, c=3) 	# 输出：6 (7, 8, 9) {'c':3, 'a':1, 'b':2}

hasattr、getattr、setattr

• hasattr() 判断对象是否包含对应的属性

• getattr() 返回一个对象属性值

• setattr() 设置对象的属性

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))	# True
print(hasattr(point1, 'y'))	# True
print(hasattr(point1, 'z'))	# True
print(hasattr(point1, 'no')) 	# False

class A(object):
     bar = 1
a = A()

# 获取属性 bar 值
print(getattr(a, 'bar')) # 1

# 属性 bar2 不存在，触发 AttributeError 异常
print(getattr(a, 'bar2'))

# 属性 bar2 不存在，但设置了默认值
print(getattr(a, 'bar2', 3)) # 3

class A:
    def __init__(self, val):
        self.val = val

    def __get__(self, instance, owner):
        pass

print(hasattr(A, 'val')) # False
print(hasattr(A(999), 'val')) # True
setattr(A, 'val', 666)
print(getattr(A, 'val')) # 666
print(hasattr(A, '__get__')) # True

闭包

def foo():
    outer = 1
    
    def inner():
        nonlocal outer
        outer = 2
        print('inner:', outer)
        return
    return inner
    
res = foo()
res()

迭代器

class MyIter:
    def __init__(self, num):
    self.num = num
    
    def __next__(self):
        if self.num <= 0:
            raise StopIteration
        self.num -= 1
        return self.num
    
    def __iter__(self):
        return self
        
for i in MyIter(10):
    print(i)

生成器(yield)

yield 返回对象，形成一个 generator 生成器，而不会结束程序

def intNum():
    print("开始执行")
    for i in range(5):
        yield i
        # print("继续执行")

num = intNum()
print(num) # <generator object intNum at 0x000001741422AC48>
print(next(num)) # 开始执行 0
print(num.__next__()) # 1
# print(list(num)) # [2, 3, 4]
# print(tuple(num)) # (2, 3, 4)

# 通过for循环遍历生成器
for i in num:
    print(i, end='') # 234

装饰器

import time

def Timer(func):
    start = time.time()

    def warp(*args, **kwargs):
        func(*args, **kwargs)
        end = time.time()
        print('消耗的时间：', end - start)
        return

    return warp

@Timer
def foo():
    for i in range(10000000):
        pass

foo() # 消耗的时间： 0.2752995491027832

@property

1. 方法可以像属性一样访问

2. 隐藏属性名，防止属性被修改

class A:
    def __init__(self, w, h):
        self.w = w
        self.h = h

    @property
    def foo(self):
        area = self.w * self.h
        return area

a = A(10, 9)
res = a.foo 	# 加了@property后，可以用调用属性的形式来调用方法,后面不需要加()
print(res) 	# 90

super

class A:
    def say(self):
        print('我是A类的say')

class B(A):
    def say(self):
        print('我是B类的say')

class C(B):
    def say(self):
        print('我是C类的say')

        super(C, self).say()
        super().say()

c = C()
c.say()

# 我是C类的say
# 我是B类的say
# 我是B类的say

new

• new 用于操作不可变对象

• 不可变对象在 init 中很难操作，new 方法可以在 init 之前，cls 未形成 self 实例化的时候操作

class A(int):
    def __init__(self, val, name):
        self.val = val
        self.name = name
        super(A, self).__init__(val)

a = A(999, 'test')
print(a) 	# TypeError: 'str' object cannot be interpreted as an integer

class A(int):
    def __new__(cls, val, name):
        instance = super().__new__(cls, val)
        instance.val = val
        instance.name = name

        return instance

a = A(999, 'test')
print(a) 		# 999
print(a.name) 		# test

setitem

# 字典不允许重复的值存入
class DistinctError(BaseException):
    def __str__(self):
        return '当传入重复值的时候引发这个错误'


class MyDict(dict):
    def __setitem__(self, key, value):
        if value in self.values():
            if key not in self:
                raise DistinctError

        super(MyDict, self).__setitem__(key, value)

d = MyDict()
d['one'] = 'python'
d['two'] = 'python'
print(d)	# __main__.DistinctError: 当传入重复值的时候引发这个错误

getitem

class MyDict(dict):
    def __init__(self, default):
        self.default = default
        super(MyDict, self).__init__()

    def __getitem__(self, item):
        if item not in self.keys():
            return self.default
        
        return super(MyDict, self).__getitem__(item)

d = MyDict('no')
d['one'] = 'python'
d['two'] = 'go'
print(d) 	# {'one': 'python', 'two': 'go'}

回调函数

简单来说就是定义一个函数，然后将这个函数的函数名传递给另一个函数做参数，以这个参数命名的函数就是回调函数

def my_callbcak(args):
    print(*args)

def caller(args, func):
    func(args)

caller((1,2), my_callbcak) # 1 2

def apply_ascyn(func, args, callback):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

def print_result(result):
    print(result)

apply_ascyn(add, (2, 3), callback=print_result) # 5

# 为了让回调函数访问外部信息，使用一个绑定方法来代替这个简单函数
def appy_async(func, args, *, callback):
    result = func(*args)
    callback(result)

def add(x ,y):
    return x + y

class ResultHandler(object):
    def __init__(self):
        self.sequence = 0

    def handle(self, result):
        self.sequence += 1
        print("[{}] Got: {}".format(self.sequence, result))

r = ResultHandler()
appy_async(add, (2,3), callback=r.handle) # [1] Got: 5

# 使用闭包代替上面的类来实现
def apply_async(func, args, *, callback):
    result = func(*args)
    callback(result)

def add(x ,y):
    return x + y

def make_handler():
    sequence = 0
    def handler(result):
        nonlocal sequence
        sequence += 1
        print("[{}] Got:{}".format(sequence, result))
    return handler

handler = make_handler()
apply_async(add, (2,3), callback=handler) # [1] Got:5

# 使用协程
def apply_async(func, args, *, callback):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

def make_handler():
    sequence = 0
    while True:
        result = yield
        sequence += 1
        print("[{}] Got:{}".format(sequence, result))

handle = make_handler()
next(handle)
apply_async(add, (2,3), callback=handle.send) # [1] Got:5

类的特殊成员（特殊属性和特殊方法）

__repr__、__str__、__base__

class A:
    # 默认情况下，__repr__() 会返回和调用者有关的 “类名+object at+内存地址” 信息
    def __repr__(self):
        return '这是一个A类，用于测试'

    # 优先级高于 __repr__ 同时使用时只返回 __str__ 的结果
    def __str__(self):
        return '这是实现了str的类' + str(A.__base__)

a = A()
print(a) 	# 这是实现了str的类<class 'object'>

__set__、__get__、__del__

class A:
    def __init__(self, val):
        self.val = val

    def __get__(self, instance, owner):
        print('调用了get', instance)
        return self.val

    def __set__(self, instance, value):
        print('调用了set', instance)
        self.val = value

    def __del__(self):
        print('调用了del')
        del self.val


class B:
    x = A(999)


b = B() 	# 结束时自动调用 __del__ 进行垃圾回收
b.x 		# 调用了get <__main__.B object at 0x000001232DCBFC88>
b.x = 888 	# 调用了set <__main__.B object at 0x000002085000FCC8>
del b 		# 调用了del
b.x 		# NameError: name 'b' is not defined

继承、自定义异常

class MyException(BaseException):
    def __init__(self):
        print('实例化时自动运行')

    def __str__(self):
        return "方法重写"

# 主动发起错误
raise MyException     # __main__.MyException: 方法重写  实例化时自动运行

import traceback

try:
    print(x)
except Exception as e:
    print(e)
    # 将异常信息写入文件
    traceback.print_exc(file=open('error.txt', 'a+', encoding='utf-8'))

连MySQL

import pymysql

# 连接失败抛出 pymysql.err.OperationalError
conn = pymysql.connect(host='localhost', user='root', password='123456')
cursor = conn.cursor()

sql = 'show databases'

cursor.execute(sql)
results = cursor.fetchall()

with open('sql_result.txt', 'w') as f:
    for index,result in enumerate(results):
        f.write('{}> {}\n'.format(index+1, result[0]))
    print('OK')

cursor.close()
conn.close()

并发编程

进程与线程

进程是具有一定独立功能的程序在某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。

进程就是线程的集合，进程是由一个或多个线程构成的，线程是操作系统进行运算调度的最小单位，是进程中的最小运行单位。

并发与并行

并发是指多个线程对应的多条指令被快速轮换执行，处理器不断地在多个线程之间切换和执行，每个线程的执行都一定会占用这个处理器的一个时间片段，因此同一时刻其实只有一个线程被执行。

并行指同一时刻有多条指令在多个处理器上同时执行，这意味着并行必须依赖多个处理器，多个线程都是在统一时刻一起执行的。

并行只能存在于多处理器系统中，因此如果计算机处理器只有一个核，就不可能实现并行。而并发在单处理器和多处理器系统中都可以存在，因为仅靠一个核，就可以实现并发。

适用场景

• IO密集型：线程被执行后就进入了等待状态，处理器就可以在某个线程处于等待状态的时候，去执行其他线程，从而提高整体的执行效率。

• 计算密(CPU)集型：任务的运行一直需要处理器的参与，如果我们开启了多线程，并不会节省整体的时间，因为需要处理的任务的计算总量是不变的。此时要是线程数目过多，反而还会在线程切换的过程中耗费更多的时间，使得整体效率变低。

多线程与多进程

• 多进程就是利用 CPU 的多核优势，在同一时间并行执行多个任务，可以大大提高执行效率。

• Python 出于对数据安全的考虑设计了 GIL 全局解释锁，而由于 GIL锁 的限制导致不论是在单核还是多核条件下，同一时刻都只能运行一个线程，这使得 Python 多线程无法发挥多核并行的优势。

• 在 Python 多线程下，每个线程的执行方式分如下三步：1、获取 GIL 2、执行对应线程的代码 3、释放 GIL。某个线程要想执行，必须先拿到 GIL，并且在一个 Python 进程中，GIL 只有一个，线程要是拿不到 GIL，就不允许执行。这样会导致即使在多核条件下，一个 Python 进程中的多个线程在同一时刻也只能执行一个。

• 而对于多进程来说，每个进程都有属于自己的 GIL，所以在多核处理器下，多进程的运行是不会受 GIL 影响的。也就是说，多进程能够更好地发挥多核优势。

• 对于 IO 密集型任务来说，多线程和多进程产生的影响差别并不大，但对于计算密集型任务来说，由于 GIL 的存在，Python 多进程的整体运行效率在多核情况下可能反而比单核更低。而 Python 的多进程相比多线程，运行效率在多核情况下比单核会有成倍提升。

• 从整体来看，Python 的多进程比多线程更有优势。所以，如果条件允许的话，尽量用多进程。

阻塞与非阻塞

• 阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成时间，自身无法继续干别的事情，则称该程序在操作上是阻塞的。

• 非阻塞指程序在等待某操作的过程中，自身不被阻塞，可以继续干别的事情，则称该程序在操作上是非阻塞的。

同步与异步

• 同步指不同程序单元为了共同完成某个任务，在执行过程中需要靠某种通信方式保持协调一致，此时这些程序单元是同步执行的。

• 异步指为了完成某个任务，有时不同程序单元之间无需通信协调也能完成任务，此时不相关的程序单元之间可以是异步的。

协程

• 协程又称微线程、纤程，是一种运行在用户态的轻量级线程。

• 协程拥有自己的寄存器上下文和栈。协程在调度切换时，将寄存器上下文和栈保存到其他地方，等切换回来的时候，再恢复先前保存的寄存器上下文和栈。因此，协程能保留上一次调用时的状态，即所有局部状态的一个特定组合，每次过程重入，就相当于进入上一次调用的状态。

• 协程本质上是单个进程，相对于多进程来说，它没有线程上下文切换的开销，没有原子操作锁定及同步的开销，编程模型也非常简单。

• 协程的用法：

  • async - 使用 async 关键字可以定义一个协程方法，这个方法在调用时不会立即被执行，而是会返回一个协程对象。

  • await - 如果协程在执行的时候遇到 await，事件循环就会将本协程挂起，转而执行别的协程，直到其他协程挂起或执行完毕。await 后面的对象必须是如下格式之一：

    • 一个原生协程对象

    • 一个由 types.coroutine 修饰的生成器，这个生成器可以返回协程对象

    • 由一个包含 __await__ 方法的对象返回的一个迭代器

  • event_loop - 事件循环，相当于一个无限循环，我们可以把一些函数注册到这个事件循环上，当满足发生条件的时候，就调用对应的处理方法。

  • coroutine - 中文翻译叫协程，在 Python 中常指代协程对象类型，我们可以将协程对象注册到时间循环中，它会被事件循环调用。

  • task - 任务，这是对协程对象的进一步封装，包含协程对象的各个状态。

  • future - 代表将来执行或者没有执行的任务的结果，实际上和 task 没有本质区别。

  import asyncio
  
  async def execute(x):
      print('Number:', x)
  
  # coroutine 是一个协程对象
  coroutine = execute(1)
  # 创建一个事件循环 loop
  loop = asyncio.get_event_loop()
  # 将协程对象注册到事件循环中并运行，此方法在内部将协程对象封装成了 task 对象
  loop.run_until_complete(coroutine)

  import asyncio
  
  async def execute(x):
      print('Number:', x)
      return x
  
  coroutine = execute(1)
  loop = asyncio.get_event_loop()
  # 将协程对象转化为 task 对象，task 对象比协程对象多了运行状态，例如 running、finished 等
  task = loop.create_task(coroutine)
  loop.run_until_complete(task)

  import asyncio
  
  async def execute(x):
      print('Number:', x)
      return x
  
  coroutine = execute(1)
  # ensure_future 方法也会返回 task 对象，这种方法即使还没有声明 loop 对象，也可以提前定义好 task 对象
  task = asyncio.ensure_future(coroutine)
  loop = asyncio.get_event_loop()
  loop.run_until_complete(task)

  import asyncio
  import requests
  
  async def request():
      url = 'https://www.baidu.com'
      status = requests.get(url)
      return status
  
  def callback(task):
      print('Status:', task.result())
  
  coroutine = request()
  task = asyncio.ensure_future(coroutine)
  # 当协程对象执行完毕之后，就会执行声明的 callback 方法，同时 task 对象会作为参数传递给 callback 方法
  task.add_done_callback(callback)
  loop = asyncio.get_event_loop()
  loop.run_until_complete(task)

  import asyncio
  import requests
  
  async def request():
      url = 'https://www.baidu.com'
      status = requests.get(url)
      return status
  
  coroutine = request()
  task = asyncio.ensure_future(coroutine)
  loop = asyncio.get_event_loop()
  loop.run_until_complete(task)
  # 实际上，即使不使用回调方法，在 task 运行完毕之后，也可以直接调用 result 方法获取结果
  print('Task Result:', task.result())

  import asyncio
  import requests
  
  async def request():
      url = 'https://www.baidu.com'
      status = requests.get(url)
      return status
  
  tasks = [asyncio.ensure_future(request()) for _ in range(5)]
  loop = asyncio.get_event_loop()
  # 把列表先传递给 asyncio 包的 wait 方法，再将其注册到事件循环中
  loop.run_until_complete(asyncio.wait(tasks))
  for task in tasks:
      print('Task Result:', task.result())

  import asyncio
  import aiohttp
  
  async def get(url):
      session = aiohttp.ClientSession()
      # 接着遇到第二个 await，调用 session.get 请求方法，然后就被挂起了。此时事件循环会寻找当前未被挂起的协程继续执行，于是转而去执行第二个 task。
      response = await session.get(url)
      await response.text()
      await session.close()
      return response
  
  async def request():
      # 延迟 5 秒才会返回响应的 URL
      url = 'https://httpbin.org/delay/5'
      print('Waiting for', url)
      # 开始运行时，事件循环会运行第一个 task，当执行到第一个 await 跟着的 get 方法时，它会被挂起，但这个 get 方法第一步的执行是非阻塞的，挂起之后会立马被唤醒，立即又进入执行。
      response = await get(url)
      print('Get response from', url, 'response')
  
  tasks = [asyncio.ensure_future(request()) for _ in range(100)]
  loop = asyncio.get_event_loop()
  loop.run_until_complete(asyncio.wait(tasks))

  import asyncio
  import aiohttp
  import time
  
  def test(number):
      start = time.time()
  
      async def get(url):
          session = aiohttp.ClientSession()
          response = await session.get(url)
          await response.text()
          await session.close()
          return response
  
      async def request():
          url = 'https://www.baidu.com/'
          await get(url)
  
      tasks = [asyncio.ensure_future(request()) for _ in range(number)]
      loop = asyncio.get_event_loop()
      loop.run_until_complete(asyncio.wait(tasks))
  
      end = time.time()
      print('Number:', number, 'Cost time:', end - start)
  
  for number in [1, 3, 5, 10, 15, 30, 50, 75, 100, 200, 500]:
      test(number)

• asyncio 实现了对 TCP、UDP、SSL 协议的异步操作，而 aiohttp 实现了对 HTTP 协议的异步操作。类似于使用 requests 发起一个 HTTP 请求然后获得响应，但 requests 发起的是同步的网络请求，aiohttp 则是异步的。

  import aiohttp
  import asyncio
  
  async def fetch(session, url):
      async with session.get(url) as response:
          # 对于一些返回协程对象的操作，前面需要加 await 来修饰
          # response.text() 返回的是协程对象，那么前面就要加 await，而 response.status 返回值是一个数值，因此前面不用加 await
          return await response.text(), response.status
  
  # 每个异步方法的前面都要统一加 async 来修饰
  async def main():
      # with as 语句用于声明一个上下文管理器，能够自动分配和释放资源
      # 在异步方法中，with as 前面加上 async 代表声明一个支持异步的上下文管理器
      async with aiohttp.ClientSession() as session:
          html, status = await fetch(session, 'https://www.baidu.com')
          print(f'html: {html[:100]}...')
          print(f'status: {status}')
  
  if __name__ == '__main__':
      # Python3.7 以后的版本中，可以使用 asyncio.run(main()) 代替最后的启动操作，不需要显式声明事件循环，run 方法内部会自动启动一个事件循环
      # asyncio.run(main())
      loop = asyncio.get_event_loop()
  	loop.run_until_complete(main())

  import aiohttp
  import asyncio
  
  async def main():
      params = {'name': 'Toki', 'age': 18}
      async with aiohttp.ClientSession() as session:
          async with session.get('https://httpbin.org/get', params=params) as response:
              print(await response.text())
  
  if __name__ == '__main__':
      asyncio.get_event_loop().run_until_complete(main())

  import aiohttp
  import asyncio
  
  async def main():
      data = {'name': 'Toki', 'age': 18}
      async with aiohttp.ClientSession() as session:
          async with session.post('https://httpbin.org/post', json=data) as response:
              print(await response.text())
  
  if __name__ == '__main__':
      asyncio.get_event_loop().run_until_complete(main())

  import aiohttp
  import asyncio
  
  async def main():
      data = {'name': 'Toki', 'age': 18}
      async with aiohttp.ClientSession() as session:
          async with session.post('https://httpbin.org/post', data=data) as response:
              print('status:', response.status)
              print('headers:', response.headers)
              print('body:', await response.text())
              print('bytes:', await response.read())
              print('json:', await response.json())
  
  if __name__ == '__main__':
      asyncio.get_event_loop().run_until_complete(main())

  import aiohttp
  import asyncio
  
  async def main():
      # 如果指定时间内及时响应，则正常返回响应内容，如果时间过短则抛出 asyncio.TimeoutError
      timeout = aiohttp.ClientTimeout(total=0.1)
      async with aiohttp.ClientSession(timeout=timeout) as session:
          async with session.get('https://httpbin.org/get') as response:
              print('status:', response.status)
  
  if __name__ == '__main__':
      asyncio.get_event_loop().run_until_complete(main())

  import asyncio
  import aiohttp
  
  # 设置请求的最大并发量
  CONCURRNCY = 5
  URL = 'https://www.baidu.com'
  
  # 创建一个信号量对象，可以用它来控制最大并发量
  semaphore = asyncio.Semaphore(CONCURRNCY)
  session = None
  
  async def scrape_api():
      # 这里把 semaphore 直接放置在了对应的爬取方法里，使用 async with 语句将 semaphore 作为上下文对象
      # 这样一来，信号量便可以控制进入爬取的最大协程数量 CONCURRNCY
      async with semaphore:
          print('scraping', URL)
          async with session.get(URL) as response:
              await asyncio.sleep(1)
              return await response.text()
  
  async def main():
      global session
      session = aiohttp.ClientSession()
      scrape_index_tasks = [asyncio.ensure_future(scrape_api()) for _ in range(10000)]
      await asyncio.gather(*scrape_index_tasks)
  
  if __name__ == '__main__':
      asyncio.get_event_loop().run_until_complete(main())