Learn day2 运算/循环/字符串操作

1.容器类型的强制转换

类型:str list tuple set dict

var1 = "今天天气好晴朗朗"
var2 = ["刘璐","王钊","王华振","罗淞峰"]
var3 = ("刘璐1","王钊1","王华振1","罗淞峰1")
var4 = {"王文贤","庄哲浩","王铁男"}
var5 = {"a":1,"b":2}

# 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.容器管理

2.1 二级容器 
　　作用:外层是一个容器类型数据,里面的元素还是一个容器类型的数据.
　　listvar = [1,2,3,4,5,(6,7,8,0)]

# 二级列表
listvar = [1,2,3,4,[4,5,66]]

# 二级元组
tuplevar = (1,2,3,(4,5,6))

# 二级集合 在集合里面只能放 可哈希数据:Number(int float complex bool) str tuple
setvar = {"a",1,2,(3,4,5)}
print(setvar)
# setvar = {"a",1,2,(3,4,5,[5,6,7])} error 列表不可哈希

# 二级字典
dictvar = {"a":1,"b":{"c":3,"d":4}}

2.2 等长的二级容器
"""
(1) 里面的每一个元素都是容器类型数据
(2) 容器里面放的元素个数等长
"""

lst = [(1,2,3),(4,5,6),(8,9,10)]
tup = (["a","b"],[1,2],(4,5))

2.3 多级容器取值

container = [1,2,3,4,5,(7,8,9,{"a":1,"b":{"c":[888,99,22]}})]
res = container[-1] # res = (7,8,9,{"a":1,"b":{"c":[888,99,22]}})
res2 = res[-1]   # res2 = {"a":1,"b":{"c":[888,99,22]}}
res3 = res2["b"] # {"c":[888,99,22]}
res4 = res3["c"] # res4 = [888,99,22]
res5 = res4[1]   # 99
print(res5)

3.强转字典

"""
需要等长的二级容器,并且元素的总个数是2个;
字符串元素个数只能是2个,多一个都不行,有局限性,不推荐使用
"""

# 外层是列表,里面是列表或者元组或者字符串(不推荐,有局限性)
lst = [["a",1],("b",2),"c3"]
res = dict(lst)
print(res)

# 外层是元组,里面是列表或者元组或者字符串(不推荐,有局限性)
tup = (["c",15],("d","sdfsdfsd"),"f8")
res = dict(tup)
print(res)

# 外层是集合,里面是元组(如果想要表达容器,在集合中只能是元组)
setvar = {("f1",3.44),("e2",3+9j)}
res = dict(setvar)
print(res)

# 外层是元组或者列表,里面是集合,从语法上来看允许,但是违背逻辑,因为集合无序,不推荐使用.
container = [{"a",15}]
res= dict(container)
print(res)

# 把列表的重复数据去掉,可以先转集合,再转列表,缺陷:顺序被打乱.
listvar = ["a","a",1,2,1,"c"]
res = list(set(listvar))
print(res)

C:\Users\G1702543\AppData\Local\Programs\Python\Python35\python.exe G:/周末四期/L002/test.py
{'a': 1, 'b': 2, 'c': '3'}
{'f': '8', 'c': 15, 'd': 'sdfsdfsd'}
{'e2': (3+9j), 'f1': 3.44}
{'a': 15}
['a', 1, 2, 'c']

Process finished with exit code 0

"""
bool() int() float() complex()
str() list() tuple() set() dict()

这些强转的数据类型,在不给参数的情况下,默认返回一个该数据类型的值
这些值可以作为变量的初始化值
"""
res = tuple()
res = dict()
res = set()
res = int()
print(res)

C:\Users\G1702543\AppData\Local\Programs\Python\Python35\python.exe G:/周末四期/L002/test.py
()
{}
set()
0

Process finished with exit code 0

3.运算比较

3.1 算数运算符:  + - * / // % **

var1 = 15
var2 = 7

# +
res = var1 + var2
print(res)

# -
res = var1 - var2
print(res)

# *
res = var1 * var2
print(res)

