当前位置: 首页 > news >正文

嵌入式0基础开始学习 ⅠC语言(2)运算符与表达式

1.运算符

      什么是运算符?
            用来进来某种运算的符号
            
        如:
             + - * / (取余,取模)          

        a,几目运算符

            根据其操作数的不同
            
            单目运算符
                       该运算符只需要带一个操作数
                       如: ++  -- &(取地址符)
                       
            双目运算符:
                       该运算符只需要带两个操作数
                       如: + - * /
            
            三目运算符:
                       该运算符需要带三个操作数
                       如:
                            a?b:c:
                               如果表达式a为真,那么整个表达式的值为b,否则整个
                               表达式的值为c

        b,结合性

             决定先算谁后算谁问题
             从左到右,从右到左
            
             如:
                   +结合性:从左到右
                         a+b
                              先算a的值,再算b的值
                              最后再算表达式a+表达式b的值
                              
                   =结合性:从右到左
                         a=b
                              先算b的值
                              再将b的值,写到变量a所对应的存储单元中去
                      
                        例子:
                                在c语言中,a+b,是否和b+a的含义一样呢?
                                    不一定,why?
                                 
                                    如:
                                            i=5,j=6
                                        (i++)+(i+j) =>5 + 6+6
                                        (i+j)+(i++) =>(5+6)+5                                        
                      

        c,优先级

                是指在一个含有多个运算符的表达式中,先算哪一个运算符,再算哪一个运算符。
                
                单目运算符 > 算术运算符 > 关系运算符 > 逻辑运算符 > 条件运算符 > 赋值运算符 > 逗号运算符
             
                (1)算术运算符
                            进行算术运算的运算符
                            
                        + -  * % / :双目运算符,结合性从左到右
                                
                            例子:
                                   5 /4 => 1(整数进行算术运算结果为整数)
                                   5.0 / 4 =>1.25
                                   
                                   typeof(5/4) =>int
                                   typeof(5.0/4)=>double
                                   
                                   (double)(3/2) => 1.0
                                   (double)3/2 =>1.5
                                   
                            思考:
                                   用c语言的表达式来描述数学表达式
                                        数学:
                                               a/b
                                        c语言中:
                                               (double)a /b
                                                1.0*a /b
                                                
                            %:  取余,求模
                                    规定,要求两个操作数都必须为整数
                                    
                                    5%4 => 1
                                    5%4.0=> ERROR
                                    4%5 =>4
                            
                            ++:
                                自增运算符
                                 i++//先使用i再++
                                 ++i//先++再使用i
                                
                            --:
                                自减运算符
                                i--
                                --i
                                
                            单目,要求操作数必须为一个”左值“(可写的地址)
                                例子:
                                       5++ =>ERROR
                                      (a+b)++ => ERROR
                                      
            表达式                  表达式的值                    做完这个表达式之后i的值
            i++                       i                                i = i+1
            ++i                       i+1                              i = i+1
            i--                       i                                i = i-1
            --i                       i-1                              i = i-1                            
                                
                        例子:
                              (1)int i =5;
                                   a= i++;//把表达式(i++)的值赋值给a,表达式i++的值为5
                                   printf("%d\n",a);//5
                                   printf("%d\n",i);//6
                                   
                                   int i =5;
                                   a = ++i;//把表达式(++i)的值赋值给a,表达式++i的值为6
                                   printf("%d\n",a);//6
                                   printf("%d\n",i);//6
                                   
                             (2)i =5;
                                (i++)+(i++)+(i++)
                                拒绝做此类题目!!!
                                因为它没有任何意义
                                如果老板要你们做这类题目
                                那就请你将你的BOSS直接炒鱿鱼
                                
                        
                (2)关系运算符
                            用来判断两个东西关系的运算符(大小关系)
                                 < > <= >= == !=
                                        都是属于双目运算符,结合性都是从左到右。
                                        
                        关系表达式:用关系运算符连接的式子。
                        关系表达式的值:
                                        关系成立 =>1
                                        关系不成立 =>0
                                        
                                    例子:
                                          表达式      表达式的值
                                           5>4            1
                                           3<=2           0
                                           0!=1           1
                                           5>4>3          0
                                          
                                        5>4>3:  是一个合法的表达式
                                                表达式的含义(5>4)>3
                                                拿表达式5>4的值,与3进行PK
                                            
                                            数学含义:
                                                   5>4 并且 4>3    
                                    问题?
                                           咱们能不能用c语言来描述数学上的5>4>3呢?
                                          涉及到 ”并且“如何来表达?
                                          
                 (3)逻辑运算符
                          用来描述逻辑关系的运算符
                               !      逻辑非       单目运算符      ”取反“
                                        !真 =>假
                                        !假 =>真
                              
                               &&      逻辑与       双目运算符       ”并且“    结合性从左到右
                               
                                        真&&真 =>  真
                                        真&&假 => 假
                                        假&&假 => 假
                                        假&&真 => 假

                               ||      逻辑或         双目运算符      ”或者“    结合性从左到右
                                         
                                        真||真 => 真
                                        真||假 => 真
                                        假||假 => 假
                                        假||真 => 真

                                    逻辑表达式:就是用逻辑运算符连接起来的式子
                                            逻辑表达式的值:
                                                            逻辑真(非0,1)
                                                            逻辑假 0

                                        例子:
                                               a = 4, b= 5;
                                               a&&b =>1
                                               a&&0 =>0
                                              (3+5)||(0) => 1
                                               !a || b =>1
                                               4&&0 || 2 =>1
                                               5>3 && 8<4-!0
                                               =>5>3 && 8<4-1
                                               =>5>3 && 8<3
                                               =>1&&0
                                               => 0      

                            练习:
                                   用逻辑表达式来判断y(输入的年份)是否为闰年
                                   (1)能被4整除,但是不能被100整除
                                   (2)能被400整除
                                   
                                    #include <stdio.h>
                                    int main()
                                    {
                                        int a;
                                        printf("请输入年份:");
                                        scanf("%d", &a);
                                        if(a%4==0&&a%100!=0||a%400==0)
                                        {
                                         printf("%d是闰年",a);
                                        }
                                        else
                                        {
                                         printf("%d不是闰年",a);
                                        }
                                        return 0;
                                    }

                                        分析一下代码的输出结构
                                        int a,b,c,d,m,n;
                                        a =1;
                                        b =2;
                                        c =3;
                                        d = 4;
                                        m =0;
                                        n= 0;
                                        (m=a<b)||(n=c<d);
                                        printf("%d\n",m);//1
                                        printf("%d\n",n);//0
                                        
                                        (m=a>b)&&(n=c<d);
                                        printf("%d\n",m);//0
                                        printf("%d\n",n);//0
                                        
                            C语言运算符是”惰性运算
                                    (1)a&&b&&c
                                                  只有a为真时,才去判断b的值
                                                  只有a,b都为真,才去判断c的值
                                                  
                                    (2)a||b||c
                                                  只要a为真,就不需要再去判断b,c的值
                                                  只有a为假,才需要去判断b的值
                                                  只有a和b都为假,才需要去判断c的值
                                                  
                                            如果事先知道表达式的值,那么后面的运算符(表达式)就不需要执行了
                                            ,这就是c语言运算符的”惰性“
                    
                (4)位运算符
                              位运算符是指按bit位来进行运算
                              位运算符要求操作数必须为整数
                                    有如下:
                                                &  按位与
                                                |  按位或
                                                ~  按位取反
                                                ^  按位异或
                                                << 按位左移
                                                >> 按位右移
                                                
                                            除了~是单目之外,其他的位运算符都是双目运算符,结合性都是从左到右
                                            
                                        位运算符操作数只能是整数
                                        所有的位运算都是把操作数变成bit序列,然后再按bit位来进行运算
                                        
                                    ~(按位取反)
                                               1 -> 0
                                               0 -> 1
                                               
                                            int a = ~3;
                                                    3:
                                                       00000000 00000000 00000000 00000011
                                                       
                                                    ~3;
                                                       11111111 11111111 11111111 11111100 <--a最终再计算机的存储形式
                                                       
                                                    %d:
                                                        符号位:
                                                                -1
                                                    逆运算:
                                                               负数:-4
                                                    %u: 2^32-4
                                                    
                                    &(按位与):
                                               
                                                a   b  a&b
                                                1   1   1
                                                0   1   0
                                                1   0   0
                                                0   0   0
                                            & 如果两个bit操作数都为1,其结果才为1,否则为0    
                                            
                                            例子:  int a =3 & 5;
                                                        8bits:
                                                                0000 0011 (3)
                                                                0000 0101 (5)
                                                              &----------------
                                                                0000 0001 (1)    
                                                练习:
                                                        写一个表达式
                                                        假设有一个整型变量a,要把a的第5个bit变成0,
                                                        其他的bit保持不变,该怎么操作?
                                                        a:
                                                            xxXxxxxx
                                                          & 11011111 <= ~(00100000) <= ~(1<<5)
                                                          
                                                          a = a& ~(1<<5);
                                                    结论:
                                                           一个bit位与0进行”按位与“的操作,结果为0
                                                            x&0 => 0
                                                           一个bit位与1进行”按位与“的操作,结果为原值
                                                            x&1 => x
                                    | 按位或:
                                                a   b  a|b
                                                0   0   0
                                                0   1   1
                                                1   0   1
                                                1   1   1
                                            | 按位或,只要有一个bit操作数为1,其结果就为1
                                              
                                                    例子:
                                                            int a = 3| 5;
                                                                8bits:
                                                                        0000 0011 (3)
                                                                        0000 0101 (5)
                                                                       |------------
                                                                        0000 0111 (7)

                                                练习;
                                                      写一个表达式
                                                      有一个整型变量a,要使a的第五位bit置1,其他的bit保持不变
                                                      该如何操作?
                                                       
                                                            a:
                                                                xxXxxxxx
                                                              | 00100000  <= (1<<5)
                                                                -----------
                                                            a:  xx1xxxxx
                                                            
                                                             a = a | (1<<5);
                                                            
                                                    结论:
                                                          一个bit位与0进行”按位或“的操作,结果为原值
                                                                x|0 => x
                                                          一个bit位与1进行”按位或“的操作,结果为1
                                                                x|1 => 1
                                                                
                                    ^ 按位异或:
                                                   a    b   a^b
                                                   0    0    0
                                                   1    0    1
                                                   0    1    1
                                                   1    1    0
                                                 "异或" :求异,不同为1,相同为0

                                                例子:
                                                        int a = 2 ^ 32;
                                                          8bits:
                                                                0000 0010 (2)
                                                                0010 0000 (32)
                                                             ^  ----------
                                                                0010 0010 (34)
                                                
                                                思考;
                                                     有一个整型变量a,要是a的第五位bit保留,其他的全部取反
                                                     该如何操作?
                                                            a:
                                                                xxXxxxxx
                                                                11011111                                                                
                                                            ^ ------------
                                                           
                                                            a = a^(~(1<<5))    
                                                    
                                                    结论:
                                                            一个bit位与0进行”按位异或“的操作,结果为原值
                                                                    x ^ 0 => x
                                                                                                   
                                                            一个bit位与1进行”按位异或“的操作,结果为原值取反      
                                                                       x ^ 1 => ~x                                    
                    

                                                    练习:
                                                          写一个程序,交换两个整数的值,不能使用临时变量
                                                          int a=6;
                                                          int b=5;
                                                          int temp;
                                                          
                                                          temp = a;
                                                          a = b;
                                                          b = temp;
                                                          
                                                          printf(a); //5
                                                          printf(b); // 6
                                                        ----------------------------------
                                                          a = a^b;
                                                          b = a^b;
                                                          a = a^b;
                                                    结论:
                                                          位运算只与当前位,没有进位,没有有借位
                                          

                                    <<  按位左移
                                            a << n  把a按bit序列整体左移n位。
                                            高位左移后,会多出来n个bit位,直接丢弃
                                            低位空出来的n个bit位,直接补0
                                        
                                            如果左移后,舍弃的高位都是0(连续的0)                                        
                                            那么左移n位,就表示在原有的基础上,乘以
                                            2的n次方
                                            
                                            例子:
                                                8bits:
                                                      1 << 4
                                                            1:   0000 0001                                                      
                                                           1<<4: 0001 0000  (1*2^4)
                                                32bits:           
                                                      7 << 8
                                                            7:  00000000 00000000 00000000 00000111
                                                           7<<8:00000000 00000000 00000111 00000000(7*2^8)
                                                           
                                    >> 按位右移
                                           x >> n 把x的bit序列整体往右移n个bits
                                           低位右移后,会多出n位,直接舍弃
                                           高位会空出n位,补什么?
                                                    对于有符号的数,高位全部补 符号位!!!!
                                                    对于无符号的数,高位直接补0                                                    
                                            
                                            练习:分析一下代码的输出结果
                                                  int a = -1;
                                                           -1;
                                                              11111111 11111111 11111111 11111111
                                                  a = a >> 31;
                                                           a >> 31:
                                                              11111111 11111111 11111111 11111111
                                                  printf("%d\n",a);// -1
                                                  printf("%u\n",a);// 2^32 -1
                                                  
                                                  unsigned int a = -1;
                                                            -1:
                                                              11111111 11111111 11111111 11111111
                                                  a = a>> 31;
                                                           a >> 31:
                                                              00000000 00000000 00000000 00000001                                                           
                                                  printf("%d\n",a);// 1
                                                  printf("%u\n",a);// 1
                                                                                              
                (5)赋值运算符    
                            = :     双目运算符,结合性从右到左
                           a = x;   先计算x的值,然后再把x的值,赋值给a
                           赋值运算符要求左边的操作数 必须为一个”可写的地址“(左值)
                           例子:
                                  5 = 5; //ERROR
                                  2 + 3 =5;//ERROR
                                  i++ = 6;//ERROR
                            
                            赋值表达式:由赋值运算符连接起来的式子。
                            赋值表达式的值:
                                           就是最后赋值给左边变量的那个值
                                
                                a = b =6;
                                     ==>先计算(b = 6)表达式的值,将其表达式的值赋值给a

                        复合赋值运算符
                                    赋值运算符和算术运算符,位运算符组成的复合的赋值运算符                        
                           
                                    如:
                                         += -= %= *= /=
                                         <<= >>= |= &= ^=    
                                      例子:
                                            a += 5
                                                  => a = a+5
                                            a += 5 +6
                                                  => a = a+(5+6)
                                                                                             
                                            a >>= n
                                                  => a =a>>n
                                                  
                    (6)条件运算符
                                   ? : 三目运算符
                                   表达式1 ? 表达式2 :表达式3        
                                   执行:
                                           如果表达式1的值为真,则整个表达式的值为表达式2的值
                                           如果表达式1的值为假,则整个表达式的值为表达式3的值

                                        例子:
                                                int a,b,c,d,m,n;
                                                a =1;
                                                b =2;
                                                c =3;
                                                d = 4;
                                                m =0;
                                                n= 0;
                                            a>b?(m=a+b):(n=c+d);
                                            printf("%d\n",m);//0
                                            printf("%d\n",n);//7
                    
                    (7)逗号运算符
                                  双目运算符,优先级是最低,结合性从左到右
                                表示式1 ,表达式2    
                                     执行:
                                            先求表达式1的值,然后再求表达式2的值
                                            整个逗号表达式的值 就是 表达式2的值
                                        例子:
                                               int a=5,b=6;
                                               a = (a = 6,a+b);
                                                    a => 12
                      
                    (8)指针运算符
                            & ->取地址符
                            * ->指向运算符
                                    &对象名:
                                             表示的含义是 取某某对象的地址    
                                    例子:
                                            int a;
                                            scanf("%d",&a);

                    (9)sizeof求字节运算符
                            单目运算符,求一个对象或类型的所占空间的字节数

                    (10)分量运算符
                          求结构体中的成员变量(分量)
                            ->
                            .
                    (11)下标运算符
                            []
                                数组名 [下标]:表示下标对应的哪一个数组元素    
                                
                    (12)强制类型转换运算符    
                                (类型)    

