2 Python的基本语法

为了保证Python解释器能顺利编译所编写的代码，也为了程序员对自己和别人所编写的程序易于阅读、维护，对编程语言的语法做一些基本约定是非常必要的。

2.1 编程方式

2.1.1 交互式编程(python)

交互式编程不需要创建脚本文件，是通过 Python 解释器的交互模式进来编写代码。（在DOS环境中输入Python，可以看到Python的版本信息，>>>后输入print(“hello，world”)就可以看到输出hello，world）

2.1.2 传统编程(C,C++,Java)

（1）简介：传统编程一般被设计为通用型语言（如C，C++），往往是系统编程语言，因此它基于某种靠近计算机底层的离线形式，涉及汇编原理的内容。

（2）特点：具有一定通用性，它必须一切从头做起，这类语言往往是面向过程的编程语言，不灵活，无法用来解决抽象或特定领域的问题（可通过提供新的扩展库来实现）；C的数据结构+算法可用来解释系统底层开发的手段，非应用开发语言

（2）应用：自然语言开发、扩展库或高层模型的底层算法，如Python语言的底层算法就是用C写的

2.1.3 脚本式编程(python)

（1）简介：脚本语言和虚拟机语言可基于更高层的开发逻辑和设计方式来解决问题，程序员不必涉入数据结构这些与底层和解决大家都解决过的问题直接相关的东西（简单来理解，例如手机，脚本语言相当于使用它打电话、上网、聊天、购物等，而系统语言就是为这些功能提供底层算法及数据结构）

（2）特点：接近自然语言，解决特定领域问题（抽象），基于高层模型（基于C，C++），无需开发平台，考虑移植和速率问题，面向应用编程，封装系统编程和系统逻辑并打包，提供大量扩展库，复用性

（3）应用：脚本式开发，OO层面复用，实现特定领域功能，如数据分析、人工智能等；

2.2 标识符

2.2.1 标识符的概念

（1）定义：在Python语言中用于规范命名解释器能识别的可执行代码对象的名称。（其实面向对象中的对象只是一个逻辑上的称呼，如变量、关键字、函数、运算符、类等都可以是对象，完整的标识符包括格式控制符、#等）

（2）硬性规则：由字母、数字、下划线组成；不可数字开头；不能是关键字；不含空格；严格区分大小写（num与Num是两个标识符）；不能有特殊符号（！@￥%等）

（3）软性规则：有描述性，见名知义；驼峰法则/低杠（StuScore、stuScore、stu_score）；

（4）匈牙利命名法：匈牙利命名法由匈牙利程序员Charles Simonyi发明的一种编程语言中对变量进行命名的规范。变量名=属性+类型+对象描述，其中每一对象的名称都要求有明确含义，可以取对象名字全称或名字的一部分。要基于容易记忆容易理解的原则。保证名字的连贯性是非常重要的，但是此命名法有争议。（stuscore/frmSwitchboard/）

2.2.2 关键字

关键字是系统已经定义过的标识符，它在程序中已经有了特定的含义，因此这些保留关键字不能用于变量名、函数名、类名等，他们属于Python语言本身的专用标识符。

（1）查看关键字：print(keyword.kwlist)

import keyword    # 导入模块
a = keyword.kwlist #生成关键字列表赋给变量a
print(len(a))     #看看有多少个关键字
print(a)
===========================================================================
33
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue',
 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
 'try', 'while', 'with', 'yield']

（2）关键字功能简介：

False	布尔类型的值“假”，与True
True	布尔类型的值“真”，与False
None	特殊，表示什么也没有，NoneType类型
and	表达式运算，逻辑与操作
or	表达式运算，逻辑或操作
is	判断变量是否为某个类的实例
not	表达式运算，非操作
in	判断变量是否在序列中
try	try包含可能会出现异常的语句，与except、finally结合使用
class	用于定义类
def	用于定义函数或方法
for	for循环语句
continue	跳出本次循环，继续执行下一次循环
break	中断循环语句的执行
return	用于从函数返回计算结果
while	while循环语句
if	条件语句，与elif、else结合使用
elif	条件语句，与if、else结合使用
else	条件语句，与if、elif结合使用，也可用于异常和循环语句
with	简化Python的语句
pass	空的类、方法或函数的占位符
from	用于导入模块，与import结合使用
import	用于导入模块，与from结合使用
except	except包含捕获异常后的操作代码块，与try、finally结合使用
assert	断言，用于判断变量或者条件表达式的值是否为真
as	用于类型转换
del	删除变量或序列的值
raise	异常抛出操作
finally	用于异常语句，出现异常后，始终要执行finally包含的代码块与try、except结合使用
global	定义全局变量
lambda	定义匿名函数
nonlocal	用于标识外部作用域的变量
yield	用于从函数依次返回值

2.3 变量与常量

2.3.1 变量与常量的概念

（1）变量：变量（Variable），指在计算机编程中与关联的标识符配对的内存存储位置，在使用时含相关类型的值，其值可以修改。（这里的标识符就是变量名，在变量被使用时，在内存里将产生两个动作，一是开辟指定地址的空间，二是赋予指定变量值，在Python语言中，变量在指定的同时，必须强制赋初始值，否则解释器报错）

