第三章 Python数据类型基础及判断、循环语句

菜鸟_老A

已于 2024-05-06 10:32:35 修改

阅读量928

点赞数 24

分类专栏： Python网络自动化运维文章标签： python 开发语言网络

于 2024-05-06 10:31:38 首次发布

本文链接：https://blog.csdn.net/m0_60875392/article/details/138485773

版权

Python网络自动化运维专栏收录该内容

10 篇文章 1 订阅

订阅专栏

第三章数据类型基础及判断、循环语句

3.1 数据类型

为什么要划分数据类型
- 作用：为了使计算机能够分辨不同的数据类型，以便于针对不同的数据类型做出相应的处理
常见的数据类型
- int（整形）
- float（浮点型）
- str（字符串）
- bool（布尔型）
- list（列表）
- dict（字典）
- set（集合）
- tuple（元组）

3.1.1 int整形

整形用于表示整数值对象，包含正整数，0和负整数

1. 整形的取值范围

python2

整形的取值范围为-2^{63}次方，如果超过了这个范围，就成为长整型

32位操作系统和64位操作系统的区别：
- 对于数据处理能力不同
  - 对于32位操作系统，依次能够处理4个字节的数据
  - 对于64位操作系统，一次能够处理8个字节的数据
- 支持内存的最大容量不同
  - 对于32位操作系统而言，能够支持内存的最大容量为4G
  - 对于64位操作系统而言，没有明确限制
  因此在python2当中划分整形和长整形一定程度上是因为可以限制数据对内存的占用
python3

对于整形没有明确的限制，也就是说理论上可以支持无限大的数字

2. 定义

num = 10
print(type(num))

<class ‘int’>

输出类型整形

3. 独有功能

输入变量后的“.”号，自动提示，即独有功能，例如：

n1 = 100
res = n1.bit_length()  # 计算该整形转换为2进制后的位数
print(res)

7

4. 公共功能

n1 = 10
n2 = 20
v1 = n1 + n2
v2 = n1 - n2
v3 = n1 * n2
v4 = n1 / n2
v5 = n2 % n1  # 求余，并将余数赋值给v5
v6 = n2 // n1  # 求除法的商值，并将值赋值给v6
print(v1, v2, v3, v4, v5, v6)

30 -10 200 0.5 0 2

5. 数据类型转化

整形转化为其他类型

n1 = 100
v1 = str(n1)  # 将变量n1转化为字符串类型，可以对v1变量使用字符串类型的方法。
v2 = bin(n1)
v3 =bool(n1)
v4 = float(n1)
print(v1, type(v1))
print(v2, type(v2))
print(v3, type(v3))
print(v4, type(v4))

100 <class ‘str’>
0b1100100 <class ‘str’>
True <class ‘bool’>
100.0 <class ‘float’>

布尔值转整形

n1 = int(True)  # True转换为整数1
n2 = int(False)  # False转换为整数0

字符串转整形

v1 = int("168", base=10)
v2 = int("0b1001", base=2)
v3 = int("0o144", base=8)
v4 = int("0x59", base=16)
print(v1, v2, v3, v4)

168 9 100 89

浮点型转整数

v1 = int(8.7)
print(v1)

8

整型转bool型

v1 = 1
v2 = -10
v3 = 0
print(bool(v1))
print(bool(v2))
print(bool(v3))

True
True
False

由输出可知，当整数为0，则为假值，为其他数值，则bool值为真值。

if语句之后的表达式无论是否存在><号，都可以用于表示真假

3.1.2 Float浮点型

浮点型用于表示小数，包含正数，0.0和负数

1. 浮点数的定义

f1 = 1.0
print(type(f1))

<class ‘float’>

v1 = 1
f1 = float(v1)
print(f1)
print(type(f1))

1.0
<class ‘float’>

2. 浮点型的取值范围

浮点型的取值范围没有明确的限制

3. 精度问题

如果是整形之间的计算，结果非常精确

但是对于浮点型的计算，可能存在微小的误差

4. 浮点型与整形的算数运算

n1 = 100
f1 = float(n1)
v1 = n1 + f1
print(type(v1))

