20个很酷的Python脚本案例源码

import requests
from bs4 import BeautifulSoup
 
url = 'https://example.com'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
 
# Extracting data, e.g., all the links on the page
links = soup.find_all('a')
for link in links:
    print(link.get('href'))

from flask import Flask, request, jsonify
import pickle
 
app = Flask(__name__)
 
# Load the trained machine learning model
with open('model.pkl', 'rb') as model_file:
    model = pickle.load(model_file)
 
@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json(force=True)
    prediction = model.predict([data['input']])
    output = {'prediction': prediction[0]}
    return jsonify(output)
 
if __name__ == '__main__':
    app.run(port=5000)

import hashlib
import time
 
class Block:
    def __init__(self, previous_hash, data):
        self.timestamp = time.time()
        self.previous_hash = previous_hash
        self.data = data
        self.hash = self.calculate_hash()
 
    def calculate_hash(self):
        return hashlib.sha256(
            (str(self.timestamp) + str(self.previous_hash) + str(self.data)).encode('utf-8')
        ).hexdigest()
 
# Create a blockchain
blockchain = [Block("0", "Genesis Block")]
 
# Add a new block
new_data = "Some transaction data"
previous_block = blockchain[-1]
new_block = Block(previous_block.hash, new_data)
blockchain.append(new_block)

from selenium import webdriver
 
# Initialize a Chrome browser
driver = webdriver.Chrome()
 
# Open a website
driver.get('https://example.com')
 
# Find an element by its ID and interact with it
element = driver.find_element_by_id('some_element_id')
element.click()
 
# Perform assertions or other actions as needed
 
# Close the browser
driver.quit()

from scapy.all import ARP, Ether, srp
 
def scan(ip):
    arp_request = ARP(pdst=ip)
    ether = Ether(dst="ff:ff:ff:ff:ff:ff")
    packet = ether/arp_request
    result = srp(packet, timeout=3, verbose=0)[0]
     
    devices = []
    for sent, received in result:
        devices.append({'ip': received.psrc, 'mac': received.hwsrc})
     
    return devices
 
ip_range = "192.168.1.1/24"
devices = scan(ip_range)
 
for device in devices:
    print(f"IP: {device['ip']}, MAC: {device['mac']}")

import requests
 
def get_crypto_prices():
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {'ids': 'bitcoin,ethereum,litecoin', 'vs_currencies': 'usd'}
    response = requests.get(url, params=params)
    prices = response.json()
    return prices
 
crypto_prices = get_crypto_prices()
 
for coin, value in crypto_prices.items():
    print(f"{coin.capitalize()}: ${value['usd']}")

import pandas as pd
import matplotlib.pyplot as plt
 
# Assume 'data.csv' is your dataset
df = pd.read_csv('data.csv')
 
# Perform data analysis
average_age = df['Age'].mean()
total_records = len(df)
 
# Create a bar chart
plt.bar(['Average Age', 'Total Records'], [average_age, total_records])
plt.xlabel('Metrics')
plt.ylabel('Values')
plt.title('Basic Data Analysis')
plt.show()

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.sentiment import SentimentIntensityAnalyzer
 
nltk.download('punkt')
nltk.download('vader_lexicon')
 
text = "NLTK is a powerful library for natural language processing. I love using it!"
 
# Tokenization
words = word_tokenize(text)
sentences = sent_tokenize(text)
 
# Sentiment analysis
sid = SentimentIntensityAnalyzer()
sentiment_score = sid.polarity_scores(text)
 
print("Tokenized Words:", words)
print("Tokenized Sentences:", sentences)
print("Sentiment Score:", sentiment_score)

from cryptography.fernet import Fernet
 
# Generate a key for encryption and decryption
key = Fernet.generate_key()
cipher_suite = Fernet(key)
 
# Data to be encrypted
data = b"Confidential information"
 
# Encryption
cipher_text = cipher_suite.encrypt(data)
print("Encrypted:", cipher_text)
 
# Decryption
plain_text = cipher_suite.decrypt(cipher_text)
print("Decrypted:", plain_text.decode('utf-8'))

from flask import Flask, jsonify, request
 
app = Flask(__name__)
 
# Sample data
books = [
    {'id': 1, 'title': 'Python Crash Course', 'author': 'Eric Matthes'},
    {'id': 2, 'title': 'Fluent Python', 'author': 'Luciano Ramalho'}
]
 
# GET request to retrieve all books
@app.route('/books', methods=['GET'])
def get_books():
    return jsonify({'books': books})
 
# POST request to add a new book
@app.route('/books', methods=['POST'])
def add_book():
    new_book = request.get_json()
    books.append(new_book)
    return jsonify({'message': 'Book added successfully'})
 
if __name__ == '__main__':
    app.run(port=5000)

import cv2
import numpy as np
 
# Load an image
image = cv2.imread('image.jpg')
 
# Convert the image to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
# Perform edge detection
edges = cv2.Canny(gray_image, 50, 150)
 
