Python-基础语法

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 8.9k 阅读时长 ≈ 8 分钟

请务必注意，Python程序是大小写敏感的，如果写错了大小写，程序会报错。

 
 

Python 基础语法

 
 

一. 标识符

一、标识符定义规则

  1. 在 Python 里，标识符由字母、数字、下划线组成。

  2. 在 Python 中，所有标识符不能以数字开头。

  3. Python 中的标识符是区分大小写的。

  4. 以下划线开头的标识符是有特殊意义的。

    1. 以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
    2. 以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

二、Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

|||
:-:|:-:|:-:|
and |exec |not
assert |finally |or
break |for |pass
class |from |print
continue |global |raise
def |if |return
del |import |try
elif |in |while
else |is |with
except |lambda |yield


二. 缩进(代码块)

一、注意事项：

  1. 学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

  2. 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行！！！

  3. 按照约定俗成的管理，应该始终坚持使用4个空格的缩进；

  4. 很多Python程序员都建议每行不超过80字符（最多79个见多）；

  5. 要将程序的不同部分分开，可使用空行，但不要在程序文件中过多地使用空行


以下代码将会执行错误：缩进空白数量不一样会报错！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

if True:
    print "Answer"
    print "True"
else:
    print "Answer"
    # 没有严格缩进，在执行时会报错
  print "False"

执行以上代码，会出现如下错误提醒：
$ python test.py  
  File "test.py", line 10
    print "False"
                ^
IndentationError: unindent does not match any outer indentation level

二、多个语句构成代码块

  1. Python不像C/C++/Java一样一条语句是以;结束，而是换行即表示一个语句结束。

  2. 缩进相同的一组语句构成一个代码块，我们称之代码组。

  3. 像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行缩进代码构成代码组。注意这里冒号( : )不能省略。


如下实例的冒号不能省略：

1
2
3
4
5
6
if expression : 
   suite 
elif expression :  
   suite  
else :  
   suite

三. 一行和多行语句

一行分为：

  1. 同一行显示多条语句;
  2. 将一行的语句分为多行显示(一条语句以多行来书写)也包括在多行语句里面来讲。

1. 同一行显示多条语句

Python可以在同一行中使用多条语句，语句之间使用分号( ; )分割，以下是一个简单的实例：

1
2
3
4
5
6
#!/usr/bin/python

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

运行输出：
runoob

3. 一条语句以多行来书写

看下面的多行语句即可，是同一个意思。


3. 多行语句

多行：

  1. Python语句中一般以新行作为语句的结束符，但是我们可以使用斜杠（ \ ）将一行的语句分为多行显示，斜杠（ \ ）称为多行连接符。

  2. 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。

  3. Python语句中一般以新行作为语句的结束符。但是我们可以使用斜杠（ \ ）将一行的语句分为多行显示，如下所示：

1
2
3
total = item_one + \
        item_two + \
        item_three

  1. 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
1
2
days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

四. 引号

  1. Python 可以使用单引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，引号的开始与结束必须的相同类型的。

  2. 其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

如下示例：

1
2
3
4
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