<class ‘float’>

整形和浮点型运算得到的结果是浮点型

3.1.3 字符串

字符是各种文字和符号的总称，包括各个国家的文字，标点符号、图形符号、文字等，可以使用字符串来表示各种文本信息

1. 定义

name = "张三"  # 可以是双引号引用
name2 = '李四'  # 也可以是单号引用
print(type(name))
print(type(name2))

<class ‘str’>
<class ‘str’>

# 如果字符串中要换行，可以使用三引号
message = """Hello World!
how are you
and how are you?"""
print(message)

Hello World!
how are you
and how are you?

2. 独有功能

startwith()

判断一个字符串是否以特定的字符开头

ip = "192.168.1.1"
res = ip.startswith("192")# 判断是否以192开头，也可以这样写，以192.16开头等
print(res)

True

endwith()

ip = "192.168.1.1"
res = ip.endswith(".1")  # 判断是否以.1结尾，不能写出1.
print(res)

True

isdecimal()/isdigit()

v1 = str(100)
res = v1.isdecimal()
print(res)
res = v1.isdigit()
print(res)

True
True

v1 = "①"
res = v1.isdecimal()
print(res)
res = v1.isdigit()
print(res)

False
True

isdigit字符串：如果字符串只包含数字则返回 True 否则返回 False
isdecimal字符串：检查字符串是否只包含十进制字符，包含返回 True 否则返回 False，但是特殊字符的数字也可以被检测为 True

strip()/lstrip()/rstrip()

去掉两端的空格，以下是代码和执行结果

ip = "     192.168.1.1      "
print(ip)
res = ip.strip()  # 去掉两端的空格，默认去掉空格和换行符，即参数" "和"\n"
print(res)

     192.168.1.1      
192.168.1.1

去掉两端的其他符号，在strip()方法中携带参数，只能携带一个参数，可以多写一条，删除多域空格

ip = "|    192.168.1.1      |"
print(ip)
res = ip.strip("|")  # 去掉两端的"|"，只会消掉“|”,不会消除空格
print(res)

|    192.168.1.1      |
    192.168.1.1

去掉左边的空格

ip = "     192.168.1.1      "
print(ip)
res = ip.lstrip()  # 去掉左边的空格，默认去掉空格
print(res)

     192.168.1.1      
192.168.1.1

去掉右边的空格

ip = "     192.168.1.1      "
print(ip)
res = ip.rstrip()  # 去掉两端两端的空格，默认去掉空格和换行符
print(res)

     192.168.1.1      
     192.168.1.1

upper()/lower()

name = "ZhangSan"
res = name.upper()  # 修改为大写，赋值给res
v1 = name.lower()  # 修改为小写，返回值赋值给v1
print(res, v1)

ZHANGSAN zhangsan

replace() 替换字符串中的字符

name = "ZhangSan"
new_name = name.replace("Zh", "Li")  # 修改字符串中的"Zh"换成的“Li”
print(new_name)

LiangSan

split() 将字符串转换为列表

ip = "192.168.10.1"
l1 = ip.split(".")  # 根据字符串中的“.”号分割开来，形成列表
print(l1)

[‘192’, ‘168’, ‘10’, ‘1’]

被分成四个元素，形成列表

ip = "192.168.10.1"
l1 = ip.split(".",2)  # 根据字符串中的“.”号分割开来，形成列表，参数2表示根据两个"."号来分成三段，负数不行
print(l1)

[‘192’, ‘168’, ‘10.1’]

被分成三个元素，形成列表

zfill 填充0到字符串，填充到指定位数

ip = "10.168.10.1"
ip_list = ip.split(".")  # ['10', '168', '10', '1']
num = ip_list[0]  # 10
b1 = bin(int(num))  # 0b1010
v1 = b1.replace("0b","")  # 1010
res = v1.zfill(8)  # 00001010 只能有一个参数（填充的位数），填充0
if res.startswith("0"):
    print("该类地址为A两类地址")

该类地址为A两类地址

.join 将列表中的元素转成字符串，用特定符号连接

command_list = ["system-view", "interface G0/0/0", "undo shutdown"]
command = "\n".join(command_list)
print(command)

