萍乡李兴球的博客_信奥C++/Python/Scratch

以 下程序生成一个批处理文件,再运行批处理后能把wmv视频都转换成mp4文件. 转换时用的是大名鼎鼎的ffmpeg。这个请自行下载，网上多得是。

import os

tasks = []
path = 'E:\\展示的创意视频'
for root,dirs,files in os.walk(path):                  # 递归遍历path的所有子文件夹和其下面的所有文件
    for file in files:                                 # 当前文件夹下面的所有文件 
        f,ext = os.path.splitext(file)                 # 分开文件名和扩展名
        if ext=='.wmv':                                # 如果扩展名是.wmv 
           source = root + os.sep + f + ext            # 形成源文件名
           dest = root + os.sep + f + '.mp4'           # 合成mp4文件名 
           s = 'ffmpeg -i ' + source + " " + dest      # 合成字符串 
           tasks.append(s)                             # 添加到tasks列表

s = '\n'.join(tasks)
s = s + "\n" + 'pause'

f = open('生成mp4.bat',mode='w')
f.write(s)
f.close()
           

以下是生成的bat文件：

ffmpeg -i E:\展示的创意视频\pygame\2D_Minecraft.wmv E:\展示的创意视频\pygame\2D_Minecraft.mp4
ffmpeg -i E:\展示的创意视频\pygame\3D星空.wmv E:\展示的创意视频\pygame\3D星空.mp4
ffmpeg -i E:\展示的创意视频\pygame\Chinese Music花瓣飞舞的春天.wmv E:\展示的创意视频\pygame\Chinese Music花瓣飞舞的春天.mp4
ffmpeg -i E:\展示的创意视频\pygame\G.wmv E:\展示的创意视频\pygame\G.mp4
ffmpeg -i E:\展示的创意视频\pygame\Video_2018-11-27_170458.wmv E:\展示的创意视频\pygame\Video_2018-11-27_170458.mp4
ffmpeg -i E:\展示的创意视频\pygame\动态背景_绿色瀑布风景waterfall parallax.wmv E:\展示的创意视频\pygame\动态背景_绿色瀑布风景waterfall parallax.mp4
ffmpeg -i E:\展示的创意视频\pygame\动态背景_蓝天绿地太阳云朵户外场景动画演示.wmv E:\展示的创意视频\pygame\动态背景_蓝天绿地太阳云朵户外场景动画演示.mp4
ffmpeg -i E:\展示的创意视频\pygame\勇闯黑暗迷宫_预览视频.wmv E:\展示的创意视频\pygame\勇闯黑暗迷宫_预览视频.mp4
ffmpeg -i E:\展示的创意视频\pygame\小猫过桥.wmv E:\展示的创意视频\pygame\小猫过桥.mp4
ffmpeg -i E:\展示的创意视频\pygame\小鸟捕手.wmv E:\展示的创意视频\pygame\小鸟捕手.mp4
ffmpeg -i E:\展示的创意视频\pygame\尖峰时刻.wmv E:\展示的创意视频\pygame\尖峰时刻.mp4
ffmpeg -i E:\展示的创意视频\pygame\打地鼠.wmv E:\展示的创意视频\pygame\打地鼠.mp4
ffmpeg -i E:\展示的创意视频\pygame\抖动的云朵_帧图生成样本示例.wmv E:\展示的创意视频\pygame\抖动的云朵_帧图生成样本示例.mp4
ffmpeg -i E:\展示的创意视频\pygame\最简太空飞船射击.wmv E:\展示的创意视频\pygame\最简太空飞船射击.mp4
ffmpeg -i E:\展示的创意视频\pygame\月亮之夜_鼠标渐隐拖尾.wmv E:\展示的创意视频\pygame\月亮之夜_鼠标渐隐拖尾.mp4
ffmpeg -i E:\展示的创意视频\pygame\泡泡坦克大战.wmv E:\展示的创意视频\pygame\泡泡坦克大战.mp4
ffmpeg -i E:\展示的创意视频\pygame\漫天飞雪效果动画.wmv E:\展示的创意视频\pygame\漫天飞雪效果动画.mp4
ffmpeg -i E:\展示的创意视频\pygame\生死存亡.wmv E:\展示的创意视频\pygame\生死存亡.mp4
ffmpeg -i E:\展示的创意视频\pygame\跳跳猫.wmv E:\展示的创意视频\pygame\跳跳猫.mp4
ffmpeg -i E:\展示的创意视频\pygame\闪电侠接金币.wmv E:\展示的创意视频\pygame\闪电侠接金币.mp4
ffmpeg -i E:\展示的创意视频\pygame\雪地打蝙蝠.wmv E:\展示的创意视频\pygame\雪地打蝙蝠.mp4
ffmpeg -i E:\展示的创意视频\pygame\鼠闯迷宫.wmv E:\展示的创意视频\pygame\鼠闯迷宫.mp4
ffmpeg -i E:\展示的创意视频\sprites\一马当先.wmv E:\展示的创意视频\sprites\一马当先.mp4
ffmpeg -i E:\展示的创意视频\sprites\人类之路.wmv E:\展示的创意视频\sprites\人类之路.mp4
ffmpeg -i E:\展示的创意视频\sprites\太空虫子.wmv E:\展示的创意视频\sprites\太空虫子.mp4
ffmpeg -i E:\展示的创意视频\sprites\奥特曼.wmv E:\展示的创意视频\sprites\奥特曼.mp4
ffmpeg -i E:\展示的创意视频\sprites\急速返航_躲避游戏_李兴球博客.wmv E:\展示的创意视频\sprites\急速返航_躲避游戏_李兴球博客.mp4
ffmpeg -i E:\展示的创意视频\sprites\恐龙跳.wmv E:\展示的创意视频\sprites\恐龙跳.mp4
ffmpeg -i E:\展示的创意视频\sprites\月满西楼mv.wmv E:\展示的创意视频\sprites\月满西楼mv.mp4
ffmpeg -i E:\展示的创意视频\sprites\未来可期之星辰大海.wmv E:\展示的创意视频\sprites\未来可期之星辰大海.mp4
ffmpeg -i E:\展示的创意视频\sprites\猴小子冲关.wmv E:\展示的创意视频\sprites\猴小子冲关.mp4
ffmpeg -i E:\展示的创意视频\sprites\盘山公路的牵引.wmv E:\展示的创意视频\sprites\盘山公路的牵引.mp4
ffmpeg -i E:\展示的创意视频\sprites\相思配图.wmv E:\展示的创意视频\sprites\相思配图.mp4
ffmpeg -i E:\展示的创意视频\sprites\竹林弹字游戏.wmv E:\展示的创意视频\sprites\竹林弹字游戏.mp4
ffmpeg -i E:\展示的创意视频\sprites\第一人称射击打蝙蝠.wmv E:\展示的创意视频\sprites\第一人称射击打蝙蝠.mp4
ffmpeg -i E:\展示的创意视频\sprites\精卫填海.wmv E:\展示的创意视频\sprites\精卫填海.mp4
ffmpeg -i E:\展示的创意视频\sprites\自动打砖块.wmv E:\展示的创意视频\sprites\自动打砖块.mp4
ffmpeg -i E:\展示的创意视频\sprites\雷电图章版.wmv E:\展示的创意视频\sprites\雷电图章版.mp4
ffmpeg -i E:\展示的创意视频\sprites\音乐跳舞毯.wmv E:\展示的创意视频\sprites\音乐跳舞毯.mp4
ffmpeg -i E:\展示的创意视频\sprites\飞扬小鸟.wmv E:\展示的创意视频\sprites\飞扬小鸟.mp4
ffmpeg -i E:\展示的创意视频\turtle\1943.wmv E:\展示的创意视频\turtle\1943.mp4
ffmpeg -i E:\展示的创意视频\turtle\Video_2019-11-27_084845.wmv E:\展示的创意视频\turtle\Video_2019-11-27_084845.mp4
ffmpeg -i E:\展示的创意视频\turtle\二维码的梦.wmv E:\展示的创意视频\turtle\二维码的梦.mp4
ffmpeg -i E:\展示的创意视频\turtle\保卫公主.wmv E:\展示的创意视频\turtle\保卫公主.mp4
ffmpeg -i E:\展示的创意视频\turtle\坦克大战.wmv E:\展示的创意视频\turtle\坦克大战.mp4
ffmpeg -i E:\展示的创意视频\turtle\太空入侵.wmv E:\展示的创意视频\turtle\太空入侵.mp4
ffmpeg -i E:\展示的创意视频\turtle\太空出租箭.wmv E:\展示的创意视频\turtle\太空出租箭.mp4
ffmpeg -i E:\展示的创意视频\turtle\忍者的行为.wmv E:\展示的创意视频\turtle\忍者的行为.mp4
ffmpeg -i E:\展示的创意视频\turtle\抢收成语.wmv E:\展示的创意视频\turtle\抢收成语.mp4
ffmpeg -i E:\展示的创意视频\turtle\星际赛车.wmv E:\展示的创意视频\turtle\星际赛车.mp4
ffmpeg -i E:\展示的创意视频\turtle\猫狮大战之算术达人.wmv E:\展示的创意视频\turtle\猫狮大战之算术达人.mp4
ffmpeg -i E:\展示的创意视频\turtle\相声大数据.wmv E:\展示的创意视频\turtle\相声大数据.mp4
ffmpeg -i E:\展示的创意视频\turtle\砸蛋.wmv E:\展示的创意视频\turtle\砸蛋.mp4
ffmpeg -i E:\展示的创意视频\turtle\神算子一休哥.wmv E:\展示的创意视频\turtle\神算子一休哥.mp4
ffmpeg -i E:\展示的创意视频\turtle\老鼠过街.wmv E:\展示的创意视频\turtle\老鼠过街.mp4
ffmpeg -i E:\展示的创意视频\turtle\花框音乐盒.wmv E:\展示的创意视频\turtle\花框音乐盒.mp4
ffmpeg -i E:\展示的创意视频\turtle\菜根谭小猫.wmv E:\展示的创意视频\turtle\菜根谭小猫.mp4
ffmpeg -i E:\展示的创意视频\turtle\解放军VS木马.wmv E:\展示的创意视频\turtle\解放军VS木马.mp4
ffmpeg -i E:\展示的创意视频\turtle\迷宫寻宝.wmv E:\展示的创意视频\turtle\迷宫寻宝.mp4
pause

