威尼斯人线上娱乐

【威尼斯人线上娱乐】Python基础之函数,Python之函数总括

27 3月 , 2019  

一、函数

Python之函数计算,python总括

一、函数

① 、为什么要用函数

    a、防止代码重用

    b、提升代码的可读性

威尼斯人线上娱乐,二 、函数的调用

   返回值=函数名(参数1,参数2)

   函数定义—重回值

   关键字:return

3、return的作用:

    a、甘休函数的实践

    b、重临要赶回的值

④ 、返回值的两种情状

    a、再次来到值为None

威尼斯人线上娱乐 1

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)


str_len = mylen()
print(str_len)

不写return
威尼斯人线上娱乐 2

def ret():
    print(111)
    return
    print(222)

re = ret()
print(re)

只写return
威尼斯人线上娱乐 3

def ret():
    print(111)
    return None
    print(222)

re = ret()
print(re)

return None

    b、再次来到值不为None

         ① 、重临一个值

威尼斯人线上娱乐 4

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

str_len = mylen()
print(str_len)

归来2个值

          ② 、重返七个值

⑤ 、函数的调用—-接受再次回到值

   a、再次回到值为None    不收受

   b、重返值不为None

       一 、重临三个值

               用三个变量接受

       二 、重返多少个值

               a、用三个变量接受,接受的结果是两个元祖

               b、有稍许个重临值就用多少个值接受

6、参数

    a、参数—-站在概念函数的角度

         壹 、地点参数

         ② 、私下认可参数

         叁 、动态参数

              a、*args

              b、**kwargs

梯次:地方参数、*args、私下认可参数、**kwargs

     b、参数—-站在调用函数的角度上

         ① 、依照岗位传参

         二 、依据重点字传参

         叁 、动态传参*tup,**dic

柒 、参数分为形参和实参   

     a、实参:调用函数的时候传出的参数

⑧ 、地方参数

     a、地方参数必须传值

威尼斯人线上娱乐 5

def aaa(a,b):
    print(a,b)
aaa(1,2)

岗位参数

⑨ 、暗中认可参数

     a、暗中同意参数能够不传值

威尼斯人线上娱乐 6

def bbb(x=10):
    print(x)
 bbb()     #x = 10
 bbb(20)  #x = 20

暗许参数

⑩ 、动态参数

威尼斯人线上娱乐 7

def ccc(*args):#1,2,3,4,5
    print(args)

ccc(1,2,3,4,5)#按位置传参数

t = (1,2,3,4,5)
ccc(t)  ((1, 2, 3, 4, 5),)
ccc(*t)  (1, 2, 3, 4, 5)
复制代码

动态参数
威尼斯人线上娱乐 8

def ddd(**kwargs):
    print(kwargs)

 ddd(k = 'a',j = 'b')#按关键字传参数

动态参数+关键字参数
威尼斯人线上娱乐 9

def eee(*args,**kwargs):
    print(args,kwargs)

 eee(12,123)

动态,先按岗位参数,再按首要性字参数

1① 、命名空间

     a、命名空间分为三种

            一 、全局命名空间

            二 、局地命名空间

            三 、内置命名空间

     b、三种命名空间的逐一:内置命名空间>全局命名空间>局地命名空间

     c、取值

           一 、在部分调用:局地命名空间->全局命名空间->内置命名空间

威尼斯人线上娱乐 10

x = 1
def f(x):
    print(x)

print(10)

View Code

          二 、在全局调用:全局命名空间->内置命名空间

威尼斯人线上娱乐 11

x = 1
def f(x):
    print(x)

f(10)
print(x)

View Code

12、作用域

      a、
 效率域就是职能范围,依照生效范围能够分为全局成效域和部分成效域。

      b、
 全局功效域:包罗松手名称空间、全局名称空间,在整个文件的轻易地点都能被引述、全局有效

      c、局地效能域:局地名称空间,只辛亏有的范围生效

作用域:
小范围的可以用大范围的
但是大范围的不能用小范围的
范围从大到小(图)
在小范围内,如果要用一个变量,是当前这个小范围有的,就用自己的
如果在小范围内没有,就用上一级的,上一级没有就用上上一级的,以此类推。
如果都没有,报错

13、闭包

       a、闭包分为:

            一 、闭:内部函数

            二 、包:包蕴对外表函数的效率域中变量的引用

       b、闭包常用的的方式

威尼斯人线上娱乐 12

def hei():
    x = 20
    def inner():
        print(x)  #局部的
    return inner

i = hei()
i()  #全局

闭包常用格局

1④ 、函数值装饰器

      a、装饰器的精神:闭包函数

     
b、装饰器的成效:正是在不转移原函数调用格局的场合下,在这几个函数的内外加上扩充功能

威尼斯人线上娱乐 13

def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner

@timer
def func1(a):
    print(a)

func1(1)

带参数的装饰器

1五 、装饰器的盛玉溪闭原则:

      a、对扩展是开放的

      b、对修改是查封的

威尼斯人线上娱乐 14

def timer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner

装饰器的固化方式

1六 、装饰器应用场景

      a、计算func的履行时间

      b、登录认证

17、可迭代

     
a、字符串,列表,集合,字典,元祖那一个度能够for循环,表达他俩是可迭代的

      b、迭代正是:将有个别数据集内的多寡四个挨三个的取出来,就 叫做可迭代

      c、可迭代对应标志:__iter__

1捌 、迭代探讨

     
a、盼望这几个数据类型里的事物也足以选取for被3个3个的取出来,那大家就不可能不满足for的需求

      b、可迭代协议——凡是可迭代的内部都有一个__iter__方法

1⑨ 、迭代器协议

      a、迭代器协议 : 中间贯彻了__iter__
__next__方法

 可迭代和迭代器的差别点 :
迭代器多实现了贰个__next__方法

 可迭代和迭代器的相同点 : 都能够用for循环

20、判断迭代器和可迭代的法子 

       a、第③种:判断在那之中是否落到实处了 __next__** **

                           ‘__next__’ in dir(o)

       b、第二种

from collections import Iterable  #可迭代
from collections import Iterator  #迭代器
isinstance(o,Iterable)
isinstance(o,Iterator)

21、生成器

     
a、生成器函数:常规函数定义,但是,使用yield语句而不是return语句再次来到结果。yield语句2遍回到贰个结实,在种种结果中间,

          挂起函数的情状,以便下次重它离开的地点继续执行

     
