深入Phtread(三)：线程的同步-Condition Variables

于 2009-09-05 11:25:00 发布
阅读量549 收藏
点赞数
文章标签： variables struct null signal thread insert

继续昨天的线程同步，条件变量（Condition Variables）是用于线程间，通信共享数据状态改变的机制。
简介
条件变量的创建和销毁
等待条件变量
唤醒等待条件变量的线程
简介
    当线程互斥地访问一些共享的状态时，往往会有些线程需要等到这些状态改变后才应该继续执行。如：有一个共享的队列，一个线程往队列里面插入数据，另一个线程从队列中取数据，当队列为空的时候，后者应该等待队列里面有值才能取数据。而共享数据（队列）应该用mutex来保护，为了检查共享数据的状态（队列是否为空），线程必须先锁定mutex，然后检查，最后解锁mutex。
 
    问题出来了：当另外一个线程B锁定mutex后，往队列里面插入了一个值，B并不知道A在等着它往队列里面放入一个值。，线程A（等待状态改变）一直在运行，线程B可能已经检查过队列是空的，并不知道队列里已经有值了，所以一直阻塞着自己。为了解决这样的问题引入了条件变量机制。线程B等待于一个条件变量，当线程A插入了一个值后，signal或broadcast这个条件变量，通知线程B状态已改变，A发现条件变量被signaled了，就继续执行。就这样，当一个线程改变共享数据状态后，可以及时通知那些等待于该状态的线程。图示下：
 


    中间的矩形代表条件变量，当线程线位于矩形内，表示线程等待该条件变量。位于中心线下下方，则表示signal了该条件变量。
    开始线程1 signal 了条件变量，由于没有其他线程等待于该条件变量，所以没什么效果。然后，线程1和线程2先后等待该条件变量，过了一会，线程3 signal了条件变量，线程3的信号解除了线程1的阻塞。然后，线程3等待该条件变量。最后线程1 broadcast了该条件变量，同时解除了等待于条件变量的线程1和线程2。
 

条件变量的创建和销毁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t* cond, pthread_condattr_t* condattr);
int pthread_cond_destroy(pthread_cond_t* cond);
 
和互斥量一样，可以动态创建和静态创建。
静态创建：条件变量声明为extern或static变量时。
例程：
+ expand sourceview plaincopy to clipboardprint?
#include <pthread.h>  
#include "error.h"  
 
typedef struct my_struct_tag  
{  
    pthread_mutex_t mutex;  
    pthread_cond_t cond;  
    int value;  
} my_struct_t;  
 
my_struct_t data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};  
 
int main()  
{  
    return 0;  
} 
#include <pthread.h>
#include "error.h"

typedef struct my_struct_tag
{
 pthread_mutex_t mutex;
 pthread_cond_t cond;
 int value;
} my_struct_t;

my_struct_t data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};

int main()
{
 return 0;
}
 
 
动态创建：一般情况下，条件变量要和它的判定条件定义在一起，此时若包含该条件变量的数据动态创建了，则条件变量也需要动态创建，不过记得不用时用pthread_cond_destroy销毁。
 
例程：
+ expand sourceview plaincopy to clipboardprint?
#include <pthread.h>  
#include "error.h"  
 
typedef struct my_struct_tag  
{  
    pthread_mutex_t mutex;  
    pthread_cond_t cond;  
    int value;  
} my_struct_t;  
 
int main()  
{  
    my_struct_t* data;  
    data = (my_struct_t*)malloc(sizeof(my_struct_t));  
    if(data == NULL)  
        ERROR_ABORT(errno,"Allocate structure");  
 
    int status;  
    status = pthread_mutex_init(&data->mutex, NULL);  
    if(status != 0)  
        ERROR_ABORT(status, "Initial mutex");  
    status = pthread_cond_init(&data->cond, NULL);  
    if(status != 0)  
        ERROR_ABORT(status, "Initial condition");  
 
    /* .... */ 
      
    status = pthread_cond_destroy(&data->cond);  
    if(status != 0)  
        ERROR_ABORT(status, "Destroy cond");  
    status = pthread_mutex_destroy(&data->mutex);  
    if(status != 0)  
        ERROR_ABORT(status, "Destroy mutex");  
 
    free(data);  
 
    return 0;  
} 
#include <pthread.h>
#include "error.h"

