day11-总结

2019-04-28

函数提高

1. 函数作为变量

• python中声明函数其实就是声明一个类型是function的变量, 函数名就是变量名。所以普通变量能做的事情函数都可以做

def func1():
    print('这是一个函数')
    return 100

---

2. 一个变量可以给另外一个变量赋值

a = 10
b = a
print(b/2)
a = 'abc'
print(a)

c = func1     # 将函数名作为变量，给另一个变量赋值
print('=======')
print(c())
print('=======')
func1 = 12.5
print(func1)
# print(func1())    # TypeError: 'float' object is not callable

---

3. 一个变量可以作为容器的元素

print('===================================')
a = 10      # 声明一个变量，类型是整型
print(type(a))


# 声明一个变量，类型是function
def func2():
    print('这是函数2')
    return 100


print(type(func2))
list1 = [a, func2, func2()]
print(list1)
print('0:', list1[0] // 3)
print('1:', list1[1]())    # print('1:', func2())  -> print('1:', 100)

• 练习

list2 = []
for i in range(5):
    def func(n):
        return i * 2
    list2.append(func)


list3 = []
for i in range(5):
    list3.append(lambda x: x*i)


print(list3[0](2), list3[1](2), list3[2](2))
"""
list2 = []
i = 0 ~ 4
i = 0:  func, list2 = [func]
i = 1:  func, list2 = [func, func]
...
i = 4: list2 = [func,func,func,func,func]
"""
# list2[0](3), list2[1](3), list2[2](3)
# func, func, func
# None, None, None
# 0, 2, 3
# 8, 8, 8
print(list2)
print(list2[0](3), list2[1](3), list2[2](3))

---

4. 变量可以作为函数的参数

• 函数作为函数的参数(实参高阶函数)

def func1(fn, fn2):
    # fn = func11
    # fn2 = func12
    fn()   # func11(),  None
    print(fn2(3) / 4)  # print(9/4)


def func11():
    print('这是一个函数')


def func12(n):
    # n = 3
    return n**2


print(func1(func11, func12))   # print(None)

• 应用: sort函数

print('===============sort的高级使用===============')
nums = [1, 34, 45, 9, 20]
nums.sort()
print(nums)

all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光头强', 'age': 21, 'score': 40}
]

# 序列.sort函数中有个参数key，这个参数要求传一个函数，并且函数有一个参数和一个返回值
# 参数就是序列中的元素, 返回值就是排序比较的对象
# def compare(item):
#     return item['age']
# all_students.sort(key=compare)
all_students.sort(key=lambda item: item['age'])
print(all_students)

• 练习，将all_message中的元祖按照第二个元素从大到小排序。然后再按照学号的最后一位从小到大排
  序

all_message = [
    ('余婷', 'python1902004'),
    ('张三', 'python1902106'),
    ('小明', 'python1902027')
]

all_message.sort(key=lambda item: item[1], reverse=True)
print(all_message)


all_message.sort(key=lambda item: item[1][-1])
print(all_message)


def yt_sort(seq, key=None, reverse=False):
    if key:
        # 选择排序
        length = len(seq)
        for x in range(length - 1):
            for y in range(x + 1, length):
                if key(seq[y]) < key(seq[x]):
                    seq[x], seq[y] = seq[y], seq[x]
    else:
        # 选择排序
        length = len(seq)
        for x in range(length-1):
            for y in range(x+1, length):
                if seq[y] < seq[x]:
                    seq[x], seq[y] = seq[y], seq[x]


nums = [23, 45, 89, 9, 21]
yt_sort(nums)
# nums.sort()
print(nums)


all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光头强', 'age': 21, 'score': 40}
]
# all_students.sort(key=lambda x: x['age'])
yt_sort(all_students, key=lambda x: x['age'])
print(all_students)


all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光头强', 'age': 21, 'score': 40}
]
print(max(all_students, key=lambda x: x['score']))

---

5. 变量作为返回值

• 将一个函数作为函数的返回值(返回值高阶函数)

print('================返回值高阶函数==============')


def func1():
    def temp(*nums):
        return sum(nums)
    return temp


print(func1()(1, 3, 5, 9))    # print(temp(1,3,5,9))  , print(18)

迭代器

1.什么是迭代器

• 迭代器是容器型数据类型(可以同时存储多个数据), 但是想要获取/查看迭代器中元素的值，只能将元素取出来。取出来的元素在迭代器中就不存在了，取的时候只能从前往后一个一个的取，不能跳着取。

2.迭代器中的元素

• 迭代器的元素只能通过类型转换，将其他容器转换成迭代器； 或者通过生成器去生成

1. 转换 - 所有序列都可以转换成迭代器。 迭代器中的元素可以是任何类型的数据

iter1 = iter([10, [1, 3]])
print(iter1)

3. 获取元素: 迭代器获取元素，不管以什么样的方式获取，获取后，这个元素在迭代器中就不存在了

1. next(迭代器) - 获取迭代器顶部数据(最上面的数据)

iter2 = iter('hello')
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
# print(next(iter2))    # StopIteration

2. 遍历获取每个元素

iter2 = iter('hello')
next(iter2)
next(iter2)
for x in iter2:
    print('x:', x)

# print(next(iter2))    # StopIteration

---

生成器

1.什么是生成器

• 生成器就是迭代器, 迭代器不一定是生成器。调用一个带有yield关键字的函数就能得到一个生成器。(yield只能出现在函数体中)

def func1():
    print('=====')
    return 100
    yield

gen1 = func1()
gen2 = func1()
print(gen1, gen2)

2.生成器的元素

• 生成器获取元素的方式和迭代器一样： next()和循环遍历
• 1）生成器元素的个数: 看执行完生成器对应的函数会遇到几次yield
• 2. 元素的值: 看yield后表达式的值

def func2():
    print('函数')
    for x in range(10):
        yield x


gen3 = func2()
print('next:', next(gen3))
print('next:', next(gen3))
print('next:', next(gen3))
# print('next:', next(gen3))
for x in gen3:
    print('x:', x)

3.生成器产生数据的原理

"""
当获取生成的元素的是，会执行生成器对应的函数，从开始执行到yield为止,将yield后面的数据作为元素返回并且记录结束位置；
下次获取元素的时候，从上次结束的位置接着往后执行，直到遇到yield, 将yield后面的数据作为元素返回并且记录结束位置；
以此类推
如果从开始执行到函数结束，没有遇到yield，那么就获取不到元素
"""
print('===============================')


def func3():
    print('第一次')
    yield 1
    print('第二次')
    yield 2
    print('第三次')
    yield 3


gen4 = func3()
print('next1:', next(gen4))

for x in range(100):
    print('+++++++++++++')

print('next2:', next(gen4))
print('next3:', next(gen4))


nums = ['001', '002', '003', '004', '005', '006']

def func5():
    for x in range(1, 6):
        yield str(x).rjust(3, '0')
nums2 = func5()

print(next(nums2))
print(next(nums2))


# 能够产生无限数字的生成器
def func6():
    num = 0
    while True:
        yield num
        num += 1


gen5 = func6()