8天学习python笔记05

day05 数据类型（上）

数据类型的知识点，常见的数据类型：

• int，整数类型(整型)

• bool，布尔类型

• str，字符串类型

• list，列表类型

• tuple，元组类型

• dict，字典类型

• set，集合类型

• float，浮点类型(浮点型)

  每种数据类型都有自己的特点及应用场最，以后的开发中需要根据实际的开发情况选择合适的数据类型。

  # int类型
  
  v1 = 123
  v2 = 888
  v3 = 12345
  ...
  

  #  bool类型
  
  v1 = True
  v2 = False
  

  # str 类型
  v1 = "佩奇"
  v2 = "Python"
  ...
  

  # list类型
  
  v1 = [11,22,33]
  v2 = ["佩奇","Alex"]
  ...
  

  # dict类型
  v1 = ["K1":1,"k2":2]
  v2 = ["name":"佩奇","age":18]
  

每种数据类型的讲解，会按照以下4个维度来进行:

1.定义

2.独有功能

3.公共功能

4.类型转换

5.其他

1.整型

整型其实就是十进制整数的统称，比如: 1、68、999都属于整型。他一般用于表示年龄、序号等。

1.1定义

number = 10

age = 99

1.2独有功能

无

v1 = 5
print(bin(v1))  # 0b101
# 调用v1(int)的独有功能，获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1)  # 3

1.3公共功能

加减乘除

v1 = 4

v2 = 8
v3 = v1 + v2

1.4转换

在项目开发和面试题中经常会出现一些“字符串”和 布尔值 转换为 整型的情况。

# 布尔值转整型

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

# 字符串转整型

v1 = int("186",base=10) 
#把字符串看成十进制的值，然后再转换为 十进制整数，结果: v1 = 186

v2 = int("0b1001",base=2) 
#把字符串看成二进制的值，然后再转换为 十进制整数，结果: v2 = 9 (0b表示二进制)

v3 = int("0o144", base=8) 
#把字符串看成八进制的值，然后转换为 十进制整数，结果: v3 = 100 (0o表示八进制)

v4 = int("0x59",base=16) 
#把字符串看成十六进制的值，然后转换为十进制整数，结果: v4 = 89 (0x表示十六进制)

所以，如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

1.5其他

1.5.1长整型

• python3 :整型(无限制)
• python2 :整型，长整型

在python2中跟整数相关的数据类型有两种: int(整型)、 long (长整型)， 他们都是整数只不过能表示的值范围不同。

• int，可表示的范围: -9223372036854775808~ 9223372036854775807
• long，整数值超出int范围之后自动会转换为long类型(无限制)。

在python3中去除了long只剩下: int (整型)，并且int长度不再限制。

1.5.2地板除

python2中两个值相除时，默认进行地板除，只保留整数位。(python3中默认会保留小数)

# py3:
v1 = 9/2
print(v1)  #4.5

# py2:
v1 = 9/2
print(v1)  #4

#默认
v1 = 3/2  #值为1

#想要保留小数位
from_future_ import division
v2 = 3/2  #值为 1.5

2.布尔类型

布尔值，其实就是“真"、“假”。

2.1定义

data = False

alex_ is _sb = True

2.2独有功能

无

2.3公共功能

无

v1

2.4转换

在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。

整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False
其他均为True

#练习题:查看一些变量为True还是False

v1 = bool(0)  # False
v2 = bool(-10)  # True
v3 = bool(10)  # True
v4 = bool("佩奇")  # True
v5 = bool("")  # False
v6 = bool(" ")  # True
v7 = bool([])  # ([])表示空列表  False
v8 = bool([11, 22, 33])  # [11, 22, 33]表示非空列表  #True
v9 = bool({})  # {}表示空字典  # False
v10 = bool({"name": "佩奇", "age": 18})  # {"name":"佩奇" , age" :18}表示非空字典  # True
 

2.5其他

2.5.1做条件自动转换

如果在if、while 条件后面写一个值当做条件时，他会默认转换为布尔类型，然后再做条件判断。

if 1 > 2:
    print("太六了")
else:
    print(999)

if " 佩奇":
    print("你好")

if "alex":
    print("你是傻逼? ")
else:
    print("你是逗比? ") 

 while 1 > 9:
    pass

if 值:    #默认转换为布尔类型，然后再做条件判断
    pass

while 值:    #默认转换为布尔类型，然后再做条件判断
    pass

3.字符串类型

