代码收藏家技术教程 2025-06-21

Python学习秘籍：咒语大全与实用指南

字符串格式限制，%xd（整数），%x.yf（小数点浮点数）

f“内容{变量}快速格式化

案例1：股价预测

INPUT语句

案例2：INPUT登陆界面语句

布尔类型函数基础运用

案例3:比较运算符的运用

IF语句基本格式

案例4:IF语句+INPUT语句练习

案例5:IF ELSE语句

案例6:IF ELIF ELSE语句

案例7:猜数字小游戏

案例8:IF ELSE嵌套规则

案例9:IF ELSE嵌套（符合工龄的员工可享受旅游）

案例10:IF ELSE嵌套（随机猜数字小游戏）

WHILE 循环语句(附题1-100总和)

案例11:WHILE 循环猜数字并统计参与次数

案例12:WHILE 嵌套语句循环应用（给猫送礼物案例）

end=' '与\t的应用

案例13:九九乘法表While循环

FOR循环语句（遍历循环/依次循环）

案例14:统计以下文字有几个a（FOR循环）

Range语句

案例15:While语句与For语句的区别（玫瑰花案例）

案例16:判断有多少个偶数和奇数

案例17:FOR循环嵌套(减肥案例)

案例18:FOR与WHILE两个一起循环嵌套

案例19:九九乘法表FOR循环

CONTINUE和BREAK中断

案例20:循环综合（发放绩效5分以上的人发1w奖金）

lenth函数

定义函数

函数的传入参数

案例21:函数练习（升级版自动查核酸）

函数返回值

函数返回值None类型

函数的说明文档

函数的嵌套调用

函数的全局变量和局部变量

案例22:函数综合案例（存钱/取钱/余额）

数据容器以及列表定义

列表的下标索引

列表的常用操作（append/extend/insert/del/remove/pop/count/index/len）

案例23：年龄列表

While和FOR遍历函数

元组的基本操作

案例24:元组应用（'周杰伦'，11，['football','music']）

字符串的定义和操作

数据容器（序列）的切片

案例25:序列的切片练习

集合的定义与操作

案例26：集合案例

案例27：字典案例

字典的常用操作

案例28:字典案例实践（升职加薪）

数据容器的通用操作（列表/字典/集合/字符串/元组）

演示字符串大小比较

函数的多返回值

函数的多种参数使用形式

函数作为参数传统

Lambda匿名函数

文件的读取方法

案例29:文件读取并统计

文件的写出操作

文件的追加写入文件

案例30:文件操作的综合案例

异常的捕获

异常的传递性

模块的概念与导入

自定义模块并导入

自定义Python包

案例31:功能模块包的综合案例

字符串格式限制，%xd（整数），%x.yf（小数点浮点数）

num1=11
num2=11.345
print("数字11宽度限制5，结果是：%5d " % num1)
print("数字11宽度限制1，结果是：%1d " % num1)
print("数字11.345宽度限制7,小数精度2，结果是：%7.2f"  % num2)
print("数字11.345宽度不限制,小数精度2，结果是：%.2f" % num2)

f“内容{变量}快速格式化

name = "桑迪"
set_up_year = 2018
stock_price =19.88
print(f"我是{name},成立于:{set_up_year}年,我今天的股票价格是：{stock_price}")
print("2*10 的结果是：%d" %(2 * 10))
print(f"2*8 的结果是：{2*8}")
print("字符串在Python中的类型名是：%s" % type("字符串"))

案例1：股价预测

#自己做的（略有瑕疵）
name = "上海搜猫"
stock_price = 20.36
stock_code = 398238432
stock_price_daily_growth_factor = 1.27
growth_days = 16
sum = 20.32
print(f"公司名{name},当前股票价格是：{stock_price}，股票代码：{stock_code},每日增长系数为{stock_price_daily_growth_factor},经过{growth_days}天后")
print(f"股票高达:%2.2f" % sum)

#官方答案（正确运算）
name = "上海搜猫"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7

finally_stock_price =stock_price *stock_price_daily_growth_factor ** growth_days

print(f"公司名{name},当前股票价格是：{stock_price}，股票代码：{stock_code},每日增长系数为{stock_price_daily_growth_factor},经过{growth_days}天后")
print("每日增长系数：%.1f , 经过%d天的增长后，股票达到了： %.2f" %(stock_price_daily_growth_factor,growth_days,finally_stock_price))

INPUT语句

print("请告诉我你是谁？")
name = input()
print("我知道了,你是:%s" % name)
同样，也可以直接用input语句写码
name = input("请告诉我你是谁？")
print("我知道了,你是:%s" % name)
如果是输入数据类型
num = input("请告诉我你的银行卡密码：")
print("你的银行卡密码的类型是： ",type(num))
数据类型转换
num = input("请告诉我你的银行卡密码：")
num= int(NUM)
print("你的银行卡密码的类型是： ",type(num))

案例2：INPUT登陆界面语句

user_name = "桑迪"
user_type = "SVIP"
print(f"您好，{user_name},您是我们是尊敬的{user_type}用户，我爱你")

布尔类型函数基础运用

bool_1 = True
bool_2 = False
print(f"bool_1的变量内容是：{bool_1},类型是：{type(bool_1)}")
print(f"bool_1的变量内容是：{bool_2},类型是：{type(bool_2)}")

案例3:比较运算符的运用

#==相等
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{num1==num2}")
#!=不相等
num3 = 15
num4 = 20
print(f"10 != 15的结果是：{num3 != num4}")
#字符串==相等
name1 = "Sandy"
name2 = "Gulangyu"
print(f"Sandy == Gulangyu 的结果是：{name1 == name2}")
#><比较
num5 = 15
num6 = 5
print(f"10 > 5的结果是：{num5 > num6}")
print(f"10 < 5的结果是：{num5 < num6}")
#>=与<=比较
num7 = 25
num8 = 25
print(f"25 <= 25的结果是：{num7 <= num8}")
print(f"25 >= 25的结果是：{num7 >= num8}")

IF语句基本格式

age = 20
print(f"我今天已经{age}岁了")
if age >= 18:
    print("我是成年人")
    print("即将仗剑走天涯")
print("岁月如梭，往事只能回忆")

案例4:IF语句+INPUT语句练习

#自己写的
print("欢迎来到猫咪魔幻世界！请告诉我你的年龄")
age = input()
print("我知道了,你的年龄是:%s" % age)
age = int(age)
if age >= 18:
    print("您已成年")
    print("游玩需要购买门票60元")
print("祝您游玩愉快！")

#官方写的，加上了if else语句，else和if是同级别，没有缩进
age = int(input("请输入你的年龄: "))
if age >= 18 :
    print("您已成年，游玩需要买票")
else:
    print("您未成年，可以免费游玩")
print("祝您游玩愉快！")

案例5:IF ELSE语句

height = int(input("请输入您的身高（cm）"))
if height >= 120 :
    print("您是个大个子，需要支付门票120元")
else :
    print("小朋友，尽情玩耍吧！")
print("祝您游玩愉快！")

案例6:IF ELIF ELSE语句

#elif语句可以写多条，进行多条选择（每一条一个个都会展示）
height = int(input("请输入您的身高（cm）"))
vip_level =int(input("请输入您的VIP级别"))
day = int(input("请告诉我今天是几号"))
if height < 120 :
    print("您是个小孩子，可以免门票")
elif vip_level > 3 :
    print("您的VIP会员级别大于3，可以免门票")
elif day == 1:
    print("今天是1号免费日，可以免费游玩")
