Python基础入门
01-如何添加注释
"""print('hello Python')"""
# 单行注释
"""
第一行注释
第二行注释
第三行注释
"""
'''
注释1
注释2
注释3
'''02-变量
"""
1. 定义变量
语法：变量名 = 值
2. 使用变量
3. 看变量的特点
"""
# 定义变量：存储数据TOM
my_name = 'TOM'
print(my_name)
# 定义变量：存储数据
schoolName = '我爱Python'
print(schoolName)03-认识bug
反正就是出错了
04-数据类型
# int -- 整型
num1 = 1
# type 就是输出它的类型
# float -- 浮点型，就是小数
num2 = 1.1
print(type(num1))
print(type(num2))
# str -- 字符串，特点：数据都要带引号
a = 'hello world'
print(type(a))
# bool -- 布尔型，通常判断使用，布尔型有两个取值 True 和 False，python中第一个字母要大写
b = True
print(type(b))
# list -- 列表
c = [10, 20, 30]
print(type(c))
# tuple -- 元组
d = (10, 20, 30)
print(type(d))
# set -- 集合
e = {10, 20, 30}
print(type(e))
# dict -- 字典 -- 键值对，定义一个变量name，它的值是TOM
f = {'name': 'TOM', 'age': 18}
print(type(f))05-格式化输出
"""
1. 准备数据
2. 格式化符号输出数据
"""
age = 18
# 1. 今年我的年龄是x岁 -- 整数 %d
print('今年我的年龄是%d岁' % age) #今年我的年龄是18岁
name = 'TOM'
# 2. 我的名字是x -- 字符串 %s
print('我的名字是%s' % name) #我的名字是TOM
weight = 75.5
# 3. 我的体重是x公斤 -- 浮点数 %f
print('我的体重是%.3f公斤' % weight) # %.3f 是保留三位小数
stu_id = 1
# 4. 我的学号是x -- %d
print('我的学号是%d' % stu_id)
# 4.1 我的学号是001
print('我的学号是%03d' % stu_id) #要求三位数不足前面填0
stu_id2 = 1000
print('我的学号是%03d' % stu_id2) #我的学号是1000
#可以混合搭配哦
# 5. 我的名字是x，今年x岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 5.1 我的名字是x，明年x岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 6. 我的名字是x，今年x岁了，体重x公斤，学号是x
print('我的名字是%s，今年%d岁了，体重%.2f公斤，学号是%06d' % (name, age, weight, stu_id))06-格式化字符串拓展
name = 'TOM'
age = 18
weight = 75.5
# 我的名字是x，今年x岁了，体重x公斤 这些数据添加进去了后都是字符串，所以都可以用%s
print('我的名字是%s，今年%s岁了，体重%s公斤' % (name, age, weight))07-f格式化字符串
name = 'TOM'
age = 18
# 我的名字是x，今年x岁了
print('我的名字是%s，今年%s岁了' % (name, age))
# 语法 f'{表达式}'
print(f'我的名字是{name}，今年{age}岁了')08-转义字符
print('hello')
print('world')
print('hello\nPython') # \n 换行符
print('\tabcd') #\t制表符，4个空格的距离09-print的结束符
print('hello', end="\n")
print('world', end="\t") # 一个tap键 4个空格的距离
print('hello', end="...")
print('Python')
print('ddsdasds', end="...")
print('xczxczx')
print('world', end="\t") # 一个tap键 4个空格的距离
print('hello')10-格式化输出
s = "我的名字是{},我的年龄是多少{},我的职业是{}".format("张三", 20, "学生")
print(s)
s1 = "我的名字是{0},我的职业是{2},我的年龄是多少{1}".format("张三", 20, "学生")
print(s1) #里面加了数字后就像数组一样，[0]=张三 [1]=20 [2]=学生
a = "1" # 000001
print("{0:0>6}".format(1))
a = "1" # 100000
print("{0:0<6}".format(1))11-复合赋值运算符
a = 10
a += 1 # a = a + 1
print(a)
b = 10
b -= 1 # b = b - 1
print(b)
# 注意： 先算复合赋值运算符右面的表达式； 再算复合赋值运算
c = 10
# c = 10 + 1 + 2
# c += 3 -- c = c + 3
c += 1 + 2
print(c)
d = 10
d *= 1 + 2
print(d)12-输入
"""
1. 书写input
input('提示信息')
2. 观察特点
2.1 遇到input，等待用户输入
2.2 接收input存变量
2.3 input接收到的数据类型都是字符串
"""
password = input('请输入您的密码：')
print(f'您输入的密码是：{password}')
print(type(password)) #type是输出它的类型13-逻辑运算符
a = 0
b = 1
c = 2
# 1. and: 与: 都真才真
print((a < b) and (c > b))
print(a > b and c > b)
# 2. or：或 : 一真则真，都假才假
print(a < b or c > b)
print(a > b or c > b)
# 3. not： 非: 取反
print(not False)
print(not c > b)14-数据类型转换函数
# 1. float() -- 将数据转换成浮点型
num1 = 1
str1 = '10'
print(type(float(num1))) # float
print(float(num1)) # 1.0
print(float(str1)) # 10.0
# 2. str() -- 将数据转换成字符串型
print(type(str(num1))) # str
# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
#什么是元组？
"""
元组与列表类似,元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义.
元组与字符串类似，下标索引从0开始，可以进行截取，组合等.
元组可以使用下 标索、截取 引来访问元组中的值.
元组中的元素值是 不允许修改 的，但我们可以对元组进行连接组合
元组中的元素值是 不允许删除 的，但我们可以使用 del 语句来删除整个元组
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
元组不可变，看一种“可变的”tuple"
"""
# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
# 5. eval() -- 计算在字符串中的有效Python表达式,并返回一个对象
str2 = '1'
str3 = '1.1'
str4 = '(1000, 2000, 3000)'
str5 = '[1000, 2000, 3000]'
print(type(eval(str2)))
print(type(eval(str3)))
print(type(eval(str4)))
print(type(eval(str5)))条件语句
1-体验if语句
"""
if 条件:
条件成立执行的代码1
.....
"""
if False:
print('条件成立执行的代码1')
print('条件成立执行的代码2')
# 注意：在这个下方的没有加缩进的代码，不属于if语句块，即和条件成立与否无关
print('这个代码执行吗？')2-if语句1
# 分析：年龄大于等于18，输出：已经成年，可以上网 -- 准备年龄的数据 和 18 做比较
age = 20
if age >= 18:
print('已经成年，可以上网')3-if语句2
# 系统可以用户输入年龄，用这个年龄做条件判断
"""
1. 用户输入
2. 保存用户输入的年龄
3. if
***** 注意一个点: input接收到的数据是str， 不能和18做判断 -- int转换类型
"""
age = int(input('请输入您的年龄：'))
if 18 <= age <= 70: #python 可以这样写
print(f'您输入的年龄是{age}, 已经成年，可以上网')
elif (age > 70):
print(f'您输入的年龄是{age}, 老年一位，可以上网')4-if语句3
# 系统可以用户输入年龄，用这个年龄做条件判断
"""
1. 用户输入
2. 保存用户输入的年龄
3. if
***** 注意一个点: input接收到的数据是str， 不能和18做判断 -- int转换类型
"""
age = int(input('请输入您的年龄：'))
if age >= 18:
print(f'您输入的年龄是{age}, 已经成年，可以上网')
else:
print(f'您输入的年龄是{age},小朋友，回家写作业去')
5-多重判断
"""
需求：
如果年龄小于18，为童工，不合法；
如果年龄18-60岁之间，为合法工作年龄
如果年龄大于60为退休年龄
"""
"""
步骤：
1. 用户输入自己的年龄， 保存变量 -- str;
2. if做判断 elif
3. 输出提示信息：您输入的年龄是x，合法与否
"""
age = int(input('请输入您的年龄：'))
# 童工
if age < 18:
print(f'您输入的年龄是{age}, 童工')
# 18-60 合法
elif (age >= 18) and (age <= 60):
print(f'您输入的年龄是{age}, 合法')
# 大于60 退休
elif age > 60:
print(f'您输入的年龄是{age}, 退休年龄')
6-条件写法
age = int(input('请输入您的年龄：'))
# 童工
if age < 18:
print(f'您输入的年龄是{age}, 童工')
# 18-60 合法
elif 18 <= age <= 60:
print(f'您输入的年龄是{age}, 合法')
# 大于60 退休
elif age > 60:
print(f'您输入的年龄是{age}, 退休年龄')
7-if嵌套
# 坐公交：如果有钱可以上车，没有钱，不能上车； 如果上车了，判断是否能坐下 -- 是否有空座位
"""
1. 准备将来要做判断的数据：钱和空座
2. 判断是否有钱：上车 和 不能上车
3. 上车了： 判断是否能坐下： 有空座位 和 无空座位
"""
money = 0
seat = 1
if money == 1:
print('土豪，请上车')
# 判断是否能坐下
if seat == 1:
print('有空座，坐下了')
else:
print('没有空座，站着等....')
else:
print('朋友，没带钱，跟着跑，跑快点')8-猜拳游戏
import random #导包
player = int(input('请出拳：0--石头；1--剪刀；2--布：'))
computer = random.randint(0, 2)
#random.randint(a, b)
#返回一个[a,b]的随机整数。功能等同于randrange(a, b+1)。
# 2. 判断输赢
# 玩家获胜
if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
print('玩家获胜，哈哈哈哈')
# 平局
elif player == computer:
print('平局，别走，再来一局')
else:
print('电脑获胜')9-随机数
"""
1. 导入模块
import random
2. 使用这个模块中的功能
random.randint()
返回一个[a,b]的随机整数
"""
import random
num = random.randint(0, 2)
num2 = random.randint(0, 100)
print(num)
print(num2)10-三目运算符
"""
语法
条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
"""
a = 1
b = 2
c = a if a > b else b
print(c)
# 需求： 有两个变量，比较大小 如果变量1 大于 变量2 执行 变量 1 - 变量2； 否则 变量2 - 变量1
aa = 10
bb = 6
cc = aa - bb if aa > bb else bb - aa
print(cc)
ff=20
hh=26
nn=ff-bb if ff>hh else hh+ff
print(nn)循环
1-循环（while）
"""
while 条件:
条件成立要重复执行的代码
......
"""
# 需求：重复打印5次媳妇儿，我错了 -- 1， 2， 3， 4， 5 6X -- 数据表示循环的次数 -- 第一次是1，最后依次5
# 1 + 1 + 1....
i = 1
while i <= 5: #当i大于5时，就停止输出
print('媳妇儿，我错了')
i += 1 # i = i + 12- 1到100 累加和
# 准备数据
i=1
# 结果变量
result = 0
while i <= 100:
# 加法运算 前两个数的结果 + 第三个数 -- 每计算一次加法则更新一次result变量值
result = result + i
i += 1
# 打印最终结果
print(result)3- 1到100偶数和
i = 1
result = 0
while i <= 100:
# 条件语句 -- if
if i % 2 == 0:
# 加法运算
result += i
i += 1
# 输出结果
print(result)4- 1到100偶数和
i = 2
result = 0
while i <= 100:
result += i
i += 2
print(result)5-break
# break：当某些条件成立，退出整个循环
# 循环吃5个苹果，吃完第3个吃饱了，第4 和 5 不吃了（不执行） -- == 4 或 >3
i = 1
while i <= 5:
# 条件：如果吃到4 或 > 3 打印吃饱了不吃了
if i == 4:
print('吃饱了，不吃了')
break
print(f'吃了第{i}个苹果')
i += 16-continue
# continue : 当条件成立，退出当前一次循环，继而执行下一次循环
# 吃5个苹果 -- 循环； 吃到第3个吃出一个虫子，第三个不吃了，没吃饱，继续吃4和5个苹果 -- 只有第三个不吃
i = 1
while i <= 5:
# 条件
if i == 3:
print('吃出一个大虫子，这个苹果不吃了')
# 如果使用continue，在continue之前一定要修改计数器，否则进入死循环
i += 1
continue
print(f'吃了第{i}个苹果')
i += 17-while循环嵌套
"""
1. 循环打印3次媳妇儿，我错了
2. 今天刷晚饭的碗
3. 上面是一套惩罚，这一套惩罚要重复执行3天 -- 一套惩罚要重复执行 -- 放到一个while循环里面
"""
j = 0
while j < 3:
i = 0
while i < 3:
print('媳妇儿，我错了')
i += 1
print('刷晚饭的碗')
print('一套惩罚结束-----------------------')
j += 18-打印五行星星
j = 0
while j < 5:
# 一行星星开始
i = 0
while i < 5:
#end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串；“end=' '”意思是末尾不换行，加空格。
print('*', end='')
i += 1
print() # 一行星星结束：换行显示下一行
j += 19-while嵌套之打印星星
# 三角形： 每行星星的个数和行号数相等
j = 0
while j < 7:
# 一行星星开始
i = 0
while i <= j:
print('*', end='')
i += 1
# 一行星星结束：换行显示下一行
print()
j += 110-while循环嵌套之九九乘法表
j = 1
while j <= 9:
# 一行的表达式开始
i = 1
while i <= j:
print(f'{i} * {j} = {i*j}', end='\t')
i += 1
# 一行的表达式结束
print()
j += 111-for循环
str1 = 'itheima'
for i in str1:#遍历str1
print(i)12-break控制for循环
str1 = 'itheima'
for i in str1:
# 当某些条件成立退出循环 -- break：条件 i取到字符e，就结束
if i == 'e':
break
print(i)13-contiune控制for循环
str1 = 'itheima'
for i in str1:
if i == 'e':#不会输出e
continue
print(i)
14-while…else
# 需求：道歉5遍媳妇我错了，完成之后执行媳妇原谅我了
"""
1. 书写道歉的循环
2. 循环正常结束要执行的代码 -- else
"""
i = 1
while i <= 5:
print('媳妇儿，我错了')
i += 1
else:
print('媳妇原谅我了，真开心呐，哈哈哈哈')
15-while…else之break
i = 1
while i <= 5:
if i == 3:
break
print('媳妇儿，我错了')
i += 1
else:
print('媳妇原谅我了，真开心呐，哈哈哈哈')
16-while…else之continue
i = 1
while i <= 5:
if i == 3:
i += 1
continue
print('媳妇儿，我错了')
i += 1
else:
print('媳妇原谅我了，真开心呐，哈哈哈哈')17-for…else
str1 = 'itheima'
for i in str1:
print(i)
else:
print('循环正常结束执行的else的代码')18-for…else之break和continue
str1 = 'itheima'
for i in str1:
if i == 'e':
# break
continue
print(i)
else:
print('循环正常结束执行的else的代码')数据序列
01-字符串
1_认识字符串
a = 'hello ' \
'world'
print(a)
print(type(a))
b = "TOM"
print(type(b))
# 三引号
e = '''i am TOM'''
print(type(e))
f = """I
am TOM"""
print(type(f))
print(f)
# I'm TOM
c = "I'm TOM"
print(c)
print(type(c))
# d = 'I'm TOM'
d = 'I\'m TOM'
print(d)
print(type(d))
2-字符串的输出
print("hello world")
name = 'ROSE'
# 我的名字是TOM
print('我的名字是%s' % name)
print(f'我的名字是{name}')3-字符串的输入
# 输入密码
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))4-下标
str1 = 'abcdefg'
print(str1)
# 数据在程序运行过程中存储在内存
# ？ 得到数据a字符， 得到数据b字符 -- 使用字符串中某个特定的数据
# 这些字符数据从0开始顺序分配一个编号 -- 使用这个编号精确找到某个字符数据 -- 下标或索引或索引值
# str1[下标]
print(str1[0])
print(str1[1])5-切片
str1 = 'abcdefg'
# 得到整个字符串数据
print(str1)
# 下标得到的是下标为某个数字的数据
print(str1[2])
# 得到abc 这3个数据该怎么办6-体验切片
# 序列名[开始位置的下标:结束位置的下标:步长]
str1 = '012345678'
# print(str1[2:5:1]) # 234
# print(str1[2:5:2]) # 24
# print(str1[2:5]) # 234
# print(str1[:5]) # 01234 -- 如果不写开始，默认从0开始选取
# print(str1[2:]) # 2345678 -- 如果不写结束，表示选取到最后
# print(str1[:]) # 012345678 -- 如果不写开始和结束，表示选取所有
# 负数测试
# print(str1[::-1]) # 876543210 -- 如果步长为负数，表示倒叙选取
# print(str1[-4:-1]) # 567 -- 下标-1表示最后一个数据，依次向前类推
# 终极测试
# print(str1[-4:-1:1]) # 567
print(str1[-4:-1:-1]) # 不能选取出数据：从-4开始到-1结束，选取方向为从左到右，但是-1步长：从右向左选取
# **** 如果选取方向(下标开始到结束的方向) 和 步长的方向冲突，则无法选取数据
print(str1[-1:-4:-1]) # 8767-字符串常用操作方法之查找
mystr = "hello world and itcast and itheima and Python"
# 1. find()
# 字符串序列.find(子串，开始位置下标，结束下标)
# print(mystr.find('and')) # 12
# print(mystr.find('and', 15, 30)) # 23
# print(mystr.find('ands')) # -1 , ands子串不存在
# 2.index()
# print(mystr.index('and')) # 12
# print(mystr.index('and', 15, 30)) # 23
# print(mystr.index('ands')) # 如果index查找子串不存在，报错
# 3.count() 统计字符串的次数
# print(mystr.count('and', 15, 30))
# print(mystr.count('and')) # 3
# print(mystr.count('ands')) # 0
# 4.rfind() 和find()功能相同，但查找方法为右侧开始
# print(mystr.rfind('and'))
# print(mystr.rfind('ands'))
# 5.rindex() 和index()功能相同，但查找方法为右侧开始
# print(mystr.rindex('and'))
# print(mystr.rindex('ands'))8-字符串常用操作方法之修改
mystr = "hello world and itcast and itheima and Python"
# 1. replace() 把and换成he #** 说明replace函数有返回值，返回值是修改后的字符串
# new_str = mystr.replace('and', 'he')
# new_str = mystr.replace('and', 'he', 1)
# 替换次数如果超出子串出现的次数，表示替换所有这个子串
# new_str = mystr.replace('and', 'he', 10)
# # print(mystr)
# print(new_str)
# ***** 调用了replace函数后，发现原有字符串的数据并没有做到修改，修改后的数据是replace函数的返回值
# --- 说明 字符串是不可变数据类型
# 数据是否可以改变划分为 可变类型 和 不可变类型
# 2. split() -- 分割，返回一个列表, 丢失分割字符
#list1 = mystr.split('and')
#list1 = mystr.split('and', 2)
#print(list1)
# 3. join() -- 合并列表里面的字符串数据为一个大字符串
mylist = ['aa', 'bb', 'cc']
#
# # aa...bb...cc
new_str = '...'.join(mylist)
print(new_str)9.字符串常用操作方法之判断
mystr = "hello world and itcast and itheima and Python"
# 1. startswith(): 判断字符串是否以某个子串开头
#print(mystr.startswith('hello'))#True
# print(mystr.startswith('hel'))
# print(mystr.startswith('hels'))
# 2. endswith(): 判断字符串是否以某个子串结尾
# print(mystr.endswith('Python'))
# print(mystr.endswith('Pythons'))
# 3. isalpha(): 字母 是否是字母
print(mystr.isalpha())
# 4. isdigit(): 数字 是否是数字
# print(mystr.isdigit())
mystr1 = '12345'
print(mystr1.isdigit())
# 5. isalnum() : 数字或字母或组合
# print(mystr1.isalnum())
# print(mystr.isalnum())
mystr2 = 'abc123'
print(mystr2.isalnum())
# 6.isspace(): 空白
print(mystr.isspace())
mystr3 = ' '
print(mystr3.isspace())
02-列表
1.列表-下标
name_list = ['TOM', 'Lily', 'ROSE']
print(name_list)
print(name_list[1])
print(name_list[0])
print(name_list[2])2.列表-查找
name_list = ['TOM', 'Lily', 'ROSE']
# 1. index() 下标
print(name_list.index('TOM'))
# print(name_list.index('TOMS'))
# 2. count() 统计次数
print(name_list.count('TOM'))
# print(name_list.count('TOMS'))
# 3.len() 列表长度
print(len(name_list))3.列表-判断是否存在
name_list = ['TOM', 'Lily', 'ROSE']
# 1. in
print('TOM' in name_list) #TOM 在这个列表吗，在,所以是True
print('TOMS' in name_list) #False
# 2. not in
print('TOM' not in name_list) #False
print('TOMs' not in name_list) #True4.列表-体验案例判断是否存在
name_list = ['TOM', 'Lily', 'ROSE']
# 需求：注册邮箱，用户输入一个账号名，判断这个账号名是否存在，如果存在，提示用户，否则提示可以注册
"""
1. 用户输入账号
2. 判断if...else
"""
name = input('请输入您的邮箱账号名:')
if name in name_list:
# 提示用户名已经存在
print(f'您输入的名字是{name}, 此用户名已经存在')
else:
# 提示可以注册
print(f'您输入的名字是{name}, 可以注册')5.列表增加数据之append
name_list = ['TOM', 'Lily', 'ROSE']
name_list.append('xiaoming')
name_list.append([11, 22])
print(name_list)
# 1. 列表数据可改的 -- 列表可变类型
# 2. append函数追加数据的时候如果数据是一个序列，追加整个序列到列表的结尾6.列表增加数据之extend
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.extend('xiaoming')
name_list.extend(['xiaoming', 'xiaohong'])
print(name_list)
# extend() 追加数据是一个序列，把数据序列里面的数据拆开然后逐一追加到列表的结尾7.列表增加数据之insert
name_list = ['TOM', 'Lily', 'ROSE']
# name_list.insert(下标, 数据)
name_list.insert(1, 'aaa')
print(name_list)8.列表删除数据
name_list = ['TOM', 'Lily', 'ROSE']
# 1. del
#del name_list
#del(name_list)
# del 可以删除指定下标的数据
# del name_list[0]
# print(name_list)
# 2. pop() -- 删除指定下标的数据，如果不指定下标，默认删除最后一个数据，
# 无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据
# del_name = name_list.pop()
# del_name = name_list.pop(1)
# print(del_name)
# print(name_list)
# 3. remove(数据)
# name_list.remove('ROSE')
# print(name_list)
# 4. clear() -- 清空
#name_list.clear()
#print(name_list)
9.列表修改数据
name_list = ['TOM', 'Lily', 'ROSE']
# 1. 修改指定下标的数据
name_list[0] = 'aaa'
print(name_list)
# 2. 逆序 reverse()
list1 = [1, 3, 2, 5, 4, 6]
# list1.reverse()
# print(list1)
# 3. sort() 排序：升序(默认) 和 降序
# list1.sort()
# list1.sort(reverse=False)
list1.sort(reverse=True)
print(list1)10.列表复制数据
name_list = ['TOM', 'Lily', 'ROSE']
list1 = name_list.copy()
print(list1)
print(name_list)
11.列表的循环遍历之while
name_list = ['TOM', 'Lily', 'ROSE']
'''
1. 准备表示下标数据
2. 循环while
条件 i < 3 len()
遍历：依次按顺序访问到序列的每一个数据
i += 1
'''
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
12.列表的循环遍历之for
name_list = ['TOM', 'Lily', 'ROSE']
for i in name_list:
# 遍历序列中的数据
print(i)13.列表嵌套
name_list = [['TOM', 'Lily', 'Rose'], ['张三', '李四', '王五'], ['xiaohong', 'xiaoming', 'xiaolv']]
# print(name_list)
# 列表嵌套的时候的数据查询
# print(name_list[0])
print(name_list[0][1])
14.随机分配办公室
# 需求：8位老师，3个办公室， 将8位老师随机分配到3个办公室
"""
步骤：
1. 准备数据
1.1 8位老师 -- 列表
1.2 3个办公室 - 列表嵌套
2. 分配老师到办公室
*** 随机分配
就是把老师的名字写入到办公室列表 -- 办公室列表追加老师名字数据
3. 验证是否分配成功
打印办公室详细信息：每个办公室的人数和对应的老师名字
"""
import random
# 1. 准备数据
teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
offices = [[], [], []]
# 2. 分配老师到办公室 -- 取到每个老师放到办公室列表 -- 遍历老师列表数据
for name in teachers:
# 列表追加数据 -- append（选中） extend insert
# xx[0] -- 不能指定是具体某个下标 -- 随机
num = random.randint(0, 2)
offices[num].append(name)
# print(num)
# print(offices)
# 为了更贴合生活，把各个办公室子列表加一个办公室编号 1， 2， 3
i = 1
# 3. 验证是否分配成功
for office in offices:
# 打印办公室人数 -- 子列表数据的个数 len()
print(f'办公室{i}的人数是{len(office)}，老师分别是：')
# 打印老师的名字
# print() -- 每个子列表里面的名字个数不一定 -- 遍历 -- 子列表
for name in office:
print(name)
i += 1
文章出处登录后可见！
已经登录？立即刷新
