廖雪峰Python学习记

抖个机灵python = p ,y ,tong

几种循环

1. range 得到的循环

for i in range(10):
	print(i,end = ' ')
	
#结果是
0123456789

2. list（列表）类型的循环

for i in list(range(10,21,2)):
	print(i,end = ' ')

结果是

10 12 14 16 18 20

3. 字典类型的循环

#定义一个字典
diction = {'A':60,'B':70,'C':80}
for i in diction.values():
	print(i,end = ' ')

结果是

60 70 80

字典类型有几种可以与循环共同搭配的函数

• items() 返回一个由元组构成的列表，每个元组包含一个键-值对
• keys() 返回字典中键值的列表
• values() 返回字典中内容的列表

for i in diction.keys():
	print(i,end = ' ')
for j in diction.values():
	print(j,end = ' ')
for k,w in diction.items():
	print('keys:%s' %k)
	print('values:%s' %w)

结果是

A B C
60 70 80
keys:A
values:60
keys:B
values:70
keys:C
values:80

函数的一些总结

1. 递归函数

递归函数重要的思想是回推思想一会在汉诺塔问题上会有详细的解释

首先，定义一个递归函数需要两个因素：

• 1.初始值
• 2.返回值是上一层的递归函数
  例如：比较老生常谈的斐波那契数列

def fact(n):
	if n == 1 or n==0:
		return n
	return fact(n-1)+fact(n-2)

实际上该程序还可以用生成器来完成

def fab(max):
	a,b,n = 0,1,0
	while True:
		yield a
		a,b = b,a+b
		n += 1  #计数用
		if n>=max:
			break
	return 'over'
obj = fab(5)
for i in range(5):
	print(next(obj))

汉诺塔问题的解决：
实际上三根柱子挪动汉诺塔可以分为三步，先假设有n阶的汉诺塔：
1. 把n-1个塔牌挪动到第二根柱子上
2. 把最大的一个挪到第三根柱子上
3. 把n-1个塔牌从第二根柱子移到第三根柱子上

不多说请看代码

def move(n,a='A',b='B',c='C'):
	if n == 1:
		print('{0}-->{1}'.format(a,c))
	else:
		move(n-1,'A','C','B')						#把n-1个塔牌挪到第二根柱子
		print('A-->C')								#把最大的一个挪到第三根柱子上
		move(n-1,'B','A','C')
	return 'Game Over'
move(3)

结果是

A–>B
A–>C
B–>C
A–>C
A–>B
A–>C
B–>C
‘Game Over’

2. 函数闭包

不多巴巴，上代码

>>> def get_sum(*a):
		def gsum():
			res = 0
			for i in a:
				res += i
			return res
		return gsum
>>> o = get_sum(1,3,5,8,9,10)
>>> o			#这里o是一个gsum函数的对象
<function get_sum.<locals>.gsum at 0x000001E836013730>
>>> o()			#当运行这个函数时才会真的计算出结果
36

闭包可以让输入的参数传递到内部函数中

3. 几种高级函数

• map()
• reduce()
• filter()

map()函数用法

map(f(x),list)
#前面是函数，后面是参数列表，map（）将参数列表挨个带入函数中，得到的结果返回

>>> def f(x):
		return x * x
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

记得map函数返回的不是一个列表类型

reduce()函数用法

reduce函数作用在一个序列[x1, x2, x3, …]上，该函数只接收两个参数，reduce把结果作为下一次计算的一个元素继续和序列的下一个元素做累积计算：

reduce(f, [x1, x2, x3, x4]) 等效于 f(f(f(x1, x2), x3), x4)

具体代码使用方法（该函数用于把连续输入的数变成一个数，从高位到低位）：

>>> from functools import reduce	#引入reduce（）方法
>>> def fn(x, y):
	     return x * 10 + y

>>> reduce(fn, [1, 3, 5, 7, 9])
13579

filter()过滤函数

这个函数就有点意思，用来筛选内容的
借用廖老师的例子，，懒得打

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
#结果: [1, 5, 9, 15]

限定前面函数返回的是一个布尔值，即True 或者 False
True留下来

用filter求素数去计算素数的一个方法：埃氏筛法
（这个方法掌握不是很好建议去自己悟一下）
点击这–>：廖雪峰老师666