Go vs C++ vs python

Go vs C++ vs python 基础知识对比

回顾一下这几个软件的基础知识吧，也算对过去一年的总结。ps.都是最基本的东西，同时对比也看一下各语言的差别。

简介

Python是一种高级编程语言，它非常适合于快速开发和原型设计。它也被称为解释型语言，因为它的代码在运行时被解释成机器代码。

Go是由Google开发的一种静态类型的编程语言。它在系统编程、网络编程和并发编程方面表现出色。

C++是一种高效的系统级静态类型编程语言，广泛用于开发操作系统、游戏和高性能应用程序。

一、变量和常量

变量和常量是编程中必不可少的部分，也是很好理解的一部分。

标识符

标识符就是我们在程序中需要用到的变量、常量、函数、属性、类、模块等需要我们来自己定义的名字

Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头。 举几个例子：abc, _, _123, a123

标识符都是一样的。

关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。

Go语言中有25个关键字：

    break        default      func         interface    select
    case         defer        go           map          struct
    chan         else         goto         package      switch
    const        fallthrough  if           range        type
    continue     for          import       return       var

此外，Go语言中还有37个保留字。

    Constants:    true  false  iota  nil

        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error

    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

python内置的关键字有33个

help("keywords")

# python3结果
False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

c++ 关键字ps c++对多

alignas         alignof         and             and_eq          asm
auto            bitand          bitor           bool            break
case            catch           char            char16_t        char32_t
class           compl           const           constexpr       const_cast
continue        decltype        default         delete          do
double          dynamic_cast   else            enum            explicit
export          extern          false           float           for
friend          goto            if              inline          int
long            mutable         namespace       new             noexcept
not             not_eq          nullptr         operator        or
or_eq           private         protected       public          register
reinterpret_cast    return      short           signed          sizeof
static          static_assert  static_cast    struct           switch
template        this            thread_local   throw           true
try             typedef        typeid          typename        union
unsigned        using           virtual         void           volatile
wchar_t         while

变量

Go语言的变量声明格式为：

var 变量名 变量类型

var name string = "zax"
var age int = 123
var isOk bool = false

//批量声明
var (
    a string
    b int
    c bool
    d float32
)
// 切片、函数、指针变量的默认为nil

//此外go支持类型推导 
var name = "Q1mi"
var age = 18

//在函数内部，可以使用更简略的 := 方式声明并初始化变量. 注意是函数内部
func main() {
	n := 10
	m := 200 // 此处声明局部变量m
	fmt.Println(m, n)
}

//匿名变量
//在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示
x, _ := foo()

//匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
// 函数外的每个语句都必须以关键字开始（var、const、func等）
// :=不能使用在函数外。
// _多用于占位，表示忽略值。

python语言的变量声明格式为:

my_variable = 42
name = "zax"

#批量声明
x, y, z = 1, 2, 3

//匿名变量
_, y = 1, 2

c++语言的变量声明格式为:

int myVariable = 42;
char a = 'a';

//批量声明
int x = 1, y = 2, z = 3;

//C++11 引入 auto 用来让编译器根据上下文自动推导变量类型的
auto x = 42;
//这将声明一个变量 x，并将其类型自动推导为 int

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值， 常量的值必须在编译时确定

go：

//常量的声明和变量声明非常类似，只是把`var`换成了`const`，常量在定义的时候必须赋值
const pi = 3.1415
const e = 2.7182

//const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：
const (
    n1 = 100
    n2
    n3
) 
//上面示例中，常量n1、n2、n3的值都是100。

//iota是go语言的常量计数器，只能在常量的表达式中使用 --------定义枚举时很有用

//iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0

python:

#Python 没有内置的常量类型，通常使用全大写字母来表示常量，但实际上它们仍然是变量，只是惯例上不会在程序中改变它们的值

MY_CONSTANT = 3.14

#可以通过 enum 或者 class 来模拟常量
from enum import Enum

class MyConstants(Enum):
    MY_CONSTANT = 3.14
    
class MyConstants:
    MY_CONSTANT = 3.14

c++

//使用 #define 来定义常量
#define MY_CONSTANT 3.14

//但是，使用 #define 宏定义时，没有类型检查，容易引起错误，也不易于维护，不太推荐使用。在 C++11 引入了 constexpr 关键字，可以用来定义常量表达式。

constexpr double MY_CONSTANT = 3.14;

//使用 const 来定义常量
const double MY_CONSTANT = 3.14;

//在 C++ 中，可以使用 enum 来定义常量。
enum MyConstants {
    MY_CONSTANT = 3.14
};

constexpr 和 const 都可以用来定义常量，但是有一些区别。

//const 定义的常量可以是编译时常量或运行时常量，而 constexpr 定义的常量必须是编译时常量
//constexpr 可以提高代码的性能和安全性

//constexpr 可以用于函数、类的成员函数以及构造函数，而 const 只能用于变量.
constexpr int result = factorial(5); // 在编译期间求值

