单行注释：#...

多行注释：'''...'''

单行注释：//...

多行注释: /*...*/

（1）数据范围：无穷大

（2）默认为4字节大小

（3）支持动态扩容（内存足够大，就可以保存足够大的数据）

（4）十六进制：0x开头

（5）八进制：0o开头

（1）双精度浮点数

（2）默认为8字节大小

（3）科学计数法表示：1.23 * 10 ** 9 == 1.23e9 ;

                                      1.23 * 10 ** (-3)  == 1.23e-3

（1）可以用单引号 ' .. '  双引号 " ... "  三引号 ''' ... ''' 

（2）单引号、双引号、三引号可以相互嵌套使用，完成各种语境

（3）r "..." 表示 内部字符串默认不转义，就是普通字符

（4）'''line1

          ...line2

          ...linen ''' 表示多行内容，与\n效果一致

bool

（1）True False

（2）用于条件选择 while、if 中

（3）0为假、非0为真

整型类型：

char

short

int

long

long long

...

（1）根据存放数据的大小由程序员自由选择

（2）不支持扩容，所以才会有这么多类型

（3）十六进制：0x开头

（4）八进制：0开头

浮点数类型：

float

double

（1）float：单精度浮点数，默认字节为4，只保留6位小数

（2）double：双精度浮点数：默认字节为8

（3）使用printf函数时如果没有指定精度，float与double都           是默认输出6位有效数字，此时使用.nf / .nlf来指定输             出的小数位数

（4）使用cout输出的时候，只保留五位小数（四舍五入）

（1）只能用双引号 " ... "

（2）以 ' \0 ' 结尾，字符串结束的标志，不算字符串的内容

（3）strlen计算字符串长度，不算末尾的' \0 '

（1）true、false

（2）默认字节为 1字节

（3）true为1，false为0

（4）0为假，非0为真

    Python

动态类型语言

（1）无需显示声明变量的数据类型，会根据赋值来自动推导数据类型，并且变量的类型可以动态改变

（2）Python中的变量必须初始化，因为变量为对象的引用，是别名，必须初始化

       C++

静态类型语言

（1）变量在使用之前必须声明类型，一旦确定类型，在其整个生命周期中，不允许被改变，也不允许其他数据类型进行赋值，但C++提供了强制类型转换的方法

（2）变量可以不初始化，被称为声明，旨在告诉编译器预留出一段空间来存放该数据类型的数据，以便后续进行赋值。

    Python

动态类型语言

        Python分为多级作用域，且只有函数和class类的代码块会涉及到作用域，if、else、elif、while、for的代码块定义的变量可以在外面使用，即属于全局变量

（1）Python的全局变量与局部变量同名时，优先匹配同级作用域的变量，若无，则找上级作用域的变量

（2）下级作用域若创建一个与上级作用域同名的变量，默认是创建一个新的数据对象，对下级作用域中的变量进行修改，不会影响上级作用域的同名变量。若想在下级作用域中修改上级变量，使用global关键字先标识上级变量，再对其进行修改

       C++

静态类型语言

        变量的作用域由大括号来决定，生命周期由自身的属性决定，但是其可以通过引用传参或指针传参来直接或间接访问变量

        全局变量：作用域全局，生命周期随进程

        栈变量：作用域和生命周期为所处大括号范围内

        堆变量：作用域所处大括号范围内，生命周期随进程

        静态局部变量：作用域所处大括号范围内
                                 生命周期随进程

        静态全局变量：作用域全局，生命周期随进程

    Python

动态类型语言

        在 Python 中，变量通过引用指向对象，当多个变量被赋值为相同的值时，它们实际上指向的是同一个对象。这种机制有助于提高内存使用效率和编程的便捷性，需要注意的是Python中赋与相同的值的对象必须是不可变对象，多个变量才会指向同一个对象，如果是list这种可变对象，则会开辟多个空间，因为Python不能确保我们后续是否会修改，若只开辟一个空间创建一个对象，则后续修改一个，其他变量也会被修改

       C++

静态类型语言

        C++是一种静态类型语言，在编译时就需要确定变量的类型和大小，这是因为在编译的时候，就已经将变量名换成地址了，为的是在运行时，初始化进程地址空间。在 C++中，每个变量都有自己独立的内存空间，因此可以在不同的作用域中使用相同的变量名，而不会相互干扰。这是因为在编译的时候，就已经把变量名转换为地址来表示了，变量名只是给我们自己看的，即使变量名相同，但是底层的地址不同，就属于不同的变量

    Python

动态类型语言

        具有自动的内存管理机制，通过垃圾回收器来自动回收不再使用的对象所占用的内存

       C++

