文章目录

• • 前言
  • 1. Python环境的搭建
  • • 1.1 python解释器的安装
    • 1.2 pycharm的安装
  • 2. Python基础语法
  • • 2.1 基本语法
    • 2.2 数据类型
    • 2.3 标识符与关键字
    • 2.4 格式化输出
    • 2.5 转义字符和print的结束符
    • 2.6 输入与数据类型转换
    • 2.7 复合赋值运算符和逻辑运算符
  • 3. Python常用语句
  • • 3.1 判断语句（if语句、if-else语句、if-elif语句）
    • 3.2 判断语句（if嵌套）
    • 3.3 判断语句（if 综合案例）
    • 3.4 循环语句（while循环）
    • 3.5 循环语句（while循环嵌套）
    • 3.6 循环语句（while...else）
    • 3.7 循环语句（for、for...else）
  • 4. 字符串
  • • 4.1 字符串的使用
    • 4.2 下标和切片
    • 4.3 字符串常用操作方法（查找、修改、判断）
  • 5. 列表、元组和字典
  • • 5.1 列表的创建和使用
    • 5.2 判断数据是否在列表中存在
    • 5.3 列表的常见操作（查找、增加、删除、修改、赋值）
    • 5.4 列表的循环遍历（for、while）
    • 5.5 列表的嵌套
    • 5.6 元组的访问
    • 5.7 元组常见操作（查找、修改）

前言

人生苦短，我用Python

1. Python环境的搭建

解释器和开发集成环境pycharm的安装还是比较简单的。
 

1.1 python解释器的安装

 
（1）到官网下载python解释器

下载地址：https://www.python.org/downloads/release/python-372/

注释： 这个解释器是3.7.2版本的
 
 
（2）开始安装python解释器

安装解释器非常简单，选择Install Now， 在把下面的环境变量打上对勾就ok了。如下如所示

 

1.2 pycharm的安装

 
工欲善其事，必先利其器。Pycharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言时 提高其效率的工具。 简单的说提高你写代码的速度，编写代码更爽更舒服。
 

（1）到官网下载Pycharm

下载地址：http://www.jetbrains.com/pycharm/download/#section=windows

 

小提示： Pythoncharm分为专业版（professional）和社区版（community）。专业版集成了一些框架和库，收费的，基础里用不到，社区版就够用了。
 
 
（2）开始安装pycharm
安装pycharm也非常简单，选好安装路径，我安装到D盘了。然后到达了如下图的界面，选择一个64位的桌面图标(shortcut)，再选择一个.py的联想，如下图所示。

 
 

2. Python基础语法

 

2.1 基本语法

 
直接上代码，一看就懂了

# 这是一个输出语句
print("Hello,World")
""" 这是一个多行注释 """

''' 这也是一个多行注释 '''
====================================================================================
# 定义变量，储存数据TOM
my_name = 'TOM'
print(my_name)

# 定义变量，储存数据，这是一瓶冰红茶
icdTea = '这是一瓶冰红茶'
print(icdTea)

 

2.2 数据类型

 
来一个思维导图，简单明了

直接上代码，一看就懂了

# 整型和浮点型
num1 = 1
num2 = 1.2
print(type(num1))
print(type(num2))

# 这是一个字符串类型
a = 'hello,world!'
print(type(a))

# 这是一个布尔类型
b = True
print(type(b))

# 这是一个列表类型
c = [10,20,30]
print(type(c))

# 这是一个元组类型
d = (10,20,30)
print(type(d))

# 这是一个集合
e = { 10,20,30}
print(type(e))

# 这是一个字典
f = { 'name': 'TOM','age': 18}
print(type(f))

小提示：还有个复数类型，就是用于表示数学中的复数，用 real + imagej表示
 
 

2.3 标识符与关键字

 
这里不多说，跟C语言和Java中的知识都差不多一样，提几个需要注意的地方。
标识符：
（1）由数字、字母、下划线组成
（2）不能数字开头
（3）不能使用内置关键字
（4）严格区分大小写
 
 

2.4 格式化输出

 
直接上代码，一看就懂

age = 18
name = 'TOM'
weight = 75.5
stu_id = 1

