目录导航：
1. 容器类型强制转换
2. 二级容器
3. 算数运算符
4. 赋值运算符与成员运算符
5. 身份运算符
6. 位运算符
7. 代码块
8. 流程控制
9. 多项分支
10. 循环分支
11. 单循环练习
12. 字符串的相关操作
13.多循环练习
14. for 循环
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))
外面是一个容器类型数据,里面的元素还是一个容器类型的数据
# 二级列表
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)
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)
# = 赋值运算符
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)
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)
& | ^ << >> ~
# & 按位与
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
以冒号最为开始,用缩进来划分同一个作用域,这个整体叫做代码块
"""作用域：作用的区域"""
"""
一个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)
}
"""
"""
流程:代码执行的过程
流程控制:对代码执行的过程一种管控
三大结构:
(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("登录失败")
"""
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("没有匹配的选项")
""" 特点:循环可以减少代码冗余,提升效率,便于后期维护 # 语法; 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)
# (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
# (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)
# (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
遍历数据时使用
"""遍历,循环,迭代是一个意思:把容器里面的每一个元素都重新获取出来"""
"""
# 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)