静态类型语言

        程序员需要手动管理内存，包括用new和delete操作符来分配和释放内存   

（1）const修饰的常变量：给变量添加常属性

（2）enum枚举常量

（3）define定义的宏

（4）字面常量：1，3.14

+   -   *   /   %    **    //

a ** b ：数学中的乘方运算，b可正、负，可整数、小数

a // b ：向下取整的除法（往小方向取整）

（1）Python中除0或0.0都为除0异常

         C++中只有除0会抛异常，除0.0会得到无穷大的数inf

（2）Python中int / int ，除不尽得到小数，不会截断

         C++中 int / int ，除不尽得到整数，会截断

<  <=  >  >=  ==  !=

（1）比较整数、比较字符串（按照字典序比较）

（2）比较浮点数：使用关系运算符比较浮点数的时候，存在一定的风险，因为浮点数载内存的存储和表示，是可能存在误差的，这样的误差会在进行算数运算的时候被放大，从而导致关系运算符的判断不准。

        正确比较浮点数：作差，判断是否在误差范围

-0.000001 < a - b < 0.000001  在误差范围就是True，反之False

（3）Python支持连续小于的写法，即Python支持连续的条件判断，而C/C++不支持

（1）and：C++中的   &&  并且

（2）or：   C++中的   ||     或者

（3）not： C++中的   !      逻辑反

（1）赋值

a = 10

a = b = 10

a , b = 10 , 20

（2）交换

a, b = b, a

is 、is not ：用于判断两个对象是否为同一个对象

                    即它们是否具有相同的内存地址

【Python中若给两个变量赋同一个值，本质上这两个变量指向的是同一个内存地址，底层不会给两个变量开辟两个相同的值的空间，这属于一种浪费，所以在使用is来判断的时候，他们属于同一个对象；但是在C++中，是会给同一个值的两个变量开辟不同的空间存放，这是不同之处】

in、not in：用于判断一个对象是否在可迭代对象中

+=、-=、*=、/=、%=、**=、//=

Pyhton不支持++、--

第一种：

（1）采用与C语言一致的风格

（2）格式：print(" ...%d %s ... " %(123, ' hello '))

（3）%s可以把所有的数据类型转换为字符串类型

第二种：

（1）format函数，通过{0}、{1}、{2}这种占位符来进行格式化打印

（2）占位符: 格式 -> 表示需要以哪种形式打印出来数据

        { 0 : nd }     { 0 : .nf }     { 0 : ns }

（3）与print配套使用

（4）print (" 我的名字是{ 0 }，我{ 1 }岁 ".format ( ' hh ',' 20 ' ) )

第三种：

（1）f-string ：使用以f开头的字符串，内部如果包含{变量名}，就会以对应的变量替换

（2）与print配套使用

（1）表示形式：以{ ... }包围，内部为key:value形式

（2）创建：d =  {key:vlaue, key:value}

（3）key不可以重复、且key为不可变对象，所以可以用做key的类型有：字符串、整数、浮点数、bool、元组

（4）查找：使用in / not in 来判断在或不在，这里是判断key

                    d [key] 存在获得value，反之抛异常

                    d.get( )存在获取value，不存在获取None

（5）插入：d [key] = value（key不存在）

（6）修改：d [key] = value（key存在）

（7）删除：d.pop(key)

（8）遍历：for循环

                    d.keys( ) 获取所有key

                    d.values( ) 获取所有values

                    d.iitems( ) 获取所有的key：values

（1）创建： s =   { key, key, key, ... }

（2）key必须是不可变对象

（2）插入：s.add( key )

（3）删除：s.remove( key )

（4）多个set可以做数学意义上的交集和并集等操作

if <条件判断>:

        <代码块>

elif<条件判断>:

        <代码块>

else:

        <代码块>

if (条件判断)

{

        //代码块

}

else if（条件判断）

{

        //代码块

}

else

{

        //代码块

}

match 变量：

        case 有关变量的条件：

                <代码块>

        case 有关变量的条件：

                <代码块>

        case _： # 匹配到其他情况

                <代码块>

switch (变量)

{

        case 有关变量的条件:

        {        

                // 代码块

        }

        ...

        default:

        {

                // 代码块

        }

}

（1）while循环

while 条件：

        循环体

（2）for循环

for 循环变量 in 可迭代对象：

        循环体

（1）while

while（循环条件）

{

        // 循环体

}

（2）do-while

do

{

        //循环体

} while（循环条件）

（3）for

for(循环变量初始值；循环条件；循环变量下一次进入循环的值)

{

        // 循环体

}