python learning2.py

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

# 取前3个元素的笨方法

r = []
n = 3
for i in range(n):
    r.append(L[i])

print(r)

# 切片
# 从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
print(L[0:3]) 
print(L[:3]) #如果第一个索引是0，还可以省略：
print(L[-2:-1])


L = list(range(100))
print(L[:10])
print(L[-10:])
print(L[10:20])
print(L[0:10:2])
print(L[::5])
 

print('ABCDEFG'[:3])    

#利用切片操作，实现一个trim()函数，去除字符串首尾的空格
def trim(s):
    if s == '':
        return s

    i = 0
    length = len(s)
    j = length - 1
    while(s[i]==' ' and i < length - 1):
        i = i + 1

    while(s[j]==' ' and j >= 1):
        j = j - 1

    return s[i:j+1]

# 测试:
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('测试成功!')


# 迭代
# 很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代
d = {'a':1 , 'b':2, 'c':3}
for key in d:
    print(key, d[key])

for ch in "ABC":
    print(ch)

# 如何判断一个对象是可迭代对象呢？
from collections import Iterable

print(isinstance('abc',Iterable))
print(isinstance('123',Iterable))

# 实现下标循环
# enumerate函数可以把一个list变成索引-元素对
for i, value in enumerate(['A','B','C']):
    print(i,value)

# for循环里，同时引用了两个变量，在Python里是很常见的
for x,y in [(1,1),(2,4),(3,9)]:
    print(x,y)


# 请使用迭代查找一个list中最小和最大值，并返回一个tuple：
def findMinAndMax(L):
    if L == []:
        return (None, None)
    
    min = max = L[0]
    
    for x in L:
        if x > max:
            max = x
        if x < min:
            min = x
    
    return (min,max)

# 测试
if findMinAndMax([]) != (None, None):
    print('测试失败!')
elif findMinAndMax([7]) != (7, 7):
    print('测试失败!')
elif findMinAndMax([7, 1]) != (1, 7):
    print('测试失败!')
elif findMinAndMax([7, 1, 3, 9, 5]) != (1, 9):
    print('测试失败!')
else:
    print('测试成功!')


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

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

# [1x1, 2x2, 3x3, ..., 10x10]
L = []
for x in range(1,11):
    L.append(x*x)

print(L)

# 列表生成式则可以用一行语句代替循环生成上面的list

print([x*x for x in range(1,11)])

# 写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来，十分有用，多写几次，很快就可以熟悉这种语法。
# for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

print([x*x for x in range(1,11) if x % 2 == 0])

# 笛卡尔积

print([m + n for m in 'ABC' for n in 'XYZ'])

# 例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：

import os
[d for d in os.listdir('.')]


# for循环其实可以同时使用两个甚至多个变量
# 列表生成式也可以使用两个变量来生成list：
d = {'x': 'A', 'y': 'B', 'z': 'C' }
print([k + '=' + v for k, v in d.items()])

# 列表中所有字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s  in L])

# 练习：如果list中既包含字符串，又包含整数，会报错
# 使用内建的isinstance函数可以判断一个变量是不是字符串：
# 修改列表生成式，在其中加上if语句保证可以正确执行 

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [s.lower() for s in L1 if isinstance(s, str)]
L3 = [s for s in L1 if isinstance(s,int)]
print(L3)
# 测试:
print(L2)
if L2 == ['hello', 'world', 'apple']:
    print('测试通过!')
else:
    print('测试失败!')

    
# 生成器

'''
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
'''

# 第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

L = [x * x for x in range(10)]
g = (x * x for x in range(10))

print(L)
print(g) # <generator object <genexpr> at 0x02587F60>

# 通过next()函数获得generator的下一个返回值：
# generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，
# 没有更多的元素时，抛出StopIteration的错误。

for n in g:
    print(n)

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

'''
注意，赋值语句：
a, b = b, a + b

相当于：
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]
'''

fib(6)

# 将上述函数改造成 generator
# 只需要把print(b)改为yield b就可以了：
# 变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

def fib1(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

f = fib(6)
print(f)

# 简单例子 依次返回数字 1 3 5

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

#调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值：
o = odd()
print(next(o))
print(next(o))
print(next(o))

# 执行3次yield后，已经没有yield可以执行了。第4次调用next(o)就报错。

# 杨辉三角

'''
          1
         / 
        1   1
       /  / 
      1   2   1
     /  /  / 
    1   3   3   1
   /  /  /  / 
  1   4   6   4   1
 /  /  /  /  / 
1   5   10  10  5   1
把每一行看做一个list，试写一个generator，不断输出下一行的list：
'''

def triangles():
    N = [1]
    while True:
        yield N
        N.append(0)
        # print(N)
        N = [N[i-1] + N[i] for i in range(len(N))]

n = 0
for t in triangles():
     print(t)
     n = n + 1
     if n == 10:
        break

# 期待输出:
# [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]