以下是幻灯片电子教案：
一.电子教案 第1章 程序设计基本方法
二.电子教案 第2章 Python语言基本语法元素
三.电子教案 第3章 基本数据类型
四.电子教案 第4章 程序的控制结构
五.电子教案 第5章 函数和代码复用
六.电子教案 第6章 组合数据类型
七.电子教案 第7章 文件和数据格式化
八.电子教案 第8章 Python计算生态
九.电子教案 第9章 Python标准库概览
十.电子教案 第10章 Python第三方库概览
十一.电子教案 第11章 Python第三方库纵览

还有20套模拟练习题目等更重要的资源，上课讲题做题目，更加轻松。成为本站会员，免费下载。

下面是下载链接：

'''

  本demo测试时运行的环境为：Windows + Python3.7
  本demo测试成功运行时所安装的第三方库及其版本如下，您可自行逐一或者复制到一个新的txt文件利用pip一次性安装：
   cffi==1.12.3
   gevent==1.4.0
   greenlet==0.4.15
   pycparser==2.19
   six==1.12.0
   websocket==0.2.1
   websocket-client==0.56.0

  语音听写流式 WebAPI 接口调用示例 接口文档（必看）：https://doc.xfyun.cn/rest_api/语音听写（流式版）.html
  webapi 听写服务参考帖子（必看）：http://bbs.xfyun.cn/forum.php?mod=viewthread&tid=38947&extra=
  语音听写流式WebAPI 服务，热词使用方式：登陆开放平台https://www.xfyun.cn/后，找到控制台--我的应用---语音听写（流式）---服务管理--个性化热词，
  设置热词
  注意：热词只能在识别的时候会增加热词的识别权重，需要注意的是增加相应词条的识别率，但并不是绝对的，具体效果以您测试为准。
  语音听写流式WebAPI 服务，方言试用方法：登陆开放平台https://www.xfyun.cn/后，找到控制台--我的应用---语音听写（流式）---服务管理--识别语种列表
  可添加语种或方言，添加后会显示该方言的参数值
  错误码链接：https://www.xfyun.cn/document/error-code （code返回错误码时必看）
  采样率16k或8K、位长16bit、单声道
'''
import websocket
import datetime
import hashlib
import base64
import hmac
import json
from urllib.parse import urlencode
import time
import ssl
from wsgiref.handlers import format_date_time
from datetime import datetime
from time import mktime
import _thread as thread

