1、列表推导

列表的元素可以在一行中进行方便的循环。

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = [number for number in numbers if number % 2 == 0]
print(even_numbers)

输出：

 [1,3,5,7]

同时，也可以用在字典上。

dictionary = {'first_num': 1, 'second_num': 2,
              'third_num': 3, 'fourth_num': 4}
oddvalues = {key: value for (key, value) in dictionary.items() if value % 2 != 0}
print(oddvalues)Output: {'first_num': 1, 'third_num': 3}

2、枚举函数

枚举是一个有用的函数，用于迭代对象，如列表、字典或文件。该函数生成一个元组，其中包括通过对象迭代获得的值以及循环计数器（从0的起始位置）。当您希望根据索引编写代码时，循环计数器很方便。

sentence = 'Just do It'
length = len(sentence)
for index, element in enumerate(sentence):
    print('{}: {}'.format(index, element))
     if index == 0:
        print('The first element!')
    elif index == length - 1:
        print('The last element!')

3、通过函数返回多个值

在设计函数时，我们经常希望返回多个值。这里我们将介绍两种典型的方法：

方法一

最简单的方式就是返回一个tuple。

get_student 函数，它根据员工的ID号以元组形式返回员工的名字和姓氏。

# returning a tuple.
def get_student(id_num):
    if id_num == 0:
        return 'Taha', 'Nate'
    elif id_num == 1:
        return 'Jakub', 'Abdal'
    else:
        raise Exception('No Student with this id: {}'.format(id_num))

Student = get_student(0)
print('first_name: {}, last_name: {}'.format(Student[0], Student[1]))

方法二、

返回一个字典类型。因为字典是键、值对，我们可以命名返回的值，这比元组更直观。

# returning a dictionary
def get_data(id_num):
    if id_num == 0:
        return {'first_name': 'Muhammad', 'last_name': 'Taha', 'title': 'Data Scientist', 'department': 'A', 'date_joined': '20200807'}
    elif id_num == 1:
        return {'first_name': 'Ryan', 'last_name': 'Gosling', 'title': 'Data Engineer', 'department': 'B', 'date_joined': '20200809'}
    else:
        raise Exception('No employee with this id: {}'.format(id_num))
employee = get_data(0)
print('first_name: {},nlast_name: {},ntitle: {},ndepartment: {},ndate_joined: {}'.format(
    employee['first_name'], employee['last_name'], employee['title'], employee['department'], employee['date_joined']))

4、像数学一样比较多个数字

如果你有一个值，并希望将其与其他两个值进行比较，则可以使用以下基本数学表达式：1<x<30。

你也许经常使用的是这种

1<x and x<30

在python中，你可以这么使用

x = 5
print(1<x<30)

5、将字符串转换为字符串列表：

当你输入 "[[1, 2, 3],[4, 5, 6]]" 时，你想转换为列表，你可以这么做。

import ast

def string_to_list(string):

    return ast.literal_eval(string)

string = "[[1, 2, 3],[4, 5, 6]]"

my_list = string_to_list(string)

print(my_list)

6、对于Else方法

Python 中 esle 特殊的用法。

number_List = [1, 3, 8, 9,1]



for number in number_List:

    if number % 2 == 0:

        print(number)

        break

    else:

        print("No even numbers!!")

7、在列表中查找n个最大或n个最小的元素

使用 heapq 模块在列表中查找n个最大或n个最小的元素。

import heapq

numbers = [80, 25, 68, 77, 95, 88, 30, 55, 40, 50]

print(heapq.nlargest(5, numbers))

print(heapq.nsmallest(5, numbers))

8、在不循环的情况下重复整个字符串

value = "Taha"

print(value * 5)  

print("-" * 21)

9、从列表中查找元素的索引

cities= ['Vienna', 'Amsterdam', 'Paris', 'Berlin']

print(cities.index('Berlin'))

10、在同一行中打印多个元素？

print("Analytics", end="")

print("Vidhya")

print("Analytics", end=" ")

print("Vidhya")

print('Data', 'science', 'blogathon', '12', sep=', ')

输出

AnalyticsVidhya

Analytics Vidhya

Data, science, blogathon, 12

11、把大数字分开以便于阅读

有时，当你试图打印一个大数字时，传递整数真的很混乱，而且很难阅读。然后可以使用下划线，使其易于阅读。

print(5_000_000_000_000)



print(7_543_291_635)

输出：

5000000000000

7543291635

12、反转列表的切片

切片列表时，需要传递最小、最大和步长。要以相反的顺序进行切片，只需传递负步长。让我们来看一个例子：

sentence = "Data science blogathon"

print(sentence[21:0:-1])

输出

nohtagolb ecneics ata

13、 “is” 和 “==” 的区别。

如果要检查两个变量是否指向同一个对象，则需要使用“is”

但是，如果要检查两个变量是否相同，则需要使用“==”。

list1 = [7, 9, 4]

list2 = [7, 9, 4]

print(list1 == list2) 

print(list1 is list2)

list3 = list1

print(list3 is list1)

输出

True

False

True

14、在一行代码中合并两个词典。

first_dct = {"London": 1, "Paris": 2}

second_dct = {"Tokyo": 3, "Seol": 4}

merged = {**first_dct, **second_dct}

print(merged)

输出

{‘London’: 1, ‘Paris’: 2, ‘Tokyo’: 3, ‘Seol’: 4}

15、识别字符串是否以特定字母开头

sentence = "Analytics Vidhya"

print(sentence.startswith("b"))

print(sentence.startswith("A"))

16、获得字符的Unicode

print(ord("T"))

print(ord("A")) 

print(ord("h")) 

print(ord("a"))

17、获取字典的键值对

cities = {'London': 1, 'Paris': 2, 'Tokyo': 3, 'Seol': 4}

for key, value in cities.items():

    print(f"Key: {key} and Value: {value}")

18、在列表的特定位置添加值

cities = ["London", "Vienna", "Rome"]

cities.append("Seoul")

print("After append:", cities)

cities.insert(0, "Berlin")

print("After insert:", cities)

输出：

[‘London’, ‘Vienna’, ‘Rome’, ‘Seoul’] After insert: [‘Berlin’, ‘London’, ‘Vienna’, ‘Rome’, ‘Seoul’]

19、Filter() 函数

它通过在其中传递的特定函数过滤特定迭代器，并且返回一个迭代器。

mixed_number = [8, 15, 25, 30,34,67,90,5,12]

filtered_value = filter(lambda x: x > 20, mixed_number)

print(f"Before filter: {mixed_number}") 

print(f"After filter: {list(filtered_value)}")

输出:

Before filter: [8, 15, 25, 30, 34, 67, 90, 5, 12]

After filter: [25, 30, 34, 67, 90]

20、创建一个没有参数个数限制的函数

def multiplication(*arguments):

    mul = 1

    for i in arguments:

        mul = mul * i

    return mul

print(multiplication(3, 4, 5))

print(multiplication(5, 8, 10, 3))

print(multiplication(8, 6, 15, 20, 5))

输出：

60

1200

72000

21、一次迭代两个或多个列表

capital = ['Vienna', 'Paris', 'Seoul',"Rome"]

countries = ['Austria', 'France', 'South Korea',"Italy"]

for cap, country in zip(capital, countries):

    print(f"{cap} is the capital of {country}")

22、检查对象使用的内存大小

import sys

mul = 5*6

print(sys.getsizeof(mul))

23、 Map() 函数

map() 函数用于将特定函数应用于给定迭代器。

values_list = [8, 10, 6, 50]
quotient = map(lambda x: x/2, values_list)
print(f"Before division: {values_list}")
print(f"After division: {list(quotient)}")

24、计算 item 在列表中出现的次数

可以在 list 上调用 count 函数。

cities= ["Amsterdam", "Berlin", "New York", "Seoul", "Tokyo", "Paris", "Paris","Vienna","Paris"]
print("Paris appears", cities.count("Paris"), "times in the list")

25、在元组或列表中查找元素的索引

cities_tuple = ("Berlin", "Paris", 5, "Vienna", 10)
print(cities_tuple.index("Paris")) 
cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]
print(cities_list.index("Amsterdam"))

26、2个 set 进行 join 操作

set1 = {'Vienna', 'Paris', 'Seoul'}
set2 = {"Tokyo", "Rome",'Amsterdam'}
print(set1.union(set2))

27、根据频率对列表的值进行排序

from collections import Counter
count = Counter([7, 6, 5, 6, 8, 6, 6, 6])
print(count)
print("Sort values according their frequency:", count.most_common())

输出：

Counter({6: 5, 7: 1, 5: 1, 8: 1})
Sort values according their frequency: [(6, 5), (7, 1), (5, 1), (8, 1)]

28、从列表中删除重复值

cities_list = ['Vienna', 'Paris', 'Seoul',"Amsterdam","Paris","Amsterdam","Paris"]
cities_list = set(cities_list)
print("After removing the duplicate values from the list:",list(cities_list))

29、找出两个列表之间的差异

