@05.Python基本运算符

一.基本运算符的介绍

1.运算符概述

基本运算符.
运算符 是一种用来检查、改变或者合并值的特殊符号或组合符号；计算机可以进行的运算有很多种，可不单单只加减乘除这么简单

2.运算符的分类

运算的种类：
算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算

下面现在我们暂时只学习算数运算、比较运算、逻辑运算、赋值运算

二.基本运算符的使用

1.算数运算符

1》算数运算符的介绍

算术运算符也即数学运算符，用来对数字进行数学运算，比如产常见的加减乘除

2》 Python 常见的算术运算符

3》Python算术运算符的使用

+ ：加法运算符的使用 ；
（1）使用最简单的，和数学一样进行基本运算
（2）拼接字符串也可以使用 +

#基本运算
x = 50
y = 87
sum1 = x + y

n = 10.8
m = 23.3
sum2 = n + m

print(sum1,sum2)
print("sum1=%d, sum2=%.2f" % (sum1, sum2))


#print value：
137 34.1
sum1=137, sum2=34.10




#字符拼接
+用于数字时表示加法运算；但是当+用于字符串时，可以有对 str 拼接（将两个字符串连接为一个）的作用，如下：
name = "【一笑奈@何】"
url = "'https://blog.csdn.net/weixin_55972781'"
age = 1
info = name + "的URL是" + url + "，它已经" + str(age) + "岁了哦🔊🔊🔊。"
print(info)



#print value：
【一笑奈@何】的URL是'https://blog.csdn.net/weixin_55972781'，它已经1岁了哦🔊🔊🔊。

ps：str() 函数用来将整数类型的 age 转换成字符串

-： 减法运算符的使用
（1）减法运算的使用也和数学中一样
（2）减法运算符除了可以用作减法运算之外，还可以用作求负运算（正数变负数，负数变正数）

#基本运算
n = 23
m = -n

x = -88.8
y = -x

sum1 = y - m
sum2 = m - y

print(m)
print(y)
print(m)
print(sum1)
print(sum2)
print(m, y)
print(m, ",", y)


#print value：
-23
88.8
-23
111.8
-111.8
-23 88.8
-23 , 88.8




#正负转换 （-可以实现转换，+不可以的）
#案例1
x = 50
x_neg = -x

y = -66.6
y_neg = -y

print(x_neg)
print(y_neg)
print(x_neg + y_neg)
print(x_neg - y_neg)
print(x_neg, ",", y_neg)


#print value；
-50
66.6
16.599999999999994
-116.6
-50 , 66.6





#案列2
n = 22
m = +n

x = -88.5
y = +x

print(m)
print(y)
print(m, y)
print(m, ",", y)


#print value：
45
-83.5
45 -83.5
45 , -83.5

＊：乘法运算符的使用
（1）乘法运算符也类似数据乘法运算
（2）可以重复输出字符串

#基础运算
x = 2 * 150
y = 22.2 * 2


print(x)
print(y)
print(x, y)
print(x, ",", y)



#print value：
300
44.4
300 44.4
300 , 44.4



#重复字符串（* 除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来）
str1 = "hello  world；"
str2 = "zeny；"

print(str1 * 3)
print(str2 * 6)



#print value：
hello  world；hello  world；hello  world；
zeny；zeny；zeny；zeny；zeny；zeny；

/ & // ：除法运算符的时使用
Python 支持 / 和 // 两个除法运算符； 但 / 和 // 是有区别的
（1）/ 表示普通除法，使用它计算出来的结果和数学中的计算结果相同。
（2）// 表示整除，只保留结果的整数部分，舍弃小数部分；注意是直接丢掉小数部分，而不是四舍五入