else :
    print("快交钱！快交钱")
print("祝您游玩愉快！")
#以上代码的简写版本（代码只要满足前一个，后面就不会继续执行了）
if int(input("请输入您的身高（cm）")) < 120 :
    print("您是个小孩子，可以免门票")
elif int(input("请输入您的VIP级别")) > 3 :
    print("您的VIP会员级别大于3，可以免门票")
elif int(input("请告诉我今天是几号")) == 1:
    print("今天是1号免费日，可以免费游玩")
else :
    print("快交钱！快交钱")
print("祝您游玩愉快！")

案例7:猜数字小游戏

num = 8
if int(input("请猜一个数字")) == num:
    print("恭喜第一次数据就猜对了呢")
elif int(input("猜错了，请再猜一次：")) == num :
    print("猜对了")
elif int(input("猜错了，请再猜最后一次：")) == num :
    print("最后一次，你终于对了！")
else:
    print("你是大笨蛋，快交钱！")

案例8:IF ELSE嵌套规则

#嵌套（当外层if满足条件时，才会执行内层if的判断；若if不满足条件，直接执行外层esle）
print("欢迎来到冒险家乐园！")
if int(input("请输入您的身高（cm）")) > 120 :
    print("您不是小孩子，不可以免门票哦")
    print("您的VIP会员级别大于3，可以免门票")
    if int(input("请输入您的VIP级别")) > 3 :
        print("您的VIP会员级别大于3，可以免门票")
    else:
        print("快交钱！快交钱")
else:
    print("欢迎小朋友免费游玩")
print("祝您游玩愉快！")

案例9:IF ELSE嵌套（符合工龄的员工可享受旅游）

#自己写的
age = int(input("请输入年龄"))
year = int(input("请输入工龄"))
level= int(input("请输入级别"))

if age >= 20:
    print("成年人一枚")
    if age <= 60 :
        print("年龄符合标准")
        if year >=3 :
            print("年龄符合标准，工龄也符合满足条件")
        else:
            print("工龄不符合旅游条件")
    elif level > 5:
        print("资历级别达到P5级别")
    else:
        print("年龄过大或级别不达标，不可以参加团建旅行")
else:
    print("Sorry啦，你再熬一熬吧！")

#官方答案
age = 20
year = 3
level =1
if age >= 18 :
    print("你已经是成年人了！")
    if age < 60 :
        print("你的年龄也达标了！")
        if year >3:
            print("恭喜你，年龄和入职时间都达标了，可以参加旅游")
        elif level >=5:
            print("恭喜你，年龄、级别达标，可以参加旅游")
        else:
            print("不好意思，年龄达标，入职时间和级别不达标")
    else:
        print("不好意思，年龄太大了")
else:
    print("不好意思，你还没有成年")

案例10:IF ELSE嵌套（随机猜数字小游戏）

#自己写的,问题多多
import random
num = random.randint(1,10)
num1 =int(input("请在1-10中随机输入一个数字："))
if num1 == num :
    print("恭喜你，一次性答对")
elif num1 > num:
    print("您输入的数字大于原来的数字，还有2次机会")
    if num1 ==num :
        print("恭喜你，把握住了第2次的机会")
    elif num1  > num:
        print("您输入的数字大于原来的数字，还有最后1次机会")
    elif num1  < num:
        print("您输入的数字小于原来的数字，还有最后1次机会")
        if num1  == num:
            print("恭喜你，把握住了最后一次的机会")
        elif num1  > num:
            print("您输入的数字大于原来的数字，game over")
        elif num1 < num:
            print("您输入的数字小于原来的数字，还game over")
elif num1  < num:
    print("您输入的数字小于原来的数字，还有2次机会")
    if num1  ==num :
        print("恭喜你，把握住了第2次的机会")
    elif num1  > num:
        print("您输入的数字大于原来的数字，还有最后1次机会")
    elif num1  < num:
        print("您输入的数字小于原来的数字，还有最后1次机会")
        if num1  == num:
            print("恭喜你，把握住了最后一次的机会")
        elif num1  > num:
            print("您输入的数字大于原来的数字，game over")
        elif num1  < num:
            print("您输入的数字小于原来的数字，还game over")
print("欢迎再次来玩！")

#官方写的
import random
num = random.randint(1,10)
guess_num = int(input("请在1-10中随机输入一个数字："))
if guess_num == num :
    print("恭喜第一次就猜中了")
else :
    if guess_num >num :
        print("你猜的数字大了")
    else:
        print("你猜的数字小了")

    guess_num = int(input("再次输入你需要的数字："))
    if guess_num == num :
        print("恭喜第二次猜中了")
    else:
        if guess_num > num:
            print("你猜的数字大了")
        else:
            print("你猜的数字小了")

        guess_num = int(input("第三次输入你需要的数字："))
        if guess_num == num:
            print("恭喜第三次猜中了")
        else:
            print("三次机会用完了，请购买复活币")

WHILE 循环语句(附题1-100总和)

i=0
while i<100 :
    print("nakdnjasd")
    i+=1
#求1-100的和
sum = 0
i=1
while i<=100:
    print("nakdnjasd")
    sum += i
    i += 1
print(f"1-100的累加是：{sum}")

案例11:WHILE 循环猜数字并统计参与次数

import random
num = random.randint(1,100)
count = 0
#设置一个True的循环标志
flag =True
while flag:
    guess_number =int(input("请随机输入1-100一个数字："))
    count += 1
    if guess_number == num:
        print("猜中了")
        #设置为False是终止循环的条件
        flag = False
    else :
        if guess_number > num:
            print("猜大了，重来")
        else:
            print("猜小了，重来")
print(f"你总共猜测了{count}次")

案例12:WHILE 嵌套语句循环应用（给猫送礼物案例）

i = 1
while i <=5 :
    print(f"今天是第{i}天，准备养猫")
    #内层循环的变量
    j = 1
    while j <= 10:
        print(f"送给猫咪第{j}包猫粮")
        j += 1
    print("小猫咪，我热爱你")
    i += 1
print(f"坚持到第{i-1}天时，小猫咪主动和我回家")

end=' '与\t的应用

#end=' '两行内容可以并列一行文字
print("你长得真好看 ",end='')
print("我对你一见钟情",end='')

#\t可以让多行字符串对齐
print("你长得\t真好看 ")
print("我对\t你一见钟情")
print("You are\tmy sunshine ")
print("I am a\tbig big girl")
print("You are\tmy sunshine ")
print("I am \tbig girl")

案例13:九九乘法表While循环

#定义外层循环
i = 1
while i<=9 :

    #定义内循环
    j = 1
    while j <= i :
        #内层循环的print语句,不要换行,通过\t制表符进行对齐
        print(f"{j}*{i} = {j*i}\t",end='')
        j += 1

    i += 1
    print()#print啥呀不输出，就是输出一个换行

FOR循环语句（遍历循环/依次循环）

#for循环无法构建无限循环
name = "飘来的云真漂亮"
#将name的内容依次取出赋予x临时变量
for x in name :
    print(x)

案例14:统计以下文字有几个a（FOR循环）

#数一数以下文字有几个a
name = "I have an apple and a banana"
#定义一个变量，统计有多少个a
count = 0
for x in name :
    if x == "a":
        count += 1

print(f"总共有几个a：{count}")

Range语句

#range语法1：range(num)
for x in range(10):
    # 从0开始到10结束（不包含10本身）
    print(x)