字符串，我们平时会用他来表示文本信息。例如:姓名、地址、自我介绍等。

3.1定义

v1 = "包治百病"
v2 = '包治百病'
v3 = "包'治百病"
v4 ='包"治百病'
v5 = """
吵架都是我的错，
因为大家打不过。
"""

#三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。

• endswith() 和 startswith() 是 Python 字符串方法，用于检查字符串是否以指定的子字符串开头或结尾。这两个方法返回布尔值（True 或 False）

• # startswith()
  定义：startswith() 方法用于检查字符串是否以指定的前缀开头。
  语法：str.startswith(prefix[, start[, end]])
  prefix：可以是单个字符串或字符串组成的元组。如果提供多个前缀，只要有一个匹配即可返回 True。
  start（可选）：开始检查的索引位置，默认为字符串开头。
  end（可选）：结束检查的索引位置，默认为字符串结尾。
  

• # endswith()
  定义：endswith() 方法用于检查字符串是否以指定的后缀结尾。
  语法：str.endswith(suffix[, start[, end]])
  suffix：可以是单个字符串或字符串组成的元组。如果提供多个后缀，只要有一个匹配即可返回 True。
  start（可选）：开始检查的索引位置，默认为字符串开头。
  end（可选）：结束检查的索引位置，默认为字符串结尾。
  

3.2 独有功能

XX开头 XX结尾

"xxxxx".功能（...）

v1 = "xxxxx"
v1.功能（...）

1.判断字符串是否以XX开头?得到一个布尓值

v1 = "叨逼叨的一天，烦死"
# True
result = v1.startswith("叨逼叨的一天") #XX开头

print(result)  # 值为True

# 案例

v1 = input("请输入住址: ")
if v1.startswith("北京市"):
    print("北京人口")
else:
    print("非北京人口")

2.判断字符串是否以XX结尾?得到一个布尓值

v1 = "叨逼叨的一天，烦死了"
# True
result = v1.startswith("烦死")  #XX结尾

print(result)  # 值为False

# 案例

address = input("请输入住址: ")
if address.endswith("村"):
    print("农业户口")
else:
    print("非农户口")

3.判断字符串是否为十进制数?得到一个布尔值

• isdecimal() 和 isdigit() 方法的区别，这两个方法都是 Python 字符串的方法，用于检查字符串是否包含数字字符，但它们的行为有所不同

# isdecimal()
定义：isdecimal() 方法检查字符串是否仅由十进制数字（0-9）组成。
特点：
只返回 True 对于 Unicode 十进制数字字符。
不包括其他类型的数字字符，如带圈数字、罗马数字等。

# isdigit()
定义：isdigit() 方法检查字符串是否仅由数字字符组成，包括十进制数字和其他形式的数字字符（如带圈数字、下标和上标数字等）。
特点：
包括更广泛的数字字符集，如带圈数字、罗马数字等。

# 其他相关方法
# isnumeric()：
检查字符串是否仅由数值字符组成，包括分数、次方和其他形式的数值字符。
比 isdigit() 更广泛，例如包括某些分数字符。

# 应用场景
输入验证：
使用 isdecimal() 来确保用户输入的是纯粹的十进制数字。
使用 isdigit() 或 isnumeric() 来允许更广泛的数字字符集，具体取决于应用需求。

v1 = "1238871"

result = v1.isdecimal()
print(result) # True

# 案例，两个数相加。
# isdecimal() 只能检查字符串是否由十进制数字组成，不能处理负数或带小数点的数字。

v1 = input("请输入值:")  # "666"

v2 = input("请输入值:")  # "999"

if v1.isdecimal() and v2.isdecimal():
    data = int(v1) + int(v2)
    print(data)

else:
    print("请正确输入数字")

v1 = "123"
print(v1.isdecimal())  # True

v2 = "①"
print(v2.isdecimal())  # False

v3 = "123"
print(v3.isdigit())  # True

v4 = "①"
print(v4.isdigit())  # True

4.去除字符串两边的 空格、换行符、制表符，得到一个新字符串

data = input("请输入内容: ") #佩奇，佩奇
print (data)

msg = " H e ll o啊，树哥 "

data = msg.strip()

print(data)  # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

lstrip()

• 定义：lstrip() 方法用于去除字符串左边（开头）的空白字符。

msg = "H e ll o啊，树哥"

data = msg.lstrip()

print(data)  # 将msg左边的空白去掉，得到"H e ll o啊，树哥 "