b、
生成器表明式:类似于列表推导,不过,生成器重回按需发生结果的2个目的,而不是二次创设2个结实列表**

生成器函数

威尼斯人线上娱乐 15

def func():
    print('aaaa')
    a = 1
    yield a    #返回第一个值
    print('bbbb')
    yield 12   #返回第二个值
ret = func()  #拿到一个生成器
print(ret)
print(next(ret)) #取第一个值
print(next(ret)) #取第二个值
print(next(ret)) #取第三个值 会报错 因为没有第三个值

生成器函数

2② 、列表推导式

平常:

威尼斯人线上娱乐 16

for i in range(100):
    print(i*i)

n*n

列表推到:

威尼斯人线上娱乐 17

l =[i*i for i in range(100)]
print(l)

n*n

2叁 、递归函数

     a、在叁个函数里调用自身

     b、Python递归最大层数限制997

     c、最大层数限制是python暗许的,可以做修改,然则不建议你改改

     d、递归实例

威尼斯人线上娱乐 18

def age(n):
    if n == 1:
        return 40
    else:
        ret = age(n-1)
        return ret + 2
age(5)

算年龄

     e、递归甘休标志:return

递归三级菜单

威尼斯人线上娱乐 19

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

def threeLM(menu):
    for key in menu:
        print(key)
    k = input(">>>")
    if k in menu:
        threeLM(menu[k])

threeLM(menu)

三级菜单

2④ 、匿名函数

     a、 匿名函数 不难的急需用函数去化解的难点 匿名函数的函数体
只有一行,也叫lambda

     b、 函数名 = lambda 参数 :返回值

   
 c、参数能够有七个,用逗号隔开分离,匿名函数不管逻辑多复杂,只可以写一行,且逻辑执行达成后的内容正是再次来到值。再次回到值和正规的函数一样可以是随意数据类型

威尼斯人线上娱乐 20

add2 = lambda x,y : x+y
ret = add2(1,2)
print(ret)

View Code
威尼斯人线上娱乐 21

l = [1,2,3,4]
print(list(map(lambda x:x*x , l)))

View Code

威尼斯人线上娱乐 22

2⑤ 、内置函数

    a、isinstance  判断变量的数据类型

temp = "asdfsdfs"  

r = isinstance(temp, list)  

print(r)

    b、lambda用法:

def f1():  

    return 123  

f2 = lambda :123  

r1 = f1()  

r2 = f2()  

print(r1,r2)

def f3(a1,a2):  

    return a1 + a2  

f4 = lambda a1,a2: a1 + a2  

r3 = f3(1,2)  

r4 = f4(3,4)  

print(r3,r4) 

    c、abs–取相对值

i = abs(-123)  

print(123)

    d、divmod  除商得余数—例如分页

a = 10 / 3  

print(a)  

r = divmod(10,3)  

print(r)  

结果:  

3.33333335  

(3,1) 

   e、eval  —–强制不更换输入类型的格式

ret = eval("1 + 3")  

print(ret)  

结果:4 

   f、filter (过滤)

ret = filter(lambda x: x >22, [11,22,33,44])  

for i in ret:  

    print(i)

  g、map  无论是map照旧filter,获得的结果都以可迭代的对象,迭代器的实例

def f1(x):  

    if x % 2 == 1:  

       return x + 100  

    else:  

       return x  

ret = map(f1, [1,2,3,4,5])  

ret2 = map(lambda x: x + 100if x % 2 == 1 else x ,[1,2,3,4,5])  

print(ret)  

for i in ret :  

    print(i) 

   h、max()最大数 min()  最小数

li = [11,22,123,1]  

r = max(li)  

print(r)  

a = min(li)  

print(a) 

   g、pow(x,y) —-就是求x的y次方

i = pow(2,100)  

print(i) 

   k、zip —意思正是取多少个变量中索引相对应的值

li1 = [11,22,33,44]  

li2 =["a",'VV',"c","E"]  

r = zip(li1,li2)  

print(r)  

for i in r :  

    print(i)

【威尼斯人线上娱乐】Python基础之函数,Python之函数总括。  l、、open—打开,关闭,close

模式    描述
r      打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。
rb     打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。
r+     打开用于读和写文件。文件指针置于该文件的开头。
rb+    打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。
w      打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
wb     打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
w+     打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
wb+    打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
a      打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说,该文件是在追加模式。如果该文件不存在,它会创建一个用于写入的新文件。
ab     打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说,文件是在追加模式。 如果该文件不存在,它会创建一个用于写入的新文件。
a+     打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建用于读写操作的新文件。
ab+    打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建读写操作的新文件。

 

 

 

 

 

 

        

 

 

   

 

 

 

       

 

   

一 、函数
① 、为何要用函数 a、制止代码重用 b、进步代码的可读性 贰 、函数的调用
再次回到值=函数名(参数1,参…

  我们能够用一段代码来促成我们需求的效果,不过当我们必要重复使用那段代码时,复制粘贴并不是三个酷的章程,大家得以用到函数来贯彻这一须求

Python基础之函数,python基础

  大家得以用一段代码来促成我们须求的功能,然则当大家要求重复使用那段代码时,复制粘贴并不是3个酷的主意,大家能够用到函数来贯彻这一必要

一 、函数定义

函数是逻辑结构化和进度化的一种编制程序方法,通过3个函数名封装好一串用来形成某一特定功用的代码

函数的定义:

def 函数名(参数1,参数2….):

  ”注释”

  函数体 

def func1():  #定义函数
    print('this is a function')  #函数体
func1()  #调用函数

#通常无参函数不需要返回值,有参函数需要有返回值
def func1(name):  #带参数的形式
    print('%s is a good man'%name)
func1('egon')

#关于函数的返回值,如果没有指定,默认是None
#函数与过程的定义就是过程没有返回值,用完之后就没有了,而函数有返回值
def func1(name):
    print('%s is a good man'%name)
print(func1('egon')) 

–>  egon is a good man

    None

函数的亮点:1.代码起用

      2.保证一致性,易于维护

      3.可扩展性好

只顾:1.函数必须先定义,在选取,和变量类似,在概念前使用会报错

   2.函数在概念阶段只检查和测试语法错误,不会实行代码,所以固然在函数体内有未定义的变量名,在函数未调用前也不会报错

   3.函数的再次来到值能够是私自档次,尽管是回来两个值,一定是元组方式

   4.return
的职能是终止函数的推行,return只举行一次,前边的情节不执行

二 、函数参数

函数的参数分为方式参数和实在参数,在函数定义的时候,函数名前面括号里的正是花样参数,在函数调用的时候,传递的参数是实际上参数。情势参数只在函数内部有效,外部无法引用。

1.形参

1)地点参数:遵照从左到右的顺序依次定义的参数 def foo(x,y,z)

  地方形参必须被传值,且多一个少三个都丰硕

