您现在的位置是：首页 > Python

当前栏目

小朋友学Python（10）：C/C++/Java/Python的关键字

Python 变量

2023-03-02 10:56:59 时间

# 一、C语言关键字 #

C语言关键字有32个

<table> 
 <thead> 
  <tr> 
   <th>auto</th> 
   <th>break</th> 
   <th>case</th> 
   <th>char</th> 
   <th>const</th> 
   <th>continue</th> 
   <th>default</th> 
   <th>do</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>double</td> 
   <td>else</td> 
   <td>enum</td> 
   <td>extern</td> 
   <td>float</td> 
   <td>for</td> 
   <td>goto</td> 
   <td>if</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>long</td> 
   <td>register</td> 
   <td>return</td> 
   <td>short</td> 
   <td>signed</td> 
   <td>sizeof</td> 
   <td>static</td> 
  </tr> 
  <tr> 
   <td>struct</td> 
   <td>switch</td> 
   <td>typedef</td> 
   <td>union</td> 
   <td>unsigned</td> 
   <td>void</td> 
   <td>volatile</td> 
   <td>while</td> 
  </tr> 
 </tbody> 
</table>

auto：声明自动变量。自动变量，只在定义它们的时候才创建，在定义它们的函数返回时系统回收变量所占存储空间。对这些变量存储空间的分配和回收是由系统自动完成的。一般情况下，不作专门说明的局部变量，均是自动变量。自动变量也可用关键字auto作出说明。  
break：跳出当前循环  
case：开关语句分支  
char：字符型  
const：声明只读变量，初始化后不能被更改  
continue：结束当前循环，开始下一轮循环  
default：开关语句中的“其它”分支  
do：循环语句的循环体  
double：双精度浮点型  
else：条件语句否定分支（与 if 连用）  
enum：声明枚举类型  
extern：声明变量或函数是在其它文件或本文件的其他位置定义  
float：单精度浮点型变  
for：一种循环语句  
goto：无条件跳转语句  
if：条件语句  
int： 整型  
long：长整型  
register：声明寄存器变量  
return ：子程序返回语句（可以带参数，也可不带参数）  
short：短整型  
signed：有符号类型  
sizeof：计算数据类型长度或变量长度（即所占字节数）  
static：声明静态变量  
struct：声明结构体类型  
switch : 用于开关语句  
typedef：用以给数据类型取别名  
unsigned：无符号类型  
union：声明共用体类型  
void：声明函数无返回值或无参数，声明无类型指针  
volatile：说明变量在程序执行中可被隐含地改变  
while：循环语句的循环条件

# 二、C++关键字 #

关键字(keyword)又称保留字，是整个语言范围内预先保留的标识符。每个C++关键字都有特殊的含义。经过预处理后，关键字从预处理记号(preprocessing-token)中区别出来，剩下的标识符作为记号(token)，用于声明对象、函数、类型、命名空间等。不能声明与关键字同名的标识符。  
ISO C++98/03关键字共63个。

<table> 
 <thead> 
  <tr> 
   <th>asm</th> 
   <th>do</th> 
   <th>if</th> 
   <th>return</th> 
   <th>typedef</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>auto</td> 
   <td>double</td> 
   <td>inline</td> 
   <td>short</td> 
   <td>typeid</td> 
  </tr> 
  <tr> 
   <td>bool</td> 
   <td>dynamic_cast</td> 
   <td>int</td> 
   <td>signed</td> 
   <td>typename</td> 
  </tr> 
  <tr> 
   <td>break</td> 
   <td>else</td> 
   <td>long</td> 
   <td>sizeof</td> 
   <td>union</td> 
  </tr> 
  <tr> 
   <td>case</td> 
   <td>enum</td> 
   <td>mutable</td> 
   <td>static</td> 
   <td>unsigned</td> 
  </tr> 
  <tr> 
   <td>catch</td> 
   <td>explicit</td> 
   <td>namespace</td> 
   <td>static_cast</td> 
   <td>using</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>export</td> 
   <td>new</td> 
   <td>struct</td> 
   <td>virtual</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>extern</td> 
   <td>operator</td> 
   <td>switch</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td>const</td> 
   <td>false</td> 
   <td>private</td> 
   <td>template</td> 
   <td>volatile</td> 
  </tr> 
  <tr> 
   <td>const_cast</td> 
   <td>float</td> 
   <td>protected</td> 
   <td>this</td> 
   <td>wchar_t</td> 
  </tr> 
  <tr> 
   <td>continue</td> 
   <td>for</td> 
   <td>public</td> 
   <td>throw</td> 
   <td>while</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>friend</td> 
   <td>register</td> 
   <td>true</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>delete</td> 
   <td>goto</td> 
   <td>reinterpret_cast</td> 
   <td>try</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

