C语言学习初级阶段

2024-05-10 10:44
文章标签 语言 学习 初级阶段

本文主要是介绍C语言学习初级阶段，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 一、运算符与表达式
    • 1.1、运算符分类
    • 1.2、关系运算符与关系表达式
    • 2.1、逻辑运算符与逻辑表达式
    • 2.2、赋值运算符
    • 2.3、求字节运算符
  • 二、选择、循环
    • 2.1、选择if-else讲解.
      • 2.1.1、关系表达式与逻辑表达式
    • 2.2、while、for、continue、break讲解
      • 2.2.1、while循环
      • 2.2.2、for循环
      • 2.2.3、continue语句
      • 2.2.4、break语句
  • 三、一维数组与字符数组
    • 3.1、一维数组
      • 3.1.1、数组的定义
      • 3.1.2、一维数组在内存中的存储
    • 3.2、数组访问越界与数组的传递
      • 3.2.1、数组的访问越界
      • 3.2.2、数组的传递
    • 3.3、字符数组与scanf读取字符串
      • 3.3.1、字符数组的初始化与传递
      • 3.3.2、scanf读取字符串
    • 3.4、gets与puts讲解，strlen-strcmp-strcpy讲解
      • 3.4.1、gets函数与puts函数
      • 3.4.2、str系列字符串操作数（需要导入string.h库）
  • 四、指针
    • 4.1、指针的本质（间接访问原理）
      • 4.1.1、指针的定义
      • 4.1.2、取地址操作符与取值操作符，指针本质
    • 4.2、指针的传递使用场景
      • 4.2.1、指针的传递
    • 4.3、指针的偏移使用场景
      • 4.3.1、指针的偏移
      • 4.3.2、指针与一维数组
    • 4.4、指针与malloc动态内存申请，栈与堆的差异
      • 4.4.1、指针与动态内存申请
      • 4.4.2、堆与栈的差异
  • 五、结构体与C++引用
    • 5.1、结构体-结构体对齐-结构体数组
      • 5.1.1、结构体的定义、初始化、结构体数组
      • 5.1.2、结构体对齐
    • 5.2、结构体指针与typedef的使用
      • 5.2.1、结构体指针
      • 5.2.2、typedef的使用
    • 5.3、C++引用
      • 5.3.1、C++引用的讲解
      • 5.3.2、C++的布尔类型
  • 运算符优先级表

一、运算符与表达式

1.1、运算符分类

  • 乘、除、取余运算符的优先级高于加、减运算符。
  • 除%运算符外，其余几种运算符既适用于浮点型数又适用于整型数。当操作符/的两个操作数都是整型数时，它执行整除运算，在其他情况下执行浮点型数除法。
  • %运算只可以用于整型数

1.2、关系运算符与关系表达式

  • 关系运算符符>、<、==、>=、<=、!=
  • 关系运算符的优先级低于算数运算符
  • 从左往右计算
  • 关系表达式的值只有真和假，对应的值为1和0
  • 0代表假，非0代表真，例如-5代表真，6代表真
  • if(3<a && a<10)先算3<a,如果a为4，则返回值是1
    错误实例if(3<a<10)无论 a 是大于 3 还是小于 3，对于 3<a 这个表达式只有 1 或 0 两种结果，1和0都是小于10的。

2.1、逻辑运算符与逻辑表达式

  • 逻辑运算符!、&&、ll依次为逻辑非、逻辑与、逻辑或,
  • 逻辑非！的优先级高于算术运算符，逻辑与和逻辑或的优先级低于关系运算符.
  • 短路运算式逻辑与和逻辑或
  • 逻辑非是单目运算符，只需要跟一个操作数 例如：!操作数
#include <stdio.h>
int main()
{int i=1;i&&printf("you can not see me\n");//当i为假时，不会执行逻辑与后的表达式，称为短路运算。i||printf("you can not see me\n");//如果i为假，逻辑或会执行后面的内容。如果i为真，整体则为真，则后面的内容不会再继续执行。//逻辑或运算，一个为真，则整体为真，//一个为假，另一个为真，整体为真return 0;
}

2.2、赋值运算符

  • 只有变量才能称为左值，例如：等号左边只可以放变量
  • inum=inum +5 =》 inum+=5

2.3、求字节运算符

  • sizeof是求字节运算符，不是函数
  • sizeof用于求变量或常量所占用空间的大小

二、选择、循环

2.1、选择if-else讲解.

2.1.1、关系表达式与逻辑表达式

5>3&&8<4-!0
在这里插入图片描述

2.2、while、for、continue、break讲解

