python基础八——函数进阶2

1.递归函数

1.1、初始递归

递归函数：在一个函数里在调用这个函数本身。

递归的最大深度：998

正如你们刚刚看到的，递归函数如果不受到外力的阻止会一直执行下去。但是我们之前已经说过关于函数调用的问题，每一次函数调用都会产生一个属于它自己的名称空间，如果一直调用下去，就会造成名称空间占用太多内存的问题，于是python为了杜绝此类现象，强制的将递归层数控制在了997(只要997！你买不了吃亏，买不了上当...).

拿什么来证明这个“998理论”呢？这里我们可以做一个实验：

1 def foo(n):
2     print(n)
3     n += 1
4     foo(n)
5 foo(1)

由此我们可以看出，未报错之前能看到的最大数字就是998.当然了，997是python为了我们程序的内存优化所设定的一个默认值，我们当然还可以通过一些手段去修改它：

import sys
print(sys.setrecursionlimit(100000))

我们可以通过这种方式来修改递归的最大深度，刚刚我们将python允许的递归深度设置为了10w，至于实际可以达到的深度就取决于计算机的性能了。不过我们还是不推荐修改这个默认的递归深度，因为如果用997层递归都没有解决的问题要么是不适合使用递归来解决要么是你代码写的太烂了～～～

看到这里，你可能会觉得递归也并不是多么好的东西，不如while True好用呢！然而，江湖上流传这这样一句话叫做：人理解循环，神理解递归。所以你可别小看了递归函数，很多人被拦在大神的门槛外这么多年，就是因为没能领悟递归的真谛。而且之后我们学习的很多算法都会和递归有关系。来吧，只有学会了才有资本嫌弃！

1.2、递归示例讲解

这里我们又要举个例子来说明递归能做的事情。

例一：

现在你们问我，yan多大了？我说我不告诉你，但yan比 hui大两岁。

你想知道yan多大，你是不是还得去问hui？hui说，我也不告诉你，但我比武huang大两岁。

你又问huang，huang也不告诉你，他说他比hehe大两岁。

那你问hehe，hehe告诉你，他18了。

这个时候你是不是就知道了？yan多大？

所以就有：

1 age(4) = age(3) + 2 
2 age(3) = age(2) + 2
3 age(2) = age(1) + 2
4 age(1) = 40

1 def age(n):
2     if n == 1:
3         return 40
4     else:
5         return age(n-1)+2
6 
7 print(age(4))

2.内置函数

什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过。

		内置函数
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

2.1作用域相关

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

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

代码示例

2.2其他相关

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

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

eval('2 + 2')  # 4


n=81
eval("n + 4")  # 85


eval('print(666)')  # 666

View Code

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

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

View Code

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

'''
参数说明：　　　

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。
'''
>>> #流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)


>>> #简单求值表达式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)


>>> #交互语句用single
>>> code3 = 'name = input("please input your name:")'
>>> compile3 = compile(code3,'','single')
>>> name #执行前name变量不存在
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"

View Code

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

2.2.2 输入输出相关 input，print

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

　　print:打印输出。

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

print(111,222,333,sep='*')  # 111*222*333

print(111,end='')
print(222)  #两行的结果 111222

f = open('log','w',encoding='utf-8')
print('写入文件',file=f,flush=True)

View Code

2.2.3内存相关 hash id

　　hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

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

'''
12322
-2996001552409009098
-4637515981888139739
2311495795356652852
1
0
2528502973977326415
'''

View Code

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

print(id(123))  # 1674055952
print(id('abc'))  # 2033192957072

2.2.3文件操作相关

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

2.2.4模块相关__import__　

　　__import__：函数用于动态加载类和函数。

2.2.5帮助

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

print(help(list))
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

None

Process finished with exit code 0

View Code

2.2.6调用相关

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

>>>callable(0)
False
>>> callable("runoob")
False
 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True

View Code

2.2.7查看内置属性

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

>>>dir()   #  获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ])    # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

View Code

2.3 迭代器生成器相关

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

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

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

View Code

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

View Code

2.4.1数字相关（14）

　　数据类型（4）：

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

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