#range语法2：range(num1,num2)
for y in range(5,10):
    #从5开始到10结束（不包含10本身，数字间隔为默认1）
    print(y)
#range语法3：range(num1,num2,step)
for m in range(5,10,2):
    # 从5开始到10结束（不包含10本身，数字间隔为2）
    print(m)

案例15:While语句与For语句的区别（玫瑰花案例）

#WHILE语句循环
i = 1
while i<=10:
    print("送玫瑰花")
    i += 1
#FOR语句循环
for x in range(10):
    print("送玫瑰花")

案例16:判断有多少个偶数和奇数

n = 0
for x in range(1,100):
    print(x)
    if x % 2 == 0:
        print(f"偶数有：{x}")
        n += 1
        print(f"偶数有count{n}个")
        print(f"奇数有count{100-n}个")

案例17:FOR循环嵌套(减肥案例)

i = 1
for i in range(1,101):
    print(f"今天是减肥的第{i}天")
    m = 1
    for m in range(1,11):
        print(f"跑了第{m}圈步")
    print(f"跑了第{m}圈，瘦了1kg")
print(f"跑了第{i}天，瘦了10kg")
#官方案例
x = 1
for x in range(1,101):
    print(f"今天是向观众唱歌的第{x}天")
    for y in range(1,11):
        print(f"给观众唱歌的第{y}首")
    print(f"我在第{x}天的时候成功了！")
print(f"第{x}天，我得奖了！")

案例18:FOR与WHILE两个一起循环嵌套

#WHile嵌套可以与FOR嵌套相互使用
#For嵌套
x = 1
for x in range(1,101):
    print(f"今天是向观众唱歌的第{x}天")
    for y in range(1,11):
        print(f"给观众唱歌的第{y}首")
    print(f"我在第{x}天的时候成功了！")
print(f"第{x}天，我得奖了！")
#While嵌套
m = 1
for m in range(1,101):
    print(f"今天是向观众唱歌的第{m}天")
    n = 1
    while n <= 10:
        print(f"给观众唱歌的第{n}首")
        n += 1
    print(f"我在第{m}天的时候成功了！")
print(f"第{m}天，我得奖了！")

案例19:九九乘法表FOR循环

#外层循环控制行数i
for i in range(1, 10) :
    # 内循环控制行数j
    for j in range(1, i + 1):
        # 内循环中输出每一行的内容
        print(f"{j} * {i} = {j * i}\t", end='')
     # 外层循环可以通过print输出一个回车符
    print()

CONTINUE和BREAK中断

#continue和break只能在所在循环上起作用，无法对上层循环起作用
#continue循环本次结束（中断本次（临时））
for i in range(1,6):
     print("语句1")
     continue
     print("语句2")
 print("语句3")
 
# #continue 案例
for i in range(1,6):
    print("语句1")
    for j in range(1, 6):
        print("语句2")
        continue
        print("语句3")
    print("语句4")

#break循环本次结束（中断所在循环（永久））
for i in range(1,3):
    print("语句1")
    for j in range(1, 3):
        print("语句2")
        break
        print("语句3")
print("语句4")

案例20:循环综合（发放绩效5分以上的人发1w奖金）

#定义账户余额
money = 10000
#for循环给员工发工资
for i in range(1, 21) :
    # num是绩效
    import random
    score = random.randint(0, 10)
    if score < 5 :
        print(f"员工{i}绩效分{score},不满足条件，不发奖金，下一位")
       #continure跳过发放
        continue

    #判断余额足不足
    if money >= 1000:
            money -= 1000
            print(f"员工{i}满足条件，发放奖金1000元，公司账户余额还有{money}元")
    else:
        print(f"余额不足，当前余额：{money}元，下个月再来")
        #停止发工资了
        break

lenth函数

#len( )统计长度
name = "youaremysunshine"
lenth = len(name)
print(lenth)
#统计长度,不使用函数
str1 = "itheima"
str2 = "itcastmeilimao"
str3 = "python"
#定义一个技数变量
count = 0
for i in str1 :
    count += 1
print(f"字符串{str1}的长度是：{count}")

count = 0
for i in str2 :
    count += 1
print(f"字符串{str2}的长度是：{count}")

count = 0
for i in str3 :
    count += 1
print(f"字符串{str3}的长度是：{count}")

#可以使用一个函数进行定义，来优化整个过程
str1 = "itheima"
str2 = "itcastmeilimao"
str3 = "python"
def my_len(data):
    count = 0
    for i in data :
        count += 1
        print(f"字符串{data}的长度是：{count}")

my_len(str1)
my_len(str2)
my_len(str3)

定义函数

'''
#函数的定义
def 函数名（传入参数):
    函数体
    return 返回值
'''
#1.定义一个函数，输出相关信息
def small_cat():
    print(f"我是世界上最可爱的小猫咪,喜欢喵喵叫")
#2.调用函数，让定义的函数开始工作
small_cat()

def ture_love():
    print(f"我是布偶猫鼓浪屿宝宝\n我真的很爱很爱你")
#2.调用函数，让定义的函数开始工作
ture_love()

函数的传入参数

'''
def add():
    result = 1+2
    print(f"1+2的结果是：{result}")
'''
def add(x, y,z):
    result = x + y + z
    print(f"{x}+{y}+{z}的结果是：{result}")
#调用函数，传入被计算的2个数字
add(7,3,9)

案例21:函数练习（升级版自动查核酸）

#     自己写的
def practice( ):
    print(f"欢迎来到魔法世界，请出示您的健康码以及72小时绿码证明！")
practice( )
import random
tem = random.randint(30.00,40.00)
print(f"此时此刻，您的体温是：{tem} ")
if tem <= 37.5:
    print(f"体温合格，欢迎光临！")
else:
    print(f"回家洗洗睡吧！")
# 官方答案
def official( num ):
    print(f"欢迎来到魔法世界，请出示您的健康码以及72小时绿码证明！")
    if num <= 37.5:
        print(f"体温合格，欢迎光临！")
    else:
        print(f"回家洗洗睡吧！")
official( 37.9 )

函数返回值

#语法判断
'''
def 函数（参数...）
    函数体
    return 返回值
变量 = 函数（参数）
'''
#函数返回值
def add(a,b):
    result = a+b
    #通过返回值，将相加的结果返回给调用者
    return result
#函数的返回值可以通过变量去接收
r = add(1,2)
print(r)
#再来一次
def add(a,b):
    result = a+b
    #通过返回值，将相加的结果返回给调用者
    return result
    # 返回结果后，还想输入一句话，千万不要写在return后面，因为不会执行的
    #print("我怎么这么好看")错误案例
r = add(1,2)
print(r)

函数返回值None类型

#演示特殊自变量：None,用在函数无返回值上，用于if判断中（none = false）,空的无意义的
#无return语句的函数返回值
def say_hi ():
    print("你好呀")

result=say_hi ()
print(f"无返回值函数返回值为{result}")
print(f"无返回值函数返回值为{type(result)}")

#主动返回None语句的函数返回值
def say_hi2 ():
    print("你好呀")
    return None

result=say_hi2 ()
print(f"无返回值函数返回值为{result}")
print(f"无返回值函数返回值为{type(result)}")

#none用于if判断：
def check_age(age):
    if age > 18:
        return "大美女"
    else:
        return None

result = check_age(16)
if not result :
    #进入if表示result是none值，也是False
    print("未成年")

#none用于声明无内容的变量上
  name = None

函数的说明文档