STATUS_FIRST_FRAME = 0  # 第一帧的标识
STATUS_CONTINUE_FRAME = 1  # 中间帧标识
STATUS_LAST_FRAME = 2  # 最后一帧的标识

class Ws_Param(object):
    # 初始化
    def __init__(self, APPID, APIKey, APISecret, AudioFile):
        self.APPID = APPID
        self.APIKey = APIKey
        self.APISecret = APISecret
        self.AudioFile = AudioFile

        # 公共参数(common)
        self.CommonArgs = {"app_id": self.APPID}
        # 业务参数(business)，更多个性化参数可在官网查看
        self.BusinessArgs = {"domain": "iat", "language": "zh_cn", "accent": "mandarin", "vinfo":1,"vad_eos":10000}

    # 生成url
    def create_url(self):
        url = 'wss://ws-api.xfyun.cn/v2/iat'
        #url = 'wss://iat-api.xfyun.cn/v2/iat'
        # 生成RFC1123格式的时间戳
        now = datetime.now()
        date = format_date_time(mktime(now.timetuple()))

        # 拼接字符串
        signature_origin = "host: " + "ws-api.xfyun.cn" + "\n"
        signature_origin += "date: " + date + "\n"
        signature_origin += "GET " + "/v2/iat " + "HTTP/1.1"
        # 进行hmac-sha256进行加密
        signature_sha = hmac.new(self.APISecret.encode('utf-8'), signature_origin.encode('utf-8'),
                                 digestmod=hashlib.sha256).digest()
        signature_sha = base64.b64encode(signature_sha).decode(encoding='utf-8')

        authorization_origin = "api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"" % (
            self.APIKey, "hmac-sha256", "host date request-line", signature_sha)
        authorization = base64.b64encode(authorization_origin.encode('utf-8')).decode(encoding='utf-8')
        # 将请求的鉴权参数组合为字典
        v = {
            "authorization": authorization,
            "date": date,
            "host": "ws-api.xfyun.cn"
        }
        # 拼接鉴权参数，生成url
        url = url + '?' + urlencode(v)
        # print("date: ",date)
        # print("v: ",v)
        # 此处打印出建立连接时候的url,参考本demo的时候可取消上方打印的注释，比对相同参数时生成的url与自己代码生成的url是否一致
        # print('websocket url :', url)
        return url