rstrip()

• 定义：rstrip() 方法用于去除字符串右边（结尾）的空白字符。

msg = "H e ll o啊，树哥"

data = msg.rstrip()

print(data)  # 将msg右边的空白去掉，得到" H e ll o啊，树哥"

# 案例

code = input("请输入4位验证码: ")  #  FB87  用于去除空白字符。
data = code.strip()

if data == "FB87":
    print('验证码正确')
else:
    print("验证码错误") 

补充：去除字符串两边指定的内容

msg = "哥H e ll o啊，树哥"
data = msg.strip("哥")
print(data)  # 将msg两边的“哥”，得到"H e ll o啊，树"

5.字符串变大写，得到一个新字符串

• upper() 方法用于将字符串中的所有小写字母转换为大写字母。

msg = "my name is oliver queen"
data = msg.upper()
print(msg)  # my name is oliver queen
print(data)  # 输出为: MY NAME IS OLIVER QUEEN

#案例

code = input("请输入4位验证码: ")  #fb87  FB87  
data = code.strip()
value = data. upper()

# value = code .strip() upper()

if value == "FB87":
    print("验证码正确")
else:
    print("验证码错误")

6.字符串变小写，得到一个新字符串

• lower() 方法用于将字符串中的所有大写字母转换为小写字母。

msg = "MY NAME IS OLIVER QUEEN"
data = msg.lower()
print(data)  # 输出为: my name is oliver queen

#案例
code = input("请输入4位验证码: ")  #fb87  FB87  
data = code.strip().lower()
if value == "fb87":
    print("验证码正确")  #fb87
else:
    print("验证码错误")  

7.字符串内容替换，得到一个新的字符串

• replace() 方法用于将字符串中的某个子字符串替换为另一个子字符串。

• 语法

  str.replace(old, new[, count])
  

  • old：要替换的旧子字符串。
  • new：用来替换的新子字符串。
  • count（可选）：指定替换的最大次数。如果不提供，默认替换所有匹配项。

data = "你是个好人，但是好人不合适我"

value = data. replace("好人", "坏人")

print(data)  # "你是个好人，但是好人不合适我"
print(value)  # "你是个坏人，但是坏人不合适我"

 #案例

video_file_name = "高清无码疯狂动物成. mp4"

new_file_name = video_file_name.replace( "mp4", "avi")  # 高清无码疯狂动物成. avi
final_file_name = new_file_name.replace( "无码", "步兵")  # 高清步兵疯狂动物成. avi
print(final_file_name)

8.字符串切割，得到一个列表

• rsplit()：从字符串的右边开始分割，适用于需要从右向左解析的场景，如文件路径、URL 等。

• split()：从字符串的左边开始分割，适用于大多数常规的字符串分割需求。

data = "佩奇|root|peiqi@qq.com"

result = data.split('|')  # ["佩奇", "root", "peiqi@qq.com"]

print(data)  # 输出: "佩奇|root|peiqi@qq.com"

print(result)  # 输出: ['佩奇', 'root', 'peiqi@qq.com']根据特定字符切开之后保存在列表中，方便以后的操作

# 案例:判断用戸名或密码是否正确

info = "佩奇,root"  # 各注:字符串中存储了用戸名或密码

user_list = info.split(',')  # 得到一个包含了2个元素的列表 ["佩奇", "root"]去除可能的空白字符","

# user_1ist[0]
# user_1ist[1]
# 获取用户输入
user = input("请输入用户名: ").strip()
pwd = input("请输入密码: ").strip()

# 检查用户名和密码是否匹配
if user == user_list[0] and pwd == user_list[1]:
    print("登录成功")
else:
    print("用户名或密码错误")

扩展

data = "佩奇|root|peiqi@qq.com"

# 不指定 maxsplit，分割所有匹配项
v1 = data.split("|")
print(f"分割所有匹配项: {v1}")  # 输出: ['佩奇', 'root', 'peiqi@qq.com']

# 指定 maxsplit=2，最多分割两次
v2 = data.split("|", 2)
print(f"最多分割两次: {v2}")  # 输出: ['佩奇', 'root', 'peiqi@qq.com']

# 指定 maxsplit=1，最多分割一次
v3 = data.split("|", 1)
print(f"最多分割一次: {v3}")  # 输出: ['佩奇', 'root|peiqi@qq.com']

应用场景：

file_path = "xxx/xxxx/xx.xx/xxx.mp4"

