python21-循环小作业

课程：B站大学
记录python学习，直到学会基本的爬虫，使用python搭建接口自动化测试就算学会了，在进阶webui自动化，app自动化

循环语句小作业

for-in作业
- 斐波那契 for
固定数值计算
素数
字符统计
数字序列
- range 函数
水仙花数
循环嵌套
冒泡排序
选择排序
数字组合
循环跳转 for else
猜数字
字典实现（解析字典）
非固定数值计算
回文数
实践是检验真理的唯一标准

for-in作业

斐波那契 for

作业要求：编写一个Python程序，使用for循环，生成并输出斐波那契数列的前n项，其中n是用户指定的正整数。斐波那契数列，又称黄金分割数列，指的是：1、1、2、3、5、8、13、21、34…从第三个数开始，每个数字都是前两个数字之和。

# 用户输入
n = int(input("请输入正整数 n："))

# 初始化斐波那契数列
fibs = [1, 1]

# 生成数列
for i in range(2, n):
    next_num = fibs[i - 1] + fibs[i - 2]
    fibs.append(next_num)

# 输出结果
print(f"斐波那契数列的前 {n} 项为：{fibs}")

固定数值计算

作业要求：对数字列表中数字的求和，求平均值，求最值，求最小值

def case_2():
    nums = [12,34,3,6,56,33434,6,3,23,23,23,57,78,11,1,8,9]
    sum = 0
    avg = None
    max_num = nums[0]
    min_num = nums[0]

    for n in nums:
        sum += n
        if n > max_num:
            max_num = n

        if n < min_num:
            min_num = n

    print("SUM:", sum)
    avg = sum / len(nums)
    print("AVG:", avg)
    print("MAX:", max_num)
    print("MIN:", min_num)

素数

作业要求：编写一个Python程序，输入一个正整数，判断这个数是否为素数（质数）。素数是指只能被1和它本身整除的正整数。

import math

# 用户输入正整数
num = int(input("请输入一个正整数："))

# 判断是否为素数
def is_prime(n):
    if n <= 1:
        return False  
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False  
    return True  

# 输出结果
if is_prime(num):
    print(f"{num} 是素数")
else:
    print(f"{num} 不是素数")

字符统计

作业要求：
从键盘输入一个字符序列，统计，大写字母，小写字母，数字，其它字符各出现次数，将次数保存到字典中。

def func2():
    data = input("请输入数据：")
    count = {
        "DX":0,
        "XX":0,
        "SZ":0,
        "QT":0
    }

    data  = list(data)
    print(data)

    for c in data:
        if c >= '0' and c <= '9':
            count["SZ"] += 1
        elif c >= 'A' and c <= 'Z':
            count["DX"] += 1
        elif c >= 'a' and c <= 'z':
            count["XX"] += 1
        else:
            count["QT"] += 1

    print(count)

数字序列

range 函数

range() 函数是一个用于生成整数序列的内置函数，通过指定起始值、停止值和步长，它能够生成一个按照指定规则递增或递减的整数序列。
for-in 结合 range 函数实现计次循环

result = 0
for i in range(1, 101):
    result += i

print(result)

Python 中，可以使用 random 模块中的 randint() 函数获取随机数。

from random import randint
print(randint(1, 3))

小tips：

from random import randint

play = int(input("请输入一个1-6之间的数字："))
bot = randint(1, 6)

if play == bot:
    print("点数相同，平局")
elif play > bot:
    print(f"玩家{play}点，电脑{bot}点，玩家胜")
else:
    print(f"玩家{play}点，电脑{bot}点，电脑胜")

水仙花数

作业要求：编写一个 Python 程序，找出100-999范围内的水仙花数。所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

for n in range(100, 1000):
    # 获取百位数
    i = n // 100   

    # 获取十位数
    j = n // 10 % 10  

    # 获取个位数
    k = n % 10  

    # 判断是否为水仙花数
    if n == i**3 + j**3 + k**3:  
         # 输出水仙花数
        print(n)

循环嵌套

循环嵌套特征

