526互联

python基础_05_python基础【2】

发布时间 2023-11-29 16:47:42作者: Lea4ning

【五】Python基础之程序与用户交互

【1】什么是与用户交互

  • 交互的本质就是输入、输出
  • 用户交互就是人往计算机中input/输入数据，计算机print/输出结果

【2】输入

  • input函数
    • 用户输入一些内容，用户按下回车键后，input 函数会返回用户输入的内容
    • 并且传输回来的数据均为字符串类型（str）
userName = input('请输入用户名:>>>')

【3】输出

（1）简单字符串

print('内容')

（2）多个变量输出

str1 = 内容打印
print('内容1'，2，str1)
# 输出：内容1 2 内容打印

（3）end参数

  • end 参数用于指定输出的结尾字符，默认为换行符"\n"(代表换行)。
  • 可以替换为任意字符
# 默认为换行
print('nice')
print('nice')
print('nice')
'''
nice
nice
nice
'''

print('nice', end='')
print('nice',end =',')
print('nice',end='!')
# nicenice,nice!
# 第一个将结束字符替换为空，故紧贴着下一个输出的值
# 第二个将结束字符替换为逗号（，）
# 第三个将结束字符替换为感叹号（！）

【六】基本运算符

【1】算数运算符

  • 加+

  • 减-

  • 乘*

  • 除/

  • 取整//

    • 数字相除，只取整数，舍弃小数点后的内容

      x=4.8
y=6
print(x/y)   # 0.79···

