小象学院之python实例

不念不忘少年蓝@ 2022-02-18 21:29 226阅读 0赞

### 文章目录 ###

*  python基础语法实例
 *   *  汇率转换
     *   *  1.0（缩进，注释 ，变量与命名，关键字 ，字符串，赋值 ，Input()与print()）
         *  2.0 (分支语句if else)
         *  3.0 (循环语句while)
         *  4.0 (函数的定义与调用)
         *  5.0 (匿名函数lambda)
     *  分形树绘制
     *   *  五角星绘制1.0 (turtle库)
         *  五角星绘制2.0 (复习函数与循环)
         *  五角星绘制3.0 (递归函数)
         *  分形树绘制 (递归函数的应用)
     *  BMR(basid metabolic rate:基础代谢率)计算器
     *   *  1.0 (数值类型及运算)
         *  2.0 (复习分支语句、循环语句及input()函数)
         *  3.0 (字符串操作)
         *  4.0 (异常处理)
     *  存钱挑战
     *   *  1.0 (复习循环语句及字符串操作)
         *  2.0 (列表的概念及操作,运用math库进行计算)
         *  3.0 (循环语句for, range()函数
         *  4.0 (函数的参数传递, 变量的作用范围)
         *  5.0 (时间处理库datetime)
     *  判断第几天
     *   *  1.0 (组合数据类型：元组)
         *  2.0 (复习列表的使用,理解列表和元组的区别)
         *  3.0 (组合数据类型：集合, 理解列表与集合的区别)
         *  4.0 (映射数据类型：字典)
     *  判断密码强弱
     *   *  1.0 (复习字符串与分支结构)
         *  2.0 (循环的跳出操作：break与continue)
         *  3.0 (文件操作：写操作)
         *  4.0 (文件操作：读操作)
         *  5.0 (面向过程编程vs面向对象编程；Python类的定义与使用)
         *  6.0 (面向对象编程的特点：封装、继承、多态)
     *  模拟掷骰子
     *   *  1.0（random模块）
         *  2.0（zip()函数的使用 ，复习字典的使用）
         *  3.0（Python绘图库matplotlib，散点图的简单绘制）
         *  4.0（简单的数据分析，matplotlib绘制直方图）
         *  5.0（科学计算库NumPy，NumPy中的向量化操作，使用NumPy进行简单的数据分析）
     *  空气质量指数(AQI)计算及分析
     *   *  1.0（复习分支结构、函数及异常处理）
         *  2.0（JSON文件格式及操作）
         *  3.0（CSV文件格式及写操作，理解JSON与CSV的关联及差别）
         *  4.0（CSV文件的读操作，os模块）
         *  5.0（什么是网络爬虫，request库）
         *  6.0（beautifulsoup库）
         *  7.0（巩固beautifulsoup库）
         *  8.0（完整网络爬虫的编写与实现）
         *  9.0（Pandas基础，利用Pandas进行数据处理及分析）
         *  10.0（数据清洗，利用Pandas进行数据可视化）

# python基础语法实例 #

## 汇率转换 ##

### 1.0（缩进，注释 ，变量与命名，关键字 ，字符串，赋值 ，Input()与print()） ###

# 输入人民币
    RMB_str_value = input('请输入人民币(CNY)金额: ')
    # 将字符串转换成数字
    RMB_value = eval(RMB_str_value)
    # 汇率
    usd_vs_RMB = 6.77
    # 汇率计算
    usd_value = RMB_value / usd_vs_RMB
    
    print('美元(USD)金额是:',usd_value)

### 2.0 (分支语句if else) ###

'''
        功能：输入带符号的数字，自动判断美元还是人民币，进行汇率换算
            人民币CNY 美元USD
        版本：2.0
        作者：飞
    '''
    
    # 汇率
    usd_vs_RMB = 6.77
    
    # 带单位的货币输入
    currency_str_value = input('请输入带单位的货币金额: ')
    
    # 获取货币单位
    unit = currency_str_value[-3:]
    
    if unit == 'CNY':
        # 输入的是人民币
        rmb_str_value = currency_str_value[:-3]
        # 将字符串转换成数字
        RMB_value = eval(rmb_str_value)
    
        # 汇率计算
        usd_value = RMB_value / usd_vs_RMB
    
        print('美元(USD)金额是:', usd_value)
    elif unit == 'USD':
        # 输入的是美元
        rmb_str_value = currency_str_value[:-3]
    
        # 将字符串转换成数字
        RMB_value = eval(rmb_str_value)
    
        # 汇率计算
        usd_value = RMB_value * usd_vs_RMB
    
        print('人民币(CNY)金额是:', usd_value)
    else:
        # 其他情况
        print('该程序尚不支持该货币类型1')

### 3.0 (循环语句while) ###

'''
        2.0功能：
             输入带符号的数字，自动判断美元还是人民币，进行汇率换算
            人民币CNY 美元USD
        版本：3.0
        新增功能：程序一直运行，直到用户选择退出
        作者：飞
    '''
    
    # 汇率
    usd_vs_RMB = 6.77
    
    # 带单位的货币输入
    currency_str_value = input('请输入带单位的货币金额（退出程序请输入Q）: ')
    
    i = 0
    
    while currency_str_value != 'Q':
    
        i = i+1
        # print('循环次数',i)
    
        # 获取货币单位
        unit = currency_str_value[-3:]
    
        if unit == 'CNY':
            # 输入的是人民币
            rmb_str_value = currency_str_value[:-3]
            # 将字符串转换成数字
            RMB_value = eval(rmb_str_value)
    
            # 汇率计算
            usd_value = RMB_value / usd_vs_RMB
    
            print('美元(USD)金额是:', usd_value)
        elif unit == 'USD':
            # 输入的是美元
            rmb_str_value = currency_str_value[:-3]
    
            # 将字符串转换成数字
            RMB_value = eval(rmb_str_value)
    
            # 汇率计算
            usd_value = RMB_value * usd_vs_RMB
    
            print('人民币(CNY)金额是:', usd_value)
        else:
            # 其他情况
            print('该程序尚不支持该货币类型')
    
        print('*********************************************************')
        # 带单位的货币输入
        currency_str_value = input('请输入带单位的货币金额（退出程序请输入Q）: ')
    
    print('程序已退出!')

### 4.0 (函数的定义与调用) ###

'''
        民币CNY 美元USD
    
        版本：
        1.0 功能：输入数字的人民币，进行美元汇率换算
        2.0 功能：输入带符号的数字，自动判断美元还是人民币
        3.0 功能：程序一直运行，直到用户选择退出
        4.0 功能：将汇率兑换功能封装到函数中
    
        作者：飞
    '''
    
    
    def convert_currency(rmb_str_value,exchange_rate):# 形参
        '''
            汇率兑换函数
        '''
        out = rmb_str_value * exchange_rate
        return out
    
    # 汇率
    usd_vs_RMB = 6.77
    
    # 带单位的货币输入
    currency_str_value = input('请输入带单位的货币金额: ')
    
    # 获取货币单位
    unit = currency_str_value[-3:]
    
    if unit == 'CNY':
        exchange_rate = 1/usd_vs_RMB
    elif unit == 'USD':
        exchange_rate = usd_vs_RMB
    else:
        # 其他情况
        exchange_rate = -1
    
    if exchange_rate != -1:
        rmb_str_value = eval(currency_str_value[:-3])
        # 调用函数
        out_money = convert_currency(rmb_str_value, exchange_rate) #实参
        print('转换后的金额', out_money)
    else:
        print('不支持该种货币！')

### 5.0 (匿名函数lambda) ###

'''
        民币CNY 美元USD
        功能：汇率换算
        版本：
        1.0 新增功能：输入数字的人民币，进行美元汇率换算
        2.0 新增功能：输入带符号的数字，自动判断美元还是人民币
        3.0 新增功能：程序一直运行，直到用户选择退出
        4.0 新增功能：将汇率兑换功能封装到函数中
        5.0 新增功能：1. 使程序结构化，def函数
                    2. 简单函数的定义，lambda函数
        作者：FLY
    '''
    
    
    # def convert_currency(rmb_value,exchange_rate):# 形参
    #     '''
    #         汇率兑换函数
    #     '''
    #     out = rmb_value * exchange_rate
    #     return out
    
    
    def main():
        '''
            主函数
        '''
        # 汇率
        usd_vs_RMB = 6.77
    
        # 带单位的货币输入
        currency_str_value = input('请输入带单位的货币金额: ')
    
        # 获取货币单位
        unit = currency_str_value[-3:]
    
        if unit == 'CNY':
            exchange_rate = 1/usd_vs_RMB
        elif unit == 'USD':
            exchange_rate = usd_vs_RMB
        else:
            # 其他情况
            exchange_rate = -1
    
        if exchange_rate != -1:
            rmb_value = eval(currency_str_value[:-3])
    
            # 简单函数的定义，lambda函数
            convert_currency2 = lambda x:x*exchange_rate
            out_money = convert_currency2(rmb_value)
    
            # # 调用函数
            # out_money = convert_currency(rmb_value, exchange_rate) #实参
    
            print('转换后的金额', out_money)
        else:
            print('不支持该种货币！')
    
    
    if __name__ == '__main__': # 永远成立，因为__name__ 就等于 '__main__'
        main()

## 分形树绘制 ##

### 五角星绘制1.0 (turtle库) ###

"""
        作者：冯飞
        功能：五角星的绘制
        版本：1.0
        日期：5/14/2019
    """
    
    import turtle #形状绘制函数
    
    def main():
    
        # 计数器
        count = 1
        while(count<=5):
    
            turtle.forward(100)
            turtle.right(144)
    
            count = count +1
    
        # # 第一条边
        # turtle.forward(100)   # 画笔向前移动50距离
        #
        # # 第二条边
        # turtle.right(144)     # 向右旋转144度
        # turtle.forward(100)
        #
        # # 第三条边
        # turtle.right(144)  # 向右旋转144度
        # turtle.forward(100)
        #
        # # 第四条边
        # turtle.right(144)  # 向右旋转144度
        # turtle.forward(100)
        #
        # # 第五条边
        # turtle.right(144)  # 向右旋转144度
        # turtle.forward(100)
    
        turtle.exitonclick() # 点击关闭图形窗口
    
    if __name__ == '__main__':
        main()

### 五角星绘制2.0 (复习函数与循环) ###

"""
        作者：冯飞
        功能：五角星的绘制
        2.0 新增功能：绘制不同大小的五角星
        日期：5/14/2019
    """
    
    import turtle #形状绘制函数
    
    
    def draw_pentagram(size):
        """
            绘制五角星
        """
        # 计数器
        count = 1
        while (count <= 5):
            turtle.forward(size)
            turtle.right(144)
            count += 1
    
    
    def main():
        """
            主函数
    
        """
        turtle.penup()          # 笔抬起
        turtle.backward(200)
        turtle.pendown()        # 笔放下
        turtle.pensize(2)       # 笔尺寸
        turtle.pencolor('blue') # 笔颜色
    
        size = 50
        while size <=100:
            # 调用函数
            draw_pentagram(size)
            size += 20
    
        turtle.exitonclick() # 点击关闭图形窗口
    
    if __name__ == '__main__':
        main()

### 五角星绘制3.0 (递归函数) ###

"""
        作者：冯飞
        功能：五角星的绘制
        2.0 新增功能：绘制不同大小的五角星
        3.0 新增功能：使用迭代函数绘制不同大小的五角星
        日期：5/14/2019
    """
    
    import turtle #形状绘制函数
    
    
    def draw_recursive_pentagram(size):
        """
            绘制五角星
        """
        # 计数器
        count = 1
        while (count <= 5):
            turtle.forward(size)
            turtle.right(144)
            count += 1
        # 五角星绘制完场，更新size参数
        size += 10
        if size<=100:
            draw_recursive_pentagram(size) # 递归函数，自己调用自己
    
    def main():
        """
            主函数
    
        """
        turtle.penup()          # 笔抬起
        turtle.backward(200)
        turtle.pendown()        # 笔放下
        turtle.pensize(2)       # 笔尺寸
        turtle.pencolor('blue') # 笔颜色
    
        size = 50
        # 调用函数
        draw_recursive_pentagram(size)
    
        turtle.exitonclick()  # 点击关闭图形窗口
    
    if __name__ == '__main__':
        main()

### 分形树绘制 (递归函数的应用) ###

"""
        作者：冯飞
        功能：利用递归函数绘制分形树
        版本：2.0
        思路：1. 绘制右侧树枝
             2. 返回树枝节点
             3. 绘制左侧树枝
             4. 返回树枝节点
    
        日期：5/14/2019
    """
    
    import turtle  # 形状绘制函数
    
    
    def draw_brach(branch_length):
        """
            绘制分形树
        """
    
        if branch_length > 5:
            # 绘制右侧树枝
            turtle.forward(branch_length)
            print('向前', branch_length)
    
            turtle.right(20)
            print('右转20')
            draw_brach(branch_length-15)
    
            # 绘制左侧树枝
            turtle.left(40)
            print('左转40')
            draw_brach(branch_length - 15)
    
            # 返回之前树枝
            turtle.right(20)
            print('右转20')
            turtle.backward(branch_length)
            print('返回', branch_length)
    
    
    def main():
        """
            主函数
    
        """
        turtle.left(90)  # 左转90度，即垂直向上方向
        turtle.penup()
        turtle.backward(150)
        turtle.pendown()
        turtle.pencolor('green')
    
        draw_brach(25)   # 调用函数，给定length
        turtle.exitonclick()  # 点击关闭图形窗口
    
    
    if __name__ == '__main__':
        main()

## BMR(basid metabolic rate:基础代谢率)计算器 ##

### 1.0 (数值类型及运算) ###

"""
        作者：FLY
        功能：BMR(basid metabolic rate:基础代谢率)计算器
        版本：1.0
        日期：5/15/2019
    """
    
    def main():
        """
            主函数
        """
        # 性别
        gender = '男'
    
        # 体重
        weight = 120
    
        # 身高
        height = 163
    
        # 年龄
        age = 26
    
        if gender == '男':
            # 男性
            bmr = 13.7*weight+5.0*height-6.8*age+66
    
        elif gender == '女':
            # 女性
            bmr = 9.6*weight+1.8*height-4.7*age+655
        else:
            bmr = -1
    
        if bmr!=-1:
            print('基础代谢率(大卡)',bmr)
        else:
            print('暂不支持该性别！')
    
    if __name__ == '__main__':
        main()

### 2.0 (复习分支语句、循环语句及input()函数) ###

"""
        作者：FLY
        功能：BMR(basid metabolic rate:基础代谢率)计算器
        2.0 :根据用户输入的信息，选择是否退出程序
        版本：2.0
        日期：5/15/2019
    """
    
    def main():
        """
            主函数
        """
        y_n = input('用户是否选择退出y/n:')
    
        while (y_n == 'n'):
            # 性别
            gender = input('性别：')
    
            # 体重
            weight = float(input('体重(kg)：'))
            print(type(weight))
    
            # 身高
            height = float(input('身高(cm)：'))
    
            # 年龄
            age = int(input('年龄：'))
    
            if gender == '男':
                # 男性
                bmr = 13.7*weight+5.0*height-6.8*age+66
    
            elif gender == '女':
                # 女性
                bmr = 9.6*weight+1.8*height-4.7*age+655
            else:
                bmr = -1
    
            if bmr != -1:
                print('基础代谢率(大卡)',bmr)
            else:
                print('暂不支持该性别！')
    
            print()  # 空行
            y_n = input('用户是否选择退出y/n:')
    
    
    if __name__ == '__main__':
        main()

### 3.0 (字符串操作) ###

"""
        作者：FLY
        功能：BMR(basid metabolic rate:基础代谢率)计算器
        2.0 :根据用户输入的信息，选择是否退出程序
        3.0 ：用户可以在一行输入所有信息，带单位的数字输出
        版本：3.0
        日期：5/15/2019
    """
    
    
    def main():
        """
            主函数
        """
        y_n = input('用户是否选择退出y/n:')
    
        while (y_n == 'n'):
    
            print('请输入以下信息，以空格隔开')
            input_str = input('性别 体重(kg) 身高(cm) 年龄：')
            str_list = input_str.split(' ')
            gender = str_list[0]
            weight = float(str_list[1])
            height = float(str_list[2])
            age = int(str_list[3])
    
            if gender == '男':
                # 男性
                bmr = 13.7*weight+5.0*height-6.8*age+66
    
            elif gender == '女':
                # 女性
                bmr = 9.6*weight+1.8*height-4.7*age+655
            else:
                bmr = -1
    
            if bmr != -1:
                print()
                print('您的性别：{},体重：{}公斤，身高：{}厘米，年龄：{}岁'.format(gender,weight,height,age))
                # print('基础代谢率',bmr,'大卡')
                print('基础代谢率：{}大卡'.format(bmr))
            else:
                print('暂不支持该性别！')
    
            print()  # 空行
            y_n = input('用户是否选择退出y/n:')
    
    
    if __name__ == '__main__':
        main()

### 4.0 (异常处理) ###

"""
        作者：FLY
        功能：BMR(basid metabolic rate:基础代谢率)计算器
        2.0 :根据用户输入的信息，选择是否退出程序
        3.0 ：用户可以在一行输入所有信息，带单位的数字输出
        4.0：处理异常操作
        版本：4.0
        日期：5/15/2019
    
        try:
            <body>
        except <ErrorType1>:
            <handle1>
        except <ErrorType2>:
            <handle2>
        except :
            <handle3>
        解释：
        当python遇到try语句，先尝试执行try包含的代码块
        如果没有遇到错误，执行try-except后面的语句
        如果遇到错误，python寻找一个符合该错误类型的异常语句，然后执行相应的处理代码
    
    """
    def try_function(str_list):
        try:
            gender = str_list[0]
            weight = float(str_list[1])
            height = float(str_list[2])
            age = int(str_list[3])
    
            if gender == '男':
                # 男性
                bmr = 13.7 * weight + 5.0 * height - 6.8 * age + 66
    
            elif gender == '女':
                # 女性
                bmr = 9.6 * weight + 1.8 * height - 4.7 * age + 655
    
            else:
    
                bmr = -1
    
            if bmr != -1:
                print()
                print('您的性别：{},体重：{}公斤，身高：{}厘米，年龄：{}岁'.format(gender, weight, height, age))
                # print('基础代谢率',bmr,'大卡')
                print('基础代谢率：{}大卡'.format(bmr))
            else:
                print('暂不支持该性别！')
    
        except ValueError:  # 可能会出现的报错类型：ValueError  向内置函数中输入了一个类型正确值不正确的对象
            print('请输入正确的信息！')
    
        except IndexError:  # 可能会出现的报错类型：IndexError  序列下标超出范围
            print('输入的信息过少！')
    
        except TypeError:  # 可能会出现的报错类型：TypeError  输入对象类型有误
            print('输入对象类型有误！')
    
        except:  # 其他所有的错误
            print('程序异常！')
    
        print()  # 空行
        y_n = input('用户是否选择退出y/n:')
    
    
    def main():
        """
            主函数
        """
        y_n = input('用户是否选择退出y/n:')
    
        while(y_n == 'n'):
    
            print('请输入以下信息，以空格隔开')
            input_str = input('性别 体重(kg) 身高(cm) 年龄：')
            str_list = input_str.split(' ')
    
            try_function(str_list)
    
    
    if __name__ == '__main__':
        main()

## 存钱挑战 ##

### 1.0 (复习循环语句及字符串操作) ###

"""
        作者：FLY
        功能：52周存钱挑战
        版本：1.0
        日期：05/15/2019
    """
    
    def main():
        """
            主函数
        """
        money_per_week = 10     # 每周的存款金额，这里初始化，第一周的存款金额
        increase_money = 10     # 递增金额
        i = 1                   # 第几周，这里初始化，第一周
        total_week = 52         # 总周数
        saving = 0              # 账户累计
    
        while i <= total_week:
            # 存钱操作
            saving += money_per_week
    
            # 输出
            print('第{}周，存入{}元，账户累计{}元 '.format(i, money_per_week, saving))  
     		
     		# 更新下一周的存钱金额
            money_per_week += increase_money
            i += 1
    
    if __name__ == '__main__':
        main()

### 2.0 (列表的概念及操作,运用math库进行计算) ###

"""
        作者：FLY
        功能：52周存钱挑战
        2.0 ：记录每周的存款数
        版本：2.0
        日期：05/15/2019
    """
    import math
    
    def main():
        """
            主函数
        """
        money_per_week = 10     # 每周的存款金额，这里初始化，第一周的存款金额
        increase_money = 10     # 递增金额
        i = 1                   # 第几周，这里初始化，第一周
        total_week = 52         # 总周数
        saving = 0              # 账户累计
    
        money_list = []         # 记录每周存款数的列表
    
        while i <= total_week:
            # 存钱操作
            # saving += money_per_week          # 版本2.0
    
            money_list.append(money_per_week)   # 版本3.0
            saving = math.fsum(money_list)      # 将集合内元素相加
            # 输出
            print('第{}周，存入{}元，账户累计{}元 '.format(i, money_per_week, saving))
    
            # 更新下一周的存钱金额
            money_per_week += increase_money
            i += 1
    
    
    if __name__ == '__main__':
        main()

### 3.0 (循环语句for, range()函数 ###

)

