数据分析实战第一节随笔

引言

Python，作为一种高级编程语言，以其简洁明了的语法和强大的功能库，赢得了全球开发者的广泛青睐。
它不仅适用于数据科学、机器学习、人工智能等领域，而且在Web开发、自动化脚本编写、科学计算等方面也发挥着重要作用。

实验工具

Python：查看Python版本：

打开命令面板，输入：python --version

Jupyter notebook：

命令面板，输入：jupyter notebook

随后自动跳转至jupyter notebook网页

Python基础：

基本语法：

Python的基本语法包括变量声明、数据类型、运算符和控制结构。例如：

变量声明

x=10

数据类型

y="Hello,Python!"

运算符

z=x+1

循环结构

if x>5:
print("x is greater than 5")

数据结构

Python内置了多种数据结构，如列表、字典、元组和集合，它们是处理复杂数据的重要工具。

函数

函数是组织代码的基本模块。在Python中定义函数非常简单：
eg：
def greet(name):
print(f"Hello, {name}!")
greet("World")

第一节数据分析实战

1.例题1：完数判断程序

eg:
def is_perfect_number(m):
factors = []
sum_of_factors = 0
# 找出所有的真因子
for i in range(1, m // 2 + 1):
if m % i == 0:
factors.append(i)
sum_of_factors += i
# 将真因子列表转换为字符串形式
factors_str = '+'.join(map(str, factors))
# 判断并输出结果
if sum_of_factors == m:
return f"{m} 是完数：{m}={factors_str}"
elif sum_of_factors < m:
return f"{m} 不是完数，真因子之和小于{m}: {m}>{factors_str}"
else:
return f"{m} 不是完数，真因子之和大于{m}: {m}<{factors_str}"
m = int(input("请输入一个正整数 m："))# 输入一个正整数 m
result = is_perfect_number(m)# 调用函数并打印结果
print(result)

2.例题2：素数判断程序

方法一

import math
def is_prime_optimized(m):
if m <= 1:
return False
if m <= 3:
return True
if m % 2 == 0 or m % 3 == 0:
return False
i = 5
while i * i <= m:
if m % i == 0 or m % (i + 2) == 0:
return False
i += 6
return True
m = int(input("请输入一个正整数 m："))# 输入一个正整数 m
if is_prime_optimized(m):# 判断并输出结果
print(f"{m} Yes")
else:
print(f"{m} No")

方法二

def is_prime_naive(m):
if m <= 1:
return False
for i in range(2, m):
if m % i == 0:
return False
return True
m = int(input("请输入一个正整数 m："))# 输入一个正整数 m
if is_prime_naive(m):# 判断并输出结果
print(f"{m} Yes")
else:
print(f"{m} No")

例题3：计算给定日期是该年的第几天

def day_of_year(year, month, day):
def is_leap_year(y):# 判断是否为闰年
return (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)
days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]# 各月的天数
if is_leap_year(year):# 调整闰年的2月天数
days_in_month[1] = 29
day_of_year = sum(days_in_month[:month-1]) + day# 计算该日期是该年的第几天
return day_of_year
year, month, day = map(int, input("请输入年 月 日：").split())# 输入年、月、日
print(day_of_year(year, month, day))

例题4：排序程序

方法一：冒泡排序

def bubble_sort(arr):
n = len(arr)
for i in range(n):#冒泡排序
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
input_data = list(map(int, input().split()))
print(" ".join(map(str, bubble_sort(input_data))))

方法二：插入排序

def insertion_sort(arr):
for i in range(1, len(arr)):#插入排序
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
input_data = list(map(int, input().split()))
print(" ".join(map(str, insertion_sort(input_data))))

方法三：

def quick_sort(arr):#快速排序
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
input_data = list(map(int, input().split()))
print(" ".join(map(str, quick_sort(input_data))))

5.例题5：求集合的交集

方法一：

def intersection_using_sets(arr1, arr2):# 转换为集合
set1 = set(arr1)
set2 = set(arr2)
intersection_set = set1 & set2# 计算交集
result = [x for x in arr2 if x in intersection_set]# 按照arr2中的顺序输出交集
return result
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
result = intersection_using_sets(arr1, arr2)
print(" ".join(map(str, result)))

方法二：

def intersection_using_dict(arr1, arr2):# 创建一个字典来记录arr1的元素
dict1 = {x: True for x in arr1}# 使用列表推导找到交集，保留arr2的顺序
result = [x for x in arr2 if x in dict1]
return result
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
result = intersection_using_dict(arr1, arr2)
print(" ".join(map(str, result)))

π的计算

1. 统计不同量级的抛点数对于π值计算精度的影响，列出表格，并统计运行时间。

