（二） Python程序的基本语法

一、PyCharm的基本使用

• 1.1、注释：为了方便自己或者其他人查看

• 单行注释：用 # 号

多行注释: 用 三引号 """这里面是注释的代码""

1.2、输入 与 输出

• 输入：和计算机交互

input("请输入金额 ")

• 输出：输出可以用开调试代码

print(num, "金额太大了")

• 输入与输出的打印：
  

二、Python语言源程序的书写格式与基本规则

• 2.1、Python语言源程序模块的初识一个Python程序可能由一个或多个模块组成。模块是程序的功能单元。Python模块的典型结构由：模块文档、模块导入、变量定义、类定义语句、函数定义语句、主程序 等组成。

• 模块文档:模块文档使用三引号注释的形式，简要的介绍模块的功能以及重要全局变量的含义。
• 模块导入:导入需要调用的其他模块。模块只能被导入一次，被导入模块中的函数代码并不会被自动执行，只能被当前模块主动（显式）调用。

• 2.2、基本词法单位、标识符/常量/运算符等构成规则与关键字

• Python的基本词法单位包括：常量、变量、关键字、运算符、表达式、函数、语句、类等。 常量：是指初始化（第一次赋予值）后保持固定不变的值。例如：1，3.14，'Hello!',False,这是4个不同类型的常量。在Python中没有命名常量，通常用一个不改变值的变量代替。比如：PI=3.14 通常用于定义圆周率常量PI。
  
• 标识符：用于不同的的词法单位，通俗的讲就是名字。标识符可以作为变量、函数、类的名字。合法的标识符必须遵守以下规则：

• 由一串字符组成，字符可以是任意字母、数字、下划线、汉字，但这些字符中的开头不能是数字。
  
• 不能与关键字同名。关键字也成为保留字，是被语言保护起来具有特殊含义的词，不能用于起名字。查看Python的语言的所有关键字（用Python自带的IDLE执行下面两句代码）

import keyword
keyword.kwlist

• 标识符中唯一能够使用的标点符号是下划线，不能含有其他标点符号（包含：空格、括号、引号、逗号、斜线、反斜线、冒号、句号、问号等）。

• 正确的标识符：X、varl、FirstName、stu_score、平均分2等
• 错误的标识符：stu-score、First Name、2平均分

• 变量：是指在运行的过程中值可以被修改的量。变量的名称除了必须符合标识符的构成规则外，要尽量遵循一些约定俗成的规范。以下划线开头的变量在Python中有特殊的含义，所以自定义名称时，一般不用下划线作为开头字符。此外，Python是严格区分大小写字母的。也就是说，Score和score会被认为是两个不同的名字。
  
• 运算符：指常量/变量之间进行何种运算。
  
• 表达式：由常量、变量加运算符构成。一个表达式可能包含多次多种运算，与数学表达式在形式上很接近。例如：1+2、2*(x+y)、0<=a<=10等。
  
• 函数：是相对独立的功能单位，可执行一定的任务。
  
• 语句：是由函数、表达式调用组成的。另外，各种控制结构也属于语句，例如： if语句、for语句。
  
• 类：是同一类事物的抽象。我们处理的数据都可以看做数据对象。Python是面向对象的程序设计语言，它是一个事物的静态特征（属性）和动态行为（方法）封装在一个结构里，称之为对象。

• 2.3、程序的书写格式与基本规则

• 2.3.1、缩进：使用缩进来区分代码块的级别。Python语言中没有采用花括号或begin...end等来分隔代码块，而是使用冒号和代码缩进来区分代码之间的层次。代码缩进是一种语法规则，错误的缩进可能导致代码的含义完全不同。如下2个代码块
  

• 建议使用在缩进代码前输入4个空格来表示代码缩进，不推荐其他数量的空格或使用制表符的方式来完成缩进。
• 2.3.2、分号：Python允许在行尾加分号，但不建议加分号，也不要用分号将两条命令放在同一行中。建议每一条命令单独一行。
  
• 2.3.3、长语句行：除非遇到长的导入模块语句或者注释里的URL，建议不宜超过80个字符。对于超长语句，允许但不提倡使用反斜杠连接行，建议在需要的地方使用圆括号来连接行。例如：

• 不推荐写法

year1 = 2016
 if year1 % 4 == 0 and year1 % 100 != 0 or \
    year1 % 400 == 0:
     print(year1,"是闰年！")
 else:
     print(year1,"不是闰年！")

• 推荐写法
  

year2 = 2018
if (year2 % 4 == 0 and year2 % 100 != 0 or
      year2 % 400 == 0):
     print(year2,"是闰年！")
else:
     print(year2,"不是闰年！")

• 2.3.4、括号：不建议使用不必要的括号，除非用于实现行连，否则不要在返回语句或者条件语句中使用括号，例如：

if (x):         # x两侧的括号多余
   foo()
if not (x):     # x两侧的括号多余
   foo()
return (x)      # x两侧的括号多余

• 2.3.5、空行：变量定义、类定义以及函数定义之间可以空两行。类内部的方法定义之间，类定义与第一个方法之间，建议一行。函数或方法中，如果有必要，可以空一行。

• 2.3.6、空格：对于赋值(=)、比较（==,<,>,!=,<>,<=,>=,in,not in,is,is not）、布尔（and,or,not）等运算符，在运算符两边各加一个空格，可以使代码更清晰。而对于算数运算符，可以按照自己的习惯决定，但建议运算符两侧保持一致。例如：

# 不推荐写法
x==1
# 推荐写法
x == 1

• 不建议在逗号、冒号、分号前面加空格，但建议在它们后面加空格（除了行尾之外）。例如：

# 推荐写法
if x == 0:
     print(x, y)
x, y = y, x
# 不推荐写法
if x == 0 :
     print(x , y)
x , y = y , x

• 参数列表，索引或切片的左括号前不要加空格。例如：

# 建议写法
func (1)
x[1] = y[3:5]
# 不建议写法
func   (1)
x [1] = y [3:5]

• 当等号用于指示关键字参数或默认参数值时，不建议在其两侧使用空格。例如：

# 推荐写法
def average(sum, num=100) : returen sum/num
# 不推荐写法
def average(sum, num = 100 ) : returen sum/num

• 不建议用空格来垂直对齐多行之间的标记，因为这会成为维护的负担（适用于:,#,=等）。例如：

# 建议写法(不整齐的注释)
 x = 1   # 注释
 score_1 = 2   # 不整齐的注释
 dictionary = {
      "ID":  1,
      "grade":  2,
    }
 # 不建议写法(整齐的注释)
 x = 1              # 注释
 score_1 = 2        # 整齐的注释
 dictionary = {
      "ID"     :  1,
      "grade"  :  2,
    }

• 2.3.7、注释：注释通常以#开始直到行尾结束。行内注释：和语句在同一行中的注释。行内注释应该以#和单个空格开始，应该至少用两个空格和前面的语句分开。注释块后面通常跟着代码，且注释块应该与相关代码的缩进一致。注释块中的每行以#和一个空格开始，注释块内段落以仅含单个#的行分割。注释块上下方最好各空一行。例如：

# 建议的写法
# 这个函数用于计算班级所有学生的平均分
#
# 例子： Avg(score,100)
def Avg(Score,Num):
      pass

• 2.3.8、文档字符串：是Python 语言独特的注释方式。文档字符串是包、模块、类或函数中的第一条语句。文档字符串可以通过对象__doc__成员被自动提取。我们书写文档字符串的时候，在其前、后使用三重双引号 """ 或三重单引号 '''。一个规范的文档字符串应该首先是一行概述，接着是一个空行，然后是文档字符串剩下的部分，并且应该与文档字符串的第一行的第一个引号对齐。例如：

def Avg(Score, Num=100):
      """ 计算班级的平均分
      从Score中读取所有学生的成绩，逐一加求总分，然后把总分除以人数Num,结果就是平均分，返回该结果
      参数
          Score: 记录所有学生的成绩列表
          Num:班级总人数，默认值是100
      返回值
          float类型的平均分
      """ 
    pass

• 文档字符串可以通过__doc__成员进行查看，也可以在help()函数的结果里

>>> print(Avg.__doc__)

• 文档字符串通常用于提供在线帮助信息。

三、Python的基本数据类型

• 3.1、数字

• Python: 的数字有 4 中数据类型：整数（int）、浮点数（float）、布尔值（bool）、复数（complex）。使用内置函数type(object)可以返回object的数据类型。内置函数instance(obj,class)可以用来测试对象objc是否为指定类型class的实例，例如：
  打印：数据类型

>>>   type (1)
>>>   <class 'int'>
>>>   type (1.0)
>>>   <class 'float'>
>>>   type ('1')
>>>   <class 'str'>

• 也可以使用isInstance()函数来判断某个对象是否是属于某个类型，例如：
  

>>> isinstance(1,int)
True
>>> isinstance('1',str)
True

• 3.1.2、整数：是不带小数部分的数字，如：100、0、-190。和其他大多数编程语言不同，Python的整数没有长度限制，甚至可以书写和计算有几百位数字的大整数。如：

>>> 9**100   #  9的100次方
265613988875874769338781322035779626829233452653394495974574961739092490901302182994384699044001

• Python的整数书写支持4种数制：十进制、二进制、八进制和十六进制。十进制数直接用默认方式书写，而后三种数制需要特殊的前缀，分别是0b、0o、0x,其中的字母也可以用大写字母。在十六进制数中，使用A~F这6个字母来代表十进制数10~15，换成小写字母a~f也是一样的。例如：

>>> 0b1010  
10
>>> 0o15
13
>>> 0x2f
47

• 3.1.2、浮点数：是带小数的数字，例如：4.、.5、-2.7315e2。其中4.相当于4.0，.5相当于0.5，-2.7315e2是科学计数法，相当于-2.7315*10^2,即-273.15。所谓 浮点是相对于定点而言的，即小数点不再固定于某个位置，而是可以浮动的。在数据存储长度有限的情况下，采用浮点表示方法，有利在数值变动范围很大或者数值很接近0时，仍能保证一定长度的有效数字。与整数不同，浮点数存在上限和下限。计算结果超出上限或者下限的范围会导致溢出错误。例如：

>>> 100.0**100
1e+200
>>> 100.0**1000
Traceback (most recent call last):
  File "<input>", line 1, in <module>
OverflowError: (34, 'Result too large')

• 注意：浮点数只能以十进制数形式书写。

需要说明的是，计算机不一定能够精确地表示程序中书写或计算的实数。有两个原因：1、因为存储有限，计算机不能精确地显示无限小数，会产生误差；2、计算机内部采用二进制数表示，但是，不是所有的二进制实数都可以用二进制数精确表示。

>>> 2/3
0.6666666666666666
>>> 1-2/3
0.33333333333333337

• 3.1.3、布尔值：布尔值就是逻辑值，只有两种：True 和 False ，分别代表“真” 和 “假”。Python 3.x中将True 和 False定义成了关键字,但实质上它们的值扔是 1 和 0；并且可以与数字类型的值进行算数运算。下面两个例子比较左右两个值是否相等：

>>> 1 == 1.0
True
>>> 123 == '123'
False

• 3.1.3、复数：是Python内置的数据类型，使用1j表示-1的平方根。复数对象有两个属性real和imag用于查看实部和虚部。例如：

>>> (3+4j)*(3-4j)
(25+0j)
>>> (3-4j).real
3.0
>>> (3-4j).imag
-4.0

• 3.2、字符串

• 3.2.1、字符串的组成

• 字符串（String）: 是由字符组成的序列，如'Python is wonderful!'、'1929288338'、'张三'、''等。其中，''表示空字符串。字符串和数字一样，都是不可变对象。所谓不可变，是指不能原地修改对象的内容。例如：

>>> a = b = 'abc'
>>> id(a)
4555430408
>>> id(b)
4555430408
>>> a = 'ABC'   # 修改了 a
>>> id(a)       # a 引用了另一处空间
4555453192
>>> b           # b 的内容不变，可见对字符串变量a赋值，并不是原地修改
'abc'

• 字符串界定符（String）:用来区分字符串和其他词法单位，有以下3种形式：

• 1、单引号，如 ','1+1=2','He said "how are you"'，当字符串中含有双引号时，最好使用单引号作为界定符。
• 2、双引号，如："","中国","It's my book."。当字符串中含有单引号的时，最好使用双引号作为界定符。
• 三引号，可以是三个连续的单引号，也可以是三个连续双引号，如：'''Hello''',"""您好"""。其常用于多行字符串，例如上面所说的文档字符串。

• 转移符: 是一些特殊的字符。Python

• 用反斜杠（\）来转义字符，以便表示那些特殊字符，如下：

• 下面是使用转义字符的例子：

>>> print("\"Greate!\"")
"Greate!"

• 原始字符串: 用于显示字符串原来的意思，不让转义符生效。这就要用r或R来定义原始字符串。例如：

>>> print(r'\t\n')
\t\n

• 如果不使用原始字符串，就得多次使用转移符\:

>>> print('\\t\\n')
\t\n

• 3.2.2、字符串操作的相关方法

• 字符串长度：使用lec()函数，可以确定字符串办好多少个字符，即字符串的长度。例如：

>>> len('abc 123')
7
>>> len('')
0
>>> len('a\nb\\c')
5

• 字符串连接：利用+运算符可以让两个字符首尾相连。例如：

>>> 'Python ' + 'Programming'
'Python Programming'

• 字符串重复：利用乘法运算符“*”可以让一个字符自身多次重复拼接在一起。例如：

>>> 10 * '=*='
'=*==*==*==*==*==*==*==*==*==*='

• 字符串索引： 利用方括号运算符[]可以通过索引值得到相应的位置（下表）的字符。Python的索引有两种：1、从前往后正向索引，n个字符的字符串，其索引值从0 至 n-1;2、从后向前的负数索引，n个字符的字符串，其索引值从 -1 至 -n。例如：

>>> s='Python'
>>> s[2]    # 注意：不能越界
't'
>>> s[-3]
'h'
>>> s[10]   # 下标越界了
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: string index out of range

• 字符串切片： 在Python中，可以使用切片（slice）从字符串中提取字符串。切片是Python序列的重要操作之一，适用于字符串、列表、元组、range对象等类型。切片的参数是两个冒号：分割的三个数字。第一个数字表示切片的开始位置（默认为0），第二个参数表示切片截止位置（但不包含这个位置，默认为字符串的长度），第三个数字表示切片的步长（默认为1），当步长省略时，可以顺便省略最后一个冒号。列入：

>>> a = 'Python'
>>> a[1:4]        # 切片实际包含索引位置为1~3的字符
'yth'
>>> a[:4]         # 省略第一个数字，表示切片从位置0开始
'Pyth'
>>> a[1:]         # 省略第二个数字，表示切片至字符串末尾结束
'ython'
>>> a[::]
'Python'
>>> a[::2]        #  步长为2
'Pto'
>>> a[::-1]       #  步长为-1，得到倒叙字符串
'nohtyP'
>>> a[:100]       #  截止位置越界，切片到末尾结束
'Python'
>>> a[100:]       #  起始位置越界，返回空字符串
''

• 与字符串的索引不同，切片操作不会因为下标越界而抛出异常，而是简单地在字符串尾部截断或者返回一个空字符串。因为字符串是不可变的对象，所以不能对字符串切片赋值。例如：

>>> a[::] = 'Java'
Traceback (most recent call last):
   File "<input>", line 1, in <module>
TypeError: 'str' object does not support item assignment

• 四、Python的基本运算和表达式

• 4.1、变量

• 4.1.1、变量的赋值与存储

• 变量的定义：在Python中没有专门的变量定义语句，变量定义是通过对变量第一次进行赋值来实现的。例如：

>>> x     # x为未定义的变量，不能访问
Traceback (most recent call last):
   File "<input>", line 1, in <module>
NameError: name 'x' is not defined
>>> x = 1   # 对x第一次赋值，也就是对x的定义。此后，x变量就存在了
>>> x
1
>>> x = 1.5    # 对 x 再次赋值，可以修改变量的值
>>> x
1.5
>>> del x      #  使用del命令删除x变量，之后变量x就不能再被访问            
>>> x
Traceback (most recent call last):
    File "<input>", line 1, in <module>
NameError: name 'x' is not defined

• 变量必须定以后才能被访问。Python中的变量比较灵活，同一个变量名称可以先后被赋予不同类型的值，定义为不同的变量对象参与计算。在上面：x一开始是一个整型变量，之后又变成了浮点型变量。
• 删除变量：使用del命令删除一个对象（包括变量、函数等），删除之后就不再能访问这个对象了，因为它已经不存了。当然，也可以通过再次赋值重新定义x变量。变量是否存在取决于变量是否占据一定的内存空间。当定义变量时，操作系统将内存空间分配给变量，该变量就存在了。当使用del命令删除变量后，操作系统释放了变量的内存空间，该变量就不存在了。Python具有垃圾回收机制，当一个对象的内存空间不再使用（引用计数为0）后，这个内存空间就会被自动释放。所以Python不会像C那样发生内存泄漏而导致内存不足甚至系统死机的现象。Python的垃圾回收是系统自动完成的，而del命令相当于程序主动地进行空间释放，将其还给操作系统。
  
• 变量引用： Python的变量实质是引用。
  
• 变量修改赋值： Python 变量是可以通过赋值来修改变量的值,但并不是原地址修改。变量的值并不是直接存储在变量里，而是以“值”对象的形式存储在内存某地址中。我们可以说变量指向那个“值”对象。因此，Python变量里存放的实际是“值”对象的位置信息（内存地址）。这种通过地址间接访问对象数据的方式，称为引用。
  使用id()函数可以确切地知道变量引用的内存地址，使用运算符`is可以判断两个变量是否引用同一个对象。例如：

>>> x = 1
>>> id(x)        #  使用id()查看x引用哪里
4553055232
>>> x = 2
>>> id(x)        #  再次查看，发现x的引用地址变了
4553055264
>>> y = 2
>>> id(y)        # 发现x和y引用同一处
4553055264
>>> x = 'Hello'
>>> y = 'Hello'
>>> x is y       #  利用运算符 is 可以判断两个变量是否引用同一个对象
True

• 当x和y都赋值为相同的小整数或者段字符串时，两个变量所引用的是同一个对象。这也被称为“驻留机制”。这是Python为提高效率所做的优化，节省了频繁创建和销毁对象的时间，也节省了存储的空间。但是，当两个变量赋值为相同的大整数或者长字符串时，默认引用的是两个不同的对象，例如：

>>>  x = 10*1000
>>>  y = 10*1000
>>>  x is y
False
>>>  x = 'Good morning.'
>>>  y = 'Good morning.'
>>>  x is y
False

• 但是我们可以通过变量之间的赋值让两个变量引用相同的对象。例如：

>>> y = x
>>>  x is y
True

• 4.1.2、变量类型的转换Python是强类型语言。当一个变量被赋值为一个对象以后，这个对象的类型就固定了。不能隐式转换为另一种类型。当运算需要的时，必须使用显示的变量类型转换。例如：input()函数所获得的输入值总是字符串，有时需要将其转换为数值类型，方能进行算术运算。例如：

>>> a = input('请输入一个整数：')
请输入一个整数：>? 3
>>> int(a)
3
>>> a
'3'

• 变量类型的转换并不是对变量原地进行修改，而是产生一个新的预期类型的对象。Python以转换目标类型名称提供类转换内置函数。

• float()函数： 将其其它类型数据转换为浮点数，例如：

>>>  float(1)
1.0
>>> float('1.23')
1.23
>>> float('1.2e-3')
0.0012
>>> float('1.2e-5')
1.2e-05

• str()函数： 将其他类型数据转换为字符串。例如：

>>> str(1)
'1'
>>> str(-1.0)
'-1.0'
>>> str(1.2e-3)
'0.0012'
>>> str(1.2e-5)
'1.2e-05'
>>> str(1.0e-5)   # 转换之后省略了'.0',因为1e-5和1.0e-5都是浮点型
'1e-05'

• 从上面可以看出，Python会尽可能转换成字符串长度较短的形式，以节省空间。
• int()函数： 将其他类型数据转换为整形。例如：

>>> int(3.14)
3
>>> int(3.5)
3
>>> int(True)  # 布尔值 True 相当于整数 1
1
>>> int(False)
0
>>> int('3')
3
>>> int('3.5')   # 有的字符串不能直接转化为整型
Traceback (most recent call last):
    File "<input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '3.5'
>>> int(float('3.5'))    # 分两步转换
3

• round()函数： 将浮点型数值圆整为整型。例如：

>>> round(1.4)
1
>>> round(1.5)    # 向上圆整
2
>>> round(2.5)   # 向下圆整为2
2

• 圆整计算总是“四舍”，但并不一定总是“五入”。因为总是逢五向上圆整会带来计算概率的偏差。所以，Python采用的是“银行家圆整”：将小数部分分为.5的数字圆整到最接近的偶数，即“四舍六入留双”。
• bool()函数： 将其他类型数据转换为布尔类型。例如：

>>> bool(0)    # 0转换为False
False
>>> bool(-1)    # 所有非 0 值 转换为 True
True
>>> bool('a')    # 非空字符串转换为 True
True
>>> bool('')     # 空字符串转换为 False
False

• char()和ord()函数：。进行整数和字符之间的相互转换：char()将一个整数按ASCII码转换为对应的字符，ord()是chr()的逆运算 ，把字符转换成对应的ASCII码或Unicode值。例如：

>>> chr(70)
'F'
>>> ord('f')
102

• 4.2、运算符Python支持算术运算符、赋值运算符、关系运算符、逻辑运算符等基本运算符。按照运算符所需要的操作数数目，可以分为单目、双目、三目运算符。

• 单目运算符：只需要一个操作数。例如：单目减（-），逻辑非（not）。
• 双目运算符：双目运算符需要两个操作。Python大多数运算符是双目运算符。
• 三目运算符：三目运算符需要三个操作数。条件运算是三目运算符，例如：a if b else c。

• 运算符具有不同的优先级。我们熟知的“先乘除后加减”就是优先级的体现。只不过，Python运算符种类多，优先级也分成了高低不同的很多层次。当一个表达式中有多个运算符的时，按优先级从高到低依次运算。
  运算符具有不同的结合性：左结合与右结合。当一个表达式中有多个运算符，且优先级都相同时，就根据结合性来判断运算的先后顺序。
  

• 左结合就是自左至右依次运算。Python运算大多数是左结合的。
• 右结合就是自右向左依次运算的。所有的单目运算符和圆括号()是右结合的。实际上圆括号是自右向左依次运算的，即内层圆括号更优先，从内向外运算。
  上面所说的通过优先级、结合性来决定运算次序，只在没有圆括号的情况下成立。使用圆括号可以改变运算符的运算次序。

• 4.3、算术算符下面是：Python的算术运算符

• 算术运算符的优先级，按照从低到高排列（同一优先级相同） 如下：

• 看几个例子

>>> x = 1
>>> -x     # - 也可以作为单目运算符
-1
>>> 5 % 3
2
>>> -5 % 3    # 余数的正负号和除数一致
1
>>> 5 % -3
-1
>>> -5 % -3
-2

• 上面都是相同类型的转换，如果不是同类型，则数据运算会产生隐士类型转换。转换的规则是：低类型向高类型转换。可以进行算术运算的各种数据类型，从低到高排列为： bool < int < float < complex。例如：

>>>  True + 1
2
>>> True + 1.5
2.5
>>> True + 1j
(1+1j)
>>> 1 + 1.5
2.5

• math模块中还定义了两个常量。

• math.pi: 数学常量 π，math.pi = 3.141592653589793。
  
• math.e: 数学常量 e，math.e = 2.718281828459045。
  使用math模块前首先导入，使用函数时要在函数名前加上“math”。例如：
  

>>>  import math
>>>  math.pi * math.sqrt(5)
7.024814731040727

• 如果要频繁使用某单一模块中的函数，为避免每次次写入模块名的麻烦，也可以按下面方式导入：
  

>>> from math import *
>>> pi * sqrt(5)
7.024814731040727

• 这样就可以像内置函数那样来使用模块函数了。但是多个模块中可能有同名函数，如果都按这个方式导入，会产生冲突的问题。
  
• 4.4、输入、输出

• 4.4.1、输入：输入语句可以再程序运行时从输入设备获得数据。标准输入设备就是键盘。通过input()函数可以获得键盘输入的数据。一般格式为
  

>>>  x = input('请输入数字：')

• input()函数首先会输出提示的字符串，然后等待用户键盘输入，直到用户按回车键结束，函数最后返回用户输入的字符串（不包括最后的回车符），系统继续执行input()函数后面的语句。其中 输入的内容会保存在 x 里面。如果想转换输入内容的类型，则使用相对应的函数即可。
  

• 4.4.2、输出：输出语句可以将程序的运行结果显示在输出设备上，供用户查看。标准的输出设备就是显示器屏幕。一般格式如下：
  

>>> print(<输出值 1>[,<输出值项 2>，... , <输出值项 n>,sep=', ',end='\n'])

• 通过print()函数将多个输出值转换为字符串并且输出，这些值之间以sep分隔，最后以end结束。sep默认为空格，end默认为换行。

>>> print('abc',123,sep='，',end=',')
abc，123,

• Python 的 print()函数中还可以使用字符串格式化控制输出。字符串的格式化形式： formart_string % obj,把对象objc按格式要求转换为字符串。

• 常见的格式字符如下：

>>> print("我的名字是%s" % "张三")   
我的名字是张三    # 即 %s 的位置使用"张三"代替

• 如果需要需要在字符串中通过格式化字符输出多个值，则每个对应值存在一对圆括号()中，值与值之间使用英文逗号隔开。例如：

>>>  print("%s 的年龄是 %d" % ("张三",20))

• 下面是一些格式化辅助命令

• 格式化输出例子：

>>> test = 5000
>>> print("%6d" % test)  # 输出宽度为6，前面有两个空格，右对齐
  5000
>>> print("%2d" % test)  # 输出宽度为2，但test 值宽度为4，按实际输出
5000
>>> print("%-6d" % test)  # 输出宽度为6，后面两个空格，左对齐
5000  
>>> print("%+6d" % test)   # 输出宽度为6，前面加一个空格，右对齐
 +5000
>>> print("%06d" % test)    # 输出宽度为6，前面加两个 0 ，空格改为0
005000
>>> print("%#od" % test)  # 以八进制数形式输出，前面添加 '0o'
0o11610d
>>> print("%#xd" % test)  # 以十六进制数形式输出，前面添加 '0x'
0x1388d

• m.n 格式常用于浮点数格式，科学计数法格式以及字符串格式的输出。对于前两种格式而言，%m.nf、%m.nX指输出的总宽度为m(可以省略)，小数点后面保留n位（四舍五入）。如果变量值的总宽度超出m,则按照实际输出。%m.ns 指输出字符串的宽度为m,输出前 n 个字符，前面补 m-n个空格。例如：

>>> test=128.3656
>>> print("%6.2f" % test)  # 输出实际宽度为6，小数点后面保留2位
128.37
>>> print("%3.1f" % test)  # 则按照实际宽度输出，小数点后面保留 1 位
128.4
>>> print("%.3ef" % test)  # 小数点后面保留 3 位
1.284e+02f
>>> test = "北京很漂亮"
print("%5.2s" % test)      # 输出的宽度为5，输出前两个字，前面有5-2=3个空格
   北京

• Python 3 还支持用格式化字符串的函数str.format()进行字符串格式化。该函数在形式上相当于通过{}来代替%，但功能更强大。例如：

>>> "{0}的年龄是{1}" .format ("张三",20)
'张三的年龄是20'

• format函数还可以用接收参数的方式对字符串进行格式化，参数位置可以不按顺序，参数也可以不用或者用多次。例如

>>> "{}的年龄是{}" .format ("张三",20)
'张三的年龄是20'
>>> "{name}的年龄是{age}" .format (age=20,name="张三")
'张三的年龄是20'
>>> "{0}的年龄是{1}" .format ("张三",20)
'张三的年龄是20'

• 4.5、赋值、关系 和 逻辑运算

• 4.5.1、赋值
  赋值运算一般用 “ = ” 表示，一般形式为：  变量 = 表达式, 其左边只能是变量，而不能是常量或者表达式。例如：5=x或者5=2+3都是错误的，左边必须是变量。注意：Python的赋值运算是没有返回值的。也就是说，赋值没有运算结果，只有效果----变量的值被改变了。例如：

>>> x = 5
>>> y = x      # 这里不是数学中的方程等式，不代表 y 值等于 x,赋值只是一个瞬间动作
>>> y
5

• 除了基本赋值外，赋值运算还包括：序列赋值、多目标赋值和 复合赋值。
• 4.5.2、关系运算符
  关系运算符也称为比较运算符，可以对两个数值或者字符串型数据进行大小比较，返回一个“真”或“假”的布尔值。
  关系运算符：

• 一定要注意比较是否相等要用双等号而不是单等号,在比较的过程中，遵循以下规则：1、两个操作数是数值型，则按大小进行比较。2、如两个操作数是字符串型，则按“字典顺序” 进行比较，即：首先取两个字符串的第一个字符进行比较较大的字符所在字符串更大；如果相同，则再取两个字符串的第二个字符进行比较，其余类推。结果有三种情况：第一种，某次比较分出胜负，较大的字符串所在字符串更大；第二种，始终不分胜负，并且两个字符串同时取完所有字符，那么这两个字符串相等；第三种，在分出胜负前，一个字符串已经取完所有字符，那么这个比较短的字符串较小。第三种情况也可以认为是空字符串和其他字符串比较，空字符串总是最小。
  常用字符串的大小关系是：空字符 < 空格 < '0'~'9' < 'A'~'Z'< 'a'~'z' < 汉字。

• 浮点数比较是否相等时要注意：因为有精度误差，可能产生本应该相等但比较结果却不相等的情况。例如：

>>> a = 0.1 + 0.1 + 0.1
>>> a == 0.3
False
>>> a 
0.30000000000000004

• 我们可以看出两个浮点数的差距是一个极小值来判定是否“应该相等”，这个“极小值”可以根据需要自行指定。例如：

>>> epsilon = 1e-6
>>> abs(a-0.3) < epsilon
True      # 复数不能比较大小，只能比较是否相等

• Python 允许 x < y < z 这样的链式比较，它相当于 x < y and y < z,可以用于 x < y > z 相当于 x < y and y > z。
  所有关系运算符的优先级相同。
• 4.5.3、逻辑运算符

• 逻辑运算符如下表

• 逻辑运算符的优先级，按照从低到高的顺序排列为： or < and < not。
  

• 4.6、表达式

• 表达式是由运算符和参与运算的数（操作数）组成。操作数可以是常量、变量，也可以是函数的返回值。
  
• 按照运算符的种类，表达式可以分成：算术表达式、关系表达式、逻辑表达式、测试表达式。
  
• 很多运算对操作数的类型有要求，例如，加法（+）要求两个操作数类型一致，当操作数类型不一致时，可能发生隐式类型转换,例如：

>>> x,y = 1,1.5
>>> a = x + y   # 整型和浮点型混合运算，整型隐式转换为浮点型
>>> a   
2.5

• 差别比较大的数据类型之间可能不会隐式类型扎转换,需要进行显示类型转换。例如：

>>> '3' + 1
Traceback (most recent call last):
     File "<input>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> int('3') + 1
4

• 常见运算符的优先级，按照从低到高的顺序排列（同一行优先级相同）总结如下：

• 表达式结果类型由操作数和运算符共同决定。

• 关系、逻辑和测试运算结果一定是逻辑值。
• 字符串进行连接 （+） 和重复 （*）的结果还是字符串。
• 两个整数操作进行算术运算的结果大多数还是整型的。浮点除法（/）的结果是浮点型的。幂运算的结果可能是浮点型的，如： 5** -2 返回值是0.04。
• 浮点型操作数进行算术运算的结果还是浮点型的。