python-函数相关

①函数的定义和调用：

• 定义函数格式

#def 函数名(形参):
#    内容
def Num(a,b):
    return a+b
print(Num(5,10))

#执行结果：
'''
15
'''

②函数的参数:

• 必选参数

def sum(a,b):
    sum = a+b
    print(sum)
sum(333,333)

#执行结果：
'''
666
'''

• 缺省参数

def sum(a=333,b=111):
    sum = a+b
    print(sum)
sum(b=333)

#执行结果：
'''
666
'''

• 可选参数

传入的参数列表为元祖

def sumCount(*args):
    result = 0
    for item in args:
        result += item
    print(result)
sumCount(111,222,333)

#执行结果：
'''
666
'''

• 关键字参数

传入的参数列表为字典

def demo(**dict):
    print(dict)
    pass
demo(name='cjl', age=18)

#执行结果：
'''
{'name': 'cjl', 'age': 18}
'''

• 参数相关案例

def people(name, age=18, *phone, **contact):
    print("我是{0}，今年{1}岁".format(name,age))
    print("我的手机号是:{0}".format(phone))
    print("我的其他联系方式：%s"%contact)
people("cjl","19",12345,54321,qq="2653644677",wechat="chen2653644677")

#执行结果：
'''
我是cjl，今年19岁
我的手机号是:(12345, 54321)
我的其他联系方式：{'qq': '2653644677', 'wechat': 'chen2653644677'}
'''

③参数的引用：

1. 在python当中万物皆对象,在函数调用的时候，实参传递的就是对象的引用
2. 了解了原理之后，就可以更好的去把控在函数内部的处理是否会影响到函数外部的数据变化

• 参数传递是通过对象引用来完成的

li=[]
def test(parms):
    li.append([1,2,3])
    print(id(parms))
    print("内部的{}".format(parms))
print(id(li))
test(li)
print("外部的{}".format(li))

#执行结果：
'''
2712787529992
2712787529992
内部的[[1, 2, 3]]
外部的[[1, 2, 3]]
'''

④函数返回值：

• return

def fun(a,b):
    sum = a + b
    return sum, sum * a
rs1,rs2 = fun(10,10)
print('rs1={0}，rs2={1}'.format(rs1,rs2))

#执行结果：
'''
rs1=20，rs2=200
'''

⑤函数的嵌套：

• 从上向下执行

def fun1():
    print("666")
def fun2():
    print("*****")
    fun1()
    print("*****")
fun2()

#执行结果：
'''
*****
666
*****
'''

⑥变量作用域：

• 局部变量

def text1():
    a = 123
    print("修改前：%d"%a)
    a = 666
    print("修改后：%d"%a)
def text2():
    a = 888
    print("text2的a值和text1中的a值不冲突--%d"%a)
text1()
text2()

#执行结果：
'''
修改前：123
修改后：666
text2的a值和text1中的a值不冲突--888
'''

• 全局变量

a = 666  #全局变量
def text1():
    print(a) #调用全局变量a
def text2():
    print(a) #调用全局变量a
text1()
text2()

#执行结果：
'''
666
666
'''

• 局部、全局变量名相同时

a = 100  #全局变量a
def text1():
    a = 123 #局部变量a和全局变量同名时，局部优先
    print("修改前：%d"%a)
    a = 666
    print("修改后：%d"%a)
def text2():
    print("a的值为：%d"%a) #没有局部变量，默认调用全局变量
def text3():
    global a #声明全局变量在函数中的标识符
    a = 200
    print("使用global修改全局变量后：%d"%a)
text1()
text2()
text3()

#执行结果：
'''
修改前：123
修改后：666
a的值为：100
使用global修改全局变量后：200
'''

⑦匿名函数：

• lambda表达式

rs1 = lambda x,y: x if x>y else y
rs2 = (la4mbda x,y: x if x>y else y)(10,5)
print(rs1(10,5))
print(rs2)

#执行结果：
'''
10
10
'''

⑧递归函数：

• 递归的本质就是循环，函数自己调用自己，默认递归上限1000次
  • 没有尾递归优化