小练习:
     1.取整型变量x中的第p位开始的n个bit位
            x:
                xxxxXXXXxxxx
            x >> p :
                     xxxxxxxxXXXX
                     000000001111 < = (1<<n)-1                    
                   & ------------                
                     00000000XXXX
                x=(x>>p)&((1<<n)-1)
                
     2.将x中第p位开始的n个bit全部取反,其余各个位保持不变
             x:
                xxxxXXXXxxxx
                000011110000   <= ((1<<n)-1) << p
               ^------------                                              
                xxxx~(XXXX)xxxx
                
            x = x^((1<<n)-1) << p

     3.将x中第p位开始的n个bit位设置为y中的最右边的n位的值,
       x其余各个位保持不变
            x:
                xxxxXXXXxxxx
                111100001111 <= ~(((1<<n)-1) << p)
               &------------
                xxxxooooxxxx
                                
            
            y:
                yyyyyyyyYYYY
                000000001111 <=(1<<n)-1
               &------------
                00000000YYYY << p  
                xxxxooooxxxx
               |------------
                xxxxYYYYxxxx
                
            (x&~(((1<<n)-1) << p)) | ((y&(1<<n)-1) <<p)
            
  4.下列表达式中,正确的C赋值表达式是?(C)

A,a=7+b+c=a+7     B,a=7+b++=a+7

