Python3的一些常用语法和属性

1、切片

平常我们要想取 list 或者 tuple 中指定索引范围的元素，可能需要通过循环，比较麻烦。Python 中提供了切片（Slice）操作符，能大大简化这种操作。

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

# 取前3个元素，用一行代码就可以完成切片：
>>> L[0:3]
['Michael', 'Sarah', 'Tracy']

# 也可以从索引1开始，取出2个元素出来：
>>> L[1:3]
['Sarah', 'Tracy']

# 也支持倒数切片：
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

如果第一个索引是0，还可以省略：

>>> L[:3]
['Michael', 'Sarah', 'Tracy']

用法示例：

>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]

#前10个数：
>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#后10个数：
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

#前10个数，每两个取一个：
>>> L[:10:2]
[0, 2, 4, 6, 8]

#所有数，每5个取一个：
>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

#甚至什么都不写，只写[:]就可以原样复制一个list：
>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple 也可以用切片操作，只是操作的结果仍是tuple。字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串。

#tuple切片操作
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

#字符串切片操作
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

2、迭代（for循环）

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。只要是可迭代对象，都可以迭代。

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

字符串也是可迭代对象，因此，也可以作用于for循环：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

我们可以通过 Python 内置的enumerate函数将一个list变成索引-元素对，这样就可以在for循环中同时迭代 list 的索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

2.1、如何判断对象是否是可迭代对象

我们可以通过 collections 模块的 Iterable 类型来判断如何判断一个对象是否是可迭代对象：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

3、推导式语法（一行代码创建list、set、dictionary）

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]可能我们就需要用到循环。

但是在 Python 中，用列表生成式则可以用一行语句代替循环生成所需的list。写列表生成式时，for前面的是一个表达式，把要生成的元素的组成规则放到前面，后面跟for循环，就可以把list创建出来。

#用循环创建，略显麻烦：
>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#用列表生成式一行代码即可创建：
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#for循环后面还可以加上if判断，这样就可以筛选出仅偶数的平方：
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可以使用两层循环，可以生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

集合和字典同时也支持这种语法：

#推导式生成集合
a = {x for x in 'abracd' if x not in 'abc'}   #{'r', 'd'}

#推导式生成字典
{x: x**2 for x in (2, 4, 6)}  #{2: 4, 4: 16, 6: 36}

4、__name__属性（注意是双下划线）

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，而仅在该模块自身运行时才执行，此时我们可以用__name__属性来进行控制：

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

运行如下：

#执行脚本本身

$ python using_name.py
程序自身在运行

#在其他模块引入该模块

$ python
>>> import using_name
我来自另一模块

每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

5、异常的捕获和抛出（try...except、raise）

5.1、try...except

python 中捕获用 try... except 语法：

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

5.2、try...except...else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。else 子句将在 try 子句没有发生任何异常的时候执行。

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。

5.3、try...except..finally

try-finally 语句无论是否发生异常都将执行最后的代码。

以下实例中 finally 语句无论异常是否发生都会执行：

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

5.4、抛出异常

Python 使用 raise 语句抛出一个指定的异常，raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

raise [Exception [, args [, traceback]]]

实例：

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

如果你捕获了一个异常，但并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出：

try:
      raise NameError('HiThere')
except NameError:
      print('An exception flew by!')
      raise

#异常被抛出
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

6、global 和 nonlocal关键字

当函数的内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字。

以下实例修改全局变量 num：

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

上面代码将依次输出：1  123   123

如果要修改嵌套作用域（非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

#!/usr/bin/python3

#下面将依次输出  100  100
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()