• 递归的两个阶段
  • 回溯：
    • 一层一层调用下去
  • 递推：
    • 满足某种结束条件，结束递归调用，然后一层一层返回

# 理由递归计算阶乘
def digui(n):
    if n == 1:
        return 1
    else:
        return n*digui(n-1)
print(digui(5))

#执行结果：
'''
120
'''

• 递归的应用：

# 取出列表内的值
l = [1,2,[3,[4,[5,[6,[7,[8,[9,[10]]]]]]]]]
def fun(list1):
    for x in list1:
        if type(x) is list:
            fun(x)
        else:
            print(x,end=' ')
fun(l)

#执行结果：
'''
1 2 3 4 5 6 7 8 9 10 
'''

⑨一些内置函数：

• cmp(a,b)
  • 用于判断a和b的大小关系，a<b返回-1，a==b返回0，a>b返回1
• eval('')
  • 用来执行一个字符串表达式，并返回表达式的值

  • a,b = 10, 6
    print(eval('a*b + pow(b,2) - 66'))
    print(int('3.14'), eval('3.14'))
    # 30
    # 3 3.14
    

• all(xxx)
  • 如果参数列表中含有False、0则返回False，否则返回True

  • li=[0,1,2]
    print(all(li))
    # False
    

• any(xxx)
  • 如果参数列表都为False、空、0则返回False，否则返回True

  • li=[0,1,2]
    print(any(li))
    # True
    

• xxx.sort()
  • 仅对list列表进行排序操作，直接修改原始对象，默认为升序
  • 参数：
    • key=len：按字符串长度排序
    • key=str.lower：忽略大小写排序
    • reverse=True：更改为降序
• sorted(xxx)
  • 对所有可迭代的对象进行排序操作，不改变原来的对象，而是返回一个新的列表，参数reverse=True时排序顺序为降序
• zip(xx,xx,...)
  • 把序列中对应的索引位置的元素，储存为一个元祖，可强转为list列表输出

  • li=['a','b','c']
    ls=['我','你','他']
    print(list(zip(li,ls)))
    # [('a', '我'), ('b', '你'), ('c', '他')]
    

• enumerate()
  • 返回一个枚举对象，用于将一个可遍历的数据对象(如：列表、元祖、字符串)组合为一个索引序列

  • li=['你','真','菜']
    for item in enumerate(li,1):
        print(item,end=' ')
    # (1, '你') (2, '真') (3, '菜') 
    

• hasattr(x,x)
  • 用于判断对象是否包含对应的属性

  • class hasattrDemo:
    a = 1
    demo = hasattrDemo()
    print(hasattr(demo,'a'),hasattr(demo,'b'))
    # True False
    

• isinstance(a,b)
  • 用于判断a是否是b类型，类似于type()
• vars()
  • 用于返回对象的属性和属性值的字典对象
• map()
  • 据提供的函数对指定序列做映射

  • def square(x):
        return x ** 2
    res = list(map(square, [1,2,3,4,5]))
    print(res)
    # 使用lambda匿名函数
    # print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
    
    # 执行结果：
    '''
    [1, 4, 9, 16, 25]
    '''
    

  • 对字典

  • L = ["1","2","3","4","5"]
    def func(key):
        dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6}
        return dic[key]
    res = list(map(func, L))
    print(res)
    
    # 执行结果：
    '''
    [1, 2, 3, 4, 5]
    '''
    

• reduce()
  • 对参数序列中元素进行累积

  • from functools import reduce
    L = [1,2,3,4,5]
    def func(x,y):
        return x*10 + y
    res = reduce(func,L)
    print(type(res), res)
    
    # 执行结果：
    '''
    <class 'int'> 12345
    '''
    

• iter():返回一个迭代器
  • next():获取迭代器中下一个元素

  • lis = [i for i in range(1,3)]
    print(lis)
    ite = iter(lis)
    print(ite)
    print(next(ite))
    print(next(ite))
    
    #执行结果：
    [1, 2]
    <list_iterator object at 0x000002515BCE5370>
    1
    2