# Display the original and processed images
cv2.imshow('Original Image', image)
cv2.imshow('Edge Detection', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
 
# Assume 'stock_data.csv' contains historical stock prices
df = pd.read_csv('stock_data.csv')
 
# Feature engineering
df['Date'] = pd.to_datetime(df['Date'])
df['Date'] = df['Date'].dt.strftime('%Y%m%d').astype(float)
 
# Selecting features and target
X = df[['Date']]
y = df['Close']
 
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
# Train a linear regression model
model = LinearRegression()
model.fit(X_train, y_train)
 
# Make predictions
predictions = model.predict(X_test)
 
# Plot the predictions against actual values
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, predictions, color='blue', linewidth=3)
plt.xlabel('Date')
plt.ylabel('Stock Price (Close)')
plt.title('Stock Price Prediction')
plt.show()

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
 
# Sender and recipient email addresses
sender_email = 'your_email@gmail.com'
recipient_email = 'recipient_email@example.com'
 
# Email server configuration
smtp_server = 'smtp.gmail.com'
smtp_port = 587
smtp_username = 'your_email@gmail.com'
smtp_password = 'your_email_password'
 
# Message content
subject = 'Automated Email'
body = 'This is an automated email sent using Python.'
 
# Create the MIME object
message = MIMEMultipart()
message['From'] = sender_email
message['To'] = recipient_email
message['Subject'] = subject
message.attach(MIMEText(body, 'plain'))
 
# Connect to the SMTP server and send the email
with smtplib.SMTP(smtp_server, smtp_port) as server:
    server.starttls()
    server.login(smtp_username, smtp_password)
    server.sendmail(sender_email, recipient_email, message.as_string())

from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer
 
# Create a chatbot instance
chatbot = ChatBot('MyBot')
 
# Create a new trainer for the chatbot
trainer = ChatterBotCorpusTrainer(chatbot)
 
# Train the chatbot on English language data
trainer.train('chatterbot.corpus.english')
 
# Get a response from the chatbot
response = chatbot.get_response('Hello, how are you?')
print(response)

from reportlab.pdfgen import canvas
 
def generate_pdf(file_name, content):
    # Create a PDF document
    pdf = canvas.Canvas(file_name)
 
    # Add content to the PDF
    pdf.drawString(100, 750, "Generated PDF Report")
    pdf.drawString(100, 730, "----------------------")
    pdf.drawString(100, 700, content)
 
    # Save the PDF
    pdf.save()
 
# Example usage
report_content = "This is a sample PDF report."
generate_pdf('sample_report.pdf', report_content)

import scrapy
 
class QuotesSpider(scrapy.Spider):
    name = 'quotes'
    start_urls = ['http://quotes.toscrape.com/page/1/']
 
    def parse(self, response):
        for quote in response.css('div.quote'):
            yield {
                'text': quote.css('span.text::text').get(),
                'author': quote.css('small::text').get(),
                'tags': quote.css('div.tags a.tag::text').getall(),
            }
 
        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

import tweepy
import time
 
# Twitter API credentials
consumer_key = 'your_consumer_key'
consumer_secret = 'your_consumer_secret'
access_token = 'your_access_token'
access_token_secret = 'your_access_token_secret'
 
# Authenticate with Twitter
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
 
# Tweet content
tweet_text = "Hello, Twitter! This is my first tweet using Tweepy."
 
# Post the tweet
api.update_status(tweet_text)
 
# Wait for 5 seconds (optional)
time.sleep(5)

import plotly.express as px
import plotly.graph_objects as go
 
# Sample data
data = {'Category': ['A', 'B', 'C', 'D'],
        'Values': [10, 25, 15, 30]}
 
# Create a bar chart using Plotly Express
fig1 = px.bar(data, x='Category', y='Values', title='Bar Chart')
 
# Create a scatter plot using Plotly Graph Objects
fig2 = go.Figure()
fig2.add_trace(go.Scatter(x=data['Category'], y=data['Values'], mode='markers', name='Scatter Plot'))
 
# Show the visualizations
fig1.show()
fig2.show()

import tkinter as tk
 
def on_button_click():
    label.config(text="Hello, " + entry.get())
 
# Create the main window
window = tk.Tk()
window.title("Simple Tkinter App")
 
# Create a label
label = tk.Label(window, text="Enter your name:")
label.pack()
 
# Create an entry widget
entry = tk.Entry(window)
entry.pack()
 
# Create a button
button = tk.Button(window, text="Click me", command=on_button_click)
button.pack()
 
# Run the application
window.mainloop()

from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy
 
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mydatabase.db'
db = SQLAlchemy(app)
 
# Define a data model
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
 
# Create the database
db.create_all()
 
@app.route('/')
def index():
    users = User.query.all()
    return render_template('index.html', users=users)
 
@app.route('/add_user', methods=['POST'])
def add_user():
    username = request.form['username']
    new_user = User(username=username)
    db.session.add(new_user)
    db.session.commit()
    return redirect(url_for('index'))
 
if __name__ == '__main__':
    app.run(debug=True)