pandas创建多重索引有很多方式，老董在使用过程中一共总结了7种类方式，本文为大家总结1下。

## 1、pd.MultiIndex.from_arrays()：

　　可以直接传入二维列表作为参数。
 
```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
 
arrays = [['baidu', 'baidu', 'sogou', 'sogou'], ['pc', 'wap', 'pc', 'wap',]]
index=  pd.MultiIndex.from_arrays(arrays, names=('name', 'pingtai'))
print(index)
df = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,22,33,44],[55,66,77,88]],index=index)
print(df)
MultiIndex([('baidu',  'pc'),
            ('baidu', 'wap'),
            ('sogou',  'pc'),
            ('sogou', 'wap')],
           names=['name', 'pingtai'])
                0   1   2   3
name  pingtai                
baidu pc        1   2   3   4
      wap       5   6   7   8
sogou pc       11  22  33  44
      wap      55  66  77  88
```



```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
arrays = [['baidu', 'baidu', 'sogou', 'sogou'], ['pc', 'wap', 'pc', 'wap',]]
index=  pd.MultiIndex.from_arrays(arrays, names=('name', 'pingtai'))
print(index)
df = pd.DataFrame([[1,2,3,4]],columns=index)
print(df)
MultiIndex([('baidu',  'pc'),
            ('baidu', 'wap'),
            ('sogou',  'pc'),
            ('sogou', 'wap')],
           names=['name', 'pingtai'])
name    baidu     sogou    
pingtai    pc wap    pc wap
0           1   2     3   4
```
## 2、pd.MultiIndex.from_tuples()：

　　可以直接传入元组组成的的列表作为参数。


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
 
tuples = [('baidu', 'pc'), ('baidu', 'wap'),
          ('sogou', 'pc'), ('sogou', 'wap')]
index=  pd.MultiIndex.from_tuples(tuples, names=('name', 'pingtai'))
 
df1 = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,22,33,44],[55,66,77,88]],index=index)
df2 = pd.DataFrame([[1,2,3,4]],columns=index)
# 自己输出验证把
```

## 3、pd.MultiIndex.from_product()：

　　可迭代对象组成的列表作为参数，列表内每个可迭代对象的元素的笛卡尔积创建索引。


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
 
tuples = [['baidu', 'sogou'], ['pc', 'wap']]
index=  pd.MultiIndex.from_product(tuples, names=('name', 'pingtai'))
 
df1 = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,22,33,44],[55,66,77,88]],index=index)
df2 = pd.DataFrame([[1,2,3,4]],columns=index)
# 自己输出验证把
```
## 4、pd.MultiIndex.from_frame：

　　传入1个df，根据df数据框(注意不是索引)作为多重索引创建df


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
 
tuples = [['baidu', 'sogou'], ['pc', 'wap']]
index=  pd.MultiIndex.from_product(tuples, names=('name', 'pingtai'))
 
df2 = pd.DataFrame([[1,2,3,4],[5,6,7,8],[11,22,33,44],[55,66,77,88]],index=index)
print(df2)
print('------------------')
# 自己输出验证把
index = pd.MultiIndex.from_frame(df2)
print(index)
                0   1   2   3
name  pingtai                
baidu pc        1   2   3   4
      wap       5   6   7   8
sogou pc       11  22  33  44
      wap      55  66  77  88
------------------
MultiIndex([( 1,  2,  3,  4),
            ( 5,  6,  7,  8),
            (11, 22, 33, 44),
            (55, 66, 77, 88)],
           names=[0, 1, 2, 3])