#整数不能除尽
print("-------------------------")
x = 25/3
print("25/3 =", x)
print("25//3 =", 25//3)
print("25.0//3 =", 25.0//3)
print("-------------------------")

#整数能除尽
y = 25/5
print("25/5 =", y)
print("25//5 =", 25//5)
print("25.0//5 =", 25.0//5)
print("-------------------------")

#小数除法
print("22.2/5.5 =", 22.2/5.5)
print("22.2//5.5 =", 22.2//5.5)
print("-------------------------")




#print value：
-------------------------
25/3 = 8.333333333333334
25//3 = 8
25.0//3 = 8.0
-------------------------
25/5 = 5.0
25//5 = 5
25.0//5 = 5.0
-------------------------
22.2/5.5 = 4.036363636363636
22.2//5.5 = 4.0
-------------------------



#从以上我们可以发现到：
1》 / 的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。
2》 如果是整数运算，不管是否可以除尽，//的 结果都是整数；当有小数参与运算时，//结果才是小数

% ：求余运算符的使用
% 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数

#整数求余数
print("-------------1-----------")
print("25%6 =", 25 % 6)
print("-25%6 =", -25 % 6)
print("25%-6 =", 25 % -6)
print("-25%-6 =", -25 % -6)


#小数求余数
print("-----------2--------------")
print("8.88%3.3 =", 8.88 % 3.3)
print("-8.88%3.3 =", -8.88 % 3.3)
print("8.88%-3.3 =", 8.88 % -3.3)
print("-8.88%-3.3 =", -8.88 % -3.3)


#整数于小数运算求余
print("-----------3---------------")
print("55.5%6 =", 55.5 % 6)
print("55%6.5 =", 55 % 6.5)
print("55.5%-6 =", 55.5 % -6)
print("-55%6.5 =", -55 % 6.5)
print("-55%-6.5 =", -55 % -6.5)




#print value：
----------------1----------------
25%6 = 1
-25%6 = 5
25%-6 = -5
-25%-6 = -1
----------------2----------------
8.88%3.3 = 2.280000000000001
-8.88%3.3 = 1.0199999999999987
8.88%-3.3 = -1.0199999999999987
-8.88%-3.3 = -2.280000000000001
---------------3-----------------
55.5%6 = 1.5
55%6.5 = 3.0
55.5%-6 = -4.5
-55%6.5 = 3.5
-55%-6.5 = -3.0




#由以上可以得出特点：
1》当第二个数字是负数时，求余的结果也是负数；总之，求余结果的正负和第一个数字没有关系，只由第二个数字决定。
2》% 两边的数字都是整数时，求余的结果也为整数；但是当其中一个为小数时，求余的结果也为小数。

** ：次方（乘方）运算符的使用
Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符
由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算

#次方运算
print('-------------1-----------')
print('2**3 =', 2**3)
print('3**4 =', 3**4)
print('4**5 =', 4**5)


#开放运算
print('------------2------------')
print('8**(1/3) =', 8**(1/3))
print('81**(1/4) =', 81**(1/4))
print('1024**(1/5) =', 1024**(1/5))



#print value：
------------1-----------
2**3 = 8
3**4 = 81
4**5 = 1024
-----------2------------
8**(1/3) = 2.0
81**(1/4) = 3.0
1024**(1/5) = 4.0

2. 比较运算符

1》比较运算符的介绍

比较运算符： 也指关系运算符，用于对常量、变量或表达式的结果进行大小比较。如果这种比较是成立的，则返回 True（真），反之则返回 False（假）
True 和 False 都是 bool 类型，它们专门用来表示一件事情的真假，或者一个表达式是否成立

2》Python常见的比较运算符

3》Python比较运算符的使用

> ， < ， == ， >=， <=， <>， !=

print("----------------------1---------------------")
print("88是否大于99：", 88 > 99)
print("25*4是否大于等于80：", 25 * 4 >= 80)
print("25*4是否小于等于80：", 25 * 4 <= 80)
print("88.5是否等于88.5：", 88.5 == 88.5)
print("22是否等于22.0：", 22 == 22.0)
print("33.0是否等于33：", 33.0 == 33)
print("44.4是否不等于33.3：", 44.4 != 33.3)
print("44.4是否大于33.3：", 44.4 > 33.3)
print("----------------------2---------------------")
print("False是否大于True：", False > True)
print("False是否小于True：", False < True)
print("False是否等于True：", False == True)
print("True是否大于True：", True > True)
print("True是否小于True：", True < True)
print("True是否等于True：", True == True)
print("False是否等于False：", False == False)





#print value：
----------------------1---------------------
88是否大于99： False
25*4是否大于等于80： True
25*4是否小于等于80： False
88.5是否等于88.5： True
22是否等于22.0： True
33.0是否等于33： True
44.4是否不等于33.3： True
44.4是否大于33.3： True
----------------------2---------------------
False是否大于True： False
False是否小于True： True
False是否等于True： False
True是否大于True： False
True是否小于True： False
True是否等于True： True
False是否等于False： True

== 和 is 之间的区别：
（1）is比较的是id
（2）==比较的是值
== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象

（1）time 模块的 gmtime() 方法用来获取当前的系统时间，精确到秒级，因为程序运行非常快，所以 t1 和 t1 得到的时间是一样的。== 用来判断 t1 和 t2 的值是否相等，所以返回 True。
（2）虽然 t1 和 t2 的值是相等，但它们是两个不同的对象（每次调用 gmtime() 都返回不同的对象），所以t1 is t2返回 False。好比两个双胞胎，虽然外貌是一样的，但是本质它们是两个人

那么，如何判断两个对象是否相同呢？额🔊🔊🔊
首先判断两个对象的内存地址是否相同，如果内存地址相同，说明这恶两个两个对象使用的是同一块内存，当然就是同一个对象了；这就像我们自己的名字，小时候的名字和工作时候用的名字，虽然不一样，但本质是一样的，当然就是同一个人了呢

import time  # 引入time模块

t1 = time.gmtime()  # gmtime()用来获取当前时间
t2 = time.gmtime()
print(time.gmtime())
print(t1 == t2)     # 输出True
print(t1 is t2)     # 输出False



#print value：
time.struct_time(tm_year=2022, tm_mon=4, tm_mday=9, tm_hour=16, tm_min=46, tm_sec=30, tm_wday=5, tm_yday=99, tm_isdst=0)
True
False

3.赋值运算符

1》赋值运算符的介绍

赋值运算符用来把右侧的值传递给左侧的变量（或者常量）
可以直接将右侧的值交给左侧的变量，也可以进行某些运算后再交给左侧的变量，比如：加减乘除、函数调用、逻辑运算等

2》Python常见的赋值运算符

3》Python赋值运算符的使用

= 连续赋值

c = 90 表示将 90 赋值给 c，所以 c 的值是 90；同时，c = 90 这个子表达式的值也是 90。
b = c = 90 表示将 c = 90 的值赋给 b，因此 b 的值也是 90。
以此类推，a 的值也是 90

由此可得，a、b、c 三个变量的值都是 90

a = b = c = 90

= 和 ==区别：
= 和 == 是两个不同的运算符，= 是用来赋值，而 == 用来判断两边的值是否相等

n = 50
m = 22.22
n -= 20  # 等价于 n=n-20
m *= n - 5  # 等价于 m=m*( n - 5 )

print("n=%d" % n)
print("m=%.2f" % m)


#print value:
n=30
m=555.50

4.逻辑运算符

1》逻辑运算符的介绍

逻辑运算，例如 ：a为真命题，b 为假命题，那么“a且b”为假，“a或b”为真，“非b”为真

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

2》Python常用的逻辑运算符

3》Python逻辑运算符的使用

三者的优先级关系：not>and>or，同一优先级默认从左往右计算

a = 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
print(a)


#print value：
False

#使用括号来区别优先级,其实意义与上面的一样
a = 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
b = (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
print(a)
print(b)


#print value:
False
False

短路运算： 逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回

a = 10 and 0 or '' and 0 or 'aaa' or 'zeny' == 'hzl'and 222 or 10 > 4
# 用括号来明确一下优先级
b = (10 and 0) or ('' and 0) or 'aaa' or ('zeny' == 'hzl' and 222) or 10 > 4

print(a)
print(b)
print(a, b)



#print value:
aaa
aaa
aaa aaa




#解析短路运算
短路：       0      ''            'aaa'                    
            假     假              真

返回：                            'aaa'

常见短路运算面试题：

a = 1 or 3

b = 1 and 3

c = 0 and 2 and 1

d = 0 and 2 or 1

e = 0 and 2 or 1 or 4

f = 0 or False and 1

print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
print(a, b, c, d, e, f)
print("zeny" or "")
print(22.22 or "zeny")


#print value：
1
3
0
1
1
False
1 3 0 1 1 False
zeny
22.22

三.Python格式化输出

python格式化输出：指的print（）函数，使用以%开的，对输出的字符串进行格式化输出

1.转换符的介绍

转换说明符（Conversion Specifier）：
转换符，它只是一个占位符，也相当于一个定义好的模板，通过转换符的 本质，调用表达式的结果，进行格式化输出；它会被后面表达式（变量、常量、数字、字符串、加减乘除等各种形式）的值代替

2.常见的转换符

常见的转换符如下所示：对于输出进行格式化，可以选择对应的格式化转换符即可

3.转换符的使用

%d 的介绍，其实其余的转换符用法都类似

#案列：
name = "zeny"
age = 1

print("【一笑奈何】的名字是" + name + "他已经到CSDN %d年了哇！哈哈是📣📣📣" % age)



#print value：
【一笑奈何】的名字是zeny他已经到CSDN 1年了哇！哈哈是📣📣📣

格式化字符串，我们也可以包含多个转换说明符，这个时候也得提供多个表达式，用以替换对应的转换说明符；多个表达式必须使用小括号( )包围起来

#升级案例：
name = "【一笑奈何】"
age = 1
url = "https://blog.csdn.net/weixin_55972781"

print("%s已经到CSDN %d 年了哦，它的web网址是%s哦 ！📸📸📸" % (name, age, url))


#print value：
【一笑奈何】已经到CSDN 1 年了哦，它的web网址是https://blog.csdn.net/weixin_55972781哦 ！📸📸📸

小结：我们从以下案列运行结果可以发现，对于整数和字符串，当数据的实际宽度小于指定宽度时，会在左侧以空格添加补齐；当数据的实际宽度大于我们指定宽度时，会按照数据的实际宽度输出，不会添加空格补齐的，在这里有指定的最小宽度和大于实际数据的宽度，当数据的实际宽度足够时，指定的宽度就没有实际意义了。
如下所示：

#继续升级案列
name = "zney"
age = 1
url = "https://blog.csdn.net/weixin_55972781"

print("age(5):%5d." % age)
print("age(10):%10d." % age)
print("name(15):%15s" % name)
print("🎁age(20):%20d，🎁name(20):%20s" % (age, name))

print("url(25):%25s." % url)
print("url(30):%30s." % url)  # 指定的宽度小于实际数值的宽度
print("url(30):%50s." % url)  # 指定的宽度大于实际数值的宽度




#print value:
age(5):    1.
age(10):         1.
name(15):           zney
🎁age(20):                   1，🎁name(20):                zney
url(25):https://blog.csdn.net/weixin_55972781.
url(30):https://blog.csdn.net/weixin_55972781.
url(30):             https://blog.csdn.net/weixin_55972781.

4.Python数据对齐方式

🎁在平常我们使用print()函数时，默认print() 输出的数据总是右对齐的；总之也就是说，当我们输出数据宽度不够长时，数据总是靠右边输出，而在左边补充空格以达到指定的宽度。
🎁Python 中，也是允许在最小宽度之前增加一个标志，可以改变数据的对齐方式；

1》Python支持的标志

2》标志说明

✨整数 （int）：指定左对齐时，在右边补 0 是没有效果的，因为这样会改变整数的值。
✨小数（float）：以上三个标志可以同时存在。
✨字符串（str）：只能使用-标志，因为符号对于字符串没有意义，而补 0 会改变字符串的值

3》标志使用

x = 2022
y = 2022.4
n = "Hello 2022.4.10"

print("x(010):%010d🐱‍💻；" % x)      # %010d 表示最小宽度为10，左边补0
print("x(+10):%+10d🐱‍💻；" % x)      # %+10d 表示最小宽度为10，并且带上符号+
print("y(-+020):%-+020f🐱‍💻；" % y)  # %-+020f 表示最小宽度为20，左对齐，带上符号+
print("y(-+20):%-+20f🐱‍💻；" % y)    # %-+20f 表示最小宽度为20，左对齐，带上符号+
print("n(-030):%-030s🐱‍💻；" % n)    # %-030s 表示最小宽度为30，左对齐，下一个数据与标志的数据空格30
print("n(-30):%-30s🐱‍💻；" % n)      # %-30s 表示最小宽度为30，左对齐，下一个数据与标志的数据空格



#print value：
x(010):0000002022🐱‍💻；
x(+10):     +2022🐱‍💻；
y(-+020):+2022.400000        🐱‍💻；
y(-+20):+2022.400000        🐱‍💻；
n(-030):Hello 2022.4.10               🐱‍💻；
n(-30):Hello 2022.4.10               🐱‍💻；

5.Python指定小数精度（float）

✨浮点数（float），print() 函数还可以指定小数点后的数字位数，指定小数的输出精度
✨浮点数值需要放在最小宽度之后，中间用点号.隔开，也可以不写最小宽度，只写浮点数的位数

✨浮点数的输出位数格式设定： n 表示最小宽度，m 表示输出的位数即精度，. 是必须存在的
%n.mf
%.mf

n = 3.141592653

print("%10.4f" % n)   # 最小宽度为10，小数点后保留4位
print("%010.4f" % n)  # 最小宽度为10，小数点后保留4位，左边补0
print("%+010.4f" % n) # 最小宽度为10，小数点后保留4位，左边补0，带符号
print("%+015.5f" % n) # 最小宽度为15，小数点后保留5位，左边补0，带符号



#print value：
    3.1416
00003.1416
+0003.1416
+00000003.14159

四.Python数据类型转换

Python 是弱类型编程语言,咋一定的场景中，还是需要用到类型转换

1.Python常见的数据类型转换

2.数据类型转换使用

✨数据类型转换比较简单，就介绍一个特殊的吧
✨使用类型转换函数时，提供给转换的数据必须是有意义的，
例：int() 函数无法将一个非数字字符串转换成整数

print(int("2022"))
print(int("202204")) 
print(str("2022.4"),type(str("2022.4")))      #转换成功，但是结果属性为str
print(float("2022.4"),type(float("2022.4")))  #转换成功，但是结果属性为float
print(int("2022.4"))    #不支持转换，转换失败滴
print(int("2022年4月")) #不支持转换，转换失败滴




#print value：
2022
202204
2022.4 <class 'str'>
2022.4 <class 'float'>
ValueError: invalid literal for int() with base 10: '2022.4'



ps：由上可以看出，输出结果与字符的类型关系不是绝对的，只与转换后的数据类型有关系 ；并且，出现转换识失败后，会终止运行 

五.Python字符转义

1.Python支持的转义字符

转义字符在书写的形式上由多个字符组成，但 Python 将它们看作是一个整体，表示一个字符

2.转义字符的使用

✨使用\t排版
✨使用\n在输出时换行，\在书写字符串时换行

str1 = 'web网站\t\t\t域名\t\t\t\t\t\t\t\t\t\t年份\t\t价值'
str2 = '百度\t\t\twww.baidu.com\t\t\t\t\t\t\t\t20\t\t\t5000000W'
str3 = 'CSDN\t\t\tblog.csdn.net\t\t\t\t\t\t\t\t10\t\t\t100000W'
str4 = '【一笑奈何】\t\thttps://blog.csdn.net/weixin_55972781\t\t1\t\t\t100W'
str5 = 'web网站\t\t\t域名'
# 同行进行换行
info = "CSDN：\t\t\thttps://blog.csdn.net\n\     
一笑奈何博客1：\thttps://blog.csdn.net/weixin_55972781\n\
一笑奈何博客2：\thttps://www.cnblogs.com/heziliang/"



print("--------------------------------------------------------------------------------")
print(str1)
print(str2)
print(str3)
print(str4)
print("--------------------------------------------------------------------------------")
print(str5)
print(info)
print("--------------------------------------------------------------------------------")





#ptint value：
--------------------------------------------------------------------------------
web网站			域名										    年份		    价值
百度			    www.baidu.com								20			5000000W
CSDN			blog.csdn.net								10			100000W
【一笑奈何】		https://blog.csdn.net/weixin_55972781		1			100W
--------------------------------------------------------------------------------
web网站			域名
CSDN：			https://blog.csdn.net
一笑奈何博客1：	https://blog.csdn.net/weixin_55972781
一笑奈何博客2：	https://www.cnblogs.com/heziliang/
--------------------------------------------------------------------------------