Python中的函数

1.函数的定义

#f(x) = ax2 + bx + c

def hello():
    print('hello1')
    print('hello2')
    print('hello3')
hello()

 def sum_2_sum():
     num1 = 20
     num2 = 30
     result = num1 + num2
     print('%d + %d = %d' %(num1,num2,result))

 sum_2_sum()

##函数的嵌套

 def westos():
     print('is westos')
     def python():
         print('python')
     python()

 westos()

##定义函数的时候的变量 叫形参(形参可以任意起名)

def welcome(x):
    print('hello',x)

##真实的数据信息，调用函数时传递的参数 实参

welcome('alice')
welcome('coco')

2.函数形参的四大参数

参数：形参 实参
形参：位置参数 默认参数 可变参数 关键字参数

#位置参数：形参和实参个数 位置必须保持一致

# def getInfo(name,age):
#     print(name,age)
#
# getInfo('laoli',38)
# getInfo(38,'laoli')

#默认参数 形参和实参可以不一致，如果没有传递值，用默认值

# def mypow(x,y=2):
#     print(x**y)
#
# mypow(4)
# mypow(2,4)

#可变参数：
def mysum(*a):
:param a:
:return:
*a:可变参数
a：是元组数据类型

     sum = 0
     for item in a:
         sum += item
     print(sum)

 mysum(1,2,3,4,5,6)

#关键字参数

def getStuInfo(name,age,**kwargs):
**kwargs是一个字典，可以传递任意多个key-value
:param name:
:param age:
:param kwargs:
:return:

print(name,age)
print(kwargs)

getStuInfo('westos','20',gender='male',hobbies=['coding','running'])
print(getStuInfo('westos','18'))

3.函数的返回值

返回值：函数运算的结果，当还需要进一步操作是，用return来返回
函数的执行结果，如果没有返回值，默认为None
一旦遇到return，函数执行结束，后面的代码不会执行

def mypow(x,y=2):
    return x ** y, x + y
    print('hello')

#对元组进行解包

 a,b = mypow(3)
 print(a,b)
print(mypow(3))

4.变量的作用域

局部变量：在函数内部定义的变量，只在函数内部起作用，函数执行
结束，变量会自动删除
全局变量

a = 1
print('outside:',id(a))

def f():
    global a    #声明a为全局变量
    a = 5
    print('inside:',id(a))

f()
print(a)
print(id(a))

5.可变参数练习

** 案例1:
编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所
有数.

**案例2:
编写一个函数, 接收字符串参数, 返回一个元组,‘ehllo WROLD’
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.

**案例3:
编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和
一个整形数k, 返回一个新列表.
函数需求:
- 将列表下标k之前对应(不包含k)的元素逆序;
- 将下标k及之后的元素逆序;
[1,2,3,4,5] 2 [2,1,5,4,3]

def cacluate(*args):
    avg = sum(args) / len(args)
    up_avg = []
    for item in args:
        if item > avg:
            up_avg.append(item)
    return avg,up_avg

a = cacluate(1,2,3,4,5,6,7)
print(a)

def f(x):
    upper_count = 0
    lower_count = 0
    for i in x:
        if i.isupper():
            upper_count += 1
        elif i.islower():
            lower_count += 1
        else:
            continue
    return upper_count,lower_count

a = f('ehllo WROLDA')


print(a)

def fun(li,k):
    if k < 0 or k > len(li):
        return 'error'
    return li[:k][::-1] + li[k:][::-1]

print(fun([1,3,5,4,2,56,78],3))

6.函数练习2

题目需求:
对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如:
f(13) = 12 + 32 = 10
f(207) = 22 + 02 + 72 = 53
下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,
且k*f(n)=n
输入:
第一行包含3个正整数k，a, b, k>=1, a,b<=1018, a<=b;
输出：
输出对应的答案;

范例:
输入: 51 5000 10000
输出: 3

def f(n):
n = str(n)
sum = 0
for item in n:
sum += int(item) ** 2
return sum

#接收变量 k a b
s = input() #'51 5000 10000'
#存储整型k a b
li = []
for item in s.split():
    li.append(int(item))

k,a,b = li

#判断是否满足条件
count = 0

