Python进阶
一、判断语言 if/elif/else和循环
单分支
语法
“”"
if 条件:
代码块
1.冒号必须是英文状态下
2.必须要缩进
执行流程图
代码
#input(“请猜一个数字”) —Str
#eval() 把Str转换成int
guess = eval(input("请猜一个数字"))
if guess ==99:
print("恭喜你猜对了") #恭喜你猜对了
二分支
语法
条件:
代码块
else:
代码块
“”"
执行流程图
代码
guess = eval(input("请猜一个数字"))
if guess == 99:
print("恭喜你猜对了")
else:
print("谢谢惠顾")
多分支
语法
“”"
if 条件:
代码块
elif 条件:
代码块
elif 条件:
代码块
…
else:
代码块
“”"
执行流程图
代码
score = eval(input("请输入一个成绩："))
if score >= 90:
print("a")
elif 90 > score>=80:
print("B")
elif 80 >score>=70:
print("C")
elif 70>score>=60:
print("D")
else:
print("不及格")
三目运算符
语法
满足条件的代码块 if 条件 else 不满足条件的代码块
三目运算符，必须是二分支语句
guess =eval(input("请猜一个数字"))
print("恭喜你猜对了")if guess == 99 else print("谢谢惠顾")
for循环
语法
for 变量 in 遍历结构:
代码块
执行流程
用法
字符串遍历
Str = "hello python"
for i in Str:
print(i)
"""
h
e
l
l
o
p
y
t
h
o
n
"""
列表遍历
list01 = ["张三","李四","王五","赵六"]
for i in list01:
print(i)
"""
张三
李四
王五
赵六
"""
普通字典遍历
dict01 = {"天龙八部":"段誉","倚天屠龙记":"张无忌","九阴真经":"周芷若","射雕英雄传":"郭靖"}
#普通遍历
for i in dict01:
print(i)
"""
1.用普通遍历,只能打印key
天龙八部
倚天屠龙记
九阴真经
射雕英雄传
"""
2.字典.items() 返回一个元组(“天龙八部”,“段誉”)
for t in dict01.items():
print(t)
print(type(t))
"""
('天龙八部', '段誉')
<class 'tuple'>
('倚天屠龙记', '张无忌')
<class 'tuple'>
('九阴真经', '周芷若')
<class 'tuple'>
('射雕英雄传', '郭靖')
<class 'tuple'>
"""
Set集合遍历
set01 = {1,2,3,4}
for i in set01:
print(i)
循环(while)
语法
while 条件:
变量改变公式
代码块
代码
a = 10
while a>0:
#变量不断改变，为了满足条件，避免进入死循环
a -= 1
print(a)
'''
9
8
7
6
5
4
3
2
1
0
'''
break和continue的运用
continue结束当次循环，继续执行后续次数循环
break
break跳出并结束当前整个循环，不执行循环后的语句
执行流程图
for i in [1,2,3,4,5]:
if i==2:
break
print(i) #1
continue
执行流程图
for i in [1,2,3,4,5]:
if i==2:
continue
print(i) #1
"""
1
3
4
5
"""
推导式
推导式是从一个或者多个迭代器快速创建序列的一种方法。
语法
[逻辑/结果 for i in 序列类型的变量]
推导式 for的简写
#普通循环
for i in [1,2,3,4]:
print(i)
#推导式
[i for i in [1,2,3,4,5]]
用法
列表类型
"""
推导式
"""
list01 = [1,2,3,4]
a= [i+1 for i in list01]
print(a) #[2, 3, 4, 5]
print(type(a)) #<class 'list'>
元组类型
list01 = [1,2,3,4]
#把里面的代码看成一个整体，一个对象
#利用我们的tuple()函数
a= tuple(i+1 for i in list01)
print(a) #(2, 3, 4, 5)
print(type(a)) #<class 'tuple'>
集合类型
list01 = [1,2,3,4]
a= {i+1 for i in list01}
print(a) #{2, 3, 4, 5}
print(type(a)) #<class 'set'>
字典类型
dict01 = {"王五":20,"张三":50,"李四":80,"赵六":18}
for k,v in dict01.items():
print(k,v)
#推导式
{print(k,v) for k,v in dict01.items()}
二、进阶函数
参数传递
参数传递机制
函数参数传递机制和赋值机制是一样的，其本质就是传递内存地址，这就是引用传递 a传进来的时候传进来的是内存地址
def isid(x):
#打印参数的内存地址
print(id(x))
a = 10
#变量的内存地址
print(id(a)) #140731588047408
#a变成的参数，打印参数内存地址
isid(a) #140731588047408
默认参数
#定义一个带有默认参数的函数
def add(x,y=10):
sum01 = x+y
return sum01
print(add(2)) #12
print(add(2,3)) #5
传参传入一个序列类型，比如list，让他默认是[]
def add(list01 = []):
list01.append(1)
return list01
#第一调用
print(add()) #[1]
#第二次调用
print(add()) #[1, 1]
#第三次调用
print(add()) #[1, 1, 1]
不定数目的参数
一个 *
一个* ：代表的是可变参数（就是可以是多个值）
def add(x,*y):
sum01 = x
for i in y:
sum01 += i
return sum01
print(add(1,2,3,4,5)) #15
两个*
**y代表可以使用任意 键值（字典） 作为参数 **y就相当于字典类型
def func_add(x,**y):
sum01 = x
#切记这里是字典的循环
for k,v in y.items():
print(k,v)
#把v（值）进行和x相加
sum01 += v
return sum01
"""
调用
a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}
"""
print(func_add(1,a=3,b=4,c=5)) #13
高阶函数
#普通函数
def func_pf(x):
return x**2
#高阶函数，以函数为参数
def func_add(func_pf):
#x**2+10
return func_pf+10
#2**2+10
a = func_add(func_pf(2))
print(a) #14
常用的高阶函数
map()
执行流程图
map(fun,x)转换，接受一个序列，按照fun的函数逻辑转换成新的序列， 返回一个map对象
‘’’
def func_add(x):
return x+2
#把原来的数据，经过func_add函数以后，每一个都加1，然后输出新的函数
m = map(func_add,[1,2,3,4,5])
print(m) #<map object at 0x000001F1D11EDFA0> map对象
print(list(m))
#简写
def func_add(x):
return x*2
print(list(map(func_add,[1,2,3,4,5])))
filter()
执行流程图
filter(func,x)过略，接受一个序列x,按照func函数要求进行转换，
func函数返回true或false,最后将返回true的元素放到新列表 ‘’’
‘’’
def func_ifScore(x):
return x >= 60
f = filter(func_ifScore,[80,98,70,34,60,59,10])
print(f) #<filter object at 0x000002865881DFD0>
print(list(f))#[80, 98, 70, 60]
'''
#过滤负数，输出正数
def func_num(x):
return x > 0
print(list(filter(func_num,[1,9,-10,8,3,-2,-6,4])))
#[1, 9, 8, 3, 4]
reduce()
执行流程图
reduce(func,x)计算，接受一个序列，把列表中的每一个值按照函数进行累加或者 别的运算返回一个计算数值
1.因为是计算，所以我们的func是两个参数
2.必须要导包
‘’’
from functools import reduce
def func_add(x,y):
return x+y
'''
y从下标1开始，依次传入
x第一次传入的是下标0的数据，以后每一次传入的是计算的和
'''
a = reduce(func_add,[1,2,3,4,5])
print(a)#15
from functools import reduce
def func_add(x,y):
return x%y
print(reduce(func_add,[80,9,5,2]))#1
zip()
压缩 zip(list01,list02)
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组 返回一个对象
1.参数必须是可迭代的序列类型
2.对象里面放的是一个个元组
3.返回一个zip对象
list01 = [1,3,5,7,9]
list02 = [2,4,6,8,10]
z = zip(list01,list02)
print(z) #<zip object at 0x00000262716FC480>
print(list(z)) #(1, 2)....返回是元组类型
#数据不一样多。以短的为基础。一一对应
list03 = [1,3,5,7,9,11,13]
list04 = [2,4,6]
print(list(zip(list03,list04))) #[(1, 2), (3, 4), (5, 6)]
#解压
'''
1.符号是*
2.zip(*zip对象)
3.声明两个变量去承接
'''
list05,list06 = zip(*list(zip(list03,list04)))
print(list05)
print(list04)
#简写压缩
name = ["张三","李四","王五","赵六","翠花"]
age = [20,30,18,90,80]
print(list(zip(name,age)))
sorted()
sorted(序列类型的对象，key=函数,reverse=Ture/False) 排序
list.sort(reverse=True/False)默认升序，如果等于Ture是降序 区别 一个是函数，一个是方法
‘’’
#list里面可以放任何数据类型
list01 = [{"name":"张三","age":20},
{"name":"李四","age":30},
{"name":"王五","age":18},
{"name":"小明","age":12},]
#按照年龄进行排序
def func_age(list01):
#根据key(age)获取value(年龄)
age01 = list01["age"]
return age01
s = sorted(list01,key=func_age,reverse=False) #升序
print(s)
#[{'name': '小明', 'age': 12}, {'name': '王五', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '李四', 'age': 30}]
小练习
list01 = [{"语文":20,"数学":80,"英语":10,"总分":110},
{"语文":50,"数学":30,"英语":90,"总分":170},
{"语文":80,"数学":90,"英语":90,"总分":260},
{"语文":10,"数学":0,"英语":0,"总分":10},
{"语文":30,"数学":60,"英语":60,"总分":150}]
def func_score(list01):
score01 = list01["总分"]
return score01
t = sorted(list01,key=func_score,reverse=True) #降序
print(t)
#[{'语文': 80, '数学': 90, '英语': 90, '总分': 260}, {'语文': 50, '数学': 30, '英语': 90, '总分': 170}, {'语文': 30, '数学': 60, '英语': 60, '总分': 150}, {'语文': 20, '数学': 80, '英语': 10, '总分': 110}, {'语文': 10, '数学': 0, '英语': 0, '总分': 10}]
函数返回值
def func01(x,y):
return x**y
以函数为返回值进行简化
1.闭包，函数里面的子函数，叫做闭包
#f01 高阶函数
def f01(x):
#f02是f01的子函数，又叫做闭包函数
def f02(y):
return x**y
#把闭包函数返回出来
return f02
'''
调用 1.f = f01(2) f就是f02(y),相当于f=f02(y)
'''
f = f01(2) #意义就是x=2
a = f(3) #意义就是y=3
#a=x**y=2**3=8
print(a)
def f03(x):
def f04(y):
return x//y
return f04
f = f03(10)
print(f(5))
偏函数
简化2 上面的这种只能固定下x,没办法固定y,使用偏函数解决这个bug
偏函数
1.partial(fun,你要固定的那个参数x) 可以固定函数中的多个参数
2.导包 from functools import partial
def func01(x,y=2):
return x**Y
'''
from functools import partial
#func = func01(x,y=2)
func =partial(func01,y=2,x=10)
a = func() #x=3
#a = x**2=3**2=9
print(a) #9
偏函数形式
def f03(x,y):
return x//y
from functools import partial
f04 = partial(f03,x=10,y=2)
print(f04()) #5
lambda表达式
lambda表达式：一行函数 理解为函数的简写
lambda 参数1，参数2，参数n : 逻辑
def func01(x,y):
return x**y
lambda x,y:x**y
函数的递归
递归是指函数在执行过程中调用了本身。简单来说就是自己调用了自己
1.自己调用自己
2.一定要有一个条件，进行退出调用
import time
递归
def num01(x):
if x<=1:
return 1
else:
return num01(x-1) +num01(x-2)
print(num01(5))
非递归,下标从0开始
def num02(x):
#初始化两个变量
a, b = 1,1
#range(5)----->0,1,2,3,4
for i in range(x):
a,b=b ,a+b
return a
print(num02(5))
#perf_counter 以秒为单位进行时间计算
#process_time 以分为单位进行计时间
start01 = time.perf_counter()
num01()
stop01 = time.perf_counter()
print("递归函数的调用时间%s"%(stop01-start01))
#process_time 以秒为单位进行计时间
start02 = time.perf_counter()
num02()
stop02 = time.perf_counter()
print("递归函数的调用时间%s"%(stop02-start02))
三、迭代器和生成器
迭代器
迭代器是一个可以遍历容器的一个对象
- 迭代器返回一个对象
- 那些东西可以进行迭代 容器类型的—list set 字典 字符串
'''
迭代器 list01._iter_() 返回一个迭代器对象
'''
list01 = [1,2,3,4]
a = list01.__iter__()
print(a)
迭代对象的遍历
1.next 不会从头开始，每次从记忆的位置开始
2.for循环不能一直调用
报错StopIteration，没有数据了
我们的next没有办法回头，不会从头开始，他只会从记忆的位置的开始
list01 = [1,2,3,4]
a = list01.__iter__()
for i in a:
print(a.__next__())
print(a.__next__()) #1
print(a.__next__()) #2
print(a.__next__()) #3
print(a.__next__()) #4
print(a.__next__()) #报错
生成器
生成器也是一种迭代器，但是你只能对其迭代一次。
由于生成器是一个返回迭代器的函数 生成器一边循环一边计算
关键字是：yield
普通函数
def func_add01(list01):
list02 = []
for i in list01:
list02.append(i+1)
return list02
生成器
def func_add02(list01):
for i in list01:
yield i+1
四、装饰器
定义
1.装饰器是一个函数
2.装饰器一个 为函数添加新的属性的函数
3.通过闭包对函数添加新的属性
闭包函数：函数的子函数就是闭包函数
语法
1.def func_a() #带有新特征的闭包函数
@def func_a
2.def func_b() #被装饰的函数 相当于func_a(func_b)
def yhouse(q):
#闭包函数
def house():
print("贴瓷砖")
q() #调用下面的函数 def q()
print("隔音棉")
return house
def nhouse(b):
def house():
b()
print("拆除瓷砖")
print("拆除隔音棉")
print("刷粉漆")
return house
@nhouse
@yhouse #自下而上
def q():
print("来看看，就是这三堵墙")
#16-18行相当于 house(q) 调用这个方法
#把q作为参数，传给了装修队这个函数
#一周之后我来验货，来看看墙弄好了没 调用
q()
小练习
def me(b):
#闭包函数
b()
def me01():
print("我没前女友")
print("去找一个富婆")
return me01
def girlfriend(b):
b()
def me01():
print("没法活了")
return me01
@girlfriend
@me #自下而上
def b():
print("你想死吗")
from functools import wraps
def ziji(gaoyuanyuan):
gaoyuanyuan()
def huanxiang():
print("有一个有气质的前女友")
print("找个富婆，有私房钱")
return huanxiang
@ziji
def gaoyuanyuan():
print("我是高圆圆，长得好看，但是脾气不好")
import inspect
#装饰器
def is_root(qx):
#闭包函数，传入name参数
def func(name):
#获取名字name,{key:value}，返回字典类型
inspect_name = inspect.getcallargs(qx,name)
# 判断用户name是不是root
#字典.get(key) 可以根据key获取value
if inspect_name.get("name") == "root":
return qx(name)
elif inspect_name.get("name") == "wyh":
return qx(name)
else:
print("你没有此权限")
return func
@is_root
def qx(name):
#需要name=root,你需要有root权限
print("你拥有此权限")
#调用
qx("wyh")
qx("root")
qx("name")
万能参数
import time
#定义一个装饰器
#1.注意作为参数传递不能使用(n)
def yh(func_fb):
#通过闭包函数，把n给闭包函数
def jssj(*args,**kwargs):
start01 = time.perf_counter()
#问题：参数(func_fb)并没有(n),但是调用的时候需要n这个参数
func_fb(*args,**kwargs)#这里函数调用就可以有参数了
stop01 = time.perf_counter()
print("函数调用的时间是%s"%(stop01-start01))
return jssj
'''
1.通过闭包函数进行传参
2.万能参数:参数可以是任何数据类型，也可以是多个参数
*args,**kwargs
效率的比较
import time
"""
函数递归
"""
def func_fb(n):
if n==0 or n==1:
return 1
else:
return func_fb(n-2)+func_fb(n-1)
"""
非递归
#下标是从0开始的
"""
def func(n):
#初始化两个变量
a,b=1,1
#range(5) ---->0,1,2,3,4
for i in range(n):
a,b=b,a+b
return a
#perf_counter 以秒为单位进行记时间
start01 = time.perf_counter()
func_fb(10)
stop01= time.perf_counter()
print("递归函数的调用时间 %s" %(stop01-start01))
#process_time 以秒为单位进行记时间
start02 = time.perf_counter()
func(10)
stop02= time.perf_counter()
print("非递归函数的调用时间%s"%(stop02-start02))
"""
递归函数的调用时间 5.050000000000193e-05
非递归函数的调用时间7.3000000000017495e-06
递归函数的处理速度快一点
Wraps()
定义
- @wraps(gaoyuanyuan) 保留变量这个函数的所有属性和方法
- from functools import wraps
from functools import wraps
def ziji(gaoyuanyuan):
@wraps(gaoyuanyuan)
def huanxiang():
print("有一个有气质的前女友")
gaoyuanyuan()
print("找个富婆，有私房钱")
return huanxiang
@ziji
def gaoyuanyuan():
print("我是高圆圆，长得好看,但是脾气不好")
五、异常
1.语法：try - except -else
try:
代码块
except <错误的名字(可写可不写)
代码块
......
elae:
代码块
注意:1.try不能单独使用
2.错误的名字(可写可不写)
代码
try:
s = eval(input("请输入一个数字"))
a = 10/s
except ZeroDivisionError:
print("除数不能是0")
else:
print("除数是正常的，运行成功")
2.语法：Try-finally
Try-finally
try:
代码块
finall:
代码块
执行结果：
无论报不报错最终都会执行
代码
#control+c
try:
s = input("请输入内容")
finally:
print("异常退出")
'''
请输入内容Traceback (most recent call last):
File "c:\Users\wyh\Desktop\python文档\Custom function.py", line 658,
in <module>
s = input("请输入内容")
KeyboardInterrupt 用户终端执行
3.语法： raise 异常名称
raise:无力代码是否异常，他会自己触发异常
代码
try:
s = eval(input("请输入一个除数："))
a = 10/s
#无论你的除数等不等于0，他都会报错
raise ZeroDivisionError
except ZeroDivisionError:
#except是异常的时候给出的警告
print("警告：除数不能为0")
常见的异常列表(要求再认)
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| ValueError | 传入无效的参数 |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| KeyError | 映射中没有这个键 |
六、变量作用域
变量的查找顺序 L>E>G>B
定义
L(local) 局部作用域
a = 20
def func():
#把全局的a引用过来
global a
#a是函数中的变量，是局部变量，只能在函数中使用
a = 10 + a
return a
#a是不存在的
print(func())
G(global) 全局作用域
age = 1
def lastyear():
age = 19
def toyear():
#global age
nonlocal age #闭包函数调用
age = age+1
print("今年的年龄",age)
print("去年的年龄",age)
return toyear
#toyear() 返回的是return toyear
toyear = lastyear()
#所以还要调用toyear
toyear()
E(Enclosing) 闭包函数中的作用域
nonlocal :把闭包外的变量引用过来
#刚出生的年龄，是全局变量，意味这谁都是从这个年龄开始的
age = 1
def qunian():
#闭包外的变量，局部变量 4-11能用
age = 19
def jinian():
"""
#把全局变量引用过来，那么就是把age=1引用过来
global age
我们想要引用的是闭包外面的变量
nonlocal :把闭包外的变量引用过来
"""
nonlocal age
#闭包里面的变量 ，局部变量 7-9行能用
age=age +1
print("今年的年龄",age)
print("去年的年龄",age)
return jinian
#qunian()返回的是return jinian
jinian = qunian()
#所以还要调用一下今年这个函数jinian()
jinian()
#今年的年龄 20
B(Built-in) 内建作用域
系统固定模块里面的变量，比如 int, bytearray 等。
比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
扫一扫
293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
