python 公式推导 python推导函数

一.推导式：

1.列表推导式

1.1[变量（加工后的变量） for 变量i in 可迭代数据类型]

显示出“python1期”

1.1.1for 循环
li=[]
for i in range(1,11):
    li.append("python%d期"%i)
print(li)
#1.1.2.列表推导式
li=["python%d期"%i for i in range(1,11)]  #['python1期', 'python2期', 'python3期
print(li)
#1.1.3.生成器
li=("python%d期"%i for i in range(1,11))  #<generator object <genexpr>
print(li)

1.2.筛选模式：[变量（加工后的变量） for 变量i in 可迭代数据类型 if 条件]

选出30以内能被3整除的数
multiples = [i for i in range(30) if i % 3 ==0]
print(multiples)
找到嵌套列表中名字含有两个‘e’的所有名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

print([name for lst in names for name in lst if name.count('e') >= 2])

1.3列表推导式和生成器：

列表推导式比较直观，但占内存
生成器不容易看出内容，节省内存

2.字典推导式：

将一个字典的key和value对调
mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency)
合并大小写对应的value值，将k统一成小写
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
print(mcase_frequency)

3.集合推导式：

计算列表中每个值的平方，自带去重功能
squared = {x**2 for x in [1, -1, 2]}
print(squared)

二.内置函数:python为我们提供了68个内置函数

1.数据类型类：int() bool() str() list() tuple() dic() set()
2.input() print()
print("666" end="") 不换行输出。python中默认换行输出
print("666",sep="|") 连接符
print("666",file=f) 打开一个文件，将内容写入里面）

print(1, 2, 3, 4, 5, sep='|')
for i in range(5):
    print(i,end=" ")   #0 1 2 3 4
for i in range(5):
    print(i, end="| ")    #0| 1| 2| 3| 4|

3.dir() 查找对象方法
4.locals() 将局部的变量储存起来  globals() 将全局的变量,函数名,等等 储存起来
5.help()  将查询对象所有信息拿出来
6.abs（）取绝对值
7.max（1,-5,4,key=abs） 求最大值  min（）求最小值  sum（[1,2,3],10)求和 10相当于初始值
8.canable()  判断此变量是否为函数名
9.id()
10.hash() 通过哈希表的规则,将对象转换成哈希值
11.all()  可迭代对象里面的所有的值转化成bool值如果都是True则,返回True
print(all([1,2,5]))  #True
print(all([0,2,5]))   #False
12.bin() 十进制转换成二进制 oct（） 转换成八进制 hex（）转换成16进制
13.float() 浮点型数据类型 有限小数，无线循环小数，不包括（无线不循环）
print(float(3))  #3.0
14.divmod() 求商和余数，放到元组里
print(divmod(8,2),divmod(7,3))  #(4, 0) (2, 1)
15.enumerate（） 枚举与for连用 自动添加索引
l=["手机","电脑","键盘"]

for i in enumerate(l):
    print(i)              #(0, '手机')  (1, '电脑')  (2, '键盘')
l=["手机","电脑","键盘"]
for i, j in enumerate(l):
    print(i,j)            #0 手机  1 电脑  2 键盘
l=["手机","电脑","键盘"]
for i, j in enumerate(l,100):   #设置起始值为100
    print(i,j)             #100 手机 101 电脑 102 键盘

16.eval（) 去除字符串的引号，有返回值
   exec() 去除字符串的引号，放的是流程

li="{'name':'jerd','age':18}"
print(eval（li))          #{'name': 'jerd', 'age': 18}
print(exec(li))          #None
code='''
for i in range(5):
    print(i)
    '''
print(eval（code))  #SyntaxError: invalid syntax 语法错误。不支持流程
print(exec(code)) #0 1 2 3 4 None

 max()的补充：

dic={3:20,2:30,5:100}
def func(x) :return x
print(max(dic,key=func))  #5
dic={3:20,2:30,5:10}
def func(x) :
    return dic[x]
print(max(dic,key=func))  #2  比较的是value值

1.ord 输入字符,返回unicode对应的编码位置

print(ord("中"))  #20013

2.chr 输入编码位置,返回unicode对应的字符

print(chr(20013))  #中

3.ascii 字符在ascii中会显示出来，不在就返回\

print(ascii("a"))  #'a'
print(ascii("中"))  #'\u4e2d'

4.%r在字符串里加字符串 repr原形毕露

name="jerd%r"%('bv')  #jerd'bv'
print(name)
print(repr("[1,2]"))  #'[1,2]'

5.slice() 切片规则

sl = slice(1,4,2)  #等同于s1[1:4:2]