# 使用 rsplit() 方法按 '.' 分割，最多分割一次
data_list = file_path.rsplit(".", 1)

# 打印分割后的结果
print("完整的 data_list:", data_list)  # 输出: ['xxx/xxxx/xx.xx/xxx', 'mp4']

# 分别打印文件路径部分和扩展名
print("文件路径部分:", data_list[0])  # 输出: xxx/xxxx/xx.xx/xxx
print("文件扩展名:", data_list[1])    # 输出: mp4

9.字符串拼接，得到一个新的字符串

join()

• 定义：join() 方法用于将序列（如列表、元组）中的字符串元素连接成一个新的字符串。

• 语法:

  separator.join(iterable)
  

  • separator：指定用来连接字符串的分隔符。
  • iterable：包含字符串元素的可迭代对象（如列表、元组等）。

data_list = ["alex", "是", "大烧饼"]
v1 = "_".join(data_list)  # alex_是_大烧饼
print(v1)

10.格式化字符串，得到新的字符串

name = "{0}的喜欢干很多行业，例如有: {1}、{2}等"
data = name.format("佩奇", "护士", "培训")

print(data)  # 输出: 佩奇的喜欢干很多行业，例如有: 护士、培训等
print(name)  # 输出: {0}的喜欢干很多行业，例如有: {1}、{2}等

11.字符串转换为字节类型

encode() 和 decode()：

• encode()：将字符串（Unicode）转换为指定编码的字节类型。
• decode()：将字节类型的数据解码回字符串（Unicode）。

# 定义一个包含中文字符的字符串
data = "嫂子"  # Unicode 字符串

# 使用 utf-8 编码将字符串转换为字节类型
v1 = data.encode("utf-8")
print(f"UTF-8 编码: {v1}")  # 输出: b'\xe5\xa7\x94\xe5\xad\x90'

# 使用 gbk 编码将字符串转换为字节类型
v2 = data.encode("gbk")
print(f"GBK 编码: {v2}")    # 输出: b'\xc9\xab\xd7\xd3'

s1 = v1.decode("utf-8")  # 嫂子
s2 = v2.decode("gbk")  # 嫂子
print(s1)
print(s2)

12.将字符串内容居中，居左，居右展示：

字符串对齐方法

1. center(width, fillchar)：

   • 定义：返回一个原字符串居中并用指定字符填充至指定宽度的新字符串。

   • 参数

     ：

     • width：指定总宽度。
     • fillchar（可选）：指定填充字符，默认是空格。

2. ljust(width, fillchar)：

   • 定义：返回一个原字符串左对齐并用指定字符填充至指定宽度的新字符串。

   • 参数

     ：

     • width：指定总宽度。
     • fillchar（可选）：指定填充字符，默认是空格。

3. rjust(width, fillchar)：

   • 定义：返回一个原字符串右对齐并用指定字符填充至指定宽度的新字符串。

   • 参数

     ：

     • width：指定总宽度。
     • fillchar（可选）：指定填充字符，默认是空格。

v1 = "王老汉"

# 居中对齐，总宽度为 21，填充字符为 "_"
data_center = v1.center(21, "_")
print(data_center)  # 输出: _______王老汉________

# 左对齐，总宽度为 21，填充字符为 "_"
data_left = v1.ljust(21, "_")
print(data_left)      # 输出: 王老汉__________________

# 右对齐，总宽度为 21，填充字符为 "_"
data_right = v1.rjust(21, "_")
print(data_right)     # 输出: __________________王老汉

13.帮助你填充0

zfill()：用于在字符串左侧填充零，以确保字符串达到指定的宽度

data = "alex"

# 使用 zfill() 在左侧填充零，使字符串总宽度为 10
v1 = data.zfill(10)
print(f"填充后的字符串: {v1}")  # 输出: 000000alex

#  处理二进制数据
data = "101"

# 使用 zfill() 在左侧填充零，使字符串总宽度为 8
v1 = data.zfill(8)
print(f"填充后的二进制字符串: {v1}")  # 输出: 00000101

练习题

1.写代码实现判断用户输入的值否以"al"开头，如果是则输出"是的"否则输出“不是的"

# 获取用户输入
value = input("请输入一个值: ")

# 判断是否以 "al" 开头
if value.startswith("al"):
    print("是的")
else:
    print("不是的")

2.写代码实现判断用户输入的值否以"Nb"结尾,如果是则输出"是的"否则输出"不是的"