system-view
interface G0/0/0
undo shutdown

通过该方法，使用“\n”换行符把字符串连接起来了，并输出

字符串格式化

占位符

name = "张三"
age = 18
gender = "male"
hobby = "study"
message = """
name:%s
age:%d
gender:%s
hobby:%s
"""% (name, age, gender, hobby)
print(message)

name:张三
age:18
gender:male
hobby:study

字符串类的值用%s代表，整数类型的用%d代表

使用“f”进行格式化

name = "张三"
age = 18
gender = "male"
hobby = "study"
# 在引号前加入f，然后在要调用参数的部分加入大括号，括号内放入变量名
message =f"""
name:{name}
age:{age}
gender:{gender}
hobby:{hobby}
"""
print(message)

name:张三
age:18
gender:male
hobby:study

使用.format格式化，字符串中的{}可以填入索引号

name = "张三"
age = 18
gender = "male"
hobby = "study"
# 在引号后面加入.format,小括号中填入需要的参数，依次填充到字符串中的大括号中
message = """
name:{}
age:{}
gender:{}
hobby:{}
""".format(name, age, gender, hobby)
print(message)

name:张三
age:18
gender:male
hobby:study

name = "张三"
age = 18
gender = "male"
hobby = "study"
# 在引号后面加入.format,小括号中填入需要的参数，按照索引号填充到字符串中
message = """
name:{2}
age:{1}
gender:{0}
hobby:{3}
""".format(name, age, gender, hobby)
print(message)

name:male
age:18
gender:张三
hobby:study

center()/ljust()/rjust()

可以用某个字符，将字符串填充到特定的长度

n1 = "info"
v1 = n1.center(50, "*")  # 将字符串居中显示，两端使用"*"填充，总长度50
v2 = n1.ljust(50, "*")   # 将字符串居左显示，右端使用”*“填充到50长度
v3 = n1.rjust(50, "*")  # 将字符串具右显示，左端使用"*"填充到50长度
print(v1)
print(v2)
print(v3)

***********************info***********************
info**********************************************
**********************************************info

encode()/decode()

encode 可以将一个字符全类型的数据转换成字节类型，decode可以将一个字节类型的数据转换成字符串类型。

a = "汉"
b = a.encode()  # 对”汉“进行加码，查看汉对应的UTF-8编码
print(type(b))  # 可以看到编码格式为byte，是字节形式
print(b)  # 打印编码，b‘’表示字节形式的值
print(b.decode("utf-8"))  # 打印解码后的值，即汉子
x = b"\xe6\xb1\x8b"  # 随意定义一个字节类型变量
print(x.decode("utf-8"))  # 解码后的值为汉子

<class ‘bytes’>
b’\xe6\xb1\x89’
汉
汋

3. 公共功能

相加

v1 = "ip address"
s1 = " "
v2 = "192.168.10.1"
v3 = v1 + s1 + v2
print(v3)

ip address 192.168.10.1

相乘，字符串与整数相乘，输出多遍

v1 = "ip address"
v2 = 3
v3 = v1 * v2
print(v3)

ip addressip addressip address

len长度，用于计算字符串的长度，包括空格，需要接收返回值

v1 = "ip address"
v2 = len(v1)
print(type(v2))
print(v2)

<class ‘int’>
10

4.字符串特性

切片，可以有三个参数

v1 = "ip address"
res = v1[0:5]  # 从第一个字符i开始到第6个字符d
print(res)
res1 = v1[0:5:2]  # 从第一个字符i开始，到第6个字符d结束，按照每两个字符取一个。
print(res1)

切片参数 [n:m:s] 
n代表起始索引（可以为负数），到m结束索引（也可以为负数），步长s取字符串中的字符。n,m无论是否为负数，m对应的元素必须是n对应元素的后面。
如果步长为-1，此时起始索引默认为-1，n对应的元素就需要再m的左侧，只是索引从右向左计数，例如[8:3:-1]
若果步长为1，此时起始索引默认为1,n对应的元素也需要在m的左侧，索引从左向右计数，例如[1:5:1]
[n:m:s]中的参数可以省略