x=4.8
y=6
print(x//y)   # 0.0

  • 求余数%

    x=5
y=2
print(x%y)
# 1
# 5/2 = 2余1，余数为1

  • 幂运算**

    x=2
y=10
print(x**y)
# 1024
# 2的10次方=1024

【2】比较运算符

  • 比较运算用来对两个值进行比较，返回的是布尔值True或False
    1. 相等运算符 = =
      1. 值value相等返回True
      2. 错误返回False
    2. 不等运算符 ! =
      1. 描述正确返回True
      2. 描述错误返回False
    3. 大于运算符 >
    4. 小于运算符 <
    5. 大于等于运算符 > =
    6. 小于等于运算符 < =

【3】赋值运算符

（1）增量赋值

x = 1
y = 2
x += y      # x += y 相当于 x = x+y
print(x)    # 3

（2）链式赋值

x = y = z = 5
print(x,y,z)    
# 输出均为5
# 可以多个 = 号 共同赋值，形似链子

（3）交叉赋值

  • 交叉赋值允许在不使用临时变量的情况下，交换两个变量的值。

    x = 1
y = 2
x, y = y, x
print(x)    # 2
print(y)    # 1

（4）解压赋值

  • 解压赋值允许将一个可迭代对象（如列表、元组等）的值解压到多个变量中，以便进一步使用。

    list1 = [1, 2, 3]
tup1 = ('a', 'b', 'c')
x, y, z = list1
a, b, c = tup1
print(x, y, z)    # 1 2 3
print(a, b, c)   # a b c

  • 注：解压赋值数量必须一致，否则将报错

    # ValueError: too many values to unpack (expected 2)

【4】逻辑运算符

  • 逻辑运算符用于连接多个条件，进行关联判断，并返回布尔值 True 或 False。
  • 常用的逻辑运算符包括与（and）、或（or）、非（not）。

（1）与（and）

  • and连接多个条件时，所有条件必须均为True，如果其中有一个为False，则返回布尔值False

    print(1 == 1 and 1 < 2 and 3 > 1)
# True
print(1 > 1 and 1 < 2 and 3 > 1)
# False

（2）或（or）

  • or连接多个条件时，至少有一个条件为True时，返回布尔值True；若多个条件均为False，则返回布尔值False

    print(1 > 1 or 1 < 2 or 3 > 1)
# True

（3）非（not）

  • not用于对一个条件取反，如果条件为True，则返回False；如果条件为False，则返回True

    print(not(1 > 1 or 1 < 2 or 3 > 1))
# False

（4）优先级问题

not>and>or

  1. not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
  2. 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
  3. 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
print((3 > 4 and 4 > 3) or (1 == 3 and 'x' == 'x') or 3 > 3)

（5）短路运算

  • 逻辑运算的结果一旦可以确定
  • 那么就以当前处计算到的值作为最终结果返回
1 or 3
1
# 1是真，而or运算中，只要有一个真就可以输出了
1 and 3
3
# and运算中，需要比较所有的条件，最后计算到的为最后一位3
0 and 2 and 1
0
# and运算中，只要有一个假就可以输出结果了，所以是假
0 and 2 or 1
1
# （0 and 2）or 1
# 多个运算符中，需要计算到最后一步跟or比较，所以是最后一位
0 and 2 or 1 or 4
1
# （0 and 2) or 1 or 4
# 此处and运算为假，or运算为真，or运算中只有有一个真就可以输出
0 or False and 1
False
# 0 or （False and 1）
# 先比较and运算，and运算输出为False，再由0与False比较，最后计算到的为False

【5】成员运算符

  • 这两个运算符可以用于字符串、列表、元组等序列类型

  • in

    • 如果在指定的序列中找到值返回 True，否则返回 False。

      list1 = [1, 2, 3]
print(1 in list1)
# True

  • not in

    • 如果在指定的序列中没有找到值返回 True，否则返回 False。

      list1 = [1, 2, 3]
print(1 not in list1)
# False

【6】身份运算符

  • is

    • 如果两个变量引用同一个对象，则返回 True，否则返回 False。

      a = 1
b = a
c = 2
print(a is b)    # True
print(a is c)    # False

  • is not

    • 如果两个变量引用的不是同一个对象，则返回 True，否则返回 False。

      a = 1
b = a
c = 2
print(a is not  b)    # False
print(a is not  c)    # True

  • 这两个运算符主要用于检查对象的标识，即它们是否指向相同的内存地址。

【补充】==与is的区别

  • == 双等号比较的是value是否相等，在同类型之间进行比较
  • is用于比较两个对象的标识id（内存地址）是否相同
  • 在实际应用中，特别是对于可变对象，==通常更适合用于比较值，而is更适合用于比较对象的身份。
  • id相同，内存地址必定相同，意味着type和value必定相同
  • value相同type肯定相同（必须是同类型比较），但id可能不同
x = [1, 2, 3]
y = [1, 2, 3]

print(id(x))    # 1748918684992
print(id(y))    # 1748921904064

print(x is y)    # False
# 当x和y是不可变的量时，指向的内存地址是相同的，如字符串、元组等
print(x == y)    # True

【七】流程控制

【1】流程控制语句介绍

  • 程序是由语句构成，而流程控制语句 是用来控制程序中每条语句执行顺序的语句。

【2】顺序结构

  • 顺序结构是指按照代码书写的顺序，一条语句接着一条语句执行，没有跳过、重复或其他特殊的结构。

【3】分支结构

（1）单分支结构（if）

if+条件1 ：
    换行 执行内容 # 条件1如果为真
结束

# 条件1如果为假则跳过if语句，执行后续的代码

（2）双分支结构（ifelse）

if+条件1 :
    执行内容1 # 条件1如果为真，则执行内容1（条件正确的情况下执行的内容）
else:
    执行内容2 # 条件1如果为假，则执行内容2（条件错误的情况下执行的内容）
    
# 示例
age = 16
if age > 18 :
    print('你已经成年啦！')
else:
    print('你还没有成年，请享受青春~')
# 输出 你还没有成年，请享受青春~
# 因为age并没有大于18，所以条件为假，所以打印这段话

（3）多分支结构（if-elif-else）

if+条件1 :
    执行内容1 # 条件1如果为真，则执行内容1（条件正确的情况下执行的内容）
elif+条件2 :
    执行内容3 # 条件1为假，而条件2为真，则执行条件2下的执行内容3
else:
    执行内容2 # 除条件1，条件2所描述的其他索引情况均执行内容2（条件错误的情况下执行的内容）


# 示例
age = 18
if age > 18:
    print('你已经成年了！')
elif age == 18:
    print('你刚刚迈入了成年人的世界！')
else:
    print('你还没有成年，请享受青春~')
    
# 输出 你刚刚迈入了成年人的世界！
# age=18 ，并不满足条件1（大于18），但是满足条件2（等于18），故输出执行内容3

（4）多层嵌套结构

  • 多层嵌套结构是将多个分支结构嵌套在一起形成的复杂结构。
  • 每一层的分支结构都可以根据不同的条件进行选择性的执行。
  • 多层嵌套结构的使用需要注意代码的可读性和维护性。

实例练习 1

# 定义一个字典 {'key':'value'} ---> 多用户登录功能
# 两个输入框 --- > 用户名和密码
# ---> 用户名和密码是否正确
# 正确 ：登陆成功
# 失败 ： 再输一次
# 再失败 ： 登录失败

个人答案（萌新一枚，供大伙批评指教）

# 定义用户登录密码
user_login = {'user': '001', 'lea4ning': '123', 'zwq': '456'}
# 用户输入用户名和密码
input_username = input('请输入用户名：>>>')
input_userPwd = input('请输入密  码：>>>')
# 程序进行运算
# 程序1 检查是否在库中，如果不在，提示重新赋值
if input_username not in user_login:  # 如果输入的用户名不在用户库中，输出‘用户不存在’
    print("用户不存在，请重新输入：>>>>")
    input_username = input('请输入用户名：>>>')    # 重新输入用户名，程序重新为用户名赋值
# 程序2 赋值正确则校验密码，若密码错误重新赋值
if input_username in user_login:    # 用户名重新赋值若正确，进入校验阶段
    if input_userPwd != user_login[input_username]:    # 校验输入的密码，错误的情况重新输入
        print("密码输入错误，请重新输入：>>>")
        input_userPwd = input('请输入密  码：>>>')    # 重新赋值密码
else:
    print("用户名不存在，请检查后重试~")
# 程序3 重新赋值内容正确，则输出登录成功
if input_userPwd == user_login.get(input_username):    # 校验重新输入的密码，正确的情况，输出登录成功
    print("密码输入正确")
    print(f"登录成功~欢迎{input_username}光临~")
else:
    print("登录失败！请检查后重启~")    # 密码经过第二遍赋值依旧错误，将输出登录失败

实例练习 2

# 使用字典模拟多用户登录功能 --- 多用户登录查看内容功能
# 字典格式 ： {'key':'value'}
# 定义一个字典 ： 用户登录和密码{'username':"password"}
# 定义一个字典 ： 字典中放 对应用户的全部信息 比如这个用户的 年龄/爱好/性别/身高
# 两个输入框 --- > 可以输入用户名和密码
# 比对用户名和密码是否正确
# 用户校验正确 ：登陆成功 并打印当前用户除 密码以外的其他信息
# 用户校验失败 ：再输一次
# 再失败 ： 登录失败，退出程序

个人答案（萌新一枚，供大伙批评指教）

# 定义字典
user_login = {'user': '001', 'lea4ning': '123', 'zwq': '456'}
user_info = {'user': {'age': 18, 'sex': 'man', 'hobby': 'run', 'height': 170},
             'lea4ning': {'age': 20, 'sex': 'man', 'hobby': 'badminton', 'height': 175},
             'zwq': {'age': 22, 'sex': 'superman', 'hobby': 'code', 'height': 180}
             }
# 设置输入
input_username = input('请输入用户名：>>>')
input_userPwd = input('请输入密  码：>>>')
# 程序输出
if input_username not in user_login:  # 如果输入的用户名不在用户库中，输出‘用户不存在’
    print("用户不存在，请重新输入：>>>>")
    input_username = input('请输入用户名：>>>')
if input_username in user_login:
    if input_userPwd != user_login[input_username]:
        print("密码输入错误，请重新输入：>>>")
        input_userPwd = input('请输入密  码：>>>')
if input_userPwd == user_login[input_username]:
    print("密码输入正确")
    print(f"""欢迎{input_username}登录，以下为您的信息
        用户姓名：{input_username}
        用户年龄：{user_info[input_username]['age']}岁
        用户性别：{user_info[input_username]['sex']}
        用户爱好：{user_info[input_username]['hobby']}
        用户爱身高：{user_info[input_username]['height']}cm
        """)
else:
    print("登录失败，请检查后重试~")

【4】循环结构

  • 循环结构是一种程序控制结构，用于反复执行一组语句，直到满足某个条件为止。

(1)while循环

语法

while condition:
    # 循环体

  • while 是循环的关键字。

  • condition 是循环的条件，当条件为真时，循环体会一直执行。

  • 循环体是需要重复执行的代码块。

    while True:
    print('nice')
# 此处while循环为死循环，因为True条件一直为真，故print('nice')一直运行
while 当条件为真时:
    持续执行代码块，除非条件出现变化，或者使用break函数

(2)for循环

语法

for variable in sequence:
    # 循环体
  • for 是循环的关键字。
  • variable 是循环变量，它会在每次循环中取 sequence 中的一个值。
  • sequence 是一个序列，可以是列表、元组、字符串等。
for i in [1, 2, 3, 4]:    # list
    print(i)
# 1 2 3 4  会按顺序提取列表[1,2,3,4]中的值
for i in (1, 2, 3, 4):    # tuple
    print(i)
# 1 2 3 4  会按顺序提取元组(1,2,3,4)中的值
for i in 'learn':    # str
    print(i)
# l e a r n 会按顺序提取字符串'learn'中的值

# 因为列表、元组、字符串都是可以通过下标索引提取内容

(3)退出循环

break:退出

1、语法
while condition:
    # 循环体
    if some_condition:
        break  # 退出循环
2、实例参考
username = "user"
password = "123"
count = 0
while count < 3:  # 第一层循环
    inp_name = input("请输入用户名：")
    inp_pwd = input("请输入密码：")
    if inp_name == username and inp_pwd == password:
        # 此处break内容解释，当用户名密码输入正确后，
        # 首先输出‘登录成功’，然后就可以通过break解除第一层循环
        print("登陆成功")
        while True:  # 第二层循环
            # 此处额外套入一层循环，且在第一层循环结束的break前，
            # 故需要先结束第二层循环才可以进行第一层循环的结束
            cmd = input('>>: ')
            if cmd == 'quit':
                break  # 用于结束本层循环，即第二层循环
            print(f'run <{cmd}>')
        break  # 用于结束本层循环，即第一层循环
    else:
        print("输入的用户名或密码错误！")
        count += 1

'''
如果没有进行循环的结束，将会在第二层循环结束后，继续进行第一层循环，重新输入用户名
'''

continue

1、语法
while condition:
    # 循环体
    if some_condition:
        continue  # 跳过当前循环，继续下一次循环
2、实例参考
count = 0

while count < 5:
    count += 1
    if count == 3:
        print(f'已跳过{count}')
        continue  # 当 count 等于 3 时，跳过当前循环，继续下一次循环
    print(count)
'''输出：
1
2
已跳过3
4
5
'''

(4)标志位

  • 自定义一个变量作为标志位
flag = True  # 初始化标志位
while flag:
    # 循环体
    if some_condition:
        flag = False  # 修改标志位，退出循环   

flag = True    # 标志位
count = 0    # 计数器
while count < 5 and flag:    # and 关键字连接的条件与标志位
    count += 1    # count每完成一次循环+1
    if count == 3:
        print(f"{count}:逢三归一")
        flag = False
    print(count)
    
# 输出：1 2 3:逢九归一 3
'''正常情况<5的数，有[1,2,3,4],
此处打印至3时，flag的值被变更为False，
and关键字关联的条件中有一方为False，则条件变为False，循环中止'''

(5)循环分支

while 条件:
    循环体
else:
    循环正常执行完毕且没被break关键字中止，将执行else语句下的内容
    如果执行过程被break关键字中止，将不会执行else语句

count = 0  # 计数器
while count < 3:
    count += 1  # count每完成一次循环+1
    print(count)    # 当count=3时，与循环语句<3不符，故循环结束
else:
    print('循环结束')
# 1 2 3 循环结束

(6)range关键字

#基本语法
for i in range(start, stop, step):
    # 循环体
# start 为起始内容
# stop 为终止内容
# step 为步长

# start 起始内容 
# 默认为0，且需要与stop成对使用，单独不可用

# stop 终止的内容
# 可单独使用
for i in range(3):    # for i in range(0,3)
    print(i)          # 0 1 2

# step 步长
# start与stop以step为间隔数，默认值为1
for i in range(1, 6):
    print(i)    # 1 2 3 4 5
    
for i in range(1, 6, 1):
    print(i)   # 1 2 3 4 5

for i in range(1, 6, 2):
    print(i)   # 1 3 5
# 若step设为0，将会报错【ValueError: range() arg 3 must not be zero】
  • 补充
# range + len 遍历序列
# 原理便是通过len()函数可以提取出序列的长度，而长度可以对应stop的值

list1 = [1,2,3]
for i in range(len(list1)):    # for i in range(0,3):
    print(list1[i])            # i的值为0 1 2 对应至list1[0],list1[1],lis1[2]

# 通过range()创建序列
list2 = list(range(1,4))    # list强转(range的值为(1,2,3))
print(list2)
# [1,2,3]

实例练习 1 (while循环分支嵌套)

# 登录功能
# ---> 存储 字典存储用户的登录信息
# 输入框输入 用户名和密码
# 可以尝试 3 次 ----> 用户名或密码错误的话就要重新输入了!
# 第一次的时候告诉你还有两次
# 最后一次的时候告诉你还愿意继续尝试吗？
# 如果选择继续尝试的话 ---> 继续尝试

个人答案（萌新一枚，供大伙批评指教）

user_info = {'user': '001'}  # 存储信息
count = 3  # 计数器
tag = True  # 标志符
# 进入循环
while count > 0 and tag:    # 当剩余次数不为1时，执行循环
    count -= 1    # 作为次数的计数期，执行一次，次数减1
    input_name = input("请输入用户名：>>>>")
    input_pwd = input("请输入密 码：>>>>")
    if input_name in user_info and input_pwd == user_info.get(input_name):   # 校验用户名和密码，正确直接退出
        print(f"欢迎{input_name}登录~祝您有美好的一天~")
        break
    else:
        print("用户名或密码有误，请检查后重新输入！")
        print(f"还有{count}次机会，请仔细检查~")    # 输入错误直接结束后续判断，重新输入用户名和密码
        if count == 0:    # 当次数归零，询问是否重新尝试
            answer = input("次数已经用完，请选择是否重试：y/n")
            if answer == 'y':    # 如果选择继续，将count的值重新添加至3次机会
                count = 3
            else:
                print("下次再见~")