Python3 基础语法

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*- 

上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。

标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。
  在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> keyword.kwlist
['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']

注释

Python中单行注释以 # 开头，实例如下：

# 第一个注释
print ("Hello, Python!") # 第二个注释 

执行以上代码，输出结果为：

Hello, Python!

多行注释可以用多个 # 号，还有 ‘’’ 和 “”"：

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

执行以上代码，输出结果为：

Hello, Python!

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

if True:
    print ("True")
else:
    print ("False")

以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

以上程序由于缩进不一致，执行后会出现类似以下错误：

 File "test.py", line 6
    print ("False")    # 缩进不一致，会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。

对象

Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、value（值） 组成。

1. 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数 id(obj) 可返回对象 obj 的标识。
2. 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的 操作。可以使用 type(obj)获得对象的所属类型。
3. 值表示对象所存储的数据的信息。使用 print(obj)可以直接打印出值。
   对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。
   
   结构如下:

注意点：
在 Windows 下可以不写第一行注释:
#!/usr/bin/python3
第一行注释标的是指向 python 的路径，告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。
此外还有以下形式（推荐写法）：
#!/usr/bin/env python3
这种用法先在 env（环境变量）设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。

引用

在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。 变量通过地址引用了“对象”。
变量位于：栈内存。
对象位于：堆内存。
图:

变量和简单赋值语句

变量的声明和赋值
变量的声明和赋值用于将一个变量绑定到一个对象上，格式如下： 变量名 = 表达式 最简单的表达式就是字面量。比如：a = 123 。 运行过程中，解释器先运行右边的表达式， 生成一个代表表达式运算结果的对象；然后，将这个对象地址赋值给左边的变量。

删除变量和垃圾回收机制 可以通过 del 语句删除不在使用的变量。
如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间。

链式赋值
链式赋值用于同一个对象赋值给多个变量。

x=y=123 #相当于：x=123; y=123

系列解包赋值
系列数据赋值给对应相同个数的变量（个数必须保持一致）

a,b,c=4,5,6 #相当于：a=4;b=5;c=6 

常量

Python 不支持常量，即没有语法规则限制改变一个常量的值。我们只能约定常量的命名规 则，以及在程序的逻辑上不对常量的值作出修改

数字和基本运算符

运算符	说明	示例	结果
+	加法	3 + 2	5
-	减法	3 - 2	1
*	乘法	3 * 2	6
/	浮点数除法	3 / 2	1.5
//	整数除法	3 //2	1
**	幂	3 ** 2	9
divmod()	使用 divmod()函数同时得到商和余数	divmod(13,3)	(4, 1)

divmod()是一个函数，我们以后会详细介绍。他返回的是一个元组。
整数
Python 中，除 10 进制，还有其他三种进制：

• 0b 或 0B，二进制 0 1
• 0o 或 0O，八进制 0 1 2 3 4 5 6 7
• 0x 或 0X，十六进制 0 1 2 3 4 5 6 7 8 9 a b c d e f

使用 int()实现类型转换：

• 浮点数直接舍去小数部分。如：int(9.9)结果是：9
• 布尔值 True 转为 1，False 转为 0。 如：int(True)结果是 1
• 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错
  加粗样式
  使用 bin，oct，hex 可输出数字的二进制，八进制，十六进制形式:

>>> a=0b111100
>>> a=60
>>> bin(a)
'0b111100'
>>> oct(a)
'0o74'
>>> hex(a)
'0x3c'

自动转型： 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0
Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

整数可以有多大？
Python2 中，int 是 32 位，可以存储从-2147483648 到 2147483647 的整数（约± 21 亿）。Long 类型是 64 位，可以存储：-2^63–263-1 之间的数值。 Python3 中，int 可以存储任意大小的整数，long 被取消。
Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适 合科学运算的特点。
浮点数
浮点数，称为 float。
浮点数用 10 ab 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。 这些数字在内存中也是按照科学计数法存储。
类型转换和四舍五入

• 类似于 int()，我们也可以使用 float()将其他类型转化成浮点数。
• 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0
• round(value)可以返回四舍五入的值 注：但不会改变原有值，而是产生新的值