需要注意：如果执行切片操作：
- 步长为正数，则索引值从左开始到右，越来越大，索引值也为正数
- 步长为负数，则索引值从右向左，带负数符号，越来越小，索引值也为负数。
- 索引n指定的元素位于索引m指定的元素后面（无论值是否为负数），结果就是空序列。
可索引

同切片，字符串中的每一个字符都对应一个索引值，最左边为0，最右边为-1

不可修改

字符串存储的内存地址中的数据本身不能修改，因此变量只能通过修改内存指针来赋值不同的变量，而无法修改对应内存中本身的数据。

name = "张三"
name[0] = "李"
print(name)

TypeError: ‘str’ object does not support item assignment

运行时报错，输出结果显示不能被赋值

3.1.4 bool布尔类型

一般用于判断一个条件的真假，只有两个值，分别时True和False

1. 定义

v1 = True
v2 = False

2. 独有功能

无

3. 公共功能

无

v1 = True + True
print(type(v1))
print(v1)

<class ‘int’>
2

当bool值进行运算时，会将bool类型转换为整形进行运算，True就对应为1，而False就对应0，得到的结果也是整形

4. 转换

整数0、空字符串、空列表、空元组、空字典转换为bool值时均为False

其他均为True

# 查看一些变量是True还是False
v1 = bool(0)
v2 = bool(-10)
v3 = bool(10)
v4 = bool("张三")  # 双引号表示字符串，转换为bool值
v5 = bool("")   # 空字符串
v6 = bool(" ")  # 字符串中有一个空格
v7 = bool([])  # []空列表
v8 = bool([11, 22, 33])  # 列表有值
v9 = bool({})  # {} 表示空字典
v10 = bool({"name": "张三", "age": 18})  # 非空字典
print(1, v1)
print(2, v2)
print(3, v3)
print(4, v4)
print(5, v5)
print(6, v6)
print(7, v7)
print(8, v8)
print(9, v9)
print(10, v10)

1 False
2 True
3 True
4 True
5 False
6 True
7 False
8 True
9 False
10 True

输入结果如上所示

3.2 判断语句

3.2.1 基本判断语句

user = input("请输入用户名：")
passwd = input("请输入密码:")
if user == "admin" and passwd == "huawei@123":
    print("登录成功")
else:
    print("登录失败")

请输入用户名：admin
请输入密码：huawei@123
登录成功

3.2.2 缩进

1. 顶级代码，顶行书写

不依赖于其他的代码而运行的代码是顶级代码，顶级代码不顶行写就会报错。

user = input("请输入用户名：")
passwd = input("请输入密码")  # 顶级代码，不依赖于任何其他的代码
if user == "admin" and passwd == "huawei@123":
    print("登录成功")  # 非顶级代码，依赖于if判断语句
else:
    print("登录失败")

2. 同级代码，缩进一致

if user == "admin" and passwd == "huawei@123":
    print("登录成功")  # 非顶级代码，依赖于if判断语句
     print(123)  # 缩进与上一句不一致

Ctrl + Alt+ L 在Pycharm中统一调整代码的缩进

3. 四个空格表示缩进（一个tab）

message = """
1.RIP
2.OSPF
3.ISIS
4.BGP
"""
option = input("请输入路由协议签对应的序号进行查询：")
if option.isdecimal() == True:
    if int(option) == 1:
        print("该路由协议为距离矢量路由协议。")
    elif int(option) == 2 or int(option) == 3:
        print("该协议是链路状态路由协议。")
    else:
        print("该路由协议为路径矢量路由协议。")
else:
    print("请输入正确的序号。")

请输入路由协议签对应的序号进行查询：a
请输入正确的序号。

请输入路由协议签对应的序号进行查询：2
该协议是链路状态路由协议。

3.3 循环语句while 和for

3.3.1 while循环

当while条件成立，循环执行下面缩进的代码

while True:
    print("Hello World!")  # 由于条件一直为真，因此一直打印该字符串

1. 实现1到100的数字相加

s = 0
i = 1
while i <= 100:
    s += i
    i += 1  # 执行一遍循环，则i+1，继续判断条件是否为真，为真则继续循环，为假则跳出循环
