1. 技术文章
  2. 模块

模块

由 给你一囗甜甜゛ 提交于 2020-02-04 14:52:28

第五章节 函数

截止目前：面向过程编程。【可读性差/可重用性差】。

发邮件

```python

面向过程编程

user_input = input('请输入角色：')

if user_input == '管理员': import smtplib from email.mime.text import MIMEText from email.utils import formataddr

msg = MIMEText('管理员，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["管理员", '344522251@qq.com'])
msg['Subject'] = "情爱的导演"

server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['管理员', ], msg.as_string())
server.quit()

elif user_input == '业务员': import smtplib from email.mime.text import MIMEText from email.utils import formataddr

msg = MIMEText('业务员，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["业务员", '业务员'])
msg['Subject'] = "情爱的导演"

server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['业务员', ], msg.as_string())
server.quit()

elif user_input == '老板':1 import smtplib from email.mime.text import MIMEText from email.utils import formataddr

msg = MIMEText('老板，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["老板", '老板邮箱'])
msg['Subject'] = "情爱的导演"

server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['老板邮箱', ], msg.as_string())
server.quit()

```

函数式编程：发邮件

```python def send_email(): import smtplib from email.mime.text import MIMEText from email.utils import formataddr

msg = MIMEText('老板，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["老板", '老板邮箱'])
msg['Subject'] = "情爱的导演"

server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', ['老板邮箱', ], msg.as_string())
server.quit()

user_input = input('请输入角色：')

if userinput == '管理员': sendemail() elif userinput == '业务员': sendemail() elif userinput == '老板': sendemail() ```

函数的本质：将N行代码拿到别处，起个名字，以后通过名字就可以找到这个代码并执行。

5.1 函数的基本结构

```python

函数的基本定义

def 函数名（）

函数名（） #执行 ```

```python def data () v = [11,22,33] print(v[0])

data()

注意：函数如果不被调用，则内部代码永远不会被执行。

```

```python

假如：管理员/业务员/老板用的是同一个邮箱。

def send_email(): print('发送邮件成功，假设有10含代码')

user_input = input('请输入角色：')

if userinput == '管理员': sendemail() elif userinput == '业务员': sendemail() elif userinput == '老板': sendemail() ```

练习题

```python

1. 写函数，计算一个列表中有多少个数字，打印： 列表中有%s个数字。

提示：type('x') == int 判断是否是数字。

"""

方式一：

def getlistcounter1(datalist): count = 0 for item in datalist: if type(item) == int: count += 1 msg = "列表中有%s个数字" %(count,) print(msg)

getlistcounter1([1,22,3,'alex',8])

方式二：

def getlistcounter2(datalist): count = 0 for item in datalist: if type(item) == int: count += 1 return count

v = getlistcounter1([1,22,3,'alex',8]) msg = "列表中有%s个数字" %(v,) print(msg) """

2. 写函数，计算一个列表中偶数索引位置的数据构造成另外一个列表，并返回。

"""

方式一：

def getdatalist1(arg): v = arg[::2] return v

data = getdatalist1([11,22,33,44,55,66])

方式二：

def getdatalist2(arg): v = [] for i in range(0,len(arg)): if i % 2 == 0: v.append(arg[i]) return v

data = getdatalist2([11,22,33,44,55,66])

"""

3. 读取文件，将文件的内容构造成指定格式的数据，并返回。

""" a.log文件 alex|123|18 eric|uiuf|19 ... 目标结构： a. ["alex|123|18","eric|uiuf|19"] 并返回。

b. [['alex','123','18'],['eric','uiuf','19']] with open("al.txt",mode="r",encoding="utf-8") as info: a = [ ] for i in info: i = i.strip() v1 = i.split("|") a.append(v1) print(a)

c. [ {'name':'alex','pwd':'123','age':'18'}, {'name':'eric','pwd':'uiuf','age':'19'}, ] """ ```

 
5.11 返回值

```python def func(arg): # .... return 9 # 返回值为9 默认：return None

val = func('adsfadsf') ```