C,a=(7+b,b++,a+7)   D,a=7+b,c=a+7

5,以下程序语句运行结果为?(D)

int a;

printf("a=%d\n",a);

A,编译出错  B,1024 C,NULL D,不确定值

6,int b=0,x=1;执行语句if(x++)b=x+1;后,x,b的值依次为?(2,3)

7,sizeof(double)的结果是?(8)

8,设f是实型变量,下列表达式中不是逗号表达式的是?(D)

A,    f=3.2,1.0    B,   f>0,f<10   C,  f=2.0,f>0  D,  f=(3.2,1.0)

9,PC机中,'\n'在内存占用的字节数是?(1)

10,设c='w',a=1,b=2,d=-5,则表达式'x'+1>c,'y'!=c+2,-a-5*b<d+1,b==a=2的值分别为?

(1,0,1,编译错误)

11,判断变量a,b的值均不为0的逻辑表达式为?

(a!=0&&b!=0)

12,数学式a/(b*c)的c语言表达式是?

( double a/(b*c) )

13,以下程序运行后的输出结果是?(3)

#include

int main()

{

int a;

a=(int)((double)(3/2)+0.5+(int)1.99*2);

printf("%d\n",a);

}

14,在c语言中,如下程序输出的结果为?

char c=250;

unsigned char d;