print(int())  # 0

print(int('12'))  # 12

print(int(3.6))  # 3

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

View Code

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

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

>>>complex(1, 2)
(1 + 2j)
 
>>> complex(1)    # 数字
(1 + 0j)
 
>>> complex("1")  # 当做字符串处理
(1 + 0j)
 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

View Code

　　进制转换（3）：

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

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

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

print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
print(hex(10),type(hex(10)))  # 0xa <class 'str'>

View Code

　　数学运算（7）：

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

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

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

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

print(abs(-5))  # 5

print(divmod(7,2))  # (3, 1)

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

print(pow(2,3))  # 两个参数为2**3次幂
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

View Code

　　　　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':2,'c':1}
print(min(dic,key=lambda x:dic[x]))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键


print(max([1,2,3]))  # 返回此序列最大值

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

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

View Code

2.4.2和数据结构相关（24）

　　列表和元祖（2）

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

　　　　tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

l = list((1,2,3))
print(l)

l = list({1,2,3})
print(l)

l = list({'k1':1,'k2':2})
print(l)

tu = tuple((1,2,3))
print(tu)

tu = tuple([1,2,3])
print(tu)

tu = tuple({'k1':1,'k2':2})
print(tu)

View Code

匿名函数

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

1 #这段代码
2 def calc(n):
3     return n**n
4 print(calc(10))
5  
6 #换成匿名函数
7 calc = lambda n:n**n
8 print(calc(10))

 calc = lambda n:n**n

calc :函数名

lambda:定义函数名关键字和def类似

n：参数

n**n:返回值

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

函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

匿名函数与内置函数举例：

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])])

View Code

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

View Code

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

View Code

生成器

4.1初识生成器

生成器的本质就是迭代器，在python社区中，大多数时候都把迭代器和生成器是做同一个概念。不是相同么？为什么还要创建生成器？生成器和迭代器也有不同，唯一的不同就是：迭代器都是Python给你提供的已经写好的工具或者通过数据转化得来的，（比如文件句柄，iter([1,2,3])。生成器是需要我们自己用python代码构建的工具。

4.2 生成器的构建方式

在python中有三种方式来创建生成器：

　　1. 通过生成器函数

　　2. 通过生成器推导式

　　3. python内置函数或者模块提供（其实1,3两种本质上差不多，都是通过函数的形式生成，只不过1是自己写的生成器函数，3是python提供的生成器函数而已）

4.3 生成器函数

探讨通过生成器函数构建生成器。

def func():

    print(11)

    return 22

ret = func()

print(ret)

# 运行结果:

11

22

View Code

将函数中的return换成yield，这样func就不是函数了，而是一个生成器函数

def func():
    print(11)
    yield 22

View Code

def func():

    print(11)

    yield 22

ret = func()

print(ret)

# 运行结果:

<generator object func at 0x000001A575163888>

View Code

运行的结果和最上面的不一样,是由于函数中存在yield,那么这个函数就是一个生成器函数.

在执行这个函数的时候.就不再是函数的执行了.而是获取这个生成器对象，那么生成器对象如何取值呢？

之前我们说了，生成器的本质就是迭代器.迭代器如何取值，生成器就如何取值。所以我们可以直接执行next()来执行以下生成器

def func():

     print("111")

     yield 222

gener = func() # 这个时候函数不会执⾏. ⽽是获取到⽣成器

ret = gener.__next__() # 这个时候函数才会执⾏

print(ret)  # 并且yield会将func生产出来的数据 222 给了 ret。  

结果:

111

222

View Code

并且我的生成器函数中可以写多个yield

def func():

    print("111")

    yield 222

    print("333")

    yield 444

gener = func()

ret = gener.__next__()

print(ret)

ret2 = gener.__next__()

print(ret2)

ret3 = gener.__next__()

# 最后⼀个yield执⾏完毕. 再次__next__()程序报错

print(ret3)



结果:

111

222

333

444

View Code

当程序运行完最后一个yield,那么后面继续运行next()程序会报错，一个yield对应一个next，next超过yield数量，就会报错，与迭代器一样。

yield与return的区别：