```python

1. 让用户输入一段字符串，计算字符串中有多少A字符的个数。有多少个就在文件a.txt中写多少个“李邵奇”。

def getcharcount(data): sumcounter = 0 for i in data: if i == 'A': sumcounter += 1

return sum_counter

def write_file(line): if len(line) == 0: return False # 函数执行过程中，一旦遇到return，则停止函数的执行。 with open('a.txt',mode='w',encoding='utf-8') as f: f.write(line) return True

content = input('请输入:') counter = getcharcount(content) write_data = "李邵奇" * counter status = writefile(writedata) if status: print('写入成功') else: print('写入失败')

```

5.2函数的小高级

```python a = 123 name = '老男孩好' nums = [11,22,33,4] data = nums

def func(): pass # 100行代码

func = 函数

```

5.2.1 函数名当作变量来使用

python def func(): print(123) v1 = func func() v1（）

```python def func(): print(123)

func_list = [func, func, func]

func_list0

func_list1

func_list2

for item in func_list: v = item() print(v)

```

```python def func(): print(123)

def bar(): print(666)

info = {'k1': func, 'k2': bar}

info'k1' info'k2' ```

python def func(): return 123 func_list1 = [func,func,func] # func 是内存地址 func_list2 = [func(),func(),func()] 执行函数。#123 print(func_list1) print(func_list2) info = { 'k1':func, 'k2':func(), } print(info)

5.2.2 函数的赋值
5.2.3 函数可以当参数进行传递

```python def func(arg): print(arg)

func(1) func([1,2,3,4])

def show(): return 999 func(show) ```

```python def func(arg): v1 = arg() print(v1)

def show(): print(666)

func(show) ```

```python def func(arg): v1 = arg() print(v1)

def show(): print(666)

result = func(show) print(result) ```

```python

面试题

def func(): print('花费查询')

def bar(): print('语音沟通')

def base(): print('xxx')

def show(): print('xxx')

def test(): print('xxx')

info = { 'f1': func, 'f2': bar, 'f3':base, 'f4':show, 'f5':test } choice = input('请选择要选择功能：') functionname = info.get(choice) if functionname: function_name() else: print('输入错误') ```

5.2 4 匿名函数lambda表达式

用于表示简单的函数。

```python

三元运算，为了解决简单的if else的情况，如：

if 1 == 1: a = 123 else: a = 456

三元运算：a = 123 if 1 == 1 else 456

lambda表达式，为了解决简单函数的情况，如：

def func(a1,a2): return a1 + 100

func = lambda a1,a2: a1+100 ```

```python func1 = lambda : 100

func2 = lambda x1: x1 * 10

func3 = lambda args,*kwargs: len(args) + len(kwargs)

DATA = 100 func4 = lambda a1: a1 + DATA v = func4(1) print(v)

DATA = 100 def func(): DATA = 1000 func4 = lambda a1: a1 + DATA v = func4(1) print(v) func()

func5 = lambda n1,n2: n1 if n1 > n2 else n2 v = func5(1111,2) print(v) ```

练习题

```python

练习题1

USERLIST = [] def func0(x): v = USERLIST.append(x) return v

result = func0('alex') print(result)

练习题2

def func0(x): v = x.strip() return v

result = func0(' alex ') print(result)

总结：列表所有方法基本上都是返回None；字符串的所有方法基本上都是返回新值

练习题3

USERLIST = [] func1 = lambda x: USERLIST.append(x)

v1 = func1('alex') print(v1) print(USER_LIST)

练习题4

func1 = lambda x: x.split('l')

v1 = func1('alex') print(v1)

练习题5

func_list = [lambda x:x.strip(), lambda y:y+199,lambda x,y:x+y]

v1 = func_list[0]('alex ') print(v1)

v2 = func_list1 print(v2)

v3 = func_list2 print(v3) ```

