【笔记】Python 程序设计基础

文章目录

前言

一些简单的…繁杂的记录…争取一个月之内写完python的基础内容（包括：程序控制结构、函数、数据容器、排序和查找、模块和包、面向对象等等…
人生苦短，我用python！！！

第1章 Python 语言概述

1.1 Python 转义字符

1.1.1 Python 常用的转义字符

-Python 常用转义字符

1、\t : 一个制表位，实现对齐的功能
2、\n : 换行符
3、\\ : 一个\
4、\" : 一个"
5、\' : 一个'
6、\r : 一个回车

1.1.2 应用实例

# \t制表符
print("jack\t20")

# \n换行
print("Hello,jack\nhello,tom")

# \\ 输出\
print("D:\\python\\chapter02")

# \" 输出"
print("杨过说：\"小龙女你嫁给我吧\"")

# \' 输出 '
print("郭靖说：\'hello\'")  # 单引号也可以不使用转义 \

# \r是回车
print("段誉向西行，\r他虽不会武功")

第2章 变量

2.1 为什么需要变量

2.1.1 一个程序就是一个世界

2.1.2 变量是程序的基本组成变量

1、不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位

2、变量有三个基本要素（类型+名称+值）

3、应用实例

# 变量的实例

# 定义了一个变量, 变量的名称a , 变量的值是1, 1是int类型(整数类型)
a = 1
# 定义了一个变量, 变量的名称b , 变量的值是2, 2是int类型(整数类型)
b = 2
# 变量b的值修改成8, 变量b的值就是8, 8是int类型。。 integer
b = 8

# 输出变量的值, type(a) 表示输出a的类型
print("a的值是", a, "类型是", type(a))
print("b的值是", b, "类型是", type(b))

2.1.3 简单的原理示意图

2.2 变量的介绍

1）变量下能当于内存中一个数据存储空间的表示
2）你可以把变量看作是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量（值）

定义变量：a=60
使用：		print(a)

# 变量使用的错误形式
# print(c)
# c = 30

2.3 变量快速入门

name = "tom"  # 字符串
age = 20  # 整型
score = 90.4  # 浮点型(小数)
gender = "男"  # 字符串

# 输出信息
print("个人信息如下:")
print(name)
print(age)
print(gender)
print(score)

# 输出信息
print("个人信息如下:", name, age, gender, score)

2.4 格式化输出

1）%操作符
参考：https://blog.csdn.net/hesongzefairy/article/details/104179419
2）format()函数
参考：https://www.runoob.com/python/att-string-format.html
3）f-strings
参考：https://blog.csdn.net/weixin_44200553/article/details/130408971

# 格式化输出案例
# 定义变量
age = 80
score = 77.5
gender = '男'
name = "贾宝玉"

# %操作符输出
print("个人信息: %s-%d-%s-%.2f" % (name, age, gender, score))  //注意类型要匹配!!!

# format()函数
print("个人信息: {} {} {}".format(name, age, gender))

# f-strings[推荐]
print(f"个人信息: {name} {age} {score} {gender}")

2.5 程序中 +号的使用

1、当左右两边都是数值型时，则做加法运算

2、当左右两边都是字符串，则做拼接运算

3、举例说明

# +号的使用案例

name = "king"
score = 50.8
num1 = 10
str1 = " ok"

print(score + num1)  # 60.8
print(name + str1)  # king ok
print(score + 90)  # 140.8
print(name + " hi")  # king hi
print("100" + "98")  # 10098
print(34.5 + 100)  # 134.5

# print(100 + 100)  # 200
# print("100" + "100")  # 100100
# print("100" + 3)  # 报错

2.6 数据类型

2.6.1 基本数据类型-目前用到的

解读
1、a，b是变量，它是没有类型的
2、a，b变量是指向的/代表的数据"hello",100是有数据类型的，“hello”,100有些地方也称为字面量

2.6.2 type() 函数-查看数据类型