typedef struct my_struct_tag
{
 pthread_mutex_t mutex;
 pthread_cond_t cond;
 int value;
} my_struct_t;

int main()
{
 my_struct_t* data;
 data = (my_struct_t*)malloc(sizeof(my_struct_t));
 if(data == NULL)
  ERROR_ABORT(errno,"Allocate structure");

 int status;
 status = pthread_mutex_init(&data->mutex, NULL);
 if(status != 0)
  ERROR_ABORT(status, "Initial mutex");
 status = pthread_cond_init(&data->cond, NULL);
 if(status != 0)
  ERROR_ABORT(status, "Initial condition");

 /* .... */
 
 status = pthread_cond_destroy(&data->cond);
 if(status != 0)
  ERROR_ABORT(status, "Destroy cond");
 status = pthread_mutex_destroy(&data->mutex);
 if(status != 0)
  ERROR_ABORT(status, "Destroy mutex");

 free(data);

 return 0;
}
 
等待条件变量
int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);
int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t* mutex, struct timespec* expiration);
 
    条件变量与互斥量一起使用，调用pthread_cond_wait或pthread_cond_timedwait时，记得在前面锁定mutex，尽可能多的判断判定条件。上面提到的两个等待条件变量的函数，显示解锁mutex，然后阻塞线程等待状态改变，等待的条件变量signaled后，锁定mutex，返回。记着，这两个函数返回时，mutex一定是锁定的。
 
多个条件变量可以共享一个互斥变量，相反则不成立。
 
例程：
+ expand sourceview plaincopy to clipboardprint?
#include <pthread.h>  
#include <time.h>  
#include "error.h"  
#include <errno.h>  
 
typedef struct my_struct_tag  
{  
    pthread_mutex_t mutex;  
    pthread_cond_t cond;  
    int value;  
} my_struct_t;  
 
my_struct_t data = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};  
 
int hibernation = 1;  
 
void* wait_thread(void* arg)  
{  
    int  status;  
    sleep(hibernation);  
 
    status = pthread_mutex_lock(&data.mutex);  
    if(status != 0)  
        ERROR_ABORT(status, "Lock mutex");  
 
    data.value = 1;  
    status = pthread_cond_signal(&data.cond);  
    if(status != 0)  
        ERROR_ABORT(status, "Singal cond");  
 
    status = pthread_mutex_unlock(&data.mutex);  
    if(status != 0)  
        ERROR_ABORT(status, "Unlock mutex");  
 
    return NULL;  
}  
 
int main(int argc, char* argv[])  
{  
    pthread_t tid;  
    int status;  
    struct timespec timeout;  
 
    if(argc > 1)  
        hibernation = atoi(argv[1]);  
 
    status = pthread_create(&tid, NULL, wait_thread, NULL);  
    if(status != 0)  
        ERROR_ABORT(status, "Create wait thread");  
 
    timeout.tv_sec = time(NULL) + 2;  
    timeout.tv_nsec = 0;  
 
    status = pthread_mutex_lock(&data.mutex);  
    if(status != 0)  
        ERROR_ABORT(status, "Lock mutex");  
 
    while(data.value == 0)  
    {  
        status = pthread_cond_timedwait(&data.cond, &data.mutex, &timeout);  
        if(status == ETIMEDOUT)  
        {  
            printf("Condition wait timed out./n");  
            break;  
        }else 
        if(status != 0)  
            ERROR_ABORT(status, "timewait");  
    }  
 
    if(data.value != 0)  
        printf("Condition wa signaled!/n");  
 
    status = pthread_mutex_unlock(&data.mutex);  
    if(status != 0)  
        ERROR_ABORT(status, "Unlock mutex");  
} 
#include <pthread.h>
#include <time.h>
#include "error.h"
#include <errno.h>

typedef struct my_struct_tag
{
 pthread_mutex_t mutex;
 pthread_cond_t cond;
 int value;
} my_struct_t;