5.3 内置函数

  • 其他：

    • len

    • open

    • range

    • id

    • type【查看类型】

    • issublass

    • isinstance【判断是否是某个类或基类的示例（对象）】

    • super【super().func() 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行（到底第一个就不在找了）】

  • 输入输出

    • input
    • print

  • 强制转换

    • str
    • list
    • tuple
    • set
    • bool
    • dict
    • int

  • 数学相关

    • abs 将十进制转换二进制
    • float
    • max
    • min
    • sum
    • divmod
    • round
    • pow

  • 进制转换

    • bin
    • oct
    • int
    • base
    • hex
    • chr 将十进制数字转换成unicode 编码中的对应字符。
    • ord 根据字符在unicode编码中找到其对应的十进制。
    • map 有2个参数，循环每个元素（第二个参数），然后让每个元素执行（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。
    • filter 有2个参数，对每个元素进行筛选，得到符合条件的元素，保存到新列表。

    • reduce 必须用2个数传参，对每个元素进行累计。

    • type 【查看类型】

    ```python

    判断是否是Foo类的实例

    class Foo: pass

    obj = Foo()

    if type(obj) == Foo: print('obj是Foo类的对象') ```

    • issubclass

    ```python class Base: pass

    class Base1(Base): pass

    class Foo(Base1): pass

    class Bar: pass

    print(issubclass(Bar,Base)) print(issubclass(Foo,Base)) ```

    • isinstance

    ```python

    判断是否是某个类或（基类）的实例（对象）

    class Base(object): pass

    class Foo(Base): pass

    obj = Foo()

    print(isinstance(obj,Foo)) # 判断obj是否是Foo类或其基类的实例（对象） print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象） ```

    • super

```python class Base(object): # Base -> object def func(self): super().func() print('base.func')

class Bar(object): def func(self): print('bar.func')

class Foo(Base,Bar): # Foo -> Base -> Bar pass

obj = Foo() obj.func()

# super().func() 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了) ```

  • chr，将十进制数字转换成unicode 编码中的对应字符。

    ```python v = chr(99) print(v)

    c

    ```

  • ord,根据字符在unicode编码中找到其对应的十进制。

    ```python num = ord("中") print(num)

    20013

    ```

  • 应用：

    ```python import random

    def getrandomcode(length=6): data = [ ] for i in range(lengh): v = random.randint(65,90) data.append(chr(v))

    return  "".join(data)

    code = getrandomcode() print(code)

    ```

    import random # 导入一个模块

    v = random.randint(起始，终止) # 得到一个随机数

  • 高级一点的内置函数

  • map。有2个参数，循环每个元素（第二个参数），然后让每个元素执行（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

    ```python v1 = [11,22,33,44] result = map(lambda x:x+100,v1) print(list(result))

    [111,122,133,144]

    ```

  • filter.有2个参数，对每个元素进行筛选，得到符合条件的元素，保存到新列表。

    ```python v1 = [11,22,33,'asd',44,'xf']

    def func(x): if type(x) == int: return True return False result = filter(func,v1) # [11,] print(list(result))

    result = filter(lambda x: True if type(x) == int else False ,v1) print(list(result))

    result = filter(lambda x: type(x) == int ,v1) print(list(result)) ```

  • reduce.，必须用2个数传参，对每个元素进行累计。

    ```python import functools v1 = ['wo','hao','e']

    def func(x,y): return x+y result = functools.reduce(func,v1) print(result)

    result = functools.reduce(lambda x,y:x+y,v1) print(result) ```

5.4 参数：【实参 / 形参】

```python def getlistfirst_data(aaa): # aaa叫形式参数(形参) v = [11,22,33,44] print(v[aaa])

getlistfirstdata(1) # 2/2/1调用函数时传递叫：实际参数（实参） getlistfirstdata(2) getlistfirstdata(3) getlistfirstdata(0) ```

  • 任意个数

  • 任意类型

  • 位置传参（调用函数并传入参数）

```python def func(a1,a2) print(a1,a2)

func() ```

  • 关键字传参