# 收到websocket消息的处理
def on_message(ws, message):
    s = ''
    try:
        code = json.loads(message)["code"]
        sid = json.loads(message)["sid"]
        if code != 0:
            errMsg = json.loads(message)["message"]
            print("sid:%s call error:%s code is:%s" % (sid, errMsg, code))

        else:
            data = json.loads(message)["data"]["result"]["ws"]
            # print(json.loads(message))
            result = ""
            for i in data:
                for w in i["cw"]:
                    result += w["w"]
            #print("sid:%s call success!,data is:%s" % (sid, json.dumps(data, ensure_ascii=False)))
            for d in data:
                s = s + d['cw'][0]['w']
            print(s)
    except Exception as e:
        print("receive msg,but parse exception:", e)


# 收到websocket错误的处理
def on_error(ws, error):
    print("### error:", error)


# 收到websocket关闭的处理
def on_close(ws):
    print("### closed ###")

# 收到websocket连接建立的处理
def on_open(ws):
    def run(*args):
        frameSize = 8000  # 每一帧的音频大小
        intervel = 0.04  # 发送音频间隔(单位:s)
        status = STATUS_FIRST_FRAME  # 音频的状态信息，标识音频是第一帧，还是中间帧、最后一帧

        with open(wsParam.AudioFile, "rb") as fp:
            while True:
                buf = fp.read(frameSize)
                # 文件结束
                if not buf:
                    status = STATUS_LAST_FRAME
                # 第一帧处理
                # 发送第一帧音频，带business 参数
                # appid 必须带上，只需第一帧发送
                if status == STATUS_FIRST_FRAME:

                    d = {"common": wsParam.CommonArgs,
                         "business": wsParam.BusinessArgs,
                         "data": {"status": 0, "format": "audio/L16;rate=16000",
                                  "audio": str(base64.b64encode(buf), 'utf-8'),
                                  "encoding": "raw"}}
                    d = json.dumps(d)
                    ws.send(d)
                    status = STATUS_CONTINUE_FRAME
                # 中间帧处理
                elif status == STATUS_CONTINUE_FRAME:
                    d = {"data": {"status": 1, "format": "audio/L16;rate=16000",
                                  "audio": str(base64.b64encode(buf), 'utf-8'),
                                  "encoding": "raw"}}
                    ws.send(json.dumps(d))
                # 最后一帧处理
                elif status == STATUS_LAST_FRAME:
                    d = {"data": {"status": 2, "format": "audio/L16;rate=16000",
                                  "audio": str(base64.b64encode(buf), 'utf-8'),
                                  "encoding": "raw"}}
                    ws.send(json.dumps(d))
                    time.sleep(1)
                    break
                # 模拟音频采样间隔
                time.sleep(intervel)
        ws.close()

    thread.start_new_thread(run, ())


