智泊Python–Day2

  Day2 围绕「数据」展开：先学字符串格式化的三种写法（f-string、% 占位符、.format()），再系统过一遍 Python 基础数据类型，最后是四类运算符（算术 / 赋值 / 比较 / 逻辑 + 成员与身份）以及运算优先级。运算符是写任何业务逻辑都离不开的零件，建议重点理解 and/or 的短路求值。

 

1.占位符

  把变量塞进字符串有三种主流写法：

• ① f-string（Python 3.6+ 推荐）：在字符串前加 f，用 {变量} 直接嵌入，最直观
• ② % 占位符：%s 字符串、%d 整数、%f 浮点数、%% 表示百分号本身，老代码里常见
• ③ **.format()**：用 {} 占位，可按位置或按关键字传值

  三者都能完成拼接，新项目优先用 f-string。

# ① f-string：f"{变量}" 直接嵌入
a = input("请输入招呼内容: ")
b = input("请输入姓名: ")
print(f"{a},我是{b}")

# ② 百分号占位符：%s 字符串 %d 整数 %f 浮点数 %% 百分号
a = input("请输入招呼内容: ")
b = input("请输入姓名: ")
o = input("请输入年龄: ")
print("%s，我的名字是%s,我今年%d岁" % (a, b, o))

# ③ .format()：{} 占位，按位置或按关键字传值
hello = input("请输入招呼内容: ")
name = input("请输入姓名: ")
age = input("请输入年龄: ")
print("{},我是{}，我今年{}岁".format(hello, name, age))
print("{a},我是{b}，我今年{c}岁".format(a=hello, b=name, c=age))

 

2.数据类型

  Python 内置数据类型可分为「数字 / 文本 / 布尔 / 空 / 容器 / 二进制」几大类。用 type() 可随时查看任意值的类型，这是调试时最常用的函数之一。

类型	名称	字面量示例	说明
int	整数	100	不带小数
float	浮点数	100.0	含小数
str	字符串	"hello"	文本
bool	布尔	True / False	真/假，底层对应 1/0
None	空类型	None	表示「无值」
list	列表	[1,2,3]	可变有序序列（类似数组）
tuple	元组	(1,2,3)	不可变有序序列
dict	字典	{"name":"张三"}	键值对
set	集合	{1,2,3}	自动去重，无序
bytes	字节	b"hello"	二进制数据

# int 整数
a = 100
print(a); print(type(a))          # 100  <class 'int'>
print("="*20)

# float 浮点数
a = 100.0
print(a); print(type(a))          # 100.0  <class 'float'>
print("="*20)

# str 字符串
a = "hello"
print(a); print(type(a))          # hello  <class 'str'>
print("="*20)

# bool 布尔类型
a, b = True, False
print(a, b); print(type(a)); print(type(b))
print("="*20)

# None 空类型
a = None
print(a); print(type(a))          # None  <class 'NoneType'>
print("="*20)

# list 列表
a = [1,2,3,4,5]
print(a); print(type(a))          # [1, 2, 3, 4, 5]  <class 'list'>
print("="*20)

# tuple 元组
a = (1,2,3,4,5)
print(a); print(type(a))          # (1, 2, 3, 4, 5)  <class 'tuple'>
print("="*20)

# dict 字典：键值对
a = {"name":"张三","age":18}
print(a); print(type(a))          # {'name': '张三', 'age': 18}  <class 'dict'>
print("="*20)

# set 集合：自动去重
print("set 集合 无重复元素")
a = {1,2,3,4,5,2,2,3,2,5}
print(a); print(type(a))          # {1, 2, 3, 4, 5}  <class 'set'>
print("="*20)

# bytes 字节二进制
a = b"hello"
print(a); print(type(a))          # b'hello'  <class 'bytes'>

 

3.算术运算

  七个算术运算符：+ - * / 是常规四则；// 是整除（向下取整，丢弃小数）、% 是取余、** 是幂。科学计数法 3.14e4 等价于 3.14 * 10**4。最后那个练习很经典：用 %10 取个位、//10%10 取十位、//100 取百位，是把数字「拆位」的基础技巧。