#定义函数，进行文档说明,多行注释（6个双引号，在中间会车即可）
def add(x,y)
    """
    add函数可以接收2个参数进行2数相加
    :param x: 形参x表示相加的一个数字
    :param y: 形参y表示相加的另一个数字
    :return: 返回值是2数相加的结果
    """
    result = x + y
    print(f"2数相加的结果是{result}")
    return  result

add(5,6)

函数的嵌套调用

# 定义函数func_a,并在内部调用func_b
def func_a():
    print("---1---")
    #嵌套使用func_b
    func_b()
    print("---3---")
# 定义函数func_a
func_a()

函数的全局变量和局部变量

#局部变量（num）
def test_a ():
    num = 100
    print(num)
test_a()
#出了函数体，局部变量（num）就无法使用了
print(num)

#全局变量(函数内外都可以正常使用)
num = 200
def test_a():
    print(f"test_a:{num}")
def test_b():
    print(f"test_a:{num}")
test_a()
test_b()
print(num)

#global关键字
num = 200
def test_a():
    print(f"test_a:{num}")
def test_b():
    num = 500 #局部变量
    print(f"test_a:{num}")
test_a()
test_b()
print(num)

#global关键字，在函数申明变量为全局变量
num = 200
def test_a():
    print(f"test_a:{num}")
def test_b():
    global num #把内部定义的变量设置为全局变量
    num = 500
    print(f"test_a:{num}")
test_a()
test_b()
print(num)

案例22:函数综合案例（存钱/取钱/余额）

'''#自己写的代码版本
#name顾客姓名/money银行卡余额
money = 50000
name = input(f"请输入您的姓名")
print(f"-------------余额-------------\n当前用户是：{name}")
def money_yue( ):
    print(f"当前存款为：{money}元")
money_yue( )
import random
money1 = random.randint(100,50000)
def money1_yue( ):
    print(f"当前随机取款为：{money1}元")
money1_yue( )
money2 =money - money1
def money2_yue( ):
    print(f"随机取款后，当前余额为{money}-{money1}={money2}元")
money2_yue( )
'''

#官方答案
#定义全局变量qian和xingming
qian = 50000
xingming =None
#要求客户输入姓名
xingming = input(f"请输入您的姓名： ")
#定义查询函数
def query(show_header):
    #show_header 表头参数
    if show_header:
       print(f"-------------查询余额-------------")
    print(f"{xingming},您好，您的余额还剩余{qian}元")

#定义存款函数
def saving(num):
    global qian #qian在函数内部定义为全局变量
    qian += num
    print(f"-------------存款-------------")
    print(f"{xingming},您好，您存款{num}元已成功")
    #调用query函数查询余额
    query(False)
#取款
def get_money(num):
    global qian
    qian -= num
    print(f"-------------取款-------------")
    print(f"{xingming},您好，您存款{num}元已成功")
    query(False)
#主菜单参数
def main():
    print(f"-------------主菜单-------------")
    print(f"{xingming},您好，欢迎来到美丽猫ATM，请选择操作：")
    print("查询余额\t[1]")
    print("存款\t[2]")
    print("取款\t[3]")
    print("退出\t[4]")
    return input(f"请输入你的选择：")
#设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue
    elif keyboard_input == "2":
        num =int(input("您想要存入多少钱，请输入："))
        saving(num)
        continue
    elif keyboard_input =="3":
        num =int(input("您想要取入多少钱，请输入："))
        get_money(num)
        continue
    else:
        print(f"退出，欢迎下一次光临！")
        break

数据容器以及列表定义

#数据容器（一种可以存储多个元素的Python数据类型）
# 数据库中的数据容器：list(列表),tuple(元祖),str(字符串),set(集合),dict(字典)
name_list = ['布偶猫','狸花猫','无毛猫','小橘猫','蓝猫']
print(name_list)

#定义一个列表 list
my_cat =["我可爱的小猫咪","布偶猫","Gulangyu"]
print(my_cat)
print(type(my_cat))

my_cat = ["我可爱的小猫咪",100,True]
print(my_cat)
print(type(my_cat))

#定义一个嵌套列表
my_list = [[1,2,3],[4,5,6]]
print(my_list) 
print(type(my_list))

列表的下标索引

#下标索引fa
name_list = ['春风','惊蛰','立夏','芒种','秋分']
# 正向索引[0]开始，'春风','惊蛰','立夏','芒种','秋分
print(name_list[0])
print(name_list[1])
print(name_list[2])
# 反向索引[-1]开始，'秋分,'芒种','立夏','惊蛰','春风'
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
#嵌套型的下标索引
name_list = [[1,2,3],[4,5,6]]
print(name_list[1],[1])

列表的常用操作（append/extend/insert/del/remove/pop/count/index/len）