char f;

d=c+249;

f=c+249;

printf("d=%d\n",d);                         //243

printf("d=%u\n",d);                         //243

printf("f=%d\n",f);                           //-13

printf("f=%u\n",f);                           //2的32次方-13

(  if短的是无符号的数,高位就直接补0 if短的是有符号的数,高位补符号位)

相关文章:

嵌入式0基础开始学习 ⅠC语言(2)运算符与表达式

1.运算符 什么是运算符&#xff1f; 用来进来某种运算的符号 如&#xff1a; - * / (取余&#xff0c;取模) a,几目运算符 根据其操作数的不同 单目运算符 该运算符…...

汇编语言(一)

寄存器&#xff1a;cpu中可以储存数据的器件&#xff08;AX&#xff0c;BX&#xff09; 汇编语言的组成&#xff1a;1.汇编指令 2.伪指令 3.其他符号 存储器&#xff1a;cpu&#xff0c;传入指令和数据&#xff0c;加以运算。&#xff08;内存&#xff09; 指令和数据&#…...

2010-2022年各省新质生产力数据(含原始数据+测算代码+计算结果)

2010-2022年各省新质生产力数据&#xff08;含原始数据测算代码计算结果&#xff09; 1、时间&#xff1a;2010-2022年 2、范围&#xff1a;31省 3、指标&#xff1a;gdp&#xff08;亿元&#xff09;、在岗职工工资&#xff1a;元、第三产业就业比重、人均受教育平均年限、…...