asm  
用于语法：  
asm-definition:  
asm ( string-literal ) ;  
意义由实现定义，典型实现中传输其中的字符串给汇编器。

auto  
在C++98/03中这个这个关键字用于声明块中的变量的生存期为自动生存期，若是对象同时具有自动存储类，即生存期在块结束时结束。这样的变量被称为局部变量。这个关键字不常用，因为即便省略，声明的默认就是auto的。

\*\_cast  
即const\_cast、dynamic\_cast、reinterpret\_cast、static\_cast。  
C++风格的类型转换。dynamic\_cast是动态的，需要运行时支持；其它都是静态检查，相比C风格的类型转换更加细化，增强了类型安全性。

bool,true,false  
bool即布尔类型，属于基本类型中的整数类型，取值为真和假。true和false分别表示真和假。注意，C语言中没有bool类型。

break,continue,goto  
break用于跳出for或while循环或switch。continue用于跳转到循环起始。goto用于无条件跳转到函数内的标号。结构化程序较少使用goto，更多使用循环代替。

case,default,switch  
switch分支语句的起始，根据switch条件跳转到case标号或defalut标记的分支上。

catch,throw,try  
用于异常处理。try指定try块的起始，try块后的catch可以捕获异常。异常由throw抛出。

char,wchar\_t  
表示字符型和宽字符型这些整数类型（属于基本类型），但一般只专用于表示字符。

const,volatile  
const和volatile是类型修饰符。用于声明变量。  
const表示只读类型（指定类型安全性，保护对象不被意外修改），  
volatile 关键字和 const 对应，volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

struct,class,union  
用于类型声明。  
class是一般的类类型。  
struct在C++中是特殊的类类型，声明中仅默认隐式的成员和基类访问限定与class不同（struct是public，class是private）。  
union是联合体类型。

delete,new  
new用来生成对象并分配内存，delete用来销毁对象并回收内存。

do,for,while  
循环语句的组成部分。C++和C语言支持do-while循环、for循环和while循环。

double、float、long、int、short、signed、unsigned  
数值类型。  
signed和unsigned作为前缀修饰整数类型，分别表示有符号和无符号。signed和unsigned修饰char类型，构成unsigned char和signed char，和char都不是相同的类型；其它整数类型的signed省略或不省略，含义不变。  
signed或unsigned可单独作为类型，相当于signed int和unsigned int。  
double和float专用于浮点数，double表示双精度，float表示单精度。  
其它关键字表示整数类型。从占用空间大小(sizeof)来看，保证char<=short<=int<=long<=long long。

if,else  
条件语句的组成部分。

enum  
构成枚举类型名的关键字。

explicit  
这个关键字修饰构造函数声明，表示显式构造函数（模版），显式构造函数不参与特定的重载。

extern, export  
为了访问其他编译单元（如另一代码文件）中的变量或对象，对普通类型（包括基本数据类、结构和类），可以利用关键字extern，来使用这些变量或对象时；但是对模板类型，则必须在定义这些模板类对象和模板函数时，使用标准C++新增加的关键字export（导出/出口/输出）。

friend  
声明友元，使其不受访问权限控制的限制。

inline  
声明定义内联函数，提示编译时内联——将所调用的代码嵌入到主调函数中。注意是否内联取决于实现——编译器有权不实际内联，如果它认为这是必要的或更符合预期的目标代码质量。

mutable  
用于类的非静态非const数据成员，表示不受到成员函数的const的限制，可以在const成员函数中使用。

namespace  
表示命名空间——其中可以声明若干标识符，组成的名称与其它命名空间不冲突。  
可以声明一个命名空间或命名空间别名。

operator  
和操作符连用，指定一个重载了的操作符函数。

private,protected,public  
指定类成员或基类中的名称的访问权限控制。

return  
子程序返回语句，终止当前函数执行，使控制流返回到主调函数的调用后。若返回类型不是void可以同时带返回值。

static  
和C语言类似，声明静态存储期对象。在C++还有另一个用途——用于类作用域声明，表示声明的成员是类共有的，不需要通过类的对象访问。

sizeof  
返回类型名或表达式具有的类型对应的大小。

template  
声明模板，实现泛型和参数化编程。

this  
this是一种实体，仅在类的非静态成员中使用，是指向类的对象的指针。

typedef  
用以给数据类型取别名。