1、通过type() 函数，来查看数据的类型

2、type() 基本使用

  -语法：type(object)
  -解读：object就是你要查看类型的数据，可严实一个具体的数据（即：字面量），也可以是变量（也就是查看该变量指向的数据的类型）

3、案例说明

# 演示type()使用

name = "tom"  # 字符串
age = 20  # 整型
score = 90.4  # 浮点型(小数)
gender = "男"  # 字符串
is_pass = True  # bool类型

# 查看变量的类型(本质是查看变量指向的数据的类型)
print(type(name))
print(type(age))
print(type(score))
print(type(gender))
print(type(is_pass))

# type可以直接查看具体的值(字面量)的类型
print(f"hello 的类型是{type("hello")}")
print(f"1.1 的类型是{type(1.1)}")
print(f"30 的类型是{type(30)}")
print(f"True 的类型是{type(True)}")

2.7 整数类型

2.7.1 基本介绍

-Python 整型就是用于存放整数值的，比如12，30，3456，-1等等

-案例演示

# 使用
n1 = 45
n2 = 88
print("n1=",n1)
print("n2=",n2)

2.7.2 整型的使用细节

1、Python中的整型，可以表示很大的数（官方：the limit（4300 digits）for integer）

import sys

# 讲解int类型的细节
# 在python中,int可以表示很大数
# the limit (4300 digits) for integer
n3 = 9 ** 888
print("n3 =", n3, type(n3))

2、Python的整数有十进制，十六进制，八进制，二进制

-十进制就是我们最常见的写法，比如 1、66、123等

-十六进制写法：加前缀 0x,由 0-9 和 A-F 的数字和字母组合

-八进制写法：加前缀 0o，由 0-7 数字组合

-二进制写法：加前缀 0b，只有 0 和 1 数字组合

-运行时，会自动转换为十进制输出

# python的整数有十进制，十六进制, 八进制，二进制表示
print(10)
# 十六进制
print(0x10)
# 八进制
print(0o10)
# 二进制
print(0b10)

3、简单介绍十六进制、八进制、二进制

4、Python中的整型占多少个字符

字节(byte):计算机中基本存储单元

位(bit):计算机中最小存储单位

1byte = 8bit

-字节数随着数字增大而增大（即：python整型是边长的）
-每次的增量是4个字节

# 字节数随着数字增大而增大

n1 = 0
n2 = 1
n3 = 2
n4 = 2 ** 15
n5 = 2 ** 30
n6 = 2 ** 128
# 在python中, 可以通过sys.getsizeof 返回对象(数据)的大小(按照字节单位返回)

print(n1, sys.getsizeof((n1)), "类型", type(n1))
print(n2, sys.getsizeof((n2)), "类型", type(n2))
print(n3, sys.getsizeof((n3)), "类型", type(n3))
print(n4, sys.getsizeof((n4)), "类型", type(n4))
print(n5, sys.getsizeof((n5)), "类型", type(n5))
print(n6, sys.getsizeof((n6)), "类型", type(n6))
print(sys.getsizeof(10))  # 28字节

2.8 浮点类型

2.8.1 基本介绍

-Python的浮点类型可以表示一个小数，比如123.4，7.8，-0.12等等

-案例演示

n1 = 4.5
n2 = -3.6
print("n1 =", n1)
print("n2 =", n2)

2.8.2 浮点型使用细节

1、浮点数表示形式如下

-十进制数形式：如：5.12 .512(必须有小数点)

-科学计数法形式：如：5.12e2，5，12E-2

2、浮点数有大小限制 边界值为：

max=1.7976931348623157e+308

min=2.225073858072014e-308

浮点类型计算后，存在精度的损失，可以使用 Decimal 类进行精确计算

案例说明

# 浮点类型的表示形式
n3 = 5.12
n4 = .512
print("n4 =", n4)