"""
        作者：FLY
        功能：52周存钱挑战
        2.0 ：记录每周的存款数-列表的append功能
        3.0: 使用循环直接计数
        版本：3.0
        日期：05/15/2019
    """
    import math
    
    def main():
        """
            主函数
        """
        money_per_week = 10     # 每周的存款金额，这里初始化，第一周的存款金额
        increase_money = 10     # 递增金额
        total_week = 52         # 总周数
        saving = 0              # 账户累计
    
        money_list = []         # 记录每周存款数的列表
    
        for i in range(total_week):  # range从0开始计数
            # 存钱操作
            money_list.append(money_per_week)
            saving = math.fsum(money_list)
            # 输出
            print('第{}周，存入{}元，账户累计{}元 '.format(i+1, money_per_week, saving))
    
            # 更新下一周的存钱金额
            money_per_week += increase_money
    
    
    if __name__ == '__main__':
        main()

### 4.0 (函数的参数传递, 变量的作用范围) ###

"""
        作者：FLY
        功能： 52周存钱挑战
        2.0 ：记录每周的存款数-列表的append功能
        3.0:  使用循环直接计数
        4.0： 灵活设置每周的存钱数，增加的存钱数，周数
        版本：4.0
        日期：05/15/2019
    
        局部变量：函数内的变量作用范围只在函数内
        全局变量：函数外的变量，在所有的函数中，都能使用，需标明global
    
        函数变量值改变如何传到主函数中：
        法一： 在函数外设置全局变量，函数体内需标明global  变量
        法二： 函数体内return变量
    """
    import math
    
    # # 全局变量
    # saving = 0
    
    
    def money_in_n_week(total_week,money_per_week,increase_money):
        # global saving
    
        money_list = []  # 记录每周存款数的列表
    
        for i in range(total_week):  # range从0开始计数
            # 存钱操作
            money_list.append(money_per_week)
            saving = math.fsum(money_list)
            # 输出
            # print('第{}周，存入{}元，账户累计{}元 '.format(i + 1, money_per_week, saving))
    
            # 更新下一周的存钱金额
            money_per_week += increase_money
    
        # print(saving)  # 循环完之后再打印
        return saving
    
    
    def main():
        """
            主函数
        """
        money_per_week = float(input('请输入每周的存款金额：'))     # 每周的存款金额，这里初始化，第一周的存款金额
        increase_money = float(input('请输入递增金额：'))      # 递增金额
        total_week = int(input('请总周数：') )         # 总周数
    
        # 调用函数
        saving = money_in_n_week(total_week, money_per_week, increase_money)
    
        print(saving)
    
    
    if __name__ == '__main__':
        main()