print(s)

5050

2. while…else…

while… else…当while后跟的条件成立，执行下面缩进的代码块，条件不成立，执行else下对应的代码块

while False:
    pass
else:
    print("值为真")

值为真

输入结果”值为真“字符串，上述循环由于不满足条件，条件一直为False，因此直接到else语句，输入字符串，终止循环

3. break

在3.2.1小节设计了一个登录程序，输入错误的时候，程序直接结束了，需要重新开启。此处使用while循环优化下。

while True:
    user = input("请输入用户名：")
    if user == "admin":
        while True:
            passwd = input("请输入密码：")
            if passwd == "huawei@123":
                print("登录成功")
                break
            else:
                print("密码输入错误2")
        break
    else:
        print("用户名输入错误3")

请输入用户名：a
用户名输入错误3
请输入用户名：admin
请输入密码：a
密码输入错误2
请输入密码：huawei@123
登录成功

在以上的登录程序中添加限制尝试次数，具体代码如下：

user_name = "admin"
user_pwd = "huawei@123"
user_max_count = 3
pwd_max_count = 3
user_retried = 0
pwd_retried = 0

while user_retried < user_max_count:
    user = input("请输入用户名：")
    user_retried += 1
    if user == "admin":
        while pwd_retried < pwd_max_count:
            passwd = input("请输入密码：")
            pwd_retried += 1
            if pwd_retried < pwd_max_count:
                if passwd == "huawei@123":
                    print("登录成功")
                    break  # A点：登录成成功后跳出内层while循环到达B点
                else:
                    print(f"密码输入错误,错误次数为{pwd_retried}")
            else:
                print(f"密码输入错误达到{pwd_max_count},请核对后再重试")
        break  # B点：该break位置必须至少和本级while同级，如果在循环内，仅跳出该循环。
    else:
        print(f"用户名输入错误，错误次数已达{user_retried}")
else:
    print(f"用户名输入已达最大次数{user_max_count}，请核对后在重新输入")

输出测试如下：

# 第一次测试：输出结果如下：错误用户名次数达最大次数，程序结束。
请输入用户名：a
用户名输入错误，错误次数已达1
请输入用户名：a
用户名输入错误，错误次数已达2
请输入用户名：a
用户名输入错误，错误次数已达3
用户名输入已达最大次数3，请核对后在重新输入
# 第二次测试：输出结果如下：错误用户名次数达最大次数，程序结束。
请输入用户名：admin
请输入密码：a
密码输入错误,错误次数为1
请输入密码：a
密码输入错误,错误次数为2
请输入密码：a
用户密码达到3,请核对后再重试
# 第三次测试：输出结果如下：错误用户名次数达最大次数，程序结束。
请输入用户名：admin
请输入密码：huawei@123
登录成功

4. continue

while True:
    print("Hello World!")
    print("123")
    continue
    print("guess what")

由于条件为真，输出第一第二个字符串，执行到continue之后再次进入循环第一句，最终结果重复输出第一句第二句。

5.遍历字符串，并打印每项

name = "张三李四王二"
s = 0
while s < len(name):
    print(name[s])
    s += 1

张
三
李
四
王
二

6. while循环打印99乘法表

# 打印99乘法表
i = 1
while i < 10:
    j = 1
    while j < i+1:
        print(f"{j}*{i}", end=" ")
        j += 1
    else:
        print()
    i += 1

# 打印99乘法表
1*1 
1*2 2*2 
1*3 2*3 3*3 
1*4 2*4 3*4 4*4 
1*5 2*5 3*5 4*5 5*5 
1*6 2*6 3*6 4*6 5*6 6*6 
1*7 2*7 3*7 4*7 5*7 6*7 7*7 
1*8 2*8 3*8 4*8 5*8 6*8 7*8 8*8 
1*9 2*9 3*9 4*9 5*9 6*9 7*9 8*9 9*9

3.3.2 for循环

for循环是一种遍历循环，只要是可以遍历的数据类型，都可以通过for循环来输出

name = "张三李四王二"
for i in name:
    print(i)