virtual  
声明虚基类或虚函数。具有虚基类或虚函数的类是多态类(polymorphic class)，需要运行时提供支持来判断成员函数调用分派到的具体类型。

typeid  
返回指针或引用所指对象的实际类型。  
typeid是操作符，不是函数。

typename  
告诉编译器是一个类型，不是一个成员。  
用在模板定义里，标明其后的模板参数是类型参数，是class的同义词，可被class代替。

using  
有两种基本用法：using声明和using指示（using namespace …）。  
前者是声明，引入命名空间或基类作用域内已经被声明的名称。后者引入命名空间内所有的名称。

void  
特殊的“空”类型，指定函数无返回值或无参数。

# 三、Java关键字 #

Java关键字是事先定义的，有特别意义的标识符，有时又叫保留字。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。  
Java关键字有50个。

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abstract</td> 
   <td>表明类或者成员方法具有抽象属性</td> 
  </tr> 
  <tr> 
   <td>assert</td> 
   <td>用来进行程序调试</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>基本数据类型之一，布尔类型</td> 
  </tr> 
  <tr> 
   <td>break</td> 
   <td>提前跳出一个块</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>基本数据类型之一，字节类型</td> 
  </tr> 
  <tr> 
   <td>case</td> 
   <td>用在switch语句之中，表示其中的一个分支</td> 
  </tr> 
  <tr> 
   <td>catch</td> 
   <td>用在异常处理中，用来捕捉异常</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>基本数据类型之一，字符类型</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>类</td> 
  </tr> 
  <tr> 
   <td>const</td> 
   <td>保留关键字，没有具体含义</td> 
  </tr> 
  <tr> 
   <td>continue</td> 
   <td>回到一个块的开始处</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>默认，例如，用在switch语句中，表明一个默认的分支</td> 
  </tr> 
  <tr> 
   <td>do</td> 
   <td>用在do-while循环结构中</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>基本数据类型之一，双精度浮点数类型</td> 
  </tr> 
  <tr> 
   <td>else</td> 
   <td>用在条件语句中，表明当条件不成立时的分支</td> 
  </tr> 
  <tr> 
   <td>enum</td> 
   <td>枚举</td> 
  </tr> 
  <tr> 
   <td>extends</td> 
   <td>表明一个类型是另一个类型的子类型，这里常见的类型有类和接口</td> 
  </tr> 
  <tr> 
   <td>final</td> 
   <td>用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量</td> 
  </tr> 
  <tr> 
   <td>finally</td> 
   <td>用于处理异常情况，用来声明一个基本肯定会被执行到的语句块</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>基本数据类型之一，单精度浮点数类型</td> 
  </tr> 
  <tr> 
   <td>for</td> 
   <td>一种循环结构的引导词</td> 
  </tr> 
  <tr> 
   <td>goto</td> 
   <td>保留关键字，没有具体含义</td> 
  </tr> 
  <tr> 
   <td>if</td> 
   <td>条件语句的引导词</td> 
  </tr> 
  <tr> 
   <td>implements</td> 
   <td>表明一个类实现了给定的接口</td> 
  </tr> 
  <tr> 
   <td>import</td> 
   <td>表明要访问指定的类或包</td> 
  </tr> 
  <tr> 
   <td>instanceof</td> 
   <td>用来测试一个对象是否是指定类型的实例对象</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>基本数据类型之一，整数类型</td> 
  </tr> 
  <tr> 
   <td>interface</td> 
   <td>接口</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>基本数据类型之一，长整数类型</td> 
  </tr> 
  <tr> 
   <td>native</td> 
   <td>用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的</td> 
  </tr> 
  <tr> 
   <td>new</td> 
   <td>用来创建新实例对象</td> 
  </tr> 
  <tr> 
   <td>package</td> 
   <td>包</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>一种访问控制方式：私用模式</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>一种访问控制方式：保护模式</td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>一种访问控制方式：共用模式</td> 
  </tr> 
  <tr> 
   <td>return</td> 
   <td>从成员方法中返回数据</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>基本数据类型之一,短整数类型</td> 
  </tr> 
  <tr> 
   <td>static</td> 
   <td>表明具有静态属性</td> 
  </tr> 
  <tr> 
   <td>strictfp</td> 
   <td>用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范[1]</td> 
  </tr> 
  <tr> 
   <td>super</td> 
   <td>表明当前对象的父类型的引用或者父类型的构造方法</td> 
  </tr> 
  <tr> 
   <td>switch</td> 
   <td>分支语句结构的引导词</td> 
  </tr> 
  <tr> 
   <td>synchronized</td> 
   <td>表明一段代码需要同步执行</td> 
  </tr> 
  <tr> 
   <td>this</td> 
   <td>指向当前实例对象的引用</td> 
  </tr> 
  <tr> 
   <td>throw</td> 
   <td>抛出一个异常</td> 
  </tr> 
  <tr> 
   <td>throws</td> 
   <td>声明在当前定义的成员方法中所有需要抛出的异常</td> 
  </tr> 
  <tr> 
   <td>transient</td> 
   <td>声明不用序列化的成员域</td> 
  </tr> 
  <tr> 
   <td>try</td> 
   <td>尝试一个可能抛出异常的程序块</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>声明当前成员方法没有返回值</td> 
  </tr> 
  <tr> 
   <td>volatile</td> 
   <td>表明两个或者多个变量必须同步地发生变化</td> 
  </tr> 
  <tr> 
   <td>while</td> 
   <td>用在循环结构中</td> 
  </tr> 
 </tbody> 