# 获取用户输入
value = input("请输入一个值: ")

# 判断是否以 "al" 开头
if value.endswith("Nb"):
    print("是的")
else:
    print("不是的")

3.将name变量对应的值中的所有的"|"替换为"p",并输出结果

name = "||alex||  "

# 先去除字符串两端的空白，再将剩余的 "|" 替换为 "p"
value = name.strip().replace("|", "p")

print(value)  # 输出: pppalexp

# -replace("|", "p")：正确地指定了要替换的目标字符为 "|"，而不是其他字符
# -使用 strip() 方法去除字符串两端的空白后再进行替换

4.写代码实现对用户输入的值判断，是否为整数，如果是则转换为整型并输入，否则直接输出"请输入数字"

while True:
    value = input("请输入值：").strip()

    if value.isdecimal():
        data = int(value)
        print(data)
        break  # 输入正确后退出循环
    else:
        print("请输入数字")

5.对用户输入的数据使用"+"切割，判断输入的值是否都是数字?
提示:用户输入的格式必须是以下+连接的格式，如5+9、alex+999

data = input("请输入内容：")
result = data.split('+',1)
if result[0].isdecimal() and result[1].isdecimal():
    print("是数字")
else:
    print("不是")

6.写代码实现一个整数加法计算器(两个数相加)

需求:提示用户输入: 5+9或15+9或5+29, 计算出两个值的和(提示:先分割再转换为整型，再相加)

print("提示输入: 5+9或15+9或5+29, 计算出两个值的和")
value = input("请输入内容：")
data_list =value.split("+", 1)

if data_list[0].isdecimal() and data_list[1].isdecimal():
    v1 = int(data_list[0])
    v2 = int(data_list[1])
    result = v1+v2
    print(result)
else:
    print("输入错误" )

7.写代码实现一个整数加法计算器(两个数相加)

需求:提示用户输入:5+9或15+9或5+29,计算出两个值的和(提示:先分割再去除空白、再转换为整型,再相加)

print("提示输入: 5+9 或 15+9 或 5+29, 计算出两个值的和")
value = input("请输入内容：")

# 使用 split() 方法将字符串按 '+' 分割成两部分
data_list = value.split("+", 1)

# 去除每个部分的空白字符并转换为整数

v1 = int(data_list[0].strip())
v2 = int(data_list[1].strip())

# 计算两个值的和
result = v1 + v2
print(f"计算结果: {result}")

8.补充代码实现用户认证。

需求:提示用户输入手机号、验证码，全都验证通过之后才算登录成功(验证码大小写不敏感)

import random

# 生成动态验证码
code = random.randrange(1000, 9999)
msg = "欢迎登录PythonAV系统，您的验证码为: {}, 手机号为: {}".format(code, "15131266666")
print(msg)

phone_number = "15131266666"  # 预定义的有效手机号码

while True:
    print("——————欢迎进入PythonAV系统——————")
    number = input("请输入手机号：")
    value = input("请输入验证码：").strip().upper()  # 输入验证码并去除空白字符，转换为大写

    if number == phone_number and value == str(code).upper():
        print("验证码正确")
        print("登录成功")
        break
    else:
        print("账号或验证码错误，请重新输入")

9.补充代码实现数据拼接

# 把输入的值添加到data_list 中，如: data_list = ["听音乐”,”哥们的女朋友"]
# # 将所有的爱好通过符号”、" 拼接起来并输出
data_list = []

while True:
    hobby = input("请输入你的爱好(Q/q退出) : ")
    if hobby.upper() == 'Q':
        break
    data_list.append(hobby)

result = "、".join(data_list)
print(result) 

3.3公共功能

1.相加：字符串 + 字符串

v1 = "alex" + "去吃饭"
print(v1)

2.相乘：字符串 * 整数

data = "兄弟" * 3
print(data) # 兄弟兄弟兄弟

3.长度

data = "跑步会出汗"
value = len(data)
print(value) # 5

4.获取字符串中的字符，索引

 message = "来做点py交易呀"
#          0 1 2345 6 7
#          ......-3-2-1
print(message[0])  # "来"
print(message[1])  # "做"
print(message[2])  # "点"

print(message[-1])  # 呀
print(message[-2])  # 易
print(message[-3])  # 交

注意：字符串中是能通过索引取值，无法修改值。【字符串在内部存储时不允许对内部元素修改，想修改只能重新创建。】

