1.###容器类型强制转换（str list tuple set dict）
var1="今天天气好晴朗！朗 "
var2=["刘璐","王钊","王华珍","罗松峰"]
var3=("刘璐","王钊","王华珍","罗松峰")
var4={"王文贤","庄哲浩","王铁男"}
var5={"a":1,"b":2}
var6=12345
#str (容器类型数据 / number 数据类型 都可以)
"""基于原来的数据类型两边套上引号"""
res=str(var2)
res=str(var5)
res=str(var6)
print(res,type(res))
#repr 以字符串的形式原型化输出数据
print(repr(res))
#list
"""规律：如果是字符串把里面的字符一个一个拿出来，作为列表的每一个元素
如果是其他容器数据，只是基于原数据，把两边的符号换成[] 换成列表
如果是字典，只是单纯的获取字典的键，不是那个值，组成列表
"""
res=list(var1)
res=list(var3)
res=list(var4)
res=list(var5)
print(res)
#tuple
"""规律：如果是字符串把里面的字符一个一个拿出来，作为元组的每一个元素
如果是其他容器数据，只是基于原数据，把两边的符号换成() 换成元组
如果是字典，只是单纯的获取字典的键，不是那个值，组成元组
"""
res=tuple(var1)
res=tuple(var2)
res=tuple(var4)
res=tuple(var5)
print(res)
#set
"""规律：如果是字符串把里面的字符一个一个拿出来，作为集合的每一个元素
如果是其他容器数据，只是基于原数据，把两边的符号换成{} 换成集合
如果是字典，只是单纯的获取字典的键，不是那个值，组成元组
集合的特征：自动去重，无序
"""
res=set(var1) #{'！', '今', '晴', '天', '朗', '好', ' ', '气'} 直接去重
res=set(var2)
res=set(var5)
print(res)
2 Python 运算符
#（1）算数运算符：+ - * / // % **
var1=15
var2=7
# +
res=var1+var2
print(res)
# -
res=var1-var2
print(res)
# *
res=var1*var2
print(res)
# / 通过除法得到的数据一定是小数，浮点型，即使除尽，数字后面加上 .0 表达小数
res=var1/var2
print(res) #5.0
# // 地板除 得到一个整数
res=7//2
print(res)
# //
res=var1 // var2 #1
print(res)
#如果除数或者被除数是一个小数，那么这个结果尾巴上带 “0”
res=var1 // 7.0 #2.0
print(res)
# % 取余
res=var1 % var2
res=13 % 7 #6
res=-13 % 7 #1 -6+7=1
res=13 % -7 #-1 -7+6=-1
res=-13 %- 7 #-6 把正确的余数算出来，前面带上负号即可
print(res)
# ** 幂运算符
res=5**2
print(res)
res=5**5
print(res)
（2）比较运算符 > < + - + == !=
#__author:vivian
#createTime 05 23:15
# Python 运算符
#（1）算数运算符：+ - * / // % **
var1=15
var2=7
# +
res=var1+var2
print(res)
# -
res=var1-var2
print(res)
# *
res=var1*var2
print(res)
# / 通过除法得到的数据一定是小数，浮点型，即使除尽，数字后面加上 .0 表达小数
res=var1/var2
print(res) #5.0
# // 地板除 得到一个整数
res=7//2
print(res)
# //
res=var1 // var2 #1
print(res)
#如果除数或者被除数是一个小数，那么这个结果尾巴上带 “0”
res=var1 // 7.0 #2.0
print(res)
# % 取余
res=var1 % var2
res=13 % 7 #6
res=-13 % 7 #1 -6+7=1
res=13 % -7 #-1 -7+6=-1
res=-13 %- 7 #-6 把正确的余数算出来，前面带上负号即可
print(res)
# **
res=5**2
print(res)
res=5**5
print(res)
# (2)运算
res=var1>var2
print(res)
#<= 实在做比较，不是在谈护具，默认值 是一个 符号
#等于
res=var1==var2
print(res)
#！= 不等于
#（2）赋值运算：= += -= *= /= //= %= **=
var1=14
var2=4
# =
var1=var2
print(var1) #4
+=
var1+=var2 #var1=var1+var2
print(var1)
-=
var1-=var2 #var1=var1-var2 10
print(var1)
*=
var1*=var2 #var1=var1*var2 56
print(var1)
var1/=var2 #var1=var1/var2 3.5
print(var1)
//=
var1//=var2 #var1=var1//var2 3
print(var1)
%=
var1%=var2 #var1=var1%var2 2
print(var1)
**=
var1 **= var2 #var1=var1**var2 18416
print(var1)
#（2）成员运算：in 和 not in （针对容器类型数据）
strvar="如果遇到你是一种错，那我宁愿一错再错。"
res="你" in strvar #True
res="遇到你" in strvar #True
res="错那" in strvar #False
print(res)
#tuple list set
tup=("吴波","帅了","毕阳生","刘德元")
res="刘德元" in tup
print(res)
lst=["吴波","帅了","毕阳生","刘德元","温红杰"]
res="温红杰" not in lst
print(res)
setvar={"莱汀","银燕","王成元"}
res="yinyan" in setvar
print(res)
#dict in 或者 not in 判断的是字典的键
dictvar={"wtn":"成熟稳重","lxh":"头发","lsf":"温文尔雅","hh":"h和好"}
res="成熟稳重" in dictvar
print(res) #False
res="lxh" in dictvar
print(res) #True
###（5）身份运算符： is 和 is not （检测两个数据在内存当中是否是同一个值）
# int -5 ~ 正无穷
var1=6
var2=6
#比较两个变量的地址，是不是同一个
res=var1 is var2
print(res) #True
#比较两个变量的值，是不是同一个
res=var1==var2
print(res) #True
#复数，在只有虚数的情况下，地址相同
var1=6j
var2=6j
print(var1 is var2) #True
#bool 两个值相同，那么地址一样
var1=False
var2=True
print(var1 is not var2) #True
#容器类型数据 只有空元组和相同字符串，在值相同的情况下，地址是相同
var1=()
var2=()
print(var1 is var2) #True
var1="好"
var2="好"
print(var1 is var2) #True
var1=[1,2]
var2=[1,2]
print(var1 is var2) #False
print(var1 is not var2) #True
###（6）逻辑运算符： and or not
# and 逻辑与
"""全真则真,一假则假"""
res = False and False
print(res) #False
res = True and False
print(res) #False
res = True and True
print(res) #True
res = False and True
print(res) #False
# or 逻辑或
"""全假则假,一真则真"""
res = True or True
print(res)
res = True or False
print(res)
res = False or True
print(res)
res = False or False
print(res)
# not 逻辑非
"""取反 真变假 假变真"""
res = not True
res = not False
print(res)
print("==============")
#逻辑短路
"""
(1) True or 表达式
(2) False or 表达式
"""
#(1)
True or print("我短路了么？1")
#(2)
False and print("我短路了么？2")
print("------------")
False or print("我短路了么？3")
True and print("我短路了么？4")
res=True or 5 #True
print(res)
res=True and 5 #5
print(res)
# print 是系统的函数,打印的值和要返回的值是两个完全不同的概念
res = print(1234)
print(res) #None print没有返回值 是通过return + 返回值定义的
# res = True and print(123)
# res = True and None
# print(res)
res = True and 7
print(res) #7
res = False and 8
print(res) #False
res = True or 99
print(res) # True
res = False or "abc"
print(res) #"abc"
# 逻辑运算符优先级
"""
() > not > and > or
如果存在逻辑短路,优先计算短路,比如True or ...... 一定为True
"""
res = 5 or 6 and 7 # 5
res = (5 or 6) and 7 # 7
res = not (5 or 6) and 7 # False
print(res)
res = 1>2 and 3<4 or 5>6 and 7>8
print(res)
# res= False and True or False and False
# res= False or False
# res = False
# ### (7)位运算符: & | ~ ^ << >>
# & 按位与
var1 = 19
var2 = 15
res = var1 & var2
print(res) #3
"""
10011
01111
00011
"""
# | 按位或
res = var1 | var2
print(res) #31
"""
10011
01111
11111
"""
# ^ 按位异或
"""两个值不相同即为真,相同即为假"""
res = var1 ^ var2
print(res)
"""
10011
01111
11100
"""
# << 左移
"""左移是乘 5左移2位相当于 5 * 2的2次幂 = 20"""
res = 5 << 2
print(res) #20
"""
0000 ... 101
0000 . 10100
"""
# >> 右移
"""右移是除 5右移1位相当于 5 // 2的1次幂 = 2"""
res = 5 >> 1
print(res)
"""
0000 ... 101
0000 ... 010
"""
# ~ 按位非 公式: ~19 => -(n+1)
res = ~(-18)
print(res)
"""
总结:所有运算符优先级;
一元运算符: 同一时间,操作一个数据的 (~ -)
二元运算符: 同一时间,操作两个数据的 (+ - * / ...)
一般情况下 , 一元运算符 优先级大于 二元运算符
-3 + 5 = 2
例外:
所有运算符优先级最高的 ** 幂运算 ~2**2
所有运算符优先级最低的 = 赋值运算符
同等级运算符优先级:
() > not > and > or
乘除 > 加减
(<< >>) > & > ^ > |
除此之外,大体优先级高低:
算术运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
赋值运算符 单独列出来 用于把右侧的值算完之后收尾.
"""
res = ~2**2
print(res)
res = 5+5 << 6//3 is 40 and True
# 5+5 << 2 is 40 and True
# 10 << 2 is 40 and True
# 40 is 40 and True
# True and True => True
print(res) #True
# 加上括号提升优先级 让别人也能看懂
res = (5+5) << (6//3) is 40 and True
3.###代码块： 以冒号作为开始，用缩进来划分作用域，这个整体是一个代码块
"""
作用域：作用的范围
看似距离相同，不代表是同一个缩进，比如4个空格和1个tab距离也是相同 ，不能混合一起
"""
print(11)
print(22)
print(33)
if 5==5:
print(1)
print(2)
print(3)
# print(4) indenterro 缩进错误
4.# ### 流程控制
"""
流程:代码执行的过程
流程控制:就是对代码执行的过程进行管控
流程控制的三大结构:
顺序结构: 代码从上到下,依次执行
分支结构: 4小类
循环结构: while , for
分支结构: 关键字 if
(1)单项分支
(2)双项分支
(3)多项分支
(4)巢状分支
"""
# （1）单项分支
"""
语法:
if 条件表达式:
code1
code2
...
...
如果条件表达式成立,那就是返回真True ,就会执行代码块
如果条件表达式不成立,那就是返回假False,不执行代码块
"""
guoyimeng = "美女"
guoyimeng = "绿巨人"
if guoyimeng == "美女":
print("给你买好吃的")
print("给你买好喝的")
print("给你买兰蔻")
print("给你买倩碧")
print("给你买香奈儿")
print("给你买LV")
print("给你买兰博基尼")
print("给你买包,因为包治百病!")
# （2）双项分支: (2个当中选一个)
"""
if 条件表达式:
code1
code2..
else:
code3
code4...
如果条件表达式为真,那就是返回真True,执行code1和code2..
如果条件表达式为假,那就是返回假False,执行code3和code4..
if 下面的代码块也可以叫做真区间
else 下面的代码块也可以叫做假区间
"""
huanghua = "高富帅"
huanghua = "屌丝"
if huanghua == "高富帅":
print("我就嫁给你")
else:
print("你是个好人~")
"""
模拟网站的登录
等待用户输入账号和密码;
账户是admin 密码是111
如果条件满足,就让他登录
如果条件不满足,就告诉他登陆失败
"""
# input 等待用户输入字符串 , 他返回的数据类型是字符串
# res = input("先森~,你妈贵姓~:")
# print(res,type(res))
username = input("请输入您的用户名:")
password = input("请输入您的密码:")
# print(username)
# print(password)
if username == "admin" and password == "111":
print("恭喜你~ 登陆成功")
else:
print("抱歉,登录失败")
# ### （3）多项分支
"""
if 条件表达式1:
code1
code2
elif 条件表达式2:
code3
code4...
elif 条件表达式3:
code5
code6...
else:
code7 ...
如果条件表达式1满足,返回真,就执行对应代码块,如果条件表达式1不满足,代码往下执行
看一看条件表达式2 是否成立,如果成立,就执行对应代码块,如果条件表达式2不满足,代码往下执行
看一看条件表达式3 是否成立,如果成立,就执行对应代码块,如果条件表达式3不满足,直接执行else这个区间的代码块
elif 可以有多个,也可以没有
else 只能有一个,也可以没有
只有当所有条件都不满足的时候,才会执行else区间.
多项分支是多选1的结果.
"""
youqian = True
#a. 双项分支
if youqian == True:
print("我就嫁给你")
else:
print("你是个好人")
youqian = False
youfang = False
youche = False
youyanzhi = False
youtili = False
# b.多项分支
print("<=============>")
if youqian == True:
print("我就嫁给你1")
elif youfang == True:
print("我就嫁给你2")
elif youche ==True:
print("我就嫁给你3")
elif youyanzhi == True:
print("我就嫁给你4")
elif youtili == True:
print("我就嫁给你5")
else:
print("你是个好人啊6")
# c.巢状分支 (单项分支 双项分支 多项分支的互相嵌套)
youqian = True
youfang = True
youche = True
youyanzhi = True
youtili = True
if youqian == True:
if youfang == True:
if youche == True:
if youyanzhi == True:
if youtili == True:
print("我就嫁给你")
else:
print("恭喜你,成为我的1号备胎.")
else:
print("恭喜你,成为我的2号备胎.")
else:
print("恭喜你,成为我的3号备胎.")
else:
print("恭喜你,成为我的4号备胎.")
else:
print("抱歉,前面就是2路汽车,一会好赶不上了呦")
#出题 height
#女生找对象
# 男生在1米~1.5米之间 小强 你在哪里?
# 男生在1.5~1.7米之间 没有安全感~
# 男生 1.7~ 1.8米之间 帅哥 留个电话
# 男生 1.8~2米之间 帅哥 你建议多一个女朋友吗
# height = 0.5
# 方法一.通用写法
"""
height = float(input("请输入您的身高:"))
if 1<=height and height<=1.5:
print("小强 你在哪里?")
elif height>1.5 and height<=1.7:
print("没有安全感~")
elif height>1.7 and height <=1.8:
print("帅哥 留个电话")
elif height>1.8 and height <=2:
print("帅哥 你建议多一个女朋友吗")
else:
print("没有符合条件的选项")
"""
# 方法二.python特有方法 可以连续比较
height = float(input("请输入您的身高:"))
if 1<=height<=1.5:
print("小强 你在哪里?")
elif 1.5<height<=1.7:
print("没有安全感~")
elif 1.7< height <=1.8:
print("帅哥 留个电话")
elif 1.8<height <=2:
print("帅哥 你建议多一个女朋友吗")
else:
print("没有符合条件的选项")
5.#打印一行十个小星星
#help 查看函数的帮助文档
help(print)
#end="" 默认不换行，在最后一个字符后面插入空字符取代
"""
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
"""
i=0
while i<=10:
print("*",end="")
i+=1
#计算1-101累加和
#死循环
"""
while True:
print(1)
"""
i=1
total=0
sign=True
while sign:
total+=i
i+=1
if i==101:
sign=False
print(total)
方法二，用变量拼接字符串得形式，打印十个小星星
i=100
while i<=110:
strvar+="*" #strvar=strvar+"*"
i+=1
print(strvar)
#(3)打印一行十个小星星 奇数个打印* 偶数打印@
"""
1.任意数和N取余：值的范围0-（n-1）
"""
i=0
while i<10:
if i%2==1:
print("*")
eilf i%2==0:
print("@")
i+=1
#(4)用 一个循环 打印十行十列小星星
i=0
while i<100:
print("*",end="")
if i%10==9:
print()
i+=1
#(5)一个循环 打印十行十列变色小星星（一个循环）
i=0
while i<100:
print("*",end="")
if i%2==0:
print("*",end="")
eilf i%2==0:
print("@",end="")
if i%10==9:
print()
i+=1
#(6)一个循环 打印十行十列隔行变色小星星（一个循环）
"""
2.任意数和n进行地板出，会出现n个相同的数字
3.地板除阔以获取一个数的高位，取余可以获取一个数的低位
"""
i=0
while i<100:
if i//10%2==0:
print("*",end="")
else:
print("@",end="")
if i%10==9:
print()
i+=1
"""
当i 范围在0-9 //10 会出现10个相同的0 0 在和2取余，余数是0
当i 范围在10-19 //10 会出现10个相同的1 0 在和2取余，余数是1
当i 范围在20-29 //10 会出现10个相同的2 0 在和2取余，余数是0
当i 范围在30-39 //10 会出现10个相同的2 0 在和2取余，余数是1
当i 范围在40-49 //10 会出现10个相同的2 0 在和2取余，余数是0
当i 范围在50-59 //10 会出现10个相同的2 0 在和2取余，余数是1
当i 范围在60-69 //10 会出现10个相同的2 0 在和2取余，余数是0
当i 范围在70-79 //10 会出现10个相同的2 0 在和2取余，余数是1
当i 范围在80-89 //10 会出现10个相同的2 0 在和2取余，余数是0
当i 范围在90-99 //10 会出现10个相同的2 0 在和2取余，余数是1
"""
6.#双层循环练习
#（1）打印十行十列小星星（用两个循环）
#打印一行十个小星星
i=0
while i<=10:
print("*",end="")
i+=1
#针对于一行十个星星，循环10次即可
j=0 #j来控制行数，一共10行
while j<10
#在这个地方写自己的逻辑
#里层循环控制打印一行十个星星
i=0
while i<=10:
print("*",end="")
i+=1
#在打印完一行之后，打印换行；
print()
j+=1
print("============")
#(2)打印十行十列换色小星星（用两个循环）
j=0
while j<10:
i=0
while i<10:
#print("*",end="")
if i%2==0:
print("*",end="")
else:
print("@",end="")
i+=1
print()
j+=1
#(3)打印一行十个小星星 奇数个打印* 偶数打印@
"""
外层j动一次，里面的循环动10次
外层动的慢，内层动的快
i和j切换即可
"""
j=0
while j<10:
i=0
while i<10:
print("*",end="")
if j%2==0:
print("*",end="")
else:
print("@",end="")
i+=1
#(4)九九乘法表
#方向一
i=1
while i<=9:
#里层循环几次，完全取决于i
j=1
while j<=i:
print("%d*%d=%2d"%(i,j,i*j),end="")
j+=1
#打印换行
print()
i+=1
#方向二
i=9
while i>0:
j=1
while j<=i:
print("%d*%d=%2d"%(i,j,i*j),end="")
j+=1
#打印换行
print()
i-=1
#(5)100-999找吉利数字：111 222 333 888
"""
789
789 //100 ==> 7
789 //10 %10 ==> 8
789 //10 ==> 9
"""
i=100
while i<=999:
baiwei=i//100
shiwei=i//10%10
gewei=i%10
#三个相同数字
if shiwei==baiwei and shiwei==gewei:
print(i)
#三个连续数字123 234 345
if shiwei==gewei-1 and shiwei==baiwei+1:
print(i)
if shiwei==gewei+1 and shiwei==baiwei-1:
print(i)
i+=1
7.# ###for 循环
"""循环 遍历 迭代 这三个名词都是 获取每一个数据的意思"""
"""
for 循环专门用来遍历数据，而while循环遍历数据有局限性，无法遍历无序容器数据
while 一般用于复杂的逻辑操作
语法：
可迭代对象：容器类型数据，range对象，迭代器
for i in可迭代对象
code...
"""
"""
#while 遍历数据的局限性
strvar={"a":1,"b":2}
lst=[1,2,3,4]
i=0
while i<len(lst):
res=lst[i]
print(res)
i+=1
"""
#遍历集合
setvar={"Jack","Rose","Lily","Lucy","Jane"}
for i in setvar:
print(i)
#遍历列表
setvar=["Jack","Rose","Lily","Lucy","Jane"]
for i in setvar:
print(i)
#遍历元组
setvar=("Jack","Rose","Lily","Lucy","Jane")
for i in setvar:
print(i)
#遍历字符串
container="我爱你亲爱的姑娘，见到你，我心花路放！"
for i in container:
print(i)
#遍历字字典 在遍历字典的时候，默认遍历健
container={"wzh":"老哥～稳","mjk":"奄奄一息","zzh":"梦游神国","dlh":"炯炯有神"}
for i in container:
print(i)
#遍历等长的二级容器
listvar=[("王健林","王思聪","王美了"),["马云","马化腾","马冬梅"],("王宝强","马蓉","宋小宝")]
#变量的解包
a,b=1,2
print(a,b)
a,b,c=4,56.6,8
print(a,b,c)
for i in listvar:
"""
('王健林', '王思聪', '王美了')
['马云', '马化腾', '马冬梅']
('王宝强', '马蓉', '宋小宝')
"""
print(i)
for a,b,c in listvar:
print(a,b,c)
"""
王健林 王思聪 王美了
马云 马化腾 马冬梅
王宝强 马蓉 宋小宝
"""
#遍历不等长的二级容器
listvar=[("王健林","王思聪","王美了"),["马云","马化腾",],("王宝强",)]
for i in listvar:
for j in i:
print(j)
"""
王健林
王思聪
王美了
马云
马化腾
王宝强
"""
#range 对象
"""
range(start,end,setp)
start 开始值
end 结束值（最大值取不到，取到之前的一个值）
setp 步长
"""
#1.range 中有一个值
for i in range(10):
print(i)
#2.range 中有两个值
for i in range(1,10):
print(i)
#3.range 中有三个正向值
for i in range(1,10,3):
print(i) # 1 4 7
#4.range 中有三个逆向值
for j in range(10,1,-3):
print(j) #10 7 4
8.九九乘法表
#九九乘法表一
i=1
while i<10:
j=1
while j<=i:
print("%d*%d=%2d"%(i,j,i*j),end=" ")
j+=1
#打印换行
print()
i+=1
#九九乘法表二
i=9
while i>0:
j=1
while j<=i:
print("%d*%d=%2d"%(i,j,i*j),end=" ")
j+=1
#打印换行
print()
i-=1
#九九乘法表三
for i in range(1,10):
for k in range(1,i):
print(end=" ")
for j in range(i,10):
print("%d*%d=%2d"%(i,j,i*j),end=" ")
print("")
#九九乘法表四
for i in range(1,10):
for k in range(1,10-i):
print(end=" ")
for j in range(1,i+1):
print("%d*%d=%2d"%(i,j,i*j),end=" ")
print("")
"""
1*1= 1
2*1= 2 2*2= 4
3*1= 3 3*2= 6 3*3= 9
4*1= 4 4*2= 8 4*3=12 4*4=16
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25
4*1= 4 4*2= 8 4*3=12 4*4=16
3*1= 3 3*2= 6 3*3= 9
2*1= 2 2*2= 4
1*1= 1
1*1= 1 1*2= 2 1*3= 3 1*4= 4 1*5= 5 1*6= 6 1*7= 7 1*8= 8 1*9= 9
2*2= 4 2*3= 6 2*4= 8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
3*3= 9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
6*6=36 6*7=42 6*8=48 6*9=54
7*7=49 7*8=56 7*9=63
8*8=64 8*9=72
9*9=81
1*1= 1
2*1= 2 2*2= 4
3*1= 3 3*2= 6 3*3= 9
4*1= 4 4*2= 8 4*3=12 4*4=16
5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25
6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
"""