循环嵌套不局限于某种循环形式，可任意相互嵌套
外层循环循环一次，内层循环循环一轮
使用 for-in 循环遍历二维列表

data = [
    [1,2,3,4,5,6,7,8,9],
    ["A","B","C","D","E"],
    ["Hello","World","Python","Hogwarts"]
]
for item in data:
    for el in item:
        print(el)

使用 while 循环遍历二维列表

data = [
    [1,2,3,4,5,6,7,8,9],
    ["A","B","C","D","E"],
    ["Hello","World","Python","Hogwarts"]
]
l1 = len(data)
i = 0
while i < l1:
    item = data[i]
    l2 = len(item)
    j = 0
    while(j < l2):
        el = item[j]
        print(el)
        j += 1
    i += 1

冒泡排序

def bubbleSort(obj, key=None, reverse=False):
    length = len(obj)
    # 外层循环用来确定找出剩余数据的最大值，N个数，找n-1次即可
    for i in range(length-1):
        for j in range(length-i-1):
            if key:  # if key != None:
                if key(obj[j]) > key(obj[j + 1]):
                    obj[j], obj[j + 1] = obj[j + 1], obj[j]
            else:
                if obj[j] > obj[j+1]:
                    obj[j], obj[j+1] = obj[j+1], obj[j]
    # return obj if not reverse else obj[::-1]
    if reverse:
        return obj[::-1]
    else:
        return obj

选择排序

def xuanze():
    data = [1,56,6,5,4,89,2]
    length = len(data)
    for i in range(length-1):
        small = data[i]
        for j in range(i+1,length):
            if data[j]<small:
                idx = j
                data[idx],data[i] = data[i],data[idx]
    return data

result = xuanze()
print(result)

数字组合

**for i in range(1, 5):
    for j in range(1, 5):
        for k in range(1, 5):
            # 条件判断排除重复数字的排列
            if (i != k) and (i != j) and (j != k):
                print(i, j, k)
**

循环跳转 for else

names = ["tom","jack","rose","tony"]

inName = input("请输入要查找的姓名：")

# 不使用 else 形式
flag = False
for name in names:
    if name == inName:
        print("找到了")
        flag = True
        break
if not flag:
    print("没找到")

# 使用 else 形式
for name in names:
    if name == inName:
        print("找到了")
        break
else:
    print("没找到")

猜数字

import random

# 生成目标数字
target_number = random.randint(1, 100)

# 初始化猜测次数
guess_count = 0

while True:
    # 接收玩家输入
    guess = int(input("请输入你的猜测数字："))

    # 增加猜测次数
    guess_count += 1

    # 判断猜测结果
    if guess == target_number:
        print(f"恭喜你猜对了！目标数字是 {target_number}，你共猜了 {guess_count} 次。")
        break
    elif guess < target_number:
        print("猜小了，请继续猜测。")
    else:
        print("猜大了，请继续猜测。")

字典实现（解析字典）

