数据类型和变量
字面量：在代码中，被写下来的固定的值。
常见有6中，数字、字符串、列表、元组、集合、字典
字符串：由任意数量的字符如中文、英文、各类符合、数字等组成。如“你好”，“hello”，在Python中被双引号引起来的就是字符串。
注释：在程序代码中对程序代码进行解释说明的文字。
作用：不能被执行，只是解释说明。
单行注释： # 开头
如：# 我的单行注释
print（“hello”）
多行注释：一对三引号
变量：在程序运行是，能存储计算结果或能表示值的抽象概念。简单说，变量就是在程序运行时，记录数据用的。
变量的定义格式
变量名称 = 变量的值 “=”表示赋值 （+、-、*、/）
变量的特征：变量的值可以改变。
# 定义一个变量，用来记录钱包余额
money = 50
# 通过print语句，输出变量记录的内容
print("钱包还有：", money)
# 买了一个冰淇淋，花费10元
money = money - 10
print("买了冰淇淋花费10元，还剩余：",money, "元")
求钱包余额
钱包余额，初始余额为50，购买了冰淇淋10元，可乐5元后，还剩多少元？
# 钱包余额，初始余额50
money = 50
# 通过print语句，输出变量记录内容
print("钱包还有：", money)
# 买了一个冰淇淋花费10元
money = money - 10
print("买冰淇淋花费10元，还剩：", money, "元")
# 买可乐花费5元
money = money -5
print("买可乐花费5元，还剩：", money, "元")
数据类型
type（）语句的使用方式
print(type("黑马"))
print(type(666))
print(type(11.1))
数据类型转换
# 将字符串转为整数
num = int("11")
print(type(num), num)
# 将字符数转为浮点数类型
num2 = float("12.12")
print(type(num2), num2)
# 错误示范
num = int(“你好”
Print(num)
任何类型可转成字符串
字符串不一定可以转成数字
浮点数转整数，会丢失精度
标识符：用户在编程时所使用的一系列名字，用于给变量、类、方法等命名。
标识符命名，只允许使用英文、中文、数字、下划线（数字不可开头，大小写敏感，不可使用关键字）
运算符
+ - * / //(取整数) & 取余 **指数
复合运算符 +=、-=、=、/=、%=、*=
字符数拼接 “+”（无法和非字符串类型进行拼接）
# name = "盒马"
# address = "东风路"
# print("我是：" + name + ", 我的地址是：" + address)
字符串格式化
通过占位完成拼接
# name = "黑马"
# message = "学IT来：%s" % name
# print(message)
通过占位完成字符串和数字的拼接 多个变量用（）按顺序写
# class_num = 57
# avg_salary = 12345
# message = "Python大数据学科，北京%s期. 毕业工资: %s" % (class_num,avg_salary)
# print(message)
# name = "传智播客"
# setup_year = 2008
# stock_price = 19.99
# message = "%s, 成立于： %d, 我今天的股价是：%f" % (name,setup_year,stock_price)
数字精度控制
m控制宽度，设置宽度小于本身，不生效
n控制小数点精度，会进行四舍五入
# print("数字11宽度限制为5, 结果是: %5d" % num1) 变成 空空空11
# print("数字11的宽度限制为1, 结果是：%1d" % num1) 变成 11
# print("数字11.123宽度限制为7, 小数精度2, 结果是: %7.2f" % num2) 变成 空空11.12
# print("数字11.123不限制, 小数精度2, 结果是: %.2f" % num2) 变成 11.12
字符串格式化——快速写法
语法： f{“内容”} 不管类型和精度
# name = "传智播客"
# setup_year = 2008
# stock_price = 19.99
# print(f"我是{name}, 我成立于：{setup_year}, 我今天的股价是：{stock_price}")
股价计算小程序
# name = ("传智播客")
# stock_price = 19.99
# stock_code = "003032"
# stock_price_daily_growth_factor = 1.2
# growth_days = 7
# print(f"公司: {name}, 股票代码: {stock_code}, 当前股票: {stock_price}")
# print("每日增长系数是: %.1f, 经过%d天的增长后，股票达到了: %.2f" % (stock_price_daily_growth_factor, growth_days, stock_price*stock_price_daily_growth_factor**growth_days))
数据输入 input() 获取键盘输入的数据
# num = input("请告诉我你的银行卡密码：")
# num = int(num)
# print("你的银行卡密码类型是: ", type(num)) 注意：字符串类型
数据类型转换
num = int(num)
# print("你的银行卡密码类型是: ", type(num)
欢迎登录小程序
定义两个变量，记录用户类型
user_name = input("请输入你的名字: ")
# user_type = input("请输入你的等级: ")
# message = "你是: %s,您是尊贵的: %s用户, 欢迎光临。" % (user_name , user_type)
条件语句
Python判断语句
布尔类型 True(1) False(0)
num1 = 10
num2 = 10
print(f"10 == 10的结果是: {num1 == num2}")
num1 = 10
num2 = 15
print(f"10 != 15的结果是: {num1 !=num2}") 不等于
If语句的基本格式
age = 10
if age >= 18:
print("我已经成年了")
print("即将步入大学生活")
注意：判断条件一定是布尔类型，不要忘冒号和归属if代码块的4个空格缩进
if else语句
年龄判断
print("欢迎来到黑马儿童游乐园, 儿童免费, 成人收费")
# age = input("请输入您的年龄: ") input输入类型都是字符串
# age = int(age)
# if age >= 18:
# print("您已成年，游玩需要补票10元。")
# else:
# print("您未成年，可以免费游玩")
# print("祝您游玩愉快。")
注意： else后不需要判断条件，同时else代码块也需要缩进4个空格
if elif else语句
# if int(input("请输入您的身高(cm): ")) < 120:
# print("身高小于120cm, 可以免费游玩。")
# elif int(input("请输入您的vip等级(1~5): ")) > 3:
# print("vip等级大于3，可以免费游玩。")
# elif int(input("请告诉我今天几号: ")) == 1:
# print("今天是1号免费日。")
# else:
# print("不好意思，条件都不满足，需要购票10元。")
判断顺序互斥且有顺序，elif可以写多个
练习案例：猜心里数字
# 定义一个变量
# num = 5
# 通过键盘输入获取猜想的数字，通过if和elif的组合进行猜想比较
# if int(input("请输入第一次猜想的数字: ")) == num:
# print("恭喜你猜对了")
# elif int(input("不对，再猜一次: ")) == num:
# print("猜对了")
# elif int(input("不对，最后猜一次: ")) == num:
# print("猜对了")
# else:
# print("sorry,全部猜错了,我想的5")
判断语句的嵌套
嵌套的关键在于：空格缩进
通过空格缩进来决定语句之间的：层次关系
公司发礼物，条件是：
- 必须是大于18岁小于30隧道成年人
-
- 同时入职时间满足大于两年，或者级别大于3才可领取
# age = 33
# year = 1
# level = 1
# if age >= 18:
# print("你是成年人")
# if age <= 30:
# print("你的年龄达标了")
# if year > 2:
# print("恭喜你，年龄和入职时间都达标，可以领取")
# elif level > 3:
# print("恭喜你，年龄和级别达标，可以领取")
# else:
# print("不好意思，尽管年龄达标，但是入职时间和级别不满足")
# else:
# print("不好意思，年龄太大了")
# else:
print("不好意思，年龄太小了")
案例需求：
定义一个数字（1~10，随机产生），通过3次判断猜数字
猜不中提示大或者小
# import random
# num = random.randint(1,10) # print(num)
# guess_num = int(input("输入你要猜的数字: "))
# if guess_num == num:
# print("恭喜你, 第一次就猜中了")
# else:
# if guess_num > num:
# print("你猜的数字太大了")
# else:
# print("你猜的数字太小了")
# guess_num = int(input("再次输入你要猜的数字: "))
# if guess_num == num:
# print("恭喜你，第二次才对了")
# else:
# if guess_num > num:
# print("你猜的数字太大了")
# else:
# print("你猜的数字太小了")
# guess_num = int(input("第三次输入你要猜的数字: "))
# if guess_num == num:
# print("第三次猜中了")
# else:
# print("三次机会用完了，没猜中")
循环语句
while循环的基础语法
While的条件类型是布尔类型，注意空格缩进
案例需求：向小美问好100次
i = 0
while i < 100:
print("小妹，你好")
i += 1
练习案例：求1-100的和
sum = 0
i = 1
while i < 101:
sum += i
i += 1
print(f"1到100累加的和是: {sum}")
while循环的基础案例：猜数字
设置一个范围1-100的随机整数变量，通过while循环，配合Input语句，判断输入的数字是否正确。
# import random
# num = random.randint(1,100)
# count = 0
# flag = True
# while flag:
# guess_num = int(input("请输入你要猜的数字: "))
# count += 1
# if guess_num == num:
# print("猜中了")
# flag = False
# else:
# if guess_num > num:
# print("猜大了")
# else:
# print("猜小了")
#
# print(f"总共才了：{count}次")
while循环的嵌套
向小美表白，每天10朵玫瑰花，直到第100天成功
外层：表白100天 的控制
内层：每天10朵玫瑰花的控制
# i = 1
# while i <= 100:
# print(f"今天是{i}天,准备表白")
# 内部 循环的控制变量
# j = 1
# while j <= 10:
# print(f"送第{j}只玫瑰花")
# j += 1
# print("小妹，我喜欢你")
# i += 1
# print(f"坚持到第{i - 1}天，表白成功")
练习案例-打印九九乘法表
# i = 1
# while i <= 9:
# j = 1
# while j <= i:
内层循环的print语句，不要换行
# print(f"{j} * {i} ={j * i}\t", end='')
# j += 1
# i += 1
# print() # 换行
制表符\t多行字符串进行对齐 print输出不换行 , end=’’
for循环的基础语法
while循环的循环条件是自定义的，自行控制循环条件
for循环是“轮询”，是对一批内容进行逐个处理
语法格式：
For 临时变量 in 待处理数据集（序列）：
循环满足条件时执行的代码
练习案例：数一数有几个a
定义字符数变量name,内容：“itheima is a brand of itcast”
通过for循环，遍历字符串，统计有几个字母a
# name = "itheima is a brand of itcast"
# count = 0
# for x in name:
# if x == "a":
# count += 1
# print(f"共有：{count}个字母a")
range(num)获取一个从0开始，到num结束的数字序列（不含num本身）
如range(5)取得的数据是[0,1,2,3,4]
Range(num1, num2)
如range(5,10)取得的数据是[5,6,7,8,9]
Range(num1,num2,step)step数字之间的步长，默认为1
如range（5,10,2）取得的数据是[5,7,9]
练习案例：有几个偶数1-100不含100本身
定义一个数字变量num，并使用range()语句，获取从1到num的序列，使用for循环遍历它
# count = 0
# for x in range(1,100):
# if x % 2 == 0:
# count += 1
# print(f"一共有{count}个偶数")
for循环的嵌套
向小美表白，每天10朵玫瑰花，直到第100天成功
# i = 1
# for i in range(1,101):
# print(f"向小妹表白的第{i}天")
# for j in range(1,11):
# print(f"送的第{j}朵玫瑰花")
# print(f"第{i}天表白结束")
# print(f"第{i}天表白成功")
for循环打印九九乘法表
# for i in range(1, 10):
# for j in range(1, i + 1):
# print(f"{j} * {i} = {j * i}\t", end='')
# print()
循环中断continue break
Continue 关键字只可以控制：它所在的循环临时中断
# for i in range(1, 6):
# print("语句1")
# continue
# print("语句2") 出现5次语句1
Break 关键字用于： 直接结束循环。同样也是只可以控制它所在的循环结束
# for i in range(1, 6):
# print("语句1")
# break
# print("语句2")
# print("语句3")出现一个语句1 一个语句3
练习案例：发工资
某公司账户余额1W元，发给20名员工工资
1.员工编号1-20，从1号开始发，依次领工资，每人可领取1000元。
2.领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资 ，换下一位。
3.如果发完，结束发工资。
# money = 10000
# for i in range(1, 21):
# import random
# score = random.randint(1, 10)
# if score < 5:
# print(f"员工{i}绩效分{score},不满足，不发工资，下一位")
# continue
# if money >= 1000:
# money -= 1000
# print(f"员工{i},满足条件发工资1000，公司余额: {money}")
# else:
# print(f"余额不足，当前余额: {money},不足发工资。")
# break
函数
函数的定义：
Def 函数名（传入参数）:
函数体
Return 返回值 参数、返回值可省
注意：参数数量不限，使用逗号隔开
传入参数时，要和形式参数一一对应，逗号隔开
练习案例：自动查核酸
定义一个函数，函数名任意，要求调用函数后可以输出如下欢迎语：
欢迎来到黑马程序员
请出示您的健康码
# def check():
# print("欢迎来到黑马程序员\n请出示您的健康码") # 或者重新写一个print
# check()
定义2数相加的函数，通过参数接收被计算的2个数字
# def add(x, y): # 形参
# result = x + y
# print(f"{x} + {y}的结果是: {result}")
# add(7, 6) # 实参
练习案例：升级版查核酸
定义一个函数，名称任意，并接受一个参数传入（数字类型，表示体温）
在函数内进行体温判断（正常体温：小于等于37.5度）
# def tem(x):
# if x <= 37.5:
# print(f"欢迎来到黑马，请出示健康码，并配合擦量体温\n您的体温是: {x}度，正常")
# else:
# print(f"欢迎来到黑马，请出示健康码，并配合擦量体温\n您的体温是: {x}度，隔离")
#
# tem(37)
函数返回值：函数在执行完成后，返回给调用者的结果
None类型：空的，无实际意义，在if判断在None等同于False
函数说明文档
# def add(a, b):
# """
# add函数可以接受2个参数，进行2术相加
# :param a: 形参a表示其中一个数字
# :param b: 形参b另一个数字
# :return: 返回值两数相加的结果
# """
# hi = a + b
# print(f"和是: {hi}")
# return hi
# add(5, 6)
函数的嵌套
def fine_b():
print("11111")
def fine_a():
print("22222")
fine_b()
print("3333")
fine_a()
变量作用域：局部变量和全局变量
局部变量：定义在函数体内的变量，即只在函数体内部生效。
# def a():
# num = 100
# print(num)
# a()
# print(num) num is not defined
全局变量：将变量定义在函数外
num = 100
def a():
print(f"{num}")
# def b():
# print(f"{num}")
# a()
# b()
# print(num)
结果：a():100 b():100 num:100
global关键字:可以在函数内部声明变量为全局变量。
num = 100
def a():
print(f"{num}")
# def b():
# global num # 全局变量
# num = 200 # 局部变量
# print(f"{num}")
#
# a()
# b()
# print(num)
结果：a():100 b():200 num: 200
综合案例：黑马ATM
1.定义一个全局变量：money,记录银行卡余额（默认5000000）
2.定义一个全局变量：name，用来记录客户姓名（启动程序是输入）
3.定义如下的函数：
查询余额函数
存款函数
取款函数
主菜单函数
要求：
- 程序 启动会要求输入客户姓名
- 查询余额、存款、取款后都会返回主菜单
- 存款、取款后，都显示一下当前余额
- 客户选择退出或输入错误，程序则退出，否则一直运行。
定义全局变量
# money = 5000000
# name = None # 可删
要求客户输入名字
# name = input("请输入您的姓名: ")
定义查询函数
# def query(show_header):
# if show_header:
# print("----余额查询-----")
# print(f"{name},您好，您的余额剩余: {money}元")
定义存款函数
# def saving(num):
# global money
# money += num
# print("----存款----")
# print(f"{name},您好，您存款{num}元成功。")
调用query函数查询余额
# query(False)
定义取款函数
# def get_money(num):
# global money
# money -= num
# print(f"{name},您好，您的取款{num}元成功，")
# query(False)
定义主菜单函数
# def main():
# print("----主菜单-----")
# print(f"{name},您好，欢迎来到黑马银行，请选择操作: ")
# print("查询余额\t[输入1]")
# print("存款\t\t[输入2]")
# print("取款\t\t[输入3]")
# print("退出\t\t[输入4]")
# return input("请输入您的选择: ")
# while True:
# keyboard_input = main()
# if keyboard_input == "1":
# query(True)
# continue
#
# elif keyboard_input == "2":
# num = int(input("您想存多少钱？请输入: "))
# saving(num)
# continue
#
# elif keyboard_input == "3":
# num = int(input("您想取多少钱？请输入: "))
# get_money(num)
# continue
#
# else:
# print("程序退出")
# break 退出循环
数据容器
- 数据容器：list（列表）
- List(列表)的遍历
- 数据容器：tuple(元组)
- 数据容器：str(字符串)
- 数据容器的切片
- 数据容器：set(集合)
- 数据容器:dire(字典)
- 数据容器的通用操作
1.1 list列表：
定义语法：[元素1, 元素2, 元素3，.......]
元素：数据容器内的每一份数据，都成为元素。
列表：可以储存多个数据，且可以为不同的数据类型，支持嵌套。
# my_list = ['hei',666,True] # 类型不限
# print(my_list)
# print(type(my_list))
# my_list = [[1,2,3],[4,5,6]] # 嵌套
# print(my_list)
# print(type(my_list))
1.1.1 列表的下标索引
从前向后方向，从0开始，依次递增
# my_list = ["tom","lily","ji"]
# print(my_list[0])
# print(my_list[2])
结果：tom ji
从后向前放心，从-1开始，依次递减
嵌套列表同样支持下标索引
# my_list2 = [[1,2,3],[4,5,6]]
# print(my_list2[1][0])
结果：4
注意：下标索引的取值范围不要超过，否则报错。
1.1.2查找某元素的下标
语法：列表.index(元素) index是列表对象内置的方法
# my_list = ["love","pigg","digitel"]
# index = my_list.index("love")
# print(f"love在列表中的下表索引值是: {index}")
结果：0
1.1.3修改特定下标索引的元素值###
# my_list = ["love","pigg","digitel"]
# # my_list[0] = "你真棒"
# # print(f"列表被修改元素值后，结果是: {my_list}
结果：[“你真棒”, “pigg”,“digitel”]
1.1.4插入元素
语法：列表.insert（下标，元素），在指定下标位置，插入指定元素
# my_list = ["love","pigg","digitel"]
# my_list.insert(1,"best")
# print(f"列表插入元素值后，结果是: {my_list}")
结果：["love","best"，"pigg","digitel"]
1.1.5.1 追加元素
语法： 列表.append(元素)，将指定元素，追加到列表的尾部。
# my_list = ["love","pigg","digitel"]
# my_list.append("黑马程序员")
# print(f"列表追加元素值后，结果是: {my_list}")
结果：["love","pigg","digitel"，"黑马程序员"]
1.1.5.2 追加元素2
语法：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表的尾部。
# my_list = ["love","pigg","digitel"]
# my_list2 = [1,2,3]
# my_list.extend(my_list2)
# print(f"列表在追加新的列表后，结果是: {my_list}")
结果：["love","pigg","digitel"，1,2,3]
1.1.6删除元素 del/.pop
# my_list2 = [1,2,3]
# del my_list[2]
# print(f"列表删除元素后，结果是: {my_list}")
结果：[1,2]
# my_list = ["love","pigg","digitel"]
elel = my_list.pop(2)
# print(f"通过pop方法取出元素后，列表内容是: {my_list},取出的元素是: {elel}")
结果：通过pop方法取出元素后，列表内容是: ["love","pigg"],取出的元素是: ["digitel"]")
1.1.7 删除某元素在列表的第一个匹配项
语法：列表.remove(元素)
# my_list = ["love","kill","best","love","kill"]
# my_list.remove("love") # 全部搜素，只删除第一个元素
# print(f"通过remove方法移除元素后，结果是: {my_list}")
结果：["kill","best","love","kill"]
1.1.8清空列表
语法：列表.clear()
# my_list = ["love","kill","best","love","kill"]
# my_list.clear()
结果：[]
1.1.9 统计列表某元素的数量
# my_list = ["love","kill","best","love","kill"]
# count = my_list.count("love")
# print(f"列表中love的数量是: {count}")
结果：2
1.1.10 统计列表有多少元素
语法：len(列表)
# my_list = ["love","kill","best","love","kill"]
# count = len(my_list)
# print(f"列表元素数量总共有: {count}个")
结果：5
列表的特点
- 可以容纳多个元素
- 可以容纳不同类型的元素
- 数据是有序储存的
- 允许数据重复存在
- 可以修改数据
1.2 list列表的遍历
while循环
# def list_while():
# my_list = ["传智教育","love","heima"]
# index = 0
# while index < len(my_list):
# ele = my_list[index]
# print(f"列表元素: {ele}")
# index += 1
# list_while()
for循环
# def list_for():
# my_list = [1,2,3,4,5]
# for x in my_list:
# print(f"{x}")
# list_for()
练习案例
定义一个列表：[1,2,3,4,5,6,7,8,9,10]
- 遍历列表，取出列表内的偶数，并存入一个新的列表对象中。
- 使用while和for循环个操作一个
# my_list = [1,2,3,4,5,6,7,8,9,10]
# my_list2 = []
# index = 0
# while index < len(my_list):
# x = my_list[index]
# if x % 2 == 0:
# my_list2.append(x)
# index += 1
# print(f"从列表{my_list}中取出偶数，组成新的列表: {my_list2}")
#
# my_list = [1,2,3,4,5,6,7,8,9,10]
# my_list2 = []
# for x in my_list:
# if x % 2 == 0:
# my_list2.append(x)
# print(f"从列表{my_list}中取出偶数，组成新的列表: {my_list2}")
2.元组
元组和列表一样可以封装多个、不同类型的元素，但最大的不同在于，元组一旦完成，就不可修改。
语法：（元素1，元素2，....）
t1 = ("hello",)定义单个元素时要加逗号
2.1.1 下标索引取出内容
# t4 = ((1,2,3),(4,5,6)) # 可嵌套 可下标
# num = t4[1][1]
# print(f"{num}")
结果：5
2.1.2 index查找方法
# t1 = ("黑马","python","传智教育")
# index = t1.index("黑马")
# print(f"{index}")
结果：0
2.1.3 count统计方法
# t2 = ("黑马","python","传智教育","ji","make","ji")
# count = t2.count("ji")
# print(f"{count}")
结果： 2
2.1.4 len统计方法
# t2 = ("黑马","python","传智教育","ji","make","ji")
# num = len(t2)
# print(f"{num}")
结果：5
2.1.5 元组的遍历
While
# t2 = ("黑马","python","传智教育","ji","make","ji")
# # index = 0
# # while index < len(t2):
# # element = t2[index]
# # print(f"{element}")
# # index += 1
for
# t2 = ("黑马","python","传智教育","ji","make","ji")
# for element in t2:
# print(f"{element}")
练习案例：元组的基本操作
定义一个元组：（“周杰伦”，11[“football”，“music”]）记录学生的信息
- 查询其年龄的下标位置
- 查询学生的姓名
- 删除爱好中的football
- 增加爱好coding到爱好list中
# t1 = ("周杰伦",11,["football","music"])
# index = t1.index(11)
# print(f"{index}")
# name = t1[0]
# print(f"{name}")
# del t1[2][0]
# print(f"{t1}")
#
# t1[2].append("coding") # t1.insert(2,"coding")
# print(f"{t1}")
3. 字符串
字符串 和元组一样无法修改 修改，追加，移除都不行
my_str = "itheima and itcast"
value = my_str[2]
print(f"从{my_str}取得下标第2的元素是{value}")
3.1.1 index 方法
my_str = "itheima and itcast"
value = my_str.index("and")
print(f"查找and,其对应起始下标是{value}")
结果：8
3.1.2# replace 得到新的字符串
my_str = "itheima and itcast"
new_my_str = my_str.replace("it","程序")
print(f"{new_my_str}")
结果："程序heima and 程序cast"
3.1.3# 字符串分割 split 分割之后变成列表
my_str = "itheima and itcast"
my_str_list= my_str.split(" ")
print(f"{my_str_list}")
结果：[‘itheima’, ‘and’, ‘itcast’]
3.1.4# strip 去除前后空格
# my_str = " itheima and itcast "
# new_my_str = my_str.strip() # 不传参 去除前后空格
# print(f"{new_my_str}")
结果："itheima and itcast"
# my_str = "12itheima and itcast21"
# new_my_str = my_str.strip("12") # 传参满足任意一个都会被去除
# print(f"{new_my_str}")
结果："itheima and itcast"
3.1.5 count方法
# my_str = "12itheima and itcast21"
count = my_str.count("it")
print(f"{count}")
结果：2
3.1.6 len方法
# my_str = "12itheima and itcast21"
# num = len(my_str)
# print(f"{num}")
结果：22
字符串的特点：
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复字符串存在
- 不可以修改
- 支付for循环
练习案例：分割字符串
定义字符串“itheima itcast boxungu”
- 统计有多少“it”
- 将字符串所有的空格全部替换为“|”
- 并按照“|”进行字符串分割，得到列表
# tt1 = "itheima itcast boxuegu"
# count = tt1.count("it")
# print(f"{count}个")
# new_my_str = tt1.replace(" ","|")
# print(f"{new_my_str}")
# new_my_list2 = new_my_str.split("|") # 变成列表了
# print(f"{new_my_list2}")