print('今年我的年龄是%d' % age)
print('我的名字叫%s' % name)
print('我的体重是%.3f' % weight)
print('我的体重是%03d' % stu_id)  # 不够三位，用0补全

print('我的名字叫：%s ，我的年龄是：%d' % (name,age))
print("我的名字叫：%s，我的年龄是：%d" % (name,age+1))  # 年龄加一岁

print("我的名字叫：%s，今年的年龄是：%d，我的体重是：%s，我的学号是：%03d" % (name,age,weight,stu_id))

===========================================================================================

name = "TOM"
age = 18
weight = 75.5

# %s比较强大
print('我的名字叫：%s，我的年龄是：%s，我的体重是：%s' % (name,age,weight))

===========================================================================================

name = 'TOM'
age = 16

# 语法：f'{表达式}'
# 这样的输出格式更加高效和简洁

print(f'我的名字叫{name},我的年龄为{age}')

小提示：

（1）务必掌握这种输出格式f'{表达式}' ，这种的输出格式更加高效简洁。f-格式化字符串是Python3.6中新增的格式化方法，这种方法更简单易读。

（2）常见的格式符号：%s （字符串） %d（有符号的十进制整数） %f（浮点数） %c（字符） 这几种是常见的格式符号，如果需要其他的再去查就好了。
 
 

2.5 转义字符和print的结束符

 
直接上代码，一看就懂
 

print('hello world')
print('hello\nworld')  # hello world直接换行输出
print('\thello')    # 前面输出空格再输出hello

=================================================================

# 在python中，print()默认自带end='\n'这个换行结束符，用户可以按照需求更改结束符

print('hello', end='\n')
print('world')

print('hello', end='\t')
print('hello')

print('hello', end='...')
print('world')

小提示：要记住print的结束符这个小知识点。
 
 

2.6 输入与数据类型转换

 
直接上代码，一看就懂
 

passward = input('请输入您的密码：')
print(f'您输入的密码是：{passward}')

# input接收到的数据类型都是字符串
print(type(passward))

====================================================================================

num = input("请输入一个数字：")
print(num)
print(type(num))

# 强制转换为int类型
print(type(int(num)))
print(type(int(num)))

===================================================================================

''' 因为得到数据类型并不是程序想要的数据类型，这个时候需要借助数据类型转换的函数来转换 '''
num = 1
str1 = '10'

# 1.将数据转换成浮点类型 float()
print(type(float(num)))
print(float(num))
print(float(str1))

# 2. 将数据转换成字符串型 str()
print(type(str(num)))

# 3. 序列转换成元组 tuple()
list1 = [10,20]
print(type(list1))
print(type(tuple(list1)))
print(tuple(list1))  	 # (100, 200)

# 4. 将一个元组转换成序列 list()
t1 = (100,200)
print(list(t1)) 		# [100, 200]

# 5. eval() 计算在字符串中的有效Python表达式，并返回一个表达式。把字符串中的数据转换成他原本的类型
str3 = '1'
str4 = '2.1'
str5 = '(10,20)'
str6 = '[10,20]'
print(type(eval(str3)))   # <class 'int'>

 
 

2.7 复合赋值运算符和逻辑运算符

 
总结几个常用算数运算符
 
（1）**      返回a的b次幂，比如 2 ** 3,结果位8

（2）%      取余

（3）//      取整除，返回商的整数部分。
 
总结几个常用复合赋值运算符
 
直接上代码，一看就懂
 

a = 10
a += 1
print(a)  # 11

b = 10
b *= 3
print(b)  # 30

# 注意：先算复合赋值运算符右侧的表达式，算复合赋值运算
c = 10
c += 1 + 2
print(c)  # 13

# 测试
d = 10
d *= 1 + 2
print(d)  	# 30 说明先算复合赋值运算符右侧的表达式，再算复合赋值运算

=====================================================================

# 逻辑运算符的运用

a = 0
b = 1
c = 2

# 1.and
print((a < b) and (a < c))   # True
print(a > b and a < c)		# False

# 2.or
print(b > c or a < c)  # True

# 3.not
print(not a < b)	# False