</table>

# 四、Python 2.7关键字 #

Python 2.7中的关键字有31个

<table> 
 <thead> 
  <tr> 
   <th>and</th> 
   <th>del</th> 
   <th>from</th> 
   <th>not</th> 
   <th>while</th> 
   <th>as</th> 
   <th>elif</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>global</td> 
   <td>or</td> 
   <td>with</td> 
   <td>assert</td> 
   <td>else</td> 
   <td>if</td> 
   <td>pass</td> 
  </tr> 
  <tr> 
   <td>yield</td> 
   <td>break</td> 
   <td>except</td> 
   <td>import</td> 
   <td>print</td> 
   <td>class</td> 
   <td>exec</td> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>raise</td> 
   <td>continue</td> 
   <td>finally</td> 
   <td>is</td> 
   <td>return</td> 
   <td>def</td> 
  </tr> 
  <tr> 
   <td>for</td> 
   <td>lambda</td> 
   <td>try</td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

1.and：表示逻辑‘与’  
2.del：用于list列表操作，删除一个或者连续几个元素。  
3.from ：导入相应的模块，用import或者from…import  
4.not：表示逻辑‘非’  
5.while：循环  
6.as：as单独没有意思，要与with一起使用，with….as  
例子：

with open(“/tmp/foo.txt”) as file: 
    data = file.read()

7.elif : 和if配合使用的，if语句中的一个分支用elif表示。  
8.global : 定义全局变量  
9.or：表示逻辑“或”  
10.with：和as一起用  
11.assert：表示断言。用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError  
12.else：条件判断，用于选择分支  
13.if：条件判断，用于选择分支  
14.pass：当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位，也可以当做是一个标记，是要以后来完成的代码。比如下面这样：

def dosomething():
        pass

15.yield： 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。  
16.break：作用是终止循环，程序走到break的地方就是循环结束的时候。注意，如果是多层循环的话，break只能终止最里边那层的循环。  
17.except：和try一起使用，用来捕获异常。try…except或try…except…finally  
18.import：用来导入模块，有时这样用from….import，作用与C/C++的include和Java的import类似  
19.print：输出  
20.class：定义类  
21.exec：可以生成一个包含python代码的字符串，然后使用exec语句执行这些语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用exec语句执行这些语句。下面是一个简单的例子

>>> exec 'print "Hello World"'

22.in：查找列表中是否包含某个元素，或者字符串a是否包含字符串b  
23.raise：raise可以显示地抛出异常。一旦执行raise语句，后面的代码就不执行了  
24.continue：跳过continue后面循环块中的语句，继续进行下一轮循环。  
25.finally :与try和except一起使用：try…except..finally，finally中的语句一定会被执行  
26.is：Python中的对象包含三要素：id、type、value  
其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值。  
is判断的是a对象是否就是b对象，是通过id来判断的。  
例子：

if(a is b)
        print “a is b”

27.return：用于跳出函数，可以返回一个值也可以不返回值  
28.def：用于定义方法  
29.for：for….in 一起使用：遍历容器中的每个元素  
30.lambda:即匿名函数，简化了函数定义的书写形式，使代码更为简洁，但是使用函数的定义方式更为直观，易理解。  
下面两种写法是等价的。  
例1：

g = lambda x: x+1

例2：

def g(x) :
    return x+1

31.try：出现在异常处理中，使用格式为：try…except或try…except…finally。  
try中放想要执行的语句，except捕获异常，finally做清理工作。

> 更多内容请关注微信公众号  
> ![wechat.jpg][]

[wechat.jpg]: /images/20220531/11a7335bd202459387376c79eb77a50f.png

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

小朋友学Python（10）：C/C++/Java/Python的关键字

相关文章