### 5.0 (时间处理库datetime) ###

"""
        作者：FLY
        功能： 52周存钱挑战
        2.0 ：记录每周的存款数-列表的append功能
        3.0:  使用循环直接计数
        4.0： 灵活设置每周的存钱数，增加的存钱数，周数
        5.0： 根据用户输入的日期，判断是一年中的第几周，，然后输出响应的存款金额
        版本：5.0
        日期：05/15/2019
    
        局部变量：函数内的变量作用范围只在函数内
        全局变量：函数外的变量，在所有的函数中，都能使用，需标明global
    
        函数变量值改变如何传到主函数中：
        法一： 在函数外设置全局变量，函数体内需标明global  变量
        法二： 函数体内return变量
    
    
        datetime库中的datetime函数：
         datetime.datetime.now()    # 生成当前的日期，时间
         Out[16]: datetime.datetime(2019, 5, 16, 16, 22, 38, 130340))
    
         解析时间字符串函数 datetime.strptime（时间字符串,'格式'），将时间字符串转换为日期
         格式'%Y/%m/%d' 或'%Y-%m-%d'    Y对应的是四位数的年份
         格式'%y/%m/%d' 或'%y-%m-%d'    Y对应的是两位数的年份
    
         格式化字符串函数 datetime.strftime（日期,'格式'），将日期转换为时间字符串
         eg:
         date = datetime.datetime.strptime('19/05/16', '%y/%m/%d')
         datetime.datet
    
    """
    """
        List：
            列表（List）是有序的元素集合
            可通过索引访问单个元素，如L[2],L[-1]
            可通过区间索引访问子列表内容，如;[2:5],L[-3:]
            列表中每个元素类型可以不同
    
            list1 + list2 : 合并（连接）两个列表
            list1 * n : 重复n次列表内容
            len（list1） : 返回列表长度（元素个数）
            x  in list1 ： 检查元素是否在列表中
    
            list1.append（x） ：将x添加到列表末尾
            list1.sort（） ：对列表元素排列（升序）
            list1.reverse（） ：将列表元素逆序
            list1.index（x） ：返回第一次出现元素x的索引值
            list1.insert（i，x） ：在位置i处插入元素x
            list1.count（x） ：返回元素x在列表中的数量
            list1.pop（i） ：取出列表中i位置上的元素，并将其删除
    
        math库：http://docs.python.org/3/library/math.html
            math.pi :圆周率
            math.ceil（x） :对x向上取整
            math.floor(x) :对x向下取整
            math.pow(x,y) :x的y次方
            math.sqrt(x) :x的平方根
            math.fsum(list1) :对集合内的元素求和
            ......
    """
    
    import math
    import datetime
    
    
    def money_in_n_week(total_week,money_per_week,increase_money):
    
        money_list = []  # 记录每周存款数的列表
        save_money_list = []
    
        for i in range(total_week):  # range从0开始计数
            # 存钱操作
            money_list.append(money_per_week)
    
            saving = math.fsum(money_list)
            save_money_list.append(saving)
            # 输出
            # print('第{}周，存入{}元，账户累计{}元 '.format(i + 1, money_per_week, saving))
    
            # 更新下一周的存钱金额
            money_per_week += increase_money
    
        return save_money_list
    
    
    def main():
        """
            主函数
        """
        money_per_week = float(input('请输入每周的存款金额：'))     # 每周的存款金额，这里初始化，第一周的存款金额
        increase_money = float(input('请输入递增金额：'))          # 递增金额
        total_week = int(input('请总周数：') )                    # 总周数
    
        # 调用函数
        save_money_list = money_in_n_week(total_week, money_per_week, increase_money)
    
        date = input('请输入日期：（yyyy/mm/dd）')
    
        # 解析时间字符串函数 datetime.strptime（时间字符串,'格式'），将时间字符串转换为日期
        # 格式化字符串函数 datetime.strftime（日期,'格式'），将解析后的日期转换为时间字符串
    
        data_p = datetime.datetime.strptime(date, '%Y/%m/%d')
        week = data_p.isocalendar()[1]                          # input：解析后的日期，out：年份，第几周，周几
    
        print('第{}周的存款：{}元'.format(week,save_money_list[week-1]))
    
    
    if __name__ == '__main__':
        main()

## 判断第几天 ##

### 1.0 (组合数据类型：元组) ###

"""
        作者：FLY
        版本：1.0
        日期：16/05/02019
        功能：输入日期，判断这一天是这一年的第几天
    
        引入元祖，元祖特点，一经输入元祖中元素，不能改变,删除，添加
        求和用math.fsum 结果是浮点数，精度更高
             sum 简单实现求和
    """
    
    from datetime import datetime
    import math
    
    
    def main():
    
        input_date_str = input('请输入日期（yyyy/mm/dd）：')
        input_date = datetime.strptime(input_date_str, '%Y/%m/%d')
        print(input_date)
    
        year = input_date.year
        month = input_date.month
        day = input_date.day
    
        per_month_day = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
        sum_day = math.fsum(per_month_day[:month-1]) + day
    
        # 判断闰年
        if (year % 400 == 0) or ((year % 100!=0)and(year % 4 == 0)):
            if month > 2:
                sum_day += + 1
    
        print('一共{}天'.format(sum_day))
    
    
    if __name__ == '__main__':
        main()

### 2.0 (复习列表的使用,理解列表和元组的区别) ###

"""
        作者：FLY
        版本：2.0
        日期：16/05/02019
        功能：输入日期，判断这一天是这一年的第几天
        2.0 ：用列表替换元祖,列表可以改变，删除，添加元素
    
        元祖特点，一经输入元祖中元素，不能改变,删除，添加
        求和用math.fsum 结果是浮点数，精度更高
             sum 简单实现求和
    """
    
    from datetime import datetime
    import math
    
    
    def is_leap_year(year):
        """
            判断是否是闰年
            是，返回True
            否，返回False
    
        """
        # 判断闰年
        is_leap = False
        if (year % 400 == 0) or ((year % 100 != 0) and (year % 4 == 0)):
            is_leap = True
    
        return is_leap
    
    
    def main():
    
        input_date_str = input('请输入日期（yyyy/mm/dd）：')
        input_date = datetime.strptime(input_date_str, '%Y/%m/%d')
        print(input_date)
    
        year = input_date.year
        month = input_date.month
        day = input_date.day
    
        per_month_day = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    
        if is_leap_year(year):
            per_month_day [1] = 29
        sum_day = math.fsum(per_month_day[:month - 1]) + day
    
    
        # if month > 2 and is_leap_year(year):
        #     sum_day += + 1
    
        print('一共{}天'.format(sum_day))
    
    
    if __name__ == '__main__':
        main()

### 3.0 (组合数据类型：集合, 理解列表与集合的区别) ###

"""
        作者：FLY
        版本：3.0
        日期：16/05/02019
        1.0：输入日期，判断这一天是这一年的第几天
        2.0 ：用列表替换元祖,列表可以改变，删除，添加元素 []
        3.0 : 将月份划分为不同的集合再操作
    
        集合：元素无序
            减，交，交集的补集，并集                 {}
        元祖特点，一经输入元祖中元素，不能改变,删除，添加  ()
        求和用math.fsum 结果是浮点数，精度更高
             sum 简单实现求和
    """
    
    from datetime import datetime
    import math
    
    
    def is_leap_year(year):
        """
            判断是否是闰年
            是，返回True
            否，返回False
    
        """
        # 判断闰年
        is_leap = False
        if (year % 400 == 0) or ((year % 100 != 0) and (year % 4 == 0)):
            is_leap = True
    
        return is_leap
    
    
    def main():
    
        input_date_str = input('请输入日期（yyyy/mm/dd）：')
        input_date = datetime.strptime(input_date_str, '%Y/%m/%d')
        print(input_date)
    
        year = input_date.year
        month = input_date.month
        day = input_date.day
    
        _31_day = {
        1,3,5,7,8,10,12}
        _30_day = {
        4,6,9,11}
    
        sum_day = day
    
        for i in range(1, month):
            if i in _31_day:
                sum_day += 31
            elif i in _30_day:
                sum_day += 30
    
        if month > 2 and is_leap_year(year):
            sum_day += 1
    
        print('{}年第{}天'.format(year, sum_day))
    
    
    if __name__ == '__main__':
        main()

### 4.0 (映射数据类型：字典) ###

"""
        作者：FLY
        版本：4.0
        日期：16/05/02019
        1.0：输入日期，判断这一天是这一年的第几天
        2.0 ：用列表替换元祖
        3.0 : 将月份划分为不同的集合再操作
        4.0 ：将月份及其对应天数通过字典表示
    
        字典：
            增加一项：
                d[key] = value
            访问：
                d[key]
            删除某项：
                del d[key]
            key 是否在字典中：    返回True or False
                key in d
    
        字典的遍历：
        1. 遍历所有的key:
            for key in d.keys()
                print(key)
        2. 遍历所有的value：
            for value in d.value():
                print(value)
        3. 遍历所有的数据项：
            for item in d.items():
                print(items)
    
        列表：可以改变，删除，添加元素                 []
        集合：元素无序
            减，交，交集的补集，并集                  {}
        元祖特点，一经输入元祖中元素，不能改变,删除，添加  ()
    
        求和用math.fsum 结果是浮点数，精度更高
             sum 简单实现求和
    """
    
    from datetime import datetime
    import math
    
    
    def is_leap_year(year):
        """
            判断是否是闰年
            是，返回True
            否，返回False
    
        """
        # 判断闰年
        is_leap = False
        if (year % 400 == 0) or ((year % 100 != 0) and (year % 4 == 0)):
            is_leap = True
    
        return is_leap
    
    
    def main():
    
        input_date_str = input('请输入日期（yyyy/mm/dd）：')
        input_date = datetime.strptime(input_date_str, '%Y/%m/%d')
        print(input_date)
    
        year = input_date.year
        month = input_date.month
        day = input_date.day
    
        # 设置天数为字典格式，访问月数读取值
        month_day_dict = {
        1: 31,
                          2: 28,
                          3: 31,
                          4: 30,
                          5: 31,
                          6: 30,
                          7: 31,
                          8: 31,
                          9: 30,
                          10: 31,
                          11: 30,
                          12: 31}
    
        sum_day = day
    
        for i in range(1, month):
            sum_day += month_day_dict[i]
    
        if month > 2 and is_leap_year(year):
            sum_day += 1
    
        print('{}年第{}天'.format(year, sum_day))
    
    
    if __name__ == '__main__':
        main()