return一般在函数中只设置一个，他的作用是终止函数，并且给函数的执行者返回值。

yield在生成器函数中可设置多个，他并不会终止函数，next会获取对应yield生成的元素。

举例：

看一下这个需求：老板向楼下卖包子的老板订购了10000个包子.包子铺老板非常实在，一下就全部都做出来了

def eat():

    lst = []

    for i in range(1,10000):

        lst.append('包子'+str(i))

    return lst

e = eat()

print(e)

View Code

但是由于员工没有那么多，只吃了2000个左右，剩下的8000个，就只能占着一定的空间，放在一边了。如果包子铺老板效率够高，我吃一个包子，你做一个包子，那么这就不会占用太多空间存储了，完美。

def eat():

    for i in range(1,10000):

        yield '包子'+str(i)

e = eat()

for i in range(200):
    next(e)

View Code

这两者的区别:

第一种是直接把包子全部做出来，占用内存。

第二种是吃一个生产一个，非常的节省内存，而且还可以保留上次的位置。

def eat():

    for i in range(1,10000):

        yield '包子'+str(i)

e = eat()

for i in range(200):
    next(e)
    
for i in range(300):
    next(e)
# 多次next包子的号码是按照顺序记录的。

View Code

4.4 send 方法（了解）

send方法

# next只能获取yield生成的值，但是不能传递值。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')

dog = gen('yan')
next(dog)
next(dog)
next(dog)


# 而使用send这个方法是可以的。
def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield 222
        print(f'{name} start to eat {food}')

dog = gen('yan')
next(dog)  # 第一次必须用next让指针停留在第一个yield后面
# 与next一样，可以获取到yield的值
ret = dog.send('骨头')
print(ret)


def gen(name):
    print(f'{name} ready to eat')
    while 1:
        food = yield
        print(f'{name} start to eat {food}')

dog = gen('yan')
next(dog)
# 还可以给上一个yield发送值
dog.send('骨头')
dog.send('狗粮')
dog.send('香肠')

View Code

send和next()区别:

相同点：

send 和 next()都可以让生成器对应的yield向下执行一次。

都可以获取到yield生成的值。

不同点：

第一次获取yield值只能用next不能用send（可以用send(None)）。

send可以给上一个yield置传递值。

4.5yield from

在python3中提供一种可以直接把可迭代对象中的每一个数据作为生成器的结果进行返回

# 对比yield 与 yield from 
def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield lst
g = func()
print(g)
print(next(g))  # 只是返回一个列表

def func():
    lst = ['卫龙','老冰棍','北冰洋','牛羊配']
    yield from lst
g = func()
print(g)
# 他会将这个可迭代对象(列表)的每个元素当成迭代器的每个结果进行返回。
print(next(g))
print(next(g))
print(next(g))
print(next(g))
'''
yield from ['卫龙','老冰棍','北冰洋','牛羊配'] 
等同于：
    yield '卫龙'
    yield '老冰棍'
    yield '北冰洋'
    yield '牛羊配'
'''

View Code

有个小坑,yield from 是将列表中的每一个元素返回,所以如果写两个yield from 并不会产生交替的效果

def func():
    lst1 = ['卫龙','老冰棍','北冰洋','牛羊配']
    lst2 = ['馒头','花卷','豆包','大饼']
    yield from lst1
    yield from lst2
    
g = func()
for i in g:
    print(i)

View Code

推导式

5.1列表推导式

列表推导式,生成器表达式以及其他推导式，推导式就是构建比较有规律的列表,生成器，字典等一种简便的方式。

给出一个列表,通过循环,想列表中添加1~10:

li = []

for i in range(10):

    li.append(i)

print(li)

View Code

那么按照上面的要求用列表推导式写一下：

ls = [i for i in range(10)]

print(ls)

列表推导式分为两种模式：

1.循环模式：[变量(加工的变量) for 变量 in iterable]

2.筛选模式: [变量(加工的变量) for 变量 in iterable if 条件]

探索多层循环的，循环模式。

5.2循环模式

什么叫'加工的变量

1.将10以内所有整数的平方写入列表

