老男孩自动化运维开发第2天

目录导航：

　　1. 容器类型强制转换
　　2. 二级容器
　　3. 算数运算符
　　4. 赋值运算符与成员运算符
　　5. 身份运算符
　　6. 位运算符
　　7. 代码块
　　8. 流程控制
　　9. 多项分支
　　10. 循环分支
　　11. 单循环练习
　　12. 字符串的相关操作　
　　13.多循环练习
　　14. for 循环

1. 容器类型强制转换

var1 = "今天天气转冷了"
var2 = [1,2,3]
var3 = (4,5,6)
var4 = {"a","b","c"}
var5 = {"a":1,"b":2}

# (1)str 强制转换成字符串
"""在原数据类型的两边套上引号"""
res = str(var2)
res = str(var3)
res = str(var4)
print(res,type(res))

# repr 在不转移字符串的情况下,原型化输出
res_new = repr(res)
print(res_new)

# (2)list 强制转换成列表
"""
如果是字符串,那么就是把每一个字符都当成新的元素组合成列表
如果是list , tuple ,set 就是在原数据类型的两边改成[]
如果是字典 , 只是获取字典的键组成列表
"""
res = list(var1)
res = list(var3)
res = list(var4)
res = list(var5)
print(res,type(res))

# (3)tuple 强制转换成元组
"""
如果是字符串,那么就是把每一个字符都当成新的元素组合成元组
如果是list , tuple ,set 就是在原数据类型的两边改成()
如果是字典 , 只是获取字典的键组成元组
"""
res = tuple(var1)
res = tuple(var2)
res = tuple(var5)
print(res,type(res))

# (4)set 强制转换成集合
"""
如果是字符串,那么就是把每一个字符都当成新的元素组合成集合
如果是list , tuple ,set 就是在原数据类型的两边改成{}
如果是字典 , 只是获取字典的键组成集合
"""
res = set(var1)
res = set(var2)
res = set(var5)
print(res,type(res))

2. 二级容器

　　外面是一个容器类型数据,里面的元素还是一个容器类型的数据

# 二级列表
lst = [1,2,3,4,[5,6,7,8]]
# 二级元组
tup = (1,2,3,(7,8,9))
# 二级集合
setvar = {"a","b",(10,11,12)}
# 二级字典
dic = {"a":1,"b":2,"c":{"d":3,"e":4}}

# 四级容器
container = [1,2,3,(4,5,6,[7,89,9,{"a":1,"b":"王文"}])]

res = container[-1]
print(res)# (4, 5, 6, [7, 89, 9, {'a': 1, 'b': '王文'}])

res2 = res[-1]
print(res2) # [7, 89, 9, {'a': 1, 'b': '王文'}]

res3 = res2[-1]
print(res3) # {'a': 1, 'b': '王文'}

res4 = res3["b"]
print(res4) # 王文

# 简写
res = container[-1][-1][-1]["b"]
print(res)

　　等长的二级容器

# 等长的二级容器
"""
(1) 首先要求里面的每一个元素都是容器
(2) 要求容器里面的元素个数都是相同的
"""
lst = [(1,2,3),["a","b","c"],{1.1,2.3,False}]
tup = ([1,2],(3,4))


# ### 强制转换成字典
"""
(1) 需要是等长的二级容器
(2) 里面的元素必须是2个
"""
# (1)外面的容器是列表
lst = [["a",1],("b",2)] #(推荐)

# 如果是字符串,长度只能是2个,有一定的局限性(不推荐使用)
lst = ["a2","c3"] # c3344
# 虽然使用集合在语法上不会报错,但是有语义上的毛病(不推荐使用)
lst = [{"a",3},{"b",4}]

dic = dict(lst)
print(dic)

# (2)外面的容器是元组
tup = (["a",1],("b",2)) #(推荐)
dic = dict(tup)
print(dic)

# (3)外面的容器是集合
setvar = {("e",6),("f",7)}
dic = dict(setvar)
print(dic)

