运算符，分支了解

.訨.

已于 2024-08-20 11:17:49 修改

阅读量323

点赞数 5

文章标签： python

于 2024-08-20 11:08:07 首次发布

本文链接：https://blog.csdn.net/qq_41936563/article/details/141352997

版权

1. 关于字典类型

# {"key":"value"}
# key : 可以是任意类型，但是不建议放，不可变数据类型，字符串

2. 元组类型（tuple）

2.1 作用

元组（tuple）是一种不可变的序列类型，类似于列表，用于存储多个有序元素。
元组与列表的主要区别在于元组的元素不能被修改、删除或添加，是不可变的数据类型。
元组通常用于存储相关联的数据，保持数据的完整性。

2.2 定义

元组通过小括号 () 定义，其中的元素可以是不同的数据类型，用逗号 , 分隔。
可以使用索引访问元组的元素。

# 定义元组
my_tuple = (1, 'hello', 3.14, True)

# 访问元组元素
first_element = my_tuple[0]
second_element = my_tuple[1]

print(first_element)  # 1
print(second_element)  # 'hello'

2.3 使用

2.3.1 元组的不可变性

由于元组是不可变的，不能对元素进行修改、删除或添加。

# 尝试修改元组的元素（会报错）
my_tuple[0] = 42  # TypeError: 'tuple' object does not support item assignment

# 尝试删除元组的元素（会报错）
del my_tuple[1]  # TypeError: 'tuple' object doesn't support item deletion

# 尝试添加元素到元组（会报错）
my_tuple.append('new_element')  # AttributeError: 'tuple' object has no attribute 'append'

2.3.2 元组的基本操作

元组支持基本的操作，如切片、拼接等。

# 切片操作
sliced_tuple = my_tuple[1:3]
print(sliced_tuple)  # ('hello', 3.14)

# 拼接操作
new_tuple = my_tuple + ('world', False)
print(new_tuple)  # (1, 'hello', 3.14, True, 'world', False)

2.3.3 元组解包

元组解包是一种将元组中的元素分配给多个变量的方法。

# 元组解包
my_tuple = (1, 'hello', 3.14, True)
a, b, c, d = my_tuple

print(a)  # 1
print(b)  # 'hello'
print(c)  # 3.14
print(d)  # True

3 什么是用户交互

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

4 为什么要与用户交互

为了让计算机能够像人一样与用户沟通交流

5 python中会如何交互

5.1 输入（input）

5.1.1 弹出输入框

input（）

5.1.2 提示信息

print（”请输入用户名“）
input（）

username = input("请输入你的用户名:>>>")
password = input('请输入你的密码:>>>')

print(username, type(username))  # input接受的所有数据类型都是str类型
print(password, type(password))  # input接受的所有数据类型都是str类型

5.1.3 数据之间进行运算需要转换数据类型

num_1 = inpute("请输入数字1：>>>")
num_2 = inpute("请输入数字2：>>>")
result = num_1 + num_2
print(result) #1  2   12 ( 字符串类型)
# 强制数据类型转换--->  将符合当前数据类型的格式数据转换成指定的数据类型
result = int(num_1)+int(num_2)
print(result)  #1 1  2

5.2 输出（print）

5.2.1 简单字符串

print函数用于向控制台输出信息,你可以使用print函数来显示程序的运行结果、提示信息等。

# 输出示例
print("Hello, World!")  # 输出简单的字符串
# Hello, World!

5.2.2 多个变量输出

print函数可以输出多个值，用逗号隔开。输出时，各个值之间默认使用空格分隔

print(f"my name is", name, "my age is", age)

5.2.3 默认 end 参数

#print 可以修改默认的尾椎
# 默认自带一个结束符，换行符，我们可以通过 end 参数修改默认的结束符

# end 参数示例
print("Hello", end="")
print(", World!")  # 输出结果为：Hello, World!  

#  将end参数的值改成任意其它字符
print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')
#整体输出结果为：aaaabbbb&cccc@

6. 运算符

6.1算数运算符

python支持的算数运算符与数学上计算的符号使用是一致的

- 我们以x=9，y=2为例来依次介绍它们

6.1.1 加法运算符 +

x = 9
y = 2
result = x + y
print(result)  # 输出：11

6.1.2 减法运算符 -

x = 9
y = 2
result = x - y
print(result)  # 输出：7

6.1.3 乘法运算符 *

x = 9
y = 2
result = x * y
print(result)  # 输出：18

6.1.4 除法运算符 /

x = 9
y = 2
result = x / y
print(result)  # 输出：4.5

6.1.4 取整除运算符 //

x = 9
y = 2
result = x // y
print(result)  # 输出：4

6.1.5 求余数运算符 %

x = 9
y = 2
result = x % y
print(result)  # 输出：1

6.1.6 幂运算符 **

x = 9
y = 2
result = x ** y
print(result)  # 输出：81

6.2 比较运算符

比较运算用来对两个值进行比较，返回的是布尔值True或False

我们以x=9，y=2为例来依次介绍它们

