Python编程：从入门到实践

print("""Hello Python world!
Hello iTuring!""")

=>
Hello Python world!
Hello iTuring!

str = 'hello world'
print(str.title())
print(str)

=> Hello World
=> hello world

name = 'Eric'
str = f'Hello {name}, would you like to learn some Python today?'
print(str)
=> Hello Eric, would you like to learn some Python today?

name='张三'
year='龙'

message_content1 = '祝{0}，新春快乐，{1}年大吉'.format(name, year)
message_content2 = '祝{current_name}，新春快乐，{current_year}年大吉'.format(current_name = name, current_year = year)
message_content3 = '祝{name}，新春快乐，{year}年大吉'.format(name = name, year = year)

print(message_content1)
print(message_content2)
print(message_content3)

num = 98.7675
print(f'你的分数是{num: .2f}')
=> 98.77

url = 'https://www.ituring.com.cn'
url = url.removeprefix('https://')
print(url)

=> www.ituring.com.cn

file_name = 'python_notes.txt'
print(file_name.removesuffix('.txt'))
=>python_notes

print(0.1+0.2)
=>0.30000000000000004

print(4/2)
=> 2

print(4 // 3)
=> 1

print(4.0**2)
=> 16.0

print(9 % 2)
=> 1

print(1.5+1.5)
=> 3.0

print(1.5 // 1.5)
=> 1.0

print(1.5 - 1.5)
=> 0.0

universe_age = 14_000_000_000
print(universe_age)

=> 14000000000

x, y, z = 0, 0, 0

MAX_CONNECTIONS = 5000

type('hello')  =>  <class 'str'>
type(6)        =>  <class 'int'>
type(6.0)      =>  <class 'float'>
type(True)     =>  <class 'bool'>
type(None)     =>  <class 'NoneType'>
type([1,2])    =>  <class 'list'>

names = ['aaa', 'bbb', 'ccc']
print(names)
=> ['aaa', 'bbb', 'ccc']

# 每当需要访问最后一个列表元素时，都可以使用索引 -1
print(names[-1])
=> ccc

# 仅当列表为空时，这种访问最后一个元素的方式才会导致错误
names = []
print(names[-1])
=> 报错

names = ['aaa', 'bbb', 'ccc']
print(names)
=> ['aaa', 'bbb', 'ccc']

names.append('ddd')
print(names)
=> ['aaa', 'bbb', 'ccc', 'ddd']

names = ['aaa', 'bbb', 'ccc']
names.insert(0, 111)
print(names)
=> [111, 'aaa', 'bbb', 'ccc']

names = ['aaa', 'bbb', 'ccc']
del names[1]
print(names)
=> ['aaa', 'ccc']

names = ['aaa', 'bbb', 'ccc']
str = names.pop()
print(str)
=> ccc
print(names)
=> ['aaa', 'bbb']

names = ['aaa', 'bbb', 'ccc']
names.pop(1)
print(names)
=> ['aaa', 'ccc']

names = ['aaa', 'bbb', 'ccc']
str = names.remove('aaa')
print(str)
=> None
print(names)
=> ['bbb', 'ccc']

names.remove('ddd')
print(names)
=> 删除不存在的值会报错

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)
=> ['audi', 'bmw', 'subaru', 'toyota']

cars = ['bmw', 'audi', 'Toyota', 'subaru']
cars.sort()
print(cars)
=> ['Toyota', 'audi', 'bmw', 'subaru']

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse = True)
print(cars)
=> ['toyota', 'subaru', 'bmw', 'audi']

cars = ['bmw', 'audi', 'toyota', 'subaru']
new_cars = sorted(cars)
print(new_cars)
=> ['audi', 'bmw', 'subaru', 'toyota']
print(cars)
=> ['bmw', 'audi', 'toyota', 'subaru']

cars = ['bmw', 'audi', 'toyota', 'subaru']
new_cars = sorted(cars, reverse = True)
print(new_cars)
=> ['toyota', 'subaru', 'bmw', 'audi']

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.reverse()
print(cars)
=> ['subaru', 'toyota', 'audi', 'bmw']

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(len(cars))
=> 4

# 格式
for 变量名 in 可迭代对象:
  # 对每个变量做一些事情...

names = ['aaa', 'bbb', 'ccc']
for name in names:
  print(name)
  
=> 
aaa
bbb
ccc