2)私下认可参数:在函数定义阶段就已经为形参赋值,调用阶段不赋值也会有暗中同意值
def foo(x,y=10)

  值平时变化的景况,平常定义成职责参数,不过值在当先3/6状态下不变的情事下,能够定义成暗中同意参数

注意:

a.暗中认可参数必须放在地方参数前边

b.暗许参数平常定义成不可变类型

c.默许参数只在概念时被赋值贰次

3)命名第壹字参数:def register(*,name,age)
*末端定义的形参,必须被传值,且必须以首要字的样式传值

2.实参

1)地方实参:与地方形参一一对应

2)关键字参数:实参在概念时,依据key-values的样式定义

  def foo(x,y)

  foo(x=1,y=2)

  关键字参数能够绝不向地方参数一样与形参一一对应,能够打破顺序限制

只顾:a.地方参数和根本字参数混合使用的时候,地方参数必须在事关心珍贵大字参数前边

   b.既能够是岗位实参格局,也能够是重庆大学字实参形式,不过3个形参只可以传值三次

3)可变长参数:

  按任务定义的可变长参数用*表示

  按主要性字定义的可变类型的参数用**表示  

def func(x,y,*args):
    print(x,y,args)
func(1,2,3,4,5)  --->1 2 (3 4 5)

#遇到*固然地点参数,把*前边的整个拆开,再一一匹配,多余的就以元组的样式存放到一只

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(1,y=2,z=3,a=1,b=2)---->1 2 {'z': 3, 'a': 1, 'b': 2}

#遇到**纵使首要字参数,把**末端的百分百拆成关键字,再一一匹配,多余的以字典方式存放到一道

def wrapper(*args,**kwargs):还不错任意格局,任意长度的参数

参数的概念顺序:x,y=1,*args,z,**kwargs,分别是岗位参数,默许参数,可变长地点参数,命名第壹字参数,可变类型参数

但须要专注的是,这一个参数并不会同时全数面世

三 、名称空间和功效域

名称空间存放名字和值的绑定关系,以key-value 的款型

在Windows命令提醒行中输入指令:import this ,在结尾一行会看到这么一句话:

  Namespaces are one honking great idea — let’s do more of those!

名称空间分为三种:

1)内置名称空间:Python自带的,如print,int,len….当Python解释器运转的时候,就会生成内置名称空间

2)全局名称空间:文件级别定义的名字会存放到全局名称空间,执行Python程序的时候发出,不难点说就算从未缩进的变量名

3)局地名称空间:定义在函数(或模块、类)内部的名字,唯有在函数(模块、类)调用的时候才生效,调用停止后就会释放

加载顺序是:内置名称空间–>全局名称空间–>局地名称空间

取值顺序是:局地名称空间–>全局名称空间–>内置名称空间

肆 、函数嵌套和效能域

1.函数嵌套包涵函数的嵌套调用和函数的嵌套定义

函数嵌套调用能够用求最大值的例证来验证:

def max2(x,y):
    if x > y:
        return x
    else:
        return y
def max4(a,b,c,d):
    res1=max2(a,b) #23
    res2=max2(res1,c) #23
    res3=max2(res2,d) #31
    return res3

print(max4(11,23,-7,31))

函数嵌套定义:

def f1():
    def f2():
        def f3():
            print('from f3')
        print('from f2')
        f3()
    print('from f1')
    f2()
# print(f1)
f1()

2.作用域

1)全局成效域:内置名称空间与大局名称空间的名字属于全局范围,在漫天文件的轻易地方都能引用

2)局地成效域:属于有个别范围,只在函数内部能够被引述,局地有效

早晚要注意局地变量和全局变量的效益范围,在一些修改全局变量会出错,在全局范围引用局地变量也会出错

功用域在函数定义时就已经稳定了,不会因调用地方而变更

而是只要一定要在有个别修改全局变量,也是用艺术的,正是在要修改的变量前加二个global

x=1
def foo():
    x=10
    print(x)        

foo()       #10
print(x)    #1

x=1
def foo():
    global x
    x=10
    print(x)

foo()       #10
print(x)    #10

def foo():
    x=1
    def f2():
        x+=x
        return x
    return f2()

print(foo())        #会报错UnboundLocalError: local variable 'x' referenced before assignment

def foo():
    x=1
    def f2():
        nonlocal x  #告诉Python解释器,这里的x不是局部变量,只会找函数内部的,不会修改全局变量
        x+=x
        return x
    return f2()

print(foo())    #会打印出修改后的x的值,2

5、闭包函数

概念在函数内部的函数,该内部函数包涵对表面功能域,而非全局效率域的名字的引用,那么该内部函数称为闭包函数

name='egon'
def func():
    name='alex'
    def bar():
        print(name)
    return bar

f=func()        #f就是闭包函数
print(f.__closure__[0].cell_contents)       #该命令可以查看闭包函数外面包了什么东西------>alex

闭包函数的风味:a.自带成效域,b.延迟总计(f只是得到了函数的内部存款和储蓄器地址,曾几何时用,加括号就足以运作)

闭包函数最基本的样式:

def 外部函数名():

  内部函数必要的变量

  def 内部函数名():

    引用外部变量

  return 内部函数名

六、装饰器

1.开放封闭原则:对扩大是开放的,对修改是封闭的

2.装饰器本质是自由可调用的靶子,被点缀对象也是随便可调用的对象

3.装饰器的效劳是:在不改动被点缀对象源代码及调用格局的前提下,为其添加新的成效

4.装饰器语法:在被点缀对象的正上方的独门一行,写上@装饰器名字

5.有四个装饰器的时候,每行四个,执行时从上往下运作

6.棉被服装饰函数有参数的景色:写成(*args,**kwargs)的形式

装饰器示例一:

#实现缓存网页内容的功能,下载的页面存放于文件中,如果文件内有值(文件大小不为0),
# 就优先从文件中读取网页内容,否则,就去下载,然后存到文件中
from urllib.request import urlopen
import os

cache_path=r'C:\untitled\0615Python第8天\cache_file.txt'
def make_cache(func):
    def wrapper (*args,**kwargs):
        if os.path.getsize(cache_path):
            #有缓存
            print('\033[45m========>有缓存\033[0m')
            with open(cache_path,'rb') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)#下载
            with open(cache_path,'wb') as f:#制作缓存
                f.write(res)
        return res
    return wrapper


@make_cache

def get(url):
    return urlopen(url).read()


print(get('https://www.python.org'))

装饰器示例二:

#为多个函数加上认证的功能(用户的账号密码来源于文件),要求登录成功一次,后续的函数都无需再输入用户名和密码
db_dic={
    'egon':'123',
    'alex':'alex3714',
    'yuanhao':'smallb'
}


db_path=r'C:\untitled\0615Python第8天\db_dic.txt'

with open(db_path,'w',encoding='utf-8') as f:
    f.write(str(db_dic))

login_dic={
    'user':None,
    'status':False,
}

def auth(func):
    def wrapper(*args,**kwargs):

        #加一个验证状态的字典,如果已经登录成功,下次使用就不用重新验证
        if login_dic['user'] and login_dic['status']:
            res=func(*args,**kwargs)
            return res
        else:
            name=input('name:')
            password=input('password:')
            with open(db_path, 'r', encoding='utf-8') as f:
                auth_dic = eval(f.read())
            if name in auth_dic and password==auth_dic[name]:
                print('login ok')
                login_dic['user']=name
                login_dic['status']=True
                res=func(*args,**kwargs)
                return res
            else:
                print('error')
    return wrapper

@auth
def index():
    print('welcom to the page')

@auth
def home(name):
    print('welcom  to %s\'s home page'%name)


index()
home('egon')

七、迭代器

1.对于字符串、列表、元组的数据类型,大家得以根据索引来完成迭代的效应,可是字典、集合那种没有索引的数据类型,就须求别的方法

2.Python为了提供一种不重视索引的迭代格局,为部分目的放置了__iter__方法,obj.__iter__()得到的结果正是迭代器

收获的迭代器既有.__iter__方法,又有.__next__方法

3.迭代器的帮助和益处:

  a.提供了一种不倚重索引的取值方式

  b.惰性统计,节外省部存款和储蓄器

4.迭代器的老毛病:

  a.取值不比遵照索引取值方便

  b.二回 性的,取值只好未来走,无法往前退

  c.不可能获取迭代器的尺寸

5.for循环实际上会私下认可调用.__iter__方法

6.判定是不是是可迭代对象和迭代器,能够用命令

print(isinstance(str1,Iterable)) —>判断是不是为可迭代对象

print(isinstance(str1,Iterator)) —>判断是不是为迭代器

⑧ 、生成器函数(语句情势和表达式情势)

1.生成器函数:函数体内富含有yield关键字,该函数的执行结果就是生成器

2.生成器实际正是迭代器的一种

3.yield的功能:

*  a.与return类似,都得以再次来到值,但不雷同的位置在于yield重返数十四遍值,而return只可以回去一回值
  b.为函数封装好了__iter__和__next__艺术,把函数的实行理并了结果做成了迭代器
  c.遵循迭代器的取值情势obj.__next__(),触发的函数的实施,函数暂停与再持续的状态都以由yield保存的
4.生成器言语格局利用实例*

威尼斯人线上娱乐 23

 1 #模拟linux中tail -f a.txt|grep 'error' |grep '404'的功能
 2 import time
 3 def tail(filepath,encoding='utf-8'):
 4     with open(filepath,encoding='utf-8') as f:
 5         f.seek(0,2)  #以末尾为开始位,第0个
 6         while True:
 7             line=f.readline()
 8             if line:
 9                 yield line
10             else:
11                 time.sleep(0.5)
12 
13 def grep(lines,pattern):
14     for line in lines:
15         if pattern in line:
16             # print(line)
17             yield line
18 
19 g1=tail('a.txt')
20 g2=grep(g1,'error')
21 g3=grep(g2,'404')
22 
23 for i in g3:
24     print(i)

View Code

5.生成器的表达式情势

def foo():
    print('starting')
    while True:
        x=yield #默认就是yield None
        print('value :',x)

g=foo() 
next(g)  #初始化,等同于g.send(None)
g.send(2)  

将yield赋值给叁个变量如x=yield,然后用send()传值,但只顾要先做3个近似开头化的操作

g.send(2)的操作实际是先把2传值给yield,再由yield传值给x,send()既有传值的作用,又有next()的功用

生成器表明式形式利用示范

威尼斯人线上娱乐 24

 1 def init(func):
 2     def wrapper(*args,**kwargs):
 3         g=func(*args,**kwargs)
 4         next(g)
 5         return g
 6     return wrapper
 7 @init
 8 def eater(name):
 9     print('%s ready to eat' %name)
10     food_list=[]
11     while True:
12         food=yield food_list#return None
13         food_list.append(food)
14         print('%s start to eat %s' %(name,food))
15 
16 
17 e=eater('alex')
18 print(e.send('狗屎'))
19 print(e.send('猫屎'))
20 print(e.send('alex屎'))
21 
22 
23 def make_shit(people,n):
24     for i in range(n):
25         people.send('shit%s' %i)
26 
27 e=eater('alex')
28 make_shit(e,5)
29 #from egon
30 #egon老师的例子有味道,但是我又忍不住不用这个

View Code

玖 、长富表达式

res= x if x>y else
y—–>衡量圭表x>y是不是为真,为真则把x赋给res,否则把y赋给res

十 、列表解析

s='hello'
res=[i.upper() for i in s]
print(res)          #['H', 'E', 'L', 'L', 'O']

大家能够用一段代码来贯彻我们供给的机能,但是当我们须求重复使用这段代码时,复制粘贴并不是二个酷的方…

壹 、为啥要用函数

① 、函数定义

    a、防止代码重用

函数是逻辑结构化和进度化的一种编制程序方法,通过3个函数名封装好一串用来实现某一一定功用的代码

    b、提升代码的可读性

函数的概念:

贰 、函数的调用

def 函数名(参数1,参数2….):

   返回值=函数名(参数1,参数2)

  ”注释”

   函数定义—重回值

  函数体 

   关键字:return