#定义一个函数
mylist = ["apple","orange","Alice"]
#查找某元素在列表中的下标索引
index = mylist.index("Alice")
print(f"Alice在列表中的下标索引是：{index}")
#查找的元素如果不存在，会报错
# index = mylist.index("Jack")
# print(f"Alice在列表中的下标索引是：{index}")
#修改特定位置的元素值 语法：列表【下标】=值
mylist[0]='榴莲小姐'
print(f"列表被修改元素值后，结果是：{mylist}")
#在列表中自定义指定位置插入元素
mylist.insert(1,"best")
print(f"列表插入元素后，结果是：{mylist}")
#append列表尾部追加元素
mylist.append("我最爱我自己")
print(f"列表插入元素后，结果是：{mylist}")
#extend列表尾部追加元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表插入元素后，结果是：{mylist}")
#删除元素
mylist = ["apple","orange","Alice"]
#del删除
del mylist2
print(f"列表删除元素后，结果是：{mylist}")
#pop删除
mylist = ["apple","orange","Alice"]
element = mylist.pop(2)
print(f"列表删除元素后，结果是：{mylist},取出的元素是{element}")
#remove删除(删除第一个出现的内容)
mylist = ["apple", "Alice","orange","Alice","Happy"]
mylist.remove("Alice")
print(f"列表删除元素后，结果是：{mylist},取出的元素是{element}")
#列表全部清除
mylist.clear()
print(f"列表清空后，结果是：{mylist}")
#统计某元素在列表中的数量
mylist = ["apple", "Alice","orange","Alice","Happy"]
count = mylist.count("Alice")
print(f"列表中Alice的数量是:{count}")
#统计列表中，总共有多少个元素(len)
mylist = ["apple", "Alice","orange","Alice","Happy"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

案例23：年龄列表

age = [21,25,21,23,22,20]
#追加一个数字31，到列表的尾部
age.append(31)
print(f"新增的数据是{age}")
#追加一个新列表{29,33,30},到列表尾部
age2 = [29,33,30]
age.extend(age2)
print(f"新增的数据是{age}")
#取出第一个元素
num1=age[0]
print(f"第一个元素是{num1}")
#取出最后一个元素
num2 = age[-1]
print(f"最后一个元素是{num2}")
#查找元素31
index = age.index(31)
print(f"31在列表中的下标索引是：{index}")

While和FOR遍历函数

#用WHILE循环遍历列表的演示函数
def list_while_func():
    my_list = ["apple","华为","Shanghai"]
#循环控制变量通过下标索引来控制，默认0
#每一次循环将下标索引变量+1
#循环条件：下标索引变量 < 列表的元素数量
#定义一个变量用来标记列表的下标
    index = 0 #初始值0
    while index < len(my_list):
    # 通过index变量去处对应下标的元素
          element = my_list[index]
          print(f"列表的元素：{element}")
    #将循环变量index 每一次循环都+1
    index  +=  1
list_while_func()


#用for循环遍历列表的演示函数
def list_for_func():
    my_list =[1,2,3,4,5]
    for element in my_list:
        print(f"列表的元素有：{element}")
list_for_func()

元组的基本操作

#定义元组
t1 = (1,"HI",True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")

#定义单个元素的元组
t4 = ("hellow")
print(f"t4的类型是：{type(t4)},内容是：{t4}")

#元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是：{t5}")

#下标索引取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据：{num}")

#index查找方法
t6 = ("春眠不觉晓","床前明月光","漂亮的大太阳")
index = t6.index("床前明月光")
print(f"在元素t6查找床前明月光，下标是{index}")

#count统计方法
t7 = ("苹果","香蕉","草莓","苹果","草莓","西瓜")
num = t7.count( "苹果")
print(f"苹果的数量有{num}个")

#元组的操作：len的函数统计元组元素数量
t8 = ("苹果","香蕉","草莓","苹果","草莓","西瓜")
num2 = len(t8)
print(f"苹果的数量有{num2}个")

#元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    #至关重要
    index += 1

#元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")
    
# 修改元组的内容
# t8[0]="itcast"

# 定义一个元组
t9 = (1,2,["haha","hehe"])
print(f"t9的内容是：{t9}")
t9[2][0] = "小猫咪宝宝"
t9[2][1] = "小狗狗"

案例24:元组应用（'周杰伦'，11，['football','music']）

# 定义学生信息元组
student = ('周杰伦', 11, ['football', 'music'])

# 1. 查询年龄所在的下标位置
age_index = student.index(11)
print(f"年龄所在的下标位置是：{age_index}")

# 2. 查询学生的姓名
name = student[0]
print(f"学生的姓名是：{name}")

# 3. 删除爱好中的football
# 由于元组内容不可变，需要先获取爱好列表，修改后再赋值
hobbies = student[2]
hobbies.remove('football')
print(f"删除football后的爱好列表：{hobbies}")

# 4. 增加coding爱好
hobbies.append('coding')
print(f"增加coding后的爱好列表：{hobbies}")

# 打印最终的学生信息元组
print(f"最终的学生信息元组：{student}")

字符串的定义和操作

#定义一个字符串
my_str = "gulangyu and xiaobaobao"

#通过下标索引取值
value = my_str[2]
print(f"my_str的第二个值是{value}")

#index方法
value2 = my_str.index("and")
print(f"my_str的and起始下标是{value2}")

#replace替换
new_my_str = my_str.replace("and","love")
print(f"替换后的结果是{new_my_str }")

#字符串分割（split）
my_str = "xiaoming and lvbaoshi"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是{type(my_str_list)}")

#strip方法（去除前后空格）
my_str = "             xiaoming and lvbaoshi        "
my_str_new = my_str.strip( )#不穿入参数，去除收尾空格
print(f"将字符串{my_str}进行stri后得到：{my_str_new}")
my_str = "12xiaoming and lvbaoshi21"
my_str_new = my_str.strip( "12")
print(f"将字符串{my_str}进行strip12后得到：{my_str_new}")

#统计字符串中某字符串出现的次数,count
my_str = "linlinlinlinlinlinlinlinlinlhahahahalinlindasdas"
count = my_str.count("li")
print(f"将字符串{my_str}中li出现的次数：{count}")

#统计字符串中的长度，len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

数据容器（序列）的切片

#对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list [1:4:1] #步长默认为1，所以可以省略不写
print(f"结果1：{result1}")

#对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:] #起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果1：{result2}")

#对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果1：{result3}")

#对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1] #将序列反转了
print(f"结果1：{result4}")

#对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
print(f"结果1：{result5}")

#对tuple进行切片，从头开始，到最后结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2] #起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果1：{result6}")

案例25:序列的切片练习

#练习案例：序列的切片实践（倒叙字符串、split分隔）
#字符串"万过薪月，员序程丽美超，敌无下天"
my_str = "万过薪月，员序程丽美超，敌无下天"

#倒叙字符串，切片取出
result1 = my_str[::-1][5:10]
print(f"方式1的结果是{result1}")

#切片取出,然后倒序
result2 = my_str[5:10][::-1]
print(f"方式1的结果是{result2}")

#split分隔"," replace替换
result3 = my_str.split("，") [1].replace("超" , " ")[::-1]
print(f"方式1的结果是{result3}")

集合的定义与操作

#定义集合
my_set ={"春天","夏天","秋天","冬天","春天","夏天","秋天","冬天","春天","夏天","秋天","冬天"}
my_set_empty = set() #定义空集合
print(f"my_set的内容是：{my_set},类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty},类型是：{type(my_set_empty)}")

#添加新元素
my_set.add("想你的季节")
my_set.add("如梦初醒")
my_set.add("春天")
print(f"my_set添加元素后的结果是：{my_set}")

#移除元素
my_set.remove("春天")
print(f"my_set移除元素后的结果是：{my_set}")

#随机取出来一个元素
my_set ={"春天","夏天","秋天","冬天","春天","夏天","秋天","冬天","春天","夏天","秋天","冬天"}
element = my_set.pop( )
print(f"集合被取出的元素是{element},取出元素后：{my_set}")

#清空集合，clear
my_set.clear()
print(f"集合被清空了，结果是{my_set}")

#取2个集合的差集(set1里面有的，但是set2里面没有的数据)
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是{set3}")
print(f"取差集后，原有set1的内容是{set1}")
print(f"取差集后，原有set2的内容是{set2}")

#消除2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果是{set1}")
print(f"消除差集后，集合2结果是{set2}")

#2个集合合并为1个
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"合并后，结果是{set3}")
print(f"合并后，集合1结果是{set1}")
print(f"合并后，集合2结果是{set2}")

#统计集合元素数量len()
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
num = len(set3)
print(f"合并后，集合元素数量是{num}")

#集合的遍历 集合不支持下标索引，不能用while
set1 = {1,2,3,4,5}
for element in set1:
    print(f"集合的元素有：{element}")

案例26：集合案例

# 有如下列表对象：
# my_list = ['猫咪','小狗','兔子','狐狸','cat','dog','rabbit','fox']
#1.定义空集合 2.for循环遍历 3.for列表元素加入集合 4.元素去重后集合对象
my_list = ['猫咪','小狗','兔子','狐狸','cat','dog','rabbit','fox','猫咪','小狗','兔子','狐狸','小狗','兔子','狐狸']
my_list_empty = ( )
print(f"my_list的值是{my_list},my_list_empty的值是{my_list_empty}")
#1.定义空集合
my_set = set()

#2.for循环遍历
for element in my_list:
    #在for循环中将列表的元素添加至集合
    my_set.add(element)
    print(f"动物园里有{element}")

#最终得到元素去重后的集合对象，并打印输出
print(f"列表的内容是{my_list}")
print(f"通过for循环后，得到的集合对象是{my_set}")

案例27：字典案例

#老师有一份名单，记录了学生的姓名和总成绩
# 王力宏 77；周杰伦 88；林俊杰 99
# 现在要将其通过python录入到程序中，并可以通过学生姓名检索学生成绩

#定义字典
my_dict1 = {"王力宏":99,"周杰伦":88,"林俊杰":77}

#定义空字典
my_dict2= { } #set()
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1},类型{type(my_dict1)}")
print(f"字典1的内容是：{my_dict2},类型{type(my_dict2)}")
print(f"字典1的内容是：{my_dict3},类型{type(my_dict3)}")

