一、操作符

• 操作符：一个特定的符号，用它与其他数据类型连接起来组成一个表达式。常用于条件判断，根据表达式返回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.例二，语法糖@用法。

######################################
#定义装饰器。
def qingjun(mq):
    def baimu():
        print("原函数准备执行了！")
        mq()
        print("原函数执行完毕！")
    return baimu
######################################
#定义原函数时，直接@装饰器调用。
@qingjun
def hello():
    print("原函数功能")
hello()

3.例三，原函数传入参数。

######################################
#定义装饰器。
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()	字典格式返回当前范围的局部变量	\