关于四舍五入的解释
“4舍6入5看齐,奇进偶不进”我觉得并不是因为浮点数在计算机表示的问题。计算机浮点数的表示是 ieee 定义的标准规则，如果 python 中存在，没道理其他语言中不存在。事实上是因为该取舍方法比过去的 “四舍五入” 方法在科学计算中更准确。而国家标准也已经规定使用 “4舍6入5看齐,奇进偶不进” 取代"四舍五入".从统计学的角度上来讲,如果大量数据无脑的采用四舍五入会造成统计结果偏大。而"奇进偶舍"可以将舍入误差降到最低。
奇进偶舍是一种比较精确比较科学的计数保留法，是一种数字修约规则。
其具体要求如下（以保留两位小数为例）：
（1）要求保留位数的后一位如果是4或者4以下的数字，则舍去， 例如 5.214保留两位小数为5.21。
（2）如果保留位数的后一位如果是6或者6以上的数字，则进上去， 例如5.216保留两位小数为5.22。
（3）如果保留位数是保留整数部分或保留一位小数，则要根据保留位来决定奇进偶舍：

>>> round(5.215,2)#实际并没有进位
5.21
>>> round(5.225,2)
5.22
>>>
>>> round(1.5)#此处进位
2
>>> round(1.5)==round(2.5)#偶数舍去
True
>>> round(1.15,1)
1.1
>>> round(1.25,1)
1.2
>>> round(1.151,1)
1.2
>>> round(1.251,1)
1.3

(4) 如果保留位数的后一位如果是5，且该位数后有数字。则进上去，例如5.2152保留两位小数为5.22，5.2252保留两位小数为5.23，5.22500001保留两位小数为5.23。
从统计学的角度，“奇进偶舍”比“四舍五入”要科学，在大量运算时，它使舍入后的结果误差的均值趋于零，而不是像四舍五入那样逢五就入，导致结果偏向大数，使得误差产生积累进而产生系统误差，“奇进偶舍”使测量结果受到舍入误差的影响降到最低。
增强型赋值运算符
运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。 a = a + 1 等价于： a +=1
时间的表示
计算机中时间的表示是从“1970 年 1 月 1 日 00:00:00”开始，以毫秒（1/1000 秒） 进行计算。我们也把 1970 年这个时刻成为“unix 时间点”。 这样，我们就把时间全部用数字来表示了。

python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒 （1/1000 毫秒）精度的浮点值。
布尔值
Python2 中没有布尔值，直接用数字 0 表示 False,用数字 1 表示 True。 Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数 字相加。
其他类型值转换 bool 值时除了 ‘’、""、’’’’’’、""""""、0、()、[]、{}、None、0.0、0L、0.0+0.0j、False 为 False 外，其他都为 True
比较运算符
所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。 以下假设变量 a 为 15，变量 b 为 30：
逻辑运算符

算符	格式	说明
or	逻辑或	x or y x 为 true，则不计算 y，直接返回 true x 为 false，则返回 y
and	逻辑与	x and y x 为 true，则返回 y 的值 x 为 false，则不计算 y，直接返回 false
not	逻辑非	not x x 为 true，返回 false x 为 false，返回 true

同一运算符
同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址

运算符	描述
is	is 是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：

• is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。
• == 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。
  整数缓存问题
  Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对 象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样 的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。
  总结
• 1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
• 2、== 比较的是两个对象的内容是否相等，值是否相等；
• 3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；
• 4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。
  复合赋值运算符

运算符	描述	示例	等价于
+=	加法赋值字符串拼接	sum += n a += “sxt”	sum = sum + n a = a + “sxt”
-=	减法赋值	num -= n	num = num - n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a/=b	a = a / b
	=	按位或赋值	a
^=	按位异或赋值	a^=b	a = a^b
&=	按位与赋值	a&=b	a = a&b
>>=	右移赋值	a>>=2	a = a>>2
<<=	左移赋值	a<<=2	a = a<<2
**=	幂运算赋值	a**=2	a = a**2
%=	取余赋值	a%=b	a = a % b
//=	整数除赋值	a//=b	a = a//b

注：与 C 和 JAVA 不一样，Python 不支持自增(++)和自减(–)