#定义重复key的字典
my_dict1 = {"王力宏":99,"王力宏":88,"林俊杰":77}
print(f"重复key的字典内容是{my_dict1}")

#从字典中基于key获取value
my_dict1 = {"王力宏":99,"周杰伦":88,"林俊杰":77}
score = my_dict1["王力宏"]
print(f"王力宏的考试成绩为{score}")
score = my_dict1["周杰伦"]
print(f"周杰伦的考试成绩为{score}")
score = my_dict1["林俊杰"]
print(f"林俊杰的考试成绩为{score}")

#定义嵌套字典
stu_score_dict = {
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":33
    },"周杰伦":{
        "语文": 88,
        "数学": 86,
        "英语": 55
    },"林俊杰":{
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是:{stu_score_dict}")

#从嵌套的字典中获取数据，比如看一下周杰伦语文信息
zhou_score = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文成绩是：{zhou_score}")
lin_score = stu_score_dict["林俊杰"]["英语"]
print(f"林俊杰的语文成绩是：{lin_score}")

字典的常用操作

#定义字典
my_dict1 = {"王力宏":99,"周杰伦":88,"林俊杰":77}

#新增元素
my_dict1["张信哲"] = 66
print(f"字典新增元素后，结果:{my_dict1}")

#更新元素
my_dict1["周杰伦"] = 33
print(f"字典更新后，结果:{my_dict1}")

#删除元素
score = my_dict1.pop("周杰伦")
print(f"移除元素后，结果:{my_dict1}，周杰伦的考试分数{score}")

#清空元素
my_dict1.clear()
print(f"字典清空了，结果:{my_dict1}")

#获取全部key的操作
my_dict1 = {"王力宏":99,"周杰伦":88,"林俊杰":77}
keys = my_dict1.keys()
print(f"字典全部key为{keys}")

#遍历字典
#方式1：通过获取到的全部key来完成遍历
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict1[key]}")
# 方式2：直接对字典进行for循环，每一遍循环都是为了得到key
for key in my_dict1:
    print(f"2字典的key是{key}")
    print(f"2字典的value是{my_dict1[key]}")

#统计字典内的元素数量
num = len(my_dict1)
print(f"字典中的元素数量有{num}个")

案例28:字典案例实践（升职加薪）

#如有以下员工，请使用字典完成数据的记录，并通过for循环，对所有级别为1的员工上升1级，薪水增加1000元
#组织字典记录数据
info_dict = {
    "王力宏":{
        "部门": "科技部",
        "工资": "3000",
        "级别": "1"
    },
    "周杰伦":{
        "部门": "市场部",
        "工资": "5000",
        "级别": "2"
    },
    "林俊杰":{
        "部门": "市场部",
        "工资": "7000",
        "级别": "3"
    },
    "张学友":{
        "部门": "科技部",
        "工资": "4000",
        "级别": "1"
    },
    "刘德华":{
        "部门": "市场部",
        "工资": "4000",
        "级别": "2"
    }
}
print(f"员工在升职加薪前的结果是{info_dict}")

#for循环遍历字典
for name in info_dict:
       #if条件判断符合条件的员工
       if info_dict[name]["级别"] == 1:
           #升职加薪操作
           #获取到员工信息字典
           employee_info_dict = info_dict[name]
           #修改员工信息
           employee_info_dict["级别"] = 2
           employee_info_dict["工资"] = employee_info_dict["工资"+1000] #employee_info_dict["工资"] +=1000
           #将员工的信息更新
           info_dict[name] = employee_info_dict
#输出结果
print(f"对员工升职加薪后的结果是{info_dict}")

info_dict = {
    "王力宏": {"部门": "科技部", "工资": 3000, "级别": 1},  # 将工资和级别改为整数类型
    "周杰伦": {"部门": "市场部", "工资": 5000, "级别": 2},
    "林俊杰": {"部门": "市场部", "工资": 7000, "级别": 3},
    "张学友": {"部门": "科技部", "工资": 4000, "级别": 1},
    "刘德华": {"部门": "市场部", "工资": 4000, "级别": 2}
}

print(f"员工在升职加薪前的结果是{info_dict}")

for name in info_dict:
    if info_dict[name]["级别"] == 1:  # 直接比较整数
        employee_info_dict = info_dict[name]
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000  # 正确的加法操作
        # 无需再次赋值 info_dict[name] = employee_info_dict

print(f"对员工升职加薪后的结果是{info_dict}")

数据容器的通用操作（列表/字典/集合/字符串/元组）

#数据容器大全
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = 'abcdefg'
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

#len元素个数
print(f"列表  元素个数有：{len(my_list)}")
print(f"元组  元素个数有：{len(my_tuple)}")
print(f"字符串  元素个数有：{len(my_str)}")
print(f"集合  元素个数有：{len(my_set)}")
print(f"字典  元素个数有：{len(my_dict)}")

#max最大元素
print(f"列表  最大的元素有：{max(my_list)}")
print(f"元组  最大的元素有：{max(my_tuple)}")
print(f"字符串  最大的元素有：{max(my_str)}")
print(f"集合  最大的元素有：{max(my_set)}")
print(f"字典  最大的元素有：{max(my_dict)}")

#min最小元素
print(f"列表  最小的元素有：{min(my_list)}")
print(f"元组  最小的元素有：{min(my_tuple)}")
print(f"字符串  最小的元素有：{min(my_str)}")
print(f"集合  最小的元素有：{min(my_set)}")
print(f"字典  最小的元素有：{min(my_dict)}")

#类型转换：容器转列表
print(f"列表   转 列表的结果是：{list(my_list)}")
print(f"元组   转 列表的结果是：{list(my_tuple)}")
print(f"字符串 转 列表的结果是：{list(my_str)}")
print(f"集合   转 列表的结果是：{list(my_set)}")
print(f"字典   转 列表的结果是：{list(my_dict)}")

#类型转换：容器转元组
print(f"列表   转 元组的结果是：{tuple(my_list)}")
print(f"元组   转 元组的结果是：{tuple(my_tuple)}")
print(f"字符串 转 元组的结果是：{tuple(my_str)}")
print(f"集合   转 元组的结果是：{tuple(my_set)}")
print(f"字典   转 元组的结果是：{tuple(my_dict)}")

#类型转换：容器转集合
print(f"列表   转 集合的结果是：{set(my_list)}")
print(f"元组   转 集合的结果是：{set(my_tuple)}")
print(f"字符串 转 集合的结果是：{set(my_str)}")
print(f"集合   转 集合的结果是：{set(my_set)}")
print(f"字典   转 集合的结果是：{set(my_dict)}")

#类型转换：容器转字符串
print(f"列表   转 字符串的结果是：{str(my_list)}")
print(f"元组   转 字符串的结果是：{str(my_tuple)}")
print(f"字符串 转 字符串的结果是：{str(my_str)}")
print(f"集合   转 字符串的结果是：{str(my_set)}")
print(f"字典   转 字符串的结果是：{str(my_dict)}")

#容器通用排序功能sorted[reverse = True]
print(f"列表   对象的排序结果是：{sorted(my_list)}")
print(f"元组   对象的排序结果是：{sorted(my_tuple)}")
print(f"字符串 对象的排序结果是：{sorted(my_str)}")
print(f"集合   对象的排序结果是：{sorted(my_set)}")
print(f"字典   对象的排序结果是：{sorted(my_dict)}")