if __name__ == "__main__":
    # 测试时候在此处正确填写相关信息即可运行
    time1 = datetime.now()
    appid = '测试的id'                                 #  请自行到科大飞讯网站上去申请appid
    apisecret = 'ZTJjZWUwMTQ2Y2U0ZGM0NDcwZWQ3Zjhj'     #  请自行到科大飞讯网站上去申请apisecret
    apikey = 'bf7396d58c1fd80596ac91c33f9a9237'        #  请自行到科大飞讯网站上去申请apikey
    wsParam = Ws_Param(APPID=appid, APISecret=apisecret,
                       APIKey=apikey,
                       AudioFile=r'output.wav')
    websocket.enableTrace(False)
    wsUrl = wsParam.create_url()
    ws = websocket.WebSocketApp(wsUrl, on_message=on_message, on_error=on_error, on_close=on_close)
    ws.on_open = on_open
    ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
    time2 = datetime.now()
    print(time2-time1)

import wave
import pyaudio

CHUNK = 1024  # 每个缓冲区的帧数
FORMAT = pyaudio.paInt16  # 采样位数
CHANNELS = 1  # 单声道
RATE = 16000
def record_audio(wave_out_path, record_second):
    """ 录音功能 """
    p = pyaudio.PyAudio()  # 实例化对象
    stream = p.open(format=FORMAT,
                    channels=CHANNELS,
                    rate=RATE,
                    input=True,
                    frames_per_buffer=CHUNK)  # 打开流，传入响应参数
    wf = wave.open(wave_out_path, 'wb')  # 打开 wav 文件。
    wf.setnchannels(CHANNELS)  # 声道设置
    wf.setsampwidth(p.get_sample_size(FORMAT))  # 采样位数设置
    wf.setframerate(RATE)  # 采样频率设置

    for _ in range(0, int(RATE * record_second / CHUNK)):
        data = stream.read(CHUNK)
        wf.writeframes(data)  # 写入数据
    stream.stop_stream()  # 关闭流
    stream.close()
    p.terminate()
    wf.close()

record_audio('output.wav',5)
print('本次录音完毕')

在设计幼儿编程课程中编写的一个小程序。 程序比较简单,迭代每一帧,调整后再合帧,输出为新的gif图形。

"""
调整gif文件大小
"""
from PIL import Image,ImageSequence

def resize_gif(infile,outfile):
    im = Image.open(infile)
    k = im.width/im.height
    if k > (4/3):        #  如果宽高比大于4比3则宽度设为480
        width = 480
        height = int(width / k)
    else:
        height = 360
        width = int(height * k)
    
    frames = []
    for frame in ImageSequence.Iterator(im):
        frame = frame.resize((width,height))
        frames.append(frame)
    pic = frames[0]
    pic.save(outfile, save_all=True,append_images=frames[1:], optimize=True,quality=100,duration=200)

path = 'F:\\风火轮编程\\课程体系\\L1_幼儿编程启蒙\\05_星空\\'
file = '银河系.gif'
outfile = path + '银河系x.gif'
resize_gif(path+file,outfile)

作业如下所示:

1. (25 Points) Fill in the definition of the recursive function base7digits(?) below that prints out the base 7
digits of the positive integer ?. All output will be on a single line with no spaces between the digits. Your
function need not print anything when ? ≤ 0. (Hint: this was discussed as an exercise in lecture on 4-1-
21, and in the examples on the class webpage.) 主要意思是把n转换成7进制数.

def base7digits(n):
# begin solution

2. (25 Points) Fill in the definition of the Python function sequence_gen(?, ?) below that returns a generator
object which produces the (infinite) sequence of positive multiples of ? that have remainder 1 when divided
by ?. Thus sequence_gen(3, 5) would produce the sequence: 6, 21, 36, 51, 66, 81,… . You may assume
that ? and ? are positive integers. 主要意思是定义一个生成器,产生6,21,36,51,66……,81这个序列.
def sequence_gen(a, b):

# begin solution

以下是7进制的参考答案:

def base7digits(n):
  
    n,r = divmod(n,7)
    if n !=0:
        return base7digits(n) + str(r)
    else:
        return str(r) 

print(base7digits(19)) 

以下是产生序列的参考答案:

def sequence_gen(a, b):

    n=6
    while True:
        yield n
        n = n + a*b

x = sequence_gen(3,5)
for _ in range(10):
    print(next(x),end=',')

晚是10:41了,还没洗脸和脚和刷牙,但要睡觉了!