需求分析部分图形工具

描述复杂的事物时,图形远比文字叙述优越得多,它形象直观容易理解。前面已经介绍了用于建立功能模型的数据流图、用于建立数据模型的实体-联系图和用于建立行为模型的状态图,本节再简要地介绍在需求分析阶段可能用到的另外3种图形工具。 1 层次方框图 层次方框图用树形结…...

ML307R OpenCPU GPIO使用

一、GPIO使用流程图 二、函数介绍 三、GPIO 点亮LED 四、代码下载地址 一、GPIO使用流程图 这个图是官网找到的&#xff0c;ML307R GPIO引脚电平默认为1.8V&#xff0c;需注意和外部电路的电平匹配&#xff0c;具体可参考《ML307R_硬件设计手册_OpenCPU版本适用.pdf》中的描…...

python基于深度学习的聊天机器人设计

python基于深度学习的聊天机器人设计 开发语言:Python 数据库&#xff1a;MySQL所用到的知识&#xff1a;Django框架工具&#xff1a;pycharm、Navicat、Maven 系统功能实现 登录注册功能 用户在没有登录自己的用户名之前只能浏览本网站的首页&#xff0c;想要使用其他功能都…...

Golang设计模式(四):观察者模式

观察者模式 什么是观察者 观察者模式(Observer Pattern)&#xff1a;定义对象之间的一种一对多依赖关系&#xff0c;使得每当一个对象状态发生改变时&#xff0c;其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅&#xff08;Publish/Subscribe&#xf…...