message = "来做点py交易呀"
index = 0
while index < len(message):
	value = message[index]
    print(value)
    index += 1

message = "来做点py交易呀"
index = len(message) - 1
while index >= 0:
    value = message[index]
    print(value)
    index -= 1

5.获取字符串中的子序列，切片

message = "来做点py交易呀"

print(message[0:2]) # "来做"
print(message[3:7]) # "py交易"
print( message[3:] ) # "py交易呀"
print( message[:5] ) # "来做点py"

print(message[4:-1]) # "y交易"
print(message[4:-2]) # "y交"

print( message[4:len(message)] ) # "y交易呀"

注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想要修改只能重新创建】

message = "来做点py交易呀"

value = message[:3] + "Python" + message[5:]
print(value)  # 来做点Python交易呀

6.步长，跳着去字符串的内容

string[start:end:step]

name = "生活不是电影，生活比电影苦"
# []在python里面前取后不取，相当于开区间闭区间

print(name[0:5:2])  # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】
print(name[:8:2])  # 输出：生不电，  【区间范围的前面不写则表示起始范围为0开始】、

print(name[2::3])  # 输出：不影活影 【区间范围的后面不写则表示结束范围为最后】
print(name[::2])  # 输出：生不电，活电苦 【区间范围不写表示整个字符串】
print(name[8:1:-1])  # 输出：活生，影电是不 【倒序】

可用于字符串翻转

name = "生活不是电影，生活比电影苦"

print(name[8:1:-1])  # 输出：活生，影电是不 【倒序】
print(name[-1:1:-1])  # 输出：苦影电比活生，影电是不 【倒序】

# 面试题：给你一个字符串，请将这个字符串翻转。
value = name[-1::-1]
print(value)  # 苦影电比活生，影电是不活生

7.循环

• while循环

message = "来做点py交易呀"
index = 0
while index < len(message):
	value = message[index]
    print(value)
    index += 1

• for循环

message = "来做点py交易呀"
# char获取循环遍历的变量
for char in message:
    print(char)

• range，帮助我们创建一系列的数字

前取后不取

range(10)  # [0,1,2,3,4,5,6,7,8,9]
range(1, 10)  # [1,2,3,4,5,6,7,8,9]
range(1, 10, 2)  # [1,3,5,7,9]
range(10, 1, -1)  # [10,9,8,7,6,5,4,3,2]

• for + range

for i in range(10):
    print(i)

message = "来做点py交易呀"
for i in range(5):  # [0,1,2,3,4]
    print(message[i])  # 来做点py

message = "来做点py交易呀"
for i in range(len(message)):  # [0,1,2,3,4,5,6,7]
    print(message[i])

• 一般应用场景while和for：

  • while，一般在做无限制（未知）循环此处时使用。

  while True:
      ...
  

  # 用户输入一个值，如果不是整数则一直输入，直到是整数了才结束。
  num = 0
  while True:
      data = input("请输入内容:")
      if data.isdecimal():
          num = int(data)
          break
  	else:
          print("输入错误，请重新输入！")
  

  • for循环，一般应用在已知的循环数量的场景。

  message = "来做点py交易呀"
  for char in message:
      print(char)
  

  for i in range(30):
      print(message[i])
  

  • break和continue关键字
  • break 用于完全终止循环。
  • continue 仅用于跳过当前循环迭代中的剩余语句，并开始下一次迭代。

  message = "来做点py交易呀"
  for char in message:
      if char == "p":
          continue
      print(char)
  
  # 输出：
  来
  做
  点
  y
  交
  易
  呀 
  

  message = "来做点py交易呀"
  for char in message:
      if char == "p":
          break
      print(char)
  
  # 输出：
  来
  做
  点
  

  # break终止输出j
  for i in range(5):
      print(i)  # 0 1 2 3 4
      for j in range(3):
          break
          print(j)  # 0 1 2  # 0 1 2  # 0 1 2  # 0 1 2  # 0 1 2
  

3.4转换

# 整型转字符串
num = 999
data = str(num)
print(data) # "999"

# 列表转字符串无意义
# 一般情况下，只有整型转字符串才有意义。

data_list = ["alex","eric",999]
data = str(data_list)
print(data) # '["alex","eric",999]'

3.5 其他

3.5.1 字符串不可被修改

name = "佩奇"

name[1]
name[1:2]  #切片

# 列表
# 可以通过索引被修改
num_list = [11, 22, 33]

