一、操作符
- 操作符：一个特定的符号，用它与其他数据类型连接起来组成一个表达式。常用于条件判断，根据表达式返回True/False采取动作。
1.1 比较操作符
- 比较操作符：比较两边值。
| 操作符 | 描述 | 示例 |
|---|---|---|
| == | 相等，两边值是否相等 | (6 == 6) 结果 True |
| != | 不相等，两边值是否不相等 | (6 != 6) 结果False |
| > | 大于，左边值是否大于右边值 | (8 > 6) 结果True |
| < | 小于，左边值是否小于右边值 | (8 < 6) 结果False |
| >= | 大于等于，左边值是否大于等于右边值 | (6 >= 6) 结果True |
| <= | 小于等于，左边值是否小于等于右边值 | (6 <= 6) 结果True |
1.测试“==”。
2.测试“！=”。
3.测试“>、<”。
4.测试“>= 、<=”。
1.2 逻辑操作符
- 判断条件逻辑。
| 操作符 | 逻辑表达式 | 描述 |
|---|---|---|
| and | x and y | 与，所有的条件都 True结果才为True；只要有一个为False，结果就为False |
| or | x or y | 或，所有的条件只要有一个是True结果就为True |
| not | not x | 非，结果取反 |
1.测试“and、or”。
2.测试“not”。
1.3 成员操作符
- 判断某个元素是否在数据类型里。
| 操作符 | 描述 | 示例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回True，否则返回False | computer = [“主机”,“显示器”,“鼠标”,“键盘”] print(“主机” in computer) 结果True print(“音响” in computer) 结果False |
| not in | 如果在指定的序列中没有找到值返回True，否则返回False | print(“主机” not in computer) 结果False print(“音响” not in computer) 结果True |
1.测试“in”。
2.测试“not in”。
1.4 身份操作符
- 判断两个对象的内存地址标识符id是否相等。
| 操作符 | 描述 |
|---|---|
| is | 判断两个标识符是否引用一个对象 |
| is not | 判断两个标识符是否引用不同对象 |
1.测试“is”。
2.测试“not is”。
二、流程控制
2.1 条件判断
//语法。
if <表达式>:
<代码块>
elif <表达式>:
<代码块>
else:
<代码块>
1.单分支，判断是否成年。
age = int(input("请输入你的年龄: "))
if age > 18:
print("恭喜，你已经成年！")
else:
print("抱歉，你还未成年！")
2.三目表达式写法。
age = int(input("请输入你的年龄: "))
print("恭喜，你已经成年！" if age > 18 else "抱歉，你还未成年！")
3.多分支，根据人的年龄段划分。
age = int(input("请输入你的年龄: "))
if age < 7 :
print("儿童")
elif age >= 7 and age < 17:
print("少年")
elif age >= 18 and age < 40:
print("青年")
elif age >= 41 and age < 48:
print("壮年")
else:
print("老年")
2.2 循环语句
- 循环的作用在于将一段代码重复执行多次。
- Python中实现循环常用有两个语句：for、while
2.2.1 for循环
- 一般用于遍历数据类型的元素进行处理，例如字符串、列表。
//语法.
for <变量> in <序列>:
<代码块>
1.例一，遍历字符串。
s = "123456"
for i in s:
print(i)
2.例二，遍历列表。
computer = ["主机","显示器","鼠标","键盘"]
for i in computer:
print(i,len(i))
3.例三，遍历字典。
computer = {"主机":5000,"显示器":1000,"鼠标":60,"键盘":150}
for i in computer.items():
print(i)
print("名称: %s\t价格: %s" % (i[0],i[1]))
4.例四，嵌套循环。
s1 = "123456"
s2 = "456789"
for i in s1:
for x in s2:
if i == x:
print(i)
2.2.2 while循环
- 在某条件下循环执行一段代码，即重复相同的任务。
//语法。
while <表达式>:
<代码块>
1.示例1，当条件满足时停止循环。
count = 0
while count < 5:
print(count)
count += 1
2.例二，死循环。
count = 0
while True:
print(count)
count += 1
2.3 continue与break语句
- continue 当满足条件时，跳出本次循环。
- break 当满足条件时，跳出所有循环。
- 注意事项：只有在for、while循环语句中才有效。
1.例一，continue语句。
for n in range(8):
if n == 3:
continue
else:
print(n)
2.例二，break。
for n in range(8):
if n == 3:
break
else:
print(n)
3.案例：用户登录，三次错误机会
count = 0
while True:
if count < 3:
name = input("请输入你的用户名: ").strip() # .strip()去除首尾空格
if len(name) == 0:
print("输入不能为空!")
continue
elif name == "qingjun":
print("登录成功.")
break
else:
print("用户名错误，请重新输入!")
count += 1
else:
print("超出错误次数, 退出!")
break
2.4 文件操作函数
- 要想读取文件（如txt、csv等），第一步要用open()内建函数打开文件，它会返回一个文件对象，这个对象拥有read()、write()、close()等方法。
语法：open(file,mode=‘r’,encoding=None)
- file：打开的文件路径，可以是绝对路径，也可以是相对路径。
- mode（可选）：打开文件的模式，如只读、追加、写入等。
- r：只读。
- w：只写。
- a：在原有内容的基础上追加内容（末尾）。
- w+：读写。
- 如果需要以字节（二进制）形式读取文件，只需要在mode值追加‘b’即可，例如wb
- 文件对象操作，f = open(‘test.txt’)
| 方法 | 描述 |
|---|---|
| f.read([size]) | 读取size字节，当未指定或给负值时，读取剩余所有的字节，作为字符串返回 |
| f.readline([size]) | 从文件中读取下一行，作为字符串返回，如果指定size则返回size字节。 |
| f.readlines([size]) | 读取size字节，当未指定或给负值时，读取剩余所有的字节，作为列表返回。 |
| f.write(str) f.flush |
写字符串到文件。 刷新缓冲区到磁盘。 |
| f.seek(offset[,whence=0]) | 在文件中移动指针，从whence 偏移offset个字节。 (0代表文件起始位置，默认。1代表当前位置2代表文件末尾) |
| f.tel() | 当前文件中的位置 (指针) |
| f.close() | 关闭文件 |
1.例一，读取文件内容。
qingjun = open('qingjun.txt',mode='r',encoding=None)
print(qingjun.read())
qingjun.flush()
qingjun.close()
2.例二，遍历打印每一行。
qingjun = open('qingjun.txt',mode='r',encoding=None)
for line in qingjun:
print(line.strip('\n')) # 去掉换行符
qingjun.flush()
qingjun.close()
3.with语句：不管在处理文件过程中是否发生异常，都能保证with 语句执行完毕后已经关闭了打开的文件句柄。
with open("qingjun.txt",encoding="utf8") as f:
data = f.read()
print(data)
三、函数
函数概念：
- 指一段可以直接被另一段程序或代码引用的程序或代码。
- 在编写代码时，常将一些常用的功能模块编写成函数，放在函数库中供公共使用，可减少重复编写程序段和简化代码结构。
3.1 定义函数
语法：
def 函数名称(参数1,参数2,...): <代码块> return <表达式> //reurn是返回的状态值，表示代码执行结果。
1.定义普通函数。
def hello():
print("Hello World!")
hello() # 调用函数
2.定义传参函数，传入固定参数。
##定义求和函数。
def f(a, b):
return a + b
print(f(1,2))# 按参数位置赋值
print(f(b =2,a=1)) # 按对应关系赋值
##生成序列列表。
def qingjun(n):
result = []
x=0
while x < n:
result.append(x)
x +=1
return result
print(qingjun(9))
##参数默认值：预先给参数定义默认值，如果调用函数时没指定该值，则用默认值。
def f(a, b=2):
return a + b
print(f(1))
print(f(1,3))
3.定义传参函数，传入多个未知参数。
- 当不知道有多少个参数时可以在参数前面加*与**，表示可接收任意多个参数。
- *name 接收任意多个参数，并放到一个元组中。
- **name 接收一个键值，并存储为字典。
//传入多个参数，计算总和。
def func(*seq):
x=0
for n in seq:
x += n
return x
print(func(1,2,3))
//传入多个键值，进行处理。
def func(**computer):
for k,v in computer.items():
print("名称:%s\t价格:%s" %(k,v))
func(主机=5000,显示器=1000,鼠标=60,键盘=150)
4.定义匿名函数。
- 匿名函数：没有名字的函数，使用lambda关键字定义，一般仅用于单个表达式。
//定义求和函数。
s = lambda a, b: a+b
print(s(1,2))
//等价于
def func(a,b):
return a+b
print(func(1,2))
3.2 作用域
含义：
- 限制一个变量或一段代码可用范围。好处是提高程序逻辑的局部性，减少名字冲突。
作用域范围：
- Local (局部作用域)：在函数中定义的变量。de关键字定义的语句块中，即函数中定义的变量。
- Enclosed (嵌套作用域)：一般出现在函数中嵌套一个函数时，在外部函数中的作用域称为嵌套作用域 (闭包常见)。
- Global (全局作用域)：文件顶层定义的变量。
- Built-in (内置作用域)：系统内解释器定义的变量，例如关键字。
1.示例。
qingjun1 = 2 ##全局变量。
def baimu(): ##定义函数
global qingjun2 ##将局部变量变成全局变量。
qingjun2 =3 #局部变量。
baimu() ##引用函数。
print(qingjun1) ##打印全局变量。
print(qingjun2) ##打印局部变量。
3.3 闭包
含义：
- 闭包是一个定义在函数内部的函数，闭包使得变量即使脱离了该函数的作用域范围也依然能被访问到。
- 嵌套函数也是闭包的一种形式，将内部嵌套定义的函数作为返回值。
构成闭包的三个条件：
- 两层以上嵌套关系
- 内部函数调用外部函数定义的变量
- 外部函数返回内部函数体对象,而不是函数体结果（加括号）
1.示例。
def qingjun():
x = 1
def baimu():
print(x)
return baimu #不加括号表示返回函数体不执行函数，外部调用时才会执行；加括号代表直接调用执行函数。
qingjun() #调用外部函数。
qingjun()() #调用内部函数。
3.4 函数装饰器
含义：
- 装饰器本质上是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。
应用场景：
- 记录日志、性能测试、权限效验等。
1.例一，原函数无传入参数。
######################################
#定义原函数。
def hello():
print("原函数功能")
hello() #调用原函数。
######################################
#定义装饰器。
def qingjun(mq): #新增函数调用器，传入参数mq，mq也可以是函数。
def baimu():
print("原函数准备执行了！") ##新增功能。
mq() #原函数放在内部函数的执行逻辑里。
print("原函数执行完毕！") ##新增功能。
return baimu #打印内部函数体，外部调用时才执行该函数。
qingjun(hello)() #调用内部函数，同时给外部函数传入函数hello，hello为原函数。
2.例二，语法糖@用法。文章来源：https://www.toymoban.com/news/detail-635480.html
######################################
#定义装饰器。
def qingjun(mq):
def baimu():
print("原函数准备执行了！")
mq()
print("原函数执行完毕！")
return baimu
######################################
#定义原函数时，直接@装饰器调用。
@qingjun
def hello():
print("原函数功能")
hello()
3.例三，原函数传入参数。文章来源地址https://www.toymoban.com/news/detail-635480.html
######################################
#定义装饰器。
def qingjun(mq):
def baimu(u):
print("原函数准备执行了！")
mq(u)
print("原函数执行完毕！")
return baimu
######################################
#定义原函数时，直接@装饰器调用，并传入参数u。
@qingjun
def hello(u):
print(u)
hello("已传入参数")
3.5 内建函数
| 函数 | 作用 | 语法 |
|---|---|---|
| range() | 动态生成数字序列。 | range(1,6)、range(10) |
| open() | 打开、并操作文件。 | open(file,mode=‘r’,encoding=None) |
| map() | 根据提供的函数处理序列中的元素，处理完后返回一个迭代器对象。 | map(function, iterable, …) |
| filter() | 用于过滤序列，过滤掉不符合条件的元素，处理完后返回一个迭代器对象。 | filter(function, iterable) |
| sorted() | 对所有可迭代的对象进行排序操作。 | sorted(iterable, *, key=None, reverse=False) key：指定带有单个参数的函数，用于从interable的每个元素取出比较的键，默认为None（直接比较元素）。 reverse 排序规则，True降序， False升序（默认） |
| reversed() | 返回一个反转的迭代器。 | reversed(seq) |
| join() | 将序列中的元素以指定的字符连接，生成一个新的字符串。 | ‘拼接符’.join(凭借对象) |
| min() | 返回可迭代对象中最小的元素 | qingjun = [1,2,3,4,5,6,7] print(min(qingjun)) |
| max() | 返回可迭代对象中最大的元素 | qingjun = [1,2,3,4,5,6,7] print(max(qingjun)) |
| sum() | 对可迭代对象求和 | qingjun = [1,2,3,4,5,6,7] print(sum(qingjun)) |
| zip() | 对多个可迭代对象创建一个聚合，返回一个元组的迭代器。 | x = [1, 2, 3]，y = [4, 5, 6] qingjun = zip(x, y) print(list(qingjun)) |
| globals() | 字典格式返回当前范围的全局变量 | \ |
| locals() | 字典格式返回当前范围的局部变量 | \ |
到了这里，关于python基础3——流程控制的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