"""
Number => int float bool complex
容器 => str list tuple set dict
这些强转函数默认在不传值的时,都会创建一个当前数据类型的值
"""
res = dict()
print(res)

3. 算数运算符

var1 = 7
var2 = 4
# +
res = var1 + var2
print(res)

# -
res = var1 - var2
print(res)

# * 
res = var1 * var2
print(res)

# / 结果永远是小数
res = var1 / var2
res = 8 / 4
print(res)

# // 地板除
# 如果被除数或者除数是整数,那么结果也是整数
res = 8 // 4
# 如果被除数或者除数是小数,那么结果也是小数
res = 8 // 4.0
print(res)

# % 取余
res = var1 % var2
res = 81 % 4
# 先计算正常的余数,然后根据被除数身上的符号,决定余数的符号是正还是负
res = -81 % 4 # -1 + 4 = 3
res = 81 % -4 # 1 + (-4) = -3
# 如果被除数和除数都是负号,就是单纯的在余数的身上套上负号即可;
res = -81 % -4# -1
print(res)

# ** 幂运算
res = 3 ** 2
res = 3 ** 3
print(res)


# (2)比较运算符:  > < >= <= == !=   
"""只有两个结果,要么是True 真的,要么是False 假的"""
# >
res = 15 > 8
print(res)

# <
res = 15 < 8
print(res)

# >=
res = 15 >= 15
print(res)

# <= 
res = 15 <= 15
print(res)

# == 比较等号两边的值是不是相同
"""
a = 5  从右向左看,把5这个值赋值给变量a
a == 5 比较,比较等号两边的这个值是不是一样的,如果一样,返回True,反之返回False
"""

res = 5 == 5
print(res)

# != 比较等号两边的值是不是不相同
res = 6 != 10
print(res)

4. 赋值运算符与成员运算符

# = 赋值运算符
var1 = 17
var2 = 4

# +=
# var1 += var2
# '''var1 = var1 + var2'''
# print(var1)

# -=
# var1 -= var2
# '''var1 = var1 - var2'''
# print(var1)

# *=
# var1 *= var2
# '''var1 = var1 * var2'''
# print(var1)

# /=
# var1 /= var2
# '''var1 = var1 / var2'''
# print(var1)

# //=
# var1 //= var2
# '''var1 = var1 // var2'''
# print(var1)

# %=
# var1 %= var2
# '''var1 = var1 % var2'''
# print(var1)

# **=
# var1 = 9
# var2 = 2
# var1 **= var2
# '''var1 = var1 ** var2'''
# print(var1)

# (4)成员运算符:  in 和 not in (针对于容器型数据)
# 字符串
"""必须是一个连续的片段"""
strvar = "我爱你,亲爱的菇凉,一看到你,我就心慌"
res = "爱" in strvar
res = "亲爱的" in strvar
res = "你到" in strvar
print(res)

# list tuple set
listvar = ["戴鹏","谢岳鹏","余文杰","钟平福","李辉","叶渊明"]
res = "谢岳鹏" in listvar
res = "余文杰" not in listvar
setvar = {"张俊文","黄其新","李建波","陈勇"}
res = "张俊文" not in setvar
tuplevar = ("猴闪","周青","郑飞")
res = "猴闪" not in tuplevar
print(res)

# dict
"""在字典当中,成员运算符判断的是字典的键,不是值"""
dictvar = {"花和尚":"鲁智深","智多星":"无用","鼓上骚":"石阡"}
res = "鲁智深" in dictvar
res = "智多星" in dictvar
res = "鼓上骚" not in dictvar
print(res)

5. 身份运算符

　　is 和 is not (检测两个数据在内存当中是否是同一个值)

# int : -5 ~ 正无穷
var1 = 18
var2 = 18
# 比较两个变量指向的这个值是不是同一个(即地址相同)
res = var1 is var2
print(res)

# float: 非负数
var1 = 5.17
var2 = 5.17
res = var1 is not var2
print(res)

# complex 实数+ 虚数永远不相同(只有虚数的情况下例外)
var1 = 7j
var2 = 7j
res = var1 is var2
print(res)

