from pyecharts import options as opts
from pyecharts.charts import Bar, Grid, Line, Liquid, Page, Pie
from pyecharts.faker import Faker
from pyecharts.globals import SymbolType

#饼状图
def pie():
    c = (
        Pie()
        .add("", [['跳水', 12], ['射击', 11], ['举重', 8], ['竞技体操', 8], ['乒乓球', 7], ['游泳', 6], ['羽毛球', 6], ['田径', 5], ['静水皮划艇', 3], ['蹦床体操', 3], ['自由式摔跤', 3], ['赛艇', 3], ['空手道', 2], ['拳击', 2], ['帆船', 2], ['花样游泳', 2], ['跆拳道', 1], ['场地自行车赛', 1], ['古典式摔跤', 1], ['击剑', 1], ['三人篮球', 1]],center=["50%", "60%"],)
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {c}"))
#         .render("饼图.html")
        )
    return c
#     return c.render_notebook()

#水滴图
def wb():
    c = (
        Liquid()
        .add("", [0.3, 0.7], is_outline_show=False, shape=SymbolType.DIAMOND)
        .set_global_opts(title_opts=opts.TitleOpts(title="Liquid-Shape-Diamond"))
#         .render("liquid_shape_diamond.html")
        )
    return c
#     return c.render_notebook()

#柱状图
def bar():
    c = (
        Bar()
        .add_xaxis(Faker.choose())
        .add_yaxis("商家A", Faker.values(), stack="stack1")
        .add_yaxis("商家B", Faker.values(), stack="stack1")
        .set_series_opts(label_opts=opts.LabelOpts(is_show=False))
        .set_global_opts(title_opts=opts.TitleOpts(title="Bar-堆叠数据（全部）"))
#         .render("bar_stack0.html")
        )
    return c
#     return c.render_notebook()
page = Page(layout=Page.DraggablePageLayout, page_title="2020东京奥运会奖牌榜")

# 在页面中添加图表
page.add(
    pie(),
    wb(),
    bar())
page.render('test.html')

CPU 架构

import platform
print("操作系统名称及版本号:",platform.platform())    #获取操作系统名称及版本号
print("操作系统版本号:",platform.version())           #获取操作系统版本号
print("操作系统的位数:",platform.architecture())      #获取操作系统的位数
print("计算机类型:",platform.machine())               # 计算机类型
print("计算机网络名称：",platform.node())             #计算机网络名称
print("计算机处理器信息:",platform.processor())       #计算机处理器信息
print("上面所有的信息汇总:",platform.uname())         #上面所有的信息汇总

CPU 核数

# 方法一：
# 如果当前Python版本大于2.6，可以简单的通过下面模块来获取当前cpu数量，
import multiprocessing
print("CPU 核数:",multiprocessing.cpu_count())
# 如果是比较老的Python版本，可以用下面的模块来获取当前cpu数量：
import psutil
print("CPU 核数:",psutil.cpu_count())

# 方法二：
# Python可以读系统文件/proc/cpuinfo，过滤“processor”字段统计核心数。
def get_cpu_info():
    processor_cnt = 0
    cpu_model = ""
    f_cpu_info = open("/proc/cpuinfo")
    try:
        for line in f_cpu_info:
#             print(line)
            if (line.find("processor") == 0):
                processor_cnt += 1
        print("cpu counts:{}" .format(processor_cnt))
    finally:
        f_cpu_info.close()
get_cpu_info()

内存信息

# 读取内存信息可以直接读系统文件/proc/meminfo。
def get_mem_info():
    mem_info = ""
    f_mem_info = open("/proc/meminfo")
    try:
        for line in f_mem_info:
#             print(line.strip())
            if (line.find("MemTotal") == 0):
                mem_info += line.strip()+ ", "
            elif (line.find("SwapTotal") == 0):
                mem_info += line.strip()
                break;
        print("mem_info---- {:s}".format(mem_info))
    finally:
        f_mem_info.close()
get_mem_info()

磁盘信息

import os
import subprocess
def get_disc_info():
#     方法一：
    disc_info=os.popen("df -h").read()
    disc_info=subprocess.Popen("df -h",shell=True).communicate()[0]
    print(disc_info)

# 方法二：
#     pipe=subprocess.Popen("df -h",stdout=subprocess.PIPE,shell=True)
#     disc_info=pipe.stdout.read()
#     print(disc_info)
get_disc_info()

网络信息

import netifaces
routingGateway = netifaces.gateways()['default'][netifaces.AF_INET][0] #网关
routingNicName = netifaces.gateways()['default'][netifaces.AF_INET][1] #网络适配器信息
for interface in netifaces.interfaces():
    if interface == routingNicName:
        #print (netifaces.ifaddresses(interface))
        try:
            routingIPAddr = netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['addr'] #获取IP
        except KeyError:
            pass
    #print ("Routing IP Address:%s"% routingIPAddr)
    return routingIPAddr