2.2.1、while循环

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
int main()
{
int i=1,total=0;
while(i<100)//在这里加分号会造成死循环
{total=total+i;//把i加到total上i++;//等价于i=i+1  在循环体内没有让while判断表达式趋近于假的操作，死循环}
printf(total);
}

2.2.2、for循环

在这里插入图片描述

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,total;
for(i=1,total=0;i<=100;i++)//如果在这行代码加上分号结果是不对的，结果为101，原因是达到100之后，才会执行下面的语句。
{total=total+1;
}
printf(total);
}

2.2.3、continue语句

  • 作用：结束本次循环，即跳过本次循环体中下面未执行的语句，接着进行是否执行下一次循环的判断
#include <stdio.h>
#include <stdlib.h>
//从1到100求和
int main()
{
int i,total;
for(i=1,total=0;i<=100;i++)//如果在这行代码加上分号结果是不对的，结果为101，原因是达到100之后，才会执行下面的语句。
{if(i%2==0){continue;//continue下面的语句均不会得到执行}total+=1;
}
printf(total);
}

2.2.4、break语句

  • break语句的作用是结束整个循环过程，不再判断执行循环的条件是否成立.
#include <stdio.h>
#include <stdlib.h>int main()
{int i, total;for (i = 1, total = 0; i <= 100; i++) {if (total > 2000){break;}total += i;}printf("total=%d,i=%d\n",total, i);return 0;
}

注意：不可以这样写printf(total, i); 括号里面的format位置必须要有参数。

三、一维数组与字符数组

3.1、一维数组

3.1.1、数组的定义

（1）具有相同的数据类型。
（2）使用过程中需要保留原始数据。
在这里插入图片描述

  • 常量表达式中可以包含常量和符号常量，但不能包含变量

在这里插入图片描述

3.1.2、一维数组在内存中的存储

在这里插入图片描述

3.2、数组访问越界与数组的传递

3.2.1、数组的访问越界

#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[5]={1,2,3,4,5};
int j=20;
int i=10;
a[5]=6;//访问越界
a[6]=7;
printf("i=%d",i);//i并没有赋值，但是值发生了变化
return 0;
}

输出结果为：i=7. 但是并没有改变i的值，为什么变成了7？
在这里插入图片描述
在这里插入图片描述

上图所示，其实a[6]是没有的，那两个位置应该是i和j的值，但是a[6] 把i和j给顶替了。

3.2.2、数组的传递

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
//数组传递到子函数后，子函数的形参接收到的是数组的起始地址，因此不能把数组的长度传递给子函数
void print(int a[],int length){ //这里写a[5]、a[6]等都是没有用的 因为数组的长度是无法传递的int i;for(i=0;i<length;i++){printf("%3d\n",a[i]);}a[3]=20;printf("\n");
}
int main()
{int a[5]={1,2,3,4,5};print(a,5);//打印的是全部的数组里面的值   如果写a[2]则打印的是具体的值 printf("a[3]=%d",a[3]); return 0;
}

3.3、字符数组与scanf读取字符串

3.3.1、字符数组的初始化与传递

在这里插入图片描述
因为字符数组一般用来存取字符串。通常采用的初始化方式是 char c[10]= “hello”。因为 C 语言规定字符串的结束标志为’\0’，而系统会对字符串常量自动加一个’\0’，为了保证处理方法一致，一般会人为地在字符数组中添加’\0’，所以字符数组存储的字符串长度必须比字符数组少 1 字节。例如，char c[10]最长存储 9 个字符，剩余的 1个字符用来存储’\0’。

  • c[10]表示的是这个数组里面有10个字符 表示的是长度
#include <stdio.h>
#include <stdlib.h>
//模拟printf（%s,c）的操作
void print(char d[])
{int i = 0;while (d[i])//当走到结束时，循环结束{printf("%c\n", d[i]);i++;}printf("\n");
}
//输出字符乱码时，去看字符数组是否存储了结束符'\0'
int main()
{char c[5] = {'h', 'e', 'l', 'l', 'o'}; // 这种方式初始化字符数组，这种方式没有结束符  char c[5]="hello" 这种方式也会出现乱码char d[5] = "how";printf("%c\n", c); // 会发现打印了乱码，因为%c读取不到结束符，会出现乱码的情况printf("%s\n", d);print(d);return 0;
}

3.3.2、scanf读取字符串

#include <stdio.h>
#include <stdlib.h>
//scanf读取字符串操作，会自动往字符数组中放结束符
int main(){char c[10];scanf("%s",c);//字符数组名c中存储了数组的起始地址  %s代表的是字符串 %c是字符 //%s遇到空格就会认为已经结束了 停止读取后面的字符  自动忽略空格printf("%s\n",c);
}

