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:UsersG1702543AppDataLocalProgramsPythonPython35python.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:UsersG1702543AppDataLocalProgramsPythonPython35python.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:UsersG1702543AppDataLocalProgramsPythonPython35python.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:UsersG1702543AppDataLocalProgramsPythonPython35python.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:UsersG1702543AppDataLocalProgramsPythonPython35python.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="" 默认不换行,在最后一个字符的后面插入空字符取代 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=" " 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=" " 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)