作业描述:
CSE 30
Programming Abstractions: Python
Programming Assignment 3
In this assignment you will create a class called Lines that will be placed in a file called lines.py. Much of
the work is already done in the template file lines_stub.py, posted at
https://classes.soe.ucsc.edu/cse030/Spring21/Examples/pa3/lines_stub.py
The Line class provides an abstract representation of a line in the ??-?? coordinate plane. Included in the
above stub is the Point class we covered in the geometry.py example, also posted on the class webpage.
Your task is fill in the definitions of the methods (10 in all) belonging to the Line class, and to add one new
method to the Point class.
The Line class represents a line in the plane by maintaining two attributes: a Point object representing a
point on the line, and a numeric value giving its slope. The obvious names for these attributes are point and
slope respectively, which are used in this document, but you can give them any names you like. One logical
problem entailed by this representation is how to represent vertical lines, i.e., lines that have no numerical
value as slope. Such lines are often said to have “infinite slope” in Geometry textbooks. We will handle
this situation by simply setting the slope attribute, normally a number, to be the string ‘infinity’. This
choice will create some special cases in the design of several of the required functions, and it will be your
task to sort out these cases logically.
This project requires some familiarity with basic facts of plane geometry, but nothing more than would be
encountered in a class like MATH 3 (precalculus algebra), a prerequisite for this course. For instance, the
function parallel() in the Line class, when called as ??.parallel(??), returns True if line ?? is parallel to line
??, and False otherwise. But as is well known, two lines are parallel if and only if they have the same slope.
Another example is intersect(), contained in the Line class. The call ??.intersect(??) will return the Point
object representing the point of intersection of line ?? with line ??. This is a common homework problem in
elementary algebra, i.e., find the point of intersection of two lines whose equations are given. You must
solve the general problem: find formulas for the coordinates of the intersection point, and account for the
special cases where the lines are parallel (return None), or where one line is vertical.
The correct output for function main() is included as a comment in the above template. If your function
definitions are correct, the output will match the quoted output exactly. However, main() should not be
considered a complete test of all of the required functions. As always, you should thoroughly test every
logical pathway within every function you design, making sure that it strictly adheres to its specification.
To do this testing, you may alter main() temporarily, but be sure to return it to its original state before you
submit the file.
Once all coding and testing are complete, change the name of the file from lines_stub.py to lines.py and
submit it to Gradescope before the due date. As always, ask questions and get help early.

帮国外留学生做的一个练习,关于面向对象编程的,以下是参考答案:

import math

class Point(object):
   """在x-y平面代表一个点的类.Class representing a Point in the x-y coordinate plane."""

   def __init__(self, x, y):
      """初始化点对象。Initialize a Point object."""
      self.xcoord = x
      self.ycoord = y
   # end

   def __str__(self):
      """返回代表点的字符串表示。Return the string representation of a Point."""
      return '({}, {})'.format(self.xcoord, self.ycoord)
   # end

   def __repr__(self):
      """返回代表点的详细的字符串表示Return the detailed string representation of a Point."""
      return 'geometry.Point({}, {})'.format(self.xcoord, self.ycoord)
   # end

   def __eq__(self, other):
      """
      判断两个点是否相等。Return True if self and other have the same coordinates, False otherwise.
      """
      if not isinstance(self,Point):return False
      if not isinstance(other,Point):return False      
      eqx = (self.xcoord==other.xcoord)
      eqy = (self.ycoord==other.ycoord)
      return eqx and eqy
   # end

   def distance(self, other):
      """返回两点距离。Return the distance between self and other."""
      diffx = self.xcoord - other.xcoord
      diffy = self.ycoord - other.ycoord
      return math.sqrt( diffx**2 + diffy**2 )
   # end

   def norm(self):
      """返回到原点距离。Return the distance from self to the origin (0, 0)."""
      return self.distance(Point(0,0))
   # end

   def midpoint(self, other):
      """返回中间点。Return the midpoint of the line segment from self to other."""
      midx = (self.xcoord + other.xcoord)/2
      midy = (self.ycoord + other.ycoord)/2
      return Point(midx, midy)
   # end

   #---------------------------------------------------------------------------
   #  Fill in the definition of this function, belonging to the Point class.
   #---------------------------------------------------------------------------
   def join(self, other):
      """
      两点确定和条线。If self==other return None. Otherwise return the line passing through 
      self and other. 两点连线
      """
      if self==other:return None
      dy = other.ycoord - self.ycoord
      dx = self.xcoord - self.xcoord
      if dx ==0:
         return Line(self,'infinity')
      else:
         return Line(self,dy/dx)
   # end     

# end