```python def func(a1,a2) print(a1,a2)

func(a1=5,a2=10) ```

  • 默认参数定义

```python # 自定义函数 def func():

func()

# 内置函数 open() len() ```

```python def func (a1,a2,a3= 9,a4= 10): print(a1,a2,a3,a4)

func 函数接受两个参数，调用函数进行传值时： func (1,2,) func(1,2,10) func(1,2,10,100) func(1,2,10,a4=100) func(1,2,a3=10,a4=100) ```

  • 万能参数（打散参数。*args）

  • 【直接说位置传参】

    • 接受任意个数的位置参数，并转换成元组

    • 调用函数无*

    ``` python def func (*args): print(args)

    func(1,2,3,4) #(1,2,3,4)

    def func (args): print(args)

    func(1,2,3,4) # 1,2,3,4 ```

    • 调用函数有**

    ```python def func(*args) print(args)

    func((1,2,3,4)) #(1,2,3,4) func([1,2,3,4]) #(1,2,3,4)

    def func(args) print(args)

    func((1,2,3,4)) # 1,2,3,4 func({1,2,3,4}) # 1,2,3,4 func(*[1,2,3,4]) # 1,2,3,4 ```

  • **kwargs【关键字传参】

    • 接受任意关键字传参，并将转换成字典

    • 调用参数无*

    ```python def func(**kwargs): print(kwargs)

    func(k1=1,k2=2) # {k1:1,k2:2} ```

    • 调用参数有*

    ```python def func(**kwargs) print(kwargs)

    func(**{"k1":"v1","k2":"v2"}) #{"k1":"v1","k2":"v2"}

    ```

  • 综合

发邮件

```python

假如：管理员/业务员/老板用的是同一个邮箱。

""" def send_email(to): import smtplib from email.mime.text import MIMEText from email.utils import formataddr

msg = MIMEText('导演，我想演男一号，你想怎么着都行。', 'plain', 'utf-8')
msg['From'] = formataddr(["李邵奇", '15776556369@163.com'])
msg['To'] = formataddr(["导演", to])
msg['Subject'] = "情爱的导演"

server = smtplib.SMTP("smtp.163.com", 25)
server.login("15776556369@163.com", "qq1105400511")
server.sendmail('15776556369@163.com', [to, ], msg.as_string())
server.quit()

""" def send_email(to): template = "要给%s发送邮件" %(to,) print(template)

user_input = input('请输入角色：')

if userinput == '管理员': sendemail('xxxx@qq.com') elif userinput == '业务员': sendemail('xxxxo@qq.com') elif userinput == '老板': sendemail('xoxox@qq.com') ```

练习题

```python

1、请写一个函数，函数计算列表info = [11,22,33,44,55] 中所有元素的和。

def info( ): info = [11, 22, 33, 44, 55] count = 0 for i in info: count += i print(count) info()

2.请写一个函数，函数计算列表中所有元素的和。

def func(al): count = 0 for i in al: count += i print(count)

func([11,22,33])

  1. 请写一个函数，函数将两个列表拼接起来 def func (a,b): a.extend(b) print(a) func([11,22,33],[1,2,3])
  1. 计算一个列表的长度 def func(a): v1 = len(a) print(v1)

func([1,2,3,4,11])

```

5.41 返回值（可以返回任意类型）

```python def func (arg):

return 9  # 默认：return None

va1 = func('dfdgfth') ```

```python

1. 让用户输入一段字符串，计算字符串中有多少A字符的个数。有多少个就在文件a.txt中写多少个“李邵奇”。

def getcharcount(data): sumcounter = 0 for i in data: if i == 'A': sumcounter += 1

return sum_counter

def write_file(line): if len(line) == 0: return False # 函数执行过程中，一旦遇到return，则停止函数的执行。 with open('a.txt',mode='w',encoding='utf-8') as f: f.write(line) return True

content = input('请输入:') counter = getcharcount(content) write_data = "李邵奇" * counter status = writefile(writedata) if status: print('写入成功') else: print('写入失败')

```