l1 = [i*i for i in range(1,11)]
print(l1)

View Code

2.100以内所有的偶数写入列表.

l1 = [i for i in range(2,101,2)]
print(l1)

View Code

3.从python1期到python100期写入列表lst

lst = [f'python{i}' % i for i in range(1,19)]

print(lst)

View Code

上面那个格式化输出的变量f'python{i}'，就是加工的变量。

上面做的那三个就是循环模式，比较简单，接下来我们研究筛选模式

5.3筛选模式

筛选模式就是在上面的基础上加上一个判断条件，将满足条件的变量留到列表中。

带着同学们做一个题：

将这个列表中大于3的元素留下来

l1 = [4, 3, 2, 6, 5, 5, 7, 8] 
print([i for i in l1 if i > 3])

View Code

示例：

1.三十以内可以被三整除的数

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

View Code

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

l = ['yan', 'yanhuihuang', 'aa', 'b', 'huangi']
# print([i.upper() for i in l if len(i) > 3])

View Code

3.找到嵌套列表中名字含有两个‘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])  # 注意遍历顺序，这是实现的关键

View Code

5.4生成器表达式

生成器表达式和列表推导式的语法上一模一样,只是把[]换成()就行了。比如将十以内所有数的平方放到一个生成器表达式中

gen = (i**2 for i in range(10))
print(gen)
# 结果: <generator object <genexpr> at 0x0000026046CAEBF8>

View Code

生成器表达式也可以进行筛选

# 获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
    print(num)

View Code

生成器表达式和列表推导式的区别:

列表推导式比较耗内存,所有数据一次性加载到内存。而.生成器表达式遵循迭代器协议，逐个产生元素。

得到的值不一样,列表推导式得到的是一个列表.生成器表达式获取的是一个生成器
列表推导式一目了然，生成器表达式只是一个内存地址。

无论是生成器表达式，还是列表推导式，他只是Python给你提供了一个相对简单的构造方式，因为使用推导式非常简单，所以大多数都会为之着迷，这个一定要深重，推导式只能构建相对复杂的并且有规律的对象，对于没有什么规律，而且嵌套层数比较多（for循环超过三层）这样就不建议大家用推导式构建。

生成器的惰性机制: 生成器只有在访问的时候才取值,说白了.你找他要才给你值.不找他要.他是不会执行的.

5.5 其他相关的推导式（了解）：

字典推导式

根据名字应该也能猜到,推到出来的是字典

lst1 = ['jay','jj','meet']
lst2 = ['周杰伦','林俊杰','郭富成']
dic = {lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic)

View Code

集合推导式

集合推导式可以帮我们直接生成一个集合,集合的特点;无序,不重复所以集合推导式自带去重功能

lst = [1,2,3,-1,-3,-7,9]
s = {abs(i) for i in lst}
print(s)

View Code

内置函数Ⅰ

函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个，由于时间关系以及考虑这些函数的不同重要性我们会挑常用的重要的内置函数去讲，就是下面红色黄色背景的内置函数。

内置函数进行分类：

黄色一了解过：all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()

红色重点掌握解：abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()

蓝色未来了解： classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()

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

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

View Code

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

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

View Code

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值

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

'''
-2996001552409009098
-4637515981888139739
1
2528502973977326415
'''

View Code

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

print(help(list))
print(help(str.split))

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

name = 'yan'
def func():
    pass
print(callable(name))  # False
print(callable(func))  # True

View Code

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

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

View Code

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

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

print(float(3))  # 3.0
print(complex(1,2))  # (1+2j)

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

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

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

print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
print(hex(10),type(hex(10)))  # 0xa <class 'str'>

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

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

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

print(divmod(7,2))  # (3, 1)
print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326
print(pow(2,3))  # 两个参数为2**3次幂
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

View Code

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'))

View Code

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

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

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

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

View Code

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

# %r  原封不动的写出来
# name = 'huihuangi'
# print('我叫%r'%name)

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

View Code

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

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

# all  可迭代对象中，全都是True才是True
# any  可迭代对象中，有一个True 就是True
# print(all([1,2,True,0]))
# print(any([1,'',0]))