def func1():  #定义函数
    print('this is a function')  #函数体
func1()  #调用函数

#通常无参函数不需要返回值,有参函数需要有返回值
def func1(name):  #带参数的形式
    print('%s is a good man'%name)
func1('egon')

#关于函数的返回值,如果没有指定,默认是None
#函数与过程的定义就是过程没有返回值,用完之后就没有了,而函数有返回值
def func1(name):
    print('%s is a good man'%name)
print(func1('egon')) 

3、return的作用:

–>  egon is a good man

    a、甘休函数的实施

    None

    b、重回要再次来到的值

函数的独到之处:1.代码录用

肆 、重返值的三种情景

      2.保持一致性,易于维护

    a、再次回到值为None

      3.可扩大性好

威尼斯人线上娱乐 25威尼斯人线上娱乐 26

在意:1.函数须求先定义,在利用,和变量类似,在概念前应用会报错

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)


str_len = mylen()
print(str_len)

   2.函数在概念阶段只检查和测试语法错误,不会实施代码,所以纵然在函数体内有未定义的变量名,在函数未调用前也不会报错

不写return

   3.函数的重返值能够是任意档次,假设是再次来到四个值,一定是元组情势

威尼斯人线上娱乐 27威尼斯人线上娱乐 28

   4.return
的机能是终止函数的实施,return只进行一次,前边的内容不履行

def ret():
    print(111)
    return
    print(222)

re = ret()
print(re)

② 、函数参数

只写return

函数的参数分为格局参数和事实上参数,在函数定义的时候,函数名前面括号里的正是花样参数,在函数调用的时候,传递的参数是事实上参数。情势参数只在函数内部有效,外部不能够引用。

威尼斯人线上娱乐 29威尼斯人线上娱乐 30

1.形参

def ret():
    print(111)
    return None
    print(222)

re = ret()
print(re)

1)地点参数:依照从左到右的相继依次定义的参数 def foo(x,y,z)

return None

  地点形参必须被传值,且多一个少1个都丰硕

    b、重临值不为None

2)默许参数:在函数定义阶段就早已为形参赋值,调用阶段不赋值也会有私下认可值
def foo(x,y=10)

         壹 、再次回到二个值

  值平常变化的事态,平时定义成职分参数,不过值在大部情景下不变的境况下,能够定义成暗中认可参数

威尼斯人线上娱乐 31威尼斯人线上娱乐 32

注意:

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

str_len = mylen()
print(str_len)

a.私下认可参数必须放在地方参数后边

归来一个值

b.暗许参数平时定义成不可变类型

          贰 、重临多个值

c.私下认可参数只在概念时被赋值一遍

⑤ 、函数的调用—-接受重回值

3)命名第三字参数:def register(*,name,age)
*背后定义的形参,必须被传值,且必须以主要字的样式传值

   a、再次回到值为None    不收受

2.实参

   b、再次回到值不为None

1)地点实参:与职责形参一一对应

       1、再次回到四个值

2)关键字参数:实参在概念时,依据key-values的花样定义

               用贰个变量接受

  def foo(x,y)

       ② 、再次来到多少个值

  foo(x=1,y=2)

               a、用1个变量接受,接受的结果是贰个元祖

  关键字参数能够毫无向地方参数一样与形参一一对应,能够打破顺序限制

               b、有稍许个重临值就用多少个值接受

小心:a.地点参数和重庆大学字参数混合使用的时候,地方参数必须在根本字参数后面

6、参数

   b.既能够是岗位实参格局,也可以是非同平日字实参方式,可是三个形参只可以传值3遍

    a、参数—-站在概念函数的角度

3)可变长参数:

         一 、地方参数

  按职责定义的可变长参数用*表示

         二 、暗中同意参数

  按首要性字定义的可变类型的参数用**表示  

         三 、动态参数

def func(x,y,*args):
    print(x,y,args)
func(1,2,3,4,5)  --->1 2 (3 4 5)

              a、*args

#遇到*即使地点参数,把*后边的整个拆开,再一一匹配,多余的就以元组的样式存放到联合

              b、**kwargs

def func(x,y,**kwargs):
    print(x,y,kwargs)
func(1,y=2,z=3,a=1,b=2)---->1 2 {'z': 3, 'a': 1, 'b': 2}

梯次:地方参数、*args、默许参数、**kwargs

#遇到**尽管重点字参数,把**背后的万事拆成主要字,再一一匹配,多余的以字典方式存放到联合

     b、参数—-站在调用函数的角度上

def wrapper(*args,**kwargs):能够承受任意情势,任意长度的参数

         壹 、依据职位传参

参数的定义顺序:x,y=1,*args,z,**kwargs,分别是岗位参数,私下认可参数,可变长位置参数,命名主要字参数,可变类型参数

         贰 、根据重点字传参

但必要留意的是,那一个参数并不会同时整个并发

         ③ 、动态传参*tup,**dic

三 、名称空间和效用域

⑦ 、参数分为形参和实参   

名称空间存放名字和值的绑定关系,以key-value 的花样

     a、实参:调用函数的时候传出的参数

在Windows命令提醒行中输入指令:import this ,在终极一行会看出这样一句话:

捌 、地点参数

  Namespaces are one honking great idea — let’s do more of those!

     a、地方参数必须传值

名称空间分为二种:

威尼斯人线上娱乐 33威尼斯人线上娱乐 34

1)内置名称空间:Python自带的,如print,int,len….当Python解释器运行的时候,就会变卦内置名称空间

def aaa(a,b):
    print(a,b)
aaa(1,2)

2)全局名称空间:文件级别定义的名字会存放到全局名称空间,执行Python程序的时候发出,不难点说不怕没有缩进的变量名

岗位参数

3)局地名称空间:定义在函数(或模块、类)内部的名字,唯有在函数(模块、类)调用的时候才生效,调用甘休后就会自由

玖 、暗中同意参数

加载顺序是:内置名称空间–>全局名称空间–>局地名称空间

     a、暗中同意参数能够不传值

取值顺序是:局地名称空间–>全局名称空间–>内置名称空间

威尼斯人线上娱乐 35威尼斯人线上娱乐 36

④ 、函数嵌套和作用域

def bbb(x=10):
    print(x)
 bbb()     #x = 10
 bbb(20)  #x = 20

1.函数嵌套包蕴函数的嵌套调用和函数的嵌套定义