# bool 只要值相同就一样
var1 = True
var2 = False
res = var1 is not var2
print(res)

# 容器类型数据
lst1 = [1,2]
lst2 = [1,2]
print(lst1 is lst2)

print("<=============================>")
# ### (6)逻辑运算符:  and or not
"""
and 逻辑与
or  逻辑或
not 逻辑非
"""

# 逻辑与 and
"""全真则真,一假则假"""
res = True and True   # True
res = True and False  # False
res = False and False # False
res = False and True  # False
print(res)

# 逻辑或 or
"""一真则真,全假则假"""
res = True or True  # True
res = True or False # True
res = False or True # True
res = False or False# False
print(res)

# 逻辑非 not (真变假,假变真)
res = not True
res = not False
print(res)

# 逻辑短路 (后面的代码不执行)
"""
	(1)True or 表达式
	(2)False and 表达式
"""
True or print(123)
False or print(123)

False and print(456)
True and print(456)

res = True or 7
res = 18 or True
res = False and 90
res = 0 and True
res = 18 and 0j
print(res)

# 逻辑运算符的优先级
# () > not > and > or
res = 5 or 6 and 7 # 5 or 7 => 5
res = (5 or 6) and 7 # 5 and 7 => 7
res = not (5 or 6 ) and 7 # not 5 and 7  => False and 7
print(res)

# 只有True or 表达式,在多个表达式的情况下仍然短路,但是False  and 表达式,在多个表达式的情况下不一定短路
res = 1>2 and 3<4 or 5<6 and 7<8 # False and True or True and True => False or True => True
res = True or 3>4 and 5<6 or 5>100 # True or False and True or False => True or False or False => True
print(res)

6. 位运算符

　　& |  ^ << >> ~

# & 按位与
var1 = 19
var2 = 15
res = var1 & var2
print(res)
"""
000 ... 10011
000 ... 01111
000 ... 00011
"""

# | 按位或
var1 = 19
var2 = 15
res = var1 | var2
print(res)
"""
000 ... 10011
000 ... 01111
000 ... 11111
"""

# ^ 按位异或 (两个值不一样,返回True,反之,返回假(比如都是0 或者 都是1))
var1 = 19
var2 = 15
res = var1 ^ var2
print(res)
"""
000 ... 10011
000 ... 01111
        11100
"""

# << 左移  乘法:5 * 2的3次幂
res = 5 << 3
print(res)
"""
000 ... 101
000 ..10100
"""
# >> 右移  除法:5 // 2的1次幂
res = 5 >> 1
print(res)
"""
000 ... 101
000 ... 001
"""

# 按位非  公式:-(n+1)
res = ~-11
print(res)

"""
运算符的优先级:
	运算符优先级最高的是 ** 幂运算
	运算符优先级最低的是 = 赋值运算符
	
	整体来看:
		一元运算符 > 二元运算符
		
	一元运算符 : 同一时间,操作一个数字的 [~ , -]
	二元运算符 : 同一时间,操作二个数字的 [+ - * / ... ]
	
	二元运算符: 整体用() 来提升运算的优先级
	逻辑运算中: () > not > and > or
	算数运算符: 乘除 > 加减
	按位运算符: << >> > & > ^ > |
	
	大体来看:
		算数运算符 > 位运算符 > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
		赋值运算符最后收尾,用来接收最后运算的数据
"""

res = 5+5 << 6 // 3 is 40 and True
# res = 10 << 2 is 40 and True
# res = 40 is 40 and True
# res = True and True => True
print(res)