# 科学计数法形式:如：5.12e2,  5.12E-2
n5 = 5.12e2  # 5.12乘以10的2次方 512.0
n6 = 5.12E-2  # 5.12除以10的2次方 0.0512
print("n5 =", n5)
print("n6 =", n6)

# 浮点类型计算后, 存在精度的损失, 可以使用 Decimal 类进行精确计算
# 如何解决
# 1. 为了避免浮点数的精度问题，可以使用Decimal 类进行精确计算
# 2. 如果使用Decimal 类 , 需要导入Decimal 类

# 导入Decimal 类
from decimal import Decimal

# b = 8.1 / 3  # 2.6666666669
b = Decimal("8.1") / Decimal("3") # 2.7
print("b =", b)

2.9 布尔类型 bool

2.9.1 基本介绍

1、布尔类型也叫 boo l类型，取值 True 和 False

2、True 和 False 都是关键字，表示布尔值

3、bool类型适用于逻辑运算，一般用于程序流程控制

-条件控制语句

-循环控制语句

比如判断某个条件是否成立，或者在某个条件满足时执行某些代码

2.9.2 案例演示

-案例演示

# bool类型的基本使用
num1 = 100
num2 = 200

if num1 > num2:
    print("num1 > num2")

# 表示把 num1 > num2 的结果赋给 result变量
result = num1 > num2
print("result =", result)

# 看看result的数据类型
print("result的类型:", type(result))
print(type(1 > -1))

2.9.3 使用细节

1、布尔类型只有两个值：True 和 False

2、布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0

3、在 Python 中，非 0 被视为真值，0 被视为假值

4、应用实例

# 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，
# Python 会将 True 视为 1，False 视为 0

b1 = False
b2 = True

print(b1 + 10)  # ? 10
print(b2 + 10)  # ? 11

# 说明
# b1 = 0: 表示赋值, 把0赋给b1
# b1 == 0 : 表示判断 b1是否和0相等
if b1 == 0:
    print("OK")

if b2 == 1:
    print("HI")

# 在Python中，非0被视为真值，0值被视为假值

if 0:
    print("哈哈")

if 1.1:
    print("嘻嘻")

if "老韩":
    print("老韩你好~")

2.10 字符串 str

2.10.1 基本介绍

1、字符串是Python中很常用的数据类型，通俗来说，字符串就是字符组成的一串内容

2、使用引号（’ 或 “）包括起来，创建字符串

3、str就是string的缩写，在使用type()查看数据类型时，字符串类型显示的是str

4、通过加号可以连接字符串

2.10.2 案例演示

# 字符串使用注意事项

# 使用引号( ' 或 " ) 包括起来, 创建字符串
str1 = 'tom说: "hello"'
print(str1)
str2 = "jack说: 'hi'"
print(str2)

print(f"str2的类型:{type(str2)}")

# 通过加号可以连接字符串
print("hi" + " tom")

2.10.3 使用注意事项

1、Python不支持单字符类型，单字符在Python中也是作为一个字符使用

2、用三个单引号’‘‘内容’’'，或三个双引号”””内容“““可以使字符串内容保持原样输出，在输出格式复杂的内容是比较有用的，比如输出一段代码

3、在字符串前面加’r’可以使整个字符串不会被转义

4、应用实例

# Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用
str3 = 'A'
print("str3类型", type(str3))

# 用三个单引号'''内容''', 或三个双引号"""内容"""可以使字符串内容保持原样输出,
# 在输出格式复杂的内容是比较有用的, 比如输出一段代码

content = '''be the cat's whiskers/pyjamas " ''

(informal) 最棒的东西（或主意、人等）
to be the best thing, person, idea, etc. " 

He thinks he's the cat's whiskers (= he has a high opinion of himself) .
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
他自以为了不起'''

print(content)

# 在字符串前面加 'r' 可以使整个字符串不会被转义
str4 = r"jack\ntom\tking"
print(str4)

2.10.4 字符串驻留机制