huggingface 笔记:查看GPU占用情况

0 准备部分 0.1 创建虚拟数据 import numpy as npfrom datasets import Datasetseq_len, dataset_size 512, 512 dummy_data {"input_ids": np.random.randint(100, 30000, (dataset_size, seq_len)),"labels": np.random.randint(0, 1, (dataset_size…...

JavaSE 学习记录

1. Java 内存 2. this VS super this和super是两个关键字&#xff0c;用于引用当前对象和其父类对象 this 关键字&#xff1a; this 关键字用于引用当前对象&#xff0c;即调用该关键字的方法所属的对象。 主要用途包括&#xff1a; 在类的实例方法中&#xff0c;通过 this …...

HTML与CSS的学习

什么是HTML,CSS&#xff1f; HTML(HyperText Markup Language):超文本标记语言。 超文本:超越了文本的限制&#xff0c;比普通文本更强大。除了文字信息&#xff0c;还可以定义图片、音频、视频等 标记语言:由标签构成的语言 >HTML标签都是预定义好的。例如:使用<a>…...

【单片机】STM32F070F6P6 开发指南(一)STM32建立HAL工程

文章目录 一、基础入门二、工程初步建立三、HSE 和 LSE 时钟源设置四、时钟系统&#xff08;时钟树&#xff09;配置五、GPIO 功能引脚配置六、配置 Debug 选项七、生成工程源码八、生成工程源码九、用户程序下载 一、基础入门 f0 pack下载&#xff1a; https://www.keil.arm…...

源码编译安装Rsync数据同步

源码编译安装 RPM软件包&#xff1a;rpm -ivh 或者 yum -y install 需要开发编译工具gcc、gcc-c、make等... 源码包----开发工具gcc与make----》可以执行的程序-----》运行安装 •主要优点 –获得软件的最新版&#xff0c;及时修复bug –软件功能可按需选择/定制&#xff…...

SQL Server2019安装步骤教程(图文)_最新教程

一、下载SQL Server2019 1.到微软官网下载SQL Server Developer版本&#xff0c;官网当前的2019版本下载需要注册账号。 不想注册的朋友&#xff0c;可以选择从网盘下载&#xff1a;点击此处直接下载 2.下载之后先解压&#xff0c;解压后执行exe安装程序。打开之后的界面如下…...

【SpringBoot】SpringBoot中防止接口重复提交(单机环境和分布式环境)

&#x1f4dd;个人主页&#xff1a;哈__ 期待您的关注 目录 &#x1f33c;前言 &#x1f512;单机环境下防止接口重复提交 &#x1f4d5;导入依赖 &#x1f4c2;项目结构 &#x1f680;创建自定义注解 ✈创建AOP切面 &#x1f697;创建Conotroller &#x1f4bb;分布…...

零基础学Java(全170集)

课程概述 本课程旨在全面深化对 Java 语言的核心技术理解&#xff0c;并提升编程实践能力。课程内容涵盖以下关键领域&#xff1a; 掌握Java核心语法&#xff0c;为后续学习打下扎实的基础。熟练运用Java常用的类库与开发工具&#xff0c;提高开发效率与质量。解决面向对象编…...

摄像头应用测试

作者简介&#xff1a; 一个平凡而乐于分享的小比特&#xff0c;中南民族大学通信工程专业研究生在读&#xff0c;研究方向无线联邦学习 擅长领域&#xff1a;驱动开发&#xff0c;嵌入式软件开发&#xff0c;BSP开发 作者主页&#xff1a;一个平凡而乐于分享的小比特的个人主页…...

Golang框架HTTP客户端框架zdpgo_resty发送表单请求

核心代码 这里通过字典传递了一个简单的表单数据。 发送的是POST请求。 resp, err : client.R().SetFormData(map[string]string{"username": "jeeva","password": "mypass",}).Post("http://127.0.0.1:3333/login")fmt.P…...

【机器学习300问】99、多通道卷积神经网络在卷积操作时有哪些注意事项?

一、多通道卷积神经网络示例 还是以图像处理为例&#xff0c;如果你的目标不仅是分析灰度图像特性&#xff0c;还打算捕捉RGB彩色图像的特征。如下图&#xff0c;当面对一张66像素的彩色图像时&#xff0c;提及的“3”实际上是指红、绿、蓝三种颜色通道&#xff0c;形象地说&am…...

Rust之函数、单元测试

1、函数 类似于C函数。 1.1、普通函数 在Rust中&#xff0c;函数的定义使用fn关键字&#xff0c;后跟函数名、参数列表、返回类型和函数体。函数体由一系列语句组成&#xff0c;用于执行特定的操作和计算。 函数定义&#xff1a; 使用fn关键字定义函数&#xff0c;函数由函数…...

Linux环境下TensorFlow安装教程

TensorFlow是学习深度学习时常用的Python神经网络框 下面以Mask R-CNN 的环境配置为例&#xff1a; 首先进入官网&#xff1a;www.tensorflow.org TensorFlow安装的总界面&#xff1a; 新建anaconda虚拟环境&#xff1a; conda create -n envtf2 python3.8 &#xff08;Pyth…...

Python|GIF 解析与构建(5):手搓截屏和帧率控制

目录 Python&#xff5c;GIF 解析与构建&#xff08;5&#xff09;&#xff1a;手搓截屏和帧率控制 一、引言 二、技术实现&#xff1a;手搓截屏模块 2.1 核心原理 2.2 代码解析&#xff1a;ScreenshotData类 2.2.1 截图函数&#xff1a;capture_screen 三、技术实现&…...

龙虎榜——20250610

上证指数放量收阴线&#xff0c;个股多数下跌&#xff0c;盘中受消息影响大幅波动。 深证指数放量收阴线形成顶分型&#xff0c;指数短线有调整的需求&#xff0c;大概需要一两天。 2025年6月10日龙虎榜行业方向分析 1. 金融科技 代表标的&#xff1a;御银股份、雄帝科技 驱动…...

【杂谈】-递归进化:人工智能的自我改进与监管挑战

递归进化&#xff1a;人工智能的自我改进与监管挑战 文章目录 递归进化&#xff1a;人工智能的自我改进与监管挑战1、自我改进型人工智能的崛起2、人工智能如何挑战人类监管&#xff1f;3、确保人工智能受控的策略4、人类在人工智能发展中的角色5、平衡自主性与控制力6、总结与…...

React Native 导航系统实战(React Navigation)

导航系统实战&#xff08;React Navigation&#xff09; React Navigation 是 React Native 应用中最常用的导航库之一&#xff0c;它提供了多种导航模式&#xff0c;如堆栈导航&#xff08;Stack Navigator&#xff09;、标签导航&#xff08;Tab Navigator&#xff09;和抽屉…...

令牌桶 滑动窗口->限流 分布式信号量->限并发的原理 lua脚本分析介绍

文章目录 前言限流限制并发的实际理解限流令牌桶代码实现结果分析令牌桶lua的模拟实现原理总结&#xff1a; 滑动窗口代码实现结果分析lua脚本原理解析 限并发分布式信号量代码实现结果分析lua脚本实现原理 双注解去实现限流 并发结果分析&#xff1a; 实际业务去理解体会统一注…...

Swagger和OpenApi的前世今生

Swagger与OpenAPI的关系演进是API标准化进程中的重要篇章&#xff0c;二者共同塑造了现代RESTful API的开发范式。 本期就扒一扒其技术演进的关键节点与核心逻辑&#xff1a; &#x1f504; 一、起源与初创期&#xff1a;Swagger的诞生&#xff08;2010-2014&#xff09; 核心…...

.Net Framework 4/C# 关键字(非常用,持续更新...)

一、is 关键字 is 关键字用于检查对象是否于给定类型兼容,如果兼容将返回 true,如果不兼容则返回 false,在进行类型转换前,可以先使用 is 关键字判断对象是否与指定类型兼容,如果兼容才进行转换,这样的转换是安全的。 例如有:首先创建一个字符串对象,然后将字符串对象隐…...

基于Java+MySQL实现(GUI)客户管理系统

客户资料管理系统的设计与实现 第一章 需求分析 1.1 需求总体介绍 本项目为了方便维护客户信息为了方便维护客户信息&#xff0c;对客户进行统一管理&#xff0c;可以把所有客户信息录入系统&#xff0c;进行维护和统计功能。可通过文件的方式保存相关录入数据&#xff0c;对…...

JavaScript 数据类型详解

JavaScript 数据类型详解 JavaScript 数据类型分为 原始类型&#xff08;Primitive&#xff09; 和 对象类型&#xff08;Object&#xff09; 两大类&#xff0c;共 8 种&#xff08;ES11&#xff09;&#xff1a; 一、原始类型&#xff08;7种&#xff09; 1. undefined 定…...

华为OD机试-最短木板长度-二分法(A卷,100分)

此题是一个最大化最小值的典型例题&#xff0c; 因为搜索范围是有界的&#xff0c;上界最大木板长度补充的全部木料长度&#xff0c;下界最小木板长度&#xff1b; 即left0,right10^6; 我们可以设置一个候选值x(mid)&#xff0c;将木板的长度全部都补充到x&#xff0c;如果成功…...