C:\Users\G1702543\AppData\Local\Programs\Python\Python35\python.exe G:/周末四期/L002/test.py
22
8
105

# / 通过除法得到的数据一定是小数,浮点型,及时除尽,数字后面加上.0表达小数.
res = var1 / var2
res = 6 / 2 # 3.0
print(res)

# // 地板除 得到一个整数
res  = 6 // 2
print(res)

res = var1 // var2
print(res)

# 如果除数或者被除数是一个小数,那么这个结果尾巴带上.0
res = var1 // 7.0
print(res)

# % 取余
res = var1 % var2
res = 13 % 7  # 6
res = -13 % 7 # 1    -6 + 7 = 1
# res = 13 % -7 # -1 6 + (-7) = -1
# res = -13 % -7# -6 把正确的余数算出来,前面带上负号即可.

print(res)

# ** 幂运算
res = 5 ** 3 # 5的3次方
print(res)

3.2 比较运算符:  > < >= <= == != 

"""比较的结果只有2个,要么是真的True,要么是假的False"""
var1 = 15
var2 = 7

# >
res = var1 > var2
print(res)

# < 
res = var1 < var2
print(res)

# >= 满足一个条件为真即可
res = 15 >= 15
print(res)

# <= 满足一个条件为真即可
res = 15 <= 15
print(res)

# == 等于,是在做比较,不是在做赋值,赋值是一个等号
res = var1 == var2
print(res)

# != 不等于
res = var1 != var2
print(res)

C:\Users\G1702543\AppData\Local\Programs\Python\Python35\python.exe G:/周末四期/L002/test.py
True
False
True
True
False
True

# *=
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)

C:\Users\G1702543\AppData\Local\Programs\Python\Python35\python.exe G:/周末四期/L002/test.py
105
15.0
2.0
2.0
128.0

 3.3 成员运算符： in 和 not in

"""判断字符串时,需要是一个连续的片段,才能返回真"""

strvar = "如果遇到你是一种错,那我宁愿一错再错"
res = "你" in strvar
res = "遇到你" in strvar
res = "错,那" in strvar
print(res)

(1) tuple list set

tup = ("吴波","帅乐","毕杨生","刘得元")
res = "刘得元" in tup
print(res)
lst  = ["吴波","帅乐","毕杨生","刘得元","温红杰"]
res = "温红杰" not in lst
print(res)
setvar = {"赖廷","银燕","王成全"}
res = "银燕" not in setvar
print(res)

(2) dict in 或者 not in   判断的是字典的键,不是那个值

dictvar = {"wtn":"成熟稳重","lxh":"大,头大","lsf":"温文尔雅","hh":"哈哈"}
res = "成熟稳重" in dictvar 
print(res) # error
res = "lsf" not in dictvar
print(res)
res = "lxh" in dictvar
print(res)

3.4 身份运算符    is 和 is not (检测两个数据在内存当中是否是同一个值)  

# int  -5 ~ 正无穷
var1 = 6
var2 = 6

# 比较两个变量指向的地址是不是同一个 [比较地址]
res = var1 is var2
print(res)

# 比较两个变量的值是不是相等;    [比较值]
res = var1 == var2
print(res)

# 复数. 在只有虚数的情况下,地址相同
var1 = 6j
var2 = 6j
print(var1 is var2)

# bool 两个值相同,那么地址一样
var1 = False
var2 = True
print(var1 is not var2)

# 容器类型数据 只有空元组和相同的字符串,在值相同情况下,地址是一样的
var1 = ()
var2 = ()
print(var1 is  var2)
var1 = "好"
var2 = "好"
print(var1 is  var2)
var1 = [1,2]
var2 = [1,2]
print(var1 is not var2)

3.5 逻辑运算符   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)

# 逻辑短路 , 后面的代码不走了
"""
(1) True or 表达式
(2) False and 表达式
"""

# (1)
True or print("我短路了么?1")
# (2)
False and print("我短路了么?2")

# 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

 3.6 位运算

# ### (7)位运算符:    & | ~ ^ << >>

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

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

# ^ 按位异或

"""两个值不相同即为真,相同即为假"""
res = var1 ^ var2
print(res)
"""
10011
01111
11100
"""
# << 左移