默许参数

函数嵌套调用可以用求最大值的事例来表明:

十 、动态参数

def max2(x,y):
    if x > y:
        return x
    else:
        return y
def max4(a,b,c,d):
    res1=max2(a,b) #23
    res2=max2(res1,c) #23
    res3=max2(res2,d) #31
    return res3

print(max4(11,23,-7,31))

威尼斯人线上娱乐 37威尼斯人线上娱乐 38

函数嵌套定义:

def ccc(*args):#1,2,3,4,5
    print(args)

ccc(1,2,3,4,5)#按位置传参数

t = (1,2,3,4,5)
ccc(t)  ((1, 2, 3, 4, 5),)
ccc(*t)  (1, 2, 3, 4, 5)
复制代码
def f1():
    def f2():
        def f3():
            print('from f3')
        print('from f2')
        f3()
    print('from f1')
    f2()
# print(f1)
f1()

动态参数

2.作用域

威尼斯人线上娱乐 39威尼斯人线上娱乐 40

1)全局作用域:内置名称空间与大局名称空间的名字属于全局范围,在全部文件的妄动地方都能引用

def ddd(**kwargs):
    print(kwargs)

 ddd(k = 'a',j = 'b')#按关键字传参数

2)局地成效域:属于有个别范围,只在函数内部能够被引用,局地有效

动态参数+关键字参数

一定要留心局地变量和全局变量的作用范围,在一部分修改全局变量会出错,在大局范围引用局地变量也会出错

威尼斯人线上娱乐 41威尼斯人线上娱乐 42

成效域在函数定义时就早已定位了,不会因调用地点而改变

def eee(*args,**kwargs):
    print(args,kwargs)

 eee(12,123)

不过如若一定要在部分修改全局变量,也是用艺术的,就是在要修改的变量前加二个global

动态,先按岗位参数,再按重要性字参数

x=1
def foo():
    x=10
    print(x)        

foo()       #10
print(x)    #1

x=1
def foo():
    global x
    x=10
    print(x)

foo()       #10
print(x)    #10

def foo():
    x=1
    def f2():
        x+=x
        return x
    return f2()

print(foo())        #会报错UnboundLocalError: local variable 'x' referenced before assignment

def foo():
    x=1
    def f2():
        nonlocal x  #告诉Python解释器,这里的x不是局部变量,只会找函数内部的,不会修改全局变量
        x+=x
        return x
    return f2()

print(foo())    #会打印出修改后的x的值,2

1一 、命名空间

伍 、闭包函数

     a、命名空间分为二种

概念在函数内部的函数,该内部函数包蕴对表面功效域,而非全局功能域的名字的引用,那么该内部函数称为闭包函数

            一 、全局命名空间

name='egon'
def func():
    name='alex'
    def bar():
        print(name)
    return bar

f=func()        #f就是闭包函数
print(f.__closure__[0].cell_contents)       #该命令可以查看闭包函数外面包了什么东西------>alex

            贰 、局地命名空间

闭包函数的特点:a.自带效能域,b.延迟总结(f只是得到了函数的内部存款和储蓄器地址,哪一天用,加括号就能够运行)

            三 、内置命名空间

闭包函数最基本的情势:

     b、二种命名空间的顺序:内置命名空间>全局命名空间>局地命名空间

def 外部函数名():

     c、取值

  内部函数必要的变量

           ① 、在一部分调用:局地命名空间->全局命名空间->内置命名空间

  def 内部函数名():

威尼斯人线上娱乐 43威尼斯人线上娱乐 44

    引用外部变量

x = 1
def f(x):
    print(x)

print(10)

  return 内部函数名

View Code

六、装饰器

          贰 、在大局调用:全局命名空间->内置命名空间

1.盛安阳闭原则:对扩充是开放的,对修改是封闭的

威尼斯人线上娱乐 45威尼斯人线上娱乐 46

2.装饰器本质是随机可调用的靶子,被点缀对象也是任意可调用的对象

x = 1
def f(x):
    print(x)

f(10)
print(x)

3.装饰器的法力是:在不改动被点缀对象源代码及调用格局的前提下,为其添加新的效能

View Code

4.装饰器语法:在被点缀对象的正上方的独立一行,写上@装饰器名字

12、作用域

5.有五个装饰器的时候,每行二个,执行时从上往下运作

      a、
 作用域正是效益范围,遵照生效范围可以分为全局作用域和部分作用域。

6.棉被服装饰函数有参数的状态:写成(*args,**kwargs)的形式

      b、
 全局功效域:包蕴放到名称空间、全局名称空间,在整个文件的任意地方都能被引述、全局有效

装饰器示例一:

      c、局地功能域:局地名称空间,只幸亏一部分范围生效

#实现缓存网页内容的功能,下载的页面存放于文件中,如果文件内有值(文件大小不为0),
# 就优先从文件中读取网页内容,否则,就去下载,然后存到文件中
from urllib.request import urlopen
import os

cache_path=r'C:\untitled\0615Python第8天\cache_file.txt'
def make_cache(func):
    def wrapper (*args,**kwargs):
        if os.path.getsize(cache_path):
            #有缓存
            print('\033[45m========>有缓存\033[0m')
            with open(cache_path,'rb') as f:
                res=f.read()
        else:
            res=func(*args,**kwargs)#下载
            with open(cache_path,'wb') as f:#制作缓存
                f.write(res)
        return res
    return wrapper


@make_cache

def get(url):
    return urlopen(url).read()


print(get('https://www.python.org'))
作用域:
小范围的可以用大范围的
但是大范围的不能用小范围的
范围从大到小(图)
在小范围内,如果要用一个变量,是当前这个小范围有的,就用自己的
如果在小范围内没有,就用上一级的,上一级没有就用上上一级的,以此类推。
如果都没有,报错

装饰器示例二:

13、闭包

#为多个函数加上认证的功能(用户的账号密码来源于文件),要求登录成功一次,后续的函数都无需再输入用户名和密码
db_dic={
    'egon':'123',
    'alex':'alex3714',
    'yuanhao':'smallb'
}


db_path=r'C:\untitled\0615Python第8天\db_dic.txt'

with open(db_path,'w',encoding='utf-8') as f:
    f.write(str(db_dic))

login_dic={
    'user':None,
    'status':False,
}