（2）常量：Python并未提供如C/C++/Java一样的const修饰符，换言之，python中没有常量。（通过自定义类可实现常量，要求符合命名全部为大写、值一旦被绑定不可再修改）

2.3.2 变量的分类

（1）常规变量：字母开头命名的变量，可用于常规赋值

（2）__name__：这种类型的变量在python中有特殊意义，属于对象的内置属性，以后学了类和对象就知道了

（3）_x：这类变量不会被from ModuleName import *的方式导入

（4）_ _x：是类的本地变量或称为类的私有变量，它会扩展成_ _classname_x除此之外，还有约定俗成的命名方式（没有强制限制，此处故意加个空格区分，实操时无空格）：

①常量以全大写字符表示

②普通变量、函数名、方法名都以小写字母开头命名

③模块名、包名以全小写字母命名

④类名以大写字母开头

2.3.3 变量的赋值

（1）序列赋：

①序列形式的赋值，其中[]、()、{}只是个形式，可要可不要（嵌套例外），严格按照

变量数=值的数量即可

②字符串、字典、集合不能被赋值，前两者不可变，后者无序

③嵌套赋值，也就是多维序列，按照层层剥皮，再套用前面的几种赋值可找出最终结果，但元素要保证其完整性和对应性

a,b = [1,2]
c,d = (3,4)
e,f = {5,6}
g,h = "78"          #但是字符串不能被赋值，他是不可变类型
i,j = {1:"ab",2:"cd"}  #此种赋的是key
print(a,b,c,d,e,f,g,h,i,j)

(a1,b1) = [1,2]    #此四行大中小括号,要与不要都行,它只是个形式，其灵魂是“序列”
[c1,d1] = (3,4)    #只要保证前后对应，个数一致就行
(e1,f1) = {5,6}
[g1,h1] = {7,8}    #集合无序,此处给g1,h1随机匹配,具体后面数据类型中详述
# {i1,j1} = [7,8]  #序列式赋值，严格讲究位置顺序的,位置确定,集合无序,此处飘红
# {k1,l1} = (9,10)
(m1,n1) = {11:"ef",12:"ij"}
print(a1,b1,c1,d1,e1,f1,g1,h1,m1,n1)

((o,p,q),r) = [{1,"a","c"},3]
print(o,p,q,r)

===========================================================================
1 2 3 4 5 6 7 8 1 2
1 2 3 4 5 6 8 7 11 12
1 c a 3

（2）解包赋：

（2）解包式赋值
① * 表示解包的意思,作用于序列,但多维序列只拆一层,以元素的值单一呈现
A = (1,2,"a","b")
B = [1,2,"a","b"]
C = {1:"a",2:"b"}
D = {1,2,"a","b"}
E = [1,2,("a","b"),[3,4],{1:"a",2:"b"}]
print(*A,"\n",*B,"\n",*C,"\n",*D,"\n",*E)
===========================================================================
1 2 a b 
 1 2 a b 
 1 2 
 1 2 b a 
 1 2 ('a', 'b') [3, 4] {1: 'a', 2: 'b'

②解包后的结果是原序列的每个元素值，是单个元素的值，能被打印，但不能直接用来赋值
A = (1,2,"a","b")
a = *A
print(a)
===========================================================================
File "F:/Python成长日记/test2.py", line 9
    a = *A
       ^
SyntaxError: can't use starred expression here

③解包赋值,带 * 的变量称之为解包变量,例如 *A（此处A仅仅是个变量的名称），我们都知道，在Python中不同于C/C++（变量需要提前声明其类型才能被赋值）,而Python天生具备智能识别天赋，你给它赋什么类型的值他就自己默认声明了是啥类型，那么这里的 *A，就具有“返祖”现象（为啥这么说呢，查下Python的底层代码就知道了），这里的 * 就是强制性声明变量A是一个列表类型变量，什么意思，就是强制性先将它所指的地址分解成一个列表（有序排列的地址然后形成一个变量地址），也就是说 * 是先拆包再打包的意思（从地址的角度来说）
a,*b = 1,2,3,4,5
print(a,b)
print(type(b))
a,*b = 1,2,3,{4,5,6,7}
print(a,b)
print(*b)
print(type(b))
===========================================================================
1 [2, 3, 4, 5]
<class 'list'>
1 [2, 3, {4, 5, 6, 7}]
2 3 {4, 5, 6, 7}
<class 'list'>

④既然是声明b是一个列表，那它能否被单独赋值呢？不能，因为Python具有一定唯一性,Python这种
高级语言并非系统语言，是用来实现特定功能的（既然我们可以用b来直接赋值一个列表，或者通过list()
函数转换，为啥还要用*b这种方式呢）
*b = 1,2,3,4,5
print(b)
===================================================================================
  File "F:/Python成长日记/test2.py", line 9
    *b = 1,2,3,4,5
    ^
SyntaxError: starred assignment target must be in a list or tuple

而且我们还可以用②中的观点来解释，它并非一个序列（这里比较抽象），就不能被赋值（a=1,这里的a可以看作是一个元素的序列）