张
三
李
四
王
二

1.range方法

range方法可以创建一系列的数字，range采用的时开闭区间，也就是最右边的值无法取到

a=range(10)
b=range(1, 5)
c=range(1, 10, 2)
d=range(10, 1, -1)
for i in a :
    print(i,end=" ")
print()  # 打印回车换行
print("分隔线".center(50, "-",))
for i in b:
    print(i,end=" ")
print()
print("分隔线".center(50, "-", ))
for i in c:
    print(i,end=" ")
print()
print("分隔线".center(50, "-",))
for i in d:
    print(i,end=" ")
print()
print("分隔线".center(50, "-",))

0 1 2 3 4 5 6 7 8 9
-----------------------分隔线------------------------
1 2 3 4
-----------------------分隔线------------------------
1 3 5 7 9
-----------------------分隔线------------------------
10 9 8 7 6 5 4 3 2
-----------------------分隔线------------------------

2.for+range

实例1：使用for循环实现1到100的相加

# 这是一个计算数字累加的程序
start = input("请输入一个起始数字：")
end = input("请输入一个结束的数字：")
step = input("请输入步长：")
s = 0
for i in range(int(start), int(end)+1, int(step)):
    s = s + i
print(s)

请输入一个起始数字：1
请输入一个结束的数字：100
请输入步长：1
5050

实例2：使用for循环实现一个小图的绘制

# 这小程序打印了一个三角形
for i in range(1, 10):
    if i<5:
        print("*"*i)
    else:
        print("*"*(10-i))

# 输出结果如下：
*
**
***
****
*****
****
***
**
*

实例3：打印99乘法表，其中在j循环中如果使用break，则不会跳转到else执行

# 打印99乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{i}*{j}", end=" ")
    print()  # 不符合j循环的时候，说明j列超过了行数，需要换行了，print默认打印回车符，再次进入i循环（行循环）
else:
    print("打印完成")

# 输出结果如下
1*1 
2*1 2*2 
3*1 3*2 3*3 
4*1 4*2 4*3 4*4 
5*1 5*2 5*3 5*4 5*5 
6*1 6*2 6*3 6*4 6*5 6*6 
7*1 7*2 7*3 7*4 7*5 7*6 7*7 
8*1 8*2 8*3 8*4 8*5 8*6 8*7 8*8 
9*1 9*2 9*3 9*4 9*5 9*6 9*7 9*8 9*9 
打印完成

实例4：编写程序，用户输入一个IP地址，判断IP地址属于几类IP地址。

# 编写一个程序：用户输入一个IP地址，判断该IP属于哪一类地址。
# 要求用户输入的IP地址是符合规范的x.x.x.x，x的取值范围是0-255
# 用户重新输入错误之后，可以继续尝试
while True:
    option = input("""请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：""")
    if option.upper() == "Q":
        break
    data_list = option.strip().split(".")
    if len(data_list) != 4 or int(data_list[0]) == 0:  # 从这里开始，判断
        print("错误，正确的格式为x.x.x.x，不能以0开始或者，点号数量不对")
        continue  # 如果符合上述条件，则重新进入while循环
    for i in data_list:
        if i.isdecimal():
            if int(i) < 0 or int(i) > 255:
                print("错误，x的范围有误，0-255")
                break  # 此处x范围错误，跳出for循环，不执行else语句
        else:
            print("错误，x应该为整数")
            break  # 跳出for循环，所有条件均不满足，回到while循环重新输入
    else:  # 上述if else如果for遍历的时候没有跳出for循环，遍历完成后（证明没有出现上述错误）自动执行本级for对应的else
        res = bin(int(data_list[0])).replace("0b", "").zfill(8)
        if res.startswith("0"):
            print("该地址为A类地址！")
        elif res.startswith("10"):
            print("该地址为B类地址")
        elif res.startswith("110"):
            print("该地址为C类地址！")
        elif res.startswith("1110"):
            print("该地址为D类地址！")
        else:
            print("该地址为E类地址！")

程序测试输出结果如下：