constexpr int factorial(int n) {
    return n <= 1 ? 1 : (n * factorial(n - 1));
}


//下面是一个使用编译时常量的例子，定义了一个 constexpr 常量 k，在编译期间就能计算出其值：
constexpr int k = 10; // 编译时常量
int arr[k]; // 可以用 k 定义数组大小

//下面是一个使用运行时常量的例子，定义了一个 const 常量 n，需要在运行时分配内存：
const int n = 100; // 运行时常量
int arr[n]; // 需要在运行时分配内存

//对于类的成员函数和构造函数，constexpr 表示函数可以在编译期间被计算，而 const 表示函数不会修改类的成员变量
class Point {
public:
    constexpr Point(int x, int y) : x_(x), y_(y) {}

    int x() const { return x_; } // const 表示不会修改类的成员变量
    int y() const { return y_; } // const 表示不会修改类的成员变量

private:
    int x_;
    int y_;
};

constexpr Point p(1, 2); // 编译时计算 Point 对象的值


constexpr 变量模板
template <typename T>
constexpr T pi = T(3.1415926535897932385);

double area = pi<double> * r * r; // 计算圆的面积

全局变量和局部变量

全局变量定义在函数外部，可以在程序的任何地方访问，而局部变量定义在函数内部，只能在函数内部访问。

go:

//全局变量需要显式地使用 var 关键字来声明，而局部变量则可以使用简短声明（short variable declaration）的方式来声明
package main

import "fmt"

var globalVar = 10

func main() {
    localVar := 20
    fmt.Println(globalVar)
    fmt.Println(localVar)
}

python

global_var = 10

def my_func():
    local_var = 20
    print(global_var)
    print(local_var)
    
my_func()   # 输出：10 20
#如果你需要在函数内部使用全局变量，你可以使用 global 关键字来显式地声明一个变量为全局变量

c++

//C++ 中有显式的全局变量和局部变量的概念，你可以在函数内部或外部使用 int、double 等关键字来声明一个变量。如果你在函数内部声明一个变量，它将被视为局部变量，而如果你在函数外部声明一个变量，它将被视为全局变量

#include <iostream>
using namespace std;

int globalVar = 10;

void my_func() {
    int localVar = 20;
    cout << globalVar << endl;
    cout << localVar << endl;
}

int main() {
    my_func();  // 输出：10 20
    return 0;
}

二、基本数据类型

go

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go 语言的基本类型和其他语言大同小异。

1 整形
分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64
其中，uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型

uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

而且还允许我们用 _ 来分隔数字，比如说： v := 123_456 表示 v 的值等于 123456。

2 浮点型
float32和float64

3 复数
complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
complex64的实部和虚部为32位，complex128的实部和虚部为64位。

4 布尔值 bool
布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算，也无法与其他类型进行转换。

5 字符串 
s1 := "hello"
s2 := "你好"
Go语言中要定义一个多行字符串时，就必须使用反引号字符：
s1 := `第一行
第二行
第三行
`
反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

6 byte和rune类型
组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号（’）包裹起来，如：
var a = '中'
var b = 'x'
rune类型实际是一个int32

修改字符串
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

T(表达式) v类型转换

python

在Python中常见的数据类型有以下8个类型，分别是：int，整数类型（整形）、float，浮点类型（浮点型）、bool，布尔类型、str，字符串类型、list，列表类型、tuple，元组类型、dict，字典类型、set，集合类型

1  int
Python 中的整数没有长度限制，不像其他编程语言有 int，smallint，short，long，longint，long 等

十进制就不说了，正常的写法
十六进制写法：加前缀 0x，出现 0-9 和 A-F 的数字和字母组合
八进制写法：加前缀 0o，出现 0-7 数字组合
二进制写法：加前缀 0b，只有 0 和 1 数字组合

2 浮点数 float

a. 浮点数只能以十进制表示，不能加前缀，否则会报语法错误
浮点数 有长度限制 边界值为：
max=1.7976931348623157e+308 min=2.2250738585072014e-308

3 布尔值 bool

布尔值就是我们常说的逻辑，可以理解为对或错
print(100 == 100.0)

4 复数 complex

# Python 中的复数这样来表示： 1 + 1j  虚部为 1，仍不可省略
print((1 + 2j).real) # 输出实部 float 类型
print((1 + 2j).imag) # 输出虚部 float 类型

5 字符串 str
通俗来说，字符串就是字符组成的一串内容，Python 中用成对的单引号或双引号括起来，用三个单引号或双引号可以使字符串内容保持原样输出，可以包含回车等特殊字符，在 Python 中字符串是不可变对象
Python 中用反斜杠 “\” 来转义字符

6 列表 list
ls = [1, 2, 3, 4, 'a', 'b', [8, 5, 7]]
for i in ls:
    print(i) 

检查列表中是否存在某个元素
使用 in 关键字，返回值为布尔值   
del ls    

c++