my_struct_t data = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};

int hibernation = 1;

void* wait_thread(void* arg)
{
 int  status;
 sleep(hibernation);

 status = pthread_mutex_lock(&data.mutex);
 if(status != 0)
  ERROR_ABORT(status, "Lock mutex");

 data.value = 1;
 status = pthread_cond_signal(&data.cond);
 if(status != 0)
  ERROR_ABORT(status, "Singal cond");

 status = pthread_mutex_unlock(&data.mutex);
 if(status != 0)
  ERROR_ABORT(status, "Unlock mutex");

 return NULL;
}

int main(int argc, char* argv[])
{
 pthread_t tid;
 int status;
 struct timespec timeout;

 if(argc > 1)
  hibernation = atoi(argv[1]);

 status = pthread_create(&tid, NULL, wait_thread, NULL);
 if(status != 0)
  ERROR_ABORT(status, "Create wait thread");

 timeout.tv_sec = time(NULL) + 2;
 timeout.tv_nsec = 0;

 status = pthread_mutex_lock(&data.mutex);
 if(status != 0)
  ERROR_ABORT(status, "Lock mutex");

 while(data.value == 0)
 {
  status = pthread_cond_timedwait(&data.cond, &data.mutex, &timeout);
  if(status == ETIMEDOUT)
  {
   printf("Condition wait timed out./n");
   break;
  }else
  if(status != 0)
   ERROR_ABORT(status, "timewait");
 }

 if(data.value != 0)
  printf("Condition wa signaled!/n");

 status = pthread_mutex_unlock(&data.mutex);
 if(status != 0)
  ERROR_ABORT(status, "Unlock mutex");
}
 
 
唤醒等待条件变量的线程
 
int pthread_cond_signal(pthread_cond_t* cond);
int pthread_cond_broadcast(pthread_cond_t* cond);
 
    一但有线程由于某些判定条件（predicate）没满足，等待条件变量。我们就有必要当条件满足时，发送信号去唤醒这些线程。
    注意：broadcast通常很容易被认为是signal的通用版，其实不能这样理解，准确一点应该说，signal是broadcast的优化版。具体区别不大，但signal效率较broadcast高些。但你不确信有几个线程等待条件变量时用broadcast（When in doubt, broadcast!）。
 
例程：

 + expand sourceview plaincopy to clipboardprint?
#include "error.h"  
#include <pthread.h>  
#include <time.h>  
#include <string.h>  
#include <errno.h>  
 
typedef struct alarm_tag  
{  
    struct alarm_tag* link;  
    int seconds;  
    time_t time;  
    char message[64];  
} alarm_t;  
 
pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;  
pthread_cond_t alarm_cond = PTHREAD_COND_INITIALIZER;  
alarm_t* alarm_list = NULL;  
time_t current_alarm = 0;  
 
/** 
 * alarm_mutex need to be locked   
 */ 
void alarm_insert(alarm_t* alarm)  
{  
    int status;  
 
    alarm_t* next;  
    alarm_t** last;  
    last = &alarm_list;  
    next = *last;  
 
    while(next != NULL)  
    {  
        if(next->time >= alarm->time)  
        {  
            alarm->link = next;  
            *last = alarm;  
            break;  
        }  
 
        last = &next->link;  
        next = next->link;  
    }  
 
    if(next == NULL){  
        *last = alarm;  
        alarm->link = NULL;  
    }  
 
    /*for test: output the list*/ 
    printf("[list: ");  
    for(next = alarm_list; next != NULL; next = next->link)  
    {  
        printf("%d(%d)[/"%s/"]  ", next->time, next->time-time(NULL), next->message);  
    }  
    printf("]/n");  
 
    if(current_alarm ==0  || alarm->time < current_alarm)  
    {  
        current_alarm = alarm->time;  
        status = pthread_cond_signal(&alarm_cond);  
        if(status != 0)  
            ERROR_ABORT(status,"Signal cond");  
    }  
 
}  
 