## 判断密码强弱 ##

### 1.0 (复习字符串与分支结构) ###

"""
        作者：FLY
        版本：1.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
         字符串判断：
             长度判断：len()
             str.isnumeric() 检测字符串是否只由数字组成
             str.isalpha() 检测字符串是否只由字母组成
             str.islower() 检测字符串中所有的字母是否都为小写
             str.isupper() 检测字符串中所有的字母是否都为大写
    
            同样，字符串和子字符串都符合这一规律
    """
    
    
    def str_clude_num(password_str):
        """
            判断字符串中是否含有数字，通过子字符串的遍历，每个子字符串是否只由数字组成
        """
        # 注意，这里的字符串并没有全部遍历，只要if语句判断为真，就返回True
        for i in password_str:
            if i.isnumeric():
                return True
            return False
    
    
    def str_clude_alpha(password_str):
        """
            判断字符串中是否含有字母，通过子字符串的遍历，每个子字符串是否只由字母组成
        """
        for i in password_str:
            if i.isalpha():
                return True
            return False
    
    
    def main():
        password_str = input('请输入您的密码：')
    
        password_strenth = 0
    
        # 判断密码长度
        if len(password_str) >= 8:
            password_strenth += 1
        else:
            print('密码要求至少8位！')
    
        # 判断密码字符串是否含有数字
        if str_clude_num(password_str):
            password_strenth += 1
        else:
            print('密码要求包含数字！')
    
        # 判断密码字符串是否含有字母
        if str_clude_alpha(password_str):
            password_strenth += 1
        else:
            print('密码要求包含字母！')
    
        # 密码强度合格
        if password_strenth == 3:
            print('密码强度合格！')
        else:
            print('密码强度不合格！')
    
    
    if __name__ == '__main__':
        main()

### 2.0 (循环的跳出操作：break与continue) ###

"""
        作者：FLY
        版本：1.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
        2.0：限制密码设置次数；循环的终止
    
    """
    
    
    def str_clude_num(password_str):
    
        """
            判断字符串中是否含有数字，通过子字符串的遍历，每个子字符串是否只由数字组成
        """
        have_num = False
    
        for i in password_str:
            if i.isnumeric():
                have_num = True
                break
    
        return have_num
    
    
    def str_clude_alpha(password_str):
    
        """
                判断字符串中是否含有字母，通过子字符串的遍历，每个子字符串是否只由字母组成
        """
        have_alpha = False
    
        for c in password_str:
            if c.isalpha():
                have_alpha = True
                break
    
        return have_alpha
    
    
    def main():
    
        """
            主函数
        """
    
        try_times = 5  # 最多尝试5次
        while try_times > 0:
    
            password_str = input('请输入您的密码：')
    
            password_strenth = 0
    
            # 判断密码长度
            if len(password_str) >= 8:
                password_strenth += 1
            else:
                print('密码要求至少8位！')
    
            # 判断密码字符串是否含有数字
            if str_clude_num(password_str):
                password_strenth += 1
            else:
                print('密码要求包含数字！')
    
            # 判断密码字符串是否含有字母
            if str_clude_alpha(password_str):
                password_strenth += 1
            else:
                print('密码要求包含字母！')
    
            # 密码强度是否合格
            if password_strenth == 3:
                print('恭喜！密码强度合格！')
                break
            else:
                print('密码强度不合格！')
                try_times -= 1
    
            print()
    
            if try_times <= 0:
                print('尝试次数过多！')
    
    
    if __name__ == '__main__':
        main()

### 3.0 (文件操作：写操作) ###

"""
            作者：FLY
        版本：3.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
        2.0：限制密码设置次数；循环的终止
        3.0：保存设置的密码及其对应的强度到文件中
    
         字符串判断：
             长度判断：len()
             str.isnumeric() 检测字符串是否只由数字组成
             str.isalpha() 检测字符串是否只由字母组成
             str.islower() 检测字符串中所有的字母是否都为小写
             str.isupper() 检测字符串中所有的字母是否都为大写
    
            同样，字符串和子字符串都符合这一规律
    
        打开文件：open(filename,mode)
        filename:文件名（包括路径）  mode: 打开模式
        mode：
            r  - 只读，文件不存在时报错
            w  - 只写，文件不存在时自动创建
            a  - 在文件末尾添加，不覆盖
            r+ - 读写
    
        写入文件：从计算机内存向文件写入数据
            write() - 将文本数据写入文件中
            writelines() - 将字符串列表写入文件中
    
        关闭文件：终止程序与文件的关联
            close()
    """
    
    
    def str_clude_num(password_str):
    
        """
            判断字符串中是否含有数字，通过子字符串的遍历，每个子字符串是否只由数字组成
        """
        have_num = False
    
        for i in password_str:
            if i.isnumeric():
                have_num = True
                break
    
        return have_num
    
    
    def str_clude_alpha(password_str):
    
        """
                判断字符串中是否含有字母，通过子字符串的遍历，每个子字符串是否只由字母组成
        """
        have_alpha = False
    
        for c in password_str:
            if c.isalpha():
                have_alpha = True
                break
    
        return have_alpha
    
    
    def main():
    
        """
            主函数
        """
    
        try_times = 3  # 最多尝试5次
        while try_times > 0:
    
            password_str = input('请输入您的密码：')
    
            password_strenth = 0
    
            # 判断密码长度
            if len(password_str) >= 8:
                password_strenth += 1
            else:
                print('密码要求至少8位！')
    
            # 判断密码字符串是否含有数字
            if str_clude_num(password_str):
                password_strenth += 1
            else:
                print('密码要求包含数字！')
    
            # 判断密码字符串是否含有字母
            if str_clude_alpha(password_str):
                password_strenth += 1
            else:
                print('密码要求包含字母！')
    
            if password_strenth <3:
                password_strenth_level = '密码强度较弱'
            else:
                password_strenth_level = '密码强度较强'
    
            # 打开/没有的话新建一个文件，写，关闭
            # 这段代码如果放在 （print()）之后，则输入正确代码后会执行break，直接跳出循环，不执行后续语句，因此要放在break前面
            f = open('D:\software\pycharm\lect06\password.txt', 'a')
            f.write(password_str + '\n')                                                     # 每次循环都要换行
            f.write('密码：{},密码强度等级:{}\n'.format(password_str, password_strenth_level))   # 格式化字符串
            f.close()
    
            # 密码强度是否合格
            if password_strenth == 3:
                print('恭喜！密码强度合格！')
                break
            else:
                print('密码强度不合格！')
                try_times -= 1
    
            print()
    
            if try_times <= 0:
                print('尝试次数过多！')
    
    
    if __name__ == '__main__':
        main()

### 4.0 (文件操作：读操作) ###

"""
        作者：FLY
        版本：4.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
        2.0：限制密码设置次数；循环的终止
        3.0：保存设置的密码及其对应的强度到文件中
        4.0: 读取保存的密码
    
         字符串判断：
             长度判断：len()
             str.isnumeric() 检测字符串是否只由数字组成
             str.isalpha() 检测字符串是否只由字母组成
             str.islower() 检测字符串中所有的字母是否都为小写
             str.isupper() 检测字符串中所有的字母是否都为大写
    
            同样，字符串和子字符串都符合这一规律
    
        打开文件：open(filename,mode)
            filename:文件名（包括路径）  mode: 打开模式
            mode：
                r  - 只读，文件不存在时报错
                w  - 只写，文件不存在时自动创建
                a  - 在文件末尾添加，不覆盖
                r+ - 读写
    
        写入文件：从计算机内存向文件写入数据
            write() - 将字符串写入文件中
            writelines() - 将字符串列表写入文件中
    
        关闭文件：终止程序与文件的关联
            close()
    
        读取操作：从文件中读取数据到计算机内存中
            read()：返回值为包含整个文件内容的一个字符串
            readline()：返回值为文件一行的一个字符串
            readlines()：返回值为整个文件内容的列表，每个元素是以换行符为结尾的一行字符串
    
        eg:
            f = open('password.txt')
    
            read()函数
            content = f.read()
            print(content)
    
            readline()函数:一行一行读，需反复调用
            line_1 = f.readline()
            print(line_1)
            line_2 = f.readline()
            print(line_2)
    
            readlines()函数
            content = f.readlines()
            print(content)
    
            for line in f.readlines():   # 或者for line in f：
                print('read:{}'.format(line))
    
            f.close()
    """
    
    
    def main():
    
        """
            主函数
        """
        f = open('password.txt')
        
        # readlines()
        for line in f.readlines():
            print('read:{}'.format(line))
    
        f.close()
    
    
    if __name__ == '__main__':
        main()

### 5.0 (面向过程编程vs面向对象编程；Python类的定义与使用) ###