6.2.1 相等运算符 ==

x = 9
y = 2
result = x == y
print(result)  # 输出：False

6.2.2 不等运算符 !=

x = 9
y = 2
result = x != y
print(result)  # 输出：True

6.2.3 大于运算符 >

x = 9
y = 2
result = x > y
print(result)  # 输出：True

6.2.4 小于运算符 <

x = 9
y = 2
result = x < y
print(result)  # 输出：False

6.2.5 大于等于运算符 >=

x = 9
y = 2
result = x >= y
print(result)  # 输出：True

6.2.6 小于等于运算符 <=

x = 9
y = 2
result = x <= y
print(result)  # 输出：False

6.3 赋值运算符

python语法中除了有=号这种简单的赋值运算外
还支持增量赋值、链式赋值、交叉赋值、解压赋值
这些赋值运算符存在的意义都是为了让我们的代码看起来更加精简。

- 我们以x=9，y=2为例先来介绍一下增量赋值

6.3.1 增量赋值

增量赋值运算符用于将变量与右侧的表达式相结合，并将结果赋值给变量。
这样可以简化表达式，提高代码的可读性。

# = += -= *= /= %= //= **=
# += 增量赋值
num_one = 2
num_one += 1  # num_one = num_one + 1
print(num_one)
num_two = num_one + 1
num_two += num_one
print(num_two)   # 7

x = 9
y = 2

# 等同于 x = x + y
x += y
print(x)  # 输出：11

在上述例子中，x += y 等同于 x = x + y，它表示将变量 x 的值与 y 相加，并将结果赋值给 x。

6.3.2 链式赋值

链式赋值允许在单一语句中给多个变量赋值。这样可以减少代码行数，提高代码的紧凑性。

a = b = c = 5
print(a, b, c)  # 输出：5 5 5

6.3.3 交叉赋值

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

x = 8
y = 9
x, y = y, x
print(x, y)  # 9 8

6.3.4 解压赋值

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

coordinates = (3, 5)

# 解压赋值
x, y = coordinates
print(x, y)  # 输出：3 5

# 解压赋值
a, b = (1, 2)
print(a, b)
# 位置变量名少了不行
# a, b = (1, 2, 3)
# 位置变量名多了不行
# a, b, c, d = (1, 2, 3)
# 使用下划线代替多余的元素
_, b, _ = (1, 2, 3)
print(b)  #2

6.4 逻辑运算符

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

6.4.1 与运算符 (and)

与运算符 and在两个条件都为 True时，返回 True；如果其中一个条件为 False，则返回 False。

x = 5
y = 10

result = (x > 0) and (y > 0)
print(result)  # 输出：True

6.4.2 或运算符 (or)

或运算符 or 在两个条件中至少有一个为 True 时，返回 True；如果两个条件都为 False，则返回 False。

x = -5
y = 10

result = (x > 0) or (y > 0)
print(result)  # 输出：True

6.4.3 非运算符 (not)

非运算符 not 用于对一个条件取反，如果条件为 True，则返回 False；如果条件为 False，则返回 True。

6.5 连续问题

6.5.1 连续多个 and

在连续多个 and 运算中，如果其中一个条件为 False，则整个表达式的结果为 False，即使后面的条件都为 True。

x = 5
y = 10
z = 15

result = (x > 0) and (y > 0) and (z > 0)
print(result)  # 输出：True

6.5.2 连续多个 or

在连续多个 or 运算中，如果其中一个条件为 True，则整个表达式的结果为 True，即使后面的条件都为 False。

x = 5
y = 10
z = -15

result = (x > 0) or (y > 0) or (z > 0)
print(result)  # 输出：True

6.6 优先级 not>and>or

# 如果出现多个 逻辑运算符连在一起的时候优先级
# 优先级：先 not 再 and 最后 or
print(3 > 4 and 4 > 3 or 1 == 3 and 'x' == 'x' or 3 > 3)
# False     and       True  or    Flase      and    True   or   Flase
# false  or false or flase
# false

print(10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4)
#  10  and   0   or  false and false or "abc"  or false  adn 333 or true
#        false or flase or "abc"  or false or true
#  false or "abc" or false or true
#  "abc" or false or true
#  "abc" or true
#  "abc"
print("abc")

6.7 成员运算符

成员运算符用于测试序列是否包含特定的元素。可以用于字符串、列表、元组等序列类型的数据。

6.7.1 in运算符

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

fruits = ["apple", "banana", "cherry"]

print("banana" in fruits)  # True
print("orange" in fruits)  # False

6.7.2 not in运算符

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

fruits = ["apple", "banana", "cherry"]

print("banana" not in fruits)  # False
print("orange" not in fruits)  # True

6.8 身份运算符

身份运算符用于比较对象的内存地址，即判断两个对象是否指向同一块内存地址

6.8.1 is运算符

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