void* alarm_thread(void* arg)  
{  
    alarm_t* alarm;  
    int sleep_time;  
    time_t now;  
    int status, expired;  
    struct timespec cond_time;  
 
    while(1)  
    {  
        status = pthread_mutex_lock(&alarm_mutex);  
        if(status != 0)  
            ERROR_ABORT(status, "lock");  
 
        current_alarm = 0;  
 
        while(alarm_list == NULL)  
        {  
            status = pthread_cond_wait(&alarm_cond, &alarm_mutex);  
            if(status != 0 )  
                ERROR_ABORT(status, "Wait cond");  
        }  
 
        alarm = alarm_list;  
        alarm_list = alarm->link;  
        now = time(NULL);  
        expired = 0;  
 
        if(alarm->time > now)  
        {  
            printf("[wating: %d(%d)/"%s/"]/n", alarm->time, alarm->time - time(NULL), alarm->message);  
 
            cond_time.tv_sec = alarm->time;  
            cond_time.tv_nsec = 0;  
            current_alarm = alarm->time;  
            while(current_alarm == alarm->time)  
            {  
                status = pthread_cond_timedwait(&alarm_cond, &alarm_mutex,&cond_time);  
                if(status == ETIMEDOUT)  
                {  
                    expired = 1;  
                    break;  
                }  
            }  
 
            if(!expired)  
                alarm_insert(alarm);  
        }else 
            expired = 1;  
 
        if(expired)  
        {  
            printf("(%d) %s/n", alarm->seconds, alarm->message);  
            free(alarm);  
        }  
 
        status = pthread_mutex_unlock(&alarm_mutex);  
        if(status != 0)  
            ERROR_ABORT(status, "Unlock mutex");  
    }  
 
    return 0;  
}  
 
int main()  
{  
    pthread_t pid;  
    int status;  
    char line[128];  
 
    status = pthread_create(&pid, NULL, alarm_thread, NULL);  
    if(status != 0)  
        ERROR_ABORT(status, "pthread_create");  
 
    while(1)  
    {  
        fprintf(stdout, "Alarm>");  
        fgets(line, sizeof(line), stdin);  
        if(strlen(line) <= 0)  
            continue;  
 
        alarm_t* alarm = (alarm_t*)malloc(sizeof(alarm_t));  
        if(alarm == NULL)  
            ERROR_ABORT(errno,"memory can't allocated!");  
 
        if(sscanf(line, "%d %s", &alarm->seconds, alarm->message) != 2)  
        {  
            printf("Bad Command/n");  
            free(alarm);  
            continue;  
        }  
 
        status = pthread_mutex_lock(&alarm_mutex);  
        if(status != 0)  
            ERROR_ABORT(status, "pthread mutex locking..");  
 
        alarm->time = time(NULL) + alarm->seconds;  
 
        /* insert into list*/ 
 
        alarm_insert(alarm);  
 
        status = pthread_mutex_unlock(&alarm_mutex);  
        if(status != 0)  
            ERROR_ABORT(status, "pthread mutex unlocking...");  
    }  
 
    return 0;  
} 
#include "error.h"
#include <pthread.h>
#include <time.h>
#include <string.h>
#include <errno.h>

typedef struct alarm_tag
{
 struct alarm_tag* link;
 int seconds;
 time_t time;
 char message[64];
} alarm_t;

pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t alarm_cond = PTHREAD_COND_INITIALIZER;
alarm_t* alarm_list = NULL;
time_t current_alarm = 0;

/**
 * alarm_mutex need to be locked 
 */
void alarm_insert(alarm_t* alarm)
{
 int status;

 alarm_t* next;
 alarm_t** last;
 last = &alarm_list;
 next = *last;

 while(next != NULL)
 {
  if(next->time >= alarm->time)
  {
   alarm->link = next;
   *last = alarm;
   break;
  }

  last = &next->link;
  next = next->link;
 }

 if(next == NULL){
  *last = alarm;
  alarm->link = NULL;
 }

 /*for test: output the list*/
 printf("[list: ");
 for(next = alarm_list; next != NULL; next = next->link)
 {
  printf("%d(%d)[/"%s/"]  ", next->time, next->time-time(NULL), next->message);
 }
 printf("]/n");

 if(current_alarm ==0  || alarm->time < current_alarm)
 {
  current_alarm = alarm->time;
  status = pthread_cond_signal(&alarm_cond);
  if(status != 0)
   ERROR_ABORT(status,"Signal cond");
 }

}

