1函数递归算法——汉诺塔
2切片——去掉字符串两端的空格
3生成器——打印10层杨辉三角
4高阶函数
5返回函数
6实例属性和类属性
函数递归算法(汉诺塔)
n表示圆盘的数量，A,B,C 表示三根柱子。
从A借助B转移到C; 每次只能移动一个; 大盘只能在小盘下面。
n=1
A --> C
n=2
A --> B
A --> C
B --> C
... ...
n
n-1 --> B
A --> C
B --> C
找到规律，移动 n 个圆盘从A到C，先把 n-1 个圆盘从A移动到B(借助C)，再把第 n 个最大的圆盘从A移动到C，最后将 n-1 个圆盘从B移动到C(n>=2)。
接下来我们来看移动圆盘的具体步骤：
定义函数move(n, a, b, c)实现上述功能，打印出移动步骤。
#! python3
# 利用递归函数移动汉诺塔:
def move(n, a, b, c):
if n == 1:
print('move', a, '-->', c)
else:
move(n-1, a, c, b)
move(1, a, b, c)
move(n-1, b, a, c)
move(3, 'A', 'B', 'C')
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
怎么打印出来的？(我也不是很懂，递归过程比较抽象)
关键在于n==1, 打印每一步移动。移动过程A,B,C的地位相同，实现了任意移动的打印。
切片(去掉字符串两端的空格)
不调用str的strip()方法
# 期望输出
if trim('hello ') != 'hello':
print('测试失败!')
elif trim(' hello') != 'hello':
print('测试失败!')
elif trim(' hello ') != 'hello':
print('测试失败!')
elif trim(' hello world ') != 'hello world':
print('测试失败!')
elif trim('') != '':
print('测试失败!')
elif trim(' ') != '':
print('测试失败!')
else:
print('测试成功!')
def trim(s):
if s=='':
s=''
else:
while s[0] == ' ' and len(s) >=2:
s=s[1:]
while s[-1] == ' ' and len(s) >=2:
s=s[:-1]
if len(s)==1 and s==' ':
s=''
return s
本来刚开始想到的是找到两端非空元素的下标，然后切片去掉两端空格部分，一直没成功。然后就想着直接对s进行操作，关键在于对于空字符串和只包含空格的字符串都要输出空字符串，处理起来比较麻烦。
生成器(打印10层杨辉三角)
# 期望输出:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
函数
def triangles():
for i in range(1,11):
b=[]
if i==1:
b=[1]
print(b)
else:
for j in range(i):
if j==0:
b.append(1)
elif j==i-1:
b.append(1)
else:
b.append(a[j]+a[j-1])
print(b)
a=b
生成器
def triangles():
for i in range(10):
if i==0:
yield([1])
elif i==1:
L1=[1,1]
yield(L1)
else:
L=[1]
for j in range(i-1):
L.append(L1[j+1]+L1[j])
L.append(1)
L1=L
yield(L1)
高阶函数
1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：
def normalize(name):
for i in range(len(name)):
if i==0:
m=name[i].upper()
else:
m=m+name[i].lower()
return m
# 测试:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
2.Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：
from functools import reduce
def prod(L):
return reduce(lambda x, y: x*y, L)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
print('测试成功!')
else:
print('测试失败!')
3.利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：
from functools import reduce
def str2float(s):
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def char2num(ch):
return DIGITS[ch]
for i in range(len(s)):
if s[i]=='.':
break
f1=reduce(lambda x, y: 10*x+y, map(char2num, s[:i]))
f2=reduce(lambda x, y: 10*x+y, map(char2num, s[i+1:]))*((10)**(-len(s)+(i+1)))
return f1+f2
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
print('测试成功!')
else:
print('测试失败!')
4.用filter求素数[埃拉托色尼筛选法(the Sieve of Eratosthenes)简称埃氏筛法]
计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：
首先，列出从2开始的所有自然数，构造一个序列：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数5，然后用5把序列的5的倍数筛掉：
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
不断筛下去，就可以得到所有的素数。
# 生成器，产生从3开始的无限奇数序列(没有2的倍数)
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
def _not_divisible(n):
return lambda x: x % n > 0
def primes():
yield 2
it = _odd_iter() # 初始序列
while True:
n = next(it) # 返回序列的第一个数
yield n
it = filter(_not_divisible(n), it) # 构造新序列
# 打印1000以内的素数:
for n in primes():
if n < 1000:
print(n)
else:
break
5.用filter求回数[从左向右读和从右向左读都是一样的数]
def is_palindrome(n):
m=''
n=str(n)
for i in range(len(n)):
m=m+n[-i-1]
return m==n
# 测试:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]:
print('测试成功!')
else:
print('测试失败!')
6.用sorted()排序
假设我们用一组tuple表示学生名字和成绩：
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
按名字排序：
def by_name(t):
return t[0]
L2 = sorted(L, key=by_name)
按成绩排序：
def by_score(t):
return t[0]
L2 = sorted(L, key=by_score)
请用sorted()对上述列表分别按名字排序：
返回函数[利用闭包返回一个计数器函数，每次调用它返回递增整数]
# 利用生成器产生返回的递增整数
def createCounter():
def inte():
n = 1
while True:
yield n
n = n+1
n=inte()
def counter():
return next(n)
return counter
# 测试:
counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5
counterB = createCounter()
if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]:
print('测试通过!')
else:
print('测试失败!')
实例属性和类属性
为了统计学生人数，可以给Student类增加一个类属性，每创建一个实例，该属性自动增加：
class Student(object):
count = 0
def __init__(self, name):
self.name = name
Student.count+=1