python3--列表推导式，生成器表达式，内置函数

发布时间：2018-04-06 15:43:55编辑：Run阅读（3510）

python列表推导式

l = [i for i in range(10)]
print(l)
ll = ['选择{}'.format(i) for i in range(1,5)]
print(ll)

执行结果






生成器表达式

1，把列表解析的[]换成()得到的就是生成器表达式

2，列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

3，python不但使用迭代器协议，让for循环变得更加通用，大部分内置函数，也是使用迭代器协议访问对象的，例如sum函数是python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和

求1到3的x的2次方的和

print(sum(x ** 2 for x in range(4)))

执行结果14




各种推导式玩法

推导式套路

之前已经学习了最简单的列表推导式和生成器表达式，但是除此之外，其实还有字典推导式，集合推导式等等

下面是一个以列表推导式为例的推导式详细格式，同样适用于其他推导式

variable = [out_exp_res for out_exp in input_list if out_exp == 2]
out_exp_res: 列表生产元素表达式，可以是有返回值的函数
for out_exp in input_list: 迭代input_list将out_exp传入out_exp_res表达式中
if out_exp == 2 根据条件过滤哪些值可以




列表推导式

例1：30以内所有能被3整除的数

s1 = [i for i in range(30) if i % 3 == 0]
print(s1)

执行结果

[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]




例2：30以内所有能被3整除的数的平方

s1 = [i**2 for i in range(30) if i % 3 == 0]
print(s1)

执行结果

[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]




例3：找到嵌套列表中名字含有两个'e'的所有名字

names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
         ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]

s2 = [i for i in names for i in i if i.count('e') == 2]
print(s2)

执行结果


['Jefferson', 'Wesley', 'Steven', 'Jennifer']




字典推导式

例1：将一个字典的key和value对调

mcase = {'a': 10, 'b': 34}
s2 = {mcase[k]: k for k in mcase}
print(s2)

执行结果


{10: 'a', 34: 'b'}