…(未完)

2.11 数据类型转换

2.11.1 隐式类型转换

1、Python变量的类型不是固定，会根据变量当前值在运行时决定的，可以通过内置函数 type(变量)来查看其类型，这种方式就是隐式转换，也称为自动转换

# Python 根据该变量使用的上下文(即 当前值)在运行时决定的类型
var1 = 10
print(type(var1))  # int类型
var1 = 1.1
print(type(var1))  # float类型
var1 = "字符串"
print(type(var1))  # str类型

2、在运算的时候，数据类型会向高精度自动转换

# 在运算的时候,数据类型会向高精度转换, float的精度高于int
var2 = 10
var3 = 1.2
var4 = var2 + var3  # 11.2 float
print("var4=", var4, "var4的类型: ", type(var4))  # 11.2 float
var2 = var2 + 0.1  # 10.1
print("var2=", var2, "var2的类型: ", type(var2))  # 10.1 float

2.11.2 显式类型转换

1、如果需要对变量数据类型进行转换，只需要将数据类型作为函数名即可，这种方式就是显式转换/强制转换

2、以下几个内置函数可以完成数据类型之间的转换。函数会返回一个新的对象/值，就是强制转换后的结果

3、案例演示

# 显示类型转换案例

i = 10

j = float(i)
print("j的类型:", type(j), "j =", j)

k = str(i)
print("k的类型:", type(k), "k =", k)  # str, "10"

2.11.3 显示类型转换注意事项

1、不管什么值的 int，float都可以转成str(),str(x) 将对象 x 转换为字符串

n1 = 100
n2 = 123.65
print(str(n1))
print(str(n2))

2、int 转成 float 时，会增加小数部分，比如 123->123.0，float 转成 int 时，会去掉小数部分 比如123.65->123

print(float(n1))  # 100.0
print(int(n2))  # 123

3、str 转 int，float 使用 int(x),float(x) 将对象 x 转换为int/float

n3 = "12.3"
print(float(n3))  # 12.3
# print(int(n3))

4、在将str 类型转成基本数据类型时, 要确保str值能够转成有效的数据, 比如 我们可以把 “123” , 转成一个整数, 但是不能把 “hello” 转成一个整数,如果格式不正确, 程序会报 ValueError，程序就会终止

n4 = "hello"
# print(float(n4))
# print(int(n4))

5、对一个变量进行强制转换，会返回一个数据/值，注意，强制转换后，并不会影响原变量的数据类型（即：不会影响原变量指向数据/值的数据类型）

i = 10
j = float(i)
print("i的值:", i, "i的类型:", type(i))  # 10,int
print("j的值:", j, "j的类型:", type(j))  # 10.0,float

k = str(i)
print("i的值:", i, "i的类型:", type(i))  # 10,int
print("k的值:", k, "k的类型:", type(k))  # "10",str

第3章 运算符

3.1 运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1）算数运算符
2）赋值运算符
3）比较运算符
4）逻辑运算符
5）位运算符

3.2 算术运算符

3.2.1 基本介绍

-算术运算符是对数值类型的变量进行运算的，在程序中使用特别多

3.2.2 算术运算符一览

3.2.3 案例演示

+，-，*，/，%，//，**

#对于除号 /, 返回结果是小数
print(10 / 3)