cities_list1 = ['Vienna', 'Paris', 'Seoul',"Amsterdam", "Berlin", "London"]
cities_list2 = ['Vienna', 'Paris', 'Seoul',"Amsterdam"]
cities_set1 = set(cities_list1)
cities_set2 = set(cities_list2)
difference = list(cities_set1.symmetric_difference(cities_set2))
print(difference)

30、将两个不同的列表转换为一个字典

number = [1, 2, 3]
cities = ['Vienna', 'Paris', 'Seoul']
result = dict(zip(number, cities))
print(result)

作者：程序员学长
来源：juejin.cn/post/7126728825274105886

itchat使用教程

itchat是一个开源的微信个人号接口，使用python调用微信从未如此简单。使用不到三十行的代码，你就可以完成一个能够处理所有信息的微信机器人。

首先，在终端安装一下itchat:

#pip是pyth的包管理工具也就是pyth的应用商店专门用来安装和卸载库
pip install itchat

1.登录

1. login() - 每次运行程序都需要扫二维码

2. login(hotReload==True) - 下次登录不用再扫二维码

3. auto_login(loginCallback=登录成功回调函数, exitCallback=退出登录回调函数)

2.退出登录

1. logout() - 强制退出登录

3.获取好友信息

1. get_friends(update=True) - 获取所有的好友信息

2. get_chatrooms() - 获取群组

3. get_mps() - 获取公众号

4. get_msg() - 获取消息列表

5. get_head_img() - 获取个人头像

4.发送消息

send(msg=消息内容, toUserName=用户名)

1).msg的值会因为消息类型不同而不同：

• 文本消息 - 引号中直接写要发送的文字内容

• 发送文件 - @fil@文件路径

• 发送图片 - @img@图片路径

• 发送视频 - @vid@视频路径

2).toUserName: 发送对象，如果不填就发送给自己

5.接收消息

想要自动接收消息，需要先对不同类型的消息进行注册，如果没有注册，对应类型的消息将不会被接收.

注册的方式如下:

@itchat.msg_register(消息类型,isFriendChat=True, isGroupChat=True,isMpChat=True)

def 函数名(msg):
    #接收到对应的消息会自动执行的代码段
    #msg.download(msg['FileName'])   #这个同样是下载文件的方式
    #msg['Text'](msg['FileName'])      #下载文件

1）消息类型:

来源：blog.csdn.net/weixin_46014553/article/details/110200748

1. 不可变类型

不可变类型，内存中的数据不允许被修改（一旦被定义，内存中分配了小格子，就不能再修改内容了）：

• 数字类型int，bool，float，complex，long(2,x)

• 字符串str

• 元组tuple

2. 可变类型

可变类型，内存中的数据可以被修改（可以通过变量名调用方法来修改列表和字典内部的内容，而内存地址不发生变化）：

• 列表list

• 字典dict（注：字典中的key只能使用不可变类型的数据）

注：给变量赋新值的时候，只是改变了变量的引用地址，不是修改之前的内容

1. 可变类型的数据变化，是通过方法来实现的

2. 如果给一个可变类型的变量，复制了一个新的数据，引用会修改（变量从之前的数据上撕下来，贴到新赋值的数据上）

3. 代码演示

# 新建列表
a = [1, 2, 3]
print("列表a：", a)
print("列表a的地址：", id(a))
print("*"*50)
# 追加元素
a.append(999)
print("列表a:", a)
print("列表a的地址：", id(a))
print("*"*50)
# 移除元素
a.remove(2)
print("列表a:", a)
print("列表a的地址：", id(a))
print("*"*50)
# 清空列表
a.clear()
print("列表a:", a)
print("列表a的地址：", id(a))
print("*"*50)
# 将空列表赋值给变量a
a = []
print("列表a的地址：", id(a))   # 通过输出可以看出地址发生了变化
print("*"*50)
# 新建字典
d = {"name": "xiaoming"}
print("字典d为：", d)
print("字典d的地址：", id(d))
print("*"*50)
# 追加键值对
d["age"] = 18
print("字典d为：", d)
print("字典d的地址：", id(d))
print("*"*50)
# 删除键值对
d.pop("age")
print("字典d为：", d)
print("字典d的地址：", id(d))
print("*"*50)
# 清空所有键值对
d.clear()
print("字典d为：", d)
print("字典d的地址：", id(d))
print("*"*50)
# 对d赋值空字典
d = {}
print("字典d为：", d)
print("字典d的地址：", id(d))
print("*"*50)

4. 运行结果

可变类型（列表和字典）的数据变化，是通过方法（比如append,remove,pop等）来实现的，不会改变地址。而重新赋值后地址会改变。具体运行结果如下图所示：

作者：ZacheryZHANG
来源：juejin.cn/post/7100423532655411213

1提取 PDF 内容

# pip install PyPDF2 安装 PyPDF2
import PyPDF2
from PyPDF2 import PdfFileReader
 
# Creating a pdf file object.
pdf = open("test.pdf", "rb")
 
# Creating pdf reader object.
pdf_reader = PyPDF2.PdfFileReader(pdf)
 
# Checking total number of pages in a pdf file.
print("Total number of Pages:", pdf_reader.numPages)
 
# Creating a page object.
page = pdf_reader.getPage(200)
 
# Extract data from a specific page number.
print(page.extractText())
 
# Closing the object.
pdf.close()

2提取 Word 内容

# pip install python-docx 安装 python-docx
 
 
import docx
 
 
def main():
     try:
     doc = docx.Document('test.docx') # Creating word reader object.
     data = ""
     fullText = []
     for para in doc.paragraphs:
         fullText.append(para.text)
         data = '\n'.join(fullText)
 
     print(data)
 
     except IOError:
     print('There was an error opening the file!')
     return
 
 
if __name__ == '__main__':
     main()

3提取 Web 网页内容

# pip install bs4 安装 bs4
 
from urllib.request import Request, urlopen
from bs4 import BeautifulSoup
 
req = Request('http://www.cmegroup.com/trading/products/#sortField=oi&sortAsc=false&venues=3&page=1&cleared=1&group=1',
         headers={'User-Agent': 'Mozilla/5.0'})
 
webpage = urlopen(req).read()
 
# Parsing
soup = BeautifulSoup(webpage, 'html.parser')
 
# Formating the parsed html file
strhtm = soup.prettify()
 
# Print first 500 lines
print(strhtm[:500])
 
# Extract meta tag value
print(soup.title.string)
print(soup.find('meta', attrs={'property':'og:description'}))
 
# Extract anchor tag value
for x in soup.find_all('a'):
     print(x.string)
 
# Extract Paragraph tag value
for x in soup.find_all('p'):
     print(x.text)

4读取 Json 数据

import requests
import json
 
r = requests.get("https://support.oneskyapp.com/hc/en-us/article_attachments/202761727/example_2.json")
res = r.json()
 
# Extract specific node content.
print(res['quiz']['sport'])
 
# Dump data as string
data = json.dumps(res)
print(data)

5读取 CSV 数据

import csv
 
with open('test.csv','r') as csv_file:
     reader =csv.reader(csv_file)
     next(reader) # Skip first row
     for row in reader:
     print(row)

6删除字符串中的标点符号

import re
import string
 
data = "Stuning even for the non-gamer: This sound track was beautiful!\
It paints the senery in your mind so well I would recomend\
it even to people who hate vid. game music! I have played the game Chrono \
Cross but out of all of the games I have ever played it has the best music! \
It backs away from crude keyboarding and takes a fresher step with grate\
guitars and soulful orchestras.\
It would impress anyone who cares to listen!"
 
# Methood 1 : Regex
# Remove the special charaters from the read string.
no_specials_string = re.sub('[!#?,.:";]', '', data)
print(no_specials_string)
 
 
# Methood 2 : translate()
# Rake translator object
translator = str.maketrans('', '', string.punctuation)
data = data.translate(translator)
print(data)

7使用 NLTK 删除停用词

from nltk.corpus import stopwords
 
 
data = ['Stuning even for the non-gamer: This sound track was beautiful!\
It paints the senery in your mind so well I would recomend\
it even to people who hate vid. game music! I have played the game Chrono \
Cross but out of all of the games I have ever played it has the best music! \
It backs away from crude keyboarding and takes a fresher step with grate\
guitars and soulful orchestras.\
It would impress anyone who cares to listen!']
 
# Remove stop words
stopwords = set(stopwords.words('english'))
 
output = []
for sentence in data:
     temp_list = []
     for word in sentence.split():
     if word.lower() not in stopwords:
         temp_list.append(word)
     output.append(' '.join(temp_list))
 
 
print(output)

8使用 TextBlob 更正拼写

from textblob import TextBlob
 
data = "Natural language is a cantral part of our day to day life, and it's so antresting to work on any problem related to langages."
 
output = TextBlob(data).correct()
print(output)

9使用 NLTK 和 TextBlob 的词标记化

import nltk
from textblob import TextBlob
 
 
data = "Natural language is a central part of our day to day life, and it's so interesting to work on any problem related to languages."
 
nltk_output = nltk.word_tokenize(data)
textblob_output = TextBlob(data).words
 
print(nltk_output)
print(textblob_output)

Output:

['Natural', 'language', 'is', 'a', 'central', 'part', 'of', 'our', 'day', 'to', 'day', 'life', ',', 'and', 'it', "'s", 'so', 'interesting', 'to', 'work', 'on', 'any', 'problem', 'related', 'to', 'languages', '.']
['Natural', 'language', 'is', 'a', 'central', 'part', 'of', 'our', 'day', 'to', 'day', 'life', 'and', 'it', "'s", 'so', 'interesting', 'to', 'work', 'on', 'any', 'problem', 'related', 'to', 'languages']

10使用 NLTK 提取句子单词或短语的词干列表

from nltk.stem import PorterStemmer
 
st = PorterStemmer()
text = ['Where did he learn to dance like that?',
     'His eyes were dancing with humor.',
     'She shook her head and danced away',
     'Alex was an excellent dancer.']
 
output = []
for sentence in text:
     output.append(" ".join([st.stem(i) for i in sentence.split()]))
 
for item in output:
     print(item)
 
print("-" * 50)
print(st.stem('jumping'), st.stem('jumps'), st.stem('jumped'))

Output:

where did he learn to danc like that?
hi eye were danc with humor.
she shook her head and danc away
alex wa an excel dancer.
--------------------------------------------------
jump jump jump

11使用 NLTK 进行句子或短语词形还原

from nltk.stem import WordNetLemmatizer
 
wnl = WordNetLemmatizer()
text = ['She gripped the armrest as he passed two cars at a time.',
     'Her car was in full view.',
     'A number of cars carried out of state license plates.']
 
output = []
for sentence in text:
     output.append(" ".join([wnl.lemmatize(i) for i in sentence.split()]))
 
for item in output:
     print(item)
 
print("*" * 10)
print(wnl.lemmatize('jumps', 'n'))
print(wnl.lemmatize('jumping', 'v'))
print(wnl.lemmatize('jumped', 'v'))
 
print("*" * 10)
print(wnl.lemmatize('saddest', 'a'))
print(wnl.lemmatize('happiest', 'a'))
print(wnl.lemmatize('easiest', 'a'))

Output:

She gripped the armrest a he passed two car at a time.
Her car wa in full view.
A number of car carried out of state license plates.
**********
jump
jump
jump
**********
sad
happy
easy

12使用 NLTK 从文本文件中查找每个单词的频率

import nltk
from nltk.corpus import webtext
from nltk.probability import FreqDist
 
nltk.download('webtext')
wt_words = webtext.words('testing.txt')
data_analysis = nltk.FreqDist(wt_words)
 
# Let's take the specific words only if their frequency is greater than 3.
filter_words = dict([(m, n) for m, n in data_analysis.items() if len(m) > 3])
 
for key in sorted(filter_words):
     print("%s: %s" % (key, filter_words[key]))
 
data_analysis = nltk.FreqDist(filter_words)
 
data_analysis.plot(25, cumulative=False)

Output:

[nltk_data] Downloading package webtext to
[nltk_data]     C:\Users\amit\AppData\Roaming\nltk_data...
[nltk_data]   Unzipping corpora\webtext.zip.
1989: 1
Accessing: 1
Analysis: 1
Anyone: 1
Chapter: 1
Coding: 1
Data: 1
...

13从语料库中创建词云

import nltk
from nltk.corpus import webtext
from nltk.probability import FreqDist
from wordcloud import WordCloud
import matplotlib.pyplot as plt
 
nltk.download('webtext')
wt_words = webtext.words('testing.txt') # Sample data
data_analysis = nltk.FreqDist(wt_words)
 
filter_words = dict([(m, n) for m, n in data_analysis.items() if len(m) > 3])
 
wcloud = WordCloud().generate_from_frequencies(filter_words)
 
# Plotting the wordcloud
plt.imshow(wcloud, interpolation="bilinear")
 
plt.axis("off")
(-0.5, 399.5, 199.5, -0.5)
plt.show()

Python 提供了非常多的库和内置函数。有不同的方法可以执行相同的任务，而在 Python 中，有个万能之王函数：lambda 函数，它可以以不同的方式在任何地方使用。今天将和大家一起研究下这个万能之王！

Lambda 函数简介

Lambda函数也被称为匿名(没有名称)函数，它直接接受参数的数量以及使用该参数执行的条件或操作，该参数以冒号分隔，并返回最终结果。为了在大型代码库上编写代码时执行一项小任务，或者在函数中执行一项小任务，便在正常过程中使用lambda函数。
lambda argument_list:expersion
argument_list是参数列表，它的结构与Python中函数(function)的参数列表是一样的

a,b
a=1,b=2
*args
**kwargs
a,b=1,*args
空
....

expression是一个关于参数的表达式，表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。

1
None
a+b
sum(a)
1 if a >10 else 0
[i for i in range(10)]
...

普通函数和Lambda函数的区别

1. 没有名称
   Lambda函数没有名称，而普通操作有一个合适的名称。

2. Lambda函数没有返回值
   使用def关键字构建的普通函数返回值或序列数据类型，但在Lambda函数中返回一个完整的过程。假设我们想要检查数字是偶数还是奇数，使用lambda函数语法类似于下面的代码片段。

   b = lambda x: "Even" if x%2==0 else "Odd" b(9)

3. 函数只在一行中
   Lambda函数只在一行中编写和创建，而在普通函数的中使用缩进

4. 不用于代码重用
   Lambda函数不能用于代码重用，或者不能在任何其他文件中导入这个函数。相反，普通函数用于代码重用，可以在外部文件中使用。

为什么要使用Lambda函数?
一般情况下，我们不使用Lambda函数，而是将其与高阶函数一起使用。高阶函数是一种需要多个函数来完成任务的函数，或者当一个函数返回任何另一个函数时，可以选择使用Lambda函数。

什么是高阶函数?
通过一个例子来理解高阶函数。假设有一个整数列表，必须返回三个输出。

• 一个列表中所有偶数的和

• 一个列表中所有奇数的和

• 一个所有能被三整除的数的和
  首先假设用普通函数来处理这个问题。在这种情况下，将声明三个不同的变量来存储各个任务，并使用一个for循环处理并返回结果三个变量。该方法常规可正常运行。

现在使用Lambda函数来解决这个问题，那么可以用三个不同的Lambda函数来检查一个待检验数是否是偶数，奇数，还是能被三整除，然后在结果中加上一个数。

def return_sum(func, lst):
  result = 0
  for i in lst:
    #if val satisfies func
    if func(i):
      result = result + i
  return result
lst = [11,14,21,56,78,45,29,28]
x = lambda a: a%2 == 0
y = lambda a: a%2 != 0
z = lambda a: a%3 == 0
print(return_sum(x, lst))
print(return_sum(y, lst))
print(return_sum(z, lst))

这里创建了一个高阶函数，其中将Lambda函数作为一个部分传递给普通函数。其实这种类型的代码在互联网上随处可见。然而很多人在使用Python时都会忽略这个函数，或者只是偶尔使用它，但其实这些函数真的非常方便，同时也可以节省更多的代码行。接下来我们一起看看这些高阶函数。

Python内置高阶函数

Map函数

map() 会根据提供的函数对指定序列做映射。

Map函数是一个接受两个参数的函数。第一个参数 function 以参数序列中的每一个元素调用 function 函数，第二个是任何可迭代的序列数据类型。返回包含每次 function 函数返回值的新列表。

map(function, iterable, ...)
Map函数将定义在迭代器对象中的某种类型的操作。假设我们要将数组元素进行平方运算，即将一个数组的每个元素的平方映射到另一个产生所需结果的数组。

arr = [2,4,6,8] 
arr = list(map(lambda x: x*x, arr)) 
print(arr)

我们可以以不同的方式使用Map函数。假设有一个包含名称、地址等详细信息的字典列表，目标是生成一个包含所有名称的新列表。

students = [
            {"name": "John Doe",
             "father name": "Robert Doe",
             "Address": "123 Hall street"
             },
            {
              "name": "Rahul Garg",
              "father name": "Kamal Garg",
              "Address": "3-Upper-Street corner"
            },
            {
              "name": "Angela Steven",
             "father name": "Jabob steven",
             "Address": "Unknown"
            }
]
print(list(map(lambda student: student['name'], students)))
>>> ['John Doe', 'Rahul Garg', 'Angela Steven']

上述操作通常出现在从数据库或网络抓取获取数据等场景中。

Filter函数

Filter函数根据给定的特定条件过滤掉数据。即在函数中设定过滤条件，迭代元素，保留返回值为True 的元素。Map 函数对每个元素进行操作，而 filter 函数仅输出满足特定要求的元素。

假设有一个水果名称列表，任务是只输出那些名称中包含字符“g”的名称。

fruits = ['mango', 'apple', 'orange', 'cherry', 'grapes'] 
print(list(filter(lambda fruit: 'g' in fruit, fruits)))

filter(function or None, iterable) --> filter object

返回一个迭代器，为那些函数或项为真的可迭代项。如果函数为None，则返回为真的项。

Reduce函数

这个函数比较特别，不是 Python 的内置函数，需要通过from functools import reduce 导入。Reduce 从序列数据结构返回单个输出值，它通过应用一个给定的函数来减少元素。