例2：合并大小写对应的value值，将k统一成小写

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
s2 = {k.lower(): mcase.get(k.lower(),  0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
print(s2)

执行结果


{'a': 17, 'z': 3, 'b': 34}




集合推导式

例1：计算列表中每个值的平方，自带去重功能

s2 = {x**2 for x in [1,-1,2]}
print(s2)

执行结果

{1, 4}




练习题：

例1：过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

s1 = ['asd', 'aaa', 'abcd', 'dhuifw']
s2 = [i.upper() for i in s1 if len(i) > 3]
print(s2)

执行结果


['ABCD', 'DHUIFW']




例2：求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元组列表







例3：求M中3,6,9组成的列表M=[[1,2,3],[4,5,6],[7,8,9]]

M = [[1,2,3],[4,5,6],[7,8,9]]
s1 = [i[-1] for i in M]
print(s1)

执行结果

[3, 6, 9]




内置函数






什么是内置函数？就是python给你提供的，拿来直接用的函数，比如print，input等等，截止到python版本3.6，现在python一共为我们提供了68个内置函数，它们就是python提供给你直接可以拿来使用的函数









1 作用域相关

locals:函数会以字典的类型返回当前位置的全部局部变量

globals:函数以字典的类型返回全部全局变量

例子

a = 1
b = 2
def func(*argv):
    c = 2
    print(locals())
    print(globals())
func(3)

执行结果







2：其它相关

字符串类型代码的执行eval,exec,complie


eval:执行字符串类型的代码，并返回最终结果


例1

print(eval('2 + 2'))
n = 81
print(eval("n + 4"))
eval('print(666)')

执行结果


4

85

666




exec:执行字符串类型的代码

s = '''
for i in [1,2,3]:
    print(i)
'''
exec(s)

执行结果


1

2

3




compile:将字符串类型的代码编译，代码对象能够通过exec语句来执行或者eval()进行求值

code1 = 'for i in range(0,10):print(i)'
compile1 = compile(code1, '', 'exec')
exec(compile1)

执行结果


1,2，3,4,5,6,7,8,9


有返回值的字符串形式的代码用eval,没有返回值的字符串形式的代码用exec,一般不用compile





输入输出相关input,print

input:函数接收一个标准输入数据，返回为string类型

print:打印输出

''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """'''
print(111,222,333,sep='*')
print(111, end='')  # 两行的结果
print(222)
f = open('log','w',encoding='utf-8')
print('写入文件',file=f,flush=True)

执行结果






内存相关hash ,id

hash：获取一个对象(和哈希对象:int,str,bool,tuple)的哈希值

print(hash(123))
print(hash('123'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

执行结果


123

-1089558323302803215

1

0

2528502973977326415




id：用于获取对象的内存地址

print(id(123))
print(id('123'))

1679778400

2709492781664




文件操作相关

open：函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写




模块相关

__import__: 函数用于动态加载类和函数




帮助

help：函数用于查看函数或模块用途的详细说明

print(help(list))






调用相关

callable：函数用于检查一个对象是否可调用，如果返回True,object仍然可能调用失败，但如果返回为False,调用对象object绝对不会成功

print(callable(0))
print(callable('hello'))

def add(a,b):
    return a + b
print(callable(add))

class A:  # 类
    def test(self):
        return 0
print(callable(A))  # 类返回True
a = A()
print(callable(a))  # 没有实现__call__,返回False

执行结果


False

False

True

True

False




查看内置属性

dir: 函数不带参数时，返回当前范围内的变量，方法和定义的类型列表：带参数时，返回参数的属性，方法列表。如果参数包含方法__dir__(),该方法将被调用，如果参数不包含__dir__(),该方法将最大限度收集参数信息

print(dir([])) #查看列表的方法






迭代器生成器相关

range:函数可以创建一个整数对象，一般用在for循环中

next：内部实际使用了__next__方法，返回迭代器的下一个项目

it = iter([1,2,3,4,5])
#循环
while True:
    try:
        #获取一下个值
        x = next(it)
        print(x)
    except StopIteration:
        #遇到StopIteration就退出循环
        break

执行结果

1

2

3

4

5

iter: 函数用来生成迭代器(将一个可迭代对象生成迭代器)

from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable))  # True
print(isinstance(l,Iterator))  # False
l1 = iter(l)
print(isinstance(l1,Iterable))  # True
print(isinstance(l1,Iterator))  # True

执行结果


True

False

True

True




基础数据类型相关

数字相关


数据类型

bool: 用于将给定参数转换为布尔类型，如果没有参数，返回False

int: 函数用于将一个字符串或数字转换为整型

print(int())
print(int('12'))
print(int(3.6))
print(int('0100',base=2)) #将2进制的0100转化成十进制，结果为4

执行结果为


0

12

3

4




float:函数用于将整数和字符串转换成浮点数




complex:函数用于创建一个值为real + imag*j的复数或者转化一个字符串为复数，如果第一个参数为字符串，则不需要指定第二个参数

print(complex(1,2))
print(complex(1))
#注意，这个地方在'+'号两边不能有空格，也就是不能写成'1 + 2j',否则报错
print(complex('1+2j'))

执行结果


(1+2j)

(1+0j)

(1+2j)




进制转换


bin：将十进制转换成二进制并返回

oct：将十进制转化成八进制字符串并返回

hex：将十进制转化成十六进制字符串并返回

print(bin(10),type(bin(10)))
print(oct(10),type(oct(10)))
print(hex(10),type(hex(10)))

执行结果


0b1010

0o12

0xa




数学运算

abs：函数返回数字的绝对值

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a//b,a%b)

round: 保留浮点数的小数位数，默认保留整数

pow：求x**y次幂（三个参数为x**y的结果对z取余)

print(abs(-5))
print(divmod(7,2))
print(round(7/3,2))
print(round(7/3))
print(round(3.32567,3))
print(pow(2,3)) #两个参数为2**3次幂
print(pow(2,3,3)) #三个参数为2**3次幂，对3取余

执行结果

5

(3, 1)

2.33

2

3.326

8

2




sum：对可迭代对象进行求和计算（可设置初始值）

min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）

max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）

print(sum([1,2,3]))
print(sum([1,2,3],100))
print(min([1,2,3])) #返回最小值
ret = min([1,2,-5,],key=abs) #按照绝对值的大小，返回此序列最小值
print(ret)
dic = {'a':3,'b':3,'c':1}

# x为dic的key，lambda的返回值(即dic的值进行比较)返回最小的值对应的键
print(min(dic, key=lambda x:dic[x]))

print(max([1,2,3])) #返回此序列最大值
ret1 = max([1,2,-5],key=abs) #返回绝对值的大小，返回此序列最大值
print(ret1)

dic1 = {'a':3,'b':2,'c':1}
# x为dic的key，lambda的返回值（即dic的值进行比较），返回最大的值对应的键
print(max(dic,key=lambda x:dic[x]))

执行结果


6

106

1

1

c

3

-5

a




和数据结构相关

列表和元组

    list：将一个可迭代对象转化成列表(如果是字典，默认将key作为列表的元素)

    tuple：将一个可迭代对象转化成元组(如果是字典，默认将key作为元组的元素)

例子


l = list((1,2,3))
print(l)
l1 = list({1,2,3})
print(l1)
l2 = list({'k1':1,'k2':2})
print(l2)
tu = tuple([1,2,3])
print(tu)
tu1 = tuple((1,2,3))
print(tu1)
tu2 = tuple({'k1':1,'k2':2})
print(tu2)

执行结果


[1, 2, 3]

[1, 2, 3]

['k1', 'k2']

(1, 2, 3)

(1, 2, 3)

('k1', 'k2')




相关内置函数

    reversed:将一个列表翻转，并返回此翻转序列的迭代器

    slice:构造一个切片对象，用于列表的切片

例子

ite = reversed(['a','2',3,'c',4,2])
for i in ite:
    print(i)

li = ['a','b','c','d','e']
sli_obj = slice(3)
print(li[sli_obj])
sli_obj = slice(0,4,2)
print(li[sli_obj])

执行结果


2

4

c

3

2

a

['a', 'b', 'c']

['a', 'c']




字符串相关

    str：将数据转化成字符串

    format：与具体数据相关，用于计算各种小数，精数等

例子

print(format('test','20'))
print(format('test','^20'))
s1 = format(3, 'b')  # 转换成二进制
s2 = format(97, 'c')  # 转换成unicode字符
s3 = format(11, 'd')  # 转化成10进制
s4 = format(11, 'o')  # 转换成8进制
s5 = format(11, 'x')  # 转换成16进制 小写字母表示
s6 = format(11, 'X')  # 转换成16进制 大写字母表示
print(s1)
print(s2)
print(s3)
print(s4)
print(s5)
print(s6)

执行结果

test                

                test

        test        

11

a

11

13

b

B




bytes: 用于不同编码之间的转化

s = '你好'
bs = s.encode('utf-8')
print(bs)
s1 = bs.decode('utf-8')
print(s1)
bs = bytes(s, encoding='utf-8')
print(bs)
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))

执行结果

b'\xe4\xbd\xa0\xe5\xa5\xbd'

你好

b'\xe4\xbd\xa0\xe5\xa5\xbd'

b'\xe4\xbd\xa0\xe5\xa5\xbd'




bytearry:返回一个新字节数组，这个数组里的元素是可变的，并且每个元素的值范围 0 <= x < 256

ret = bytearray('sam', encoding='utf-8')
print(id(ret))
print(ret)
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))

执行结果







memoryview

ret = memoryview(bytes('你好', encoding='utf-8'))
print(len(ret))
print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))

执行结果

6

<memory at 0x0000018F0BC4D1C8>

你

好




ord:输入字符找该字符编码的位置

chr:输入位置数字找出其对应的字符

ascii:是ascii码中的返回该值，不是就返回/u

# ord 输入字符找该字符编码的位置
print(ord('a'))
print(ord('中'))

# chr 输入位置数字找出其对应的字符
print(chr(97))
print(chr(20013))

# 是ascii码中的返回该值，不是就返回/u
print(ascii('a'))
print(ascii('中国'))

执行结果


97

20013

a

中

'a'

'\u4e2d\u56fd'




repr:返回一个对象的string形式（原形毕露）

# %r 原封不动的写出来
name = 'sam'
print('我叫{}'.format(name))

# repr原形毕露
print(repr('{"name": "sam"}'))
print('{"name": "sam"}')

执行结果


我叫sam

'{"name": "sam"}'

{"name": "sam"}




数据集合

dict:创建一个字典

set:创建一个集合

frozenset:返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

len:返回一个对象中元素的个数

sorted:对所有可迭代的对象进行排序操作

L = [('a', 1), ('c', 3), ('d', 4), ('b', 2),]
print(sorted(L, key=lambda x:x[1])) # 利用key

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students, key=lambda s: s[2]))  # 利用key按年龄排序

print(sorted(students, key=lambda s: s[2], reverse=True))  # 按降序

执行结果


[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]




enumerate:枚举，返回一个枚举对象

print(enumerate([1,2,3]))
for i in enumerate([1,2,3]):
    print(i)
for i in enumerate([1,2,3],100):
    print(i)

执行结果


<enumerate object at 0x0000029F8542E8B8>

(0, 1)

(1, 2)

(2, 3)

(100, 1)

(101, 2)

(102, 3)




all:可迭代对象中，全部都是True才是True

any:可迭代对象中，有一个True就是True

print(all([1,2,True,0]))
print(any([1,'',0]))

执行结果

False

True




zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
    print(i)

执行结果


(1, 'a', '*')

(2, 'b', '**')

(3, 'c', (1, 2, 3))




filter:过滤

# filter 过滤，通过你的函数，过滤一个可迭代对象，返回的是True
# 类似于[i for i in range(10) if i > 3]
def func(x): return x % 2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)

执行结果


<filter object at 0x00000177ADEAA1D0>

2

4

6




map：会根据提供的函数对指定序列做映射

ret  = map(square, [1,2,3,4,5])  # 计算列表各个元素的平方
for i in ret:
    print(i)

ret1 = map(lambda x:x**2, [1,2,3,4,5])  # 使用lambda匿名函数
for i in ret1:
    print(i)

# 提供了两个列表，对相同位置的列表数据进行相加
ret2 = map(lambda x,y :x+y, [1,3,5,7,9], [2,4,6,8,10])
for i in ret2:
    print(i)




匿名函数lamdba

匿名函数：为了解决那些功能很简单的需求而设计的一句话函数

def calc(n):
    return n ** n
print(calc(10))

# 换成匿名函数
calc1 = lambda n:n**n
print(calc1(10))

执行结果


10000000000

10000000000



上面是对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明

函数名 = lamdba 参数:返回值

#参数可以有多个，用逗号隔开

#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

#返回值和正常的函数一样可以使任意数据类型




可以看出，匿名函数并不是真的不能有名字

匿名函数的调用和正常的调用也没有什么区别，就是函数名(参数)就可以了

匿名函数与内置函数举例

l = [3,2,100,999,213,1111,31121,333]
print(max(l))
dic = {'k1':10,'k2':100,'k3':30}
print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

res1 = filter(lambda x:x>10,[5,8,11,9,15])
for i in res1:
    print(i)

关键字：