a = [1, 2, 3]
print('a', id(a))
b = a
print('b', id(b))
c = [1, 2, 3]
print('c', id(c))
# 因为 a 是b来的所以a是b
print(a is b) 
# 因为a 和 c 是两个独立的内存空间，所以 a 不是 c

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is b)  # True
print(a is c)  # False

6.8.2 is not运算符

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

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a is not b)  # False
print(a is not c)  # True

6.8.3 补充 ==和 is

# 比较运算符，比较的值先相等
# == 比较的是 值是否相等
# is 比较的是 内存空间地址
x = 'Info Tony:18'
y = 'Info Tony:18'
print(id(x), id(y))  # x与y的id不同，但是二者的值相同
# 3158064309168 3158064309168

print(x == y)  # 等号比较的是value
# True

print(type(x), type(y))  # 值相同type肯定相同
# (<class 'str'>, <class 'str'>)

print(x is y)  # is比较的是id，x与y的值相等但id可以不同
# True

7 流程控制(if-elif-else)

7.1 流程控制语句介绍

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

- 可以通过控制语句实现更丰富的逻辑以及更强大的功能。
- 几乎所有编程语言都有流程控制语句，功能也都基本相似。

其流程控制方式有

- 顺序结构（依次向下执行）
- 分支结构 (相当于给了两个条件来进行判断)
- 循环结构 (直到条件为否才结束当前循环)

这里最简单最常用的就是顺序结构，即语句从上至下一一执行

7.2 顺序结构

在计算机程序中，顺序结构是指按照代码书写的顺序，一条语句接着一条语句执行，没有跳过、重复或其他特殊的结构。
程序按照从上到下的顺序逐行执行，直到报错或者程序条件为否的情况才会终

7.3 分支结构

# 可以在执行程序的过程中加一些判断条件
# 只有判断条件为真的情况才会执行代码
# 如果我的分数 > 90 打印优秀

7.3.1 单分支结构(if)

单分支结构指的是程序根据条件的成立与否，执行两个分支中的其中一个。
常见的单分支结构语法是if语句。

（1）语法

if 条件:
    # 如果条件成立，执行这里的代码块  #前面空的是四个空格
    
# score = 89
# if score > 90:
#     # 这里面的代码我们称之为代码体/代码块
#     print(f"当前成绩为 {score} ， 评级为优秀!")
# print(f"111")

# 单分支结构会依次向下执行代码# 并且在遇到条件时进行判断，如果条件为真则执行当前代码提

Python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行
条件可以是任意表达式，但执行结果必须为布尔类型
在if判断中所有的数据类型也都会自动转换成布尔类型

- None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False
- 其余均为True

7.4 双分支结构(if-else)

双分支结构也是根据条件的成立与否，选择性地执行不同的代码块。
与单分支结构不同的是，双分支结构有两个分支，分别对应条件成立和条件不成立的情况。

（1）语法

if 条件:
    # 如果条件成立，执行这里的代码块
else:
    # 如果条件不成立，执行这里的代码块

双分支结构用于在条件成立时执行一个代码块，在条件不成立时执行另一个代码块。例如：

age = 16
if age >= 18:
    print("你已成年，可以参加投票。")
else:
    print("你还未成年，不能参加投票。")

# if score >= 90:
#     print(f" {score} 优秀")
# else:
#     print("不优秀")
# print(11)
# 双分支条件：有一个条件做约束，如果当前条件不符合，则会进入到另一个条件的代码体中

7.5 多分支结构(if-elif-else)

多分支结构是在双分支结构的基础上扩展，它包含多个分支，每个分支都对应不同的条件。
程序根据条件的成立情况选择性地执行相应的代码块。

(1) 语法

if 条件1:
    # 如果条件1成立，执行这里的代码块
elif 条件2:
    # 如果条件1不成立且条件2成立，执行这里的代码块
else:
    # 如果条件1和条件2都不成立，执行这里的代码块

(2) 使用

score = 69
if score >= 90:
    print(f"{score} :>>>> 优秀")
elif score >= 80:
    print(f"{score} :>>>> 良好")
elif score >= 70:
    print(f"{score} :>>>> 及格")
else:
    if score >= 60:
        print(f"差及格还有一丢丢")
    else:
        print(f"{score} :>>>> 不及格")

7.6 循环结构

 循环结构
# 一个条件不符合我当前状态的时候我可能还会二次判断
# 密码尝试上 可以进行多次密码的尝试
while 条件(循环截止的条件):
# 代码体

# 达到某个条件的时候想结束当前循环
 continue
# 结束整个循环
 break

 while True:
     score = int(input("请输入成绩：》》》》"))
     if score >= 90:
         print(f"优秀")
     else:
         print(f"不及格")

count = 0
while count <=9:
    count += 1
    if count == 1:
        print("这是 1 ")
    elif count == 3:
        print("这是 3 ")
        # 结束本次循环
        continue  # 走到continue 以后就不会继续乡下执行代码，而是回到了  while 条件重新进入当前循环
    elif count == 5:
        print(f"这是 :>>> {count}")
        break # 类似于程序出现错误直接将当前程序打断
    print(count)