"""左移是乘  5左移2位相当于 5 * 2的2次幂 = 20"""
res = 5 << 2
print(res)
"""
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

4. 代码块

# ### 代码块 : 以冒号作为开始,用缩进来划分作用域,这个整体是一个代码块
"""
作用域:作用的范围
看似距离相同,不代表是同一个缩进,比如4个空格和1个tab距离也是相同的,但是并不是同一个代码块
1个tab的距离 = 4个空格,在写代码块的时,要么全用4个空格,要么全用1个tab缩进,不要混在一起使用
python 代码要比其他语言更加简洁,对代码的格式有要求.
"""
print(11)
print(22)
print(33)

if 5 == 5:
    print(1)
    print(2)
    print(3)
    # print(4) # IndentationError

if 6 != 6:
    print(5)
                        print(6)

# php 等其他语言用的是{}来包裹代码,表达同一个作用域
"""
# 了解
if(6==6){
    var_dump($a)
                                                                                                                                        var_dump($b)
}
"""

5. 流程控制(单项\双向)

# ### 流程控制
"""
流程:代码执行的过程
流程控制:就是对代码执行的过程进行管控

流程控制的三大结构:
    顺序结构: 代码从上到下,依次执行
    分支结构: 4小类
    循环结构: while , for

分支结构: 关键字 if
    (1)单项分支
    (2)双项分支
    (3)多项分支
    (4)巢状分支
"""

# 单项分支
"""
语法:
    if 条件表达式:
        code1
        code2
        ...
        ...

    如果条件表达式成立,那就是返回真True ,就会执行代码块
    如果条件表达式不成立,那就是返回假False,不执行代码块
"""

guoyimeng = "美女"
guoyimeng = "绿巨人"
if guoyimeng == "美女":
    print("给你买好吃的")
    print("给你买好喝的")
    print("给你买兰蔻")
    print("给你买倩碧")
    print("给你买香奈儿")
    print("给你买LV")
    print("给你买兰博基尼")
    print("给你买包,因为包治百病!")

# 双项分支: (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("抱歉,登录失败")

6.多项巢状

# ### 多项分支
"""
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
# 双项分支
if youqian == True:
    print("我就嫁给你")
else:
    print("你是个好人")

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

# 多项分支
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")