"""
        作者：FLY
        版本：5.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
        2.0：限制密码设置次数；循环的终止
        3.0：保存设置的密码及其对应的强度到文件中
        4.0: 读取保存的密码
        5.0：定义一个passward工具类
    
         字符串判断：
             长度判断：len()
             str.isnumeric() 检测字符串是否只由数字组成
             str.isalpha() 检测字符串是否只由字母组成
             str.islower() 检测字符串中所有的字母是否都为小写
             str.isupper() 检测字符串中所有的字母是否都为大写
    
            同样，字符串和子字符串都符合这一规律
    
        打开文件：open(filename,mode)
            filename:文件名（包括路径）  mode: 打开模式
            mode：
                r  - 只读，文件不存在时报错
                w  - 只写，文件不存在时自动创建
                a  - 在文件末尾添加，不覆盖
                r+ - 读写
    
        写入文件：从计算机内存向文件写入数据
            write() - 将字符串写入文件中
            writelines() - 将字符串列表写入文件中
    
        关闭文件：终止程序与文件的关联
            close()
    
        读取操作：从文件中读取数据到计算机内存中
            read()：返回值为包含整个文件内容的一个字符串
            readline()：返回值为文件一行的一个字符串
            readlines()：返回值为整个文件内容的列表，每个元素是以换行符为结尾的一行字符串
    
        eg:
            f = open('password.txt')
    
            read()函数
            content = f.read()
            print(content)
    
            readline()函数:一行一行读，需反复调用
            line_1 = f.readline()
            print(line_1)
            line_2 = f.readline()
            print(line_2)
    
            readlines()函数
            content = f.readlines()
            print(content)
    
            for line in f.readlines():   # 或者for line in f：
                print('read:{}'.format(line))
    
            f.close()
    
        类的定义:
            __init__(self):初始化对象的各属性
    """
    
    
    class passwordtool:
        """
            定义类
        """
        # 类的属性（类的初始化)
        def __init__(self, password_str):
            self.password_str = password_str
            self.password_strenth = 0
    
        # 类的方法
        def process_passward(self):
            # 规则一：判断密码长度
            if len(self.password_str) >= 8:
                self.password_strenth += 1
            else:
                print('密码要求至少8位！')
    
            # 规则二：判断密码字符串是否含有数字
            if self.str_clude_num():   # 因为要调用str_clude_num函数，而此函数在类里，所以前面加self
                self.password_strenth += 1
            else:
                print('密码要求包含数字！')
    
            # 规则三：判断密码字符串是否含有字母
            if self.str_clude_alpha():  # 这里不需要传入参数 
                self.password_strenth += 1
            else:
                print('密码要求包含字母！')
    
        def str_clude_num(self):
    
            """
                判断字符串中是否含有数字，通过子字符串的遍历，每个子字符串是否只由数字组成
            """
            have_num = False
    
            for i in self.password_str:
                if i.isnumeric():
                    have_num = True
                    break
    
            return have_num
    
        def str_clude_alpha(self):
            """
                    判断字符串中是否含有字母，通过子字符串的遍历，每个子字符串是否只由字母组成
            """
            have_alpha = False
    
            for c in self.password_str:
                if c.isalpha():
                    have_alpha = True
                    break
    
            return have_alpha
    
    
    def main():
    
        """
            主函数
        """
    
        try_times = 3  # 最多尝试5次
        while try_times > 0:
    
            password_str = input('请输入您的密码：')
    
            # 调用类
            password_tool = passwordtool(password_str)   # 执行类的初始化
            password_tool.process_passward()  # 判断密码是否合格，执行类的方法
    
            # 判断密码强度如何
            if password_tool.password_strenth <3:
                password_strenth_level = '密码强度较弱'
            else:
                password_strenth_level = '密码强度较强'
    
            # 打开/没有的话新建一个文件，写，关闭
            # 这段代码如果放在 （print()）之后，则输入正确代码后会执行break，直接跳出循环，不执行后续语句，因此要放在break前面
            f = open('D:\software\pycharm\lect06\password_5.0.txt', 'a')
            f.write(password_str + '\n')                                                     # 每次循环都要换行
            f.write('密码：{},密码强度等级:{}\n'.format(password_str, password_strenth_level))   # 格式化字符串
            f.close()
    
            # 密码强度是否合格
            if password_tool.password_strenth == 3:
                print('恭喜！密码强度合格！')
                break
            else:
                print('密码强度不合格！')
                try_times -= 1
    
            print()
    
            if try_times <= 0:
                print('尝试次数过多！')
    
    
    if __name__ == '__main__':
        main()

### 6.0 (面向对象编程的特点：封装、继承、多态) ###

"""
        作者：FLY
        版本：6.0
        日期：17/05/02019
        1.0：密码长度至少8位
             密码含有数字
             密码含有字母
    
        2.0：限制密码设置次数；循环的终止
        3.0：保存设置的密码及其对应的强度到文件中
        4.0: 读取保存的密码
        5.0：定义一个passward工具类
        6.0：将文件操作封装到一个类中
    
         字符串判断：
             长度判断：len()
             str.isnumeric() 检测字符串是否只由数字组成
             str.isalpha() 检测字符串是否只由字母组成
             str.islower() 检测字符串中所有的字母是否都为小写
             str.isupper() 检测字符串中所有的字母是否都为大写
    
            同样，字符串和子字符串都符合这一规律
    
        打开文件：open(filename,mode)
            filename:文件名（包括路径）  mode: 打开模式
            mode：
                r  - 只读，文件不存在时报错
                w  - 只写，文件不存在时自动创建
                a  - 在文件末尾添加，不覆盖
                r+ - 读写
    
        写入文件：从计算机内存向文件写入数据
            write() - 将字符串写入文件中
            writelines() - 将字符串列表写入文件中
    
        关闭文件：终止程序与文件的关联
            close()
    
        读取操作：从文件中读取数据到计算机内存中
            read()：返回值为包含整个文件内容的一个字符串
            readline()：返回值为文件一行的一个字符串
            readlines()：返回值为整个文件内容的列表，每个元素是以换行符为结尾的一行字符串
    
        eg:
            f = open('password.txt')
    
            read()函数
            content = f.read()
            print(content)
    
            readline()函数:一行一行读，需反复调用
            line_1 = f.readline()
            print(line_1)
            line_2 = f.readline()
            print(line_2)
    
            readlines()函数
            content = f.readlines()
            print(content)
    
            for line in f.readlines():   # 或者for line in f：
                print('read:{}'.format(line))
    
            f.close()
    
        类的定义:
            __init__(self):初始化对象的各属性
    """
    
    
    class passwordtool:
        """
            定义类
        """
        # 类的属性（类的初始化)
        def __init__(self, password_str):
            self.password_str = password_str
            self.password_strenth = 0
    
        # 类的方法
        def judge_passward_strenth_level(self):
            """
                判断密码强度等级
            """
            # 判断密码强度如何
            if self.password_strenth < 3:
                password_strenth_level = '密码强度较弱'
            else:
                password_strenth_level = '密码强度较强'
            return password_strenth_level
    
        def process_passward(self):
            """
                判断密码是否符合三个规则，加1操作
            """
            # 规则一：判断密码长度
            if len(self.password_str) >= 8:
                self.password_strenth += 1
            else:
                print('密码要求至少8位！')
    
            # 规则二：判断密码字符串是否含有数字
            if self.str_clude_num():   # 因为要调用str_clude_num函数，而此函数在类里，所以前面加self
                self.password_strenth += 1
            else:
                print('密码要求包含数字！')
    
            # 规则三：判断密码字符串是否含有字母
            if self.str_clude_alpha():  # 这里不需要传入参数
                self.password_strenth += 1
            else:
                print('密码要求包含字母！')
    
        def str_clude_num(self):
    
            """
                判断字符串中是否含有数字，通过子字符串的遍历，每个子字符串是否只由数字组成
            """
            have_num = False
    
            for i in self.password_str:
                if i.isnumeric():
                    have_num = True
                    break
    
            return have_num
    
        def str_clude_alpha(self):
            """
                    判断字符串中是否含有字母，通过子字符串的遍历，每个子字符串是否只由字母组成
            """
            have_alpha = False
    
            for c in self.password_str:
                if c.isalpha():
                    have_alpha = True
                    break
    
            return have_alpha
    
    
    class filetool:
    
        def __init__(self, filepath):
            self.filepath = filepath
    
        def write_to_file(self, line):
            f = open(self.filepath,'a')
            f.write(line)
            f.close()
    
        def read_from_file(self):
            f = open(self.filepath)
            # content = f.readlines()
            # return content
    
            for line in f.readlines():
                print('read:{}'.format(line))
    
            f.close()
    
    
    def main():
    
        """
            主函数
        """
        filepath = 'D:\software\pycharm\lect06\password_6.0.txt'
    
        try_times = 3  # 最多尝试3次
        
        # 实例化文件工具类
        file_tool = filetool(filepath)
        
        while try_times > 0:
    
            password_str = input('请输入您的密码：')
    
            # 调用类
            password_tool = passwordtool(password_str)   # 执行类的初始化
            password_tool.process_passward()  # 判断密码是否合格，执行类的方法
    
            # 写文件
            strenth_level = password_tool.judge_passward_strenth_level()  # 判断密码强度
            line = '密码：{},密码强度等级:{}\n'.format(password_str, strenth_level)
            file_tool.write_to_file(line)
    
            # 密码强度是否合格
            if password_tool.password_strenth == 3:
                print('恭喜！密码强度合格！')
                break
            else:
                print('密码强度不合格！')
                try_times -= 1
    
            print()
    
        # 放在循环外面，可以在循环终止后给用户不能再输入密码的原因
        if try_times <= 0:
            print('尝试次数过多！')
    
        # 所有循环结束后再读取
        # 读文件
        file_tool.read_from_file()
    
    
    if __name__ == '__main__':
        main()

## 模拟掷骰子 ##

### 1.0（random模块） ###

"""
        作者：FLY
        功能：模拟掷骰子,一个筛子投10次后，每个点数出现的次数和频率
        版本：1.0
        日期：05/18/2019
    
        随机事件：random 模块
            常用函数：
                random()          生成0~1的随机浮点数
                uniform(a,b)      生成a~b的随机浮点数
                randint(a,b)      生成a~b的随机整数
                choice(<list>)    从列表中随机返回一个元素
                shuffle(<list>)   将列表中元素随机打乱
                sample(<list>,k)  从列表中随机获取k个元素
                
        遍历列表时，同时获取每个元素的索引号和元素值
            enumerate()
            一般用于for循环中
    """
    import random
    
    
    def rool_dice():
        """
           输出骰子6个点的随机整数
        """
        rool = random.randint(1, 6)  # 限定数字范围
        return rool
    
    
    def main():
        """
            主函数
        """
        # 投骰子总次数
        total_times = 10000
    
        # 初始化列表，每个点出现的次数
        # result_list = [0, 0, 0, 0, 0, 0]
        result_list = [0]*6
    
        for i in range(total_times):
            rool = rool_dice()
            for j in range(1, 7):
                if rool == j:
                    result_list[j-1] += 1
        print(result_list)
    
        for i, result in enumerate(result_list):  # 遍历列表时，同时获取每个元素的索引号和元素值
            print('点数{}的次数：{}, 频率{}'.format(i+1, result, result / total_times))
    
    
    if __name__ == '__main__':
        main()

### 2.0（zip()函数的使用 ，复习字典的使用） ###

"""
        作者：FLY
        功能：模拟掷1个骰子,一个筛子投10次后，每个点数出现的次数和频率
        2.0：模拟投掷2个骰子
        版本：2.0
        日期：05/18/2019
    
        随机事件：random 模块
            常用函数：
                random()          生成0~1的随机浮点数
                uniform(a,b)      生成a~b的随机浮点数
                randint(a,b)      生成a~b的随机整数
                choice(<list>)    从列表中随机返回一个元素
                shuffle(<list>)   将列表中元素随机打乱
                sample(<list>,k)  从列表中随机获取k个元素
    
        遍历列表时，同时获取每个元素的索引号和元素值
            enumerate() 一般用于for循环中
            格式：for i, x in enumerate(list):
                i 索引号，从0开始
                x 元素值
                list 列表
            eg:
                list = [1,2,3]
                for i,x in enumerate(list):
                print(i,x)
                输出：
                    0 1
                    1 2
                    2 3
    
        遍历字典所有项：
            for item in d.items():
                print(items)
    
            eg: d = {'a':1,'b':2}
                for item in d.items():
                    print(item)
                输出：
                ('a', 1)
                ('b', 2)
    
    
        zip函数：将对应的元素打包成一个个元祖
            l1 = ['1','2']
            l2 = [1,2]
            zip(l1,l2)
    
            元祖中元素不可更改，如若更改，需转换成字典或其他
            dict(zip(l1,l2))    # {'1': 1, '2': 2}
    """
    import random
    
    
    def roll_dice():
        """
           输出一个骰子6个点的随机整数
        """
        roll = random.randint(1, 6)  # 限定数字范围
        return roll
    
    
    def main():
        """
            主函数
        """
        # 投骰子总次数
        total_times = 10000
    
        # 初始化列表
        result_list = [0]*11   # 每次投两个筛子的点数和:2，3,4...12 .共11个
    
        # 生成索引号，从2到12
        roll_index = list(range(2, 13))
    
        # 索引号与对应初始化的值一一对应，并呈字典格式（方便后续更改字典值）
        roll_dict = dict(zip(roll_index, result_list))
    
        for i in range(total_times):
            roll1 = roll_dice()  # 第一个骰子
            roll2 = roll_dice()  # 第二个骰子
            
            for j in range(2, 13):
                if (roll1 + roll2) == j:
                    roll_dict[j] += 1   # 字典索引加1
    
        for i, result in roll_dict.items():  # 字典的遍历
            print('点数{}的次数：{}, 频率{}'.format(i, result, result / total_times))
    
    
    if __name__ == '__main__':
        main()