reduce(function, sequence[, initial]) -> value

将包含两个参数的函数(function)累计应用于序列(sequence)的项，从左到右，从而将序列reduce至单个值。

如果存在initial，则将其放在项目之前的序列，并作为默认值时序列是空的。

假设有一个整数列表，并求得所有元素的总和。且使用reduce函数而不是使用for循环来处理此问题。

from functools import reduce
lst = [2,4,6,8,10]
print(reduce(lambda x, y: x+y, lst))
>>> 30

还可以使用 reduce 函数而不是for循环从列表中找到最大或最小的元素。

lst = [2,4,6,8]

# 找到最大元素

print(reduce(lambda x, y: x if x>y else y, lst))

# 找到最小元素

print(reduce(lambda x, y: x if x<y else y, lst))

高阶函数的替代方法

列表推导式

其实列表推导式只是一个for循环，用于添加新列表中的每一项，以从现有索引或一组元素创建一个新列表。之前使用map、filter和reduce完成的工作也可以使用列表推导式完成。然而，相比于使用Map和filter函数，很多人更喜欢使用列表推导式，也许是因为它更容易应用和记忆。

同样使用列表推导式将数组中每个元素进行平方运算，水果的例子也可以使用列表推导式来解决。

arr = [2,4,6,8]

arr = [i**2 for i in arr]

print(arr)

fruit_result = [fruit for fruit in fruits if 'g' in fruit]

print(fruit_result)

字典推导式

与列表推导式一样，使用字典推导式从现有的字典创建一个新字典。还可以从列表创建字典。

假设有一个整数列表，需要创建一个字典，其中键是列表中的每个元素，值是列表中的每个元素的平方。

lst = [2,4,6,8]

D1 = {item:item**2 for item in lst}

print(D1)

>>> {2: 4, 4: 16, 6: 36, 8: 64}

# 创建一个只包含奇数元素的字典

arr = [1,2,3,4,5,6,7,8]

D2 = {item: item**2 for item in arr if item %2 != 0}

print(D2)

>>> {1: 1, 3: 9, 5: 25, 7: 49}

一个简单应用

如何快速找到多个字典的公共键

方法一

dl = [d1, d2, d3] # d1, d2, d3为字典，目标找到所有字典的公共键

[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]

例

dl = [{1:'life', 2: 'is'}, 

      {1:'short', 3: 'i'}, 

      {1: 'use', 4: 'python'}]

[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]

# 1

解析

# 列表表达式遍历dl中第一个字典中的键
[k for k in dl[0]]
# [1, 2]

# lambda 匿名函数判断字典中的键，即k值是否在其余字典中
list(map(lambda d: 1 in d, dl[1:]))
# [True, True]
list(map(lambda d: 2 in d, dl[1:]))
#[False, False]

# 列表表达式条件为上述结果([True, True])全为True,则输出对应的k值
#1

方法二

# 利用集合（set）的交集操作
from functools import reduce
# reduce(lambda a, b: a*b, range(1,11)) # 10!
reduce(lambda a, b: a & b, map(dict.keys, dl))

写在最后
目前已经学习了Lambda函数是什么，以及Lambda函数的一些使用方法。随后又一起学习了Python中的高阶函数，以及如何在高阶函数中使用lambda函数。除此之外，还学习了高阶函数的替代方法：在列表推导式和字典推导式中执行之前操作。虽然这些方法看似简单，或者说你之前已经见到过这类方法，但你很可能很少使用它们。你可以尝试在其他更加复杂的函数中使用它们，以便使代码更加简洁。

作者：编程学习网
来源：https://juejin.cn/post/7084062324981497870

接：写了个自动批改小孩作业的代码（上）

2.4 切割图像

上帝说要有光，就有了光。

于是，当光投过来时，物体的背后就有了影。

我们就知道了，有影的地方就有东西，没影的地方是空白。

这就是投影。

这个简单的道理放在图像切割上也很实用。

我们把文字的像素做个投影，这样我们就知道某个区间有没有文字，并且知道这个区间文字是否集中。

下面是示意图：

2.4.1 投影大法

最有效的方法，往往都是用循环实现的。

要计算投影，就得一个像素一个像素地数，查看有几个像素，然后记录下这一行有N个像素点。如此循环。

首先导入包：

import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFont
import PIL
import matplotlib.pyplot as plt
import os
import shutil
from numpy.core.records import array
from numpy.core.shape_base import block
import time

比如说要看垂直方向的投影，代码如下：

# 整幅图片的Y轴投影，传入图片数组，图片经过二值化并反色
def img_y_shadow(img_b):
    ### 计算投影 ###
    (h,w)=img_b.shape
    # 初始化一个跟图像高一样长度的数组，用于记录每一行的黑点个数
    a=[0 for z in range(0,h)]
    # 遍历每一列，记录下这一列包含多少有效像素点
    for i in range(0,h):          
        for j in range(0,w):      
            if img_b[i,j]==255:     
                a[i]+=1  
    return a

最终得到是这样的结构：[0, 79, 67, 50, 50, 50, 109, 137, 145, 136, 125, 117, 123, 124, 134, 71, 62, 68, 104, 102, 83, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, ……38, 44, 56, 106, 97, 83, 0, 0, 0, 0, 0, 0, 0]表示第几行总共有多少个像素点，第1行是0，表示是空白的白纸，第2行有79个像素点。

如果我们想要从视觉呈现出来怎么处理呢？那可以把它立起来拉直画出来。

# 展示图片
def img_show_array(a):
    plt.imshow(a)
    plt.show()
    
# 展示投影图， 输入参数arr是图片的二维数组，direction是x,y轴
def show_shadow(arr, direction = 'x'):

    a_max = max(arr)
    if direction == 'x': # x轴方向的投影
        a_shadow = np.zeros((a_max, len(arr)), dtype=int)
        for i in range(0,len(arr)):
            if arr[i] == 0:
                continue
            for j in range(0, arr[i]):
                a_shadow[j][i] = 255
    elif direction == 'y': # y轴方向的投影
        a_shadow = np.zeros((len(arr),a_max), dtype=int)
        for i in range(0,len(arr)):
            if arr[i] == 0:
                continue
            for j in range(0, arr[i]):
                a_shadow[i][j] = 255

    img_show_array(a_shadow)

我们来试验一下效果：

我们将上面的原图片命名为question.jpg放到代码同级目录。

# 读入图片
img_path = 'question.jpg'
img=cv2.imread(img_path,0) 
thresh = 200 
# 二值化并且反色
ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 

二值化并反色后的变化如下所示：

上面的操作很有作用，通过二值化，过滤掉杂色，通过反色将黑白对调，原来白纸区域都是255，现在黑色都是0，更利于计算。

计算投影并展示的代码：

img_y_shadow_a = img_y_shadow(img_b)
show_shadow(img_y_shadow_a, 'y') # 如果要显示投影

下面的图是上面图在Y轴上的投影

从视觉上看，基本上能区分出来哪一行是哪一行。

2.4.2 根据投影找区域

最有效的方法，往往还得用循环来实现。

上面投影那张图，你如何计算哪里到哪里是一行，虽然肉眼可见，但是计算机需要规则和算法。

# 图片获取文字块，传入投影列表，返回标记的数组区域坐标[[左，上，右，下]]
def img2rows(a,w,h):
    
    ### 根据投影切分图块 ### 
    inLine = False # 是否已经开始切分
    start = 0 # 某次切分的起始索引
    mark_boxs = []
    for i in range(0,len(a)):        
        if inLine == False and a[i] > 10:
            inLine = True
            start = i
        # 记录这次选中的区域[左，上，右，下]，上下就是图片，左右是start到当前
        elif i-start >5 and a[i] < 10 and inLine:
            inLine = False
            if i-start > 10:
                top = max(start-1, 0)
                bottom = min(h, i+1)
                box = [0, top, w, bottom]
                mark_boxs.append(box) 
                
    return mark_boxs

通过投影，计算哪些区域在一定范围内是连续的，如果连续了很长时间，我们就认为是同一区域，如果断开了很长一段时间，我们就认为是另一个区域。

通过这项操作，我们就可以获得Y轴上某一行的上下两个边界点的坐标，再结合图片宽度，其实我们也就知道了一行图片的四个顶点的坐标了mark_boxs存下的是[坐，上，右，下]。

如果调用如下代码：

(img_h,img_w)=img.shape
row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
print(row_mark_boxs)

我们获取到的是所有识别出来每行图片的坐标，格式是这样的：[[0, 26, 596, 52], [0, 76, 596, 103], [0, 130, 596, 155], [0, 178, 596, 207], [0, 233, 596, 259], [0, 282, 596, 311], [0, 335, 596, 363], [0, 390, 596, 415]]

2.4.3 根据区域切图片

最有效的方法，最终也得用循环来实现。这也是计算机体现它强大的地方。

# 裁剪图片,img 图片数组， mark_boxs 区域标记

def cut_img(img, mark_boxs):



    img_items = [] # 存放裁剪好的图片

    for i in range(0,len(mark_boxs)):

        img_org = img.copy()

        box = mark_boxs[i]

        # 裁剪图片

        img_item = img_org[box[1]:box[3], box[0]:box[2]]

        img_items.append(img_item)

    return img_items