if __name__ == "__main__":
    try:
        print ("Routing IP Address:",GetNetworkIP())
    except:
        print ("Unable to get the address, there may not be installed netifaces module! command:pip install netifaces")

                             桃花庵歌
                     【作者】唐寅 【朝代】明
    桃花坞里桃花庵，桃花庵里桃花仙。桃花仙人种桃树，又摘桃花卖酒钱。
    酒醒只在花前坐，酒醉还来花下眠。半醒半醉日复日，花落花开年复年。
    但愿老死花酒间，不愿鞠躬车马前。车尘马足富者趣，酒盏花枝贫者缘。
    若将富贵比贫贱，一在平地一在天。若将贫贱比车马，他得驱驰我得闲。
    别人笑我太疯癫，我笑他人看不穿。不见五陵豪杰墓，无花无酒锄作田。 

理解深度优先搜索的关键在于解决“当下该如何做”。至于“下一步该如何做”则与“当下该如何做”是一样的。
基本模型：

void dfs(int step)
{
    判断边界
    尝试每一种可能 for(i=1;i<=n;i++)
    {
       继续下一步 dfs(step+1)
    }
    返回
}
//或者是
int dfs(int t)
{
    if(满足输出条件)
    {
        输出解;
    }
    for(int i=1;i<=尝试方法数;i++)
        if(满足进一步搜索条件)
        {
            为进一步搜索所需要的状态打上标记;
            dfs(t+1);
            恢复到打标记前的状态;//也就是说的{回溯一步}
        }
}

示例1：输入整数n,全排列1~n

#include "stdio.h"
int a[10],book[10],n;
void dfs(int step){
    int i; 
    if(step==n+1){
        for(i=1;i<=n;i++){
            printf("%d",a[i]);
        }
        printf("\n");
        return;
    }
    for(i=1;i<=n;i++){
        if(book[i]==0){
            a[step]=i;
            book[i]=1;
            dfs(step+1);
            printf("\n");
            book[i]=0;
        }
    
    }
    return;
}
int main(){
    scanf("%d",&n);
    dfs(1);
    return 0;
}

示例2：□ □ □ + □ □ □ = □ □ □，在□中填入1~9使等式成立且每位数字只出现一次

#include "stdio.h"
int a[10],book[10],sum=0;
void dfs(int step){
    int i;
    if(step==10){
        if(a[1]*100+a[2]*10+a[3]+a[4]*100+a[5]*10+a[6]==a[7]*100+a[8]*10+a[9]){
            sum++;
            printf("%d%d%d+%d%d%d=%d%d%d ",a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]); 
        }
        return;
    }
    for(i=1;i<=9;i++){
        if(book[i]==0){
            a[step]=i;
            book[i]=1;
            dfs(step+1);
            book[i]=0;
        }
    }
    return;
}
int main(){
    dfs(1);
    printf("\n");
    printf("一共有%d组结果",sum/2);
}

示例3：迷宫。
给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

#include "stdio.h"
int m,n,p,q,min=99999,sum=0;
int a[51][51],book[51][51];
void dfs(int x,int y,int step){
    int next[4][2]={
    {0,1},//向右走 
    {1,0},//向下走
    {0,-1},//向左走
    {-1,0}};//向上走
    int tx,ty,k;
    //判断是否到达位置 
    if(x==p&&y==q){
        if(step<min){
            sum++;
            min=step;
        }
        return;//很重要 
    }
    //枚举4种走法 
    for(k=0;k<=3;k++){
        //计算下一个点坐标 
        tx=x+next[k][0];
        ty=y+next[k][1];
        //判断是否越界 
        if(tx<1||tx>n||ty<1||ty>n){
            continue;
        }
        //判断该点是否为障碍物或已经在走过的路径中 
        if(a[tx][ty]==0&&book[tx][ty]==0){
            book[tx][ty]=1;
            dfs(tx,ty,step+1);
            book[tx][ty]=0;
        }
    }
    return ; 
}
int main(){
    int i,j,startx,starty;
    scanf("%d %d",&n,&m);//n行m列
    //读入迷宫 
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
        }
    }
    //读入起止点坐标
    scanf("%d %d %d %d",&startx,&starty,&p,&q);
    //从起始点开始搜索
    book[startx][starty]=1;
    dfs(startx,starty,0);
    printf("共有%d条路径",sum)
    printf("\n");
    printf("最短路径走了%d步",min);
    return 0;  
}

"*****接竹竿*****"
# 牌的大小范围：1——9
class struct_1:
    data=[]
    head:int
    tail:int
class struct_2:
    data=[]
    head:int
    tail:int
class stack:
    data=[]
    top:int