import random
import time
def estimate_pi(num_points):
inside_circle = 0
for _ in range(num_points):
x = random.random()
y = random.random()
if xx + yy <= 1:
inside_circle += 1
return (inside_circle / num_points) * 4
point_counts = [100, 1000, 10000, 100000, 1000000]# 量级和运行时间统计
results = []
for num_points in point_counts:
start_time = time.time()
pi_estimate = estimate_pi(num_points)
end_time = time.time()
results.append((num_points, pi_estimate, end_time - start_time))
print("点数\t估算的π值\t运行时间")
for result in results:
print(f"{result[0]}\t{result[1]:.6f}\t{result[2]:.4f}秒")

2. 结合turtle模块，模拟抛点在1/4圆上的抛洒过程，圆内与圆外的点通过不同的颜色区分。

import turtle
import random
def draw_point(x, y, color):
turtle.penup()
turtle.goto(x * 200 - 100, y * 200 - 100)
turtle.pendown()
turtle.dot(5, color)
def simulate_points(num_points):
turtle.speed(0)
turtle.hideturtle()
turtle.bgcolor("white")
turtle.setworldcoordinates(-100, -100, 100, 100)
turtle.pensize(2)
turtle.penup()# Draw the quarter circle
turtle.goto(0, 0)
turtle.pendown()
turtle.circle(100, 90)
turtle.goto(0, 0)
for _ in range(num_points):
x = random.random()
y = random.random()
if xx + yy <= 1:
draw_point(x, y, "green") # Inside the circle
else:
draw_point(x, y, "red") # Outside the circle
turtle.done()
simulate_points(100)

3. 怎么才能让π计算的程序每次运行结果都一样？
   import random
def estimate_pi(num_points):
random.seed(25) # 固定随机数种子eg:25
inside_circle = 0
for _ in range(num_points):
x = random.random()
y = random.random()
if xx + yy <= 1:
inside_circle += 1
return (inside_circle / num_points) * 4
pi_estimate = estimate_pi(1000000)# 估算π值
print(f"Estimated π: {pi_estimate}")

文件和数据格式化

a.Python源文件改写。

编写一个程序，读取一个Python源程序文件，将文件中所有除保留字外的小写字母换成大写字母，生成后的文件要能够被Python解释器正确执行。

import keyword
import os
def convert_file(file_path):
if not os.path.exists(file_path):
print("文件不存在")
return
with open(file_path, "r", encoding="utf-8") as f:
original_lines = f.readlines()
print("修改前的文档内容：")
print("".join(original_lines))
new_lines = []
for line in original_lines:
new_line = ""
for word in line.split():
if keyword.iskeyword(word):
new_line += word + " "
else:
new_line += word.upper() + " "
new_lines.append(new_line.strip())
with open(file_path, "w", encoding="utf-8") as f:
f.write("\n".join(new_lines))
print("修改后的文档内容：")
print("".join(new_lines))
print("转换完成")
if name == "main":
file_path = input("请输入Python源文件路径：")
convert_file(file_path)

b.制作英文学习词典。

编写程序制作英文学习词典，词典有3个基本功能：添加、查询和退出。程序读取源文件路径下的txt格式词典文件，若没有就创建一个。词典文件存储方式为“英文单词 中文单词”，每行仅有一对中英释义。程序会根据用户的选择进入相应的功能模块，并显示相应的操作提示。当添加的单词已存在时，显示“该单词已添加到字典库”；当查询的单词不存在时，显示“字典库中未找到这个单词”，用户输入其他选项时，提示“输入有误”。

import os
def load_dictionary(file_path):
dictionary = {}
if os.path.exists(file_path):
with open(file_path, 'r', encoding='utf-8') as file:
for line in file:
if line.strip():
english, chinese = line.strip().split(' ', 1)
dictionary[english] = chinese
return dictionary
def save_dictionary(dictionary, file_path):
with open(file_path, 'w', encoding='utf-8') as file:
for english, chinese in dictionary.items():
file.write(f"{english} {chinese}\n")
def add_word(dictionary):
english = input("请输入英文单词：")
if english in dictionary:
print("该单词已添加到字典库")
else:
chinese = input("请输入中文释义：")
dictionary[english] = chinese
print("单词添加成功")
def query_word(dictionary):
english = input("请输入英文单词查询：")
if english in dictionary:
print(f"{english}: {dictionary[english]}")
else:
print("字典库中未找到这个单词")
def main():
file_path = 'dictionary.txt'
dictionary = load_dictionary(file_path)
while True:
print("1. 添加单词")
print("2. 查询单词")
print("3. 退出")
choice = input("请输入你的选择：")
if choice == '1':
add_word(dictionary)
save_dictionary(dictionary, file_path)
elif choice == '2':
query_word(dictionary)
elif choice == '3':
break
else:
print("输入有误")
if name == "main":
main()