num_list[0]
num_list[0] = 666
print(num_list)  # [666, 22, 33]

总结：

1. 整型在Python2和Python3中的区别？
   • 在Python 2中，有两种整数类型：int 和 long。
   • Python 3移除了这种区分，所有整数都是统一的 int 类型 。
2. 进制之间的转换。

• 进制转换可以通过内置函数完成。例如：
  • 将十进制整数转为二进制、八进制或十六进制字符串：bin(), oct(), hex()
  • 使用 int() 函数将其他进制的字符串转为十进制整数，如 int('1010', 2) 表示将二进制字符串 '1010' 转换为十进制。

3. 其他类型转换为布尔类型时，空和0为False，其他均为True。

4. 条件语句中可自动化转换布尔类型来做判断。

if "佩奇":
    print(666)
else:
    print(999)

5. 字符串中常见的独有功能。

6. 字符串中常见的公共功能。

7. 字符串创建之后是不可以被修改的。

作业题：

1.请用代码实现如下进制的转换。

v1 = 675  # 请将v1转换为二进制（字符串类型）。
v1 = bin(675)
print(v1)  # 0b1010100011

v2 = "0b11000101"  # 请将二进制v2转换为十进制（整型）
v2 = int("0b11000101", base=2)  # 197
print(v2)

v3 = "11000101"  # 请将二进制v3转换为十进制（整型）
v3 = int("11000101", base=2)  # 197
print(v3)

2.按要求实现

现有 v1=123 和 v2=456，请将这两个值转换为二进制，并将其二进制中的前缀 0b 去掉，然后将两个二进制拼接起来，最终再转换为整型（十进制）。

例如：

123 对应二进制为 "0b1111011" ，去除前缀0b之后的二进制为 "1111011"

456 对应二进制为 "0b111001000" ，去除前缀0b之后的二进制为 "111001000"

将两个二进制拼接起来的值为："1111011111001000"，再将此值转换为整型为：63432

v1 = 123
v2 = 456

# 将整数转换为二进制字符串，并去掉前缀 '0b'
binary_v1 = bin(v1)[2:]  # 去掉'0b'前缀
binary_v2 = bin(v2)[2:]  # 去掉'0b'前缀

# 拼接两个二进制字符串
Binary = binary_v1 + binary_v2

# 将拼接后的二进制字符串转换为十进制整数
result = int(Binary, base=2)

print(result)  # 输出最终的十进制整数

3.按要求实现

现有 v1=123 和 v2=456，请将这两个值转换为二进制，并将其二进制中的前缀 0b 去掉，再补足为2个字节（16位），然后将两个二进制拼接起来，最终再转换为整型（十进制）。

例如：

123 对应二进制为 "0b1111011" ，去除前缀0b之后的二进制为 "1111011" ，补足16位为 "00000000 01111011"

456 对应二进制为 "0b111001000" ，去除前缀0b之后的二进制为 "111001000"，，补足16位为 "00000001 11001000"

将两个二进制拼接起来的值为："00000000 0111101100000001 11001000"，再将此值转换为整型为：8061384

v1 = 123
v2 = 456

# 将整数转换为二进制字符串，并去掉前缀 '0b'
binary_v1 = bin(v1)[2:]  # 去掉'0b'前缀
binary_v2 = bin(v2)[2:]  # 去掉'0b'前缀
# 使用 zfill() 在左侧填充零，使字符串总宽度为 16
Binary = (binary_v1.zfill(16)) + (binary_v2.zfill(16))
print(Binary)

# 将拼接后的二进制字符串转换为十进制整数
result = int(Binary, base=2)

print(result)  # 输出最终的十进制整数

4.列举你了解的那些数据类型的值转换为布尔值为False。

v1 = bool(0)
print(v1)
v2 = bool("")
print(v2)
v3 = bool([])
print(v3)
v4 = bool({})
print(v4)

5.看代码写结果：

if "":
    print(123)
else:
    print(456)
# 456 

if 0:
    print(999)
else:
    print(666)
# 666

if "佩奇":
    print(345)
else:
    print(110)
# 345

6.让用户输入一段文本，请实现将文本中的敏感词 苍老师、波波老师替换为 ***，最后并输入替换后的文本。

# 获取用户输入的文本
data = input("请输入文本：")

# 替换敏感词 "苍老师" 和 "波波老师" 为 "***"
value = data.replace("苍老师", "***").replace("波波老师", "***")

# 输出替换后的文本
print(value)