# 打印1-4，不会打印5
for num in range(1, 5):
  print(num)
  
=>
1
2
3
4

for num in range(5):
  print(num)
=>
0
1
2
3
4

nums = list(range(1, 5))
print(nums)
=> [1, 2, 3, 4]

# 打印1-10以内的奇数
# 从1开始，不断加2
nums = list(range(1, 10, 2))
print(nums)
=> [1, 3, 5, 7, 9]

nums = []
for num in range(1, 11):
  nums.append(num ** 2)
print(nums)
=> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(min(digits))
print(max(digits))
print(sum(digits))
=>
0
9
45

nums = [value ** 2 for value in range(1, 10)]
print(nums)
=> [1, 4, 9, 16, 25, 36, 49, 64, 81]

players = ['charles', 'martina', 'michael', 'florence', 'eli']
# 打印第二、三名队员
print(players[1:3])
=> ['martina', 'michael']

# 如果没有指定第一个索引，Python 将自动从列表开头开始
# 打印前三名队员
print(players[:3])
=> ['charles', 'martina', 'michael']

# 要让切片终止于列表末尾，也可使用类似的语法
# 打印第二名开始到最后的队员
print(players[1:])
=> ['martina', 'michael', 'florence', 'eli']

# 负数索引返回与列表末尾有相应距离的元素，因此可以输出列表末尾的任意切片
# 打印最后三名队员
print(players[-3:])
=> ['michael', 'florence', 'eli']

# 可在表示切片的方括号内指定第三个值。这个值告诉 Python 在指定范围内每隔多少元素提取一个。
# 打印前四名中奇数名次的队员
print(players[:4:2])
=> ['charles', 'michael']

players = ['charles', 'martina', 'michael', 'florence', 'eli']
for player in players[:3]:
  print(player)
  
=> 
charles
martina
michael

foods = ['pizza', 'falafel', 'carrot cake']
# 复制列表
new_foods = foods[:]
print(new_foods)
=> ['pizza', 'falafel', 'carrot cake']

new_foods[0] = 'candy'
print(new_foods)
=> ['candy', 'falafel', 'carrot cake']

print(foods)
=> ['pizza', 'falafel', 'carrot cake']

dimensions = (200, 50)
print(dimensions[0])
=> 200

dimensions[1] = 100
=> 报错，元组元素不可修改

dimensions = (200, 100)
=> 不报错，可以给表示元组的变量赋值

# 如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号
my_t = (3,)

# 遍历元组元素
for dimension in dimensions:
  print(dimension)

# 格式（同样别忘了冒号和缩进！）
if 条件:
  执行语句
else:
  执行语句

# 格式
if 条件一:
  if 条件二:
    语句A
  else:
    语句B
else:
  语句C

# 格式
if 条件一:
  语句A
elif 条件二:
  语句B
elif 条件三:
  语句C
else:
  语句D

alien_color = ['red', 'yellow', 'blue']

for item in alien_color:
  if item == 'yellow':
    print('is yellow')
  elif item == 'red':
    print('is red')
  else:
    print('is blue')

arr = []
if arr:
  print(arr)
else:
  print('arr is None')
=> arr is None

alien_0 = {'color': 'green'}
print(alien_0['color'])
=> green

# 字典中键值对数量
print(len(alien_0))
=> 1

# 添加键值对
alien_0['point'] = 10
print(alien_0)
=> {'color': 'green', 'point': 10}

# 修改字典中的值
alien_0['point'] = 5

# 删除键值对
del alien_0['point']

# 判断键是否存在于字典
alien_0 = {'color': 'green'}
print('points' in alien_0)
=> False

# 元组作为键
contacts = {
  ('张伟', 1): '13711111111',
  ('张伟', 2): '13722222222',
  ('张伟', 3): '13733333333',
}
# 找到张伟2的联系方式
phone = contacts[('张伟', 2)]
print(phone)
=> 13722222222

alien_0 = {'color': 'green'}
point_value = alien_0.get('points', 'No point value assigned.')
print(point_value)
=> No point value assigned.
=> 若第二个入参为空，返回None

for key,value in 字典.items():
  操作语句

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'rust',
  'phil': 'python',
}
print(favorite_languages.items())
=> dict_items([('jen', 'python'), ('sarah', 'c'), ('edward', 'rust'), ('phil', 'python')])

for name, language in favorite_languages.items():
  print(f"{name.title()}'s favorite language is {language.title()}.")