for i in range(a,b+1):
    if k * f(i) == i:
        count += 1

print(count)

7.高阶函数

高阶函数
-实参是一个函数名
-函数的返回值是一个函数

 def fun(a,b):
     return a+b

 a = fun(1,2)
 print(a)

 print(abs(-11))

 f = abs
#函数本身也可以赋值给变量，变量可以指向函数
 print(f(-10))

#传递的参数包括函数名
def fun(x,y,f):
    return f(x),f(y)

print(fun(-10,24,abs))

8.内置高阶函数

import random

map()函数接收两个参数，一个是函数，一个是序列
map将传入的函数依次作用到序列的每个元素，并把结果作为
新的序列返回

#序列[-1,2,-3,4]的每个元素求绝对值

# print(list(map(abs,[-1,2,-3,4])))

#对于序列的每个元素求阶乘（10个2-9之间的随机数）

# def f(x):
#     res = 1
#     for i in range(1,x+1):
#         res *= i
#     return res
#
# li = [random.randint(2,9) for i in range(10)]
# print(li)
#
# print(list(map(f,li)))

#转化为整型并以列表形式输出
s = '1 3 5 7 9'
# print(s.split())
print(list(map(int,s.split())))

9.内置高阶函数reduce

reduce:接收两个参数，把一个函数作用在一个序列上，reduce会把结果继续和序列的下一个元素做累积计算
reduce(f,[a,b,c,d,e]) = f(f(f(a,b),c),d)

from functools import reduce

def multi(x,y):
    return x*y

print(reduce(multi,range(1,5)))

10.内置高阶函数filter

filter过滤函数:接收一个函数和一个序列
filter函数把传入的函数依次作用于每个元素，然后根据返回值
是True汉时False来决定保留或者丢弃该元素

def isodd(num):
    if num % 2 == 0:
        return True
    else:
        return False

print(list(filter(isodd,range(100))))

11.内置高阶函数sorted

li = [2,1,3,4]
# li.sort(reverse=True)
# print(li)
# a = sorted(li)
# print(a)

info = [
    ('x1',200,32),
    ('x2',40,12),
    ('x3',40,2),
    ('x4',1000,23),
    ('x5',40,5),
]
print(sorted(info))

#按照商品数量
def sorted_by_count(x):
    return x[1]

#按照商品价格
def sorted_by_price(x):
    return x[2]

#先按数量由小到大，如果数量一样
#再按价格由小到大
def sorted_by_count_price(x):
    return x[1],x[2]



print(sorted(info,key=sorted_by_count))
print(sorted(info,key=sorted_by_price))
print(sorted(info,key=sorted_by_count_price))

12.sorted练习

# 题目需求:
给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
在原始数组上进行移动操作， 勿创建新的数组;
# 输入:
    第一行是数组长度， 后续每一行是数组的一条记录;
    4
    0
    7
    0
    2
# 输出:
    调整后数组的内容;
    4
    7
    2
    0
    0
"""

n = ''.join(input().split())
li = [int(i) for i in n]

def move(x):
    if x == 0:
        return 3
    else:
        return 2

# [4,0,7,0,2]
# [2,3,2,3,2]
# [2,2,2,3,3]

print(sorted(li,key=move))

13.匿名函数

匿名函数的关键字为lambda,冒号前面是形参，冒号后面是返回值

from functools import reduce

# def fun(*args,**kwargs):
#     return args,kwargs

# print(fun(1,2,3,4,5))

# print(lambda *args,**kwargs:(args,kwargs))

# def add(x,y):
#     return x+y

# print(reduce(lambda x,y:x+y,[1,2,3,4,5]))

# def mypow(x):
#     return x ** 2

# print(list(map(lambda x:x**2,range(1,11))))

#1~100之间的偶数
# print(list(filter(lambda x:x%2==0,range(1,101))))

nums = [0,7,0,1,2,1,5,1,7,8,0,65,1,3,4]
# nums1 = [1,0,1,0,0,0,0,0,0,0,1,0,0,0,0]
print(sorted(nums,key=lambda x:1 if x == 0 else 0))

# def f(x):
#     if x == 0:
#         return 1
#     else:
#         return 0