初识函数

一、数学定义的函数

函数的定义：给定一个数集A，对A施加对应法则f，记作f（A），得到另一个数集B，也就是B=f(A)。那么这个关系式就叫做函数关系式，简称函数。函数概念有三个要素：定义域A、值域C和对应法则f。其中核心是对应法则f，他是函数关系的本质特征。

二、Python定义函数

def cad(x):
    x += 1
    return  x
a=cad(3)
print(a)
# def:定义函数的关键字
# cad函数名称
# （内可定义形参）
# 注释（非必要信息，但强烈建议增添描述信息）
# x += 1 处理逻辑
# return 定义返回值
# cad(3)调用函数

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。

三、为什么要有函数

    1、代码复用

    2、代码保持一致性

    3、易维护、好修改

四、函数和过程

    过程是没有返回值的函数

def test01():
    msg="hello nice to meet you"
    print(msg)
def test02():
    msg="hello  nice to meet you too,i am fine"
    print(msg)
    return msg
t1 = test01()
t2 = test02()
print('from test01 return is [%s]'%t1)
print('from test02 return is [%s]'%t2)


hello nice to meet you
hello  nice to meet you too,i am fine
from test01 return is [None]
from test02 return is [hello  nice to meet you too,i am fine]

    可以看到test01返回值是None（表示没有返回值），test02是有返回值的

    函数是可以有多个返回值的，如果返回值数为0，则返回None，返回值数为1，返回返回值本身，返回值大于1，返回一个以返回值为元素的一个元祖。

五、函数的参数

    1、形参变量只有在被调用时才分配内存单元，在调用结束时，即可释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后不能再使用该形参变量。

    2、实参可以是变量、常量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，他们必须有确定的值，以便把这些值传递给形参。因此需要预先赋值。

def cal(x,y):
    res = x * y
    return res

a = 3 
b = 4 
c = cal(a,b)
print(c)


12#函数遇见第一个return就结束  其后面（包括return）的代码不再执行

x,y为形参。a，b为实参

3、位置参数和关键字：

标准调用格式是实参和形参一一对应（包括顺序）。关键字调用不需要按照顺序，但是必须一一对应，也可以混搭，但是位置参数必须在关键字参数左边。

def test(x, y, z):
    print(x,y,z)
test(1, 2, 3)
test(x=1, z=3, y=2)
test(1, 2, z=3)

1 2 3
1 2 3
1 2 3

4、默认参数（默认参数是一个值如果不赋值就是默认值，如果有赋值就是所赋的值）

def cad(x,type="sql"):
    print(x)
    print(type)
cad(2,type="mysql")

2
mysql

5、非固定长度参数*args

def cad(x,*args):
    print(x)
    print(args)
cad(2,"dasd",34)

2
('dasd', 34)

        2作为参数 传给了x，后面的作为元组传递。

6、非固定长度参数**kwargs   

def cad(x,**kwargs):
    print(x)
    print(kwargs)

cad(1,y=2,z=3)

1
{'y': 2, 'z': 3}

        1作为参数传递给x，后面以字典的形式传递

六、局部变量与全局变量

全局变量：在模块内、在所有函数的外面、在class外面

局部变量：在函数内、在class的方法内

