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

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)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

python:函数的高级特性

22930
来自专栏hbbliyong

nodejs 的序列化与反序列化

1.序列化 stringify函数的作用就是序列化对象,也就是说将对象类型转换成一个字符串类型(默认的分割符("&")和分配符("=")),先介绍它的基本用法,...

33970
来自专栏肖洒的博客

Python3学习集合

18230
来自专栏阿炬.NET

正则表达式学习笔记

28070
来自专栏数据结构与算法

03:八进制小数

03:八进制小数 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB描述 八进制有限小数均可以用十进制有限小数精确地表示。比如,八...

37370
来自专栏编程

Go语言中new和make的区别

Go语言中new和make是内建的两个函数,主要用来创建分配类型内存。在我们定义生成变量的时候,可能会觉得有点迷惑,其实他们的规则很简单,下面我们就通过一些示例...

20070
来自专栏Jed的技术阶梯

算法小细节之数组某部分的中间位置的索引

给定一个数组的某个部分,这部分起始索引为L,结束索引为R,求这部分中间位置的索引。

12220
来自专栏十月梦想

JavaScript数组元素排序

使用for循环遍历出数组;然后判断i号元素和i+1号大小,如果判断大于,存储小的元素,如果判断小于存储大的元素

9230
来自专栏书山有路勤为径

1.C与C++

使用c++中的标准库类型vector可以很轻松的完成任务。 不需要管理内存分配,对不同的类型都可以处理

13740
来自专栏我的博客

sizeof用法

sizeof()功能:计算数据空间的字节数 1.与strlen()比较 strlen()计算字符数组的字符数,以”\0″为结束判断,不计算为’\...

29940

扫码关注云+社区

领取腾讯云代金券