这一步骤是拿着方框，从大图上用小刀划下小图，核心代码是img_org[box[1]:box[3], box[0]:box[2]]图片裁剪，参数是数组的[上：下，左：右]，获取的数据还是二维的数组。

如果保存下来：

# 保存图片
def save_imgs(dir_name, imgs):
 
    if os.path.exists(dir_name):
        shutil.rmtree(dir_name) 
    if not os.path.exists(dir_name):    
        os.makedirs(dir_name)

    img_paths = []
    for i in range(0,len(imgs)):
        file_path = dir_name+'/part_'+str(i)+'.jpg'
        cv2.imwrite(file_path,imgs[i])
        img_paths.append(file_path)
    
    return img_paths

# 切图并保存
row_imgs = cut_img(img, row_mark_boxs)
imgs = save_imgs('rows', row_imgs) # 如果要保存切图
print(imgs)

图片是下面这样的：

2.4.4 循环可去油腻

还是循环。横着行我们掌握了，那么针对每一行图片，我们竖着切成三块是不是也会了，一个道理。

需要注意的是，横竖是稍微有区别的，下面是上图的x轴投影。

横着的时候，字与字之间本来就是有空隙的，然后块与块也有空隙，这个空隙的度需要掌握好，以便更好地区分出来是字的间距还是算式块的间距。

幸好，有种方法叫膨胀。

膨胀对人来说不积极，但是对于技术来说，不管是膨胀（dilate），还是腐蚀（erode），只要能达到目的，都是好的。

kernel=np.ones((3,3),np.uint8)  # 膨胀核大小
row_img_b=cv2.dilate(img_b,kernel,iterations=6) # 图像膨胀6次

膨胀之后再投影，就很好地区分出了块。

根据投影裁剪之后如下图所示：

同理，不膨胀可截取单个字符。

这样，这是一块区域的字符。

一行的，一页的，通过循环，都可以截取出来。

有了图片，就可以识别了。有了位置，就可以判断识别结果的关系了。

下面提供一些代码，这些代码不全，有些函数你可能找不到，但是思路可以参考，详细的代码可以去我的github去看。

def divImg(img_path, save_file = False):

    img_o=cv2.imread(img_path,1) 
    # 读入图片
    img=cv2.imread(img_path,0) 
    (img_h,img_w)=img.shape
    thresh = 200
    # 二值化整个图，用于分行
    ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 

    # 计算投影，并截取整个图片的行
    img_y_shadow_a = img_y_shadow(img_b)
    row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
    # 切行的图片，切的是原图
    row_imgs = cut_img(img, row_mark_boxs)
    all_mark_boxs = []
    all_char_imgs = []
    # ===============从行切块======================
    for i in range(0,len(row_imgs)):
        row_img = row_imgs[i]
        (row_img_h,row_img_w)=row_img.shape
        # 二值化一行的图，用于切块
        ret,row_img_b=cv2.threshold(row_img,thresh,255,cv2.THRESH_BINARY_INV)
        kernel=np.ones((3,3),np.uint8)
        #图像膨胀6次
        row_img_b_d=cv2.dilate(row_img_b,kernel,iterations=6)
        img_x_shadow_a = img_x_shadow(row_img_b_d)
        block_mark_boxs = row2blocks(img_x_shadow_a, row_img_w, row_img_h)
        row_char_boxs = []
        row_char_imgs = []
        # 切块的图，切的是原图
        block_imgs = cut_img(row_img, block_mark_boxs)
        if save_file:
            b_imgs = save_imgs('cuts/row_'+str(i), block_imgs) # 如果要保存切图
            print(b_imgs)
        # =============从块切字====================
        for j in range(0,len(block_imgs)):
            block_img = block_imgs[j]
            (block_img_h,block_img_w)=block_img.shape
            # 二值化块,因为要切字符图片了
            ret,block_img_b=cv2.threshold(block_img,thresh,255,cv2.THRESH_BINARY_INV)
            block_img_x_shadow_a = img_x_shadow(block_img_b)
            row_top = row_mark_boxs[i][1]
            block_left = block_mark_boxs[j][0]
            char_mark_boxs,abs_char_mark_boxs = block2chars(block_img_x_shadow_a, block_img_w, block_img_h,row_top,block_left)
            row_char_boxs.append(abs_char_mark_boxs)
            # 切的是二值化的图
            char_imgs = cut_img(block_img_b, char_mark_boxs, True)
            row_char_imgs.append(char_imgs)
            if save_file:
                c_imgs = save_imgs('cuts/row_'+str(i)+'/blocks_'+str(j), char_imgs) # 如果要保存切图
                print(c_imgs)
        all_mark_boxs.append(row_char_boxs)
        all_char_imgs.append(row_char_imgs)


    return all_mark_boxs,all_char_imgs,img_o

最后返回的值是3个，all_mark_boxs是标记的字符位置的坐标集合。[左,上,右,下]是指某个字符在一张大图里的坐标，打印一下是这样的：

[[[[19, 26, 34, 53], [36, 26, 53, 53], [54, 26, 65, 53], [66, 26, 82, 53], [84, 26, 101, 53], [102, 26, 120, 53], [120, 26, 139, 53]], [[213, 26, 229, 53], [231, 26, 248, 53], [249, 26, 268, 53], [268, 26, 285, 53]], [[408, 26, 426, 53], [427, 26, 437, 53], [438, 26, 456, 53], [456, 26, 474, 53], [475, 26, 492, 53]]], [[[20, 76, 36, 102], [38, 76, 48, 102], [50, 76, 66, 102], [67, 76, 85, 102], [85, 76, 104, 102]], [[214, 76, 233, 102], [233, 76, 250, 102], [252, 76, 268, 102], [270, 76, 287, 102]], [[411, 76, 426, 102], [428, 76, 445, 102], [446, 76, 457, 102], [458, 76, 474, 102], [476, 76, 493, 102], [495, 76, 511, 102]]]]

它是有结构的。它的结构是：

all_char_imgs这个返回值，里面是上面坐标结构对应位置的图片。img_o就是原图了。

2.5 识别

循环，循环，还是TM循环！

对于识别，2.3 预测数据已经讲过了，那次是对于2张独立图片的识别，现在我们要对整张大图切分后的小图集合进行识别，这就又用到了循环。

翠花，上代码！

all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
model = cnn.create_model()
model.load_weights('checkpoint/char_checkpoint')
class_name = np.load('class_name.npy')

# 遍历行
for i in range(0,len(all_char_imgs)):
    row_imgs = all_char_imgs[i]
    # 遍历块
    for j in range(0,len(row_imgs)):
        block_imgs = row_imgs[j]
        block_imgs = np.array(block_imgs)
        results = cnn.predict(model, block_imgs, class_name)
        print('recognize result:',results)

上面代码做的就是以块为单位，传递给神经网络进行预测，然后返回识别结果。

针对这张图，我们来进行裁剪和识别。

看底部的最后一行

recognize result: ['1', '0', '12', '2', '10']
recognize result: ['8', '12', '6', '10']
recognize result: ['1', '0', '12', '7', '10']

结果是索引，不是真实的字符，我们根据字典10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'转换过来之后结果是：

recognize result: ['1', '0', '-', '2', '=']
recognize result: ['8', '-', '6', '=']
recognize result: ['1', '0', '-', '7', '=']

和图片是对应的：

2.6 计算并反馈

循环……

我们获取到了10-2=、8-6=2，也获取到了他们在原图的位置坐标[左,上,右,下]，那么怎么把结果反馈到原图上呢？

往往到这里就剩最后一步了。

再来温习一遍需求：作对了，能打对号；做错了，能打叉号；没做的，能补上答案。

实现分两步走：计算（是作对做错还是没错）和反馈（把预期结果写到原图上）。

2.6.1 计算 python有个函数很强大，就是eval函数，能计算字符串算式，比如直接计算eval("5+3-2")。

所以，一切都靠它了。

# 计算数值并返回结果  参数chars：['8', '-', '6', '=']
def calculation(chars):
    cstr = ''.join(chars)
    result = ''
    if("=" in cstr): # 有等号
        str_arr = cstr.split('=')
        c_str = str_arr[0]
        r_str = str_arr[1]
        c_str = c_str.replace("×","*")
        c_str = c_str.replace("÷","/") 
        try:
            c_r = int(eval(c_str))
        except Exception as e:
            print("Exception",e)

        if r_str == "":
            result = c_r
        else:
            if str(c_r) == str(r_str):
                result = "√"
            else:
                result = "×"

    return result

执行之后获得的结果是：

recognize result: ['8', '×', '4', '=']
calculate result: 32
recognize result: ['2', '-', '1', '=', '1']
calculate result: √
recognize result: ['1', '0', '-', '5', '=']
calculate result: 5

2.6.2 反馈

有了结果之后，把结果写到图片上，这是最后一步，也是最简单的一步。

但是实现起来，居然很繁琐。

得找坐标吧，得计算结果呈现的位置吧，我们还想标记不同的颜色，比如对了是绿色，错了是红色，补齐答案是灰色。

