Python笔记3-常用运算符&if语句一

一、常用运算符【重点掌握】

1.算术运算符

运算符 说明

a = 5
b = 3

# 1.+  -
print(a + b)
print(a - b)

# 2.*  /
# 数学上，2 + 3a----->编程里，2 + 3 * a
print(a * b)
print(a / b)

print(0.2 * 5)   # 1.0
print(10.0 / 2)  # 5.0
print(10 / 2.0)  # 5.0
print(10.0 / 2.0)  # 5.0

# 3.//
# 注意：//的结果是/的结果的整数部分，不涉及四舍五入
print(a // b)   # 1

# 4.%
print(a % b)  # 2

"""
注意：
    a.//，%和/本质上都是进行除法运算
    b.只要有浮点数参与运算，运算的结果都是浮点型
"""

# 5.**
print(a ** b)
print(b ** a)
print(3 ** 2)


# 6.在算术运算符中，**的优先级是最高的
print(2 * 5 ** 3)    # 250
# 如果表达式中出现不同优先级的运算符，可以通过()提高优先级
print((2 * 5) ** 3)  # 1000

2.赋值运算符

        运算符          	  说明   
         =           	简单赋值运算符

+=、-=、*=、/=、%=、//=、**=等 复合赋值运算符

# 1.=
# 作用：主要用于定义变量或者给变量赋值
# 注意：不管=右边的表达式如何复杂，永远都是计算=右边表达式的结果，然后给=左边的变量进行赋值
# num = 3 + 5 * 5 - 3 // 247

num1 = 10    # 定义变量
num1 = 20    # 重新赋值


# 2.+=  -=  *=  /=   //=  %=  **=
# 作用：给指定的变量进行计算，并给该变量重新赋值
m1 = 5
print(m1)
m1 += 2    # 等价于m1 = m1 + 2
print(m1)

m2 = 10
print(m2)
m2 %= 2   # 等价于m2 = m2 % 2
print(m2)

3.关系运算符

运算符 说明
== 相等
!= 不相等

大于 

< 小于

= 大于等于
<= 小于等于

# 关系运算符：比较运算符，条件运算符
# 注意：关系运算符比较的结果无非两个结果，结果都是布尔类型，如果成立则是True，如果不成立则是False

# 使用场景：一般结合if语句或while语句使用

# 1.
print(3 > 5)
print(3 < 5)
print(3 >= 5)
print(3 <= 5)
print(3 == 5)
print(3 != 5)

print("*" * 30)

# 2.支持关系比较的常用类型
# a.数字

# b.字符串
# 字符串之间能够支持关系运算符的比较，底层依据的是ASCII码
print("abc" > "xyz")
print("abc" < "xyz")  # True

print('0' < 'a')
print('A' < 'a')

"""
常见ASCII码的大小规则：0~9<A~Z<a~z。
1）数字比字母要小。如 “7”<“F”；
2）数字0比数字9要小，并按0到9顺序递增。如 “3”<“8” ；
3）字母A比字母Z要小，并按A到Z顺序递增。如“A”<“Z” ；
4）同个字母的大写字母比小写字母要小32。如“A”<“a” 。
5)几个常见字母的ASCII码大小： “A”为65；“a”为97；“0”为 48
"""

4.逻辑运算符

逻辑运算符是用来做逻辑计算的，就像之前用到的比较运算符 ，每一次比较其实就是一次条件判断，都会得到一个相应的True或者False的值，而逻辑运算符的操作数就是一个用来做条件判断的表达式或者变量

运算符 说明
and 与
or 或
not 非

重点：短路原则

a.A and B,如果A为False，不需要计算B的值，整个表达式的结果为False

b.A or B,如果A为True，不需要计算B的值，整个表达式的结果为True

c.and和or混合使用

1>表达式从左往右运算，如果or的左侧为True，则会短路or后面所有的表达式【不管是and还是or连接】，整个表达式的结果为True

2>表达式从左往右运算,如果and的左侧为False,则短路后面所有的and，直到or出现，接着计算

3>如果or的左侧为False，或者and的左侧为True，则不能使用短路逻辑判断

注意：所有被短路的表达式均不会被输出

"""
假：False  0  0.0  ""  []  ()  {}  None等
真：除了假之外的数据
"""


# 1.and:与
"""
真  and  真 = 真
真  and  假 = 假
假  and  真 = 假
假  and  假 = 假

规律：一假为假，全真为真
"""
print(True and False)   # False
print(True and 0.0)     # 0.0
print(True and [])      # []

print(True and 15)      # 15
print(True and 'aaa')   # aaa
print(True and True)    # True

print("*" * 30)

# 短路原则：False
print(False and False)
print(False and 0.0)
print(False and [])

print(0 and 15)
print(0.0 and 'aaa')
print([] and True)

"""
总结：
    A  and  B
    a.如果A为真，A  and B的结果是B
    b.如果A为假，A  and B的结果是A，B会被短路
"""

# 2.or：或
"""
真  or  真 = 真
真  or  假 = 真
假  or  真 = 真
假  or  假 = 假

规律：一真为真，全假为假
"""

# 短路原则：True
print(True or False)
print(True or 0.0)
print(True or [])

print(True or 15)
print(True or 'aaa')
print(True or True)

print("*" * 30)

print(False or False)    # False
print(False or 0.0)     # 0.0
print(False or [])     # []

print(0 or 15)    # 15
print(0.0 or 'aaa')  # aaa
print([] or True)    # True


"""
总结：
    A  or  B
    a.如果A为真,A  or  B的结果是A,B会被短路
    b.如果A为假，A  or  B的结果是B
"""

# 3.not：非
"""
not 真 = 假
not 假 = 真
"""
print(not 'abc') # False
print(not 0)   # True

"""
总结：
    a.and和or计算的结果不一定是布尔值
    b.not运算的结果一定是布尔值
"""

5.成员运算符

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

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

6.身份运算符

身份运算符用于比较两个对象的存储单元

is:判断两个标识符是不是引用自一个对象

is not:判断两个标识符是不是引用自不同对象

# is
# is not

# is:判断两个变量中存储的是否是同一个值
# is not:判断两个变量中存储的是否是不同的值

# 1.id(x):获取一个变量在内存空间中的地址,实质上是获取变量中存储的数据在内存中的地址
num1 = 10
print(id(num1))
print(id(10))
num2 = 20
print(id(num2))


# 2.
# a.
a = 10
b = 10
print(a is b)  # 地址
print(a == b)  # 值/内容

# b.
list1 = [34,56]
list2 = [34,56]
print(id(list1),id(list2))
print(list1 is list2)  # False
print(list1 == list2)

"""
【面试题】is和==的区别
    a.==判断的是两个变量的值是否相同
    b.is判断的是两个变量的地址是否相同
    c.如果两个变量的地址相同，则这两个变量的值一定相同；如果两个变量的值相同，他们的地址不一定相同
"""

二、分支语句【重点掌握】

1.概念

在生活中，所谓的判断，指的是如果某些条件满足才能做某件事情；条件不满足时则不能做

在编程中，判断所给定的条件是否满足，根据判断的结果对应执行不同的语句，Python中的分支语句只有if语句

2.使用

2.1if单分支

语法：

if 表达式：
	语句

说明：当程序执行到if语句时，首先判断“表达式”的值，如果表达式的值为“真”，则执行缩进的语句；如果表达式的值为“假”，则跳过整个if语句继续向下执行

import  random

"""
注意：
    a.在Python中，是通过缩进区分代码块的
    b.if语句中的条件可以是常量，变量，也可以是表达式
    c.if单分支的工作原理：如果条件成立，则执行代码块中的语句，
      如果条件不成立，则整个if语句会被跳过，继续执行后面的代码
"""


# 1.基本语法
print("start")
# a.常量
# if 4:
#     print("ok~~~111")

# b.变量
# a = 10
# if a:
#     print("ok~~~2222")

# c.运算符表达式
a = 12
b = 9
if a == b:
    print('ok~~~~333')
print("end")

# 2.应用
# 需求1：如果是未成年人，则禁止进入网吧
# age = input("请输入你的年龄：")
# age = int(age)
# if age < 18:
#     print("未成年人禁止入内")

# 需求2：从控制台输入一个数，判断该数是否是偶数
# num = int(input("请输入一个数："))
# if num % 2 == 0:
#     print("偶数")

# 需求3：模拟彩票中奖操作：随机产生一个数，和用户输入的数进行比较，如果相等，则表示中奖

# 扩展：产生一个指定范围内的随机数
"""
第一步：导入工具，import  random,注意：建议将该导入的代码添加到py文件的开头
第二步：产生一个指定范围内的随机数：random.randint(start,end),是一个闭区间
"""
# n = random.randint(1,100)
# print(n,type(n))

num1 = random.randint(1,100)
print(num1)
num2 = int(input("请输入一个数："))
if num1 == num2:
    print("恭喜你，中奖了")

2.2if双分支

语法：

if 表达式：
	语句1
else：
	语句2

说明：当程序执行到if-else语句时，首先判断“表达式”的值，如果表达式的值为“真”，则执行语句1；如果表达式的值为“假”，则执行语句2

import  random

# 1.基本语法
"""
if双分支的工作原理：如果条件成立，则执行if分支的代码块，如果条件不成立，则执行else的代码块
"""
a = 10
if a < 5:
    print("ok")
else:
    print("no~~ok")


# 2.应用
# 需求1：从控制台输入一个数，判断该数是否是偶数
# num = int(input("请输入一个数："))
# if num % 2 == 0:
#     print("偶数")
# else:
#     print("奇数")


# 需求2：模拟彩票中奖操作：随机产生一个数，和用户输入的数进行比较，如果相等，则表示中奖
num1 = random.randint(1,100)
print(num1)
num2 = int(input("请输入一个数："))
if num1 == num2:
    print("恭喜你，中奖了")
else:
    print("谢谢参与")

三、进制转换【自学了解】

计算机在内存中以二进制【0和1】的形式存储数据，在二进制的基础上，计算机还支持八进制和十六进制这两种进制

一个二进制表示一个比特(bit)，也称为位，计算机处理数据的最小单位为字节【Byte】,1字节= 8位  ，比如：0010   1010

1----》0000 0001

但是，我们生活中习惯使用十进制，所以当人与计算机之间进行交互的时候就要涉及到进制之间的转换

进制的表示有特定的符号集和进位制：

	二进制：0和1，逢二进一

	八进制：0~7，逢八进一

	十进制：0~9，逢十进一

	十六进制：0~9，a~f/A~F 

1B = 8b

B，KB,MB,GB ,TBPB,EB,DB

1KB = 1024B

1.进制转换原理

如：计算机处理3 + 5的流程

a.分别将3和5转换为对应的二进制

b.计算3的二进制和5的二进制的和

c.将和的结果从二进制转换为十进制

• 十进制 —》二进制
  转换原理：对十进制数进行除2运算，直到商为0为止，然后将各个步骤得到的余数倒着写出来
• 二进制—》十进制
  转换原理：把二进制数按权展开、相加即得十进制数（位权，十进制的位权是10，二进制的是2,位置表示法 ，如：345 930 803
  930------》9 * 10(2) + 3 * 10(1) + 0 * 10(0)
  0000 1010----->1 * 2(3) + 1 * 2(1) = 10
  1001 0110---->150
• 二进制—》八进制
  转换原理：三位二进制按权展开相加得到1位八进制数，从右向左开始分组，三位为一组，不足时补0
  10010110---->010 010 110----->2 2 6---->0o226 o—>oct
  1010001---->001 010 001---->1 2 1----->0o121
• 二进制—》十六进制
  转换原理：与二进制转八进制方法相似，八进制是取三合一，十六进制是取四合一，同样，二进制转成十六进制是从右向左开始分组，四位为一组，不足时补0
  10010110---->1001 0110---->9 6---->0x96
  1010001---->0101 0001---->5 1----->0x51
  10111110---->1011 1110----->11 14---->0xbe
  111011----->0011 1011---->3 11---->0x3b
• 十进制—》八进制或者十六进制
  方法一：把十进制转成二进制x，然后再由二进制转成八进制或者十六进制
  方法二：对十进制除以8或者16进行取余，直到商为0为止,类似十进制转二进制
• 八进制或者十六进制—》十进制
  转换原理：把八进制或者十六进制按权展开，相加即得十进制

2.原码反码补码

0 + 0  = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10
11 + 1 = 100
111 + 1 = 1000

原码：一个数的二进制表示形式，高位表示符号位，0表示正数，1表示负数

如：10：0000 1010     -10:1000 1010

反码：在原码的基础上，除了符号位之外，其他位取反【0–》1 ，1—》0】

如：10：0000 1010     -10:1111 0101

补码：在反码的基础上，加1【0000 0001】

如：10：0000 1010    -10:1111 0110

注意：正数的原码反码补码是同一个，都是该数的二进制

验证：计算机中数据的存储采用的是原码，反码还是补码？
10 + （-10） = 0

前提：以8位为例
原码：
	0000 1010
	1000 1010
-----------------
	1001 0100

反码：
	0000 1010
	1111 0101
 ----------------
    1111 1111
    
 补码：
 	0000 1010
 	1111 0110
  -------------
    0000 0000  -----》溢出

# 结论：数据在计算机中是以二进制的补码形式存储的

3.整数表示

# 一、二进制，八进制，十进制和十六进制在Python中都可以表示

# 1.二进制
# 表示方式：用0b开头，b:bin
n1 = 0b1010
print(n1)

# 2.八进制
# 表示方式：用0o开头，o:oct
n2 = 0o226
print(n2)

# 3.十进制
n3 = 10
print(n3)

# 4.十六进制
# 表示方式：用0x,x:hex
n4 = 0x96
print(n4)

4.代码实现进制转换

函数  	说明          

bin(x) 将数字x转换为二进制
oct(x) 将数字x转换为八进制
hex(x) 将数字 x转换为十六进制

# 二、进制转换
# 1.bin/oct/hex(x),将x转换为二进制/八进制/十六进制
m = 10

print(bin(m))
print(oct(m))
print(hex(m))

# 2.int(x,base),base表示进制，默认为10，也可以自定义为2,8,16，可以实现二/八/十六进制转换成十进制
print(int("110"))
print(int("110",base=10))
print(int("110",10))

print(int("110",base=2))
print(int("110",base=8))
print(int("110",base=16))

5.位运算符

运算符 说明
& 与
| 或
^ 异或
~ 取反
<< 左移

右移

# 与
print(6 & 2)
print(6 & 3)
print(8 & 3)

# 或
print(6 | 2)
print(8 | 3)

# 异或
print(6 ^ 3 ^ 3)
# 需求：交换两个变量的值
a = 10
b = 20
a = a ^ b   # a = 10 ^ 20
b = a ^ b   # b = 10 ^ 20 ^ 20
a = a ^ b   # a = 10 ^ 20  ^ 10
print(a,b)

# 取反
print(~6)
print(~-6)

# 左移和右移
print(6 << 2)
print(8 << 3)

print(8 >> 3)
print(-6 >> 3)