void* alarm_thread(void* arg)
{
 alarm_t* alarm;
 int sleep_time;
 time_t now;
 int status, expired;
 struct timespec cond_time;

 while(1)
 {
  status = pthread_mutex_lock(&alarm_mutex);
  if(status != 0)
   ERROR_ABORT(status, "lock");

  current_alarm = 0;

  while(alarm_list == NULL)
  {
   status = pthread_cond_wait(&alarm_cond, &alarm_mutex);
   if(status != 0 )
    ERROR_ABORT(status, "Wait cond");
  }

  alarm = alarm_list;
  alarm_list = alarm->link;
  now = time(NULL);
  expired = 0;

  if(alarm->time > now)
  {
   printf("[wating: %d(%d)/"%s/"]/n", alarm->time, alarm->time - time(NULL), alarm->message);

   cond_time.tv_sec = alarm->time;
   cond_time.tv_nsec = 0;
   current_alarm = alarm->time;
   while(current_alarm == alarm->time)
   {
    status = pthread_cond_timedwait(&alarm_cond, &alarm_mutex,&cond_time);
    if(status == ETIMEDOUT)
    {
     expired = 1;
     break;
    }
   }

   if(!expired)
    alarm_insert(alarm);
  }else
   expired = 1;

  if(expired)
  {
   printf("(%d) %s/n", alarm->seconds, alarm->message);
   free(alarm);
  }

  status = pthread_mutex_unlock(&alarm_mutex);
  if(status != 0)
   ERROR_ABORT(status, "Unlock mutex");
 }

 return 0;
}

int main()
{
 pthread_t pid;
 int status;
 char line[128];

 status = pthread_create(&pid, NULL, alarm_thread, NULL);
 if(status != 0)
  ERROR_ABORT(status, "pthread_create");

 while(1)
 {
  fprintf(stdout, "Alarm>");
  fgets(line, sizeof(line), stdin);
  if(strlen(line) <= 0)
   continue;

  alarm_t* alarm = (alarm_t*)malloc(sizeof(alarm_t));
  if(alarm == NULL)
   ERROR_ABORT(errno,"memory can't allocated!");

  if(sscanf(line, "%d %s", &alarm->seconds, alarm->message) != 2)
  {
   printf("Bad Command/n");
   free(alarm);
   continue;
  }

  status = pthread_mutex_lock(&alarm_mutex);
  if(status != 0)
   ERROR_ABORT(status, "pthread mutex locking..");

  alarm->time = time(NULL) + alarm->seconds;

  /* insert into list*/

  alarm_insert(alarm);

  status = pthread_mutex_unlock(&alarm_mutex);
  if(status != 0)
   ERROR_ABORT(status, "pthread mutex unlocking...");
 }

 return 0;
}
 


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/future_fighter/archive/2009/02/12/3883415.aspx