#对于取整除 // , 返回商的整数部分(并且是向下取整)
print(10 // 3)  # 3
print(-9 // 2)  # -5
print(-10 // 3)  # -4

#当对一个数取模时, 对应的运算公式:  a % b = a - a // b * b
print(10 % 3)  # 1
#分析  -10 % 3 = -10 - (-10) // 3 * 3 = -10 - (-4) * 3 = -10 +12 = 2
print(-10 % 3)  # 2
#分析 10 % -3 = 10 - 10 // (-3) * (-3) = 10 - (-4) * (-3) = 10 - 12=-2
print(10 % -3)  # -2
#分析 -10 % -3 = -10 +9 = -1
print(-10 % -3)  # -1

print(2 ** 5)  # 32
print(9 ** 2)  # 81

3.2.4 细节说明

1、对于除号/，返回结果是小数

例如：10/3 ，结果是 3.33333… ，10/5 ，结果是 2.0

2、对于取整除 //，返回商的整数部分（并且是向下取整）

比如 9//2 结果是 4，-9//2 结果是 -5

3、当对一个数取模时，对应的运算公式：a % b = a – a // b * b

3.2.5 案例

1、假如还有97天放假, 问：合xx个星期零xx天

'''
    思路分析
    1. 定义变量
    days: 记录总的天数
    week: 记录对应的星期
    left_day: 记录剩余的天数
    2. week: 记录对应的星期 days // 7
    3. left_day: 记录剩余的天数 days % 7
    4. 输出信息
'''

# 定义相关的变量
days = 97
week = days // 7
left_day = days % 7
# 输出
print(f"假如还有{days}天放假, 则：合{week}个星期 零{left_day}天")

2、定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为: 5/9*(华氏温度-100), 请求出华氏温度对应的摄氏温度。[234.5]

"""
    思路:
    1. 定义变量 hua_shi she_shi 
    2. 根据要求直接套用公式即可
    3. 输出结果
"""
hua_shi = 234.5
she_shi = 5 / 9 * (hua_shi - 100)
print(f"华氏温度{hua_shi} 对应的摄氏温度 {she_shi}")
print("华氏温度 %.2f 对应的摄氏温度 %.2f" % (hua_shi, she_shi))

3.3 比较运算符

3.3.1 介绍

3.3.2 比较运算符一览

3.3.3 案例演示

# 讲解比较运算符的使用

a = 9
b = 8
print(a > b)  # T
print(a >= b)  # T
print(a <= b)  # F
print(a < b)  # F
print(a == b)  # F
print(a != b)  # T
# 表示把 a>b比较的结果，赋给flag
flag = a > b  # flag = True
print("flag = ", flag)  # T
print(a is b)  # F
print(a is not b)  # T

str1 = "abc#"
str2 = "abc#"

print("------------------")
print(str1 == str2)  # T
print(str1 is str2)  # T

3.3.4 细节说明

1、比较运算符的结果要么是True，要么是False

2、比较运算符组成的表达式，我们称为比较表达式，比如：a > b

3、比较运算符 == 不能误写成 =

3.4 逻辑运算符

3.4.1 基本介绍

3.4.2 and 案例演示

# and运算符的使用
# 定义一个成绩变量
score = 70
# 判断成绩是否在60-80之间

# print(score >= 60 and score <= 80)  # T

if (score >= 60 and score <= 80):
    print("成绩还不错~")

3.4.3 使用注意事项

1、and是种“短路运算符”，只有当第一个为True时才去验证第二个

2、在Python中，非0被视为真值，0值被视为假值

3、代码说明

# 示例：
a = 1
b = 99

print(a and b)  # 99
# 在python() 括起来的运算优先级最高
print((a > b) and b)  # F
print((a < b) and b)  # 99

3.4.4 or 案例演示

# 定义一个成绩变量
score = 70
# 判断成绩是否<=60 或者 >= 80

# print(score <= 60 or score >= 80)  # F
if score <= 60 or score >= 80:
    print("hi~~")

3.4.5 使用注意事项

# 示例
a = 1
b = 99

print(a or b)  # 1
print((a > b) or b)  # 99
print((a < b) or b)  # True

3.4.6 not 案例演示

# 代码
a = 3
b = not (a > 3)  # True
print(b)  # T
print(not False)  # T
print(not True)  # F
print(not 0)  # T
print(not "jack")  # F
print(not 1.88)  # F
print(not a)  # F

3.5 赋值运算符

3.5.1 基本介绍

3.5.2 案例演示

# 1) 赋值运算符案例
num1 = 10
i = 100
i += 100  # => i = i + 100
print("i=", i)  # 200
i -= 100  # => i = i - 100
print("i=", i)  # 100
i *= 3  # i = i * 3
print("i=", i)
# %= //= /= 等等

# 2) 有两个变量, a和b, 要求将其进行交换，最终打印结果
a = 30
b = 40
"""
    分析
    1. 先定义一个中间变量temp
    2. temp = a  # 先把a的值保存到temp
    3. a = b # 把b的值赋给a
    4. b = temp #把temp(即a)的值赋给b
"""
# print(f"没有交换前 a={a}, b={b}")
# temp = a
# a = b
# b = temp
# print(f"交换后 a={a}, b={b}")

"""
    在python中支持一个简单的方式实现变量交换
    x , y = y, x
"""
print(f"没有交换前 a={a}, b={b}")
a, b = b, a
print(f"交换后 a={a}, b={b}")

3.5.3 赋值运算符特点

1、运算顺序从右往左 num = a + b + c

2、赋值运算符的左边是变量，右边可以是变量、表达式、字面量

比如

num1 = 20

num2 = 78 * 34 – 10

num3 = a

num4 = a * b

3、支持链式赋值

a = b = c = 100

4、支持系列解包赋值，注意变量和值的个数和位置要对应

a,b,c =100,200,300

3.6 三元运算符

3.6.1 基本语法

3.6.2 应用案例

使用前面的方式, 得到2个数的最大值

a = 10
b = 80
max = a if a < b else b
print(f"max={max}")

3.6.3 练习

使用前面的 if-else方式, 得到3个数的最大值

"""
    思路分析
    1. a, b, c三个数
    2. 先求出 a , b 的最大值 max1
    3. 再求出 max1 和 c的最大值max2
"""

# 1. a, b, c三个数
a = 30
b = 50
c = 53
# 2. 先求出 a , b 的最大值 max1
max1 = a if a > b else b
# 3. 再求出 max1 和 c的最大值
max2 = max1 if max1 > c else c
print("max2=", max2)

# 还可以使用一条语句完成, 即可以支持嵌套使用,可读性差, 知道可以这样使用即可
# 不推荐..
max = (a if a > b else b) if (a if a > b else b) > c else c
print("max=", max)

3.7 关键字

定义：被Python 语言赋予了特殊含义，用做专门用途的字符串(单词)

3.8 键盘输入语句

3.8.1 介绍

– 在编程中，需要接受用户输入的数据，就可以使用键盘输入语句来获取

– input() 介绍

input(prompt)

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。

3.8.2 应用实例演示

要求：可以从控制台接收用户信息,【姓名，年龄，成绩】

name = input("请输入姓名: ")
age = input("请输入年龄: ")
score = input("请输入成绩: ")

print("\n输入的信息如下: ")
print("name:", name)
print("age:", age)
print("score:", score)

# 注意， 接收到的数据类型是str
print(type(age))
print(type(score))

# 如果我们希望对接收到的数据进行算术运算，则需要进行类型转换
print(10 + float(score))
print(20 + int(age))

# 当然，我们也可以在接收数据的时候，直接转成需要的类型
age = int(input("请输入年龄: "))

print("age的类型是:", type(age))

第 4 章 进制

未完…

第5章 程序控制结构

5.1 程序流程控制介绍

1）顺序控制

2）分支控制

3）循环控制

5.2 顺序控制

程序从上待选逐行地执行，中间没有任何判断和跳转

print("----程序开始执行----")
print("1.小明去上学...")
print("2.小明学习中...")
print("3.小明放学了...")
print("----程序执行结束----")

#Python 中定义变量时采用合法的前向引用。如：
#代码
#num1 = 12
#num2 = num1 + 2

#错误形式：
num2 = num1 + 2 #错误
num1 = 12

5.3 分支控制 if-else

5.3.1 介绍

让程序有选择的执行，分支控制有三种

1）单分支

2）双分支

3）多分支

5.3.2 单分支

单分支是通过 if 语句来实现的，if 语句的基本语法如下：

if 条件表达式：
  	   代码块（可以执行多条语句）

1、当条件表达式为True 时，就会执行代码块; 如果为False , 就不执行

2、Python缩进非常重要, 是用于界定代码块的, 相当于其他编程语言里的大括号{ }

if 4 > 1:
     print("ok1")
     print("ok2")
     print("ok3")

3、最短的缩进对较长的有包含关系, 缩进前后没有要求,但是每个代码块应具有相同的缩进长度(TAB或者相同个数的空格)

if 100 > 20:
    print("ok4")
    print("ok5")
    if 8 > 2:
        print("ok6")

4、小结：可以看出，和其他语言对比：其他语言的代码块是用{ }表示的， python 缩进就代替了{ }

请编写一个程序, 可以输入人的年龄,如果该小伙伴的年龄大于18岁,则输出 “你年龄大于18,要对自己的行为负责!”

"""
    思路分析:
    1. 定义变量age, 接收用于输入(注意要转成整数)
    2. 使用if判断即可
"""
age = int(input("请输入小伙伴的年龄:"))
if age > 18:
    print("你年龄大于18,要对自己的行为负责!")

5.3.3 双分支

if 条件表达式：
	执行代码块 1
else:
	执行代码块 2

1）if、else 是关键字，是规定好的
2）当条件表达式成立，即执行代码块1，否则执行代码块2，注意，不要少写了 冒号：

"""
    思路分析:
    1. 定义变量age, 接收用户输入(注意要转成整数)
    2. 使用if-else判断即可
"""
age = int(input("请输入小伙伴的年龄:"))
if age > 18:
    print("你年龄大于18,要对自己的行为负责!")
else:
    print("你的年龄不大, 这次放过你了")

5.3.4 单分支和双分支练习题

1、 编写程序，定义2个整数变量并赋值, 判断两数之和，如果大于等于50，打印"hello world!"

"""
    思路分析
    1. 定义变量num1 和 num2 并赋值
    2. 判断num1 + num2 >= 50 是否成立使用 if 单分支
"""
num1 = 10
num2 = 99
if num1 + num2 >= 50:
    print("hello world!")

2、编写程序，定义2个float型变量并赋值, 如果第一个数大于10.0，且第2个数小于20.0，打印两数之和

"""
    思路分析
    1. 定义变量num1 和 num2 并赋值
    2. 判断 num1 > 10.0 and num2 < 20.0 是否成立使用if单分支
    3. 根据判断的结果，输出 num1 + num2
"""
num1 = 11.2
num2 = 5.2
if num1 > 10.0 and num2 < 20.0:
    print(f"{num1} + {num2} = {num1 + num2}")

3、定义两个变量int类型，判断二者的和，是否能被3又能被5整除，打印提示信息

"""
    思路分析
    1. 定义num1 和 num2 并赋值
    2. 判断 (num1 + num2) % 3 == 0 and (num1 + num2) % 5 == 0 使用双分支if-else
    3. 然后输出结果
"""

num1 = 10
num2 = 5
if (num1 + num2) % 3 == 0 and (num1 + num2) % 5 == 0:
    print(f"{num1 + num2} 可以被3又能被5整除")
else:
    print(f"{num1 + num2} 不满足既可以被3又可以被5整除")

4、判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除 (2)能被400整除

"""
    思路分析
    1. 定义一个year 保存年份
    2. 判断 (year % 4 == 0 and year % 100 !=0) or year % 400 == 0 是否成立
    3. 如果成立就是闰年，否则就不是闰年 if-else
"""
year = 2024
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print(f"{year} 是闰年")
else:
    print(f"{year} 不是闰年")

​

(未完…持续更新中…)

作者：Cayito