"""
数据类型
"""
#
# # int
# num1 = 1
# # float
# num2 =1.1
# print(type(num1))
# print(type(num2))
#
# # str ,字符串，特点：数据都带引号，单引、双引均可
# a = 'hello world'
# print(type(a))
# b=True # boolean
# 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 字典 键值对
# f = {'name':'Tom','age': 16}
# print((type(f)))
# """
# 1.准备数据
# 2.格式化符号输出数据
# """
# age =18
# name = 'TOM'
# weight = 75.5
# stu_id = 1
#
# print('今年我的年龄是%d岁')
# # 1.今年我的年龄是x岁
# print('今年我的年龄是%d岁' % age)
# # 2.我的名字是x
# print('名字是%s' % name)
# # 3.我的体重是x公斤
# # 75.500000
# print('体重是%f公斤' % weight)
# # 75.50
# print('体重是%.2f公斤' % weight)
# # 4.我的学号是x
# print('我的学号是%d' % stu_id)
# # 4.1 我的学号是001
# # %06d，表示输出的整数显示位数，不⾜以0补全，超出当前位数则原样输出
# print('我的学号是%03d' % stu_id)
# stu_id2 = 1000
# print('我的学号是%03d' % stu_id2)
# # 5.我的名字是x,今年x岁了
# print('名字是%s,今年%d岁了' % (name,age))
# print('名字是%s,今年%d岁了' % (name,age + 1))
# # 6.我的名字是x，今年x岁了,体重是x公斤,学号是x
# print('名字是%s，今年%d岁了,体重是%f公斤,学号是%d' % (name, age,weight, stu_id))
# print('名字是%s，今年%d岁了,体重是%.2f公斤,学号是%06d' % (name, age,weight, stu_id))
#
# '''
# 格式化字符串除了%s，还可以写为 f'{表达式}'
# '''
# # 7.我的名字是x，今年x岁了,体重是x公斤
# print('我的名字是%s，今年%s岁了,体重是%s公斤' %(name,age,weight))
#
# print(f'我的名字是{name}，今年{age}岁了,体重是{weight}公斤')
# print(f'我的名字是{name}，今年{age+1}岁了,体重是{weight}公斤')
#
# # %s 与f'{}'区别； f代码量少；f更高效；开发多用f; f-格式化是python3.6新增的格式化方法
#
'''
转义字符
\n ：换⾏。
\t ：制表符，⼀个tab键（4个空格）的距离。
\ 反斜杠
'''
# # 两行
# print('hello')
# print('world')
#
# print('hello\npython')
# # 缩进4空格
# print('\tabcd')
'''
print函数的结束符
想⼀想，为什么两个print会换⾏输出？
在Python中，print()， 默认⾃带 end="\n" 这个换⾏结束符，所以导致每两个 print 直接会换⾏
展示，⽤户可以按需求更改结束符。
'''
# print('hello')
# print('hello')
# print('输出内容', end="\n")
# print('输出内容', end=" ")
# print('hello', end="....\t")
# print('world', end=" ")
'''
1.书写input
input('提示信息')
2.观察特点
输⼊的特点
当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。
'''
# password = input('请输入您的密码：')
# print(f'您输入的密码是{password}')
# print(type(password))
'''
转换数据类型
int(x [,base ]) 将x转换为⼀个整数
float(x ) 将x转换为⼀个浮点数
complex(real [,imag ]) 创建⼀个复数，real为实部，imag为虚部
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象
tuple(s ) 将序列 s 转换为⼀个元组
list(s ) 将序列 s 转换为⼀个列表
'''
# num = input('请输入数字：')
# print(num,type(num)) # str
# print(type(int(num))) # <class 'int'>
# 1. float() -- 转换成浮点型
# num1 = 1
# print(float(num1)) # 1.0
# print(type(float(num1)))
# str1 = '10'
# print(float(str1)) #10.0
#
# # 2. str() -- 转换成字符串类型
# num2 = 10
# print(type(str(num2)))
#
# # 3. tuple() -- 将⼀个序列转换成元组
# list1 = [10, 20, 30]
# print(tuple(list1)) # (10, 20, 30)
#
# # 4. list() -- 将⼀个序列转换成列表
# t1 = (100, 200, 300)
# print(list(t1))
#
# # 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
# str1 = '10'
# str0 = '1.1'
# str2 = '[1, 2, 3]'
# str3 = '(1000, 2000, 3000)'
# print(type(eval(str1)))
# print(type(eval(str0)))
# print(type(eval(str2)))
# print(type(eval(str3)))
'''
运算符
运算符的分类:
算数运算符
赋值运算符
复合赋值运算符
⽐较运算符
逻辑运算符
单击pycharm - python console ；打开
'''
'''
PyDev console: starting.
Python 3.7.4 (tags/v3.7.4:e09359112e, Jul 8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32
1 + 1
2
1 + 1.1
2.1
1 - 1
0
1 - 0.5
0.5
2 * 0.5
1.0
4 / 2
2.0
2.0
9 // 4
2
9 % 4
1
2 ** 3
8
1 + 2 * 3
7
(1+2) * 3
9
2 * 3 ** 2
18
(2 * 3) ** 2
36
# # // 整除 9 // 4 输出结果为2
# # % 取余 9 % 4 输出结果为 1
# # ** 指数 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
# # () ⼩括号 ⼩括号⽤来提⾼运算优先级，即 (1 + 2) * 3 输出结果为 9
# 混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -
tyhon console >>>
# 多个变量赋值
num1, num2, str1 = 1, 1.1, 'abc'
num1
1
# 多变量赋相同值
a = b = 100
a
100
b
100
'''
'''
复合赋值运算符
'''
# c = 10
# # c = 10 + 1 + 2 # 错误
# # c += 3 -- c = c + 3 # 正确 （先算复合赋值运算符右边的表达式，再算复合运算符）
# c += 1 + 2
# print(c) # 13
#
# d = 10
# d *= 1 + 2
# print(d) # 30
'''
比较运算符
1 == 1
True
'''
'''
逻辑运算符
and or not
x and y
x or y
not x
'''
# a = 1
# b = 2
# c = 3
#
# print( (a < b) and ( b < c))
# print((a > b) or (c > b))
# print(not (b < c))
'''
条件语句
if 条件:
条件成立执行的代码1
.....
'''
# if True:
# if False:
# print("条件成立执行的代码")
# print("条件成立执行的代码")
#
# print('这个代码执行吗？')
# age = int(input('请输入您的年龄:'))
# if age >= 18 :
# print(f"您已经成年{age}岁，可以上网")
# D:\Learn\HM-21人工智能Ai\21年【年度钻石会员】人工智能AI进阶\阶段1 人工智能Python基础\第三章 判断语句\3-3 if...elif...else格式
'''
if 条件:
代码
else:
代码
'''
# age = int(input('请输入您的年龄:'))
# if age > 18:
# print('已经成年，可以上网')
# else:
# print('未成年，不可上网')
'''
多重判断
if 条件1:
代码1
elif 条件2:
代码2
else:
以上都不成立时，执行
'''
# age = int(input('请输入年龄：'))
#
# if age < 18:
# print("为童工，不合法")
# elif age >= 18 and age < 60:
# print("合法工作年龄")
# else:
# print('退休了')
'''
if嵌套
'''
"""
1. 如果有钱，则可以上⻋
2. 上⻋后，如果有空座，可以坐下
上⻋后，如果没有空座，则站着等空座位
如果没钱，不能上⻋
"""
# money = int(input('查找包里是否有钱：'))
# if money > 1:
# hasSit = False
# if hasSit:
# print('有空座，可坐下')
# else:
# print('无座，有钱也站着')
# else:
# print('没钱，不能坐公交，走路吧！')
'''
猜拳游戏
1. 导出random模块
2. 使⽤random模块中的随机整数功能
语法如下：
1 import 模块名
1 random.randint(开始,结束) ，包含开始和结束
'''
# import random
#
# player = int(input('0-石头，1-剪刀，2-布：'))
#
# computer = random.randint(0, 2)
# print(computer)
#
# if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 1):
# print('玩家胜利')
# elif (player == computer):
# print('平局')
# else:
# print('玩家输')
'''
三⽬运算符
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式
'''
# 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)
'''
while 条件:
条件成⽴重复执⾏的代码1
条件成⽴重复执⾏的代码2
'''
# 循环计数器，一般第一个计数值为从0开始；
# i = 0
# while i < 5:
# print('媳妇儿，我错了')
# i += 1
'''
0-100内偶数累加的和
'''
# 程序去计算偶数
# i = 2
# result = 0
# while i <= 100:
# if (i % 2 == 0):
# result += i
# i += 1
# print(result)
# 人为经验判断：偶数+2为偶数
# i = 2
# result = 0
# while i <= 100:
# result += i
# i += 2
# print(result)
'''
break和continue是循环中满⾜⼀定条件退出循环的两种不同⽅式
'''
'''
4.1 理解
举例：⼀共吃5个苹果，吃完第⼀个，吃第⼆个…，这⾥"吃苹果"的动作是不是重复执⾏？
情况⼀：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作
停⽌，这⾥就是break控制循环流程，即终⽌此循环。
情况⼆：如果吃的过程中，吃到第三个吃出⼀个⼤⾍⼦...,是不是这个苹果就不吃了，开始吃第四个苹
果，这⾥就是continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码。
'''
# i = 1
# while i <= 5:
# print(f'吃完第{i}个了')
# if i == 3:
# print(f'吃饱了')
# break
# i += 1
#
# i = 1
# while i <= 5:
# if i == 3:
# print(f'吃到第{i}个，吃出一个大虫子，这个不吃了')
# i += 1
# print(f'吃完第{i}个了')
# i += 1
'''
while循环嵌套
'''
'''
打印*形正方形
'''
# i = 0
# while i < 5:
# print('', end='\n')
# j = 0
# while j < 5:
# print('*', end='')
# j += 1
# i += 1
'''
打印星号(三⻆形)
'''
# i = 0
# while i < 5:
# print('', end='\n')
# j = 0
# while i >= j:
# print('*', end='')
# j += 1
# i += 1
'''
九九乘法表
'''
# i = 1
# while i <= 9:
# print('', end='\n')
# j = 1
# while i >= j:
# print(f'{i} x {j} = { i * j }', end='\t')
# j += 1
# i += 1
'''
for循环
'''
'''
for 临时变量 in 序列:
重复执⾏的代码1
重复执⾏的代码2
'''
# str1 = 'itheima'
# for i in str1:
# print(i)
'''
循环可以和else配合使⽤，else下⽅缩进的代码指的是【当循环正常结束之后要执⾏的代码。】 break退出，则不执行else,continue，会执行else
while、for都可与else配合使用
'''
'''
需求：⼥朋友⽣⽓，要求道歉5遍：媳妇⼉，我错了。道歉到第三遍的时候，媳妇埋怨这⼀遍说的不真
诚，是不是就是要退出循环了？这个退出有两种可能性：
更⽣⽓，不打算原谅，也不需要道歉了，程序如何书写？
只⼀遍不真诚，可以忍受，继续下⼀遍道歉，程序如何书写？
'''
# i = 1
# while i <= 5:
# if i == 3:
# print('这一遍不真诚；不打算原谅了；不需要道歉了')
# break
# print(f'媳妇儿，我道歉第{i}遍了')
# i += 1
# else:
# print('媳妇原谅我了')
#
# i = 1
# while i <= 5:
# if i == 3:
# print('这一遍不真诚；继续下一次道歉')
# i += 1
# continue
# print(f'媳妇儿，我道歉第{i}遍了')
# i += 1
# else:
# print('媳妇原谅我了')
'''
字符串
'''
# 单引号 代码显示效果换行了，内容以脚本的思想，没有换行
# 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)
'''
下标
'''
# str1 = 'abcdefg'
# print(str1)
# print(str1[2]) # c
# print(str1[5]) # f
'''
切⽚
序列[开始位置下标:结束位置下标:步⻓]
[ ) 左闭右开
'''
str1 = '012345678'
# 得到整个字符串
# print(str1)
# 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[:]) # 不写开始结束，表示选取从头到尾
# print(str1[::-1]) # 876543210 # 如果步长为负数，表示倒叙选取
# print(str1[-4:-1]) # 567
# 终极测试
# print(str1[-4:-1:1]) # 567
# print(str1[-4:-1:-1]) # 不能选取出数据 从-4开始到-1结束，选取方向从左到右；但是-1是从右向左选取；方向不一致
# # **** 如果选取方向（下标开始到结束）和步长的方向冲突，则无法选取数据
# print(str1[-1:-4:-1]) # 876
# D:\Learn\HM-21人工智能Ai\21年【年度钻石会员】人工智能AI进阶\阶段1 人工智能Python基础\第五章 字符串\5-4 字符串操作方法
'''
四、常⽤操作⽅法
'''
'''
find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。
字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。
'''
# mystr = "hello world and itcast and itheima and Python"
# 1. find()
# print(mystr.find('and')) # 12
# print(mystr.find('and', 15, 30)) # 23
# print(mystr.find('ands')) # 不存在，返回 -1
# 2. index()
# print(mystr.index('and'))
# print(mystr.index('ands')) # 不存在，报错： ValueError: substring not found
# 3. count()
# print(mystr.count('and', 15, 30)) # 1
# print(mystr.count('and')) # 3
'''
rfind()： 和find()功能相同，但查找⽅向为右侧开始。
rindex()：和index()功能相同，但查找⽅向为右侧开始。
'''
# print(mystr.rfind('and')) # 35
# print(mystr.rfind('ands')) # -1
# print(mystr.rindex('and')) # 35
# print(mystr.rindex('ands')) # ValueError: substring not found
'''
修改
'''
'''
replace()：替换; 有返回值，返回值是修改后的字符串；原字符串变量没有改变
字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
注意：替换次数如果查出⼦串出现次数，则替换次数为该⼦串出现次数。
'''
# mystr = "hello world and itcast and itheima and Python"
# 数据是否可以改变划分为可变类型和不可变类型
# new_str = mystr.replace('and', 'he')
# print(new_str)
# print(mystr.replace('and', 'he', 2))
# print(mystr.replace('and', 'he', 10))
'''
split()：按照指定字符分割字符串。 分割，返回一个列表,丢失分割字符
字符串序列.split(分割字符, num)
num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
'''
# list1 = mystr.split('and')
# list1 = mystr.split('and', 2)
# print(list1)
'''
join() 合并列表里面的字符串数据为一个大字符串
'''
# mylist = ['aa', 'bb', 'cc']
# # aa..bb..cc
# print('..'.join(mylist))
'''
大小写转换
capitalize()：将字符串第⼀个字符转换成⼤写。
capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。
title()：将字符串每个单词⾸字⺟转换成⼤写
lower()：将字符串中⼤写转⼩写。
upper()：将字符串中⼩写转⼤写。
'''
# mystr = "hello world and itcast and itheima and Python"
# # print(mystr.capitalize()) # Hello world and itcast and itheima and python
# # print(mystr.title()) # Hello World And Itcast And Itheima And Python
# print(mystr.upper()) # HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
# print(mystr.lower()) # hello world and itcast and itheima and python
'''
lstrip()：删除字符串左侧空⽩字符。
rstrip()：删除字符串右侧空⽩字符。
strip()：删除字符串两侧空⽩字符。
'''
# mystr = " hello world and itcast and itheima and Python "
# print(mystr)
# print(mystr.lstrip())
# print(mystr.rstrip())
# print(mystr.strip())
'''
ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。
字符串序列.ljust(⻓度, 填充字符)
rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和
ljust()相同。
center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语
法和ljust()相同。
python console
Python 3.7.4 (tags/v3.7.4:e09359112e, Jul 8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32
mystr = 'hello'
mystr
'hello'
mystr.ljust(10)
'hello '
mystr.ljust(10, '.')
'hello.....'
mystr.rjust(10)
' hello'
mystr.rjust(10, '.')
'.....hello'
mystr.center(10)
' hello '
mystr.center(10, '.')
'..hello...'
'''
'''
字符串判断
'''
# mystr = "hello world and itcast and itheima and Python"
# print(mystr.startswith('hello'))
# print(mystr.startswith('world', 6))
# print(mystr.endswith('Python'))
'''
isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。
isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。
'''
# print('hello'.isalpha())
# print('123'.isdigit())
# print('abc123'.isalnum())
# print("\t\n".isspace())
# print(' '.isspace()) # True
'''
列表
'''
'''
下标
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# print(name_list)
# print(name_list[1])
'''
index()：返回指定数据所在位置的下标 。注意：如果查找的数据不存在则报错。
count()：统计指定数据在当前列表中出现的次数。
与字符使用方式一样
len()：访问列表⻓度，即列表中数据的个数。
判断是否存在
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# print(name_list.index('TOM'))
# print(name_list.index('TOMS')) # ValueError: 'TOMS' is not in list
# print(name_list.count('Lily'))
# print(name_list.count('Lilys')) # 0
# print(len(name_list))
# print('TOM' in name_list)
# print('TOMS' in name_list)
# print('TOMS' not in name_list)
# print('TOM' not in name_list)
'''
需求：查找⽤户输⼊的名字是否已经存在。
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# name = input('请输入您的名字：')
# if name in name_list:
# print(f'{name}已存在')
# else:
# print(f'{name}可用')
'''
增加
append()：列表结尾追加数据。
列表序列.append(数据)
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# name_list.append('XiaoMing') ['TOM', 'Lily', 'ROSE','XiaoMing']
# print(name_list) # 列表是可变类型
# name_list.append([11,22]) # 追加整个序列到列表 ['TOM', 'Lily', 'ROSE', 11, 23]
# print(name_list)
'''
extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。
'''
# name_list.extend('xiaoming')
# print(name_list) # ['TOM', 'Lily', 'ROSE', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
# name_list.extend([11,23])
# print(name_list) # ['TOM', 'Lily', 'ROSE', 11, 23]
'''
insert()：指定位置新增数据。
列表序列.insert(位置下标, 数据)
'''
# name_list.insert(1,'aa')
# print(name_list) # ['TOM', 'aa', 'Lily', 'ROSE']
'''
删除
del ⽬标
del()
'''
# del name_list
# print(name_list) # NameError: name 'name_list' is not defined
# del name_list[0]
# print(name_list) # ['Lily', 'ROSE']
'''
pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
列表序列.pop(下标)
'''
# del_name = name_list.pop()
# del_name = name_list.pop(1)
# print(del_name)
# print(name_list)
'''
remove(数据)
'''
# name_list.remove('ROSE')
# print(name_list)
# name_list.clear()
# print(name_list)
'''
修改
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# # 修改指定下标的数据
# name_list[0] = 'aaa'
# print(name_list)
#
# # 逆序 reverse()
# list1 = [1, 3, 2, 5, 4, 6]
# list1.reverse()
# print(list1) # [6, 4, 5, 2, 3, 1]
#
# # sort() 排序：升序(默认)和降序
# # list1.sort()
# # list1.sort(reverse=False)
# list1.sort(reverse=True)
# print(list1)
'''
复制
'''
# name_list = ['TOM', 'Lily', 'ROSE']
# name_li2 = name_list.copy()
# name_li2.reverse()
# print(name_li2)
# print(name_list)
'''
列表的循环遍历
'''
name_list = ['TOM', 'Lily', 'ROSE']
# i = 0
# while i < len(name_list):
# print(name_list[i])
# i += 1
# for i in name_list:
# print(i)
# # TOM
# # Lily
# # ROSE
#
# for idx,val in enumerate(name_list):
# print(idx,val)
'''
列表嵌套
'''
# name_list = [['TOM','Lily', 'Rose'], ['张三','李四', '王五'], ['小米','小花','小明']]
# print(name_list)
# print(name_list[0])
# print(name_list[0][1])
'''
综合应⽤ -- 随机分配办公室
需求：有三个办公室，8位⽼师，8位⽼师随机分配到3个办公室
步骤
1.准备数据
8位老师，3个办公室
2.分配老师到办公室 随机分配
3.验证是否分配成功 办公室列表追加老师
'''
# import random
# teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
# offices = [[], [], []]
# for name in teachers:
# offidx = random.randint(0,2)
# offices[offidx].append(name)
# i = 1
# for office in offices:
# print(f'办公室{i}人数为{len(office)}')
# for name in office:
# print(name)
# i += 1
'''
元组
元组的应⽤场景
⼀个元组可以存储多个数据，元组内的数据是不能修改的。
'''
# t1 = (10, 20, 30)
# print(type(t1))
# print(t1)
# t2 = (10,)
# print(type(t2)) # <class 'tuple'>
# t3 = (10)
# print(type(t3)) # <class 'int'>
# t4 = ('aaa')
# print(type(t4)) # <class 'str'>
# t5 = ('aaa',)
# print(type(t5)) # <class 'tuple'>
'''
元组的常⻅操作
元组数据不⽀持修改，只⽀持查找，具体如下：
按下标查找数据
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index
⽅法相同。
count()：统计某个数据在当前元组出现的次数。
len()：统计元组中数据的个数。
'''
# t1 = ('aa', 'bb', 'cc', 'dd')
# print(t1[0])
# print(t1.index('aa'))
# print(t1.index('bbb'))
# print(t1.count('aa'))
# print(len(t1))
'''
元组修改
但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要。
'''
# t1[0] = 'aaa' # TypeError: 'tuple' object does not support item assignment
# t2 = ('aa', 'bb', ['cc', 'dd'])
# print(t2[2])
# t2[2][0] = 'TOM'
# print(t2) # ('aa', 'bb', ['TOM', 'dd'])
'''
字典
字典的应⽤场景
思考1： 如果有多个数据，例如：'Tom', '男', 20，如何快速存储？
字典，字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标，
后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可。
创建字典的语法:
字典特点：
符号为⼤括号
数据为键值对形式出现
各个键值对之间⽤逗号隔开
'''
# 有数据的字典
dict1 = {'name': 'TOM', 'age': 20, 'gender':' 男'}
# print(dict1)
# print(type(dict1)) # <class 'dict'>
# # 空字典
# dict2 = {}
# dict3 = dict()
# print(type(dict2))
# print(type(dict3))
'''
字典常⻅操作
'''
# 增 字典序列[key] = 值
# 注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
# dict1 = {'name': 'TOM', 'age': 20, 'gender':' 男'}
# dict1['id'] = 110
# print(dict1)
# dict1['name'] = 'ROSE'
# print(dict1)
# 删 del() / del：删除字典或删除字典中指定键值对。
# del(dict1)
# print(dict1) # NameError: name 'dict1' is not defined
# del dict1['name']
# del dict1['names'] # KeyError: 'names'
# dict1.clear() # {}
# print(dict1)
# 改 字典序列[key] = 值
# 注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对
# dict1['id'] = 110
# print(dict1)
'''
查
key值查找
如果当前查找的key存在，则返回对应的值；否则则报错。
get()
keys()
values()
items()
'''
# print(dict1['name'])
# print(dict1['name1']) # print(dict1['name1'])
# dict1 = {'name': 'TOM', 'age': 20, 'gender':' 男'}
# print(dict1.get('name')) # TOM
# print(dict1.get('id')) # None
# print(dict1.get('id','Lily')) # Lily
# # 查找字典中所有的key,返回可迭代的对象
# print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
#
# print(dict1.values()) # dict_values(['TOM', 20, ' 男'])
# # 查找字典中所有的键值对，返回可迭代对象，里面的对象是元组，元组数据1是key,2是value
# print(dict1.items()) # dict_items([('name', 'TOM'), ('age', 20), ('gender', ' 男')])
'''
字典遍历
'''
# dict1 = {'name': 'TOM', 'age': 20, 'gender':' 男'}
# # for key in dict1.keys():
# # print(key)
# # for v in dict1.values():
# # print(v)
#
# for item in dict1.items():
# print(item) # ('name', 'TOM')
#
# # 遍历字典的键值对，拆包
# for k,v in dict1.items():
# print(f'{k}={v}')
'''
集合
创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
特点：
1. 集合可以去掉重复数据；
2. 集合数据是⽆序的，故不⽀持下标
'''
# s1 = {10, 20, 30, 40, 50}
# print(s1) # {40, 10, 50, 20, 30}
# s2 = {10, 20, 30, 40, 30, 40, 50}
# print(s2)
# s3 = set('abcdefg')
# print(s3) # {'d', 'b', 'g', 'f', 'a', 'e', 'c'}
# s4 = set()
# print(type(s4)) # <class 'set'>
# s5 = {}
# print(type(s5)) # <class 'dict'>
'''
集合常⻅操作⽅法
增加数据
因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。
add()
update(), 追加的数据是序列。
'''
# 集合是可变类型
# s1 = {10, 20}
# s1.add(100)
# print(s1)
# s1.add(100)
# s1.add([10,20,30]) # TypeError: unhashable type: 'list'
# s1.update([10, 50, 30])
# print(s1)
# s1.update(60) # TypeError: 'int' object is not iterable
'''
删除数据
remove()，删除集合中的指定数据，如果数据不存在则报错。
discard()，删除集合中的指定数据，如果数据不存在也不会报错。
pop()，随机删除集合中的某个数据，并返回这个数据
'''
# s1 = {10, 20, 30, 40, 50}
# s1.remove(10)
# s1.remove(100) # KeyError: 100
# s1.discard(10)
# s1.discard(10)
# print(s1)
# del_num = s1.pop()
# print(del_num)
# print(s1)
'''
查找数据
in：判断数据在集合序列
not in：判断数据不在集合序列
'''
# s1 = {10, 20, 30, 40, 50}
# print(10 in s1)
# print(10 not in s1)
'''
公共操作
运算符
运算符 描述 ⽀持的容器类型
+ 合并 字符串、列表、元组
* 复制 字符串、列表、元组
in/not in 元素是否存在 字符串、列表、元组、字典
公共⽅法
容器类型转换
'''
# # 1. 字符串
# str1 = 'aa'
# str2 = 'bb'
# str3 = str1 + str2
# print(str3) # aabb
# # 2. 列表
# list1 = [1, 2]
# list2 = [10, 20]
# list3 = list1 + list2
# print(list3) # [1, 2, 10, 20]
# # 3. 元组
# t1 = (1, 2)
# t2 = (10, 20)
# t3 = t1 + t2
# print(t3) # (10, 20, 100, 200)
# dict1 = {'name':'aa'}
# dict2 = {'gender':'bb'}
# dict3 = dict1 + dict2 # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# print(dict3)
# # 1. 字符串
# print('-' * 10) # ----------
# # 2. 列表
# list1 = ['hello']
# print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# # 3. 元组
# t1 = ('world',)
# print(t1 * 4) # ('world', 'world', 'world', 'world')
# 1. 字符串
# print('a' in 'abcd') # True
# print('a' not in 'abcd') # False
# # 2. 列表
# list1 = ['a', 'b', 'c', 'd']
# print('a' in list1) # True
# print('a' not in list1) # False
# # 3. 元组
# t1 = ('a', 'b', 'c', 'd')
# print('aa' in t1) # False
# print('aa' not in t1) # True
# dict1 = {'name': 'TOM', 'age': 20, 'gender':' 男'}
# print('name' in dict1.keys())
# print('TOM' in dict1.values())
'''
公共⽅法
函数 描述
len() 计算容器中元素个数
del 或 del() 删除
max() 返回容器中元素最⼤值
min() 返回容器中元素最⼩值
range(start,
end, step) ⽣成从start到end的数字，步⻓为 step，供for循环使⽤；range()⽣成的序列不包含end数字。
enumerate() 函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序
列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。
'''
# 1. 字符串
# str1 = 'abcdefg'
# print(len(str1)) # 7
# # 2. 列表
# list1 = [10, 20, 30, 40]
# print(len(list1)) # 4
# # 3. 元组
# t1 = (10, 20, 30, 40, 50)
# print(len(t1)) # 5
# # 4. 集合
# s1 = {10, 20, 30}
# print(len(s1)) # 3
# # 5. 字典
# dict1 = {'name': 'Rose', 'age': 18}
# print(len(dict1)) # 2
# str1 = 'abcdef'
# list1 = [10,20,30]
# t1 = (10,20,30)
# s1 = {10,20,30}
# dict1 = {'name': 'TOM','age':17}
# del str1
# # del list1
# del(list1[0])
# print(list1)
# del dict1['name']
# print(dict1)
# print(max(str1),min(str1))
# print(max(list1),min(list1))
# print(range(1, 10,1)) # range(1, 10) 返回可迭代对象
# # 左闭右开
# for i in range(1, 10, 1):
# print(i)
# 默认步长是1
# for i in range(1, 10):
# print(i)
# # 默认从0开始
# for i in range(10):
# print(i)
'''
enumerate(可遍历对象, start=0)
start参数⽤来设置遍历数据的下标的起始值，默认为0。
'''
# list1 = ['a', 'b', 'c', 'd']
# for i in enumerate(list1):
# print(i) # (1, 'b') ... (下标 数据)
# start 修改下标起始值
# for i in enumerate(list1,start=1):
# print(i)
'''
容器类型转换
tuple()
list()
set()
'''
# list1 = [10, 20, 30, 40, 50, 20]
# s1 = {100, 200, 300, 400, 500}
# t1 = ('a', 'b', 'c', 'd', 'e')
#
# print(tuple(list1))
# print(tuple(s1))
#
# print(list(s1))
# print(list(t1))
# print(set(list1))
# print(set(t1))
'''
列表推导式
⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。
----
列表推导式
字典推导式
集合推导式
'''
# 需求创建一个0-10的列表
# while实现.....
# list1 = []
# i = 0
# while i < 10:
# list1.append(i)
# i += 1
# print(list1)
# for实现.....
# list1 = []
# for i in range(10):
# list1.append(i)
# print(list1)
# 列表推导式实现
# list1 = [i for i in range(10)]
# print(list1)
# 带if的列表推导式
# 需求：创建0-10的偶数列表
# list1 = [ i for i in range(0,10,2)]
# print(list1)
# list0 = []
# for i in range(10):
# if i % 2 == 0:
# list0.append(i)
# print(list0)
# list2 = [i for i in range(10) if i % 2 == 0]
# print(list2)
# 多个for循环实现列表推导式
# 需求：创建列表如下： [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
# list1 = []
# for i in range(1,3):
# for j in range(3):
# list1.append((i,j))
# list2 = [(i, j) for i in range(1, 3) for j in range(3)]
# print(list2)
'''
字典推导式
如何快速合并为⼀个字典？
答：字典推导式
字典推导式作⽤：快速合并列表为字典或提取字典中⽬标数据。
'''
# . 创建⼀个字典：字典key是1-5数字，value是这个数字的2次⽅。
# dict1 = {i: i**2 for i in range(1, 5)}
# print(dict1)
# 将两个列表合并为⼀个字典
# list1 = ['name', 'age','gender']
# list2 = ['Tom', 20, 'man']
# dict2 = { list1[i]: list2[i] for i in range(len(list1))}
# print(dict2)
# # 如果两个列表数据长度不同，len统计列表数据多的个数，会报错；统计少的，不会报错
#
# # 提取字典中⽬标数据
# counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# count1 = {k: v for k,v in counts.items() if v > 200}
# print(count1)
'''
集合推导式
'''
# 需求：创建⼀个集合，数据为下⽅列表的2次⽅。
# list1 = [1, 1, 2]
# set1 = {i**2 for i in list1}
# print(set1) # print(set1) #