nolycjyf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Fraeser: errors-in-variables estimation-开源
04-28
一个图形化的MatLab框架，用于在变量误差环境中估算静态，动态线性和多项式系统的参数，对其进行建模和仿真，目的是比较各种估算策略。
深入Phtread(二)：线程的同步-Mutex
lvfengchang1220的专栏
07-30 329
并行的世界，没有同步，就失去了秩序，就会乱作一团！试想，交通没有红绿灯，生产线产品装配没有一定的顺序... 结果是显而易见的。多个线程也需要同步，否则程序运行起来结果不可预测，这是我们最不能容忍的。交通的同步机制就是红绿灯，Pthread提供了互斥量（mutex）和条件变量（Condition Variables）两种机制去同步线程。 不变量，临界区和判定条件 互斥量（Mute
uib-framework-variables-karin167:uib-framework-variables-karin167由GitHub Classroom创建
03-16
Sassy网站 创建一个样机网站，如。 说明： 使用sass创建模型。 尽可能使用嵌套和变量。 确保先为移动设备设计！ 断点： 768px-平板电脑 1024px-桌面 样式颜色： 卡的背景颜色：＃e0ddb2 ...
002a-basic-variables-sep-Encryptor：002a-basic-variables-Sep-Encryptor由GitHub Classroom创建
02-09
SDSS计算研究Python作业作业2基本变量和数据类型（总计标记6） 目标： 将值存储在基本变量中检索基本变量值使用print（）显示变量的内容在本课程中，您将学习使用变量的基础知识。 变量在代码中极为重要，因为它们...
任务02-javascript-variables-loops-conditions-whatever647：任务02-javascript-variables-loops-conditions-whatever647由GitHub Classroom创建
02-12
Javascript循环，条件和对象分配：目标这是多伦多大学历史系教授的数字人文课程“一项任务。 如果您是一名老师，请随意为自己的课程分叉并重新利用。 如果您是学生，请继续阅读！ 您不必成为一名编码人员即可在本...
root-variables:面向未来的原生 CSS 变量
05-30
根变量:root最小的、面向未来的原生 CSS 变量（CSS 自定义属性... link rel =" stylesheet " href =" https://unpkg.com/root-variables " >jsDelivr < link rel =" stylesheet " href =" https://cdn.jsdelivr.n
课程设计基于python+mediapipe+opencv开发的手势识别系统源码（含超详细注释）.zip
05-15
课程设计基于python+mediapipe+opencv开发的手势识别系统源码（含超详细注释）.zip个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 课程设计基于python+mediapipe+opencv开发的手势识别系统源码（含超详细注释）.zip个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 课程设计基于python+mediapipe+opencv开发的手势识别系统源码（含超详细注释）.zip个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 课程设计基于python+mediapipe+opencv开发的手势识别系统源码（含超详细注释）.zip个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计。
yolov7 车牌检测 车牌识别 中文车牌识别 检测 支持双层车牌 支持12种中文车牌
最新发布
05-15
yolov7
基于MQTT的智能宠物投喂系统.zip
05-15
基于MQTT的智能宠物投喂系统：STM32、ESP8266、LCDST7789、压力传感器、按键中断修改定时投喂时间、云平台
Qt进阶：优秀QT开源项目
05-15
详细说明：https://blog.csdn.net/u010168781/article/details/138924179 1、Krita 2、QGIS 3、Kdenlive 4、Clementine 5、Syncthing 6、KDevelop
2023-04-06-项目笔记 - 第一百三十四阶段 - 4.4.2.132全局变量的作用域-132 -2024.05.15
05-15
2023-04-06-项目笔记-第一百三十四阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.132全局变量的作用域_132 - 2024-05-15
matlab基于区间知识的大脑情绪学习算法.zip
05-15
matlab基于区间知识的大脑情绪学习算法.zip
Scrapy-0.8.win32.exe
05-15
文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
setuptools-34.1.0-py2.py3-none-any.whl
05-15
文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
基于python+PyQt5开发的智能照明控制系统上位机软件源码.zip
05-15
基于python+PyQt5开发的智能照明控制系统上位机软件源码.zip
pytest-4.6.3.tar.gz
05-15
文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
麦肯锡战略咨询经验.ppt
05-15
麦肯锡战略咨询经验.ppt
--fs-1: 7rem; --fs-2: 4.5rem; --fs-3: 3.6rem; --fs-4: 2.4rem; --fs-5: 2.2rem; --fs-6: 2rem; --fs-7: 1.6rem; --fs-8: 1.5rem; --fs-9: 1.4rem; --fs-10: 1.3rem; --fs-11: 1.2rem; --fw-500: 500; --fw-600: 600; --fw-700: 700; --fw-800: 800;这个是定义什么
06-12
这是 CSS 中使用自定义属性（CSS Variables）来定义一些字体大小和字重的变量。 其中，以 `--fs-` 开头的变量用来定义不同级别的字体大小，例如 `--fs-1` 定义了最大的字体大小为 7rem，而 `--fs-11` 则定义了最小...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值