python基础语法（合集）

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 + 1

2- 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 += 1

6-continue

# continue : 当条件成立，退出当前一次循环，继而执行下一次循环
# 吃5个苹果 -- 循环； 吃到第3个吃出一个虫子，第三个不吃了，没吃饱，继续吃4和5个苹果 -- 只有第三个不吃
i = 1
while i <= 5:
    # 条件
    if i == 3:
        print('吃出一个大虫子，这个苹果不吃了')
        # 如果使用continue，在continue之前一定要修改计数器，否则进入死循环
        i += 1
        continue
    print(f'吃了第{i}个苹果')
    i += 1

7-while循环嵌套

"""
1. 循环打印3次媳妇儿，我错了
2. 今天刷晚饭的碗
3. 上面是一套惩罚，这一套惩罚要重复执行3天 -- 一套惩罚要重复执行 -- 放到一个while循环里面
"""
j = 0
while j < 3:
    i = 0
    while i < 3:
        print('媳妇儿，我错了')
        i += 1
    print('刷晚饭的碗')
    print('一套惩罚结束-----------------------')
    j += 1

8-打印五行星星

j = 0
while j < 5:
    # 一行星星开始
    i = 0
    while i < 5:
#end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串；“end=' '”意思是末尾不换行，加空格。
        print('*', end='')
        i += 1
    print() # 一行星星结束：换行显示下一行
    j += 1

9-while嵌套之打印星星

# 三角形： 每行星星的个数和行号数相等
j = 0
while j < 7:
    # 一行星星开始
    i = 0
    while i <= j:
        print('*', end='')
        i += 1
    # 一行星星结束：换行显示下一行
    print()
    j += 1

10-while循环嵌套之九九乘法表

j = 1
while j <= 9:
    # 一行的表达式开始
    i = 1
    while i <= j:
        print(f'{i} * {j} = {i*j}', end='\t')
        i += 1
    # 一行的表达式结束
    print()
    j += 1

11-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])  # 876

7-字符串常用操作方法之查找

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) #True

4.列表-体验案例判断是否存在

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