7.有变量name = "aleX leNb " 完成如下操作：

• 移除 name 变量对应的值两边的空格,并输出处理结果

name = "aleX leNb "
data = name.strip()

print(data)

• 判断 name 变量是否以 "al" 开头,并输出结果（用切片 或 startswith实现）

data = "aleX leNb "
name = data.strip()
if name.startswith("al"):
    print(name)
else:
    print("不是以al开头")

• 判断name变量是否以"Nb"结尾,并输出结果（用切片 或 endswith实现）

data = "aleX leNb "
name = data.strip()
if name.endswith("Nb"):
    print(name)
else:
    print("不是以al开头")

• 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果

data = "aleX leNb "
name = data.replace("l", "p")
print(name)

• 将 name 变量对应的值根据 所有的"l" 分割,并输出结果

data = "aleX leNb "
result = data.split('l')
print(result)
# ['a', 'eX', 'Ne', 'b']

• 将name变量对应的值根据第一个"l"分割,并输出结果

name = "aleX leNb"

# 使用 split 方法并限制最大分割次数为 1
result = name.split('l', 1)

# 输出结果
print(result)
# ['a', 'eX leNb']

• 将 name 变量对应的值变大写,并输出结果

data = "aleX leNb "
result = data.upper()
print(result)
# ALEX LENB 

• 将 name 变量对应的值变小写,并输出结果

data = "aleX leNb "
result = data.lower()
print(result)

8.如何实现字符串的翻转？

data = "aleX leNb "
#  使用 strip() 方法去除两端的空白字符再进行字符串的翻转
print(data.strip()[::-1])
#  bNel Xela

9.有字符串s = "123a4b5c"

• 通过对s切片形成新的字符串 "123"

s = "123a4b5c"
new_s = s[0:3]
print(new_s)

• 通过对s切片形成新的字符串 "a4b"

s = "123a4b5c"
new_s = s[3:6]
print(new_s)

• 通过对s切片形成字符串 "c"

s = "123a4b5c"
new_s = s[-1::]
print(new_s)

• 通过对s切片形成字符串 "ba2"

s = "123a4b5c"
new_s = s[-3:0:-2]
print(new_s)

10.使用while循环实现对字符串 message = "伤情最是晚凉天，憔悴厮人不堪言" 中每个字符进行输出。

message = "伤情最是晚凉天，憔悴厮人不堪言"
index = 0
while index < len(message):
    print(message[index])
    index += 1

11.使用for循环实现对字符串 message = "伤情最是晚凉天，憔悴厮人不堪言" 中每个字符进行输出。

message = "伤情最是晚凉天，憔悴厮人不堪言"
for item in message:
    print(item)

12.使用for循环和range实现对字符串 message = "伤情最是晚凉天，憔悴厮人不堪言" 中每个字符进行倒叙输出。

message = "伤情最是晚凉天，憔悴厮人不堪言"

for i in range(len(message)):
    print(message[i])

13.使用for循环实现输出倒计时效果，例如：输出内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"。

list = input("请输入：")
for list in range(3, 0,-1):
    print(list)
    text = f"倒计时{list}秒"
    print(text)

14.让用户输入一段文本，请计算文本中 "浪" 出现的次数，并输入结果。

# 获取用户输入的文本
data = input("请输入内容：")

# 使用 count() 方法计算 "浪" 出现的次数
count = data.count("浪")

# 输出结果
print(f"'浪' 出现的次数为: {count}")

15.获取用户两次输入的内容，并提取其中的数字，然后实现数字的相加（转换为整型再相加）：

"""
要求：
	将num1中的的所有数字找到并拼接起来：1232312
	将num2中的的所有数字找到并拼接起来：1218323
	然后将两个数字进行相加。
"""
num1 = input("请输入：") # asdfd123sf2312
num2 = input("请输入：") # a12dfd183sf23
# 请补充代码

num1 = input("请输入：")  # asdfd123sf2312
num2 = input("请输入：")  # a12dfd183sf23

# 提取并拼接数字
# num1_list = [item for item in num1 if item.isdecimal()]

num1_list = []
num2_list = []

for item in num1:
    if item.isdecimal():
        num1_list.append(item)

# num2_list = [item for item in num2 if item.isdecimal()]
for item in num2:
    if item.isdecimal():
        num2_list.append(item)


data1 = "".join(num1_list)
data2 = "".join(num2_list)

result = int(data1)+int(data2)
print(result)