5.5函数的中高级

5.5.1 函数可以做返回值

```python def func(): print(123)

def bar (): return func

v = bar() v() # 123 ```

```python nane = "oldboy" def func():

def bar (): return func v = bar() v() # oldboy

```

python def bar(): def inner(): print(123) return inner v = bar() v( ) # 123

python name = "oldboy" def bar(): name = "alex" def inner(): print(name) return inner v = bar() v() # alex

python name = "oldboy" def bar(name): def inner(): print(name) return inner v1 = bar("alex") v2 = var("aric") v1() # alex v2() #aric

练习题

```python 第一题 name = 'alex' def base(): print(name) def func(): name = 'eric' base() func() # alex

第二天 name = 'alex' def func(): name = 'eric' def base(): print(name) base() # 'eric' func() # 'eric'

第三题 name = 'alex'

def func(): name = 'eric' def base(): print(name) return base base = func() base() #'eric'

```

注意：函数在何时被谁创建？

面试题

```python info = []

def func(): print(item)

for item in range(10): info.append(func)

info0 #9 ```

```python info = []

def func(i): def inner(): print(i) return inner

for item in range(10): info.append(func(item))

info0 #0 info1 #1 info4 #4 ```

5.52 闭包
  • 闭包概念：为函数创建一块区域并为其维护自己数据，以后执行方便调用。
    • 应用场景：装饰器 / SOLAlchemy源码

```python def func(name): def inner(): print(name) return inner

v1 = func('alex') v1() # alex v2 = func('eric') v2() # eric ```

```python

不是闭包

def func1(name): def inner(): return 123 return inner

是闭包：封装值 + 内层函数需要使用。

def func2(name): def inner(): print(name) return 123 return inner ```

5.53 高阶函数
  • 把函数当作参数传递
  • 把函数当作返回值

注意：对函数进行赋值

5.6作用域

python中：

  • py 文件：全局作用域

  • 函数：局部作用域

  • 一个函数是一个作用域

  • 作用域中查找数据规则：优先在自己作用域找数据，自己没有就去"父级"--> "父级"-->"父级"-->直到全局，全部没有就报错。注意：父级作用域中的值到底是什么？

```python a = 1 def s1(): x1 = 666 print(x1) print(a) print(b)

b = 2 print(a) s1() a = 88888 def s2(): print(a,b) s1()

s2() ```

  • 作用域中查找数据规则：优先在自己作用域找数据，自己没有就去"父级"--> "父级"-->"父级"-->直到全局，全部没有就报错。注意：父级作用域中的值到底是什么？

```python x = 10 def func(): x = 9 print(x)

func() ```

练习题

```python x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) func()

x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) x1() func()

x = 10 def func(): x = 9 print(x) def x1(): x = 999 print(x) print(x) x1()

func()

x = 10 def func(): x = 8 print(x) def x1(): x = 999 print(x) x1() print(x) func()

x = 10 def func(): x = 8 print(x) def x1(): print(x) x1() print(x)

func()

x = 10 def func(): x = 8 print(x) def x1(): print(x) x = 9 x1() x = 10 print(x)

x = 10 def func(): x = 8 print(x) def x1(): print(x)

  x1()
  x = 9
  x1()
  x = 10
  print(x)

func() 
```

  • 子作用域中只能 找到父级中的值，默认无法重现为父级的变量进行赋值。（global/nonlocal可以强制做）

```python name = 'oldboy' def func(): name = 'alex' # 在自己作用域再创建一个这样的值。 print(name) func() print(name)

# ##################### name = [1,2,43] def func(): name.append(999) print(name) func() print(name)

# ###################### 如果非要对全局的变量进行赋值 # 示例一 name = ["老男孩",'alex'] def func(): global name name = '我' func() print(name) # 示例一 name = "老男孩" def func(): name = 'alex' def inner(): global name name = 999 inner() print(name) func() print(name)

name = "老男孩" def func(): name = 'alex' def inner(): global name name = 999 inner() print(name) func() print(name)

# ############################## nonlocal name = "老男孩" def func(): name = 'alex' def inner(): nonlocal name # 找到上一级的name name = 999 inner() print(name) func() print(name) ```

  • 补充：全局变量以后必须全部是大写