# 算术运算符
a, b = 10, 4
print(a+b); print(a-b); print(a*b); print(a/b)
print(a//b)    # 2  整除
print(a%b)     # 2  取余
print(a**b)    # 10000  幂

# 科学计数法
a = 3.14 * 10**4
b = 3.14e4
print(a); print(b)    # 31400.0  31400.0

# 练习：输入三位数，拆分个位/十位/百位
num = int(input("请输入一个三位数："))
print("个位数为：", num % 10)
print("十位数为：", num // 10 % 10)
print("百位数为：", num // 100)

 

4.赋值运算

  复合赋值运算符把「运算 + 赋值」合二为一：a += 1 等价于 a = a + 1，同理有 -=、*=、//= 等。注意等号右边先完整计算，再赋给左边。

a, b, c = 100, 200, 300
a += 1    # a = a + 1
b -= 1    # b = b - 1
c //= 2   # c = c // 2
print(a)  # 101
print(b)  # 199
print(c)  # 150

 

5.比较运算

  比较运算符 > < >= <= == != 的返回值永远是布尔类型。字符串比较有两条规则：长度不同则短的更小；长度相同则按字符 ASCII 码逐位比。下面的 BMI 练习把比较和逻辑连起来用——bmi >= 18.5 and bmi <= 25 判断是否在正常区间。

# 数值比较
a, b = 10, 20
print(a > b)    # False
print(a < b)    # True
print(a >= b)   # False
print(a <= b)   # True
print(a == b)   # False
print(a != b)   # True

# 字符串比较：长度不同则短的小；长度相同按 ASCII 逐位比
a, b = "hello", "world"
print(a > b)    # False
print(a < b)    # True

# 练习：BMI = 体重(kg) / 身高(m)^2，判断是否正常区间 18.5~25
height = float(input("请输入身高（米）: "))
weight = float(input("请输入体重（千克）: "))
bmi = weight / (height**2)
print("您的BMI值为: ", bmi)
if bmi >= 18.5 and bmi <= 25:
    print("您的体重正常")
else:
    print("您的体重异常")

 

6.成员运算符和身份运算符

  成员运算符 in / not in 判断元素是否在容器里（列表、字符串等都可用），日常最常用。身份运算符 is / is not 判断两个变量是否指向同一个内存对象——这点常被和 == 混淆：== 比的是「值相等」，is 比的是「内存地址相同」。用 id() 可查看对象的内存地址。

# 成员运算符
a = [1, 2, 3, 4, 5]
print(1 in a)    # True
print(6 in a)    # False

# 身份运算符
b, c = 10, 20
print(b is c)      # False
print(b is not c)  # True

# == 比「值」，is 比「内存地址」
print(id(a)); print(id(b)); print(id(c))

 

7.逻辑运算符

  and（与）/ or（或）/ not（非）返回布尔。重点在隐式布尔值和短路求值：数字 0、空字符串、空容器、None 都被当作 False，其余为 True。短路是指 and 遇到第一个假值就直接返回它、or 遇到第一个真值就直接返回它，后续表达式不再执行——这常用来写「带默认值的取值」之类简洁逻辑。

a, b, c = 10, 20, 30

# and：都真返回最后一个真值；遇假返回第一个假值
print(a > b and b > c)    # False
print(a < b and b < c)    # True

# or：遇真返回第一个真值
print(a > b or b > c)     # False
print(a < b or b < c)     # True

# not：取反
print(not a < b)          # False

# 隐式布尔值
print(bool(0))        # False
print(bool(1))        # True
print(bool(""))      # False
print(bool("hello")) # True
print(bool(None))    # False
print(bool([]))      # False
print(bool(()))      # False
print(bool({}))      # False  （注意 {} 是空字典，不是空集合）

# 短路运算
print(3 and 5)              # 5
print(3 and 0 and 5)        # 0
print(3 and 0 and print("hello"))   # 0（print 不执行）
print(3 and print("hello") and 6)   # 先打印 hello，返回 None
print(3 or 5 or 6)          # 3
print(0 or 3 or 5 or 6)     # 3

 

8.运算优先级

  记不住优先级时加括号最稳妥。从高到低大致是：括号 () → 指数 ** → 乘除 * / // % → 加减 + - → 比较 > < 等 → 逻辑 and or not → 赋值 =。下面这行综合了括号、指数、比较和逻辑，正是优先级规则的最佳练习。

# 优先级：括号 > 指数 > 乘除 > 加减 > 比较 > 逻辑 > 赋值
n = (4 + (3 * (2**3))) > 10 or 5 and 0
print(n)