五. 注释

  1. python中单行注释采用 # 开头。
  2. python 中多行注释使用三个单引号( ''' )或三个双引号( """ )。

单行注释,如下示例1：

1
2
3
4
5
6
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

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

多行注释,如下示例2： 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py


'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

六. 空行

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

什么是空行？

1
2
3
4
5
a=2+3
print(a)
           #这里就是空行
b=a+3
print(b)

七. 输出(print)

Python3.0以后的输出使用print()函数。分为换行输出和不换行输出。
在print()括号中加上字符串，就可以向屏幕上输出指定的文字。括号里还可以放表达式等……

  1. 换行输出：print 默认输出是换行的
  2. 不换行输出：将括号里的所有参数输出在一行，只需要在每一个参数后面加一个,即可。注意：
  1. 最后一个参数后面没有,，也就是和普通函数使用一样；
  2. 参数中间的,输出来是一个空格。如下：
  3. 循环输出变量b的时候如果不换行，可在后面加个end=' '，即print(b, end=' ')
1
2
3
4
print('Thequickbrownfox', 'jumpsover', 'thelazydog')

运行结果：
Thequickbrownfox jumpsover thelazydog


7.1 输出的补充

Python的三种输出：

  1. Python两种输出值的方式: 表达式语句和print()函数；
    1. 如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
    2. 如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现.
  2. 第三种方式是使用文件对象的 write() 方法，标准输出文件可以用sys.stdout引用！

7.2 输出时常用的函数

  • str()： 将对象转化为适于人阅读的形式，函数返回一个对象的string格式。
  • repr()： 将对象转化为供解释器读取的形式，返回一个对象的 string 格式。可以输出包括转义字符在内的所有字符！
  • end=' '： 循坏输出时常用于不换行输出。
  • str.format() ：格式化输出。

举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
x = "'abcd\ne\nfg'"
print(str(x))
print(repr(x))

output：
'abcd
e
fg'
"'abcd\ne\nfg'"
------------------------------------------------------------------------------------------
'''repr() 的参数可以是 Python 的任何对象'''
x = 10 * 3.25
y = 200 * 200
print(repr((x, y, ('Google', 'Runoob'))))

output： (32.5, 40000, ('Google', 'Runoob'))
------------------------------------------------------------------------------------------
'''  我们都知道正常情况下将多个字符串输出在一行直接使用半角逗号,分隔即可。但是循坏输出要想不换行就得
使用 end=' '了  '''

a = [1,2,3,4,5,6]
for x in a:
  print(x)
print('\n----------分隔符-----------') 
for y in a: 
  print(y,end='')
print('\n----------分隔符-----------') 
for y in a: 
  print(y,end='w')
print('\n----------分隔符-----------') 
for y in a: 
  print(y,end=' ')
OUTPUT：
1
2
3
4
5
6

----------分隔符-----------
123456
----------分隔符-----------
1w2w3w4w5w6w
----------分隔符-----------
1 2 3 4 5 6

7.3 str.format()格式化字符串

旧式的格式化输出在[Python-基础语法]里面讲过，这里的str.format()就是新版的格式化的一种形式。

语法：字符串类型格式化采用format()方法，基本使用格式是：
<模板字符串>.format(<逗号分隔的参数>)

所谓的**str.format()**：即.format()前是一个字符串，字符串里面有{}相当于旧书式的%。{}及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。分为以下几种使用方法：


  1. 在括号中的数字用于指向传入对象在 format() 中的索引位置，如下所示：
1
2
3
4
5
6
print('{0} 和 {1}'.format('Google', 'Runoob'))
print('{1} 和 {0}'.format('Google', 'Runoob'))

OUTPUT：
Google 和 Runoob
Runoob 和 Google

  1. 在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。也可以位置及关键字参数可以任意的结合:
1
2
3
4
5
6
7
8
9
print('{0} 和 {1}'.format('Google', 'Runoob'))
print('{1} 和 {0}'.format('Google', 'Runoob'))
print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob',
                                                       other='Taobao'))

OUTPUT：
Google 和 Runoob
Runoob 和 Google
站点列表 Google, Runoob, 和 Taobao。

  1. 在 {} 里使用 !a (使用 ascii()), !s(使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:
1
2
3
4
5
6
7
import math
print('常量 PI 的值近似为： {}。'.format(math.pi))
print('常量 PI 的值近似为： {!s}。'.format(math.pi))

OUTPUT:
常量 PI 的值近似为： 3.141592653589793。
常量 PI 的值近似为： 3.141592653589793。

  1. 可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。

format()方法中<模板字符串>的{}除了包括参数序号，还可以包括格式控制信息。此时，{}的内部样式如下：

     {<参数序号>: <格式控制标记>}
     
其中，<格式控制标记>用来控制参数显示时的格式，包括：**<填充><对齐><宽度>,<.精度><类型>** 6 个字段，这些字段都是可选的，可以组合使用，逐一介绍如下。参考：[Python字符串格式化–format()方法]

1.jpg


<宽度>
指当前槽的设定输出字符宽度，如果该槽对应的format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。

<对齐>
指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。

<填充>
指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

s = "PYTHON"
 
"{0:30}".format(s)
Out[17]: 'PYTHON                        '
 
"{0:>30}".format(s)
Out[18]: '                        PYTHON'
 
"{0:*^30}".format(s)
Out[19]: '************PYTHON************'
 
"{0:-^30}".format(s)
Out[20]: '------------PYTHON------------'
 
"{0:3}".format(s)

Out[21]: 'PYTHON'

逗号（，）
<格式控制标记>中逗号（，）用于显示数字的千位分隔符，例如：

1
2
3
4
5
6
7
8
"{0:-^20,}".format(1234567890)
Out[24]: '---1,234,567,890----'
 
"{0:-^20}".format(1234567890) #对比输出
Out[25]: '-----1234567890-----'
 
"{0:-^20,}".format(12345.67890)
Out[26]: '----12,345.6789-----'

<.精度>
表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。

<类型>
表示输出整数和浮点数类型的格式规则。对于整数类型，输出格式包括6 种：

  • b: 输出整数的二进制方式；
  • c: 输出整数对应的 Unicode 字符；
  • d: 输出整数的十进制方式；
  • o: 输出整数的八进制方式；
  • x: 输出整数的小写十六进制方式；
  • X: 输出整数的大写十六进制方式；
1
2
3
4
5
6
7
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
...
Runoob     ==>          2
Taobao     ==>          3
Google     ==>          1

对于浮点数类型，输出格式包括4 种：

  • e: 输出浮点数对应的小写字母 e 的指数形式；
  • E: 输出浮点数对应的大写字母 E 的指数形式；
  • f: 输出浮点数的标准浮点形式；
  • %: 输出浮点数的百分形式。

  1. 如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。

最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :

1
2
3
4
5
6
7
8
9
10
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3


也可以通过在 table 变量前使用 '**' 来实现相同的功能：

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3

八. 输入(input)

  1. 函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量（指针）中，以方便你使用。
  2. input()函数有个返回值，返回类型为String。

一、参数

输入分为两种：空参数、带有参数。

空参数：input()；效果是屏幕上没有任何提示，等待用户输入。
带有参数：input('请输入一个字符串：')；效果是屏幕上显示“请输入一个字符串：”，然后等待用户输入。

二、返回值

关于input()的返回值，是字符串String类型
如下会报错，假如输入1998，返回给s的值是字符串”1998”，如果直接和数字型进行比较会报错：

1
2
3
4
5
6
s = input('birth: ')
birth = s
if birth < 2000:
    print('00前')
else:
    print('00后')

解决方法是使用函数int(str)，功能是将字符串类型转换成数字型。

1
2
3
4
5
6
s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')