```python USER_LIST = [11,22,3]

def func(): name = 'asdf' USERLIST.append(12) USERLIST.append(name)

func() print(USER_LIST) ```

5.7 递归

函数自己调用自己。（效率低）

  • 递归的最大次数是（1000次）

```python def func(): print(1) func()

func() ############################### ```

```python def func(i) print(i) func(i+1)

func(1) ```

```python def func(a,b): # 1 # 1 # 2 # 3 # 5 print(b) func(b,a+b)

func(0,1) ############################### def func(a): if a ==5: return 10000 result = func(a+1)+10 return result

v = func(1) ```

递归的返回值

```python def func(a) if a ==5: return 100000 result = func(a+1)+10

v = func(1) name = "alex" def func(): def inner(): print(name) return inner v = func()

```

5.8 装饰器

装饰器：在不改变原函数内部代码的基础上，在函数执行前和之后自动执行某个功能。

  1. .装饰器的基本格式

```python def x1(func): def inner(args,kwargs): data = func(args,kwargs) # 执行原函数并获取返回值 return data return inner

@x1 def index(): print(123)

index() ```

2.带参数的装饰器

```python def x(counter): def wrapper(func): def inner(args,kwargs): data = func(args,kwargs) # 执行原函数并获取返回值 return data return inner return wrapper

@x(9) def index(): pass ```

```python def func(): pass v = 10 v = func

def base(): print(1) def bar(): print(2)

bar = base bar() #1 ```

```python def func(): def inner(): pass return inner

v = func() print(v) # inner函数

def func(arg): def inner(): print(arg) return inner

v1 = func(1) v2 = func(2)

def func(arg): def inner(): arg() return inner

def f1():
    print(123)

v1 = func(f1) v1() #123

def func(arg): def inner(): arg() return inner

def f1(): print(123) return 666

v1 = func(f1) result = v1() # 执行inner函数 / f1含函数 -> 123 print(result) # None

def func(arg): def inner(): return arg() return inner

def f1(): print(123) return 666

v1 = func(f1) result = v1() # 执行inner函数 / f1含函数 -> 123 print(result) #666

```

```python def func(arg): def inner(): print("before") v = arg print("after") return v return inner

def index(): print("123") return"666"

示例一

v1 = index() # 执行index函数，打印123并返回666赋值个v1

示例二

v2 = func(index)# v2是inner函数，arg = index函数 index = 666 v3 = v2()

示例三

v4 = func(index) index = v4 # index ==> inner index()

示例四

index = func(index) index() ```

``` def func(arg)： def inner(): v = arg() return v return inner

第一步：执行func 函数并将下面的函数参数传递，相当于：func(index)

第一步:将func的返回值重新赋值给下面的函数名。index = func(index)

@func def index(): print(123) return 666

print(index)

```

应用场景：想要为函数扩展功能时，可以选择用装饰器。

```python

计算函数执行时间

def wrapper(func): def inner(): starttime = time.time() v = func() endtime = time.time() print(endtime-starttime) return v return inner

@wrapper def func1(): time.sleep(2) print(123)

@wrappen def func2(): time.sleep(1) print(123)

def func3(): time.sleep(1.5) print(123)

func1() ```

5.9 迭代器

自己不会写迭代器，只用。

任务：请展示列表中所有的数据。

  • while + 索引 + 计数器

  • 迭代器，对 某种对象(str/list/tuple/dict/set类创建的对象)-可迭代对象 中的元素进行逐一获取，表象：具有__next__方法且每次调用都获取可迭代对象中的元素（从前到后一个一个获取）。

    • 列表转换成迭代器：
    • v1 = iter([11,22,33,44])
    • v1 = [11,22,33,44].iter()
    • 迭代器想要获取每个值：反复调用 ```val = v1.next()

```python v1 = [11,22,33,44]