# 程序员的习惯
# 加小括号为了避免歧义，增加优先级

 
 

3. Python常用语句

3.1 判断语句（if语句、if-else语句、if-elif语句）

直接上代码，一看就懂

if True:
    print('条件成立了')
# 下面的代码没有缩进到if语句块，所以和if条件无关
print('这个代码执行吗？')

=================================================================

age = 20
if age >= 18:
    print('已经成年可以上网')

# 注意：不缩进的语句，跟if语句没有关系了。
print('系统关闭')

================================================================

# 注意：input接受用户输入的数据是字符串类型，这时需要转换为int类型才能进行判断
age =int( input('请输入您的年龄：'))
if age >= 18:
    print(f'您输入的年龄是{age},已经成年可以上网')
    
================================================================

age =int( input('请输入您的年龄：'))
if age >= 18:
    print(f'您输入的年龄是{age},已经成年可以上网')
else:
    print(f'你输入的年龄是{age}，小朋友，回家写作业去')

----------------------------------------------------------------

age = int(input('请输入您的年龄'))
if age < 18:
    print(f'您输入的年龄是{age}，童工')
elif (age >= 18) and (age <= 60):
    print(f'您输入的年龄是{age}，合法')
elif age > 60:
    print(f'您输入的年龄是{age}，退休')

-----------------------------------------------------------------

age = int(input('请输入您的年龄'))
if age < 18:
    print(f'您输入的年龄是{age}，童工')
# 条件的简化写法
elif 18 <= age <= 60:
    print(f'您输入的年龄是{age}，合法')
elif age > 60:
    print(f'您输入的年龄是{age}，退休')

3.2 判断语句（if嵌套）

直接上代码

# if嵌套坐公交

money = 1
seat = 1

if money == 1:
    print('土豪，请上车')
    # 判断是否能坐下
    if seat == 1:
        print('有空做，请坐下')
    else:
        print('没有空做，请等着....')
else:
    print('没钱，不让上车')

 

3.3 判断语句（if 综合案例）

 
直接上代码

# 猜拳游戏
import random