print(f"列表   对象的反向排序结果是：{sorted(my_list,reverse=True)}")
print(f"元组   对象的反向排序结果是：{sorted(my_tuple,reverse=True)}")
print(f"字符串 对象的反向排序结果是：{sorted(my_str,reverse=True)}")
print(f"集合   对象的反向排序结果是：{sorted(my_set,reverse=True)}")
print(f"字典   对象的反向排序结果是：{sorted(my_dict,reverse=True)}")

演示字符串大小比较

#演示字符串大小比较
#abc 比较 abd
print(f"abd大于abc，结果：{'abd'>'abc'}")
#a 比较 ab
print(f"ab大于ab，结果：{'ab'>'a'}")
#a 比较 A
print(f"A大于a，结果：{'A'>'a'}")
#key1 比较 key2
print(f"Key2大于key1，结果：{'key2'>'key1'}")

函数的多返回值

#演示使用多个变量，接收多个返回值
def test_return ():
    return 1,2,3,"hellow",True
x,y,z,m,n = test_return()
print(x)
print(y)
print(z)
print(m)
print(n)

函数的多种参数使用形式

#定义函数
def user_info (name,age,gender):
    print(f"姓名是：{name},年龄：{age},性别：{gender}")

# 位置参数 - 默认使用形式
user_info('小明',20,'男')

#关键字参数
user_info(name = '小王',gender='女',age =11)
user_info(gender ='女',name = '小陈',age =15)

#缺省参数（默认值）
def user_info (name,age,gender = '男'):
    print(f"姓名是：{name},年龄：{age},性别：{gender}")
user_info('小天',13)
user_info('小天',13,gender= '女')

#不定长 - 位置不定长，*号
#不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f" args的参数类型是：{type(args)},内容是:{args} ")
user_info(1,2,3,'小明','男孩')

#不定长 - 关键字不定长，**号
def user_info(**kwargs):
    print(f" args的参数类型是：{type(kwargs)},内容是:{kwargs} ")
# user_info(1,2,3,'小明','男孩')这种是错误的
user_info(name = '小帅',age = 11,gender = '男孩',addr = '上海')

函数作为参数传统

#定义函数,接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2) #computer是函数
    print(f"computer的类型是：{type(compute)}")
    print(f"计算结果是：{result}")

#定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
    return x + y

#调用，并传入函数
test_func(compute)

Lambda匿名函数

# 定义一个函数，接收其他函数输入（lambda匿名函数）
def test_func(compute):
    result = compute(1,2)
    print(f"结果是{result}")
#通过lambda匿名函数的形式，将匿名函数作为参数的值
test_func(lambda x,y:x+y)

文件的读取方法

#打开文件
import time

f = open("/Users/li/Downloads/test","r",encoding="UTF-8")
print(type(f))

#读取文件-read()
print(f"读取10个字节的结果是：{f.read(10)}")
print(f"read方法读取的全部结果是：{f.read()}")
print("-------------------------------------------")

#读取文件 - readlines()
Lines = f.readlines()#读取文件的全部行，然后封装到列表中
print(f"lines对象的类型：{type(Lines)}")
print(f"lines对象的内容：{Lines}")

#读取文件 - readline()
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行数据是{line1},第二行数据是{line2},第三行数据是{line3}")

#for循环读取文件行
for line in f:
    print(f"每一行数据是：{line}")

#文件关闭
time.sleep(500000)#程序睡眠50w秒
f.close()

# #with open的语法
with open("/Users/li/Downloads/test","r",encoding="UTF-8") as f:
    for line in f:
      print(f"每一行数据是：{line}")

time.sleep(500000)

案例29:文件读取并统计

#单词计数，统计上海出现的次数
#打开文件，以读取模式打开
f = open("/Users/li/Downloads/test","r",encoding="UTF-8")

#方式一：读取全部数据，通过字符串count方法统计上海出现的次数
content = f.read( )
count = content.count("上海")
print(f"上海在文件中出现了：{count}次")

#方法二：读取内容，一行一行读取
count = 0  #使用count变量来累计上海的出现次数
for line in f:
    line = line.strip() #去除开头和结尾的空格和换行符
    words = line.split(" ")
    print(words)
    for word in words:
        if word =="上海" :
            count += 1 #如果单词是上海，数量就可以累加+1

#判断单词出现次数并累计
print(f"上海出现的次数是:{count}")

#关闭文件
f.close()

文件的写出操作

#打开文件，不存在的文件，r读w写a追加
import time
f = open("/Users/li/Downloads/test2","w", encoding="UTF-8")
#write写入
f.write("笑傲江湖，唯我独尊")#内容写入到内存中
#flush刷新                #内容写入到内存中
f.flush()
time.sleep(500000)
#close关闭文件             #close的办法，内置
f.close()

#打开一个存在的文件
f = open("/Users/li/Downloads/test2","w", encoding="UTF-8")
#write写入，flush刷新
f.write("我是大美丽")
#close关闭文件        
f.close()

文件的追加写入文件

#文件追加操作
#打开一个不存在的文件
f = open("/Users/li/Downloads/test3","a",encoding="UTF-8")
#write 写入
f.write("春风不度玉门关\n")
#flush刷新
f.flush()
#close关闭
f.close()
#打开一个存在的文件
f = open("/Users/li/Downloads/test3","a",encoding="UTF-8")
#write写入、flush刷新
f.write("\n是哪个朝代的诗人写的")
#close.关闭

案例30:文件操作的综合案例

#文件操作的综合案例
#打开文件得到的文件对象，准备读取
fr = open("/Users/li/Downloads/test3","r",encoding="UTF-8")
#打开文件得到的文件对象，准备写入
fw = open("/Users/li/Downloads/test3.bak","w",encoding="UTF-8")
#for循环读取文件
for line in fr:
    line = line.strip( )
    #判断内容，将满足的内容写出
    if line.split("，")[-1] == "测试":
        continue   #continue进入下一次循环，这一次后面的内容就跳过了
    #将内容写出去
    fw.write(line)
    #由于前面对内容进行了strip的操作，所以要手动的写出换行符
    fw.write("\n")

#close2个文件对象
fr.close()
fw.close() #写出文件调用close会自动flush

异常的捕获

#演示捕获异常
#基本捕获语法
try:
    f = open("/Users/li/Downloads/test4","r",encoding="UTF-8")
except:
    print(f"出现异常了，因为文件不存在，我将open的模式，为w模式去打开")
    f = open("/Users/li/Downloads/test4","w",encoding="UTF-8")

#捕获指定的异常
try:
    print(name)
except NameError as e :
    print("出现了变量未定义的异常")
    print(e)

#捕获多个异常
try:
    1/0
    print(name)
except (NameError,ZeroDivisionError) as e:
    print("出现了变量未定义，或者除以0的异常错误")

#未正确设置捕获异常类型，将无法捕获异常