# 列表转换成迭代器 v2 = iter(v1) result1 = v2.next() print(result1) result2 = v2.next() print(result2) result3 = v2.next() print(result3) result4 = v2.next() print(result4) result5 = v2.next() print(result5) """ # v1 = "alex" # v2 = iter(v1) # while True: # try: # val = v2.next() # print(val) # except Exception as e: # break ```

  • 直到报错： StopIteration错误，表示已经迭代完毕。

  • 如何判别一个对象是否是迭代器：内部是否有__next__方法 。

  • for 循环

```python v1 = [11,22,33,44]

# 1.内部会将v1转换成迭代器 # 2.内部反复执行 迭代器.next() # 3.取完不报错 for item in v1: print(item) ```

5.10 可迭代对象

  • 内部具有 __iter__() 方法且返回一个迭代器。（*）
  • 可以被for 循环

python v1 = [11,22,33,44] result = v1.__iter__()

5.11生成器（函数的变异）

  • 函数中如果存在yield，那么该函数就是一个生成器函数，调用生成器函数会返回一个生成器，生成器只有被for循环时，生成器函数内部的代码才会执行，每次循环都会获取yield返回的值。

```python

函数

def func(): return 123 func() ```

```python

生成器函数（内部是否包含yield）

def func(): print('F1') yield 1 print('F2') yield 2 print('F3') yield 100 print('F4')

函数内部代码不会执行，返回一个 生成器对象 。

v1 = func()

生成器是可以被for循环，一旦开始循环那么函数内部代码就会开始执行。

for item in v1: print(item) ```

```python def func(): count = 1 while True: yield count count += 1

val = func()

for item in val: print(item) ```

```python def func(): count = 1 while True: yield count count += 1 if count == 100: return

val = func() for item in val: print(item) ```

示例：读文件

```python def func(): """ 分批去读取文件中的内容，将文件的内容返回给调用者。 :return: """ cursor = 0 while True: f = open('db', 'r', encoding='utf-8')# 通过网络连接上redis # 代指 redis[0:10] f.seek(cursor) datalist =[] for i in range(10): line = f.readline() if not line: return datalist.append(line) cursor = f.tell() f.close() # 关闭与redis的连接

    for row in data_list:
        yield row

for item in func(): print(item) ```

特殊的迭代器：

```python def func(): yield 1 yield 2 yield 3

v = func() result = v.next() print(result) result = v.next() print(result) result = v.next() print(result) result = v.next() print(result) ```

特殊的可迭代对象：

```python def func(): yield 1

v = func() result = v.iter() print(result) ```

5.12推到式

  • 列表推导式【生成式】

    • 基本格式

    ```python 目的：方便的生成一个列表。 格式： v1 = [i for i in 可迭代对象] v2 = [i for i in 可迭代对象 if 条件] # 条件为true 才进行append

    v1 = [ i for i in 'alex' ] v2 = [i+100 for i in range(10)] v3 = [99 if i>5 else 66 for i in range(10)]

    def func(): return 100 v4 = [func for i in range(10)]

    v5 = [lambda : 100 for i in range(10)] result = v59

    def func(): return i v6 = [func for i in range(10)] result = v65

    v7 = [lambda :i for i in range(10)] result = v75

    v8 = [lambda x:x*i for i in range(10)] # 新浪微博面试题

    1.请问 v8 是什么？

    2.请问 v80 的结果是什么？

    面试题

    def num(): return [lambda x:i*x for i in range(4)]

    num() -> [函数,函数,函数,函数]

    print([ m(2) for m in num() ]) # [6,6,6,6]

    ##################### 筛选

    v9 = [i for i in range(10) if i > 5] ```

    • 集合推导式

    python v1 = {i for i in "alex"}

    • 字典推导式

    python v1 = v1 = {"k"+str(i):i for i in range(10)}

标签
python
python函数
python列表
python继承
python实例
input
info
lambda
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!