文章目录
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文件格式及操作）
"""
作者：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的关联及差别）
"""
作者：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模块）
"""
作者：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库）
更多方法参考：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库）
"""
作者：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进行数据处理及分析）
"""
作者：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进行数据可视化）
"""
作者：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()
2792
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