下面代码是在一个图img上，把文本内容text画到(left,top)位置，以特定颜色和大小。

# 绘制文本
def cv2ImgAddText(img, text, left, top, textColor=(255, 0, 0), textSize=20):
    if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型
        img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    # 创建一个可以在给定图像上绘图的对象
    draw = ImageDraw.Draw(img)
    # 字体的格式
    fontStyle = ImageFont.truetype("fonts/fangzheng_shusong.ttf", textSize, encoding="utf-8")
    # 绘制文本
    draw.text((left, top), text, textColor, font=fontStyle)
    # 转换回OpenCV格式
    return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

结合着切图的信息、计算的信息，下面代码提供思路参考：

# 获取切图标注，切图图片，原图图图片
all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
# 恢复模型，用于图片识别
model = cnn.create_model()
model.load_weights('checkpoint/char_checkpoint')
class_name = np.load('class_name.npy')

# 遍历行
for i in range(0,len(all_char_imgs)):
    row_imgs = all_char_imgs[i]
    # 遍历块
    for j in range(0,len(row_imgs)):
        block_imgs = row_imgs[j]
        block_imgs = np.array(block_imgs)
        # 图片识别
        results = cnn.predict(model, block_imgs, class_name)
        print('recognize result:',results)
        # 计算结果
        result = calculation(results)
        print('calculate result:',result)
        # 获取块的标注坐标
        block_mark = all_mark_boxs[i][j]
        # 获取结果的坐标，写在块的最后一个字
        answer_box = block_mark[-1]
        # 计算最后一个字的位置
        x = answer_box[2] 
        y = answer_box[3]
        iw = answer_box[2] - answer_box[0]
        ih = answer_box[3] - answer_box[1]
        # 计算字体大小
        textSize =  max(iw,ih)
        # 根据结果设置字体颜色
        if str(result) == "√":
            color = (0, 255, 0)
        elif str(result) == "×":
            color = (255, 0, 0)
        else:
            color = (192, 192,192)
        # 将结果写到原图上
        img_o = cv2ImgAddText(img_o, str(result), answer_box[2],  answer_box[1],color, textSize)
# 将写满结果的原图保存
cv2.imwrite('result.jpg', img_o)

结果是下面这样的：

注意

1. 同级新建fonts文件夹里拷贝一些字体文件，从这里找C:\Windows\Fonts，几十个就行。

2. get_character_pic.py 生成字体

3. cnn.py 训练数据

4. main.py 裁剪指定图片并识别，素材图片新建imgs文件夹,在imgs/question.png下，结果文件保存在imgs/result.png。

5. 注意如果识别不成功，很可能是question.png的字体你没有训练（这幅图的字体是方正书宋简体，但是你只训练了楷体），这时候可以使用楷体自己编一个算式图。

原文：https://juejin.cn/post/7006732549451939847

一、亮出效果

最近一些软件的搜题、智能批改类的功能要下线。

退1024步讲，要不要自己做一个自动批改的功能啊？万一哪天孩子要用呢！

昨晚我做了一个梦，梦见我实现了这个功能，如下图所示：

功能简介：作对了，能打对号；做错了，能打叉号；没做的，能补上答案。

醒来后，我环顾四周，赶紧再躺下，希望梦还能接上。

二、实现步骤

基本思路

其实，搞定两点就成，第一是能识别数字，第二是能切分数字。

首先得能认识5是5，这是前提条件，其次是能找到5、6、7、8这些数字区域的位置。

前者是图像识别，后者是图像切割。

• 对于图像识别，一般的套路是下面这样的（CNN卷积神经网络）：

• 对于图像切割，一般的套路是下面的这样（横向纵向投影法）：

既然思路能走得通，那么咱们先搞图像识别。准备数据->训练数据并保存模型->使用训练模型预测结果。

2.1 准备数据

对于男友，找一个油嘴滑舌的花花公子，不如找一个闷葫芦IT男，亲手把他培养成你期望的样子。

咱们不用什么官方的mnist数据集，因为那是官方的，不是你的，你想要添加±×÷它也没有。

有些通用的数据集，虽然很强大，很方便，但是一旦放到你的场景中，效果一点也不如你的愿。

只有训练自己手里的数据，然后自己用起来才顺手。更重要的是，我们享受创造的过程。

假设，我们只给口算做识别，那么我们需要的图片数据有如下几类：

索引：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
字符：0 1 2 3 4 5 6 7 8 9 = + - × ÷

如果能识别这些，基本上能满足整数的加减乘除运算了。

好了，图片哪里来？！

是啊，图片哪里来？

吓得我差点从梦里醒来，500万都规划好该怎么花了，居然双色球还没有选号！

梦里，一个老者跟我说，图片要自己生成。我问他如何生成，他呵呵一笑，消失在迷雾中……

仔细一想，其实也不难，打字我们总会吧，生成数字无非就是用代码把字写在图片上。

字之所以能展示，主要是因为有字体的支撑。

如果你用的是windows系统，那么打开KaTeX parse error: Undefined control sequence: \Windows at position 3: C:\̲W̲i̲n̲d̲o̲w̲s̲\Fonts这个文件夹，你会发现好多字体。

我们写代码调用这些字体，然后把它打印到一张图片上，是不是就有数据了。

而且这些数据完全是由我们控制的，想多就多，想少就少，想数字、字母、汉字、符号都可以，今天你搞出来数字识别，也就相当于你同时拥有了所有识别！想想还有点小激动呢！

看看，这就是打工和创业的区别。你用别人的数据相当于打工，你是不用操心，但是他给你什么你才有什么。自己造数据就相当于创业，虽然前期辛苦，你可以完全自己把握节奏，需要就加上，没用就去掉。

2.1.1 准备字体

建一个fonts文件夹，从字体库里拷一部分字体放进来，我这里是拷贝了13种字体文件。

好的，准备工作做好了，肯定很累吧，休息休息休息，一会儿再搞！

2.1.2 生成图片

代码如下，可以直接运行。

from __future__ import print_function
from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw
import os
import shutil
import time

# %% 要生成的文本
label_dict = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'}

# 文本对应的文件夹，给每一个分类建一个文件
for value,char in label_dict.items():
  train_images_dir = "dataset"+"/"+str(value)
  if os.path.isdir(train_images_dir):
      shutil.rmtree(train_images_dir)
  os.makedirs(train_images_dir)

# %% 生成图片
def makeImage(label_dict, font_path, width=24, height=24, rotate = 0):

  # 从字典中取出键值对
  for value,char in label_dict.items():
      # 创建一个黑色背景的图片，大小是24*24
      img = Image.new("RGB", (width, height), "black") 
      draw = ImageDraw.Draw(img)
      # 加载一种字体,字体大小是图片宽度的90%
      font = ImageFont.truetype(font_path, int(width*0.9))
      # 获取字体的宽高
      font_width, font_height = draw.textsize(char, font)
      # 计算字体绘制的x,y坐标，主要是让文字画在图标中心
      x = (width - font_width-font.getoffset(char)[0]) / 2
      y = (height - font_height-font.getoffset(char)[1]) / 2
      # 绘制图片，在那里画，画啥，什么颜色，什么字体
      draw.text((x,y), char, (255, 255, 255), font)
      # 设置图片倾斜角度
      img = img.rotate(rotate)
      # 命名文件保存，命名规则：dataset/编号/img-编号_r-选择角度_时间戳.png
      time_value = int(round(time.time() * 1000))
      img_path = "dataset/{}/img-{}_r-{}_{}.png".format(value,value,rotate,time_value)
      img.save(img_path)
       
# %% 存放字体的路径
font_dir = "./fonts"
for font_name in os.listdir(font_dir):
  # 把每种字体都取出来，每种字体都生成一批图片
  path_font_file = os.path.join(font_dir, font_name)
  # 倾斜角度从-10到10度，每个角度都生成一批图片
  for k in range(-10, 10, 1): 
      # 每个字符都生成图片
      makeImage(label_dict, path_font_file, rotate = k)

上面纯代码不到30行，相信大家应该能看懂！看不懂不是我的读者。

核心代码就是画文字。

draw.text((x,y), char, (255, 255, 255), font)

翻译一下就是：使用某字体在黑底图片的(x,y)位置写白色的char符号。

核心逻辑就是三层循环。

如果代码你运行的没有问题，最终会生成如下结果：

好了，数据准备好了。总共15个文件夹，每个文件夹下对应的各种字体各种倾斜角的字符图片3900个（字符15类×字体13种×角度20个），图片的大小是24×24像素。

有了数据，我们就可以再进行下一步了，下一步是训练和使用数据。

2.2 训练数据

2.2.1 构建模型

你先看代码，外行感觉好深奥，内行偷偷地笑。

# %% 导入必要的包 
import tensorflow as tf
import numpy as np
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib
import cv2

