Python day13

Python day13

三元表达式

res = "ok" if x > y else "no"
print(res)

列表生成式

没有用列表生成式的时候

l = []
for i in range(10):
    l.append(i)
print(l)

使用了列表生成式

l = [i for i in range(10)]
print(l)

可以极大的简化代码方便，改变了一定的编程习惯

列表推导式

语法
[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

l = [i for i in range(10) if i > 5]
print(l)

names = ["lxx","hxx","wxx","lili"]

names = [name+"_123" for name in names]
print(names)

names = ["lxx","hxx_123","wxx_123","lili"]
names = [name for name in names if name.endswith("sb")]
print(names)

字典生成式

res = {i: i**2 for i in range(5)}
print(res)#{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

items = [("k1",111),("k2",222),("k3",333)]
print({k:v for k,v in items})#{'k1': 111, 'k2': 222, 'k3': 333}

集合生成式

res = {i for i in range(5)}
print(res)#{0, 1, 2, 3, 4}

生成器表达式(生成式)

把列表推导式的[]换成()就是生成器表达式
它的优点是省内存,一次只会产生一个值在内存里

 res = (i for i in range(3))
 print(res)
 print(next(res))
 print(next(res))
 print(next(res))

函数递归

递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用

递归有两个阶段
1.回溯:向下一层一层挖井
2.递推:向上一层一层返回

注意！递归调用一定要在某一层结束

由于调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制默认为1000

当然你也可以手动修改递归最大深度

import sys

sys.getrecursionlimit()#查看递归深度

sys.setrecursionlimit(2000)#修改递归深度

递归的使用案例

nums =[1,[2,[3,[4,[5,[6,[7,[8,[9]]]]]]]]]

def get(l):
    for num in l:
        if type(num) is list:
            get(num)
        else:
            print(num)
get(nums)

python中的递归效率低,且没有尾递归优化,且对递归层级做了限制

使用二分法+递归的方式从一个按照从小到大排列的数字列表中找到指定的数字

nums = [1,3,7,13,23,37,43,57,63,77,91,103,500,700]#一定要按照从小到大的顺序或从大到小
n1 = 64
def get(nums,n1):
    print(nums)
    mid =len(nums)// 2
    if len(nums) == 0:
        print("空了")
        return
    if nums[mid] > n1:
        get(nums[:mid],n1)
    elif nums[mid] < n1:
        get(nums[mid+1:],n1)
    else:
        print(nums[mid])
get(nums,n1)

匿名函数

匿名函数就是没有名字的函数,且是一次性使用，但能随时定义
比如我们现在有一个函数但这个函数可能只要用一次

def num(x,y):
    return x+y

那我们就可以使用匿名函数

res = (lambda x,y:x+y)(1,2)
print(res)

还有一些需要掌握的

#最大
print(max(salaries,key=lambda k:salaries[k]))

#最小
print(min(salaries,key=lambda k:salaries[k]))

#排序,默认从小到大
print(sorted(salaries,key=lambda k:salaries[k]))

#排序,从大到小
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))

这些则是需要了解的

#map
names = ["lxx","hxx","wxx","lili"]
res = map(lambda name:name+"123",names)
print(list(res))

#filter
names = ["lxx_123","hxx","wxx_123","lili"]
res = filter(lambda name:name.endswith("123"),names)
print(list(res))

#reduce
from  functools import reduce
res = reduce(lambda x,y:x+y,[1,2,3])
print(res)
res = reduce(lambda x,y:x+y,["aa","bb","cc"])
print(res)

res = pow(10,2,3)#10**2%3
print(res)

面向过程编程

面向过程编程的核心是"过程"二字，过程就是解决问题的步骤，既先干啥，后干啥。所以基于该思想编写程序的过程就好比设计一条一条流水线
面向过程编程的优点是复杂的问题流程化，进而就简单化，而它的缺点则是牵一发而动全身，拓展性差

面向过程其实是最为实际的一种思考方式，就算是面向对象的方法也是含有面向过程的思想。可以说面向过程是一种基础的方法。它考虑的是实际地实现。一般的面向过程是从上往下步步求精，所以面向过程最重要的是模块化的思想方法。对比面向过程，面向对象的方法主要是把事物给对象化，对象包括属性与行为。当程序规模不是很大时，面向过程的方法还会体现出一种优势。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织。比如拿学生早上起来这件事说明面向过程，粗略的可以将过程拟为：
(1)起床
(2)穿衣
(3)洗脸刷牙
(4)去学校
而这4步就是一步一步地完成，它的顺序很重要，你只需要一个一个地实现就行了。而如果是用面向对象的方法的话，可能就只抽象出一个学生的类，它包括这四个方法，但是具体的顺序就不一定按照原来的顺序。