6.reversed() 形成一个新的迭代器.

li=[1,2,3]
l2=reversed(li)
print(l2)   #<list_reverseiterator object at 0x0000023027E4B240>

重要的内置函数

#1.和对应的迭代对象匹配
li=["name","age"]
li1=["jerd",18]
#print(zip(li,li1))  #<zip object at 0x000001BDB8C0CB08> 是迭代器  只能通过for或next取值
for i in zip(li,li1):
       print(i)  #('name', 'jerd')  ('age', 18)    #print(list(i))
#2.迭代对象的个数不一一对应时，匹配最少的
li=["name","age","hobby"]
li1=["jerd",18]
for i in zip(li,li1):
       print(i)   #('name', 'jerd')  ('age', 18)
li=["name","age"]
li1=["jerd",18,"hobby"]
for i in zip(li,li1):
       print(i)             #('name', 'jerd')  ('age', 18)
#3.多个迭代对象进行匹配时
li=["name","age","high"]
li1=["jerd",18,"hobby"]
li2=["sd",15]
for i in zip(li,li1,li2):
       print(i)       #('name', 'jerd', 'sd') ('age', 18, 15)
'''
#2.map(func, *iterables)) 可迭代对象的元素，一个一个传给函数
'''
def func(x):return x**2
#print(map(func,[1,2,3]))   #<map object at 0x000001DDE2A37438>
for i in map(func,[1,2,3]):
    print(i)               #1,4,9
'''
#3.filter(function or None, iterable)过滤
#1.第一个参数为None
for i in filter( None,[1,2,3]):
    print(i)                      #1 2 3
#2.第一个参数为func。把可迭代对象里的元素一个一个传递给函数，满足函数中内容的就取出来
def func(x):
    return x %2==0
for i in filter(func,[0,1,2,4]):
    print(i,type(i))                 #0,2,4   'int'
#用列表推导式：
li=[0,1,2,4]
print([i for i in li if i % 2==0 ])  #[0, 2, 4]
#用列表推导式和filter过滤的不同
'''
1.列表推导式返回列表，占内存
2.filter（）返回迭代器，省内存
3.能与别的函数结合
'''
#3.sorted((*args, **kwargs)  排序 返回的是列表
li=[5,2,3]
print(sorted(li))  #[2, 3, 5]
#根据字符串长度进行排序
#1.使用sorted（） 会形成新的列表，排序必须是列表
l = ['fsdafsa','fddsaf','qqq','fgasjdlg;dsjfg']
def func(x):return len(x)
print(sorted(l,key=func))  #l = ['fsdafsa','fddsaf','qqq','fgasjdlg;dsjfg']
#2.使用sort  是对原列表进行排序
l.sort(key=func)
print(l)  #['qqq', 'fddsaf', 'fsdafsa', 'fgasjdlg;dsjfg']
#3.所有排序方法中，sorted的效率是最高的。它使用c代码编写的
#5.都是带key的:zip max min map filter 返回的是迭代器 sorted 返回的是列表
#方法中key都是函数名

二.编码知识补充：编码 encode（'utf-8') 解码 decode（'utf-8'）

将bytes类型的utf-8编码方式转变成bytes类型gbk编码方式
s='中国'.encode('utf-8')   #b'\xe4\xb8\xad\xe5\x9b\xbd'
print(s)
s=s.decode("utf-8").encode('gbk')
print(s)   #b'\xd6\xd0\xb9\xfa'

三.匿名函数

1.func=lambda x:x
2. func为函数名  lambda为关键字  第一个x为形参 第二个x为返回值 等同于def func(x):return x

面试题：
#1.现在有两元祖(('a'),('b'))，(('c'),('d'))，请使用python 中的匿名函数生成列表[{'a':'c'},{'b':'d'}]
func=lambda x,y :[{x[0]:y[0]},{x[1]:y[1]}]
tu1=(('a'),('b'))
tu2=(('c'),('d'))
print(func(tu1,tu2))  #[{'a': 'c'}, {'b': 'd'}]
#注意('a')没有逗号，不是元组。类型为字符串 如果当成元组会写成func=lambda x,y :[{x[0][0]:y[0][0]},{x[1][0]:y[1][0]}]
#2.现在有两元祖(('a',),('b',))，(('c',),('d',))，请使用python 中的匿名函数生成列表[{'a':'c'},{'b':'d'}]
func=lambda x,y :[{x[0][0]:y[0][0]},{x[1][0]:y[1][0]}]
tu1=(('a'),('b'))
tu2=(('c'),('d'))
print(func(tu1,tu2))