类型: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.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]   # 99print(res5)

"""
需要等长的二级容器,并且元素的总个数是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.1 算数运算符:  + - * / // % **

var1 = 15
var2 = 7

# +res = var1 + var2print(res)

# -res = var1 - var2print(res)

# *res = var1 * var2print(res)

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

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

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

res = var1 // var2print(res)

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

# % 取余res = var1 % var2res = 13 % 7  # 6res = -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 = 15var2 = 7

# >res = var1 > var2print(res)

# < res = var1 < var2print(res)

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

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

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

# != 不等于res = var1 != var2print(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 * var2print(var1)

# /=var1 /= var2 # var1 = var1 / var2print(var1)

# //=var1 //= var2 # var1 = var1 // var2print(var1)

# %=var1 %= var2 # var1 = var1 % var2print(var1)

# **=var1 **= var2 # var1 = var1 ** var2print(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 strvarres = "遇到你" in strvarres = "错,那" in strvarprint(res)

(1) tuple list set

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

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

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

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

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

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

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

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

# bool 两个值相同,那么地址一样var1 = Falsevar2 = Trueprint(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 Falseprint(res) #Falseres = True and Falseprint(res) #Falseres = True and Trueprint(res) #Trueres = False and Trueprint(res) #False

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

# not 逻辑非 """取反 真变假 假变真"""res = not Trueres = not Falseprint(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 7print(res) #7res = False and 8print(res) #Falseres = True or 99print(res) # Trueres = False or "abc"print(res) #"abc"

# 逻辑运算符优先级"""() > not > and > or如果存在逻辑短路,优先计算短路,比如True or ...... 一定为True"""

res = 5 or 6 and 7   # 5res = (5 or 6) and 7 # 7res = not (5 or 6) and 7 # Falseprint(res)

res = 1>2 and 3<4 or 5>6 and 7>8print(res)# res= False and True or False and False# res= False or False# res = False

 3.6 位运算

# ### (7)位运算符:    & | ~ ^ << >># & 按位与var1 = 19var2 = 15res = var1 & var2print(res)"""100110111100011"""

# | 按位或res = var1 | var2print(res)"""100110111111111"""

# ^ 按位异或

"""两个值不相同即为真,相同即为假"""res = var1 ^ var2print(res)"""100110111111100"""# << 左移

"""左移是乘  5左移2位相当于 5 * 2的2次幂 = 20"""res = 5 << 2print(res)"""0000 ... 1010000 . 10100"""# >> 右移

"""右移是除  5右移1位相当于 5 // 2的1次幂 = 2"""res = 5 >> 1print(res)"""0000 ... 1010000 ... 010"""

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

"""总结:所有运算符优先级;一元运算符: 同一时间,操作一个数据的 (~ -)二元运算符: 同一时间,操作两个数据的 (+ - * / ...)

一般情况下 , 一元运算符 优先级大于 二元运算符-3 + 5 =  2

例外:所有运算符优先级最高的 ** 幂运算  ~2**2所有运算符优先级最低的 = 赋值运算符

同等级运算符优先级:() > not > and > or乘除 > 加减(<< >>) > & > ^ > |

除此之外,大体优先级高低:算术运算符 > 位运算符  > 比较运算符 > 身份运算符 > 成员运算符 > 逻辑运算符赋值运算符 单独列出来 用于把右侧的值算完之后收尾."""

res = ~2**2print(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 => Trueprint(res) #True

# 加上括号提升优先级 让别人也能看懂res = (5+5) << (6//3) is 40 and True

# ### 代码块 : 以冒号作为开始,用缩进来划分作用域,这个整体是一个代码块
"""
作用域:作用的范围
看似距离相同,不代表是同一个缩进,比如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) # IndentationErrorif 6 != 6:print(5)print(6)# php 等其他语言用的是{}来包裹代码,表达同一个作用域
"""
# 了解
if(6==6){var_dump($a)var_dump($b)
}
"""

# ### 流程控制
"""
流程:代码执行的过程
流程控制:就是对代码执行的过程进行管控流程控制的三大结构:顺序结构: 代码从上到下,依次执行分支结构: 4小类循环结构: while , for分支结构: 关键字 if(1)单项分支(2)双项分支(3)多项分支(4)巢状分支
"""# 单项分支
"""
语法: if 条件表达式:code1code2......如果条件表达式成立,那就是返回真True ,就会执行代码块如果条件表达式不成立,那就是返回假False,不执行代码块
"""guoyimeng = "美女"
guoyimeng = "绿巨人"
if guoyimeng == "美女":print("给你买好吃的")print("给你买好喝的")print("给你买兰蔻")print("给你买倩碧")print("给你买香奈儿")print("给你买LV")print("给你买兰博基尼")print("给你买包,因为包治百病!")# 双项分支: (2个当中选一个)
"""
if 条件表达式:code1code2..
else:code3code4...如果条件表达式为真,那就是返回真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("抱歉,登录失败")

# ### 多项分支
"""
if 条件表达式1:code1code2
elif 条件表达式2:code3code4...
elif 条件表达式3:code5code6...
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 = Trueif 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("没有符合条件的选项")

# ### 循环结构
"""
特点:可以提升代码执行的效率,减少冗余代码
语法:
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+totali+=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 += ii+=1if i == 101:sign = False
print(total) # 5050

# 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+=1print("<===============>")
# 2.用变量拼接字符串的形式,打印一行十个小星星
i = 0
strvar = ""
while i<10:strvar += "*" # strvar = strvar + "*"i+=1print(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 = 23 % 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 = 03 // 3 = 1
4 // 3 = 1
5 // 3 = 16 // 3 = 2
7 // 3 = 2
8 // 3 = 20 // 4 = 0
1 // 4 = 0
2 // 4 = 0
3 // 4 = 04 // 4 = 1
5 // 4 = 1
6 // 4 = 1
7 // 4 = 18 // 4  = 2
9 // 4  = 2
10 // 4 = 2
11 // 4 = 212 // 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
"""

# ### 字符串相关操作
# (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)

# ### 双层循环练习
# (1)打印十行十列小星星 (用两个循环)# 打印一行十个小星星
# i = 0
# while i<10:# print("*",end="")# i+=1# 针对于一行十个星星,循环10次即可
j =  0  # j来控制行数 一共10行
while j<10:# 在这个地方写你自己的逻辑# 里层循环控制打印一行十个星星i = 0while i<10:print("*",end="")i+=1# 在打印完一行之后,打印换行;print()j+=1print("<====>")
# (2)打印十行十列隔列换色小星星

j = 0
while j<10:# 打印星星i = 0while 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 = 0while 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)# 内层循环,循环几次完全取决于ij = 1while j<=i:print("%d*%d=%2d " % (i,j,i*j),end="")j+=1# 打印换行print()i+=1
# 方向二 倒叙
print("<>=====")
i = 9
while i>0:# print(i)# 内层循环,循环几次完全取决于ij = 1while 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 % 10gewei = i % 10# 三个相同的数字if shiwei == gewei and shiwei == baiwei:print(i)# 123 456 789if shiwei == gewei - 1 and shiwei == baiwei+1:print(i)# 321 765 876if shiwei == gewei + 1 and shiwei == baiwei-1:print(i)i+=1

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