=>
Jen's favorite language is Python.
Sarah's favorite language is C.
Edward's favorite language is Rust.
Phil's favorite language is Python.

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'rust',
  'phil': 'python',
}

print(favorite_languages.keys())
=> dict_keys(['jen', 'sarah', 'edward', 'phil'])

for key in favorite_languages.keys():
  print(key)

=> 
jen
sarah
edward
phil

# 在遍历字典时，会默认遍历所有的键
for key in favorite_languages: 
等价于
for key in favorite_languages.keys():

favorite_languages = {
  'jen': 'python',
  'sarah': 'c',
  'edward': 'rust',
  'phil': 'python',
}
print(favorite_languages.values())
=> dict_values(['python', 'c', 'rust', 'python'])

for value in favorite_languages.values():
  print(value)
=>
python
c
rust
python

# 使用set剔除重复项
for value in set(favorite_languages.values()):
  print(value)
=>
c
python
rust

name = input("Please enter your name: ")
print(f"\nHello, {name}!")

=>Please enter your name: 

=> 输入 csm
Please enter your name: csm

Hello, csm!

age = input("How old are you? ")
age = int(age)

if age >= 18:
  print("你成年了")
else:
  print("你还未成年")
  
=> How old are you?
=> 输入20
How old are you? 20
你成年了

# 格式
while 条件:
  行动

message = ''
while message != 'quit' :
  message = input('请输入信息，输入quit时退出程序：')
  if message != 'quit':
    print(message)
    
=>
请输入信息，输入quit时退出程序：1
1
请输入信息，输入quit时退出程序：2
2
请输入信息，输入quit时退出程序：quit

active = True
message = ''
while active:
  message = input('请输入信息，输入quit时退出程序：')
  if message == 'quit':
    break
  else:
    print(message)

num = 0
while num < 10:
  num = num + 1
  if (num % 2 == 0):
    continue
  print(num)
  

=>
1
3
5
7
9