# %% 构建模型
def create_model():
  model = Sequential([
      layers.experimental.preprocessing.Rescaling(1./255, input_shape=(24, 24, 1)),
      layers.Conv2D(24,3,activation='relu'),
      layers.MaxPooling2D((2,2)),
      layers.Conv2D(64,3, activation='relu'),
      layers.MaxPooling2D((2,2)),
      layers.Flatten(),
      layers.Dense(128, activation='relu'),
      layers.Dense(15)]
  )
   
  model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

  return model

这个模型的序列是下面这样的，作用是输入一个图片数据，经过各个层揉搓，最终预测出这个图片属于哪个分类。

这么多层都是干什么的，有什么用？和衣服一样，肯定是有用的，内衣、衬衣、毛衣、棉衣各有各的用处。

2.2.2 卷积层 Conv2D

各个职能部门的调查员，搜集和整理某单位区域内的特定数据。我们输入的是一个图像，它是由像素组成的，这就是R e s c a l i n g ( 1. / 255 , i n p u t s h a p e = ( 24 , 24 , 1 ) ) Rescaling(1./255, input_shape=(24, 24, 1))Rescaling(1./255,input shape=(24,24,1))中，input_shape输入形状是24*24像素1个通道（彩色是RGB 3个通道）的图像。

卷积层代码中的定义是Conv2D(24,3),意思是用3*3像素的卷积核，去提取24个特征。

我把图转到地图上来，你就能理解了。以我大济南的市中区为例子。

卷积的作用就相当于从地图的某级单位区域中收集多组特定信息。比如以小区为单位去提取住宅数量、车位数量、学校数量、人口数、年收入、学历、年龄等等24个维度的信息。小区相当于卷积核。

提取完成之后是这样的。

第一次卷积之后，我们从市中区得到N个小区的数据。

卷积是可以进行多次的。

比如在小区卷积之后，我们还可在小区的基础上再来一次卷积，在卷积就是街道了。

通过再次以街道为单位卷积小区，我们就从市中区得到了N个街道的数据。

这就是卷积的作用。

通过一次次卷积，就把一张大图，通过特定的方法卷起来，最终留下来的是固定几组有目的数据，以此方便后续的评选决策。这是评选一个区的数据，要是评选济南市，甚至山东省，也是这么卷积。这和现实生活中评选文明城市、经济强省也是一个道理。

2.2.3 池化层 MaxPooling2D

说白了就是四舍五入。

计算机的计算能力是强大的，比你我快，但也不是不用考虑成本。我们当然希望它越快越好，如果一个方法能省一半的时间，我们肯定愿意用这种方法。

池化层干的就是这个事情。池化的代码定义是这样的M a x P o o l i n g 2 D ( ( 2 , 2 ) ) MaxPooling2D((2,2))MaxPooling2D((2,2))，这里是最大值池化。其中（2,2）是池化层的大小，其实就是在2*2的区域内，我们认为这一片可以合成一个单位。

再以地图举个例子，比如下面的16个格子里的数据，是16个街道的学校数量。

为了进一步提高计算效率，少计算一些数据，我们用2*2的池化层进行池化。

池化的方格是4个街道合成1个，新单位学校数量取成员中学校数量最大（也有取最小，取平均多种池化）的那一个。池化之后，16个格子就变为了4个格子，从而减少了数据。

这就是池化层的作用。

2.2.4 全连接层 Dense

弱水三千，只取一瓢。

在这里，它其实是一个分类器。

我们构建它时，代码是这样的D e n s e ( 15 ) Dense(15)Dense(15)。

它所做的事情，不管你前面是怎么样，有多少维度，到我这里我要强行转化为固定的通道。

比如识别字母a~z，我有500个神经元参与判断，但是最终输出结果就是26个通道(a,b,c,……,y,z)。

我们这里总共有15类字符，所以是15个通道。给定一个输入后，输出为每个分类的概率。

注意：上面都是二维的输入，比如24×24，但是全连接层是一维的，所以代码中使用了l a y e r s . F l a t t e n ( ) layers.Flatten()layers.Flatten()将二维数据拉平为一维数据([[11,12],[21,22]]->[11,12,21,22])。

对于总体的模型，调用m o d e l . s u m m a r y ( ) model.summary()model.summary()打印序列的网络结构如下：

_________________________________________________________________
Layer (type)                 Output Shape             Param #   
=================================================================
rescaling_2 (Rescaling)     (None, 24, 24, 1)         0         
_________________________________________________________________
conv2d_4 (Conv2D)           (None, 22, 22, 24)       240       
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 11, 11, 24)       0         
_________________________________________________________________
conv2d_5 (Conv2D)           (None, 9, 9, 64)         13888     
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)         0         
_________________________________________________________________
flatten_2 (Flatten)         (None, 1024)             0         
_________________________________________________________________
dense_4 (Dense)             (None, 128)               131200    
_________________________________________________________________
dense_5 (Dense)             (None, 15)               1935      
=================================================================
Total params: 147,263
Trainable params: 147,263
Non-trainable params: 0
_________________________________________________________________

我们看到conv2d_5 (Conv2D) (None, 9, 9, 64) 经过2*2的池化之后变为max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)。(None, 4, 4, 64) 再经过F l a t t e n FlattenFlatten拉成一维之后变为(None, 1024)，经过全连接变为(None, 128)再一次全连接变为(None, 15)，15就是我们的最终分类。这一切都是我们设计的。

m o d e l . c o m p i l e model.compilemodel.compile就是配置模型的几个参数，这个现阶段记住就可以。

2.2.5 训练数据

执行就完了。

# 统计文件夹下的所有图片数量
data_dir = pathlib.Path('dataset')
# 从文件夹下读取图片，生成数据集
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
  data_dir, # 从哪个文件获取数据
  color_mode="grayscale", # 获取数据的颜色为灰度
  image_size=(24, 24), # 图片的大小尺寸
  batch_size=32 # 多少个图片为一个批次
)
# 数据集的分类，对应dataset文件夹下有多少图片分类
class_names = train_ds.class_names
# 保存数据集分类
np.save("class_name.npy", class_names)
# 数据集缓存处理
AUTOTUNE = tf.data.experimental.AUTOTUNE
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
# 创建模型
model = create_model()
# 训练模型，epochs=10，所有数据集训练10遍
model.fit(train_ds,epochs=10)
# 保存训练后的权重
model.save_weights('checkpoint/char_checkpoint')

执行之后会输出如下信息：

Found 3900 files belonging to 15 classes. 
Epoch 1/10 122/122 [=========] - 2s 19ms/step - loss: 0.5795 - accuracy: 0.8615 
Epoch 2/10 122/122 [=========] - 2s 18ms/step - loss: 0.0100 - accuracy: 0.9992 
Epoch 3/10 122/122 [=========] - 2s 19ms/step - loss: 0.0027 - accuracy: 1.0000 
Epoch 4/10 122/122 [=========] - 2s 19ms/step - loss: 0.0013 - accuracy: 1.0000 
Epoch 5/10 122/122 [=========] - 2s 20ms/step - loss: 8.4216e-04 - accuracy: 1.0000 
Epoch 6/10 122/122 [=========] - 2s 18ms/step - loss: 5.5273e-04 - accuracy: 1.0000 
Epoch 7/10 122/122 [=========] - 3s 21ms/step - loss: 4.0966e-04 - accuracy: 1.0000 
Epoch 8/10 122/122 [=========] - 2s 20ms/step - loss: 3.0308e-04 - accuracy: 1.0000 
Epoch 9/10 122/122 [=========] - 3s 23ms/step - loss: 2.3446e-04 - accuracy: 1.0000 
Epoch 10/10 122/122 [=========] - 3s 21ms/step - loss: 1.8971e-04 - accuracy: 1.0000

我们看到，第3遍时候，准确率达到100%了。最后结束的时候，我们发现文件夹checkpoint下多了几个文件：

char_checkpoint.data-00000-of-00001
char_checkpoint.index
checkpoint

上面那几个文件是训练结果，训练保存之后就不用动了。后面可以直接用这些数据进行预测。

2.3 预测数据

终于到了享受成果的时候了。

# 设置待识别的图片
img1=cv2.imread('img1.png',0) 
img2=cv2.imread('img2.png',0) 
imgs = np.array([img1,img2])
# 构建模型
model = create_model()
# 加载前期训练好的权重
model.load_weights('checkpoint/char_checkpoint')
# 读出图片分类
class_name = np.load('class_name.npy')
# 预测图片，获取预测值
predicts = model.predict(imgs) 
results = [] # 保存结果的数组
for predict in predicts: #遍历每一个预测结果
  index = np.argmax(predict) # 寻找最大值
  result = class_name[index] # 取出字符
  results.append(result)
print(results)

我们找两张图片img1.png,img2.png，一张是数字6，一张是数字8，两张图放到代码同级目录下，验证一下识别效果如何。

图片要通过cv2.imread('img1.png',0) 转化为二维数组结构，0参数是灰度图片。经过处理后，图片转成的数组是如下所示(24,24)的结构：

我们要同时验证两张图，所以把两张图再组成imgs放到一起，imgs的结构是（2,24,24）。

下面是构建模型，然后加载权重。通过调用predicts = model.predict(imgs)将imgs传递给模型进行预测得出predicts。

predicts的结构是(2,15),数值如下面所示：