# 用括号来提升优先级,让别人看懂代码
res = (5+5) << (6 // 3) is 40 and True

7. 代码块

　　以冒号最为开始,用缩进来划分同一个作用域,这个整体叫做代码块

"""作用域：作用的区域"""
"""
一个tab 大概是4个空格的距离
"""

if 5 == 5:
	print(111)
	print(222)
	
"""
if 5 == 7:
	print(333)
	print(444)
	print(555)
    print(666)
"""
"""
在代码块中,
	要么全部使用	缩进
	要么全部使用4个空格来表达缩进
	不能	和空格混合在一起使用
	即使在外观上来看,距离相同,也不是一个代码块;
"""


# php (了解)
"""
if(5 == 5){
	print(333)
print(444)
print(666)
}
"""

8.流程控制

"""
流程:代码执行的过程
流程控制:对代码执行的过程一种管控

三大结构:
	(1) 顺序结构: 代码默认从上到下依次执行
	(2) 分支结构: 4种分支
	(3) 循环结构: while  for

分支结构:
	(1) 单项分支
	(2) 双项分支
	(3) 多项分支
	(4) 巢状分支
"""
# 单项分支
"""
if 条件表达式:
	code1
	code2
	
如果条件表达式 成立, 就执行对应的代码块,反之,不执行
"""

chenzhenlian = "美女"
if chenzhenlian == "巫婆":
	print("给她买倩碧")
	print("给她买香奈儿")
	print("给她买香迪奥")
	print("给她买肾宝")
	print("给他买包,因为包治百病")
	
# 双项分支 (二选一)
"""
if 条件表达式:
	code1
	code2
else:
	code3
	code4
	
如果条件表达式 成立, 就执行if这个代码块中的内容
如果条件表达式 不成立,就执行else这个代码块中的内容

if 对应的代码块也叫作 真区间
else 对应的代码块也叫作 假区间

"""

shisongya = "穷鬼"
if shisongya == "有钱人":
	print("我就嫁给他")
else:
	print("你是个好人")

# ### 模拟网站登录
"""
账户: admin
密码: 123
如果账户密码满足条件,
	就登录成功
	否则登录失败
"""
# input 等待用户输入字符串
"""
res = input("请输入您的姓名:")
print(res,type(res))

"""

username = input("请输入您的账户:")
password = input("请输入你的密码:")

if username == "admin" and password == "123":
	print("登录成功")
else:
	print("登录失败")

9. 多项分支

"""
if 条件表达式1:
	code1
elif 条件表达式2:
	code2
elif 条件表达式3:
	code3
else:
	code4
先判定条件表达式1 是否成立,如果为真,执行对应的1号代码块,反之,向下继续判断
在判定条件表达式2 是否成立,如果为真,执行对应的2号代码块,反之,向下继续判断
在判定条件表达式3 是否成立,如果为真,执行对应的3号代码块,反之,向下继续判断
...
当所有的条件都不满足了,执行else这个区间的代码块

elif 可以出现0个或者多个
else 可以出现0个或者1个
"""

youqian = True
youfang = True
youche = False
youyanzhi = False
youtili = False

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("你是个好人")

print("<===============>")
# 巢状分支 (单项分支 双项分支 多项分支的互相嵌套)
if youqian == True:
	if youfang == True:
		if youche == True:
			if youyanzhi == True:
				if youtili == True:
					print("我嫁给你了~恭喜你")
				else:
					print("你补一点大腰子再过来")
			else:
				print("去韩国整完容在找我")
else:
	print("我给你钱,打车走")




#出题 height
#女生找对象
	# 男生在1米~1.5米之间 小强 你在哪里?
	# 男生在1.5~1.7米之间 没有安全感~
	# 男生 1.7~ 1.8米之间 帅哥 留个电话
	# 男生 1.8~2米之间 帅哥 你建议多一个女朋友吗

# 方法一 python 特有的写法
"""
height = 1.7
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("帅哥 你建议多一个女朋友吗")
"""

# 方法二 通用写法
height = float(  input("请输入您的身高:")  )
# print(height,type(height))
if height >= 1 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("没有匹配的选项")

10. 循环分支

"""
特点:循环可以减少代码冗余,提升效率,便于后期维护

# 语法;
while 条件表达式:
	code1
	code2
	...
如果条件表达式成立,就执行循环体中的代码,反之不执行
"""

# 打印 1~100
# (1)初始化一个变量i
i = 1
# (2)写上循环的判断条件
while i<=100:
	# (4) 写上对应的逻辑
	print(i)
	# (3)自增自减的i值
	i += 1 # i = i + 1

"""
代码解析:
先初始化变量i = 1

# 第一次循环
i = 1 , i <= 100 条件满足,返回True ,执行循环体 print(i) => print(1) i += 1 => i = 2
# 第二次循环
i = 2 , i <= 100 条件满足,返回True ,执行循环体 print(i) => print(2) i += 1 => i = 3
# 第三次循环
i = 3 , i <= 100 条件满足,返回True ,执行循环体 print(i) => print(3) i += 1 => i = 4

....
....
以此类推

当 i = 101 , i <= 100  条件不满足,返回False , 终止循环.
"""

# 计算1~100的累加和
# 方法一
i = 1
total = 0
while i<=100:
	total += i
	i+=1
print(total)

"""
# 代码解析:
# 第一次循环
i=1 i<=100 条件满足,返回True  total += i => total = total + i => total = 0 + 1  , i+=1 => i = 2

# 第二次循环
i=2 i<=100 条件满足,返回True  total += i => total = total + i => total = 0 + 1 + 2  , i+=1 => i = 3

# 第三次循环
i=3 i<=100 条件满足,返回True  total += i => total = total + i => total = 0 + 1 + 2 + 3  , i+=1 => i = 4

...
依次循环

当i = 101的时候  i<=100 条件不满足,返回False ,循环终止
total = 0 + 1 + 2 + 3 + ... + 100
"""

# 死循环
"""
while True:
	print(1)
"""

# 方法二
sign = True
i = 1
total = 0
while sign:
	total += i
	i+=1
	# 手动判断如果i 已经加到了101 ,就意味着循环应该终止了;
	if i == 101:
		sign = False
print(total)

11. 单循环练习

# (1)打印一行十个小星星

# help 查看帮助文档
"""
help(print)
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
"""
# 用while 改写
i = 0
while i<10:
	print("*",end="")
	i+=1

print()

# (2)用变量拼接字符串的形式,打印一行十个小星星
i = 0
strvar = ""
while i<10:
	strvar += "*"
	i+=1
print(strvar)

# (3)打印一行十个小星星 奇数个打印★ 偶数个打印☆
i = 0
while i < 10:
	if i % 2 == 0:
		print("★",end="")
	else:
		print("☆",end="")
	i+=1

print()
# (4)用 一个循环 打印十行十列小星星
"""
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
"""

"""
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
3 % 2 = 1

0 % 3 = 0
1 % 3 = 1
2 % 3 = 2
3 % 3 = 0

0 % 8 = 0
1 % 8 = 1
2 % 8 = 2
3 % 8 = 3
4 % 8 = 4
5 % 8 = 5
6 % 8 = 6
7 % 8 = 7
8 % 8 = 0
9 % 8 = 1
10 % 8 = 2
任意数和n进行取余,余数范围: 0~(n-1)
0123456789
**********
10111213141516171819
* * * * * * * * * * 
20212223242526272829
* * * * * * * * * *
...
90919293949596979899
* * * * * * * * * *
9 ~ 99的时候 要添加换行
"""

i  = 0 
while i<100:
	# 打印星星
	print("*",end="")
	# 打印换行
	if i % 10 == 9:
		print()
	i+=1


# (5)一个循环 打印十行十列隔列变色小星星(一个循环)
"""
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
"""

i  = 0 
while i<100:
	# 打印星星
	if i % 2 == 0:
		print("★",end="")
	else:
		print("☆",end="")
	
	# 打印换行
	if i % 10 == 9:
		print()
	i+=1

# (6)一个循环 打印十行十列隔行变色小星星(一个循环)
"""
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
★★★★★★★★★★
☆☆☆☆☆☆☆☆☆☆
"""

"""
0 // 3 = 0
1 // 3 = 0
2 // 3 = 0
3 // 3 = 1
4 // 3 = 1
5 // 3 = 1
6 // 3 = 2



0 // 5 = 0
1 // 5 = 0
2 // 5 = 0
3 // 5 = 0
4 // 5 = 0

5 // 5 = 1
6 // 5 = 1
7 // 5 = 1
8 // 5 = 1
9 // 5 = 1




任意数和n进行地板除,会出现n个相同的数字


0 // 10 = 0
1 // 10 = 0
2 // 10 = 0
3 // 10 = 0
4 // 10 = 0
5 // 10 = 0
6 // 10 = 0
7 // 10 = 0
8 // 10 = 0
9 // 10 = 0

10 // 10 = 1
11 // 10 = 1
12 // 10 = 1
13 // 10 = 1
14 // 10 = 1
15 // 10 = 1
16 // 10 = 1
17 // 10 = 1
18 // 10 = 1
19 // 10 = 1

20~29 => 10个相同的2
30~39 => 10个相同的3
...
90~99 => 10个相同的9
相同的数字分别从0~9
"""


i  = 0 
while i<100:
	# 打印星星
	if i // 10 % 2 == 0:
		print("★",end="")
	else:
		print("☆",end="")


	# 打印换行
	if i % 10 == 9:
		print()
	i+=1

12. 字符串的相关操作　

# (1)字符串的拼接 +
strvar1 = "我恨你,"
strvar2 = "你为什么不爱我"
res = strvar1 + strvar2
print(res)
# += 
res += "!!!" # res = res  + "!!!"
print(res)

# (2)字符串的重复  * 
strvar = "重要的事情说三遍!"
res = strvar * 3
print(res)

# (3)字符串跨行拼接 
strvar = "sdfsjdfjsdfjshjfdhjsdfjsdfsdfsdfffffffffffffffffffffffffffffffffffffffffffffff" 
"sdfsdf sdfsdfsdfsfdsdfsfsd"
print(strvar)

# (4)字符串的索引
# 正向索引  0 1 2345
strvar =   "我的baby"
# 逆向索引 -6-5-4-3-2-1
print(strvar[3],strvar[-3])

# (5)字符串的切片: 截取
# 语法 => 字符串[::]  完整格式：[开始索引:结束索引:间隔值]
	# (1)[开始索引:]  从开始索引截取到字符串的最后
	# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
	# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
	# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
	# (5)[:]或[::]  截取所有字符串
	

# (1)[开始索引:]  从开始索引截取到字符串的最后
strvar = "如果遇到你是一种错,那我宁愿一错再错"
res = strvar[2:]
print(res)
	
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = strvar[:4]
print(res)
	
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = strvar[11:14] # 我宁愿 11~13
print(res)
	
# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
res = strvar[::2]  # 正向截取
# 0 2 4 6 8 10 12 14 .... 
res = strvar[::-1] # 逆向截取
# -1 -2 -3 -4 -5 -6 -7 ...
print(res)

# (5)[:]或[::]  截取所有字符串
str_new = strvar[:]
str_new = strvar[::]
print(str_new)

13.多循环练习

# (1)打印十行十列小星星 (用两个循环)

j = 0
while j < 10:

	# 打印一行十个小星星 **********
	i = 0
	while i<10:
		print("*",end="")
		i+=1

	# 打印换行 

	print()

	j+=1
	
# (2)打印十行十列隔列换色小星星

# ★☆★☆★☆★☆★☆

j = 0
while j < 10:

	# 打印一行十个小星星 **********
	i = 0
	while i<10:
		if i % 2 == 0:
			print("★",end="")
		else:
			print("☆",end="")
		i+=1

	# 打印换行 

	print()

	j+=1


# (3)打印十行十列隔行换色小星星

j = 0
while j < 10:

	# 打印一行十个小星星 **********
	i = 0
	while i<10:
		if j % 2 == 0:
			print("★",end="")
		else:
			print("☆",end="")
		i+=1

	# 打印换行 

	print()

	j+=1

# (4)99乘法表
# 方向一 (升序 1-9)
i = 1
while i <= 9:	
	# 打印表达式
	j = 1
	while j<=i:
		# print(i,j)
		print("%d*%d=%2d " % (i,j,i*j),end="")
		j+=1
		
	# 打印换行
	print()
	
	i+=1
	
# 方向二 (降序 9-1)
print("<===>")
i = 9
while i >= 1:	

	j = 1
	while j<=i:
		# print(i,j)
		print("%d*%d=%2d " % (i,j,i*j),end="")
		j+=1
		
	print()
	
	i-=1


# (5)100 ~ 999 找吉利数字 111 222 123 321 888 ...
"""
// 地板除可以获取到一个数高位
%  取余可以获取到一个数的低位

789

个位: 789 % 10 => 9
十位: 789 // 10 % 10 => 8
百位: 789 // 100 => 7
"""
# 方法一
i = 100
while i <= 999:

	# 个位
	gewei = i % 10
	# 十位
	shiwei = i // 10  % 10
	# 百位
	baiwei = i // 100
	
	if shiwei == gewei and shiwei == baiwei :
		print(i)
	elif shiwei == gewei - 1 and shiwei == baiwei + 1:
		print(i)
	elif shiwei == gewei + 1 and shiwei == baiwei - 1:
		print(i)

	i+=1

print("<====>")
# 方法二
i = 100
while i<=999:
	# 强转成字符串
	num = str(i)
	# 通过下标获取个十百
	gewei = int( num[-1] )
	shiwei = int(num[-2])
	baiwei = int(num[-3])
	
	if shiwei == gewei and shiwei == baiwei :
		print(i)
	elif shiwei == gewei - 1 and shiwei == baiwei + 1:
		print(i)
	elif shiwei == gewei + 1 and shiwei == baiwei - 1:
		print(i)

	i+=1

14. for 循环

　　遍历数据时使用

"""遍历,循环,迭代是一个意思:把容器里面的每一个元素都重新获取出来"""
"""
# while 循环在遍历数据时,有一定的局限性,for循环应用而生,
	for   循环专门用来遍历数据的
	while 循环一般用于复杂逻辑操作
	
# lst = [1,2,3,4]
lst = {"a","b","c"}
i = 0
while i<len(lst):
	# print(i)
	print(lst[i])
	i+=1
"""
"""
# for 循环语法:
for i in 可迭代性数据
可迭代性数据:(容器类型数据,range对象,迭代器)
"""
# 字符串
container = "你的酒窝没有酒,但是我却醉的一塌糊涂"
# 列表
container = ["猴山","薇薇","刘琦","余建","谢峰","王文"]
# 元组
container = ("猴山","薇薇","刘琦","余建","谢峰","王文")
# 集合
container = {"猴山","薇薇","刘琦","余建","谢峰","王文"}
# 字典  如果是字典,遍历的是字典的键
container = {"czl":"美丽大方","ssy":"老练沉稳","hqx":"抠脚大叔","zjw":"成功人士"}

for i in container:
	print(i)

		
# 变量的解包
a,b = (1,2)
a,b = [3,4]
a,b = {"a","b"}
a,b = {"a1":1,"b1":2}
a,b,c = ("王健林","王思聪","王妈妈")
# print(a,b,c)

# 遍历等长的二级容器
lst = [("王健林","王思聪","王妈妈") , ["马云","麻花藤","马妈妈"],{"王宝强","马蓉","宋小宝"}]
for a,b,c in lst:
	print(a,b,c)

# 遍历不等长的二级容器
lst = [("王健林","王思聪","王妈妈") , ["马云","马妈妈"],{"王宝强"}]
for i in lst:
	for j in i:
		print(j)


# range对象
"""
range(start,end,step)
start 开始索引
end   结束索引
step  步长
结束索引 这个值取不到,取到end这个值之前的那个数据
"""

# range(一个值的情况) 0~9
for i in range(10): 
	print(i)
	
# range(二个值得情况) 2~7
for i in range(2,8):
	print(i)
	
# range(三个值得情况) 1 3 5 7 9 升序
for i in range(1,10,2):
	print(i)
	
# range(三个值得情况) 9 7 5 3 1 降序
for i in range(9,0,-2):
	print(i)