关于切片/截取（slice）和random模块的使用（实例：猜单词小游戏）

切片和random的使用在源码中都有注释（可以直接下载）：https://github.com/NoobZeng/GuessWords

1. README.MD

• 基于Python的猜单词游戏
• 猜单词小游戏
• 主要使用random模块、切片slice
• random模块的基础使用：demo_random.py
• 切片的基础使用：demo_slice.py
• 游戏运行play.py或者test.py
• play和test不同地方是乱序单词的组合，前者用random.randrange()和切片的方式，后者使用random.sample()和join方法的方式

2. 切片的简单使用

# !/usr/bin/env python
# ! _*_ coding:utf-8 _*_
# @TIME   : 2019/9/10  6:13
# @Author : Noob
# @File   : demo_slice.py

# python中符合序列的有序序列都支持切片（slice）
# 如：字符串、列表（list）、元祖（tuple）
# 格式：[start: end: step]
# start：起始索引，从0开始，-1表示结束
# end：结束索引，切片结果不包含结束索引，即不包含最后一位，-1代表最后一个位置索引
# step：步长，可以不提供，默认值是1，但是值不能为0，不然会报错ValueError: slice step cannot be zero
# end-start=正数时，从左向右取值，end-start=负数时，反向取值

"""
举例：字符串
"""
str_slice = "python"

print("1. 全部截取")
str1 = str_slice[:]
print(str1)
# python

print("2. 从0开始到3，每次增加1截取，不包含索引结束的位置")
str2 = str_slice[0: 3: 1]
print(str2)
# pyt

print("3. 从0到倒数第二位，每次增加2截取，不包含索引结束的位置")
str3 = str_slice[0: -1: 2]
print(str3)
# pto

print("4. 默认从起始位置索引，每次增加1截取，结束索引为3，省略步长")
str4 = str_slice[: 3]
print(str4)
# pyt

print("5. 反向取值，每次增加1截取，不包含索引结束位置")
str5 = str_slice[3: 0: -1]
print(str5)
# hty

print("6. 从索引3开始到结束索引，省略步长1")
str6 = str_slice[3:]
print(str6)
# hon

demo_slice.py

3. random模块的简单使用

# !/usr/bin/env python
# ! _*_ coding:utf-8 _*_
# @TIME   : 2019/9/10  6:13
# @Author : Noob
# @File   : demo_random.py

import random

# 1. 生成一个随机小数n，n大于等于0小于1.0
print("1. random.random()：生成一个随机小数n，n大于等于0小于1.0")
n = random.random()
print(n)

# 2. 生成一个指定范围内的小数，两个参数中一个是上限一个是下限
# 如果a<b，则生成的随机数n的范围在a<=n<=b
# 如果a>b，则生成的随机数n的范围在b<=n<=a
print("2. random.uniform(a, b)：生成一个指定范围内的小数，两个参数中一个是上限一个是下限")
n = random.uniform(10, 20)
print(n)
n = random.uniform(20, 15)
print(n)

# 3. 生成一个指定范围内的整数，其中参数a是下限，参数b是上限，生成的随机数范围在a<=n<=b
print("3. random.randint(a, b)：生成一个指定范围内的整数")
n = random.randint(5, 9)
print(n)

# 4. 从指定范围内按指定基数递增的集合中获取一个随机数（有点类似于有序列表的切片），start包含在范围内，stop不包含在范围内
print("4. random.randrange([start], stop[, step])：从指定范围内按指定基数递增的集合中获取一个随机数")
n = random.randrange(2, 10, 3)
print(n)

# 5. 重序列中获取一个随机元素，其原型为random.choice(sequence)，参数sequence标识一个有序类型。泛指序列数据结构，
# 字符串、列表、元祖都属于sequence。
print("5. random.choice(sequence)：从序列中获取一个随机元素")
n = random.choice("hello world")
print(n)
n = random.choice(("java", "C", "C++", "php"))
print(n)
n = random.choice(["java", "C", "C++", "php"])
print(n)

# 6. 打乱列表中的元素，shuffle()返回的是none，只是该函数改变了原列表数据的顺序
print("6. random.shuffle(x[, random)：打乱列表中的元素")
a = [1, 2, 3, 4, 5]
n = random.shuffle(a)
print(n)  # None
print(a)

# 7. 从指定序列中随机获取指定长度的片段，sample()函数不会修改原有序列
print("7. random.sample(sequence,k)：从指定序列中随机获取指定长度的片段")
a = "abcdefg"
n = random.sample(a, 3)
print(n)
print(a)

demo_random.py

4. 猜单词游戏（1）play.py

# !/usr/bin/env python
# ! _*_ coding:utf-8 _*_
# @TIME   : 2019/9/10  3:51
# @Author : Noob
# @File   : play.py

# 导入random模块
import random

# 创建单词序列
words = ("python", "java", "peal", "vue", "http", "javascript", "php", "cplus")

# 开始游戏
print(
    """
    欢迎参加猜单词游戏
    把字母组合成一个正确的单词
    """
)

iscontinue = "y"

while iscontinue == 'y' or iscontinue == 'Y':
    # 从序列中随机抽出一个单词
    word = random.choice(words)
    # 一个用于判断玩家是否才对的变量
    correct = word
    # 创建乱序后单词
    jumble = ""
    while word:  # word不是空串循环
        # 根据word长度产生word的随机位置
        position = random.randrange(len(word))
        # 将position位置的字母组合到乱象需后单词
        jumble += word[position]
        # 通过切片将position位置的字母从元单词中
        word = word[:position] + word[(position+1):]
    print("乱序后单词：", jumble)

    guess = input("\n请你猜：")
    while (guess != correct and guess != "") or (guess == ""):
        print("对不起不正确.")
        guess = input("继续猜：")
    if guess == correct:
        print("真棒，你猜对了！")
    iscontinue = input("\n是否继续（Y/N)：")

play.py

5. 猜单词游戏（2）test.py

# !/usr/bin/env python
# ! _*_ coding:utf-8 _*_
# @TIME   : 2019/9/10  22:16
# @Author : Noob
# @File   : test.py

import random

# 开始游戏
print(
    """
    欢迎参加猜单词游戏
    把字母组合成一个正确的单词
    """
)

# 判断游戏是否继续的标识
iscontinue = "y"
words = ["fiddler", "myeclipse", "pycharm", "sumblim", "jmeter", ""]
# 去掉单词库中的空字符串
# words = list(filter(None, words))

while iscontinue == "y" or iscontinue == "Y":
    # 判断词库列表长度
    if len(words) != 0:
        # 随机抽取一个单词
        word = random.choice(words)
        # 词库出现为空的单词就跳过
        if word == "" and len(words) != 1:
            continue
        elif word == "" and len(words) == 1:
            print("单词已经全部猜完，结束游戏！！！")
            break
        # random.sample(sequence, k)：随机获取指定长度的序列片段，得到的是一个数组，且不会修改到原序列
        # 通过join方法重新拼合成一个字符串，是乱序后的单词
        jumple = "".join(random.sample(word, len(word)))
        print("\n" + jumple)
        # 用于判断输入单词是否正确的标识
        correct = input("请输入该单词的正确拼写：")
        while correct != word:
            correct = input("猜错了，请思考后继续：")
        print("恭喜猜对了！！！")
        # 猜完后将该单词移出列表
        words.remove(word)
        if len(words) != 0:
            iscontinue = input("是否继续（Y/N）：")
    else:
        print("单词已经全部猜完，结束游戏！！！")
        break

test.py

转载于:https://www.cnblogs.com/noobzeng/p/11508400.html