```
## 5、groupby()：

　　通过分组统计得到多重索引，groupby函数默认as_index=True，即把分组的列作为索引


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
 
df = pd.DataFrame({'name': ['baidu', 'baidu','sogou', 'sogou'],
					'pingtai':['pc','wap','pc','wap'],
                   'value': [100., 200., 50., 80.]}
                   )
df_res = df.groupby(['name','pingtai']).sum()
print(df_res)
print('----------------')
print(df_res.index)
               value
name  pingtai       
baidu pc       100.0
      wap      200.0
sogou pc        50.0
      wap       80.0
----------------
MultiIndex([('baidu',  'pc'),
            ('baidu', 'wap'),
            ('sogou',  'pc'),
            ('sogou', 'wap')],
           names=['name', 'pingtai'])
```
## 6、pivot_table()：

　　pivot_table函数生成透视表(其实也是分组聚合)


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
import numpy as np  
 
 
df = pd.DataFrame({"A": ["baidu", "baidu", "baidu", "baidu", "baidu",
                         "google", "google", "google", "google"],
                   "B": ["pc", "pc", "pc", "wap", "wap",
                         "pc", "pc", "wap", "wap"],
                   "C": [1, 2, 2, 3, 3, 4, 5, 6, 7],
                   "D": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
table = pd.pivot_table(df, values='D', index=['A', 'B'],aggfunc=np.sum)
print(table)
print('----------------')
print(table.index)
             D
A      B      
baidu  pc   11
       wap  11
google pc   14
       wap  18
----------------
MultiIndex([( 'baidu',  'pc'),
            ( 'baidu', 'wap'),
            ('google',  'pc'),
            ('google', 'wap')],
           names=['A', 'B'])
```
## 7、读取excel文件

　　读取excel文件，通过index_col或者header参数设置多重索引


```python
# ‐*‐ coding: utf‐8 ‐*‐
import pandas as pd
import numpy as np  
 
# 第1和2列设为行索引
pd.read_excel(file_excel,index_col=[0,1]) 
# 第1和2行设为列索引
pd.read_excel(file_excel,header=[0,1])
```

pandas创建多重索引的7种方法

## 问题描述：FileNotFoundError: Could not find module 'libiconv.dll'
![微信截图_20221129173518.png](https://blog.kyln.fun/static/img/89e38f654e5357dd23c89e5b0ad5c249.%E5%BE%AE%E4%BF%A1%E6%88%AA%E5%9B%BE_20221129173518.png)

这个问题网上众说纷纭，我列举有网络上的方法：




    1.Python版本不对

    2.pyzbar的版本不对

    3.下载某某DLL，放入根目录

    4.dll劫持等安全性问题等等

作为一个新手我觉着我就想使用一个 pyzbar 包，简单识别一个二维码。怎么可能这么复杂，以上方法我亲测，对于我出现的问题是解决不了的，大家也可以去一个个试试，我只代表我个人的意见！

## 解决方案：
    我研究了很长时间，最后我发现其实只是libiconv.dll 没有安装动态连接库，所以我们下载一下动态链接库即可解决问题。

    下载链接：[动态链接库](https://download.microsoft.com/download/F/3/5/F3500770-8A08-488E-94B6-17A1E1DD526F/vcredist_x64.exe)

FileNotFoundError: Could not find module 'libiconv.dll' (or one of its dependencies)

:::warning{title="显示requests下载网速和进度条"}
写了一个函数，直接复制下载的代码，调用download_show()函数即可。
:::
```python
# -*- coding:   utf-8 -*-
# @Time     :   2021/8/6 14:23
# @Author   :   Kyln.Wu
# @Email    :   kylnwu@qq.com
# @FileName :   显示requests下载网速和进度条.py
# @IDE      :   PyCharm
import os
import time
import requests



def download_show(url):
    # url = 'https://down.360safe.com/se/360se_setup.exe'
    folder = './下载/'  # 在本代码所存放的目录下新建一个文件夹，可以自行修改中间的文字
    if not os.path.exists(folder):  # 判断文件夹是否存在，如果不存在就创建
        os.mkdir(folder)
    name = '360se_setup.exe'    # 文件名命名
    filename = os.path.abspath(folder + name)
    # 请求下载地址，以流式的。打开要下载的文件位置。
    with requests.get(url=url, stream=True) as r, open(filename, 'wb') as file:
        # 请求文件的大小单位字节B
        total_size = int(r.headers['content-length'])
        # 已下载的字节大小
        content_size = 0
        # 进度下载完成的百分比
        plan = 0
        # 请求开始的时间
        start_time = time.time()
        # 上秒的下载大小
        temp_size = 0
        # 开始下载每次请求1024字节
        for content in r.iter_content(chunk_size=1024):
            file.write(content)
            # 统计已下载大小
            content_size += len(content)
            # 计算下载进度
            plan = (content_size / total_size) * 100
            # 每一秒统计一次下载量
            if time.time() - start_time > 1:
                # 重置开始时间
                start_time = time.time()
                # 每秒的下载量
                speed = content_size - temp_size
                # KB级下载速度处理
                if 0 <= speed < (1024 ** 2):
                    print('已下载：{:.2f}'.format(plan), '%', '下载速度：{:.4f}'.format(speed / 1024), 'KB/s', end='\r')
                    # MB级下载速度处理
                elif (1024 ** 2) <= speed < (1024 ** 3):
                    print('已下载：{:.2f}'.format(plan), '%', '下载速度：{:.4f}'.format(speed / (1024 ** 2)), 'MB/s', end='\r')
                    # GB级下载速度处理
                elif (1024 ** 3) <= speed < (1024 ** 4):
                    print('已下载：{:.2f}'.format(plan), '%', '下载速度：{:.4f}'.format(speed / (1024 ** 3)), 'GB/s', end='\r')
                    # TB级下载速度处理
                else:
                    print('已下载：{:.2f}'.format(plan), '%', '下载速度：{:.4f}'.format(speed / (1024 ** 4)), 'TB/s', end='\r')
                # 重置已下载大小
                temp_size = content_size
        print('下载完成！保存路径为: ' + filename)


if __name__ == '__main__':
    download_show('https://down.360safe.com/se/360se_setup.exe')
```

用python写一个下载的进度条

:::warning{title="Pycharm专业版激活方法"}
低调使用
:::

## 1、打开[https://getintopc.com/](https://getintopc.com/)网站，搜索“pycharm”下载2022版安装包和激活工具
或直接点这个链接下载2022版
[https://getintopc.com/softwares/development/jetbrains-pycharm-pro-2022-free-download-3565748/](https://getintopc.com/softwares/development/jetbrains-pycharm-pro-2022-free-download-3565748/)

如下图，下载安装包和激活工具（解压密码：123）



![pycharm.jpg](https://blog.kyln.fun/static/img/fbdb072a42386a8c59ff1f32794a42a5.pycharm.jpg)

## 2、正常安装Pycharm x64 v2022.1
经本人测试，从官方下载的pycharm安装包也可以成功激活。
如果上面的网址下载安装包比较慢，可以选择官网下载。
然后用激活工具激活。

## 3、按下面步骤激活

:::info{title="激活方法"}
##注意1：以下操作说明基于WINDOWS，如果您使用的是OS X/Linux，请根据您的操作系统更改地址。
确保.jar文件完整路径不包含任何空格。

##注意2：同一时间只能使用一个javaagent，如果您已经更换/升级了其他代理，请务必移除对应。

该代理将激活IDE和一些插件！
注意：如果您已经登录到您的JB帐户，请先注销！
注意：如果您已经安装了“IDE评估重置”插件，请先卸载它！

#### 以下是激活步骤：
1) 将下载的激活工具包中的ja-netfilter-all文件夹复制到C:\。
最好放在C:\，而且不能删除哦！
(ja-netfilter.jar文件的路径应该是“C:\ja-netfilter-all\ja-netfilter.jar”)。

2) 找到所需JetBrains产品的.vmOptions文件：
它位于JetBrains IDE的bin目录中。
例如：
C:\Program Files\JetBrains\PyCharm professional Edition 2021.2.2\bin\pycharm64.exe.vmOptions。
或者，如果您使用自定义VM选项，则路径将为，
例如：
C：\Users\%username%\AppData\Roaming\JetBrains\pycharm 2021.3\pycharm64.exe.vmoptions。

3) 右键以记事本打开pycharm64.exe.vmOptions文件，在末尾添加以下行：

`-javaagent:C：\ja-netfilter-all\ja-netfilter.jar=jetbrains`

4) 运行Pycharm，选择激活方式，选择许可证服务器，输入服务器地址：https://jetbra.in

5) 点击“测试连接”，如果提示连接成功，再点击激活，一般就可以正常激活了。

============================================================
在某些PC上，会抛出“服务器未通过数据完整性检查”的错误。
在这种情况下，请关闭IDE，打开相应的.vmOptions。
在C：\JA-netFilter-all\vmOptions文件夹中，将与步骤3相同的行也添加到该.vmOptions中；然后重复步骤4。

注意：不关心激活时间(如果显示激活时间)，它是备用许可证，不会过期。
注意：此许可证可以激活Code With Me插件和大多数其他插件！


新的自动配置vm选项(如果不起作用，请使用手动方式(上面的步骤2))：
MacOS或Linux：执行“脚本/install.sh”
Windows：双击执行“脚本\安装-当前-用户.vbs”(针对当前用户)。
“脚本\Install-all-users.vbs”(适用于所有用户)。


#### 常见问题：
问：OS X/Linux上的.vmOptions文件在哪里？
答：使用IDE中的菜单项：齿轮图标->编辑自定义VM选项。
注：要访问此功能，您必须在JetBrains网站上创建一个免费帐户来激活试用版的JetBrains产品&完全激活它。
:::

pycharm专业版免费激活

:::tip{title="python的异步协程应用"}
下载高清美M靓照示例
爬虫的核心四步：
1、分析目标网站
2、发送请求
3、解析网页代码
4、清洗保存数据
:::
```python
# -*- coding:   utf-8 -*-
# @Time     :   2022/7/16 11:23   
# @Author   :   Kyln.Wu
# @Email    :   kylnwu@qq.com
# @FileName :   aiohttp-demo.py
# @IDE      :   PyCharm
# https://www.umei.cc 优美图库下载
import asyncio
import os.path
import aiofiles
import aiohttp
import httpx
import requests
from lxml import html
etree = html.etree




# 获取某个MM的图片总张数，返回数值
def get_all_pic_num(url):
    resp = requests.get(url)
    res_html = etree.HTML(resp.text)
    pic_nums_text = res_html.xpath('/html/body/main/div[1]/div/div[1]/span[4]/text()')[0]
    pic_all_num = pic_nums_text.rsplit('/', 1)[1]
    print(pic_all_num)
    return int(pic_all_num)


# 异步方法遍历图片总张数，获取真实的图片url地址，最终返回url列表
async def get_pic_list(url, n):
    print('正在解析图片地址...')
    pic_url_list = []
    tasks = []
    for i in range(n):
        if i == 0:
            each_url = url
            # print(each_url)
        else:
            each_url = f"{url.rsplit('.', 1)[0]}_{i + 1}.htm"
            # print(each_url)
        # 下面两行是异步处理的关键，把网页解析装入一个异步任务列表
        task = asyncio.ensure_future(parse_html(each_url, pic_url_list))
        task.add_done_callback(get_urls)    # get_urls是一个回调函数，后面有定义
        tasks.append(task)
    # 异步执行解析图片地址，等待任务完成
    await asyncio.wait(tasks)
    return pic_url_list


# 异步方法解析网页，是get_pic_list函数的一部分，单独拿出来写一个函数，返回图片地址列表
async def parse_html(url, pic_url_list):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            res_html = etree.HTML(await resp.text())
            try:
                pic_url = res_html.xpath('/html/body/main/div[1]/div/section/a/img/@src')[0]
                pic_url = f"https://{pic_url.split('//')[1]}"
                # print(pic_url)
                pic_url_list.append(pic_url)
            except Exception as e:
                print(e)

    return pic_url_list


# 异步方法下载图片，并保存到本地
async def aio_download(url, path):
    name = url.rsplit('/', 1)[1]
    # 异步发送请求http1.x
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            print(f'aiohttp异步请求：{resp.status}')
            if resp.status == 200:
                # 异步写入文件
                async with aiofiles.open(f'./{path}/{name}', 'wb') as f:
                    await f.write(await resp.content.read())
            else:
                # 这一步视目标网站的情况而定，这里是因为目标网站的图片地址有重定向的情况，用aiohttp不能重定向url。同时也为了多给出一种异步方法，供参考使用。
                await httpx_download(url, path)

    print(name, '--->搞定！')


# 异步模式下载http2.0的链接
async def httpx_download(url, path):
    name = url.rsplit('/', 1)[1]
    # 也可以写成client = httpx.AsyncClient()
    async with httpx.AsyncClient() as client:
        # 这里有个坑，httpx.get默认不追踪网页重定向，如果碰到返回代码301，需要加上参数follow_redirects=True
        resp = await client.get(url, follow_redirects=True)
        print(f'httpx异步请求：{resp.status_code}')
        if resp.status_code == 200:
            # 异步写入文件
            async with aiofiles.open(f'./{path}/{name}', 'wb') as f:
                await f.write(resp.content)


# 这个函数是配合task.add_done_callback方法用的
# 定义一个任务对象的回调函数，回调函数必须有参数，参数为回调函数的绑定者（任务对象）
def get_urls(task):
    result = task.result()
    return result


# 根据main中输入的MM主页网址，定义本地保存的目录格式和对网址进行格式化，以便后续使用
def format_url(url):
    if "_" in url:
        path = f"./{url.rsplit('/', 1)[1].rsplit('_', 1)[0]}"
        web_url = f"{url.rsplit('_', 1)[0]}.htm"
    else:
        path = f"./{url.rsplit('/', 1)[1].rsplit('.', 1)[0]}"
        web_url = url
    if not os.path.exists(path):
        os.makedirs(path)
    return path, web_url


# 异步协程任务主程序
async def main(urls):
    tasks = [asyncio.create_task(httpx_download(url, save_path)) for url in urls]

    await asyncio.wait(tasks)


if __name__ == '__main__':
    # url = 'https://www.umei.cc/bizhitupian/weimeibizhi/225251.htm'    # 随便获取一个美女的图集网址
    url = input('请输入图集网址：')    # 随便获取一个美女的图集网址

    # 根据接收输入的网址，定义保存目录和格式化网址和保存文件名
    save_path, parse_url = format_url(url)
    name = url.rsplit('/', 1)[1]
    # 获取图片总张数
    num = get_all_pic_num(parse_url)

    # 创建任务对象
    # get_pic_list()是一个协程函数对象，需要用asyncio.ensure_future()创建成任务，并去执行才会有结果
    url_list_task = asyncio.ensure_future(get_pic_list(parse_url, num))

    # 想要得到任务对象的返回值，需要用task.add_done_callback()方法回调返回值
    # 想要回调返回值，绑定回调函数。
    url_list_task.add_done_callback(get_urls)
    # print(url_list)

    # 创建事件循环对象
    loop = asyncio.get_event_loop()

    # 将任务对象存储到Event_loop中且启动任务对象，第一次异步循环任务事件，获取全部图片地址的列表
    url_list = loop.run_until_complete(url_list_task)
    print(url_list)

    # 把图片地址列表传入主函数，进行第二次异步循环任务事件，异步下载并保存结果
    loop.run_until_complete(main(url_list))



```

1、pd.MultiIndex.from_arrays()：

问题描述：FileNotFoundError: Could not find module 'libiconv.dll'

1、打开https://getintopc.com/网站，搜索“pycharm”下载2022版安装包和激活工具