### 3.0（Python绘图库matplotlib，散点图的简单绘制） ###

"""
        作者：FLY
        功能：模拟掷1个骰子,一个筛子投10次后，每个点数出现的次数和频率
        2.0：模拟投掷2个骰子，他们点数和的次数和频率
        3.0: 可视化投掷2个骰子的结果
        版本：3.0
        日期：05/19/2019
    
        随机事件：random 模块
            常用函数：
                random()          生成0~1的随机浮点数
                uniform(a,b)      生成a~b的随机浮点数
                randint(a,b)      生成a~b的随机整数
                choice(<list>)    从列表中随机返回一个元素
                shuffle(<list>)   将列表中元素随机打乱
                sample(<list>,k)  从列表中随机获取k个元素
    
        遍历列表时，同时获取每个元素的索引号和元素值
            enumerate() 一般用于for循环中
            格式：for i, x in enumerate(list):
                i 索引号，从0开始
                x 元素值
                list 列表
            eg:
                list = [1,2,3]
                for i,x in enumerate(list):
                print(i,x)
                输出：
                    0 1
                    1 2
                    2 3
    
        遍历字典所有项：
            for item in d.items():
                print(items)
    
            eg: d = {'a':1,'b':2}
                for item in d.items():
                    print(item)
                输出：
                ('a', 1)
                ('b', 2)
    
    
        zip函数：将对应的元素打包成一个个元祖
            l1 = ['1','2']
            l2 = [1,2]
            zip(l1,l2)
    
            元祖中元素不可更改，如若更改，需转换成字典或其他
            dict(zip(l1,l2))    # {'1': 1, '2': 2}
    
        列表相乘：
            ['0']*5 == ['0', '0', '0', '0', '0']
            ['0'*5] == ['00000']
    
        数据可视化：
            matplotlib是一个数据可视化函数库
            它的子模块pyplot提供了2D图表制作的基本函数
    
            eg:散点图绘制
                import matplotlib.pyplot as plt
                # x, y 分别是横坐标和纵坐标
                plt.scatter(x,y)
                plt.show()
    """
    import random
    import matplotlib.pyplot as plt
    
    
    def roll_dice():
        """
           输出一个骰子6个点的随机整数
        """
        roll = random.randint(1, 6)  # 限定数字范围
        return roll
    
    
    def main():
        """
            主函数
        """
        # 投骰子总次数
        total_times = 5
    
        # 初始化列表
        result_list = [0]*11   # 每次投两个筛子的点数和:2，3,4...12 .共11个
    
        # 生成索引号，从2到12
        roll_index = list(range(2, 13))
    
        # 索引号与对应初始化的值一一对应，并呈字典格式（方便后续更改字典值）
        roll_dict = dict(zip(roll_index, result_list))
    
        # 记录骰子的结果，初始化
        roll1_list = []
        roll2_list = []
    
        for i in range(total_times):
            roll1 = roll_dice()  # 第一个骰子
            roll2 = roll_dice()  # 第二个骰子
    
            # 两个骰子的记录
            roll1_list.append(roll1)
            roll2_list.append(roll2)
    
            for j in range(2, 13):
                if (roll1 + roll2) == j:
                    roll_dict[j] += 1   # 字典索引加1
    
        for i, result in roll_dict.items():  # 字典的遍历
            print('点数{}的次数：{}, 频率{}'.format(i, result, result / total_times))
    
        # 数据可视化
        # 横坐标是次数，纵坐标是出现的点数
        x = range(1, total_times+1)  # 次数
        plt.scatter(x, roll1_list, c='red', alpha='0.5')  # 散点图，颜色，透明度
        plt.scatter(x, roll2_list, c='blue', alpha='0.5')
        plt.show()
    
    
    if __name__ == '__main__':
        main()

### 4.0（简单的数据分析，matplotlib绘制直方图） ###

"""
        作者：FLY
        功能：模拟掷1个骰子,一个筛子投10次后，每个点数出现的次数和频率
        2.0：模拟投掷2个骰子，他们点数和的次数和频率
        3.0: 可视化投掷2个骰子的结果
        4.0：直方图可视化结果
        版本：4.0
        日期：05/19/2019
    
        随机事件：random 模块
            常用函数：
                random()          生成0~1的随机浮点数
                uniform(a,b)      生成a~b的随机浮点数
                randint(a,b)      生成a~b的随机整数
                choice(<list>)    从列表中随机返回一个元素
                shuffle(<list>)   将列表中元素随机打乱
                sample(<list>,k)  从列表中随机获取k个元素
    
        遍历列表时，同时获取每个元素的索引号和元素值
            enumerate() 一般用于for循环中
            格式：for i, x in enumerate(list):
                i 索引号，从0开始
                x 元素值
                list 列表
            eg:
                list = [1,2,3]
                for i,x in enumerate(list):
                print(i,x)
                输出：
                    0 1
                    1 2
                    2 3
    
        遍历字典所有项：
            for item in d.items():
                print(items)
    
            eg: d = {'a':1,'b':2}
                for item in d.items():
                    print(item)
                输出：
                ('a', 1)
                ('b', 2)
    
    
        zip函数：将对应的元素打包成一个个元祖
            l1 = ['1','2']
            l2 = [1,2]
            zip(l1,l2)
    
            元祖中元素不可更改，如若更改，需转换成字典或其他
            dict(zip(l1,l2))    # {'1': 1, '2': 2}
    
        列表相乘：
            ['0']*5 == ['0', '0', '0', '0', '0']
            ['0'*5] == ['00000']
    
        数据可视化：
            matplotlib是一个数据可视化函数库
            它的子模块pyplot提供了2D图表制作的基本函数
    
            散点图绘制
                import matplotlib.pyplot as plt
                # x, y 分别是横坐标和纵坐标
                plt.scatter(x,y)
                plt.show()
            直方图绘制
                import matplotlib.pyplot as plt
                # data 数据列表, bins分组边界
                plt.hist(data,bins)
                plt.show()
                
        解决中文显示问题
            plt.rcParams['font.sans-serif'] = ['SimHei']
            plt.rcParams['axes.unicode_minus'] = False
    """
    import random
    import matplotlib.pyplot as plt
    
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    
    def roll_dice():
        """
           输出一个骰子6个点的随机整数
        """
        roll = random.randint(1, 6)  # 限定数字范围
        return roll
    
    
    def main():
        """
            主函数
        """
        # 投骰子总次数
        total_times = 1000
    
        # 记录骰子的结果，初始化
        roll_list = []
    
        for i in range(total_times):
            roll1 = roll_dice()  # 第一个骰子
            roll2 = roll_dice()  # 第二个骰子
    
            roll_list.append(roll1 + roll2)  # 两个骰子的点数之和
    
        # 数据直方图可视化
        # 从2到12,。2~3，3~4...12~13
        # plt.hist(roll_list, bins=range(2, 14), edgecolor='black', linewidth='1') # x轴：bins  y轴：每个边界出现的次数
        plt.hist(roll_list, bins=range(2, 14), normed=1, edgecolor='black', linewidth='1')   # y轴：每个边界出现的次数进行归一化
        plt.title('骰子点数统计')
        plt.xlabel('点数')
        plt.ylabel('归一化频率')
        plt.show()
    
    
    if __name__ == '__main__':
        main()

### 5.0（科学计算库NumPy，NumPy中的向量化操作，使用NumPy进行简单的数据分析） ###

"""
        作者：FLY
        功能：模拟掷1个骰子,一个筛子投10次后，每个点数出现的次数和频率
        2.0：模拟投掷2个骰子，他们点数和的次数和频率
        3.0: 可视化投掷2个骰子的结果
        4.0：直方图可视化结果
        5.0：使用科学计算库简化程序，完善数据可视化结果
    
        版本：5.0
        日期：05/19/2019
    
        随机事件：random 模块
            常用函数：
                random()          生成0~1的随机浮点数
                uniform(a,b)      生成a~b的随机浮点数
                randint(a,b)      生成a~b的随机整数
                choice(<list>)    从列表中随机返回一个元素
                shuffle(<list>)   将列表中元素随机打乱
                sample(<list>,k)  从列表中随机获取k个元素
    
        遍历列表时，同时获取每个元素的索引号和元素值
            enumerate() 一般用于for循环中
            格式：for i, x in enumerate(list):
                i 索引号，从0开始
                x 元素值
                list 列表
            eg:
                list = [1,2,3]
                for i,x in enumerate(list):
                print(i,x)
                输出：
                    0 1
                    1 2
                    2 3
    
        遍历字典所有项：
            for item in d.items():
                print(items)
    
            eg: d = {'a':1,'b':2}
                for item in d.items():
                    print(item)
                输出：
                ('a', 1)
                ('b', 2)
    
    
        zip函数：将对应的元素打包成一个个元祖
            l1 = ['1','2']
            l2 = [1,2]
            zip(l1,l2)
    
            元祖中元素不可更改，如若更改，需转换成字典或其他
            dict(zip(l1,l2))    # {'1': 1, '2': 2}
    
        列表相乘：
            ['0']*5 == ['0', '0', '0', '0', '0']
            ['0'*5] == ['00000']
        numpy
            创建数组：
                import numpy as np
                np.array(<list>) # 列表转数组
                np.arange()      # 指定范围数组
                np.random.randint(a,b,size)  # 创建[a,b)间形状为size的随机整数数组
            eg:
                np.arange(2, 5)
                输出：
                    array([2, 3, 4])
    
        数据可视化：
            matplotlib是一个数据可视化函数库
            它的子模块pyplot提供了2D图表制作的基本函数
    
            散点图绘制
                import matplotlib.pyplot as plt
                # x, y 分别是横坐标和纵坐标
                plt.scatter(x,y)
                plt.show()
            直方图绘制
                import matplotlib.pyplot as plt
                # data 数据列表, bins分组边界
                plt.hist(data,bins)
                plt.show()
    
        解决中文显示问题
            plt.rcParams['font.sans-serif'] = ['SimHei']
            plt.rcParams['axes.unicode_minus'] = False
    """
    import random
    import matplotlib.pyplot as plt
    import numpy as np
    
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    
    def main():
        """
            主函数
        """
        # 投骰子总次数
        total_times = 1000
    
        # 生成范围为从1到6，total_times个数
        roll1_array = np.random.randint(1, 7, size=total_times)  # 第一个骰子
        roll2_array = np.random.randint(1, 7, size=total_times)  # 第二个骰子
        roll_array = roll1_array + roll2_array   # 两个骰子的点数之和
    
        # 引用np的直方图函数，返回bins和对应出现的次数
        hist, bins = np.histogram(roll_array, bins=range(2, 14))
        print(hist)
        print(bins)
    
        # 数据直方图可视化
    
        # x轴：bins  y轴：每个边界出现的次数
        # plt.hist(roll_array, bins=range(2, 14), edgecolor='black', linewidth='1') # 从2到12,。2~3，3~4...12~13，所以是range(2, 14)
    
        # y轴：每个bin出现的次数进行归一化(每个bin出现的次数/总次数)
        plt.hist(roll_array, bins=range(2, 14), normed=1, edgecolor='black', linewidth='1', rwidth=0.8)  # rwidth直方图宽度
    
        # 设置x轴坐标点显示
        tick_label = ['2点', '3点', '4点', '5点',
                      '6点', '7点', '8点', '9点',
                      '10点', '11点', '12点']
        tick_loca = np.arange(2, 13)+0.5   # 用np.arange的原因是它可以实现数组对应相加，而range不能
        plt.xticks(tick_loca, tick_label)
    
        plt.title('骰子点数统计')
        plt.xlabel('点数')
        plt.ylabel('归一化频率')
        plt.show()
    
    
    if __name__ == '__main__':
        main()