'''
#捕获所有异常
try:
    # 1/0
    # print(name)
    f = open("/Users/li/Downloads/test4","r",encoding="UTF-8")
    print("我是大魅力")
except Exception as e:
    print("出现异常了")
#else的功能
else:
    print("好高兴，没有出现异常耶！")
#finally的功能(无论有没有异常，最终都要处理的结果)
finally:
    print("无论有没有异常，我都要贯彻到底")
    f.close()

异常的传递性

#演示异常的传递性
#定义一个出现异常的方法
def func1():
    print("func1开始执行")
    num = 1/0
    print("func1结束执行")
#定义一个无异常的方法，调用上面的方法
def func2():
    print("func2开始执行")
    func1()
    print("func2结束执行")
#定义一个方法，调用上面的方法
def main():
    try:
       func2()
    except Exception as e:
        print(f"出现异常了，异常的信息是：{e}")

main()

模块的概念与导入

#演示模块的导入
#使用import导入time模块使用sleep功能（函数）
import time #导入python内置的time模块（time.py这个代码文件）
print("你好")
time.sleep(5) #通过time.可以使用模块内部的全部功能（类、函数、变量）
print("我好")
time.sleep(5)
print("大家好")

#使用from导入time的sleep功能
from time import sleep
print("你好")
sleep(1)
print("我很想你")
sleep(2)
print("不要再离开我了，我么")

#使用*导入time模块的全部功能
from time import * #*表示全部的意思
print("有一天")
sleep(1)
print("我遇见了一个和你很像的人")
sleep(2)
print("才发现你已经在我心里住了很久很久")

#使用*导入time模块的全部功能
import  time as t
print("那天重逢")
t.sleep(1)
print("你说我胖了")
t.sleep(2)
print("我以前也胖，但你忘了")

from time import sleep as sl
print("时光已逝永不回")
sl(1)
print("原本属于我们的合唱")
sl(2)
print("虽未开口，但藏于我心")

自定义模块并导入

#自定义模块
#导入自定义模块使用
'''
import test2
test2.test(2,3)
'''
from test2 import test
test(2,3)
导入不同模块的同名功能
from test2 import test
from test3 import test
test(2,3)

# __main__变量
from test2 import test

# __all__变量
from test3 import *
test_a(1,2)
test_b(5,3)

'''
test2
def test(a,b):
    print(a + b)

if __name__ == '__main__':
    test(1,2)
'''

'''
test3
__all__=['test_a']
def test_a(a,b):
    print(a + b)

def test_b(a,b):
    print(a - b)
'''

自定义Python包

#演示Python包
#包名.模块名.目标
#创建一个包

#1.导入自定义的包中的模块，并使用
import test20250611.model1
import test20250611.model2
test20250611.model1.info_print()
test20250611.model2.info_print()

#2.可以用from语句
from test20250611 import model1
from test20250611 import model2
model1.info_print()
model2.info_print()

#3.更简易的语法
from test20250611.model1 import  info_print
from test20250611.model2 import  info_print
info_print()

#4.通过__all__变量，控制import*
from test20250611 import *
model1.info_print()
model2.info_print()

案例31:功能模块包的综合案例

"""
演示异常、模块、包的综合案例练习（模块包外的调试界面）
"""
#创建my_utiles包，在包内创建：str_util.py和file_util.py 两个模块，并提供相应函数
import my_utils.str_util
from my_utils import file_util
print(my_utils.str_util.str_reverse("我喜欢小猫咪"))
print(my_utils.str_util.substr("我喜欢大猫咪",0,4))

# file_util.print_file_info("/Users/li/Downloads/test3")
file_util.append_to_file("/Users/li/Downloads/test3","我是大富翁")
file_util.print_file_info("/Users/li/Downloads/test3")

"""
字符串相关的工具模块
"""
def str_reverse(s):
    """
    功能是将字符串完成反转
    :param s: 将被反转的字符串
    :return: 反转后的字符串
    """
    return s[::-1]

def substr(s,x,y):
    """
    功能是按照给定的下标完成给定字符串的切片
    :param s: 即将被切片的字符串
    :param x: 切片的开始下标
    :param y: 切片的结束下标
    :return: 切片完成后的字符串
    """
    return s[x:y:1]

if __name__ == '__main__':
    print(str_reverse("等到世界颠倒你才会爱我"))
    print(substr("等到世界颠倒你才会爱我",1,3))

"""
文件处理相关的工具模块
"""
def print_file_info(file_name):
    """
    功能是：将给定的文件内容输出到控制台中
    :param file_name: 即将被读取的文件路径
    :return: None
    """
    f = None
    try:
        f = open(file_name,"r", encoding="UTF-8")
        content = f.read()
        print("文件的全部内容如下")
        print(content)
    except Exception as  e:
        print(f"程序出现了异常，原因是：{e}")
    finally:
        if f: #如果变量是none，表示false，如果有任何内容，就是true
          f.close()

def append_to_file(file_name,data):
    """
    功能：指定的数据追加到指定的文件中
    :param file_name: 指定的文件路径
    :param data: 指定的数据
    :return: None
    """
    f = open(file_name,"a",encoding="UTF-8")
    f.write(data)
    f.write("\n")
    f.close()

if __name__ == '__main__':
    # print_file_info("/Users/li/Downloads/test3")
      append_to_file("/Users/li/Downloads/test3","我是超级大魅力")

作者：桑迪Sandy.Q

物联沃分享整理
物联沃-IOTWORD物联网 » Python学习秘籍：咒语大全与实用指南

代码收藏家普通

分享到：

字符串格式限制，%xd（整数），%x.yf（小数点浮点数）

f“内容{变量}快速格式化

案例1：股价预测

INPUT语句

案例2：INPUT登陆界面语句

布尔类型函数基础运用

案例3:比较运算符的运用

IF语句基本格式

案例4:IF语句+INPUT语句练习

案例5:IF ELSE语句

案例6:IF ELIF ELSE语句

案例7:猜数字小游戏

案例8:IF ELSE嵌套规则

案例9:IF ELSE嵌套（符合工龄的员工可享受旅游）

案例10:IF ELSE嵌套（随机猜数字小游戏）

WHILE 循环语句(附题1-100总和)

案例11:WHILE 循环猜数字并统计参与次数

案例12:WHILE 嵌套语句循环应用（给猫送礼物案例）

end=' '与\t的应用

案例13:九九乘法表While循环

FOR循环语句（遍历循环/依次循环）

案例14:统计以下文字有几个a（FOR循环）

Range语句

案例15:While语句与For语句的区别（玫瑰花案例）

案例16:判断有多少个偶数和奇数

案例17:FOR循环嵌套(减肥案例)

案例18:FOR与WHILE两个一起循环嵌套

案例19:九九乘法表FOR循环

CONTINUE和BREAK中断

案例20:循环综合（发放绩效5分以上的人发1w奖金）

lenth函数

定义函数

函数的传入参数

案例21:函数练习（升级版自动查核酸）

函数返回值

函数返回值None类型

函数的说明文档

函数的嵌套调用

函数的全局变量和局部变量

案例22:函数综合案例（存钱/取钱/余额）

数据容器以及列表定义

列表的下标索引

列表的常用操作（append/extend/insert/del/remove/pop/count/index/len）

案例23：年龄列表

While和FOR遍历函数

元组的基本操作

案例24:元组应用（'周杰伦'，11，['football','music']）

字符串的定义和操作

数据容器（序列）的切片

案例25:序列的切片练习

集合的定义与操作

案例26：集合案例

案例27：字典案例

字典的常用操作

案例28:字典案例实践（升职加薪）

数据容器的通用操作（列表/字典/集合/字符串/元组）

演示字符串大小比较

函数的多返回值

函数的多种参数使用形式

函数作为参数传统

Lambda匿名函数

文件的读取方法

案例29:文件读取并统计

文件的写出操作

文件的追加写入文件

案例30:文件操作的综合案例

异常的捕获

异常的传递性

模块的概念与导入

自定义模块并导入

自定义Python包

案例31:功能模块包的综合案例

代码收藏家 普通

相关推荐

发表回复 取消回复

代码收藏家普通

发表回复取消回复