day02
数据类型
数据类型指的就是变量值的不同类型
数字类型
整形（int）
age = 18 # age=int(18)
print(id(age))
print(type(age))
print(age)
1906601984
<class 'int'>
18
- 一般用于加减乘除、逻辑判断（大于、小于）
- python中可以用sys.getsizeof(object)来获取对象所占内存的大小。
浮点型（float）
salary = 2.1 # salary=float(2.1)
print(id(salary))
print(type(salary))
print(salary)
2904710131144
<class 'float'>
2.1
- 一般用于加减乘除、逻辑判断（大于、小于）
字符串类型（str）
字符串相当于一根羊肉串，字符串就是一串被串起来的字符，在单引号、双引号或三引号内包裹的一串字符。需要注意的是：三引号内的字符可以换行，而单双引号内的字符不行
name1 = 'nick'
name2 = "egon"
print(id(name1))
print(type(name1))
print(name1)
2904729877672
<class 'str'>
nick
字符串的拼接
字符串的拼接，是重新申请一个小空间把两个字符串都拷贝一份后再拼接，而不是把一个小空间内的变量值复制到另一个变量的小空间内然后拼接。
msg2 = "my name is 'nick'"
msg3 = 'my name is "nick"'
print(msg2 + msg3) # my name is 'nick'my name is "nick"
my name is 'nick'my name is "nick"
'520' + '1314'
'5201314'
520 + 1314
1834
字符串的乘法
msg1 = 'hello'
msg2 = 'z'
print(msg1 > msg2)
False
name = 'nick '
print(name * 10)
nick nick nick nick nick nick nick nick nick nick
字符串的乘法只能乘数字
字符串的逻辑比较
msg3 = 'zero'
msg4 = 'zx'
print(msg3 > msg4)
print('Z' > 'A')
print('Z' > 'a')
False
True
False
字符串比较大小，按照ASCII码比较
列表类型（list）
#此时需要存储一个人的爱好，如果我们使用数据类型存储，那么毫无疑问，只能使用字符串存储，并且一个人的爱好可能是多个的，因此我们用空格作为爱好与爱好之间的分隔符。
hobbies = "read run girl"
print(hobbies)
read run girl
但存不是目的，取才是目的。 如果要取出其中一个爱好，则需要换种方法存储。
在[]中用逗号隔开任意类型的值
hobby = 'read'
hobby_list = [hobby, 'run', 'girl']
print(id(hobby_list))
print(type(hobby_list))
print(hobby_list)
2904730232264
<class 'list'>
['read', 'run', 'girl']
#如何取
hobby_list = ['read', 'run', 'girl']
# 索引序号 0 1 2
# 取出第二个爱好
print(hobby_list[1])
run
hobby_list = ['read', 'run', ['girl_name', 18, 'shanghai']]
# 取出girl的年龄
print(hobby_list[2][1])
18
字典类型（dict）
我们能通过列表取值的时候，是基于我们已经知道了列表内部所有的元素。如果不是我存储的信息，应该如何去精准取值呢？
在{}内用逗号分隔开多个元素，每一个元素都是key: value的格式，其中value是任意格式的数据类型，key由于具有描述性的作用，所以key通常是字符串类型。
字典用来存取多个值，按照key：value的方式存值，取的时候可以通过key而非索引去取值，key对value具有描述性的作用。 存放数据的种类各种各样并且数据较多的时候可以使用字典。
user_info = {'name': 'nick', 'gender': 'male', 'age': 19,
'company_info': ['oldboy', 'shanghai', 50]}
print(id(user_info))
print(type(user_info))
print(user_info)
2904730240056
<class 'dict'>
{'name': 'nick', 'gender': 'male', 'age': 19, 'company_info': ['oldboy', 'shanghai', 50]}
# 字典套列表
user_info = {'name': 'nick', 'gender': 'male', 'age': 19,
'company_info': ['oldboy', 'shanghai', 50]}
print(user_info['name'])
print(user_info['company_info'][0])
nick
oldboy
# 字典套字典
user_info = {'name': 'nick', 'gender': 'male', 'age': 19, 'company_info': {
'c_name': 'oldboy', 'c_addr': 'shanghai', 'c_num_of_employee': 50}}
print(user_info['name'])
print(user_info['company_info']['c_name'])
nick
oldboy
布尔类型（bool）
使用bool（） 可直接得出True或者False的结果
结果为False的情况：
- 定义为False的对象：None、False
- 值为0的数字类型：0、0.0、0j、Decimal（0）、Fraction（0,1）
- 空的序列和集合：'' 、（）、[]、{}、set（）、range(0)
解压缩
#面对如下情况，给出一个列表，需要一次性取出多个值。
name_list = ['nick', 'egon', 'jason']
x = name_list[0]
y = name_list[1]
z = name_list[2]
print(f'x:{x}, y:{y}, z:{z}')
x:nick, y:egon, z:jason
#上面的方法需要定义多个变量值，面对一次性取多个值时比较繁琐，此时可以用解压缩来实现。
name_list = ['nick', 'egon', 'jason', ]
x, y, z = name_list
print(f'x:{x}, y:{y}, z:{z}')
x:nick, y:egon, z:jason
有时候我们解压缩的值可能是我们不想要的，那么可以使用下划线，万能的下划线。
name_list = ['nick', 'egon', 'jason', 'tank']
x, y, z, a = name_list
x, _, z, _ = name_list # _相当于告诉计算机不要了，不能以_开头和结尾
print(x,z)
nick jason
name_list = ['nick', 'egon', 'jason', 'tank', 'kevin', 'jerry']
x, *_, z = name_list # *相当于中间都补齐_
print(f'x:{x},z:{z}')
x:nick,z:jerry
字典里面也可以解压缩，但是字典中解压缩的key
info = {'name': 'nick', 'age': 18}
x, y = info
print(x, y)
name age
注意：无论我们输入的值是数字类型、字符串类型、列表类型，input的接收值都是字符串类型。
运算符
算数运算符
print(3*3) # * 乘号： 输出得9
print(3**4) # ** 次方 ： 输出得81
print(50-5*6) # 遵循数学算数顺序，先乘除，后加减 输出得20
print((50-5*6)/4) # / 除以 返回是浮点数 输出得5.0
print(9/3) #得3.0
print(10/3) #计算机（二进制010101）返回为10进制
#二进制的有穷性 输出得3.3333333333333335（得到的是浮点型）
print(10//3) # //:整数 向下取整 3.3333333333333335 取3
print(-10//3) #地板除 -3.3333333333333335------> 向下取整 取-4
print(10%3) # % 取余数 10//3=3....1 3*3=9 10-9=1
print(-10%3) # -10//3=-4 -4*3=-12 -10-(-12)=2 注意负数！！！！！！
abs(x) # X的绝对值 如果x是复数，那么abs返回的是他的模数
int(x) # 将X转换为整数型
float(x) #将X转换为整数
complex(re,im) #返回一个复数，re是实部，im是虚部。
c.conjugate() #返回c的共轭复数
divmod(x,y) #返回（x//y,x%y） 同时得到商和余数
#任意一个数 X == （x//y）*y+(x%y)
pow(x,y) #计算x的y次方
pow(2,3,5) #相当于2**3 然后再 %5
x ** y #计算x的y次方
print(5.4-3) #2.4000000000000004 并不是Python的bug，是因为计算时需要转为2进制，
# 计算完后结果转为10进制，从而产生精准误差
2.4000000000000004
python中的小数都以浮点数存放
针对上面这种情况通过导入内置的模块 decimal解决
import decimal
a = decimal.Decimal('5.4')
b = decimal.Decimal('3')
print(a-b)
2.4
比较运算符
！[]{http://81rc.81.cn/sy/gzdt_210283/16237252_2.html}
print(11<12)
True
赋值运算符
标准赋值运算符 : = , a += b 等价于 a = a + b ;
加法赋值运算符 : +=
减法赋值运算符 : -=
乘法赋值运算符 : *=
除法赋值运算符 : /=
取整除赋值运算符 : //=
取模赋值运算符 : %=
幂赋值运算符 : **=
逻辑运算符
# 从左到右的方式找到逻辑运算符，找到逻辑运算符的左边，左边成立，再去找到逻辑运算符的右边
print(3 > 3 and 1 > 2 or 2 > 1) # False
身份运算符
# is和==的区别：is用于判断两个变量引用对象是否为同一个(是否在同一块内存空间中)， ==用于判断引用变量的值是否相等。
x = 257
y = x
z = 257
print(f'x is y:{x is y}')
print(f'x == y:{x == y}')
print(f'x is z:{x is z}')
print(f'x == z:{x == z}')
x is y:True
x == y:True
x is z:False
x == z:True
位运算符
#按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
#下表中变量 a 为 60，b 为 13，二进制格式如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b
# 12 = 0000 1100
print("1 - c 的值为：", c)
1 - c 的值为： 12
c = a | b
# 61 = 0011 1101
print("2 - c 的值为：", c)
2 - c 的值为： 61
c = a ^ b
# 49 = 0011 0001
print("3 - c 的值为：", c)
3 - c 的值为： 49
c = ~a
# -61 = 1100 0011
print("4 - c 的值为：", c)
4 - c 的值为： -61
c = a << 2
# 240 = 1111 0000
print("5 - c 的值为：", c)
5 - c 的值为： 240
c = a >> 2
# 15 = 0000 1111
print("6 - c 的值为：", c)
6 - c 的值为： 15
成员运算符
a = 10
b = 20
list = [1, 2, 3, 4, 5]
if (a in list):
print("1 - 变量 a 在给定的列表中 list 中")
else:
print("1 - 变量 a 不在给定的列表中 list 中")
1 - 变量 a 不在给定的列表中 list 中
if (b not in list):
print("2 - 变量 b 不在给定的列表中 list 中")
else:
print("2 - 变量 b 在给定的列表中 list 中")
2 - 变量 b 不在给定的列表中 list 中
# 修改变量 a 的值
a = 2
if (a in list):
print("3 - 变量 a 在给定的列表中 list 中")
else:
print("3 - 变量 a 不在给定的列表中 list 中")
3 - 变量 a 在给定的列表中 list 中
python运算符优先级
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print("(a + b) * c / d 运算结果为：", e)
(a + b) * c / d 运算结果为： 90.0
e = ((a + b) * c) / d # (30 * 15 ) / 5
print("((a + b) * c) / d 运算结果为：", e)
((a + b) * c) / d 运算结果为： 90.0
e = (a + b) * (c / d); # (30) * (15/5)
print("(a + b) * (c / d) 运算结果为：", e)
(a + b) * (c / d) 运算结果为： 90.0
e = a + (b * c) / d; # 20 + (150/5)
print("a + (b * c) / d 运算结果为：", e)
a + (b * c) / d 运算结果为： 50.0
流程判断
if判断
if
if 条件:
代码1
代码2
代码3
...
# 代码块(同一缩进级别的代码，例如代码1、代码2和代码3是相同缩进的代码，这三个代码组合在一起就是一个代码块，相同缩进的代码会自上而下的运行)
if else
if 条件:
代码1
代码2
代码3
...
else:
代码1
代码2
代码3
...
if elif else
if 条件1:
代码1
代码2
代码3
...
elif 条件2:
代码1
代码2
代码3
...
elif 条件3:
代码1
代码2
代码3
...
else:
代码1
代码2
代码3
...
while判断
while循环又称为条件循环
while
while 条件
code 1
code 2
code 3
...
while True:
print('*1'*100)
print('*2'*100)
# 实现ATM的输入密码重新输入的功能
while True:
user_db = 'nick'
pwd_db = '123'
inp_user = input('username: ')
inp_pwd = input('password: ')
if inp_user == user_db and pwd_db == inp_pwd:
print('login successful')
else:
print('username or password error')
while + break
上述代码虽然实现了ATM输入功能，但是用户密码输对了，他也会继续输入，所以此时就需要break语句来打断当前层的循环，执行其他代码
while True:
print('1')
print('2')
break
print('3')
1
2
while True:
user_db = 'nick'
pwd_db = '123'
inp_user = input('username: ')
inp_pwd = input('password: ')
if inp_user == user_db and pwd_db == inp_pwd:
print('login successful')
break
else:
print('username or password error')
print('退出了while循环')
username: nick
password: 123
login successful
退出了while循环
while + continue
continue的意思是终止本次循环，直接进入下一次循环
n = 1
while n < 4:
print(n)
n += 1
1
2
3
while True:
if 条件1:
code1
code2
code3
...
else:
code1
code2
code3
...
continue
n = 1
while n < 10:
if n == 8:
# n += 1 # 如果注释这一行，则会进入死循环
continue
print(n)
n += 1
while循环的嵌套
#ATM密码输入成功还需要进行一系列的命令操作，比如取款，比如转账。并且在执行功能结束后会退出命令操作的功能，即在功能出执行输入q会退出输出功能的while循环并且退出ATM程序。
# 退出内层循环的while循环嵌套
while True:
user_db = 'nick'
pwd_db = '123'
inp_user = input('username: ')
inp_pwd = input('password: ')
if inp_user == user_db and pwd_db == inp_pwd:
print('login successful')
while True:
cmd = input('请输入你需要的命令：')
if cmd == 'q':
break
print(f'{cmd} 功能执行')
else:
print('username or password error')
print('退出了while循环')
# 退出双层循环的while循环嵌套
while True:
user_db = 'nick'
pwd_db = '123'
inp_user = input('username: ')
inp_pwd = input('password: ')
if inp_user == user_db and pwd_db == inp_pwd:
print('login successful')
while True:
cmd = input('请输入你需要的命令：')
if cmd == 'q':
break
print(f'{cmd} 功能执行')
break
else:
print('username or password error')
print('退出了while循环')
tag控制循环退出
# tag控制循环退出
tag = True
while tag:
user_db = 'nick'
pwd_db = '123'
inp_user = input('username: ')
inp_pwd = input('password: ')
if inp_user == user_db and pwd_db == inp_pwd:
print('login successful')
while tag:
cmd = input('请输入你需要的命令：')
if cmd == 'q':
tag = False
print(f'{cmd} 功能执行')
else:
print('username or password error')
print('退出了while循环')
username: nick
password: 123
login successful
请输入你需要的命令：q
q 功能执行
退出了while循环
while+else
while+else：else会在while没有被break时才会执行else中的代码。
# while+else
n = 1
while n < 3:
print(n)
n += 1
else:
print('else会在while没有被break时才会执行else中的代码')
1
2
else会在while没有被break时才会执行else中的代码
for循环
基础语法
给出一个列表，我们把这个列表里面的所有名字取出来，可以直接用while语句
name_list = ['nick', 'jason', 'tank', 'sean']
n = 0
while n < 4:
# while n < len(name_list):
print(name_list[n])
n += 1
nick
jason
tank
sean
字典也有取多个值的需求，字典可能有while循环无法使用了，这个时候可以使用我们的for循环。
info = {'name': 'nick', 'age': 19}
for item in info:
# 取出info的keys
print(item)
name
age
name_list = ['nick', 'jason', 'tank', 'sean']
for item in name_list:
print(item)
nick
jason
tank
sean
for循环的循环次数受限于容器类型的长度，而while循环的循环次数需要自己控制。for循环也可以按照索引取值。
print(list(range(1, 10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(1, 10): # range顾头不顾尾
print(i)
1
2
3
4
5
6
7
8
9
# for循环按照索引取值
name_list = ['nick', 'jason', 'tank', 'sean']
for i in range(len(name_list)):
print(i, name_list[i])
0 nick
1 jason
2 tank
3 sean
在Python中，len()是一个内置函数，用于返回一个对象的长度或元素的个数。它通常用于字符串、列表、元组、字典和其他可迭代对象。
str = "Hello World"
print(len(str)) # 输出：11 因为空格也算一个空间
11
# 对于列表和元组，len()会返回列表或元组中的元素个数。
my_list = [1, 2, 3, 4, 5]
print(len(my_list)) # 输出：5
my_tuple = (1, 2, 3, 4, 5)
print(len(my_tuple)) # 输出：5
5
5
#对于字典，len()会返回字典中键值对的个数。
my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict)) # 输出：3
3
for+break
# for+break
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
if name == 'jason':
break
print(name)
nick
for+continue
# for+continue
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
if name == 'jason':
continue
print(name)
nick
tank
sean
for循环嵌套
# for循环嵌套
for i in range(3):
print(f'-----:{i}')
for j in range(2):
print(f'*****:{j}')
-----:0
*****:0
*****:1
-----:1
*****:0
*****:1
-----:2
*****:0
*****:1
for+else
# for+else
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
print(name)
else:
print('for循环没有被break中断掉')
nick
jason
tank
sean
for循环没有被break中断掉
for item in iterable:
# 执行循环体的代码
else:
# 执行循环结束后的代码
for-else语句的工作方式如下：
- 首先，迭代对象（如列表、字符串、元组等）将按顺序逐个赋值给变量item。
- 进入循环体，执行循环体里的代码块。
- 如果循环正常结束（没有遇到break语句），则执行else块中的代码。
- 如果循环被break语句中断，则不执行else块中的代码。
for循环实现loading
import time
print('Loading', end='')
for i in range(6):
print(".", end='')
time.sleep(0.2)
Loading......
这段代码使用了time模块来实现一个简单的加载动画效果。代码的功能是打印出"Loading…"的动画效果，每打印一个点号停顿0.2秒。
-
首先，我们导入了time模块，这是Python标准库中用于时间相关操作的模块。
-
然后，通过一个for循环来迭代range(6)，表示打印6个点号。
-
在循环内部，使用print()函数打印一个点号，并通过end=''参数来指定打印结束时不换行，从而使点号连续打印在一行中。这样就实现了"Loading…"的效果。
-
接下来，调用time.sleep(0.2)函数来让程序暂停0.2秒，也就是每打印一个点号后停顿0.2秒。
-
最终的效果是，程序依次打印".“，停顿0.2秒，再打印一个”."，再停顿0.2秒，以此类推，直到打印6个点号形成"Loading…"的动画效果。
注意：time.sleep()函数用于在程序执行过程中暂停指定的秒数，这里用它来制造停顿效果。
# 给定年龄，用户可以猜三次年龄
# 年龄猜对，让用户选择两次奖励
# 用户选择两次奖励后可以退出
age = 18 # 答案
count = 0 # 游戏次数控制
prize_dict = {0: '布娃娃', 1: '变形金刚', 2: '奥特曼', 3: '女朋友'}
# 核心代码
while count < 3:
inp_age = input('请输入你的年龄>>>') # 与用户交互
# 判断用户是否骚扰(超纲：判断用户输入的是否为数字)
if not inp_age.isdigit():
print('傻逼,你的年龄输错了')
continue
inp_age_int = int(inp_age)
# 核心逻辑,判断年龄
if inp_age_int == age:
print('猜对了')
print(prize_dict) # 打印奖品
# 获取两次奖品
for i in range(2):
prize_choice = input(
'请输入你想要的奖品,如果不想要,则输入"n"退出!!!') # 与用户交互获取奖品
# 判断是否需要奖品
if prize_choice != 'n':
print(f'恭喜你获得奖品: {prize_dict[int(prize_choice)]}')
else:
break
break
elif inp_age_int < age:
print('猜小了')
else:
print('猜大了')
count += 1 # 成功玩一次游戏
if count != 3:
continue
again_choice = input('是否继续游戏,继续请输入"Y",否则任意键直接退出.') # 交互是否再一次
# 判断是否继续
if again_choice == 'Y':
count = 0
请输入你的年龄>>>18
猜对了
{0: '布娃娃', 1: '变形金刚', 2: '奥特曼', 3: '女朋友'}
请输入你想要的奖品,如果不想要,则输入"n"退出!!!3
恭喜你获得奖品: 女朋友
请输入你想要的奖品,如果不想要,则输入"n"退出!!!2
恭喜你获得奖品: 奥特曼
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现