def PTbamboo():
    book=[]
    q1=struct_1()
    q2=struct_2()
    s=stack()
    q1.head=1
    q1.tail=1
    q2.head=1
    q2.tail=1
    s.top=0
    for i in range(100):
        q1.data.append(0)
        q2.data.append(0)
        s.data.append(0)
    for i in range(1,10):
        book.append(0)
    for i in range(6):
        a=input("请一号拿牌：")
        q1.data[q1.tail]=a
        q1.tail+=1
    for i in range(6):
        b=input("请二号拿牌：")
        q2.data[q2.tail]=b
        q2.tail+=1
    print(q1.data[:10])
    print(q2.data[:10])
    while q1.head<q1.tail and q2.head<q2.tail:
        t=int(q1.data[q1.head])
        if book[t]==0:
            q1.head+=1
            s.top+=1
            s.data[s.top]=t
            book[t]=1
        else:
            q1.head+=1
            q1.data[q1.tail]=t
            q1.tail+=1
            while s.data[s.top]!=t:
                book[s.data[s.top]]=0
                q1.data[q1.tail]=s.data[s.top]
                q1.tail+=1
                s.top-=1
        t=int(q2.data[q2.head])
        if book[t]==0:
            q2.head+=1
            s.top+=1
            s.data[s.top]=t
            book[t]=1
        else:
            q2.head+=1
            q2.data[q2.tail]=t
            q2.tail+=1
            while s.data[s.top]!=t:
                book[s.data[s.top]]=0
                q2.data[q2.tail]=s.data[s.top]
                q2.tail+=1
                s.top-=1
    if q2.head==q2.tail:
        print("1 win!")
        print("一号玩家手中的牌为：",end='')
        for i in range(q1.head,q1.tail):
            print(q1.data[i],end='')
        if s.top>0:
            print("桌上的牌为：",end='')
            for i in range(1,s.top+1):
                print(s.data[i],end='')
        else:
            print("桌上已经没牌了！")
    else:
        print("2 win!")
        print("二号玩家手中的牌为：",end='')
        for i in range(q2.head,q2.tail):
            print(q2.data[i],end='')
        if s.top>0:
            print("桌上的牌为：",end='')
            for i in range(1,s.top+1):
                print(s.data[i],end='')
        else:
            print("桌上已经没牌了！")
# PTbamboo()

桶排序:
桶排序的思想：数组x的下标是有序的，例如x[0],x[1],x[2]中的0,1,2；
桶排序的要旨是把待排序的数据放到数组x中，根据x中的最大值m设置数组y[0]->y[m]=0；
循环遍历x数组i in range(m+1)次，如果x[j]=i,那么y[x]=y[x]+1
现在x中的元素变成了数组y中的下标中值不为0的下标

def bucket_sort():
    import random
    x,y=[],[]
    for i in range(20):         #用random函数随机生成一组数据放到数组x中
        a=random.randint(0,12)
        x.append(a)
    print("x中的原数据:",x)
    m=max(x)                    #找出x中的最大值m,m决定了数组y的长度
    print("数组x中的最大值：",m)
    for i in range(0,m+1):     #数组y的长度为m+1，并赋值为0
        y.append(0)
    for i in range(20):
        y[x[i]]+=1
    print("y中的值",y)
    for i in range(m+1):
        for j in range(0,y[i]):
            print(i,end=' ')
bucket_sort()

冒泡排序:

def bubble_sort():
    import random
    x=[]
    m=eval(input("输入随机生成数据的个数："))
    for i in range(m):
        a=random.randint(0,20)   #随机生成数的大小范围
        x.append(a)
    print("数组x中的数据：",x)
    for i in range(1,len(x)):
        for j in range(0,len(x)-i):
            if x[j]<x[j+1]:
                x[j],x[j+1]=x[j+1],x[j]
    print("排序后：",x)
bubble_sort()

快速排序:

def Quick_sort(lists:list,left:int,right:int):
    # 跳出递归判断
    if left>=right:
        return lists
    # 选择参考点，该调整范围的第1个值
    key=lists[left]
    low=left
    high=right
    # 循环判断直到遍历全部
    while left<right:
        # 从右边开始查找大于参考点的值
        while left<right and key<=lists[right]:
            right-=1
        lists[left]=lists[right]  # 这个位置的值先挪到左边
        # 从左边开始查找小于参考点的值
        
        while left<right and key>=lists[left]:
            left+=1
        lists[right]=lists[left]  # 这个位置的值挪到右边
        
    # 写回改成的值
    lists[left]=key
    
    # 递归，并返回结果
    Quick_sort(lists,low,left-1)  # 递归左边部分
    Quick_sort(lists,left+1,high) # 递归右边部分
    return lists

lists=[4,5,3,8,6,2,7,9,4,1]
Quick_sort(lists,0,len(lists)-1)
print(lists)