#------------------------------------------------------------------------------
#  Fill in the definitions of each method in the Line class.
#------------------------------------------------------------------------------
class Line(object):
   """在x-y平面中表示线的Line类。Class representing a Line in the x-y coordinate plane."""
   
   def __init__(self, P, m):
      """初始化一根线,P表示点，m表示斜率。Initialize a Line object."""
      self.P = P                  # 线上的一个点
      self.m = m                  # 斜率
      if m=='infinity':           # 如果位子斜率无限大
         self.b = 'infinity'
      else:
         self.b = str(P.ycoord- m * P.xcoord) # 根据y = k*x + b算出在y轴上的截距
         self._b = P.ycoord- m * P.xcoord
      # end

   def __str__(self):
      """Return a string representation of a Line."""
      #return '({}, {})'.format(self.P, self.m)
      return 'Line through ({}, {}) of slope {}'.format(self.P.xcoord,self.P.ycoord,self.m)
   # end

   def __repr__(self):
      """ Return a detailed string representation of a Line."""
      #return 'geometry.Line({}, {})'.format(self.P, self.m)
      return 'lines.Line(point=({}, {}), slope={})'.format(self.P.xcoord,self.P.ycoord,self.m)
   # end

   def __eq__(self, other):
      """
      返回两线是否是同一根线。Return True if self and other are identical Lines, False otherwise.
      """
      if not isinstance(self,Line):return False
      if not isinstance(other,Line):return False
     
      # 第一种情况，都是垂直，第二种情况self垂直x轴，other不垂直x轴，第三种情况self不垂直x轴，other垂直x轴
      if self.m == 'infinity' and other.m == 'infinity' and self.P.xcoord == other.P.xcoord:return True
      if self.m == 'infinity' and  not isinstance(other.m,str):return False
      if not isinstance(self.m,str) and  other.m=='infinity' :return False      
      
      b = self.b == other.b
      m = self.m == other.m
      return b and m
   # end

   def parallel(self, other):
      """
      Return True if self and other are parallel lines, False otherwise.
      """
      if self == other:return False
      if self.m == 'infinity' and  not isinstance(other.m,str):return False
      if not isinstance(self.m,str) and  other.m=='infinity' :return False   
      return self.m == other.m
   # end

   def perpendicular(self, other):
      """
      返回两线是否垂直。Return True if self and other are perpendicular lines, False otherwise.
      """
      if self.m == 'infinity' and other.m == 0 :return True
      if self.m == 0 and other.m == 'infinity': return True
      if self.m * other.m == -1 : return True
      return False
   
   # end

   def contains_point(self, P):
      """
      返回是否包括P点。Return True if self contains point P, False otherwise.
      """
      x = P.xcoord
      y = P.ycoord
      if self.m == 'infinity':              #  如果self垂直x轴
         return self.P.xcoord == x
      else:                                 # 否则不垂直x轴            
         ycor  = self.m * x + self._b       # 根据y = k* x + b算出应该的y值
         return y == ycor
   
   # end

   def intersect(self, other):
      """
      返回交叉点。If self and other are parallel, return None.  Otherwise return their
      Point of intersection.
      """
      # 第一种情况，两者相等
      if self == other:return None
      # 第二种情况是两者都垂直x轴，但平行
      if self.m == 'infinity' and other.m == 'infinity' :return None
      # 第三种情况,斜率都为0
      if self.m==0 and other.m==0 : return None
      # 第四种情况，self垂直x轴，other不垂直x轴
      if self.m == 'infinity' and  not isinstance(other.m,str):
         x = self.P.xcoord
         y = other.m * x + other._b
      # 第五种情况，self是斜的，other垂直于x轴
      if not isinstance(self.m,str) and  other.m=='infinity' :
         x = other.P.xcoord
         y = self.m * x + self._b

      if not isinstance(self.m,str) and  not isinstance(other.m,str):
         x = (other._b - self._b) / (self.m - other.m)
         y = self.m * x + self._b
      return Point(x,y)     
      
   # end

   def parallel_line(self, P):
      """返回通过P点的平行线。Returns the Line through P that is parallel to self."""
      m = self.m
      return Line(P,m)
   # end

   def perpendicular_line(self, P):
      """返回通过P点的垂直线。Returns the Line through P that is perpendicular to self."""
      if self.m=='infinity':
         m = 0
      elif self.m==0:
         m = 'infinity'
      else:
         m = -self.m
      return Line(P,m)
      
   # end

# end