player = int(input('请出拳：0--石头；1--剪刀；2--布'))
# computer = 1
computer = random.randint(0,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('电脑获胜')

================================================================================

# 随机数的使用

''' 步骤： 1.导入模块 import random 2.使用这个模块中的功能 random.randint '''
import random
num = random.randint(0,2)
print(num)

================================================================================

# 三目运算符
a = 1
b = 2
c = a if a > b else b
print(c)

aa = 10
bb = 6
cc = aa - bb if aa > bb else bb - aa
print(cc)

    

 

3.4 循环语句（while循环）

直接看个栗子就能上手使用while循环

# 1-100 累加和
i = 1
result = 0
while i <= 100:
    result += i
    i += 1

print(result)

3.5 循环语句（while循环嵌套）

# 重复打印5行星星

j = 0
while j < 5:
    # 一行星星的打印
    i = 0
    while i < 5:
        # 一行内的星星不能换行，取消print默认结束符\n
        print('*', end='')
        i += 1
    # 利用空的print来进行换行
    print()
    j += 1

============================================================

# 打印三角形，每行星星的个数和行号数相等
# j表示行号
j = 0
while j < 5:
    # 一行星星的打印
    i = 0
    while i <= j:
        # i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
        print('*', end='')
        i += 1
    # 利用空的print来进行换行
    print()
    j += 1

=============================================================

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

3.6 循环语句（while…else）

''' 所谓else指的是循环正常结束之后要执行的代码， 即如果是break终止循环的情况，else下方缩进的代码将不执行。 '''

i = 1
while i <= 5:
    if i == 3:
        break
    print('媳妇我错了')
    i += 1
else:
    print('媳妇原谅我了，真开心呐')

===================================================================

""" 因为continue是退出了当前一次循环，继续下一次循环，所以改循环在continue控制下 是可以正常结束的，当循环结束后，则执行了else缩进的代码。 """
i = 1
while i <= 5:
    if i == 3:
        # 切记在执行continue之前，一定要改变计数器。否则就会陷入死循环
        i += 1
        continue
    print('媳妇我错了')
    i += 1
else:
    print('媳妇原谅我了，真开心呐')

    

3.7 循环语句（for、for…else）

str1 = 'ilovepython'
for i in str1:
    # 当某些条件成立，退出循环 条件：i取到字符e的时候退出循环
    if i == 'e':
        # continue
        break
    print(i)
   
======================================================================

所谓else指的是循环正常结束之后要执行的代码，
str1 = 'ilovepython'
for i in str1:
    print(i)
else:
    print('循环正常结束执行的else代码')
    

4. 字符串

4.1 字符串的使用

# 字符串的使用区别

a = 'hello' \
    ' world'
print(a)   # 输出一行 hello world

c = '''hello world'''
print(type(c))
print(c)       # 换行输出hello world


d = """hello world"""
print(type(d))  # <class 'str'>
print(d)        # 会直接换行输出

# 打印 I'm Tom，使用单引号，必须使用转移字符，把他转义过去
e = 'I\'m Tom'
print(e)

# 要是有单引号出现可以使用双引号括住
f = "I' love Tom"
print(f)

============================================================================

# 字符串的输出 

name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')

==============================================================================

# 字符串的输入
password = input('请输入您的密码')
print(f'您输入的密码是{password}')
# input接收到的用户输入的数据都是字符串
print(type(password))

4.2 下标和切片

（1）下标

str1 = 'abcdefg'
print(str1)
# 数据在运行过程中存储在内存
# 使用字符串中特定的数据
# 使用编号精确找到某个字符数据，下标索引值
# str[下标]
print(str1[0])  # 输出a
print(str1[1])  # 输出b

（2）切片

# 序列名[开始位置的下标：结束位置的下表：步长]
# 取值区间左闭右开的

str1 = '012345678'
# print(str1[2:5:1]) 234
# print(str1[2:5:2]) 24
# print(str1[2:5]) 234 # 如果不写步长，默认步长是1
# 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 方向一致就可以正确输出

小总结： 下标是精确的找到某一个元素，切片可以利用下标找到某一部分元素（左闭右开）

4.3 字符串常用操作方法（查找、修改、判断）

（1）查找

mystr = 'hello world and itcast and itsmail and Python'

# 1. find()
print(mystr.find('and')) # 输出的是12，以为下标是从0开始数的
print(mystr.fing('and',15,30))
print(mystr.find('ands')) # -1,ands字串不存在

# 2. index
print(mystr.find('and')) # 12
print(mystr.find('and',15,30)) #23
print(mystr.index('ands')) #如果index查找字串不存在，报错

# 3. count()
print(mystr.count('and')) 3
print(mystr.count('and',15,30)) 1
print(mystr.count('ands')) 0

# 4. rfind()
print(mystr.rfind('and')) 35
print(mystr.find('ands')) -1 如果没找到，则返回-1

# 5. rindex()
print(mystr.rindex('and')) 35  就算是到着找，它的下标还是从左到右从下标0开始的
print(mystr.rindex('ands'))

（2）修改

# 遇到列表、字典，内部的数据可以直接修改，修改的就是原列表或者原字典。叫做可变类型。
# 字符串是一个不可变类型的数据

mystr = 'hello world and itcast and itheima and Python'
# 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')
print(list1)

# 3. join() 合并列表里面的字符串数据为一个大字符串
mylist = ['aa','bb','cc']
new_str = '...'.join(mylist)
print(new_str)

修改-非重点

# 一、字符串对齐
# mystr.ljust(10) 左对齐
# mystr.rjust(10) 右对齐
# mystr.rjust(10,'.') 以点作为填充效果
# mystr.center(10) 中间居中
# mystr.center(10,'.') 以点填充空白的地方



# 二、大小写转换
mystr = 'hello world and itcast and itheima and Python'
# 1. capitalize() 字符串首字母大写
# new_str = mystr.capitalize()
# print(new_str)

# 2. title():字符串中每个单词首字母大写
# new_str = mystr.title()
# print(new_str)

# 3. upper():小写转大写
# new_str = mystr.upper()
# print(new_str)

# 4. lower()：大写转小写
# new_str = mystr.lower()
# print(new_str)


# 三、删除空白字符
str1 = " hello world and itcast and itheima and Python "
# 1. lstrip():删除字符串左侧空白字符
# print(str1)
# new_str = str1.lstrip()
# print(new_str)

# 2. rstrip():删除字符串右侧空白字符
new_str = str1.rstrip()
print(str1)
print(new_str)

# 3. strip():删除字符串两侧空白字符
# new_str = str1.strip()
# print(new_str)

（3）判断

# 判断开头或结尾
mystr = 'hello world and itcast and itheima and Python'
# 1. startswith(字串，开始位置下标，结束位置下标):判断字符串是否以某个字串开头
print(mystr.startswith('hello'))
print(mystr.startswith('hel'))
print(mystr.startswith('hels'))
print(mystr.startswith('hell',0,10)) 开始位置下标和结束位置下标可以省略

# 2. endswich(字串，开始位置下标，结束位置下标)，始位置下标和结束位置下标可以省略
print(mystr.endswith('Python'))
print(mystr.endswith('Pythons'))

# 判断
3. isalpha():字母  纯字母才可以，如果中间有空格返回的false
print(mystr.isalpha())

# 4. isdigit():数字，中间也不能有空格，否则返回false
print(mystr.isdigit())
mystr1 = "12345"
print(mystr1.isdigit())

# 5. isalnum():数字或字母或组合
print(mystr1.isalnum()) # True
print(mystr.isalnum())  # False 因为中间有空格
mystr2 = 'abc123'
print(mystr2.isalnum())

# 6. isspace():判断是否是空白，是返回True
print(mystr.isspace())  # False
mystr3 = ' '
print(mystr3.isspace())	 # True

5. 列表、元组和字典

5.1 列表的创建和使用

name_list = ['TOM','Lily','ROSE']
print(name_list)   # ['TOM', 'Lily', 'ROSE']
# 根据下标进行输出
print(name_list[0])  # 输出 TOM
print(name_list[1])  # 输出 Lily
print(name_list[2])  # 输出 ROSE

5.2 判断数据是否在列表中存在

name_list = ['TOM','Lily','ROSE']
# 1. in 如果在里面就返回true，否则false
print('TOM' in name_list)
print('TOMS' in name_list)

# 2. not in 这个跟in相反
print('TOM' not in name_list)
print('TOMS' not in name_list)

体验案例

name_list = ['TOM','List','ROSE']

# 需求：注册邮箱，用户输入一个账户名，判断这个账号是否存在，如果存在，提示用户，否则提示可以注册
name = input("请输入您的邮箱账号名：")
if name in name_list:
    # 提示用户名已经存在
    print(f'您输入的名字是{name}，此用户已经存在')
else:
    # 提示可以注册
    print(f'您输入的名字是{name},可以注册')

5.3 列表的常见操作（查找、增加、删除、修改、赋值）

（1）查找（index、count、len）

name_list = ['TOM','Lily','Rose']

# 1.index()
print(name_list.index('TOM'))  #返回 0
# print(name_list.index('TOMs')) 没有找到，报错

# 2. count()
print(name_list.count('TOM'))
# print(name_list.count('TOMS')) # 报错

# 3.len()
print(len(name_list)) # 输出3

（2）增加（append、extend、insert）

# 1. 列表数据是可变的 -- 列表是可变类型
# 2. append函数追加数据的时候如果是一个序列，追加整个序列到列表的结尾

name_list = ['TOM','Lily','ROSE']
name_list.append('xiaoming')
name_list.append([11,22])
name_list.append(11)
print(name_list)  # 输出结果为：['TOM', 'Lily', 'ROSE', 'xiaoming', [11, 22], 11]

# extent() 追加数据是一个序列，把数据序列里面的数据拆开然后逐一追加到列表的结尾
name_list = ['TOM','Lily','ROSE']
name_list.extend('xiaoming')
# 把序列拆开，逐一的放到列表中
name_list.extend(['xiaoming','xiaojun'])
print(name_list) 
 # 输出结果为：['TOM', 'Lily', 'ROSE', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g', 'xiaoming', 'xiaojun']

name_list = ['Tom','Lily','ROSE']
# name_list.insert(下标，数据) 在指定位置加入数据
name_list.insert(1,'aa')
print(name_list) # 输出的结果为：['Tom', 'aa', 'Lily', 'ROSE']

（3）删除（del、pop、remove、clear）

name_list = ['Tom','Lily','ROSE']

# 1. del
# del name_list
# print(name_list) 已经把列表已经删除，已经没有列表了

# del 也可以指定下标的数据
# del name_list[0]
# print(name_list) # 输出的结果 ['Lily', 'ROSE']


# 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) # 直接清空整个数据

（4）修改（reverse、sort）

name_list = ['TOM','Lily','ROSE']

# 修改指定下标的数据
# name_list[0] = 'aaa'
# print(name_list) # ['aaa', 'Lily', 'ROSE']

# 2. 逆序 reverse()
list1 = [1, 3, 4, 2, 5]
# list1.reverse()
# print(list1)

# 3. sort() 排序：升序（默认）和 降序
# list1.sort() # 升序
list1.sort(reverse=False)  # 升序 [1, 2, 3, 4, 5]
list1.sort(reverse=True)   # 降序 [5, 4, 3, 2, 1]
print(list1)

（5）赋值

name_list = ['tom','lucy','jack']
list1 = name_list.copy()
print(list1)
print(name_list)

5.4 列表的循环遍历（for、while）

for循环

name_list = ['tom','rose','jack']
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

while循环

# for循环的代码量要少于while的代码量
# 一般在工作岗位下，涉及到遍历序列当中的数据的话，一般优选于for循环
name_list = ['tom','rose','jack']
for i in name_list:
    # 遍历序列中的数据
    print(i)
    

5.5 列表的嵌套

列表嵌套时的数据查询

name_list = [['TOM', 'Lily','Rose'], ['张三','李四','王二'], [ '小红', '小绿', '小蓝']]
# print(name_list)
# 列表嵌套的时候的数据查询
print(name_list[0])
print(name_list[0][0])

案例-随机分配办公室

# 需求：八位老师，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(在指定位置加入数据)
    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

5.6 元组的访问

注意： 如果是单个数据的元组，那么后面必须加逗号，否则就不是元组的数据类型，而是整个数据本身的数据类型

# 输出元组
t1 = (10, 20, 30)
print(t1)  # 输出 (10, 20, 30)

# 如果是单个数据的元组，那么后面必须加逗号，否则就不是元组的数据类型，而是整个数据本身的数据类型
# 1.多个数据元组
t1 = (10, 20, 30)
print(type(t1))  # 输出 <class 'tuple'>

# 2. 单个数据元组
t2 = (10,)
print(type(t2))  # 输出 <class 'tuple'>
=====================================================================

# 3. 如果单个数据的元组不加逗号
t3 = (10)
print(type(t3))  # 输出 <class 'int'>

t4 = ('aaa')
print(type(t4))  # 输出 <class 'str'>
================================================================================
t5 = ('aaa',)
print(type(t5))  # 输出 <class 'tuple'>

5.7 元组常见操作（查找、修改）

（1）查找

t1 = ('aa', 'bb', 'cc')

# 1. 下标
print(t1[0])   # aa

# 2. index()
print(t1.index('aa'))  # 输出0 其实有参数二，有参数三对应一个查找的范围,如果没有找到就直接报错。

# 3. count()
print(t1.count('aa')) # 统计aa的次数，输出结果为1

# 4. len()
print(len(t1))  # 统计整个元组的个数，输出结果为3

（2）修改

# 元组确实不能修改，但是元组中含有的列表可以修改。
# 工作中尽可能遵循一个规则，但凡是出现在小括号元组里面的数据，尽可以能靠自觉去要求不做修改
# 工作中如果是同事的代码，有数据出现在元组中，尽可能在查找操作的时候，小心一点，尽可能不要去修改这一部分的操作。

t1 = ('aa', 'bb', 'cc')
# t1[0] = 'aaa' 这个操作是错的，是不能修改的。
t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2])
t2[2][0] = 'TOM'
print(t2)