## 空气质量指数(AQI)计算及分析 ##

### 1.0（复习分支结构、函数及异常处理） ###

"""
        作者：FLY
        功能：AQI空气质量计算
        版本：1.0
        日期：05/20/2019
    """
    
    
    def cal_linear(iaqi_lo, iaqi_hi, bp_lo, bp_hi, cp):
        """
            范围缩放
        """
        iaqi = (iaqi_hi - iaqi_lo) * (cp - bp_lo) / (bp_hi - bp_lo) + iaqi_lo
    
        return iaqi
    
    
    def cal_pm_iaqi(pm_val):
        """
            计算pm2.5的IAQI
        """
        if 0<= pm_val < 35:
            iaqi = cal_linear(0, 50, 0, 35, pm_val)
    
        if 36<= pm_val < 76:
            iaqi = cal_linear(50, 100, 35, 75, pm_val)
    
        elif 76 <= pm_val < 116:
            iaqi = cal_linear(100, 150, 75, 115, pm_val)
    
        else:
            pass
    
        return iaqi
    
    
    def cal_co_iaqi(co_val):
        """
            计算一氧化碳的IAQI
        """
        if 0 <= co_val < 3:
            iaqi = cal_linear(0, 50, 0, 3, co_val)
    
        elif 3 <= co_val < 5:
            iaqi = cal_linear(50, 100, 2, 4, co_val)
    
        else:
            pass
    
        return iaqi
    
    
    def cal_aqi(param_list):
        """
            AQI计算
        """
        pm_val = param_list[0]
        co_val = param_list[1]
    
        # 分别计算pm2.5和一氧化碳的IAQI
        pm_iaqi = cal_pm_iaqi(pm_val)
        co_iaqi = cal_co_iaqi(co_val)
    
        return max(pm_iaqi, co_iaqi)
    
    
    def main():
        """
            主函数
        """
        print('请输入以下信息，用空格分隔')
        input_str = input('(1).PM2.5 (2).CO:')
        str_list = input_str.split(' ')  # 将字符串以空格分隔
        pm_val = float(str_list[0])
        co_val = float(str_list[1])
    
        # 往列表中添加两个元素
        param_list = []
        param_list.append(pm_val)
        param_list.append(co_val)
    
        # 调用AQI计算函数
        aqi_val = cal_aqi(param_list)
        print('空气质量指数为：{}'.format(aqi_val))
    
    
    if __name__ == '__main__':
        main()

### 2.0（JSON文件格式及操作） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]

"""
        作者：FLY
        功能：AQI空气质量计算
    
        版本：2.0
        日期：05/20/2019
    
        JSON库：处理JSON格式的python标准库
            两个过程：
                编码encoding,将python数据类型转换成JSON格式的过程
                解码decoding，从JSON格式中解析数据对应到python数据类型的过程
            函数：
                字符串：
                    dumps() ：将python数据类型转换为JSON格式
                    loads()：将JSON格式字符串转换为python数据类型
                文件：
                    dump()：与dumps()功能一致，输出到文件
                    load(): 与loads()一致，将JSON格式文件转换为python数据类型
    
        list.sort(func)
            fun指定了排序的方法
            func可以通过lamda函数实现
    
    """
    
    import json
    
    
    def process_json_file(filepath):
        f = open(filepath, mode='r', encoding='utf-8',)
        city_list = json.load(f)  # 将json格式字符串转换为python数据类型
        return city_list
    
    
    def main():
        """
            主函数
        """
        filepath = input('请输入json文件名称：')
        city_list = process_json_file(filepath)
        city_list.sort(key=lambda x: x['aqi'])  # 按照元素的aqi进行从小到大排序
        top5_list = city_list[: 5]  # 输出前5个
        print(city_list)
    
        # 写入前5个
        # 写入的json文件是呈一行显示，如果让它多行显示，Google：json formatter
        f = open('top5_aqi.json', mode='w', encoding='utf-8')  # 文件名，模式，编码
        json.dump(top5_list, f, ensure_ascii=False)  # ensure_ascii=False 确保中文写入不会出现乱码
        f.close()
    
    
    if __name__ == '__main__':
        main()

### 3.0（CSV文件格式及写操作，理解JSON与CSV的关联及差别） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]

"""
        作者：FLY
        功能：AQI空气质量计算
    
        版本：3.0
        日期：05/20/2019
    
    """
    
    import json
    import csv
    
    
    def process_json_file(filepath):
        """
            解码json文件
        """
        f = open(filepath, mode='r', encoding='utf-8',)
        city_list = json.load(f)  # 将json格式字符串转换为python数据类型
        return city_list
    
    
    def main():
        """
            主函数
        """
        filepath = input('请输入json文件名称：')
        city_list = process_json_file(filepath)
        city_list.sort(key=lambda x: x['aqi'])  # 按照元素的aqi进行从小到大排序
    
        lines = []
        # city_list的第一个对象的所有key放到一个list中
        lines.append(list(city_list[0].keys()))
    
        for x in city_list:
            lines.append(list(x.values()))
    
        f = open('aqi.csv', 'w', encoding='utf-8', newline='')  # newline=''作用是每个新行不加任何字符
        writer = csv.writer(f)
        for line in lines:
            writer.writerow(line)
        f.close()
    
    
    if __name__ == '__main__':
        main()

### 4.0（CSV文件的读操作，os模块） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]

"""
        作者：FLY
        功能：AQI空气质量计算
        2.0：json.load(f)读json文件
            使用lamda函数对文件进行排序sort
            使用json.dump 写入排序后的json文件
        3.0：将json文件写入csv文件
        4.0： 用with打开文件，csv.reader(f)读csv文件
        版本：4.0
        日期：05/20/2019
    
        JSON库：处理JSON格式的python标准库
            两个过程：
                编码encoding,将python数据类型转换成JSON格式的过程
                解码decoding，从JSON格式中解析数据对应到python数据类型的过程
            函数：
                字符串：
                    dumps() ：将python数据类型转换为JSON格式
                    loads()：将JSON格式字符串转换为python数据类型
                文件：
                    dump()：与dumps()功能一致，输出到文件
                    load(): 与loads()一致，将JSON格式文件转换为python数据类型
    
        list.sort(func)
            fun指定了排序的方法
            func可以通过lamda函数实现
            city_list.sort(key=lambda x: x['aqi'])  # 按照元素的aqi进行从小到大排序
    
        json 写入：
                f = open('top5_aqi.json', mode='w', encoding='utf-8')  # 文件名，模式，编码
                json.dump(top5_list, f, ensure_ascii=False)  # ensure_ascii=False 确保中文写入不会出现乱码
                f.close()
    
            读入：
                f = open(filepath, mode='r', encoding='utf-8',)
                city_list = json.load(f)  # 将json格式字符串转换为python数据类型
    
        csv 写入：
                法1：
                    f = open('aqi.csv', 'w', encoding='utf-8', newline='')  # newline=''作用是每个新行不加任何字符
                    writer = csv.writer(f)
                    for line in lines:
                        writer.writerow(line)
                    f.close()
                法2：
                    import pandas as pd
                    top10_citys.to_csv('top10_citys', index=False)
            读入：
                法1：
                    with open(filepath, mode='r', encoding='utf-8', newline='') as f:
                        reader = csv.reader(f)  # 将每行记录作为列表返回
                        for row in reader:
                            print(row)
                            print(','.join(row))  # 将['aqi', 'area']列表准换成整体字符串，以逗号隔开 aqi,area
                法2：
                    使用pandas 读取csv文件：
                    import pandas as pd
                    aqi_data = pd.read_csv('china_city_aqi.csv')
    
    """
    
    import json
    import csv
    import os
    
    
    def process_json_file(filepath):
        """
            读json文件
        """
        # f = open(filepath, mode='r', encoding='utf-8')
        # city_list = json.load(f)  # 将json格式字符串转换为python数据类型
        # return city_list
    
        # 用with的好处是不需要close文件，with模块外自动释放空间
        with open(filepath, mode='r', encoding='utf-8') as f:
            city_list = json.load(f)
        print(city_list)
    
    
    def process_csv_file(filepath):
        """
            读csv文件
        """
        with open(filepath, mode='r', encoding='utf-8', newline='') as f:
            reader = csv.reader(f)  # 将每行记录作为列表返回
            for row in reader:
                print(row)
                print(','.join(row))  # 将['aqi', 'area']列表准换成整体字符串，以逗号隔开 aqi,area
    
    
    def main():
        """
            主函数
        """
        filepath = input('请输入文件名称：')
        filname, filetxt = os.path.splitext(filepath)  # 将文件分割成文件名与扩展名
    
        if filetxt == '.json':
            # 处理json文件
            process_json_file(filepath)
    
        elif filetxt == '.csv':
            # 处理csv文件
            process_csv_file(filepath)
        else:
            print('暂不支持该文件格式！')
    
    
    if __name__ == '__main__':
        main()