#------------------------------------------------------------------------------
#  Do not change functon main(). Its role is just to test all of the above.
#  Actually you can change it during your own independent testing, but return
#  it to exactly this state before you submit the project.
#------------------------------------------------------------------------------
def main():

   P = Point(1, 3)
   Q = Point(3, 3)
   R = Point(1, 1)
   S = Point(3, 1)
   T = Point(4, 3)
   U = Point(5, 5)
   V = Point(2, 2)
   W = Point(2, 5)
   X = Point(2, -1)

   A = Line(P, -1)
   B = Line(R, 1)
   C = S.join(T) #points_to_line(S, T)
   D = Line(W, 'infinity')               # 垂直线
   E = Line(Q, 0)
   F = C.parallel_line(P)                # 是否平行  

   print()
   print('A =', A)
   print(repr(A))
   print()
   print('B =', B)
   print(repr(B))
   print()
   print('C =', C)
   print(repr(C))
   print()
   print('D =', D)
   print(repr(D))
   print()
   print('E =', E)
   print(repr(E))
   print()
   print('F =', F)
   print(repr(F))

   print()
   print(B.intersect(C)==U)
   print(A.intersect(B)==V)
   print(D.intersect(C)==X)
   print(D.intersect(Line(T,'infinity'))==None)
   print(A.perpendicular(B))
   print(D.perpendicular(E))
   print(A.parallel(B.perpendicular_line(Q)))
   print(A.contains_point(S))
   print(B.contains_point(U))
   print(C.contains_point(X))
   print(F.contains_point(W))

   print()

# end

#------------------------------------------------------------------------------
if __name__=='__main__':

   main()

帮国外留学生写的代码，这代码写了很多次。正所谓，温故而知新，可以为师矣。
解法一：

import time

def init(n):
    n = int(n)
    row = [0] * (n+1)
    box = []
    for i in range(n+1):
        box.append(list(row))            # 每一行的索引为0的值缺省为1，记录此行皇后索引号的
    
    return box

def is_safe(B,i,j):
    n = len(B)-1    
    direction = [(-1,-1),(-1,0),(-1,1)]
    
    for d in direction:
        dx,dy = d
        r = i                # 行
        c = j                # 列  
        while True:
            r = r + dx
            c = c + dy
            if r>=1 and r<=n and c>=1 and c<=n:
                if B[r][c]==1 :                    
                    return False
            else:               
                break    
    return True
            
def printBoard(B):
    
    n = len(B)-1
    s = [B[i][0] for i in range(1,n+1)]
    print(tuple(s))
        
def removeQueen(B,i,j):
    """移除i行的皇后"""
    
    for x in range(1,len(B)):
        B[i][x] = 0
        
def placeQueen(B,i,j):
    """放皇后，首先移除i行的皇后"""
    removeQueen(B,i,j-1)

    B[i][j] = 1
    B[i][0] = j


def findSolutions(B,i,mode=None):
    
    global acc_sum    
    n = len(B)-1
    if i > n:
        if mode=='-v':            
            printBoard(B)        
            acc_sum += 1
        return 1
    else:
        for j in range(1,len(B)):           
            if is_safe(B,i,j):                 
                placeQueen(B,i,j)                
                findSolutions(B,i+1,mode)
          
    return acc_sum

def main():
    import sys
    p = sys.argv
    p = ['Queen.py','-v','5']
    if len(p)==1:
        print("Usage: python3 Queens.py [-v] number")
    elif len(p)==2:
        if p[1].isnumeric():
            a = init(p[1])            
            findSolutions(a,1)
            print(f"{p[1]}-Queens.py has {len(box)} solutions")
        else:
            print("Usage: python3 Queens.py [-v] number")
    else:
        a = init(p[2])
         
        findSolutions(a,1,p[1])
         
        print(f"{p[2]}-Queens.py has {acc_sum} solutions")
        
if __name__ == '__main__':
   acc_sum = 0
   main()

      

八皇后问题解决法二：

import sys

def no_conflict(board,row,col):
    """检测row行，col列上的皇后是否和其它的皇后有冲突"""
    i = 0
    while i < row:
        if abs(col-board[i]) in (0,abs(row-i)):
            return False
        i += 1
    return True

def EightQueen(board,row):
    global box
    blen = len(board)
    if row == blen:               # 索引为8了，则输出一个方案
        box.append(tuple(board))
        return True
    col = 0
    while col < blen:
        if no_conflict(board,row,col):  # 如果没有冲突，则摆一颗皇后
            board[row] = col
            EightQueen(board,row+1)     # 摆下一行                
        col += 1                        # 同一行，下一列

def main():
    global box    
    p = sys.argv
    p = ['Queen.py','-v','7']
    if len(p)==1:
        print("Usage: python3 Queens.py [-v] number")
    elif len(p)==2:
        if p[1].isnumeric():
            a = [None]*int(p[1])
            EightQueen(a,0)
            print(f"{p[1]}-Queens.py has {len(box)} solutions")
        else:
            print("Usage: python3 Queens.py [-v] number")
    else:
        a = [None]*int(p[2])
        EightQueen(a,0)
        for b in box:
            print(b)
        print(f"{p[2]}-Queens.py has {len(box)} solutions")
            
if __name__== '__main__':

    box = []
    main()