Python搜索４个作用域[本地作用域(L)(函数内部声明但没有使用global的变量)，之后是上一层结构中def或者lambda的本地作用域(E),之后是全局作用域(G)（函数中使用global声明的变量或在模块层声明的变量），最后是内置作用域(B)（即python的内置类和函数等）］并且在第一处能够找到这个变量名的地方停下来。如果变量名在整个的搜索过程中
都没有找到，Python就会报错。

    1、顶头写的变量就是全局变量，在任何位置都可以调用。

name = "tom"
def chang_name():
    print(name)
chang_name()

tom

    2、局部变量是定义在函数或者其他内部的变量，只有在函数内部有效，如果局部变量和全局变量冲突，在函数内部优先使用局部变量。

name = "tom"
def chang_name():
    name = "alex"
    print(name)
chang_name()

alex

    3、可以在函数内部通过globa参数来定义调取全局变量

name = "tom"
def change_name2():
    print(name)
def chang_name():
    global name
    name = "alex"
    print(name)

def chang_name1():
    print(name)

change_name2()
chang_name()
chang_name1()

tom
alex
alex

先执行chang_name2,函数内没有定义name变量，所以输出全局变量tom。

在执行chang_name，函数内通过global拿到全局变量  并可以修改全局变量

再执行chang_name1时 调用全局变量时 全局变量已经改为alex。

PS：如果函数内部没有global关键字则在函数内部只能读取该变量，无法重新赋值，但是对于可变对象可以对内部元素操作比如append等，在内部赋值操作也是针对该局部变量非全局变量。
　　　　如果函数中有global关键字表示当前局部的变量其实是全局变量，可以修改及赋值。
　　　　代码规范：全局变量全部用大写，局部变量使用小写，就不会有冲突出现了

4、进一步理解全局变量与局部变量

    函数的执行顺序，当定义一个函数的时候不会调用到内存里执行，只有在调用的时候才会执行，看以下列子，函数里面嵌套函数以及函数的执行顺序。

NAME = "科比"

def NBAplayer():
    name = "奥尼尔"
    print(name)
    def CBAplayer():
        name = "易建联"
        print(name)
        def CUBAplayer():
            name="不了解"
            print(name)
        print(name)
        CUBAplayer()
    CBAplayer()
    print(name)
NBAplayer()


奥尼尔
易建联
易建联
不了解
奥尼尔

        分步分析：

        1、定义了全局变量NAME 并赋值为‘科比’

        2、调用NBAplayer函数

        3、执行NBAplayer函数内部程序，定义局部变量name，并赋值为‘奥尼尔’

        4、执行NBAplayer函数内部程序，并打印出name值为‘奥尼尔’（第一行的奥尼尔）

        5、执行NBAplayer函数内部程序，调用函数CBAplayer

        6、执行CBAplayer函数内部程序，定义局部变量name值为‘易建联’

        7、执行CBAplayer函数内部程序，并打印出name值为‘易建联’（第二行的易建联）

        8、执行CBAplayer函数内部程序，并打印出name值为‘易建联’（第三行的易建联）

        9、调用CUBAplayer函数

        10、执行CUBAplayer函数内部程序，定义局部变量name为‘不了解’

        11、执行CUBAplayer函数内部程序，并打印出name值为‘不了解’（第四行的不了解）

        12、执行NBAplayer函数内部传递打印name，因为已经跳出其他函数，这里的name值为‘奥尼尔’（第五行的奥尼尔）

5、在一个函数内部定义全局变量的例子

name = "baidu"
def first():
    name = "ali"
    def second():
        global name
        name = "meituan"
    second()
    print(name)
print(name)
first()
print(name)


baidu
meituan
meituan

    程序运行分步：

            1、定义全局变量name值为‘baidu’

            2、打印全局变量name（输出第一行baidu）

            3、调用first函数

            4、执行first函数内部程序，定义局部变量name值为‘ali’

            5、调用second函数

            6、在函数内部用global定义全局变量name

            7、修改全局变量的值name为‘meituan’

            8、打印name，这里的name值为‘ali’，因为局部变量优先于全局变量（第二行的ali）

            9、打印全局变量name，由于在函数second中用global重新定义修改了全局变量所以值为‘第三行meituan’

七、前向引用

def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo()


from foo
from bar

1、先调用foo函数。输出from foo

2、foo函数调用了bar函数，再输出from bar

调整函数顺序，将foo函数放在前面

def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
foo()
 
from foo
from bar

1，调用foo函数输出from foo

2，虽然bar函数定义在foo函数后面但是已经执行在内存里面只是假如没有运行foo函数就没有调用而已，运行了foo也就调用了bar函数输出from bar。

调整顺序把调用函数foo放在中间

def foo():
    print('from foo')
    bar()
foo()
def bar():
   print('from bar')

运行会报错，因为bar函数还有被加载进内存或者说还没用定义到bar函数

理论：函数及变量，def定义函数的时候把里面的代码当成是字符串全部放到内存里，所以即使里面有函数并没有定义也不会报错。

八、函数递归

    在函数内部可以调用其他函数，如果调用自己就是递归。

import time
def calc(n):
    print(n)
    time.sleep(2)
    calc(n)
calc(10)

time.sleep()是设置让程序每隔两秒睡一次，没隔两秒无限循环输出传入的参数，如果设置sleep则会运行不断无限循环超出内存极限直至报错。

def calnum(n):
    print(n)
    if  int(n/2)==0:
        return  n
    return  calnum(int(n/2))

calnum(10)

1，调用函数参数为10，打印10 （输出第一行10）

2，判断条件10/2取整数为5不等于0，不满足if条件

3，递归调用此时参数为5，打印5（输出第二行5）

4，判断条件5/2取整数为2不等于0，不满足if条件

5，递归调用此时参数为2，打印2（输出第三行2）

6，判断条件2/2取整数为1，不满足if条件

7，递归调用此时参数为1，打印1（输出第四行1）

8，判断条件1/2取整数为0，满足if条件返回值为参数1，退出函数。如果这里加一个n变量等于calc（10）则最后n的值为1

递归特性：

    1、必须有一个明确的结束条件。

    2、每次进入更深一层递归时，问题规模要比上次递归减小。

    3、递归效率不高，递归层次过多会导致栈溢出。

列子：递归模拟问路过程

import time

person_list = ['zhangsan','lisi','xiaohong']

def ask_way(person_list):
    print('*'*90)
    if len(person_list)==0:
        return '没人知道在哪里'
    person = person_list.pop(0)
    if person == 'xiaohong':
        return '%s 说：我知道，冬菇亚欧就在远方'%person
    print('hi 美男%s 东莞在哪里'%person)
    print('%s 回答道,我不知道，我去给你问问%s'%(person,person_list))
    time.sleep(1)
    res = ask_way(person_list)
    print('%s问的结果是：%s'%(person,res))
    return res
res = ask_way(person_list)
print(res)


******************************************************************************************
hi 美男zhangsan 东莞在哪里
zhangsan 回答道,我不知道，我去给你问问['lisi', 'xiaohong']
******************************************************************************************
hi 美男lisi 东莞在哪里
lisi 回答道,我不知道，我去给你问问['xiaohong']
******************************************************************************************
lisi问的结果是：xiaohong 说：我知道，冬菇亚欧就在远方
zhangsan问的结果是：xiaohong 说：我知道，冬菇亚欧就在远方
xiaohong 说：我知道，冬菇亚欧就在远方

递归原理如图：

九、递归的作用域

    一个函数的返回值可以是另一个函数的函数名，返回的是该函数的地址，加（）可以执行

def foo():
    name = 'lisi'
    def bar():
        print(name)
    return bar
a = foo()  #把函数的return结果赋给变量a
print(a)    #打印a  因为foo（）返回的是函数bar，所以打印的是内存地址
a()         #a加（）相当于执行了bar函数 运行打印函数内的内容

<function foo.<locals>.bar at 0x0000018B45734840>
lisi

不管在哪个位置调用，但是函数的作用域是在该函数定义时的作用域，所以这里打印出来的是list

     在看一个列子：

name = 'zhangsan'

def foo():
    name = 'lisi'
    def bar():
        name = 'wangwu'
        def tt():
            print(name)
        return  tt
    return bar

func = foo()  #执行函数foo把函数bar的内存地址赋值给变量func
print(func)   #打印bar函数的内存地址
func1 = func()  #func保存的是函数bar的内存地址所以这里是加（）执行bar函数，将函数tt的内存地址返回给变量func1
print(func1)  #打印函数tt的内存地址
func1()  #执行函数tt

<function foo.<locals>.bar at 0x0000017632C04840>
<function foo.<locals>.bar.<locals>.tt at 0x0000017632C048C8>
wangwu

十、匿名函数

    定义一个函数返回值是输入参数+1

def calx(x):
    return x+1 
print(calx(1))

2

    以上函数可以使用匿名函数实现，

func = lambda x:x+1    #:号前面是传递的参数，：号后面是return的值
print(func)
print(func(10))


<function <lambda> at 0x000001ECDE6F2EA0>
11

好处：1、用匿名函数不必担心函数名冲突，此外匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量。再利用变量来调用函数。

           2、匿名函数只有一行代码，内部不能有复杂逻辑。

            可以有多个返回值

func = lambda x,y,z:(x+1,y-1,z*3)    #:号前面是传递的参数，：号后面是return的值
print(func)
print(func(1,2,3))


<function <lambda> at 0x0000027191392EA0>
(2, 1, 9)

后面有多个返回值必须加(),否则报错，类似于函数可以有多个返回值，返回值以元祖的方式返回

十一、函数式编程

    编程方法论：

        1、面向过程

        2、函数式

        3、面向对象

        高阶函数：

        （满足两个特性任意一个即为高阶函数）

            1、函数的传入参数是一个函数名

            2、函数的返回值是一个函数名

        

函数式编程：例一：不可变；不用变量保存状态，不修改变量

#非函数式
a = 1
def incr_test1():
    global a
    a+=1
    return a
#改变了全局变量a的值
incr_test1()
print(a)
 
#函数式
n = 1
def incr_test2(n):
    return n+1
 
print(incr_test2(1))
print(n)
 
2
2
1

使用非函数式编程变量a的值有改变，使用函数式变量n的值没有改变

列二：函数名作为实参传递给另外一个函数

def foo(n):
    print(n)
def bar(name):
    print('my name is %s'%name)

foo(bar)  #把函数名作为参数传递给函数foo  打印函数bar的内存地址
foo(bar('zhangdan'))  #先执行bar('zhangsan')打印 my name is zhangsan 再把bar函数的返回值给foo函数



<function bar at 0x000001F9D3BF4840>
my name is zhangdan
None

列三：函数名作为函数返回值

def bar():
    print('from bar')

def foo():
    print('from foo')
    return  bar

n = foo()  #运行函数foo先打印from foo 然后把函数的返回值及函数bar的内存地址赋值给n
n()   #n加()运行打印from bar


from foo
from bar

函数编程四：尾调用，在函数的最后一步调用另外一个函数（最后一步不一定是最后一行）

#函数bar在foo内为尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)
 
#函数bar1和bar2在foo内均为尾调用，二者在if条件判断条件不同的情况下均有可能作为函数的最后一步
def bar1(n):
    return n
 
def bar2(n):
    return n+1
 
def foo(x):
    if type(x) is str:
        return bar1(x)
    elif type(x) is int:
        return bar2(x)
 
#函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    y = bar(x)
    return y
 
#函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)+1

十二、map函数

列：一个列表为[1,2,3,4,5]求平方以后的值

1、使用for循环实现

num = [1,2,3,4,5]
ret = []
for i in num:
    ret.append(i*2)
print(ret)

[2,4,6,8,10]

假如这样的列表有多个则需要重复代码才能实现此功能。

2、使用函数实现，如果有多个列表，可以减少代码重复

def map_test(array):
    ret = []
    for i in array:
        ret.append(i**2)
    return  ret
num = [1,2,3,4,5]
ret = map_test(num)
print(ret)

[1, 4, 9, 16, 25]

3、假设对列表的处理方法有变化不是平方而是其他，比如自增或者自减1，可以把这方法定义成另外的函数，然后在函数map_test传递参数的时候增加一个参数调用函数名来实现

def add_one(x):
    return  x+1
def reduce_one(x):
    return  x-1
def map_test(func,array):
    ret = []
    for i in array:
        ret.append(func(i))
    return ret
num = [1,2,3,4,5,6]
ret = map_test(add_one,num)
ret2 = map_test(reduce_one,num)
print(ret)
print(ret2)

[2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5]

这里调用的是add_one函数所以增加1 同理也可以定义平方函数等其他方法的函数

使用匿名函数实现

def add_one(x):
    return  x+1
def reduce_one(x):
    return  x-1
def map_test(func,array):
    ret = []
    for i in array:
        ret.append(func(i))
    return ret
num = [1,2,3,4,5,6]
ret = map_test(add_one,num)
ret2 = map_test(reduce_one,num)
ret3 = map_test(lambda x:x**2,num)
print(ret)
print(ret2)
print(ret3)

[2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5]
[1, 4, 9, 16, 25, 36]

3、使用map函数实现（返回的是一个可以迭代的内存地址，使用list迭代生产新的列表）

num = [1,2,3,4,5]
res = map(lambda x:x-1,num)
print('内置函数map处理的结果是',res)
print(list(res))

内置函数map处理的结果是 <map object at 0x000001DBA20B7DD8>
[0, 1, 2, 3, 4]

十三、filter函数

    需求：有一个人员列表，要求去掉以sb开头的人

    1、通过for循环来实现

movie_people = ['sb_zhansan','sb_lisi','wangwu']
ret = []
for p in movie_people:　　
    if not p.startswith('sb'):　　#如果不是以sb开头则把他添加到列表里面
        ret.append(p)
print(ret)
 
['wangwu']

    2、使用函数实现

def remove_sb(list):　　　　　　　　　　　　　　　　　　#定义函数形参为list一个列表
    ret = []　　　　　　　　　　　　　　　　　　　　　　 #定义一个用于接收的空列表
    for p in list:
        if not p.startswith('sb'):
           ret.appenf(p)
    return ret
 
movie_people = ['sb_zhansan','sb_lisi','wangwu']
ret = remove_sb(movie_people)
print(ret)
 
['wangwu']

3，但是处理的逻辑有可能是去掉前面的也有可能是去掉后面的字符，可以把处理的逻辑写成一个函数

movie_people = ['sb_zhansan','sb_lisi','wangwu']　　　　#处理以sb开头的字符串
def sb_show(n):　　
    return n.startswith('sb')　　　　　　　　　　　　　　　#如果是以sb开头返回True
 
def filter_test(func,array):　　　　　　　　　　　　　　　 #定义函数包含两个形参，第一个为函数名，第二个为传递的列表
    ret=[]
    for p in array:
        if not func(p):
            ret.append(p)
    return ret
 
res=filter_test(sb_show,movie_people)
print(res)
 
['wangwu']

4、使用匿名函数简化

movie_people = ['sb_zhansan','sb_lisi','wangwu']


def filter_test(func,array):
    ret=[]
    for p in array:
        if not func(p):
            ret.append(p)
    return ret

res=filter_test(lambda n:n.startswith('sb'),movie_people)
print(res)

['wangwu']

5、使用filter函数

        filter函数前面是一个函数，后面是一个可迭代的对象，把可迭代对象依次给函数处理，如果为True则保留结果，

movie_people = ['sb_zhansan','sb_lisi','wangwu']
 
 
ret = filter(lambda n:not n.startswith('sb'),movie_people)
print(ret)          #ret是一个可迭代对象打印是内存地址
print(list(ret))    #使用list方法迭代出列表
 
['wangwu']

十四、reduce函数

    需求：有一个列表num=[1,2,3,4,5,6,7,8]求里面所有数字相加的结果

    1、使用for循环实现：

num_1=[1,2,3,4,5,6,7,8,9,10]
count = 0
for i in num_1:
    count = count + i
print(count)
 
55

    2、使用函数实现：

num_1=[1,2,3,4,5,6,7,8,9,10]
def reduce_test(array):
    res = 0
    for num in array:
        res = res + num
    return res
 
res = reduce_test(num_1)
print (res)

55

3，假如方法不同不是+可能是乘或者其他，把功能细化

num_1=[1,2,3,4,5,6,7,8,9,10]
 
#def multi(x,y):
#    return x+y
def reduce_test(func,array):
    res=0
    for num in array:
        res=func(res,num)
    return res
 
res = reduce_test(lambda x,y:x+y,num_1)
print(res)
 
55

4、使用reduce函数实现，合并一个序列，结果的一个值

num_1=[1,2,3,4,5,6,7,8,9,10]
from functools import reduce        #python2可以直接使用reduce 3需要导入模块
res = reduce(lambda x,y:x+y,num_1)
print(res)
 
55

小结：

map处理序列中的每个元素，得到的结果是一个列表，该列表元素个数及位置与原来一样

filter遍历序列中的每一个元素，判断元素所得到的布尔值，如果为true则保留，反之去掉

reduce处理一个序列并把序列按照逻辑进行合并

十五、内置函数：

    1、abs() 函数返回数字的绝对值。

    2、all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

元素除了是 0、空、FALSE 外都算 TRUE。

    3、any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。

元素除了是 0、空、FALSE 外都算 TRUE。

    4、bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

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

    6、bytes把字符串编码打印结果  print(bytes('你好',encoding='utf-8'))  b'\xe4\xbd\xa0\xe5\xa5\xbd'

    7、chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

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

    9、divmod（）取商得余数print(divmod(10,3))  (3,1)    可以用于网站分页。

    10、enumerate把一个列表生产可迭代对象使索引对应的元素一一对应

res = enumerate([1,2,3])
print(res)
for index,i in res:
    print(index,i)
 
<enumerate object at 0x0000025F7642DD38>
0 1
1 2
2 3

    11、eval

            a、把字符串中的数据结构提取出来     

            b、计算表达式

dic_str = "{'name':'zhangsan'}"
express = '1*2+3+5-2'
print(eval(dic_str))
print(eval(express))

{'name': 'zhangsan'}
8

    12、hash，可hash的数据类型为不可变类型，不可hash的数据类型为可变数据类型，hash对象的码不会随hash值大写变化而变化。不能根据hash码反推出hash源。

name = 'zhangsan'
print(hash(name))
print(hash(name))
name = 'lisi'
print(hash(name))
 
5623004878365971046
5623004878365971046
-8895594236205219231

13、help() 函数用于查看函数或模块用途的详细说明。help([object])

14、hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。hex(x)

15、oct() 函数将一个整数转换成8进制字符串。oct(x)

16、id() 函数用于获取对象的内存地址。id([object])

17、print() 方法用于打印输出，最常见的一个函数。

18、int() 函数用于将一个字符串或数字转换为整型。

19、isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

print(isinstance(1,int))
 
True

20、 len() 方法返回对象（字符、列表、元组等）长度或项目个数。

21、globals全局变量，locals打印局部变量

locals() 函数会以字典类型返回当前位置的全部局部变量。对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

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

name = 'lisi'
def test():
    age  = 18
    print(globals())
    print(locals())
test()



{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001ECB1CCB240>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/admin/PycharmProjects/Pythonday02/homework01.py', '__cached__': None, 'num': [1, 2, 3, 4, 5, 6, 7, 8], 'name': 'lisi', 'test': <function test at 0x000001ECB1912EA0>}
{'age': 18}

22、max（）取最大值

23、min（）取最小值

24、zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

res = zip(('a','b'),(1,2))
print(list(res))
p = {'name':'zhangsan','age':18,'gender':'none'}
res = zip(p.keys(),p.values())
print(list(res))

[('a', 1), ('b', 2)]
[('name', 'zhangsan'), ('age', 18), ('gender', 'none')]

25、max和min的高级应用

有一个字典分别是key对应的年纪大小，需要取出里面最大的年纪

age_dic={'age1':18,'age4':20,'age3':100,'age2':30}
print(max(age_dic.values()))　　　　　　　　　　#把values作为可迭代对象然后用max取最大值
 
100

假如需要在取最大值的时候取出对应的keys 可以使用以上的zip方法，把对应的年纪和key生成一一对应的列表然后使用max比较

　　这里把年纪放在前面了，优先比较前面的

age_dic={'age1':18,'age4':20,'age3':100,'age2':30}
print(max(age_dic.values()))
 
print(max(list(zip(age_dic.values(),age_dic.keys()))))
 
100
(100, 'age3')

PS：比较的数据类型必须相同，否则报错

需求：有一个列表包含多个字典，需要比较取出年纪最大那个字典

people = [
    {'name':'zhangsan','age':18},
    {'name':'lisi','age':19},
    {'name':'wangwu','age':20}
]
 
res = max(people,key=lambda dic:dic['age'])
print(res)
 
{'age': 20, 'name': 'wangwu'}

如果是直接输入max(people)会报错，因为迭代出来的元素是字典，但是字典是无法进行比较的，这里使用了max函数的key参数指定比较的key 后面跟一个匿名函数dic返回值是对应的年纪

27，ord根据字符转换成ascii码 

print(ord('a'))
 
97

28，pow 

      a，传递两个参数求幂

print(pow(3,3))
 
27

      b，传递三个参数前两位求幂，再对最后一位取余数

print(pow(3,3,2))

1

29，range产生等差序列  range() 函数可创建一个整数列表，一般用在 for 循环中。 

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

30，reversed反转（原序列顺序不变）

l = [1,2,3]
print(list(reversed(l)))
 
[3,2,1]

31，round 四舍五入


32，set把迭代对象转换成集合

33，定义切片方法，先把切片方法定义，便于修改，也可以加参数对应切片步长(左闭右开)

l = 'ehgjsdfje'
s1 = slice(3,5)
print(l[s1])

js

34，sorted排序，用法和max，min及其类似 （a，原序列不变 b，排序本质就是在比较大小，不同类型的数据无法排序）

l = [3,2,3,1,7]
print(sorted(l))
print(l)
 
[1, 2, 3, 3, 7]
[3, 2, 3, 1, 7]

35，str转换成字符串


36，sum求和


37，tuple转换成元祖


38，type显示数据的类型


39，vars如果没有加参数打印locals变量，如果有参数打印方法，以字典的模式


40，import导入模块，模块其实就是一个py文件 可以把其他py文件写好的方法直接拿过来调用


　import不能导入字符串，__import__可以导入字符串