def func3():
    txt = '''#a
    Trans:art. 一;字母A
    #a.m.
    Trans:n. 上午
    #a/c
    Trans:n. 往来帐户@往来:come - and - go; contact; intercourse@n. 往来帐户
    #aardvark
    Trans:n. 土猪
    #aardwolf
    Trans:n. 土狼
    #aasvogel
    Trans:n. 秃鹰之一种
    #abaci
    Trans:n. 算盘
    #aback
    Trans:ad. 向后地;朝后地
    #abacus
    Trans:n. 算盘
    #abaft
    Trans:ad. 向船尾@prep. 在...后
    #abalone
    Trans:n. 鲍鱼
    #abandon
    Trans:vt. 放弃;沉溺@n. 放任
    #abandoned
    Trans:a. 被抛弃的;自弃的;自甘堕落的
    #abandonee
    Trans:n. 被遗弃者;被委付者
    #abandoner
    Trans:n. 遗弃者;委付者
    #abandonment
    Trans:n. 放弃;自暴自弃;放纵
    #abas
    Trans:vt. 打倒
    #abase
    Trans:vt. 降低...的地位;降低...的品格;贬抑
    #abasement
    Trans:n. 贬抑;屈辱;谦卑
    #abash
    Trans:vt. 使...羞愧;使困窘
    #abashment
    Trans:n. 羞愧;
    #abate
    Trans:vt. 缓和;减弱;减少;废除@vi. 缓和;减弱;减少
    #abatement
    Trans:n. 减少;减轻;缓和
    #abatis
    Trans:n. 鹿柴;拒木;铁丝网
    #abatment
    Trans:n. 消除，减除
    #abb
    Trans:n. 横丝;纬;羊毛
    #abbacy
    Trans:n. 大修道院院长之职位;管区;任期
    #abbatial
    Trans:a. 大修道院的;大修道院长的;女大修道院长的
    #abbe
    Trans:n. 大修道院院长;僧侣;神父
    #abbess
    Trans:n. 女修道院院长;女庵主持
    #abbey
    Trans:n. 修道院
    #abbot
    Trans:n. 修道院院长;方丈;住持
    #abbreviate
    Trans:vt. 缩写;使...简略;缩短
    #abbreviation
    Trans:n. 缩写
    #abbreviator
    Trans:n. 缩写者
    #abc
    Trans:n. 基础知识;美国广播公司;澳大利亚广播公司
    #abcoulomb
    Trans:n. 绝对库伦
    #abdicate
    Trans:vt. 放弃@vi. 逊位
    #abdication
    Trans:n. 逊位;弃权;辞职
    #abdicator
    Trans:n. 放弃者;让位者
    #abdomen
    Trans:n. 腹部
    #abdominal
    Trans:a. 腹部的;腹式呼吸;开腹手术
    #abduct
    Trans:vt. 诱拐;绑走
    #abduction
    Trans:n. 诱拐
    #abductor
    Trans:n. 诱拐者
    #abe
    Trans:n. 亚伯;Abraham 的昵称
    #abeam
    Trans:ad. 与船的龙骨成直角
    #abecedarian
    Trans:n. 初学者@a. 字母的;初步的
    #abed
    Trans:ad. 在床上
    #abelmosk
    Trans:n. 秋葵
    #aberrance
    Trans:n. 脱离正道;越轨;脱离常轨
    #aberrant
    Trans:a. 脱离正道的;脱离常轨的;变体的
    #aberration
    Trans:n. 越轨;光行差;心理失常;色差
    #abestrine
    Trans:adj. 石棉的
    #abet
    Trans:vt. 教唆;帮助'''

    data = txt.split("\n    #")
    myDict = {}
    for item in data:
        # 处理第一个单词字符串
        if item.startswith("#"):
            item = item[1:]
        # 拆分单词项
        k, w = item.split("\n    Trans:")
        myDict[k] = w

    inw = input("请输入一个单词：")
    if  inw in myDict:
        trans = myDict[inw]
        print(trans)
    else:
        print("输入的单词不存在")

非固定数值计算

def case_3():
    sum = 0
    avg = None
    num = 0
    max_num = None
    min_num = None

    while True:
        flag = False
        n = input("请输入数字：")
        print(type(n))
        if n == "bye":
            break
        else:
            if n.startswith("-"): # -123123
                n = n[1:] # 123123
                flag = True

            if n.isdigit():
                n = int(n)
                if flag == True:
                    n *= -1
                num += 1
                sum += n

                if max_num == None:
                    max_num = n
                elif max_num < n:
                    max_num = n

                if min_num == None:
                    min_num = n
                elif max_num > n:
                    min_num = n

回文数

作业要求：编写一个Python程序，输入一个5位数，判断输入的这个数字是否为回文数。回文数是指从左到右和从右到左读都一样的数。例如12321。如果输入的是回文数，输出是回文数，否则输出不是回文数。（使用循环进行实现）

a = int(input("请输入一个数字:\n"))
x = str(a)
flag = True

# 遍历字符串的一半字符
for i in range(len(x) // 2):
    if x[i] != x[-i - 1]:
        # 如果字符不相同，将标志变量设为False 并退出循环
        flag = False
        break

if flag:
    print(f"{a} 是一个回文数!")
else:
    print(f"{a} 不是一个回文数!")