[[ 16.134243 -12.10675 -1.1994154 -27.766754 -43.4324 -9.633694 -12.214878 1.6287893 2.562174 3.2222707 13.834648 28.254173 -6.102874 16.76582 7.2586184] [ 5.022571 -8.762314 -6.7466817 -23.494259 -30.170597 2.4392672 -14.676962 5.8255725 8.855118 -2.0998626 6.820853 7.6578817 1.5132296 24.4664 2.4192357]]

意思是有2个预测结果，每一个图片的预测结果有15种可能。

然后根据 index = np.argmax(predict) 找出最大可能的索引。

根据索引找到字符的数值结果是[‘6’, ‘8’]。

下面是数据在内存中的监控：

可见，我们的预测是准确的。

下面，我们将要把图片中数字切割出来，进行识别了。

之前我们准备了数据，训练了数据，并且拿图片进行了识别，识别结果正确。

到目前为止，看来问题不大……没有大问题，有问题也大不了。

下面就是把图片进行切割识别了。

下面这张大图片，怎么把它搞一搞，搞成单个小数字的图片。

续：写了个自动批改小孩作业的代码（下）

原文：https://juejin.cn/post/7006732549451939847

参考链接：

https://mp.weixin.qq.com/s/Umq6UjeKD0kwgyZgVA28zA

https://weibo.com/5044281310/LbhRgewXz

    整理 | 王晓曼

今天准备爬取某某点评店铺信息时，遇到了『字体』反爬。比如这样的：

还有这样的：

可以看到这些字体已经被加密（反爬）

竟然遇到这种情况，那辰哥就带大家如何去解决这类反爬（字体反爬类）

01 网页分析

在开始分析反爬之前，先简单的介绍一下背景（爬取的网页）

辰哥爬取的某某点评的店铺信息。一开始查看网页源码是这样的

这种什么也看不到，咱们换另一种方式：通过程序直接把整个网页源代码保存下来

获取到的网页源码如下：

比如这里看到评论数（4位数）都有对应着一个编号（相同的数字编号相同），应该是对应着网站的字体库。

下一步，我们需要找到这个网站的字体库。

02 获取字体库

这里的字体库建议在目标网站里面去获取，因为不同的网站的字体库是不一样，导致解码还原的字体也会不一样。

1、抓包获取字体库

在浏览器network里面可以看到一共有三种字体库。（三种字体库各有不同的妙用，后面会有解释）

把字体库链接复制在浏览器里面打开，就可以把字体库下载到本地。

2、查看字体库

这里使用FontCreator的工具查看字体库。

下载地址：

https://www.high-logic.com/font-editor/fontcreator/download

这里需要注册，邮箱验证才能下载，不过辰哥已经下载了，可以在公众号回复：FC，获取安装包。

安装之后，把刚刚下载的字体库在FontCreator中打开

可以看到字体的内容以及对应的编号。

比如数字7对应F399、数字8对应F572 ，咱们在原网页和源码对比，是否如此？？？

可以看到，真是一模一样对应着解码就可以还原字体。

3、为什么会有三个字体库

在查看加密字体的CSS样式时，方式有css内容是这样的

字体库1：d35c3812.woff 对应解码class为 shopNum

字体库2：084c9fff.woff 对应解码class为 reviewTag和address

字体库3：73f5e6f3.woff 对应解码class为 tagName

也就是说，字体所属的不同class标签，对应的解密字体库是不一样的，辰哥这里不得不说一句：太鸡贼了

咱们这里获取的评论数，clas为shopNum，需要用到字体库d35c3812.woff

03 代码实现解密

1、加载字体库

既然我们已经知道了字体反爬的原理，那么我们就可以开始编程实现解密还原。

加载字体库的Python库包是：fontTools ，安装命令如下：

pip install fontTools

将字体库的内容对应关系保存为xml格式

code和name是一一对应关系

可以看到网页源码中的编号后四位对应着字体库的编号。

因此我们可以建立应该字体对应集合

建立好映射关系好，到网页源码中去进行替换

这样我们就成功的将字体反爬处理完毕。后面提取内容大家基本都没问题。

2、完整代码

输出结果：

可以看到加密的数字全部都还原了。

04 小结

辰哥在本文中主要讲解了如此处理字体反爬问题，并以某某点评为例去实战演示分析。辰哥在文中处理的数字类型，大家可以尝试去试试中文如何解决。

作者：Python研究者
来源：https://juejin.cn/post/6970933428145356831

1、迭代

1.1 迭代的概念

使用for循环遍历取值的过程叫做迭代，比如：使用for循环遍历列表获取值的过程

# Python 中的迭代
for value in [2, 3, 4]:
    print(value)

1.2 可迭代对象

标准概念：在类里面定义__iter__方法，并使用该类创建的对象就是可迭代对象

简单记忆：使用for循环遍历取值的对象叫做可迭代对象, 比如：列表、元组、字典、集合、range、字符串

1.3 判断对象是否是可迭代对象

# 元组，列表，字典，字符串，集合，range都是可迭代对象
from collections import Iterable
# 如果解释器提示警告，就是用下面的导入方式
# from collections.abc import Iterable

# 判断对象是否是指定类型
result = isinstance((3, 5), Iterable)
print("元组是否是可迭代对象:", result)

result = isinstance([3, 5], Iterable)
print("列表是否是可迭代对象:", result)

result = isinstance({"name": "张三"}, Iterable)
print("字典是否是可迭代对象:", result)

result = isinstance("hello", Iterable)
print("字符串是否是可迭代对象:", result)

result = isinstance({3, 5}, Iterable)
print("集合是否是可迭代对象:", result)

result = isinstance(range(5), Iterable)
print("range是否是可迭代对象:", result)

result = isinstance(5, Iterable)
print("整数是否是可迭代对象:", result)

# 提示: 以后还根据对象判断是否是其它类型，比如以后可以判断函数里面的参数是否是自己想要的类型
result = isinstance(5, int)
print("整数是否是int类型对象:", result)

class Student(object):
    pass

stu = Student()
result = isinstance(stu, Iterable)

print("stu是否是可迭代对象:", result)

result = isinstance(stu, Student)

print("stu是否是Student类型的对象:", result)

1.4 自定义可迭代对象

在类中实现__iter__方法

自定义可迭代类型代码

from collections import Iterable
# 如果解释器提示警告，就是用下面的导入方式
# from collections.abc import Iterable

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        pass

my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)

print(result)

for value in my_list:
    print(value)

执行结果:

Traceback (most recent call last):
True
  File "/Users/hbin/Desktop/untitled/aa.py", line 24, in <module>
    for value in my_list:
TypeError: iter() returned non-iterator of type 'NoneType'

通过执行结果可以看出来，遍历可迭代对象依次获取数据需要迭代器

总结

在类里面提供一个__iter__创建的对象是可迭代对象，可迭代对象是需要迭代器完成数据迭代的

2、迭代器

2.1 自定义迭代器对象

自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象

from collections import Iterable
from collections import Iterator

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
class MyIterator(object):

    def __init__(self, my_list):
        self.my_list = my_list

        # 记录当前获取数据的下标
        self.current_index = 0

        # 判断当前对象是否是迭代器
        result = isinstance(self, Iterator)
        print("MyIterator创建的对象是否是迭代器:", result)

    def __iter__(self):
        return self

    # 获取迭代器中下一个值
    def __next__(self):
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration


my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)

print(result)

for value in my_list:
    print(value)

运行结果:

True
MyIterator创建的对象是否是迭代器: True
1
2

2.2 iter()函数与next()函数

1. iter函数: 获取可迭代对象的迭代器，会调用可迭代对象身上的__iter__方法

2. next函数: 获取迭代器中下一个值，会调用迭代器对象身上的__next__方法

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
# 迭代器是记录当前数据的位置以便获取下一个位置的值
class MyIterator(object):

    def __init__(self, my_list):
        self.my_list = my_list

        # 记录当前获取数据的下标
        self.current_index = 0

    def __iter__(self):
        return self

    # 获取迭代器中下一个值
    def __next__(self):
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration

# 创建了一个自定义的可迭代对象
my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)

# 获取可迭代对象的迭代器
my_iterator = iter(my_list)
print(my_iterator)
# 获取迭代器中下一个值
# value = next(my_iterator)
# print(value)

# 循环通过迭代器获取数据
while True:
    try:
        value = next(my_iterator)
        print(value)
    except StopIteration as e:
        break

2.3 for循环的本质

遍历的是可迭代对象

• for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

遍历的是迭代器

• for item in Iterator 循环的迭代器，不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

2.4 迭代器的应用场景

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

现在我们想要通过for...in...循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。

class Fibonacci(object):

    def __init__(self, num):
        # num:表示生成多少fibonacci数字
        self.num = num
        # 记录fibonacci前两个值
        self.a = 0
        self.b = 1
        # 记录当前生成数字的索引
        self.current_index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_index < self.num:
            result = self.a
            self.a, self.b = self.b, self.a + self.b
            self.current_index += 1
            return result
        else:
            raise StopIteration


fib = Fibonacci(5)
# value = next(fib)
# print(value)

for value in fib:
    print(value)