def auth(func):
    def wrapper(*args,**kwargs):

        #加一个验证状态的字典,如果已经登录成功,下次使用就不用重新验证
        if login_dic['user'] and login_dic['status']:
            res=func(*args,**kwargs)
            return res
        else:
            name=input('name:')
            password=input('password:')
            with open(db_path, 'r', encoding='utf-8') as f:
                auth_dic = eval(f.read())
            if name in auth_dic and password==auth_dic[name]:
                print('login ok')
                login_dic['user']=name
                login_dic['status']=True
                res=func(*args,**kwargs)
                return res
            else:
                print('error')
    return wrapper

@auth
def index():
    print('welcom to the page')

@auth
def home(name):
    print('welcom  to %s\'s home page'%name)


index()
home('egon')

       a、闭包分为:

七、迭代器

            ① 、闭:内部函数

1.对此字符串、列表、元组的数据类型,我们能够根据索引来实现迭代的职能,可是字典、集合那种没有索引的数据类型,就必要其它措施

            贰 、包:包蕴对外表函数的效能域中变量的引用

2.Python为了提供一种不信赖索引的迭代格局,为一些目的放置了__iter__方法,obj.__iter__()获得的结果正是迭代器

       b、闭包常用的的款型

取得的迭代器既有.__iter__方法,又有.__next__方法

威尼斯人线上娱乐 47威尼斯人线上娱乐 48

3.迭代器的独到之处:

def hei():
    x = 20
    def inner():
        print(x)  #局部的
    return inner

i = hei()
i()  #全局

  a.提供了一种不注重索引的取值情势

闭包常用格局

  b.惰性计算,节省里部存储器

1四 、函数值装饰器

4.迭代器的后天不足:

      a、装饰器的天柱山真面目:闭包函数

  a.取值比不上依照索引取值方便

     
b、装饰器的成效:正是在不更改原函数调用格局的处境下,在那么些函数的上下加上扩大作用

  b.1回 性的,取值只好今后走,无法往前退

威尼斯人线上娱乐 49威尼斯人线上娱乐 50

  c.不恐怕获取迭代器的尺寸

def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner

@timer
def func1(a):
    print(a)

func1(1)

5.for循环实际上会暗中同意调用.__iter__方法

带参数的装饰器

6.判定是不是是可迭代对象和迭代器,能够用命令

1伍 、装饰器的绽泰安闭原则:

print(isinstance(str1,Iterable)) —>判断是还是不是为可迭代对象

      a、对扩张是开放的

print(isinstance(str1,Iterator)) —>判断是还是不是为迭代器

      b、对修改是查封的

八 、生成器函数(语句情势和表达式情势)

威尼斯人线上娱乐 51威尼斯人线上娱乐 52

1.生成器函数:函数体内含有有yield关键字,该函数的执行结果就是生成器

def timer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner

2.生成器实际就是迭代器的一种

装饰器的固定情势

3.yield的功能:

1⑥ 、装饰器应用场景

*  a.与return类似,都得以再次回到值,但不均等的地点在于yield重回数次值,而return只好回去3次值
  b.为函数封装好了__iter__和__next__艺术,把函数的执行结果做成了迭代器
  c.遵从迭代器的取值格局obj.__next__(),触发的函数的推行,函数暂停与再持续的意况都是由yield保存的
4.生成器言语情势利用实例*

      a、总计func的实践时间

威尼斯人线上娱乐 53威尼斯人线上娱乐 54

      b、登录认证

 1 #模拟linux中tail -f a.txt|grep 'error' |grep '404'的功能
 2 import time
 3 def tail(filepath,encoding='utf-8'):
 4     with open(filepath,encoding='utf-8') as f:
 5         f.seek(0,2)  #以末尾为开始位,第0个
 6         while True:
 7             line=f.readline()
 8             if line:
 9                 yield line
10             else:
11                 time.sleep(0.5)
12 
13 def grep(lines,pattern):
14     for line in lines:
15         if pattern in line:
16             # print(line)
17             yield line
18 
19 g1=tail('a.txt')
20 g2=grep(g1,'error')
21 g3=grep(g2,'404')
22 
23 for i in g3:
24     print(i)

17、可迭代

View Code

     
a、字符串,列表,集合,字典,元祖那个度可以for循环,说明他俩是可迭代的

5.生成器的表明式方式

      b、迭代便是:将某些数据集内的数额3个挨二个的取出来,就 叫做可迭代

def foo():
    print('starting')
    while True:
        x=yield #默认就是yield None
        print('value :',x)

g=foo() 
next(g)  #初始化,等同于g.send(None)
g.send(2)  

      c、可迭代对应标志:__iter__

将yield赋值给贰个变量如x=yield,然后用send()传值,但只顾要先做二个类似初步化的操作

1⑧ 、迭代协商

g.send(2)的操作实际是先把2传值给yield,再由yield传值给x,send()既有传值的成效,又有next()的功力

     
a、可望那个数据类型里的事物也可以利用for被一个2个的取出来,那我们就亟须知足for的供给

生成器表明式格局利用示范

      b、可迭代协议——凡是可迭代的中间都有三个__iter__方法

威尼斯人线上娱乐 55威尼斯人线上娱乐 56

1⑨ 、迭代器协议

 1 def init(func):
 2     def wrapper(*args,**kwargs):
 3         g=func(*args,**kwargs)
 4         next(g)
 5         return g
 6     return wrapper
 7 @init
 8 def eater(name):
 9     print('%s ready to eat' %name)
10     food_list=[]
11     while True:
12         food=yield food_list#return None
13         food_list.append(food)
14         print('%s start to eat %s' %(name,food))
15 
16 
17 e=eater('alex')
18 print(e.send('狗屎'))
19 print(e.send('猫屎'))
20 print(e.send('alex屎'))
21 
22 
23 def make_shit(people,n):
24     for i in range(n):
25         people.send('shit%s' %i)
26 
27 e=eater('alex')
28 make_shit(e,5)
29 #from egon
30 #egon老师的例子有味道,但是我又忍不住不用这个

      a、迭代器协议 : 里面贯彻了__iter__
__next__方法

View Code

 可迭代和迭代器的差别点 :
迭代器多落成了1个__next__方法

九 、安慕希表明式

 可迭代和迭代器的相同点 : 都足以用for循环

res= x if x>y else
y—–>度量圭表x>y是还是不是为真,为真则把x赋给res,不然把y赋给res

20、判断迭代器和可迭代的法门 

