1、切片
平常我们要想取 list 或者 tuple 中指定索引范围的元素&＃xff0c;可能需要通过循环&＃xff0c;比较麻烦。Python 中提供了切片(Slice)操作符&＃xff0c;能大大简化这种操作。
>>> L &＃61; [&＃39;Michael&＃39;, &＃39;Sarah&＃39;, &＃39;Tracy&＃39;, &＃39;Bob&＃39;, &＃39;Jack&＃39;]#取前3个元素&＃xff0c;用一行代码就可以完成切片&＃xff1a;
>>> L[0:3]
[&＃39;Michael&＃39;, &＃39;Sarah&＃39;, &＃39;Tracy&＃39;]#也可以从索引1开始&＃xff0c;取出2个元素出来&＃xff1a;
>>> L[1:3]
[&＃39;Sarah&＃39;, &＃39;Tracy&＃39;]#也支持倒数切片&＃xff1a;
>>> L[-2:]
[&＃39;Bob&＃39;, &＃39;Jack&＃39;]>>> L[-2:-1]
[&＃39;Bob&＃39;]
L[0:3]表示&＃xff0c;从索引0开始取&＃xff0c;直到索引3为止&＃xff0c;但不包括索引3。即索引0&＃xff0c;1&＃xff0c;2&＃xff0c;正好是3个元素。
如果第一个索引是0&＃xff0c;还可以省略&＃xff1a;
>>> L[:3]
[&＃39;Michael&＃39;, &＃39;Sarah&＃39;, &＃39;Tracy&＃39;]
用法示例&＃xff1a;
>>> L &＃61; list(range(100))>>>L
[0,1, 2, 3, ..., 99]#前10个数&＃xff1a;
>>> L[:10]
[0,1, 2, 3, 4, 5, 6, 7, 8, 9]#后10个数&＃xff1a;
>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]#前10个数&＃xff0c;每两个取一个&＃xff1a;
>>> L[:10:2]
[0,2, 4, 6, 8]#所有数&＃xff0c;每5个取一个&＃xff1a;
>>> L[::5]
[0,5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]#甚至什么都不写&＃xff0c;只写[:]就可以原样复制一个list&＃xff1a;
>>>L[:]
[0,1, 2, 3, ..., 99]
tuple 也可以用切片操作&＃xff0c;只是操作的结果仍是tuple。字符串&＃39;xxx&＃39;也可以看成是一种list&＃xff0c;每个元素就是一个字符。因此&＃xff0c;字符串也可以用切片操作&＃xff0c;只是操作结果仍是字符串。
#tuple切片操作
>>> (0, 1, 2, 3, 4, 5)[:3]
(0,1, 2)#字符串切片操作
>>> &＃39;ABCDEFG&＃39;[:3]&＃39;ABC&＃39;
>>> &＃39;ABCDEFG&＃39;[::2]&＃39;ACEG&＃39;
在很多编程语言中&＃xff0c;针对字符串提供了很多各种截取函数(例如&＃xff0c;substring)&＃xff0c;其实目的就是对字符串切片。Python没有针对字符串的截取函数&＃xff0c;只需要切片一个操作就可以完成&＃xff0c;非常简单。
2、迭代(for循环)
如果给定一个list或tuple&＃xff0c;我们可以通过for循环来遍历这个list或tuple&＃xff0c;这种遍历我们称为迭代(Iteration)。Python的for循环不仅可以用在list或tuple上&＃xff0c;还可以作用在其他可迭代对象上。只要是可迭代对象&＃xff0c;都可以迭代。
默认情况下&＃xff0c;dict迭代的是key。如果要迭代value&＃xff0c;可以用for value in d.values()&＃xff0c;如果要同时迭代key和value&＃xff0c;可以用for k, v in d.items()。
>>> d &＃61; {&＃39;a&＃39;: 1, &＃39;b&＃39;: 2, &＃39;c&＃39;: 3}
>>> for key ind:
... print(key)
...
a
c
b
字符串也是可迭代对象&＃xff0c;因此&＃xff0c;也可以作用于for循环&＃xff1a;
>>> for ch in &＃39;ABC&＃39;:
... print(ch)
...
A
B
C
我们可以通过 Python 内置的enumerate函数将一个list变成索引-元素对&＃xff0c;这样就可以在for循环中同时迭代 list 的索引和元素本身&＃xff1a;
>>> for i, value in enumerate([&＃39;A&＃39;, &＃39;B&＃39;, &＃39;C&＃39;]):
... print(i, value)
...
0 A
1B
2 C
2.1、如何判断对象是否是可迭代对象
我们可以通过 collections 模块的 Iterable 类型来判断如何判断一个对象是否是可迭代对象&＃xff1a;
>>> from collections importIterable
>>> isinstance(&＃39;abc&＃39;, Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
3、推导式语法(一行代码创建list、set、dictionary)
列表生成式即List Comprehensions&＃xff0c;是Python内置的非常简单却强大的可以用来创建list的生成式。
举个例子&＃xff0c;要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))&＃xff1a;
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
但如果要生成[1x1, 2x2, 3x3, ..., 10x10]可能我们就需要用到循环。
但是在 Python 中&＃xff0c;用列表生成式则可以用一行语句代替循环生成所需的list。写列表生成式时&＃xff0c;for前面的是一个表达式&＃xff0c;把要生成的元素的组成规则放到前面&＃xff0c;后面跟for循环&＃xff0c;就可以把list创建出来。
#用循环创建&＃xff0c;略显麻烦&＃xff1a;
>>> L &＃61;[]>>> for x in range(1, 11):
... L.append(x*x)
...>>>L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]#用列表生成式一行代码即可创建&＃xff1a;
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]#for循环后面还可以加上if判断&＃xff0c;这样就可以筛选出仅偶数的平方&＃xff1a;
>>> [x * x for x in range(1, 11) if x % 2 &＃61;&＃61;0]
[4, 16, 36, 64, 100]
还可以使用两层循环&＃xff0c;可以生成全排列&＃xff1a;
>>> [m &＃43; n for m in &＃39;ABC&＃39; for n in &＃39;XYZ&＃39;]
[&＃39;AX&＃39;, &＃39;AY&＃39;, &＃39;AZ&＃39;, &＃39;BX&＃39;, &＃39;BY&＃39;, &＃39;BZ&＃39;, &＃39;CX&＃39;, &＃39;CY&＃39;, &＃39;CZ&＃39;]
集合和字典同时也支持这种语法&＃xff1a;
#推导式生成集合
a &＃61; {x for x in &＃39;abracd&＃39; if x not in &＃39;abc&＃39;} #{&＃39;r&＃39;, &＃39;d&＃39;}
#推导式生成字典
{x: x**2 for x in (2, 4, 6)} #{2: 4, 4: 16, 6: 36}
4、__name__属性(注意是双下划线)
一个模块被另一个程序第一次引入时&＃xff0c;其主程序将运行。如果我们想在模块被引入时&＃xff0c;模块中的某一程序块不执行&＃xff0c;而仅在该模块自身运行时才执行&＃xff0c;此时我们可以用__name__属性来进行控制&＃xff1a;
#!/usr/bin/python3#Filename: using_name.py
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:print(&＃39;程序自身在运行&＃39;)else:print(&＃39;我来自另一模块&＃39;)
运行如下&＃xff1a;
#执行脚本本身
$ python using_name.py
程序自身在运行#在其他模块引入该模块
$ python>>> importusing_name
我来自另一模块
每个模块都有一个__name__属性&＃xff0c;当其值是&＃39;__main__&＃39;时&＃xff0c;表明该模块自身在运行&＃xff0c;否则是被引入。
5、异常的捕获和抛出(try...except、raise)
5.1、try...except
python 中捕获用 try... except 语法&＃xff1a;
importsystry:
f&＃61; open(&＃39;myfile.txt&＃39;)
s&＃61;f.readline()
i&＃61;int(s.strip())exceptOSError as err:print("OS error: {0}".format(err))exceptValueError: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 子句&＃xff0c;如果使用这个子句&＃xff0c;那么必须放在所有的 except 子句之后。else 子句将在 try 子句没有发生任何异常的时候执行。
for arg in sys.argv[1:]:try:
f&＃61; open(arg, &＃39;r&＃39;)exceptIOError:print(&＃39;cannot open&＃39;, arg)else:print(arg, &＃39;has&＃39;, len(f.readlines()), &＃39;lines&＃39;)
f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好&＃xff0c;这样可以避免一些意想不到&＃xff0c;而 except 又无法捕获的异常。
5.3、try...except..finally
try-finally 语句无论是否发生异常都将执行最后的代码。
以下实例中 finally 语句无论异常是否发生都会执行&＃xff1a;
try:
runoob()exceptAssertionError as error:print(error)else:try:
with open(&＃39;file.log&＃39;) as file:
read_data&＃61;file.read()exceptFileNotFoundError as fnf_error:print(fnf_error)finally:print(&＃39;这句话&＃xff0c;无论异常是否发生都会执行。&＃39;)
5.4、抛出异常
Python 使用 raise 语句抛出一个指定的异常&＃xff0c;raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类(也就是 Exception 的子类)。
raise [Exception [, args [, traceback]]]
实例&＃xff1a;
x &＃61; 10
if x > 5:raise Exception(&＃39;x 不能大于 5。x 的值为: {}&＃39;.format(x))
如果你捕获了一个异常&＃xff0c;但并不想去处理它&＃xff0c;那么一个简单的 raise 语句就可以再次把它抛出&＃xff1a;
try:raise NameError(&＃39;HiThere&＃39;)exceptNameError:print(&＃39;An exception flew by!&＃39;)raise
#异常被抛出
An exception flew by!
Traceback (most recent call last):
File"", line 2, in?
NameError: HiThere
6、global 和 nonlocal关键字
当函数的内部作用域想修改外部作用域的变量时&＃xff0c;就要用到global和nonlocal关键字。
以下实例修改全局变量 num&＃xff1a;
#!/usr/bin/python3
num&＃61; 1
deffun1():global num #需要使用 global 关键字声明
print(num)
num&＃61; 123
print(num)
fun1()print(num)
上面代码将依次输出&＃xff1a;1 123 123
如果要修改嵌套作用域(非全局作用域)中的变量则需要 nonlocal 关键字了&＃xff0c;如下实例&＃xff1a;
#!/usr/bin/python3
#下面将依次输出 100 100
defouter():
num&＃61; 10
definner():
nonlocal num#nonlocal关键字声明
num &＃61; 100
print(num)
inner()print(num)
outer()
京公网安备 11010802041100号