# 巢状分支 (单项分支 双项分支 多项分支的互相嵌套)
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("抱歉,前面就是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("没有符合条件的选项")

7. while循环

# ### 循环结构
"""
特点:可以提升代码执行的效率,减少冗余代码
语法:
while 条件表达式:
    code1...
    code2....
如果条件表达式成立,那就返回True,执行代码块里面的内容
如果条件表达式成立,那就返回False,终止循环.
"""

# 打印1~100;
"""
# (1) 初始化一个变量i
i = 1
# (2) 写一个循环的条件
while i<=100:
    # (3) 写一个自增自减的值
    i+=1
"""
i = 1
while i<=100:
    print(i)
    i+=1 # i = i+1

"""
代码解析:
先初始化变量i等于1
判断1 <= 100 条件为真,返回True,执行循环中的代码块
直接print(1)
让i 自增加1 变成结果2
第一次循环结束 ,回到22 循环判断的条件中

判断2 <= 100 条件为真,返回True,执行循环中的代码块
直接print(2)
让i 自增加1 变成结果3
第二次循环结束 ,回到22 循环判断的条件中

判断3 <= 100 条件为真,返回True,执行循环中的代码块
直接print(3)
让i 自增加1 变成结果4
第三次循环结束 ,回到22 循环判断的条件中

判断4 <= 100 条件为真,返回True,执行循环中的代码块
直接print(4)
让i 自增加1 变成结果5
第四次循环结束 ,回到22 循环判断的条件中

依次类推.. 直到什么时候结束?
当 i = 101 的时候

1 <= 101 条件不成立,返回False ,不执行代码块,直接循环终止;
"""

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

"""
i =1
total = 0 + 1
i+=1 => i = 2
第一次循环结束...

i = 2
total = 0 + 1 + 2
i+=1 => i = 3
第二次循环结束...

i = 3
total = 0 + 1 + 2 + 3
i+=1 => i = 4
第三次循环结束...

.... 依次类推  ,什么时候结束?
当 i = 101
发现 101 <= 100 这个条件为假 那么循环终止
此刻total = 0+1+2+3+4+... .... + 100 = 5050
"""

# 死循环
"""
while True:
    print(1)
"""
# 方法二: 做1~100的累加和
print("<====>")
i = 1
total = 0
sign = True
while sign:
    total += i
    i+=1

    if i == 101:
        sign = False
print(total) # 5050
    

8. 练习--单层循环经典练习

# 1.打印一行十个小星星
# help 查看函数的帮助文档
help(print)
# end="" 默认不换行,在最后一个字符的后面插入空字符取代\n
print("<===>")
"""
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
print("*",end="")
"""
i = 0
while i<10:
    print("*",end="")
    i+=1

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

print(strvar)

# (3)打印一行十个小星星 奇数个打印★ 偶数个打印☆
"""
0 % 2 = 0
1 % 2 = 1
2 % 2 = 0
3 % 2 = 1
4 % 2 = 0
...

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

3 % 3 = 0
4 % 3 = 1
6 % 3 = 2
...

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
.....
1.任意数和n取余 : 值得范围 0~(n-1)
"""
i = 0
while i < 10:
    # 所有的代码写在中间... 下面..

    # 输出星星的代码
    if i % 2 == 0:
        print("★",end="")
    else:
        print("☆",end="")

    i+=1

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

# 如何打印100颗星星?
"""
i = 0
while i<100:
    # 打印星星
    print("*",end="")

    if i % 10 == 9:
        # 打印换行 因为默认end="\n"
        print()
    i+=1
"""
规律:
0123456789  10111213141516171819   20212223242526272829
**********  * * ********           **********          **********************************************************************
            0 1 23456789           0123456789
"""

# (5)一个循环 打印十行十列隔列变色小星星(一个循环)
"""
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
★☆★☆★☆★☆★☆
"""
i = 0
while i<100:
    # 打印星星
    if i % 2 == 0:
        print("★",end="")
    else:
        print("☆",end="")    

    if i % 10 == 9:
        # 打印换行 因为默认end="\n"
        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
7 // 3 = 2
8 // 3 = 2

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

4 // 4 = 1
5 // 4 = 1
6 // 4 = 1
7 // 4 = 1

8 // 4  = 2
9 // 4  = 2
10 // 4 = 2
11 // 4 = 2

12 // 4 = 3
....

2.任意数 和 n进行地板除,会出现n个相同的数字
3.地板除可以获取一个数的高位,取余可以获取一个数的低位
    89 // 10 = 8 (高位)
    89 % 10  = 9 (低位)
"""

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  1在和2取余,余数是1
当i 范围在20~29 // 10 会出现10个相同的2  2在和2取余,余数是0
当i 范围在30~39 // 10 会出现10个相同的3  3在和2取余,余数是1
当i 范围在40~49 // 10 会出现10个相同的4  4在和2取余,余数是0
当i 范围在50~59 // 10 会出现10个相同的5  5在和2取余,余数是1
当i 范围在60~69 // 10 会出现10个相同的6  6在和2取余,余数是0
当i 范围在70~79 // 10 会出现10个相同的7  7在和2取余,余数是1
当i 范围在80~89 // 10 会出现10个相同的8  8在和2取余,余数是0
当i 范围在90~99 // 10 会出现10个相同的9  9在和2取余,余数是1
"""

9.字符串操作

# ### 字符串相关操作
# (1)字符串的拼接 +
res = "我爱你" + "亲爱的菇凉"
print(res)
s1 = "我爱你"
s2 = "亲爱的祖国"
res = s1 + s2
print(res)

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

# (3)字符串跨行拼接 \
strvar = "水电费水电费sdkfjsjdfjksjdfksjdkjskdjfksjdfkjskdf"\
"aaabbbccc"
print(strvar)

# (4)字符串的索引
#          0 1 2 3 4 5 6 7 8  正向索引
strvar = "咱们班的女生特别多"
#         -9-8-7-6-5-4-3-2-1  逆向索引
res = strvar[6]
print(res)
res = strvar[-3]
print(res)

# (5)字符串的切片: 字符串的截取
"""
语法 => 字符串[::]  完整格式：[开始索引:结束索引:间隔值]
    (1)[开始索引:]  从开始索引截取到字符串的最后
    (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
    (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
    (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
    (5)[:]或[::]  截取所有字符串
"""
# listvar = ["王子红","麦秸康","友军表","王铁男","庄泽浩","好舌头","王文多一个字","刘璐","李志华","文招财","陈凤杰"]
strvar = "黑夜给了我黑色的眼睛,我却用它翻白眼"
# (1)[开始索引:]  从开始索引截取到字符串的最后
res = strvar[3:]
print(res)
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = strvar[:8]
print(res)
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = strvar[5:10] # 最大下标10取不到
print(res)
# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符

# 正向获取
res = strvar[::3]
# 0 3 6 9 12 15  黑 了 色 睛 却 翻
print(res)

# 逆向获取
res = strvar[::-1]
#-1 -2 -3 -4 ... 一直到最后
print(res)

10. 双层循环经典

# ### 双层循环练习
# (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:
        # 控制打印星星的花色
        if i % 2 == 0:
            print("★",end="")
        else:
            print("☆",end="")
        i+=1

    # 打印换行
    print()

    j+=1

# (3)打印十行十列隔行换色小星星
"""
外层j动一次,里面i的循环动10次,
外层动的慢,内层动的快
i和j切换即可;
"""
print("<====>")
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乘法表
# 方向一 正序
i = 1
while i<=9:
    # print(i)
    # 内层循环,循环几次完全取决于i
    j = 1
    while j<=i:
        print("%d*%d=%2d " % (i,j,i*j),end="")
        j+=1

    # 打印换行
    print()
    i+=1
# 方向二 倒叙
print("<>=====")
i = 9
while i>0:
    # print(i)
    # 内层循环,循环几次完全取决于i
    j = 1
    while j<=i:
        print("%d*%d=%2d " % (i,j,i*j),end="")
        j+=1

    # 打印换行
    print()
    i-=1

# (5)100 ~ 999 找吉利数字 111 222 123 321 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 == gewei and shiwei == baiwei:
        print(i)

    # 123 456 789
    if shiwei == gewei - 1 and shiwei == baiwei+1:
        print(i)

    # 321 765 876
    if shiwei == gewei + 1 and shiwei == baiwei-1:
        print(i)
    i+=1

14. for循环

# ### for 循环
"""循环 遍历 迭代 这三个名词都是获取每一个数据的意思"""
"""
    for 循环专门用来遍历数据,
    而while循环遍历数据有局限性,无法遍历无序容器数据
    while一般用于复杂的逻辑操作

语法:
    可迭代对象:(容器类型数据,range对象,迭代器)
    for i in 可迭代对象:
        code..
"""

"""
# while 遍历数据的局限性
lst = [1,2,3,4]
lst = {1,2,3,4}
i = 0
while i<len(lst):
    res = lst[i]
    print(res)
    i+=1
"""

# 遍历集合
container = {"树则会","郭一萌","银燕","刘璐","罗淞峰"}

# 遍历列表
container = ["树则会","郭一萌","银燕","刘璐","罗淞峰"]

# 遍历元组
container = ("树则会","郭一萌","银燕","刘璐","罗淞峰")
for i in container:
    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,5,6)
print(a,b,c)
a,b = 7,8
print(a,b)

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,step)
start 开始值
end   结束值 (最大值取不到,取到之前的那个值)
step  步长
"""
# 1.range中只有一个值
for i in range(10):
    print(i)

# 2. range中有二个值
for i in range(1,9):
    print(i)

# 3. range中有三个值 正向值
for i in range(1,15,3):
    # 1 4 7 10 13
    print(i)

print("<=============>")
# 3. range中有三个值 逆向值
for i in range(15,0,-3):
    # 1 4 7 10 13
    print(i)