scanf 通过%s 读取字符串，对 c 和 d 分别输入"are"和"you"（中间加一个空格），scanf
在使用%s 读取字符串时，会忽略空格和回车（这一点与%d 和%f 类似）

3.4、gets与puts讲解，strlen-strcmp-strcpy讲解

3.4.1、gets函数与puts函数

gets函数格式：char *gets(char *str);
scanf是遇到空格就不再读取
gets一次读取一行，gets遇到\n 后，不会存储\n，而是将其翻译为空字符’\0’

#include <stdio.h>
#include <stdlib.h>
int main()
{char a [20];gets(a);//gets中放入我们字符数组的数组名即可  //gets一次读取一行printf("%s\n",a);return 0;
}

puts只能输出字符串，且括号里面只能放数组名。
puts等价于printf(“%s\n”,c);

3.4.2、str系列字符串操作数（需要导入string.h库）

strlen函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{int len;char c[20];gets(c);puts(c);len=strlen(c);//统计字符串长度，\0是作为结束符 不统计在字符串长度之内printf("len=%d\n",len);}

自定义函数mystrlen

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int mystrlen(char c[20])
{int i=0;while(c[i])//找到结束符后 循环结束{i++;}return i;
}
int main()
{int len;char c[20];gets(c);puts(c);len=strlen(c);//统计字符串长度，\0是作为结束符 不统计在字符串长度之内printf("len=%d\n",len);len=mystrlen(c);printf("my len=%d\n",len);return 0;}

strcat函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{int len;char c[20];char d[100];gets(c);puts(c);len=strlen(c);//统计字符串长度，\0是作为结束符 不统计在字符串长度之内printf("len=%d\n",len); strcat(c,d);//把d的内容拼接到c中//不可以放字符串常量puts(c);return 0;}

strcpy函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{int len;char c[20];char d[100];gets(c);puts(c);len=strlen(c);//统计字符串长度，\0是作为结束符 不统计在字符串长度之内printf("len=%d\n",len); strcpy(c,d);//把c中的字符串复制到e中//不可以放字符串常量puts(c);return 0;}

strcmp函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main()
{int len;char c[20];char d[100];gets(c);puts(c);len=strlen(c);//统计字符串长度，\0是作为结束符 不统计在字符串长度之内printf("len=%d\n",len); printf("c?d=%d\n",strcmp(c,d));//或者可以写成strcmp（c,"how"）；//c>how 返回值是正值  相等为0  小于返回-1   return 0;}

四、指针

4.1、指针的本质（间接访问原理）

4.1.1、指针的定义

  • 指针变量才可以存储地址
  • 定义格式： 基类型 *指针变量名
  • 指针：一个变量的地址
  • 指针变量：一个变量，专门用来存放另一变量的地址（即指针）

4.1.2、取地址操作符与取值操作符，指针本质

  • 取地址操作符：&，也叫引用，通过这个操作符可以获得一个变量的地址
  • 取值操作符：*，也叫解引用，通过这个操作符可以获得一个地址对应的数据
    在这里插入图片描述
    在这里插入图片描述
  • 声明3个指针变量：int *a,*b,*c
  • int *a,b,c 表示的是 int *a，int b，int c

4.2、指针的传递使用场景

4.2.1、指针的传递

  • 形参是变量
  • 函数调用就是值传递
#include <stdio.h>
#include <stdlib.h>
#include <string.h>void change(int *j)//j是形参
{*j=5;
}
int main(){int i=10;printf("before change i=%d\n",i);change(&i);//c语言的函数调用是值传递，实参赋值给形参，j=iprintf("after change i=%d\n",i);return 0;}

在这里插入图片描述

4.3、指针的偏移使用场景

4.3.1、指针的偏移

如下图所示，数组名中存储着数组的起始地址Ox61fdf0，其类型为整型指针，所以可以将其赋值给整型指针变量p，可以从监视窗口中看到p+1的值为Ox61fdf4。那么为什么加1后不是Ox61fdf1呢?因为指针变量加1后，偏移的长度是其基类型的长度，也就是偏移sizeof(int)，这样通过*p+1就可以得到元素a[1].编译器在编译时，数组取下标的操作正是转换为指针偏移来完成
在这里插入图片描述

4.3.2、指针与一维数组

为什么一维数组在函数调用进行传递时,它的长度子函数无法知道呢?
这是由于一维数组名中存储的是数组的首地址．如下例所示，数组名c中存储是一个起始地址，所以子函数change 中其实传入了一个地址.
定义一个指针变量时，指针变量的类型要和数组的数据类型保持一致，通过取值操作，就可将“h”改为“H”，这种方法称为指针法.获取数组元素时，也可以通过取下标的方式来获取数组元素并进行修改，这种方法称为下标法。

#include <stdio.h>
void change(char *d)
{*d='H';d[1]='E';  //与*(d+1)='E'等价*(d+2)='L';
}
int main()
{char c[10]="hello";change(c);puts(c);return 0;
}

4.4、指针与malloc动态内存申请，栈与堆的差异

4.4.1、指针与动态内存申请

C语言的数组长度固定是因为其定义的整型、浮点型、字符型变量、数组变量都在栈空间中，而栈空间的大小在编译时是确定的、如果使用的空间大小不确定，那么就要使用堆空间。

#include <stdio.h>
#include <stdlib.h>//malloc使用的头文件
#include <string.h>int main()
{int size;//size表示申请的空间的大小char *p;//void *类型的指针不能偏移，因此不会定义无类型指针scanf("%d",&size);//输入要申请的空间大小//malloc返回的void*代表无指针类型p=(char *)malloc(size);//p[0]='H';//p[1]='0';//p[2]='w';//p[3]='\0';strcpy(p,"malloc succceed");puts(p);free(p);//释放申请空间时，给的地址必须是最初malloc返回给我们的地址//	free(p+1);错误  必须要和之前的值相同，不能改变return 0;

4.4.2、堆与栈的差异

堆是一个动态的。

#include <stdio.h>	
#include <string.h>
#include <stdlib.h>
char *print_stack()
{char c[100]="I am print_stack";puts(c);return c;
}
cahr *print_malloc()
{cahr *p=(char*)malloc(100);strcpy(p,"I am print_malloc");puts(p);return p;
}
int main()
{char *p;p=print_stack();puts(p);p=print_malloc();puts(p);free(p);//只有free时，堆空间才会释放return 0;
}

五、结构体与C++引用

5.1、结构体-结构体对齐-结构体数组

5.1.1、结构体的定义、初始化、结构体数组

声明结构体类型的一般形式：

struct 结构体名{成员列表};//下面是一个例子
struct student
{int num;char name[20];char sex;int age;float score;char addr[30];
};

先声明结构体类型，再定义变量名，例如struct student student1,student2;
结构体的scanf输入和输出

#include <stdio.h>
struct student
{/* data */int num;char name[20];char sex;int age;float score;char addr[30];};//结构体类型声明时，后面一定要加分号
int main()
{struct student s={1001,"lele",'M',20,85.4,"Shenzhen"};//最好不能让变量名和结构体名一样struct student sarr[3];//定义一个结构体数组变量int i;//结构体输出，必须单独访问内部的每个成员printf("%d %s %c %d %f %s\n",s.num,s.name,s.sex,s.age,s.score,s.addr);//要用点.  作用是成员选择运算符for(i=0;i<3;i++){scanf("%d%s %c%d%f%s",&sarr[i].num,sarr[i].name,&sarr[i].sex,&sarr[i].age,&sarr[i].score,sarr[i].addr);//s.name是一个数组不需要取地址，因为里面自带的有地址 }for(i=0;i<3;i++){printf("%d %s %c %d %f %s\n",sarr[i].num,sarr[i].name,sarr[i].sex,sarr[i].age,sarr[i].score,sarr[i].addr);}//scanf("%d%s %c%d%f%s",&s.num,s.name,&s.sex,&s.age,&s.score,s.addr);//s.name是一个数组不需要取地址，因为里面自带的有地址 return 0;}

5.1.2、结构体对齐

结构体的大小必须是其最大成员的整数倍。

#include <stdio.h>
#include <stdlib.h>
struct student_type1{double score;//double是一个浮点类型 8个字节  浮点分为float和double   float占4个字节   8short age; //short是整型占2个字节 跟int一样，int占4个字节               2
};
struct student_type2{double score;//double是一个浮点类型 8个字节  浮点分为float和double  8char height;     //如果2个小存储之和是小于最大长度8，那么他们就结合在一起，看成2个short age;                      //2
};
struct student_type3{int height;  //4char sex;       //1    short age;      //2
};
int main()
{struct student_type1 s1;struct student_type2 s2;struct student_type3 s3;printf("s1 size=%d\n",sizeof(s1));printf("s2 size=%d\n",sizeof(s2));printf("s3 size=%d\n",sizeof(s3));return 0;
}
//输出结果如下
s1 size=16
s2 size=16
s3 size=8

5.2、结构体指针与typedef的使用

5.2.1、结构体指针

一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设置一个指针变量，
用它指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。
指针变量也可以用来指向结构体数组中的元素，从而能够通过结构体指针快速访问结构体内的每个成员

#include <stdio.h>
//结构体指针的练习
struct student{int num;char name[20];char sex;
};
int main()
{struct student s={1001,"wangle",'M'};struct student sarr[3]={1001,"lilei",'M',1005,"zhangsan",'M',1007,"lili",'F'};struct student *p;//定义了一个结构体指针变量p=&s;printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式一通过结构体指针访问成员printf("%d %s %c\n",p->num,p->name,p->sex);//方式二，大部分用这种p=sarr;//等价于p=&sarr[0];printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式一通过结构体指针访问成员printf("%d %s %c\n",p->num,p->name,p->sex);//方式二，大部分用这种printf("---------------------------------------------\n");p=p+1;printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex);//方式一通过结构体指针访问成员printf("%d %s %c\n",p->num,p->name,p->sex);//方式二，大部分用这种return 0;
}//结果如下
1001 wangle M
1001 wangle M
1001 lilei M
1001 lilei M
---------------------------------------------
1005 zhangsan M
1005 zhangsan M

5.2.2、typedef的使用

前面定义结构体变量时使用的语句是 struct student s，以这种方式来定义结构体变量有些
麻烦，即每次都需要写 struct student。那么有没有简单一些的定义方式呢？答案是肯定的，可以选择使用 typedef 声明新的类型名来代替已有的类型名

#include <stdio.h>
//结构体指针
typedef struct student
{int num;char name[20];char sex;
}stu,*pstu;//stu是struct student的别名
//stu等价于 struct student , pstu等价于struct student*typedef int INTEGER;
int main(){stu s={1001,"wangle",'M'};pstu p;//定义了一个结构体指针变量INTEGER i=10;//stu *p=&s;//定义了一个结构体指针变量p=&s;printf("i=%d,p->num=%d\n",i,p->num);return 0;
}
//结果如下
i=10,p->num=1001

使用 stu 定义结构体变量和使用 struct student 定义结构体变量是等价的；使用 INTEGER
定义变量 i 和使用 int 定义变量 i 是等价的；pstu 等价于 struct student*，所以 p 是结构体指针变量

5.3、C++引用

5.3.1、C++引用的讲解

#include <stdio.h>
//当你在子函数中要求改主函数中变量的值就要引用，不修改就不需要写引用&
void modify_num(int &b)//形参中写&要称为引用
{b=b+1;
}
//在子函数内修改主函数的普通变量的值
int main()
{int a=10;modify_num(a);printf("after modifyt_num=%d\n",a);return 0;
}
#include <stdio.h>
void modify_num(int *&p,int *q)  //引用必须和变量名紧邻 
{p=q;
}
//子函数内修改主函数的一级指针变量
int main()
{int *p=NULL;int i=0;int *q=&i;modify_num(p,q);printf("after_num:%d\n",*p);return 0;
}

5.3.2、C++的布尔类型

布尔类型在 C 语言没有，是C++的，只有true和false

#include <stdio.h>
int main()
{bool a=true;bool b=false;printf("a=%d,b=%d\n",a,b);return 0;
}

运算符优先级表

在这里插入图片描述

这篇关于C语言学习初级阶段的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/976222。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
学习hash总结

学习hash总结

2014/1/29/   最近刚开始学hash，名字很陌生，但是hash的思想却很熟悉，以前早就做过此类的题，但是不知道这就是hash思想而已，说白了hash就是一个映射，往往灵活利用数组的下标来实现算法，hash的作用：1、判重；2、统计次数；
阅读更多...
零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

介绍 R语言的扩展物种堆积图是一种数据可视化工具，它不仅展示了物种的堆积结果，还整合了不同样本分组之间的差异性分析结果。这种图形表示方法能够直观地比较不同物种在各个分组中的显著性差异，为研究者提供了一种有效的数据解读方式。 加载R包 knitr::opts_chunk$set(warning = F, message = F)library(tidyverse)library(phyl
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

透彻！驯服大型语言模型（LLMs）的五种方法，及具体方法选择思路

引言 随着时间的发展，大型语言模型不再停留在演示阶段而是逐步面向生产系统的应用，随着人们期望的不断增加，目标也发生了巨大的变化。在短短的几个月的时间里，人们对大模型的认识已经从对其zero-shot能力感到惊讶，转变为考虑改进模型质量、提高模型可用性。 「大语言模型(LLMs)其实就是利用高容量的模型架构（例如Transformer）对海量的、多种多样的数据分布进行建模得到，它包含了大量的先验
阅读更多...
【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络（1）sklearn

系列文章目录 监督学习：参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归（SAheart.csv） 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2