### 5.0（什么是网络爬虫，request库） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 4]  
更多方法参考：[http://docs.python-requests.org/][http_docs.python-requests.org]

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        版本：5.0
        日期：05/21/2019
    """
    import requests
    
    
    def get_html_txt(url):
        """
            返回url文本
        """
        r = requests.get(url)  # 网页请求
        # print(r.status_code)   # HTTP的返回状态，200成功，400失败
        return r.text          # 返回HTTP的页面内容，字符串形式
    
    
    def main():
        """
            主函数
        """
        city_pinyin = input('请输入城市拼音：')
        url = 'http://pm25.in/' + city_pinyin
        url_txt = get_html_txt(url)
    
        # 获取59所在的div子字符串
        aqi_div = '''<div class="span12 data">
            <div class="span1">
              <div class="value">
                '''  # 注意前面是有空格字符串的
    
        # 找到子字符串在整体字符串的位置 find
        index = url_txt.find(aqi_div)
        begin_index = index + len(aqi_div)
        end_index = begin_index + 2  # 2是两个数字的长度
        aqi_value = url_txt[begin_index:end_index]
        print('空气质量输出：{}'.format(aqi_value))
    
    
    if __name__ == '__main__':
        main()

### 6.0（beautifulsoup库） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 8]

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        存在的弊端：不知道aqi是不是都是2位
                  aqi_div中的空格字符串问题
        6.0：输入拼音，返回AQI，解决上述弊端
        版本：:6.0
        日期：05/21/2019
    """
    import requests
    from bs4 import BeautifulSoup
    
    
    def get_city_aqi(city_pinyin):
        """
            获取城市的AQI
        """
        url = 'http://pm25.in/' + city_pinyin
        r = requests.get(url, timeout=30)  # 等待30秒，30秒无结果就不等了
        bs = BeautifulSoup(r.text, 'lxml')  # 创建BeautifulSoup对象，页面内容，指定解码器
        div_list = bs.find_all('div', {
        'class': 'span1'})  # 找到左右的div节点，指定条件：class = span1
    
        city_aqi = []
        for i in range(8):
            city_content = div_list[i]
            caption = city_content.find('div', {
        'class': 'caption'}).text.strip()  # 获取节点内的内容，strip()移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
            value = city_content.find('div', {
        'class': 'value'}).text.strip()
            city_aqi.append((caption, value))
    
        return city_aqi
    
    
    def main():
        """
            主函数
        """
        city_pinyin = input('请输入城市拼音：')
        city_aqi = get_city_aqi(city_pinyin)
    
        print('空气质量输出：{}'.format(city_aqi))
    
    
    if __name__ == '__main__':
        main()

### 7.0（巩固beautifulsoup库） ###

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        存在的弊端：不知道aqi是不是都是2位
                  aqi_div中的空格字符串问题
        6.0：输入拼音，返回AQI，解决上述弊端
        7.0：获取所有城市
        版本：:7.0
        日期：05/21/2019
    """
    import requests
    from bs4 import BeautifulSoup
    
    
    def get_city_aqi(city_pinyin):
        """
            获取城市的AQI
        """
        url = 'http://pm25.in/' + city_pinyin
        r = requests.get(url, timeout=30)  # 等待30秒，30秒无结果就不等了
        bs = BeautifulSoup(r.text, 'lxml')  # 创建BeautifulSoup对象，页面内容，指定解码器摸（一般是lxml），编码格式不指定默认是和网页编码格式一致
        div_list = bs.find_all('div', {
        'class': 'span1'})  # 找到左右的div节点，指定条件：class = span1
    
        city_aqi = []
        for i in range(8):
            city_content = div_list[i]
            caption = city_content.find('div', {
        'class': 'caption'}).text.strip()  # 获取节点内的内容，strip()移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
            value = city_content.find('div', {
        'class': 'value'}).text.strip()
            city_aqi.append((caption, value))
    
        return city_aqi
    
    
    def get_all_city():
        """
            获取所有城市的名称，拼音
        """
        city_list = []
        url = 'http://pm25.in/'
        r = requests.get(url, timeout=30)
        bs = BeautifulSoup(r.text, 'lxml')
        city_div = bs.find_all('div', {
        'class': 'bottom'})[1]  #有两个条件一样的div,取第二个
        city_a_div = city_div.find_all('a')
    
        for city in city_a_div:
            city_text_name = city.text
            city_pinyin = city['href'][1:]  # 拼音要取href的属性，前面有/，所有切片
            city_list.append((city_text_name, city_pinyin))
        return city_list
    
    
    def main():
        """
            主函数
        """
        city_list = get_all_city()
    
        for city in city_list:
            city_name = city[0]
            city_pinyin = city[1]
            city_aqi = get_city_aqi(city_pinyin)
    
            print(city_name, city_aqi)
    
    
    if __name__ == '__main__':
        main()

### 8.0（完整网络爬虫的编写与实现） ###

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        存在的弊端：不知道aqi是不是都是2位
                  aqi_div中的空格字符串问题
        6.0：输入拼音，返回AQI，解决上述弊端
        7.0：获取所有城市
        8.0：将获取所有城市的aqi保存成csv文件，写操作
        版本：:8.0
        日期：05/21/2019
    """
    import requests
    from bs4 import BeautifulSoup
    import csv
    
    def get_city_aqi(city_pinyin):
        """
            获取城市的AQI
        """
        url = 'http://pm25.in/' + city_pinyin
        r = requests.get(url, timeout=30)  # 等待30秒，30秒无结果就不等了
        bs = BeautifulSoup(r.text, 'lxml')  # 创建BeautifulSoup对象，页面内容，指定解码器摸（一般是lxml），编码格式不指定默认是和网页编码格式一致
        div_list = bs.find_all('div', {
        'class': 'span1'})  # 找到左右的div节点，指定条件：class = span1
    
        city_aqi = []
        for i in range(8):
            city_content = div_list[i]
            # caption = city_content.find('div', {'class': 'caption'}).text.strip()  # 获取节点内的内容，strip()移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
            value = city_content.find('div', {
        'class': 'value'}).text.strip()
            city_aqi.append(value)
    
        return city_aqi
    
    
    def get_all_city():
        """
            获取所有城市的名称，拼音
        """
        city_list = []
        url = 'http://pm25.in/'
        r = requests.get(url, timeout=30)
        bs = BeautifulSoup(r.text, 'lxml')
        city_div = bs.find_all('div', {
        'class': 'bottom'})[1]  #有两个条件一样的div,取第二个
        city_a_div = city_div.find_all('a')
    
        for city in city_a_div:
            city_text_name = city.text
            city_pinyin = city['href'][1:]  # 拼音要取href的属性，前面有/，所有切片
            city_list.append((city_text_name, city_pinyin))
        return city_list
    
    
    def main():
        """
            主函数
        """
        city_list = get_all_city()
    
        # csv的第一行
        header = ['City', 'AQI', 'PM2.5/1h', 'PM10/h', 'CO/1h', 'NO2/1h', 'O3/1h', 'O3/8h', 'SO2/1h']
        # csv 的写操作
        with open('china_city_aqi', 'w', encoding='utf-8', newline='') as f:
            writer = csv.writer(f)
            writer.writerow(header)  # 写入csv的第一行
    
            for i, city in enumerate(city_list):
                # 记录进度
                if (i+1) % 10 == 0:
                    print('已处理{}条记录，共{}条记录'.format(i+1, len(city_list)))
    
                city_name = city[0]    # 它是一个字符串
                city_pinyin = city[1]  # 它是一个字符串
                city_aqi = get_city_aqi(city_pinyin)  # 它是一个列表
                row = [city_name]+city_aqi
                writer.writerow(row)
    
    
    if __name__ == '__main__':
        main()

### 9.0（Pandas基础，利用Pandas进行数据处理及分析） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 18]

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        存在的弊端：不知道aqi是不是都是2位
                  aqi_div中的空格字符串问题
        6.0：输入拼音，返回AQI，解决上述弊端
        7.0：获取所有城市
        8.0：将获取所有城市的aqi保存成csv文件，写操作
        9.0: 利用pandas进行数据处理
    
        版本：:9.0
        日期：05/22/2019
    """
    import pandas as pd
    
    
    def main():
        """
            主函数
        """
        # 使用pandas 读取csv文件
        aqi_data = pd.read_csv('china_city_aqi.csv')
    
        print('基本信息预览：')  # object 表示字符串
        print(aqi_data.info())
    
        print('数据预览')
        print(aqi_data.head())  # 可以指定行数，也可以不指定
        # print(aqi_data['City'])  # 列索引
        # print(aqi_data[['City', 'AQI']])  # 不连续列索引，放在一个列表中
    
        # 基本统计
        print('AQI最大值', aqi_data['AQI'].max())
        print('AQI最小值', aqi_data['AQI'].min())
        print('AQI均值', aqi_data['AQI'].mean())
    
        # top10排序
        top10_citys = aqi_data.sort_values(by='AQI').head(10)
        print('空气质量最好的前10个城市')
        print(top10_citys)
    
        # bottom 10排序的两种方法
        bottom10_citys = aqi_data.sort_values(by='AQI', ascending=False).head(10)  # 升序为假
        # bottom10_citys = aqi_data.sort_values(by='AQI').tail(10)
    
        print('空气质量最差的前10个城市')
        print(bottom10_citys)
    
        # 保存csv文件
        top10_citys.to_csv('top10_citys', index=False) # 如果不想要索引，可以设置成False
        bottom10_citys.to_csv('bottom10_citys', index=False)
    
    
    if __name__ == '__main__':
        main()

### 10.0（数据清洗，利用Pandas进行数据可视化） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 19]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 20]

"""
        作者：FLY
        功能：AQI空气质量计算
        5.0: 通过网络链接获取网页内容，对获得的网页内容进行处理
        存在的弊端：不知道aqi是不是都是2位
                  aqi_div中的空格字符串问题
        6.0：输入拼音，返回AQI，解决上述弊端
        7.0：获取所有城市
        8.0：将获取所有城市的aqi保存成csv文件，写操作
        9.0: 利用pandas进行数据处理
        10.0：数据清洗，利用pandas进行数据可视化
    
        版本：:10.0
        日期：05/22/2019
    """
    import pandas as pd
    import matplotlib.pyplot as plt
    
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    
    def main():
        """
            主函数
        """
        # 使用pandas 读取csv文件
        aqi_data = pd.read_csv('china_city_aqi.csv')
    
        print('基本信息预览：')  # object 表示字符串
        print(aqi_data.info())
    
        print('数据预览')
        print(aqi_data.head())  # 可以指定行数，也可以不指定
        # print(aqi_data['City'])  # 列索引
        # print(aqi_data[['City', 'AQI']])  # 不连续列索引，放在一个列表中
    
        # 数据清洗，保留AQI>0的数据
        condition = aqi_data['AQI']>0
        clean_data = aqi_data[condition]
    
        # 基本统计
        print('AQI最大值', clean_data['AQI'].max())
        print('AQI最小值', clean_data['AQI'].min())
        print('AQI均值', clean_data['AQI'].mean())
    
        # top10排序
        top10_citys = clean_data.sort_values(by='AQI').head(10)
        top10_citys.plot(kind='bar', x='City', y='AQI', title='空气质量最好的50个城市',
                         figsize=(20, 10))
        plt.savefig('top10_citys.png')  # 先保存，再show
        plt.show()
    
    
    if __name__ == '__main__':
        main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]: /images/20220219/5b2965226f904378b747eca691573353.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]: /images/20220219/ad77fcb3783645d38c7c1efc6ed0df7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190520193340685.?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]: /images/20220219/d493b19df83e4c0dae365759502d0bdc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 4]: /images/20220219/0d23747b8f6a49638944842857ffde64.png
[http_docs.python-requests.org]: http://docs.python-requests.org/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 5]: /images/20220219/4b998e6caec14af0ac0136edd03225fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 6]: /images/20220219/ea09d62324aa41688a3104d966419b65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 7]: /images/20220219/3dfe300f42804e8a85db59692af5222d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 8]: /images/20220219/25e080cfc40a45e2bcada9a99f38675e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 9]: /images/20220219/37c45b4742f34f5f8511d5c8a87ae7f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 10]: /images/20220219/14e273e825734a60811e4d6bdf296669.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 11]: /images/20220219/4e887a34c3ad4b6994e65d0719b5b69b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 12]: /images/20220219/d3322fa0d63b4c2ca638c2db71899b75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 13]: /images/20220219/6fc09ca587fd4916a57a4a96888fe1b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 14]: /images/20220219/b02b4c767d0042c4aaae7d479f0f8127.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 15]: /images/20220219/f8986179b93744ae8ed2e8a6a4b762c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 16]: /images/20220219/5b17877f190341708f6f77ddf183372d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 17]: /images/20220219/158974401a994dafb265bc37d71caff0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 18]: /images/20220219/21d2b58692de48f2b519b517f57704ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 19]: /images/20220219/edb70c2ddd1a4faa97afe4738ed3bf81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 20]: /images/20220219/5bc06e11bb3246be8793c795476d78c0.png