菜鸟"Python"之————题海战术（8）

在这里插入代码片
```def hanshu():
    x=100
    def neibu():
        nonlocal x     # 修饰x说明x是外部非全局变量
        x=1000
    print(x)           #100
    neibu()            #调用内函数
    print(x)           #1000
hanshu()

函数的返回值
def qiuhe(a,b):
    c=a+b
    return c
d=qiuhe(3,4)
print(d)


def qiuhe(a,b):
    c=a+b
    d=a*b
    e=a/b
    f=a-b
    return c,d,e,f
w,x,y,z=qiuhe(4,4)
print(w,x,y,z)


a=100
def hanshu(b):
    c=a+b            #c=参数b的值加全局变量a的值（其值为最新赋的值）
    print(c)
a=200               #全局变量a的值重新赋值
def hanshu(b):
    c=a+b           #c=参数b的值加全局a的值
    print(c)
hanshu(8)          #执行函数1
hanshu(8)          #执行函数2

def hanshu(name,age,sex='男'):
    print('我叫',name,end=' ')
    print('今年',age,end=' ')
    print('性别',sex)
hanshu("张三",18)
hanshu("李四",18,'女')
hanshu('王五',18,'男')       #这三种写法都是对的


def hanshu(b,a=[]):       #a是默认参数，但是a是可变参数，后面调用此参数会保存修改后的状态
    a.append(10)
    print(a,b)
hanshu(10)
hanshu(12)

def hanshu(*args):    #可变参数，接受的参数放在元祖里
    print((args))
    for x in args:
        print(x,end=" ")
    print()
hanshu(1,2,3)
hanshu(1,2,3,4,5,6,7,8)
hanshu()

def hanshu(**kwargs):         #可变参数，字典类型，可接受任何数列的参数
    print(kwargs)
    for k,v in kwargs.items():
        print(k,v,end=" ")
    print()
hanshu(name='张三')
hanshu(name='张三',age=20,sex='男')
hanshu()

============================
a=lambda x,y:x*y+6   #小型匿名函数，x，y是接受的参数 x*y+6 是返回的表达式
print(a(5,6))
#一样
a=lambda x,y:x*y+6
b=a(5,6)
print(b)
=============================

b={'name':'张三','age':20}
def func(a):
    return b['age']
print(func(b))   #20

b={'name':'张三','age':20}
f=lambda a:a['age']             #冒号 前面是参数，后面是要返回的值，接受a返回a的属性的值
x=f(b)                      #调用lambda函数，返回赋值给x
print(x)

a=[1,-5,2]
a.sort(key=abs)  #abs是求绝对值函数，把函数名传给key，让其在内部进行函数调用
print(a)

==========================================================

def hanshu(a):
    return a['age']
a=[{'name':'zs','age':19},
   {'name':'ls', 'age': 29},
   {'name':'ww','age':39}]
b=max(a,key=hanshu)   #以函数为比较对象，次函数返回了每个元素的age的值，求最大
print(b)
一样
a=[{'name':'zs','age':19},
   {'name':'ls', 'age': 29},
   {'name':'ww','age':39}]
b=max(a,key=lambda x:x['age'])
print(b)

============================================================

a=[i for i in range(1,10)]
print(a)         #[1, 2, 3, 4, 5, 6, 7, 8, 9]


a=[i for i in range(1,10,2)]      # 2 为步长
print(a)                          #[1, 3, 5, 7, 9]


a=[i for i in range(1,10) if i%3==0 ]      # 是3的倍数
print(a)           #[3, 6, 9]

a=[i*2 for i in range(1,10) if i%3==0]
print(a)            #[6, 12, 18]

a=[i*3 for i in range(1,20)if i%5==0 or i%7==0]
print(a)                    #[15, 21, 30, 42, 45]

a=[[1,2,3],[4,5,6],[7,8,9]]
print(a[0][1])      # 2
print(a[1][2])      #6


a=[[1,2,3],[4,5,6],[7,8,9]]
b=[a[0][i] for i in range(3)]
print(b)                        # [1, 2, 3]
c=[a[i][0] for i in range(3)]
print(c)                        #[1, 4, 7]


a=[[1,2,3],[4,5,6],[7,8,9]]
b=[a[i][i] for i in range(3)]
print(b)                        #[1, 5, 9]

a=[[1,2,3],[4,5,6],[7,8,9]]
b=[a[i][2-i] for i in range(3)]
print(b)                        #[3, 5, 7]

=====================================================
a=[[1,2,3],[4,5,6],[7,8,9]]
for i in range(len(a)):                   #这是用下标的形式
    for j in range(len(a[i])):
        print(a[i][j],end=" ")      # 1 2 3 4 5 6 7 8 9
====
第二种 不用下标的方式

a=[[1,2,3],[4,5,6],[7,8,9]]
for x in a:
    for y in x:
        print(y,end=" ")
===================================================

===================================================
a=[[1,2,3],[4,5,6],[7,8,9]]
b=[a[i][j] for i in range(3) for j in range(3)]
print(b)

=第二种
a=[[1,2,3],[4,5,6],[7,8,9]]
b=[y for x in a for y in x]
print(b)

=====================================================

a={'a':1,'b':2,'c':3}            #此处 key 必须是不可变类型
b={v:k for k,v in a.items()}
print(b)                #{1: 'a', 2: 'b', 3: 'c'}   键值互换位置

========================================================
字典

a={'a':10,'A':20,'b':2,'c':3,'B':30,'D':40}
b={k.lower():(a.get(k.lower(),0)+a.get(k.upper(),0)) for k in a.keys()}
print(b)         #{'a': 30, 'b': 32, 'c': 3, 'd': 40}

==========================================================

a={'a':10,'A':20,'b':2,'c':3,'B':30,'D':40}
d={'a','b'}
b={k.lower():(a.get(k.lower(),0)+a.get(k.upper(),0)) for k in a.keys() if k in d}
print(b)            #{'a': 30, 'b': 32}

=================================

a='abc'
b='123'
c=zip(a,b)
for x,y in c:
    print(x,y)
==============================

a='abc'
b='123'
c=zip(a,b)
for x in c:
    print(x)

a=[1,2,3,4]
b=['a','b','c','d','e','f']
c=zip(a,b)                   #打包成一个zip，内部都是元祖类型，两个参数为一个元祖，以短的决定去长度
for x in c:
    print(x)

def hanshu(x):
    return x*x
a=[1,2,3,4]
d=map(hanshu,a)       # map对象，对每个a中的元素进行函数加工，返回一个新的序列
print(d)
for x in d:
    print(x)


def hanshu(a):
    if a%2==0:
        return True
a=[1,2,3,4,5,6]
b=filter(hanshu,a)      # 过滤数据，符合函数内部的要求留下
for x in b:
    print(x)

def hanshu1(a):    #过滤函数
    if a%2==0:
        return True
def hanshu2(b,a):      # b接受的是一个函数地址
    for x in a:
        if b(x)==True:    #调用b地址对应的函数
            print(x)
a=[1,2,3,4,6]
hanshu2(hanshu1,a)       # 把hanshu1的地址传递给形参b，而不是调用