10、列表解析

       a、第1种:判断其中是否促成了 __next__** **

s='hello'
res=[i.upper() for i in s]
print(res)          #['H', 'E', 'L', 'L', 'O']

                           ‘__next__’ in dir(o)

       b、第二种

from collections import Iterable  #可迭代
from collections import Iterator  #迭代器
isinstance(o,Iterable)
isinstance(o,Iterator)

21、生成器

     
a、生成器函数:常规函数定义,不过,使用yield语句而不是return语句重临结果。yield语句一遍回到三个结果,在各种结果中间,

          挂起函数的情事,以便下次重它离开的地点继续执行

     
b、
生成器表明式:类似于列表推导,可是,生成器重临按需发生结果的三个对象,而不是2次营造五个结果列表**

生成器函数

威尼斯人线上娱乐 57威尼斯人线上娱乐 58

def func():
    print('aaaa')
    a = 1
    yield a    #返回第一个值
    print('bbbb')
    yield 12   #返回第二个值
ret = func()  #拿到一个生成器
print(ret)
print(next(ret)) #取第一个值
print(next(ret)) #取第二个值
print(next(ret)) #取第三个值 会报错 因为没有第三个值

生成器函数

2二 、列表推导式

平常:

威尼斯人线上娱乐 59威尼斯人线上娱乐 60

for i in range(100):
    print(i*i)

n*n

列表推到:

威尼斯人线上娱乐 61威尼斯人线上娱乐 62

l =[i*i for i in range(100)]
print(l)

n*n

2三 、递归函数

     a、在两个函数里调用本人

     b、Python递归最大层数限制997

     c、最大层数限制是python私下认可的,能够做修改,不过不建议你改改

     d、递归实例

威尼斯人线上娱乐 63威尼斯人线上娱乐 64

def age(n):
    if n == 1:
        return 40
    else:
        ret = age(n-1)
        return ret + 2
age(5)

算年龄

     e、递归甘休标志:return

递归三级菜单

威尼斯人线上娱乐 65威尼斯人线上娱乐 66

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

def threeLM(menu):
    for key in menu:
        print(key)
    k = input(">>>")
    if k in menu:
        threeLM(menu[k])

threeLM(menu)

三级菜单

2④ 、匿名函数

     a、 匿名函数 不难的须要用函数去消除的题材 匿名函数的函数体
唯有一行,也叫lambda

     b、 函数名 = lambda 参数 :返回值

   
 c、参数能够有两个,用逗号隔离,匿名函数不管逻辑多复杂,只好写一行,且逻辑执行达成后的剧情正是重返值。重临值和常规的函数一样能够是不管三七二十一数据类型

威尼斯人线上娱乐 67威尼斯人线上娱乐 68

add2 = lambda x,y : x+y
ret = add2(1,2)
print(ret)

View Code

威尼斯人线上娱乐 69威尼斯人线上娱乐 70

l = [1,2,3,4]
print(list(map(lambda x:x*x , l)))

View Code

威尼斯人线上娱乐 71

2伍 、内置函数

    a、isinstance  判断变量的数据类型

temp = "asdfsdfs"  

r = isinstance(temp, list)  

print(r)

    b、lambda用法:

def f1():  

    return 123  

f2 = lambda :123  

r1 = f1()  

r2 = f2()  

print(r1,r2)

def f3(a1,a2):  

    return a1 + a2  

f4 = lambda a1,a2: a1 + a2  

r3 = f3(1,2)  

r4 = f4(3,4)  

print(r3,r4) 

    c、abs–取相对值

i = abs(-123)  

print(123)

    d、divmod  除商得余数—例如分页

a = 10 / 3  

print(a)  

r = divmod(10,3)  

print(r)  

结果:  

3.33333335  

(3,1) 

   e、eval  —–强制不变换输入类型的格式

ret = eval("1 + 3")  

print(ret)  

结果:4 

   f、filter (过滤)

ret = filter(lambda x: x >22, [11,22,33,44])  

for i in ret:  

    print(i)

  g、map  无论是map依然filter,获得的结果都是可迭代的靶子,迭代器的实例

def f1(x):  

    if x % 2 == 1:  

       return x + 100  

    else:  

       return x  

ret = map(f1, [1,2,3,4,5])  

ret2 = map(lambda x: x + 100if x % 2 == 1 else x ,[1,2,3,4,5])  

print(ret)  

for i in ret :  

    print(i) 

   h、max()最大数 min()  最小数

li = [11,22,123,1]  

r = max(li)  

print(r)  

a = min(li)  

print(a) 

   g、pow(x,y) —-就是求x的y次方

i = pow(2,100)  

print(i) 

   k、zip —意思正是取七个变量中索引相对应的值

li1 = [11,22,33,44]  

li2 =["a",'VV',"c","E"]  

r = zip(li1,li2)  

print(r)  

for i in r :  

    print(i)

  l、、open—打开,关闭,close

模式    描述
r      打开一个文件为只读。文件指针被放置在文件的开头。这是默认模式。
rb     打开一个文件只能以二进制格式读取。文件指针被放置在文件的开头。这是默认模式。
r+     打开用于读和写文件。文件指针置于该文件的开头。
rb+    打开用于读取和写入二进制格式的文件。文件指针置于该文件的开头。
w      打开一个文件只写。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
wb     打开一个文件只能以二进制格式写入。如果文件存在覆盖该文件。如果该文件不存在,则创建写入新文件。
w+     打开文件为写入和读取模式。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
wb+    打开用于以二进制格式写入和读出文件。如果文件存在覆盖现有文件。如果该文件不存在,创建用于读写操作的新文件。
a      打开用于追加的文件。文件指针是在文件是否存在该文件的末尾。也就是说,该文件是在追加模式。如果该文件不存在,它会创建一个用于写入的新文件。
ab     打开文件用于二进制格式追加。文件指针是在文件是否存在该文件的末尾。也就是说,文件是在追加模式。 如果该文件不存在,它会创建一个用于写入的新文件。
a+     打开文件为追加和读取方式。文件指针是在文件是否存在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建用于读写操作的新文件。
ab+    打开一个文件以附加和二进制格式读取模式。如果该文件存在文件指针在该文件的末尾。该文件以追加模式打开。如果该文件不存在,它将创建读写操作的新文件。

 

 

 

 

 

 

        

 

 

   

 

 

 

       

 

   


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图