# 错误测试输出结果如下：
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：0.10.10.10
错误，正确的格式为x.x.x.x，不能以0开始或者，点号数量不对
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：1.1.1.1.1
错误，正确的格式为x.x.x.x，不能以0开始或者，点号数量不对
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：1.1.256.1
错误，x的范围有误，0-255
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：1.1.a.1
错误，x应该为整数
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：q

# 判断测试输出结果如下：
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：10.10.10.10
该地址为A类地址！
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：172.16.1.1
该地址为B类地址
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：192.168.10.1
该地址为C类地址
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：224.1.1.1
该地址为D类地址
请输入IP地址查询，IP地址的格式为x.x.x.x，x范围为0-255(Q/q退出）：255.255.0.0
该地址为E类地址

3.4 运算符

3.4.1 分类

算数运算符，例如：加减乘除
比较运算符，例如：大于、小于、等于
逻辑运算符，例如：且或非 and，or，not
赋值运算符，例如变量赋值：+=、-=、%=
成员运算符，例如：in、not in

l1 = [1, 2, 3]
if 4 in l1:
    print("ok")
else:
    print("no")

输出如下：

no

l1 = [1, 2, 3]
if 4 not in l1:
    print("ok")
else:
    print("no")

输出如下：

ok

3.4.2 逻辑运算

常见的比较运算符、比较运算符和逻辑运算符。这三种运算符比较时，优先级从高到低总结：加减乘除>比较 >not and or

and 运算：从左到右查找，查找到一个False值，则表达式的结果为该False，如果整个表达式都是True值，则结果为最后一个True
- 如果是字符串运算，如果存在假值，则为False，如果都为真值，取最后一个真值。
or 运算：从左到右查找，查找到一个True值，则表达式的结果为该True，如果整个表达式都为False值，则结果为False
- 如果是字符串运算，如果全部为空，则为False，如果存在真值，则选择第一个真值。

例1.

v1 = "张三" and "李四"
v2 = "" and "王五"
v3 = 1 or 8
v4 = 0 or 8
print(v1)
print(v2)
print(v3)
print(v4)

李四

1
8

例2：

v1 = 1 or 2
v2 = -1 or 3
v3 = 0 or -1
v4 = 0 or 100
v5 = "" or 10
v6 = "张三" or ""
v7 = 0 or ""
print("v1", v1)
print("v2", v2)
print("v3", v3)
print("v4", v4)
print("v5", v5)
print("v6", v6)
print("v7", v7)

v1 1
v2 -1
v3 -1
v4 100
v5 10
v6 张三
v7

例3:

v1 = (0 and 4 and 3 or 8 and 2)  
print(v1)

输出结果如下：0 and 4结果为0，再and 3结果也为0，再or 8 结果为8，在and 2，结果为2

2

例4：

v1 = (0 or 4 and 3 or 8 and 2)
print(v1)

输出结果如下：0 or 4 结果为4，and 3结果为3，or 8结果也为3，整个表达式结果为3

3

菜鸟_老A

关注

24
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

第三章 Python数据类型基础及判断、循环语句

第三章 数据类型基础及判断、循环语句

3.1 数据类型

3.1.1 int整形

1. 整形的取值范围

2. 定义

3. 独有功能

4. 公共功能

5. 数据类型转化

3.1.2 Float浮点型

1. 浮点数的定义

2. 浮点型的取值范围

3. 精度问题

4. 浮点型与整形的算数运算

3.1.3 字符串

1. 定义

2. 独有功能

3. 公共功能

4.字符串特性

3.1.4 bool布尔类型

1. 定义

2. 独有功能

3. 公共功能

4. 转换

3.2 判断语句

3.2.1 基本判断语句

3.2.2 缩进

1. 顶级代码，顶行书写

2. 同级代码，缩进一致

3. 四个空格表示缩进（一个tab）

3.3 循环语句while 和for

3.3.1 while循环

1. 实现1到100的数字相加

2. while…else…

3. break

4. continue

5.遍历字符串，并打印每项

6. while循环打印99乘法表

3.3.2 for循环

1.range方法

2.for+range

3.4 运算符

3.4.1 分类

3.4.2 逻辑运算

第三章数据类型基础及判断、循环语句