python笔记

python3 基础教程 笔记

循环

Python的循环有两种。

for...in循环

• for...in循环依次把list或tuple中的每个元素迭代出来
• for(关键字) item(元素) in(关键字) iterable(集合):
  do something:

>>> names = ['Michael', 'Bob', 'Tracy']	//遍历names
>>> for name in names:
...	print(name)
Michael
Bob
Tracy
>>> sum = 0	//计算1-10的整数之和
>>> for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
...	sum = sum + x
... print(sum)
>>> list(range(5))	//生成的序列是从0开始小于5的整数：
[0，1, 2, 3, 4]
>>> sum = 0	//累加1-100
>>> for x in range(101)	//range(101)生成0-100的整数序列
...	sum = sum + x
...	print(sum)
...
5050

while循环

while循环，只要条件满足，就不断循环，不满足是退出循环。
实现100以内的所有奇数之和：

>>> sum = 0
>>> n = 99
>>> while n > 0:
...	sum = sum + n
...	n = n - 2
...	print(sum)
...

小结:

• 循环是让计算机做重复任务的有效的方法。
• 当代码写的有问题时，程序会陷入“死循环”,可以Ctrl+C退出或kill掉python

进程

递归

递归函数小结

• 使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出
• 针对尾递归优化的语言可以通过尾递归防止栈溢出。
• 尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

切片

切片（Slice）操作符-->取指定索引范围的操作

切片操作

>>> L['Micahel', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> L[0:3] 	//取前三个元素,表示从索引0开始到索引3，但不包括索引3
['Micheal', 'Sarah', 'Tracy']	
>>> L[:3]	//第一个索引是0的话，省略
['Micheal', 'Sarah', 'Tracy']
>>> L[-2:]	//取倒数的第二个元素到最后的元素
['Bob', 'Jack']
>>> L[-2:-1]	//去倒数第二个元素，索引3，但不包括索引4
['Bob']
>>>
>>> L = list(range(100))
>>> L
[0, 1, 2, 3, ..., 99]
>>> L[:10]	//前10个数
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L[-10:]	//后10个数
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> L[10:20]	//前11-20个数
>>> [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> L[:10:2]	//前10个数，每两个取一个
[0, 2, 4, 6, 8]
>>> L[::20]	//所有数每20个取一个
[0, 20, 40, 60, 80]
>>> L[:]	//原样复制一个list
[0, 1, 2, 3, ..., 99]

tuple也是一种list，区别与tuple不可变

tuple的切片操作

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

小结：

• 有了切片操作，很多地方循环就不在需要了。
• Python的切片非常灵活，一行代码可以实现很多行循环才能实现的操作。

迭代

迭代（Iteration）：给定一个list或tuple，通过for循环来遍历这个list或tuple

迭代操作

只要是可迭代对象，无论有无下标都可迭代。如dict，list,str，字符串等
默认，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:	//迭代dict
...	print(key)
...
a
b
c
>>> for ch in 'ABC':	//迭代字符串
...	print(ch)
...
A
B
C

判断是否是可迭代对象

使用collection模块的Iterable类型判断:

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

使用Python内置的enumerate函数实现list类似Java那样的下标循环
enumerate函数可以把一个list编程索引-元素对，for循环就可对其同时迭代

>>> for i, value in enumerate(['A', 'B', 'C']):		
...	print(i, value)
...
0 A
1 B
2 C
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:	//同时引用两个变量
... print(x, y)
...
1 1
2 4
3 9

小结：

• 任何可迭代的对象都可以用于for循环，包括我们自定义的
• 只要符合迭代条件，就可以使用for循环

列表生成式

列表生成式（List Comprehensions）是Python内置的可以用来创建list的生成式

生成式操作：

>>>list （range(1, 11)	//生成list[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> L = []	//生成[1*1, 2*2, ..., 10*10]
>>> 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]
>>> [x * x for x in range(1, 11) if x % 2 == 0]	//用if筛选出偶数的平方
[4, 16, 36, 64, 100]
>>> [m + n for m in 'ABC' for n in 'XYZ']	//用两层循环生成全排列
['AX', 'AY', 'AZ', 'BX', 'BY'，‘BZ', 'CX', 'CY', 'CZ']

实例：列出当前目录下的所有文件和目录名

>>> import os # 导入os模块
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop',
'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures',
'Public', 'VirtualBox VMs', 'Workspace', 'XCode']

同时使用两个或多个变量

>>> d = {'x':'A', 'y':'B', 'z':'C'} //使用for循环
>>> for k, v in d.items():	//dict的item()可以同时迭代key和value
...	print(k, '=', v)
...
y = B
x = A
z = C
>>> [k + '=' + v for k, v in d.items()]	//使用列表生成式
['y=B', 'x=A', 'z=C']
>>> L = ['Hello', 'World', 'IBM', 'apple']
>>> [s.lower() for s in L]	//把list中所有字符串变成小写
['hello', 'world', ibm', 'apple']

小结：

• 运用列表生成式，可以快速生成list，可以通过一个list推导出另一个list，而

代码十分简洁

生成器

• 通过列表生成式可以直接创建一个列表，但是由于内存限制，列表容量有限。
• 在创建一个很大的列表，仅使用前几个元素时，就浪费了绝大部分空间。
• 生成器(gnerator)：不创建完整的list，采取一边循环一边计算的机制。

创建generator

>>> L = [x * x for x in range(10)]	//使用[]创建list
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))	//使用()创建generator
>>> g
<generator object <genexpr> at 0x1022ef630>

打印出generator的每一个元素

>>> next(g)	//generator保存是算法，调用next(g)就计算出g的下一个值
0
>>> next(g)
1
...
>>> next(g)
81
>>> next(g)	//计算到最后的元素，没有更多元素，抛出StopIteration错误
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
StopIteration

使用for循环调用next(g)

>>> g = (x * x for x in range(10))
>>> for n in g:		//使用for来迭代就不用担心StopIteration
...	print(n)
...
0
1
4
...
81

实现斐波拉切数列函数

def fib(max):	//不使用generator实现
	n, a, b = 0, 0, 1
	while n < max:
		print(b)
		a, b = b, a + b
		n = n + 1
	return 'done'

fib函数调用

>>> f = fib(6)
>>> f
1
1
2
3
5
8
'done'

使用generator实现斐波拉切数列函数

def fib_generator(max)：//使用generator实现
	n, a, b = 0, 0, 1
	while n < max:
		yield b		//包含yield关键字，函数就是一个generator
		a, b = b, a + b
		n = n + 1
	return 'done'

fib_generator函数调用

>>> f = fib_generator(6）
>>> f
<generator object fib at 0x104feaaa0>

捕获StopIteration错误

>>> g = fib(6)
>>> while True:
...	try:
...		x = next(g)
...		print('g:' x)
...	except StopIteration as e:
...		pritnt('Generator return value:', e.value)
...	break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

小结：

• generator是非常强大。
• generator工作原理：它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。
• 函数改generator：遇到return语句或执行到函数体最后一行语句结束(generator指令)，for循环随着结束。