pets = ['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
print(pets)

while 'cat' in pets:
    pets.remove('cat')

print(pets)

responses = {}
# 设置一个标志，指出调查是否继续
polling_active = True

while polling_active:
    # 提示输入被调查者的名字和回答
  name = input("\nWhat is your name? ")
  response = input("Which mountain would you like to climb someday? ")

    # 将回答存储在字典中
  responses[name] = response

    # 看看是否还有人要参与调查
  repeat = input("Would you like to let another person respond? (yes/no) ")
  if repeat == 'no':
      polling_active = False

# 调查结束，显示结果
print("\n--- Poll Results ---")
for name, response in responses.items():
    print(f"{name} would like to climb {response}.")
    

=>
What is your name? Eric
Which mountain would you like to climb someday? Denali
Would you like to let another person respond? (yes/no) yes

What is your name? Lynn
Which mountain would you like to climb someday? Devil's Thumb
Would you like to let another person respond? (yes/no) no

--- Poll Results ---
Eric would like to climb Denali.
Lynn would like to climb Devil's Thumb.

# 语法
def 函数名(入参):
  操作

# 调用函数
函数名(入参)

def favorite_book(name):
  print(f"my favorite book is {name}")

favorite_book('Harry Potter')
=> my favorite book is Harry Potter

#关键词实参
favorite_book(name = 'alive')

def make_pizza(*toppings):
    """概述要制作的比萨"""
    print("\nMaking a pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza('pepperoni')
=>
Making a pizza with the following toppings:
- pepperoni

make_pizza('mushrooms', 'green peppers', 'extra cheese')
=>
Making a pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

def build_profile(first, last, **user_info):
  """创建一个字典，其中包含我们知道的有关用户的一切"""
  user_info['first_name'] = first
  user_info['last_name'] = last
  return user_info

user_profile = build_profile('albert', 'einstein', location='princeton', field='physics')
print(user_profile)
=>
{'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

def make_pizza(size, *toppings):
    """概述要制作的比萨"""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

import module_name

module_name.function_name()

import pizza

pizza.make_pizza(16, 'pepperoni')

# 只导入模块中的特定函数
import module_name import function_name

# 用逗号分隔函数名，可根据需要从模块中导入任意数量的函数
import module_name import function_name1, function_name2, function_name3

from pizza import make_pizza 

make_pizza(16, 'pepperoni')

from module_name import function_name as fn

from pizza import make_pizza as mp

mp(16, 'pepperoni')

import pizza as p

p.make_pizza(16, 'pepperoni')

import module_name as mn

from module_name import *

from pizza import *

make_pizza(16, 'pepperoni')

lambda num1,num2: num1 +num2

def calculate_and_print(num, calculator):
  result = calculator(num)
  print(result)

calculate_and_print(5, lambda num: num * 5)
=> 25

result = (lambda num1,num2: num1 +num2)(2, 3)
print(result)
=> 5

# 定义类
class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def sit(self):
    print(f"{self.name} is sitting now.")

# 创建对象
dog1 = Dog('wangwang', 2)
dog2 = Dog('xiaobai', 1)

# 访问属性
print(dog1.name)
=> wangwang

# 调用方法
dog1.sit()
dog2.sit()
=>
wangwang is sitting now.
xiaobai is sitting now.

class Animal:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def greeting(self):
    print(f"hello, I am {self.name}.")

class Tail:
  def __init__(self, size, length):
    self.size = size
    self.length = length

# 继承父类
class Dog(Animal):
  def __init__(self, name, age, sex):
    """
    先初始化父类的属性，再初始化电动汽车特有的属性
    """
    super().__init__(name, age)
    self.sex = sex
    # 将实例用作属性
    self.tail = Tail('big', 10)

  # 定义子类方法
  def eating(self):
     print(f"{self.name} is eating")

# 重写父类方法
  def greeting(self):
     print("wang wang!")

dog1 = Dog('wangcai', 1, 'male')
dog1.eating()
dog1.greeting()
print(dog1.tail.size)

from random import randint
print(randint(1, 6))
=> 3

from random import choice
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(choice(players))
=> martina

from pathlib import Path

path = Path('pi_digits.txt')
contents = path.read_text()
print(contents)

f = open('pi_digits.txt', 'r', encoding="utf-8")
print(f.read()) # 会读全部的文件内容，并打印
print(f.read()) # 会读空字符串，并打印
f.close() # 关闭文件，释放资源
=>
3.1415926535
  8979323846
  2643383279

f = open('pi_digits.txt', 'r', encoding="utf-8")
print(f.read(5)) # 读取第1-5个字节
print(f.read(5)) # 读取第6-10个字节
f.close()
=>
3.141
59265

f = open('pi_digits.txt', 'r', encoding="utf-8")
line = f.readline()
while(line != ''):
  print(line.strip())
  line = f.readline()
f.close()

f = open('pi_digits.txt', 'r', encoding="utf-8")
lines = f.readlines()
for line in lines:
  print(line.strip())
f.close()

with open('pi_digits.txt', 'r') as f:
  print(f.read())

from pathlib import Path

path = Path('pi_digits.txt')
contents = path.read_text()
# 如果系统的默认编码与要读取的文件的编码不一致，参数 encoding 必不可少。
contents1 = path.read_text(encoding='utf-8')

pi_str = ''

for line in contents.splitlines():
  pi_str += line.strip()
  print(line)
=>
3.1415926535
  8979323846
  2643383279

print(pi_str)
=> 3.141592653589793238462643383279

from pathlib import Path

path = Path('programming.txt')
path.write_text("I love programming.")

with open('data.txt', 'w') as f:
  f.write('qwer\n')
  f.write('asdf')

from pathlib import Path
import json

numbers = [2, 3, 5, 7, 11, 13]

path = Path('numbers.json')
contents = json.dumps(numbers)
path.write_text(contents)

from pathlib import Path
import json

path = Path('numbers.json')
contents = path.read_text()
numbers = json.loads(contents)

print(numbers)
=> [2, 3, 5, 7, 11, 13]

path = Path('username.json')
if path.exists():
  contents = path.read_text()
  username = json.loads(contents)
  print(f"Welcome back, {username}!")
else:
  username = input("What is your name? ")
  contents = json.dumps(username)
  path.write_text(contents)
  print(f"We'll remember you when you come back, {username}!")

number1 = int(input('请输入被除数：'))
number2 = int(input('请输入除数：'))
try:
  answer = number1 / number2
except ZeroDivisionError:
  print("除数不能为0")
else:
  print(f"{number1}/{number2}={answer}")
finally:
  print("计算结结束")
  
=>
请输入被除数：2
请输入除数：1
2/1=2.0
计算结束

=>
请输入被除数：1
请输入除数：0
除数不能为0
计算结束

def count_words(path):
    """计算一个文件大致包含多少个单词"""
    try:
        --snip--
    except FileNotFoundError:
        pass
    else:
        --snip--

from name_function import get_formatted_name

def test_first_last_name():
  """能够正确地处理像 Janis Joplin 这样的姓名吗？"""
  formatted_name = get_formatted_name('janis', 'joplin')
  assert formatted_name == 'Janis Joplin'

import pytest
from survey import AnonymousSurvey

@pytest.fixture
def language_survey():
  """一个可供所有测试函数使用的 AnonymousSurvey 实例"""
  question = "What language did you first learn to speak?"
  language_survey = AnonymousSurvey(question)
  return language_survey

def test_store_single_response(language_survey):
  """测试单个答案会被妥善地存储"""
  language_survey.store_response('English')
  assert 'English' in language_survey.responses

def test_store_three_responses(language_survey):
  """测试三个答案会被妥善地存储"""
  responses = ['English', 'Spanish', 'Mandarin']
  for response in responses:
    language_survey.store_response(response)

  for response in responses:
    assert response in language_survey.responses

pygame.sprite.groupcollide(self.bullets, self.aliens, True, True)

pygame.sprite.spritecollideany(self.ship, self.aliens)

self.msg_image = self.font.render(msg, True, self.text_color, self.button_color)

self.play_button.rect.collidepoint(mouse_pos)

 rounded_score = round(self.stats.score, -1)

score_str = f"{rounded_score:,}"

import matplotlib.pyplot as plt

input_values = [1, 2, 3, 4, 5] # 输入值
squares = [1, 4, 9, 16, 25] # 输出值

plt.style.use('seaborn-v0_8') # 使用内置样式
# 变量 fig 表示由生成的一系列绘图构成的整个图形。
# 变量 ax 表示图形中的绘图
fig, ax = plt.subplots()
# 根据给定的数据绘制绘图，设置线条粗细
ax.plot(input_values, squares, linewidth=3) 

# 设置图题并给坐标轴加上标签
ax.set_title("Square Numbers", fontsize=24)
ax.set_xlabel("Value", fontsize=14)
ax.set_ylabel("Square of Value", fontsize=14)

# 设置刻度标记的样式
ax.tick_params(labelsize=14)


# 打开 Matplotlib 查看器并显示绘图
plt.show()

import matplotlib.pyplot as plt

# x_values = [1, 2, 3, 4, 5]
# y_values = [1, 4, 9, 16, 25]
x_values = range(1, 1001)
y_values = [x**2 for x in x_values] # 列表推导式

plt.style.use('seaborn-v0_8')
fig, ax = plt.subplots()
# ax.scatter(2, 4, s=200) # 绘制单点
# ax.scatter(x_values, y_values, color = (0, 0.8, 0), s=10) # 绘制一系列点

# 使用颜色映射：根据每个点的 y 坐标值来设置其颜色
ax.scatter(x_values, y_values, c = y_values, cmap = plt.cm.Blues, s=10) # 绘制一系列点

# 设置图题并给坐标轴加上标签
ax.set_title("Square Numbers", fontsize=24)
ax.set_xlabel("Value", fontsize=14)
ax.set_ylabel("Square of Value", fontsize=14)

# 设置刻度标记的样式
ax.tick_params(labelsize=14)

# 设置每个坐标轴的取值范围
ax.axis([0,1100, 0, 1_100_000])
ax.ticklabel_format(style='plain') # 修改刻度标记样式

# 打开 Matplotlib 查看器并显示绘图
plt.show()  
# 保存绘图
# plt.savefig('squares_plot.png', bbox_inches='tight')

from random import choice # choice选择一个值

class RandomWalk:
    """一个生成随机游走数据的类"""

    def __init__(self, num_points=5000): # 设置随机游走包含的默认点数
        """初始化随机游走的属性"""
        self.num_points = num_points

        # 所有随机游走都始于(0, 0)
        self.x_values = [0]
        self.y_values = [0]


    def fill_walk(self):
        """计算随机游走包含的所有点"""

        # 不断游走，直到列表达到指定的长度
        while len(self.x_values) < self.num_points:

            # 决定前进的方向以及沿这个方向前进的距离
            x_step = self.get_step()
            y_step = self.get_step()

            # 拒绝原地踏步
            if x_step == 0 and y_step == 0:
                continue

            # 计算下一个点的 x 坐标值和 y 坐标值
            x = self.x_values[-1] + x_step
            y = self.y_values[-1] + y_step

            self.x_values.append(x)
            self.y_values.append(y)


    def get_step(self):
        direction = choice([1, -1])
        distance = choice([0, 1, 2, 3, 4])
        step = direction * distance
        return step

import matplotlib.pyplot as plt
from random_walk import RandomWalk


# 只要程序处于活动状态，就不断地模拟随机游走
while True:
    # 创建一个 RandomWalk 实例
    rw = RandomWalk(50000)
    rw.fill_walk()

    # 将所有的点都绘制出来
    plt.style.use('classic')
    fig, ax = plt.subplots()
    # fig, ax = plt.subplots(figsize=(15, 9)) # 使用参数figsize指定生成的图形尺寸

    # 使用颜色映射来指出游走中各个点的先后顺序，并删除每个点的黑色轮廓，让其颜色更加明显
    point_numbers = range(rw.num_points)
    ax.scatter(rw.x_values, rw.y_values, c=point_numbers, cmap=plt.cm.Blues, edgecolors='none', s=1)
    # ax.scatter(rw.x_values, rw.y_values, s=15)
    # ax.plot(rw.x_values, rw.y_values)

    ax.set_aspect('equal') # 设置两条轴上刻度的间距相等

    # 突出起点和终点
    ax.scatter(0, 0, c='green', edgecolors='none', s=100)
    ax.scatter(rw.x_values[-1], rw.y_values[-1], c='red', edgecolors='none',
        s=100)

    # 隐藏坐标轴
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    plt.show()

    keep_running = input("Make another walk? (y/n): ")
    if keep_running == 'n':
        break

from random import randint

class Die:
    """表示一个骰子的类"""

    def __init__(self, num_sides=6):
        """骰子默认为 6 面的"""
        self.num_sides = num_sides

    def roll(self):
        """"返回一个介于 1 和骰子面数之间的随机值"""
        return randint(1, self.num_sides)

import plotly.express as px
from die import Die

# 创建量个 D6
die_1 = Die()
die_2 = Die()
# die_2 = Die(8)

# 掷几次骰子并将结果存储在一个列表中
results = []
for roll_num in range(1000):
    result = die_1.roll() + die_2.roll()
    results.append(result)

frequencies = []
max_result = die_1.num_sides + die_2.num_sides
poss_results = range(2, max_result+1)
for value in poss_results:
    frequency = results.count(value) # 计算每个点数在 results 中出现了多少次
    frequencies.append(frequency)


title = "投掷1000次两个六面骰子的结果"
labels = {'x': 'Result', 'y': 'Frequency of Result'}
fig = px.bar(x=poss_results, y=frequencies, title=title, labels=labels) # 绘制直方图
fig.update_layout(xaxis_dtick=1) # xaxis_dtick表示x轴上刻度标记的间距，设置为1，给每个条形都加上了标签

fig.show()
# fig.write_html('dice_visual_d6d6.html') # 保存图形

from pathlib import Path
import csv

path = Path('weather_data/sitka_weather_07-2021_simple.csv')
lines = path.read_text().splitlines()

reader = csv.reader(lines)
header_row = next(reader)

# 对列表调用 enumerate() 来获取每个元素的索引及其值
for index, column_header in enumerate(header_row):
    print(index, column_header)

from datetime import datetime
first_date = datetime.strptime('2021-07-01', '%Y-%m-%d')
print(first_date)
=> 2021-07-01 00:00:00

ax.fill_between(dates, highs, lows, facecolor='blue', alpha=0.1)

from pathlib import Path
import csv
from datetime import datetime
import matplotlib.pyplot as plt

path = Path('weather_data/death_valley_2021_simple.csv')
# path = Path('weather_data/sitka_weather_2021_simple.csv')
lines = path.read_text().splitlines()

reader = csv.reader(lines)
header_row = next(reader)
date_index = header_row.index('DATE')
high_index = header_row.index('TMAX')
low_index = header_row.index('TMIN')
name_index = header_row.index('NAME')

# 提取日期、最高温度和最低温度
dates, highs, lows = [], [], []
place_name = ""
for row in reader:
    if not place_name:
        place_name = row[name_index]

    current_date = datetime.strptime(row[date_index], '%Y-%m-%d') # 把日期数据转化成datetime对象
    try:
        high = int(row[high_index])
        low = int(row[low_index])
    except ValueError:
        print(f"Missing data for {current_date}")
    else:
        dates.append(current_date)
        highs.append(high)
        lows.append(low)

# 根据最高温度绘图
plt.style.use('seaborn-v0_8')
fig, ax = plt.subplots()
ax.plot(dates, highs, color='red', alpha=0.5)
ax.plot(dates, lows, color='blue', alpha=0.5)
ax.fill_between(dates, highs, lows, facecolor='blue', alpha=0.1)

# 设置绘图的格式
plt.rcParams["font.family"] = ["sans-serif"]
plt.rcParams["font.sans-serif"] = ['SimHei']

title = f"2021年最高最低气温\n{place_name}"
ax.set_title(title, fontproperties="SimHei", fontsize=24)
ax.set_xlabel('', fontsize=16)
fig.autofmt_xdate() # 倾斜文本
ax.set_ylabel("Temperature (F)", fontsize=16)
ax.tick_params(labelsize=16)

plt.show()

from pathlib import Path
import json
import plotly.express as px
import pandas as pd

# 将数据作为字符串读取并转换为 Python 对象
path = Path('eq_data/eq_data_1_day_m1.geojson')
try:
    contents = path.read_text()
except:
    contents = path.read_text(encoding='utf-8')
all_eq_data = json.loads(contents) # 将字符串转换成Python 对象


# 将数据文件转换为更易于阅读的版本
# path = Path('eq_data/readable_eq_data.geojson')
# readable_contents = json.dumps(all_eq_data, indent=4) # 将Python 对象转换成字符串, indent表示缩进量
# path.write_text(readable_contents)

# 查看数据集中的所有地震
all_eq_dicts = all_eq_data['features']

mags, titles, lons, lats = [], [], [], [] 
for eq_dict in all_eq_dicts:
    mag = eq_dict['properties']['mag']
    title = eq_dict['properties']['title']
    lon = eq_dict['geometry']['coordinates'][0]
    lat = eq_dict['geometry']['coordinates'][1]
    mags.append(mag)
    titles.append(title)
    lons.append(lon)
    lats.append(lat)

# 使用DataFrame封装数据
data = pd.DataFrame(
 data=zip(lons, lats, titles, mags), columns=['经度', '纬度', '位置', '震级']
)
data.head()

fig = px.scatter(
    # x=lons,
    # y=lats,
    # labels={'x': '经度 ', 'y': '纬度 '},
    data,
    x='经度',
    y='纬度',
    range_x=[-200, 200],
    range_y=[-90, 90],
    width=800,
    height=800,
    title='全球地震散点图',
    size='震级',
    size_max=10,
    color='震级',
    hover_name='位置',
 )
# fig.write_html('eq_data/global_earthquakes.html')
fig.show()

import requests
import plotly.express as px

# 执行 API 调用并查看响应
url = "https://api.github.com/search/repositories"
url += "?q=language:python+sort:stars+stars:>10000"

headers = {"Accept": "application/vnd.github.v3+json"}
r = requests.get(url, headers=headers)
print(f"Status code: {r.status_code}")

# 处理结果
response_dict = r.json()
print(f"Complete results: {not response_dict['incomplete_results']}")

# 处理有关仓库的信息
repo_dicts = response_dict['items']
stars, hover_texts, repo_links = [], [], []
for repo_dict in repo_dicts:
    # 将仓库名转换为链接
    repo_name = repo_dict['name']
    repo_url = repo_dict['html_url']
    repo_link = f"<a href='{repo_url}'>{repo_name}</a>"
    repo_links.append(repo_link)

    stars.append(repo_dict['stargazers_count'])
    # 创建悬停文本 
    owner = repo_dict['owner']['login']
    description = repo_dict['description']
    hover_text = f"{owner}<br />{description}"
    hover_texts.append(hover_text)

# 可视化
title = "Most-Starred Python Projects on GitHub"
labels = {'x': 'Repository', 'y': 'Stars'}
fig = px.bar(x=repo_links, y=stars, title=title, labels=labels,hover_name=hover_texts)
fig.update_layout(title_font_size=28, xaxis_title_font_size=20, yaxis_title_font_size=20)
fig.update_traces(marker_color='SteelBlue', marker_opacity=0.6)
fig.show()