python中的函数

定义一个函数

def hello():
    print('python') ##这个函数的功能就是打印python

通过函数名来调用函数

函数必须经过调用才能作用

hello()   ##运行打印出python

函数的定义嵌套和调用

当函数定义有嵌套时，调用时，从内到外逐层调用

def westos():
    print('it is westos')
    def python():
        print('is python')
    python()  ## 先调用内部的那个函数
westos()    ##再调用外部的函数
最后显示结果时it is westos is python

形参和实参

定义函数的时候的变量 叫形参(名字任意)

def welcome(a):
    print('welcome',a)

真实的数据信息,调用函数的时候 传递 叫实参

welcome('tom')
welcome('lily')

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

位置参数:形参和实参必须保持一致

def getinfo(name,age):
    print('姓名:',name,'年龄:',age)
------------------------------------
getinfo('westos',11)   
getinfo(11,'westos')     ##这样调用要严格按照函数定义的形参顺序去传递，例如这个例子：打印出来会变成name =11 age = westos ##不符合常理
------------------------------------------------
getinfo(age=11,name='westos')   ##将形参和实参直接对应起来，不会导致顺序混乱

默认参数

设置默认参数的意义在于如果用户在调用函数时，实参的数量少于形参，不会报错，而是直接补充一个原先设定好的值，让函数调用正常执行。

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

可变参数

*a是对传递过来的值进行解包，因为如果传递过来的参数数据类型是列表、元组、集合、字典等不能进行直接的运算，要先进行解包，将其中的每个元素取出来

def mysum(*a):     
    print(*a)
    print(a)
    sum  = 0
    for item in a:
        sum += item    
    print(sum)     ##如果不进行解包，会直接报错

以下这些都是需要进行解包的参数类型

mysum(1,2,3,4,5)
mysum([1,2,3,4,5])

参数解包:在参数名前加*

nums = [1,2,3,4]
nums2 = (1,2,3,4)
nums3 = {1,2,3,4}
------------------------------
mysum(*nums) #进行解包  *nums:1 2 3 4
mysum(*nums2)
mysum(*nums3)

关键字参数

def getinfo(name,age,**k):
    print(name)
    print(age)
    print(k)
d = dict(a=1,b=2)
print(*d)
--------------------------
getinfo('westos',12,**d)

函数的返回值

返回值：函数运算的结果，还需要进一步操作，给函数一个返回值
return用来返回函数执行的结果，如果函数没有返回值，默认返回None
一旦遇到return 函数执行结束，后面的代码不会执行
多个返回值的时候，python会帮我们封装成一个元组类型
return会将执行过程中的值保存下来，留到后面再次调用时还可用，但是print,执行结束之后就回收了内存地址空间，不再保留值，无法进行再次的使用

def mypow(x,y=2):
    #print(x ** y)
    # pass    ##pass的作用是先让程序可以正常执行
    return x**y,x+y    ##返回值
a = mypow(2,4)
print(a)
print(mypow(5,2))   ##直接打印调用这个函数，可以正常执行

函数的作用域

一般而言，函数定义中的变量若在没有进行全局声明的情况下，只作用在这个函数内部，对于函数外的变量的独立的。
如果要将函数内部的变量声明为全局变量，则global a进行全局声明，但是此时id(a)，这两个变量的身份还是不一样。

a = 1       ##这个a是全局变量
print('outside:',id(a))

def fun():
    global a #声明a为全局变量
    a = 5
    print('inside:',id(a))
--------------------------------
fun()
print(a)    ##在函数内部还没有进行a为全局变量的声明时，打印出来的是1
print(id(a))

函数的练习

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

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    #返回平均值，以及列表
print(cacluate(1,2,3,4,5))    #调用函数

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

def Fun(str):     #定义函数，接受一个字符串参数
    upper = lower = 0     #定义计数器
    for i in str:     #遍历字符串
        if i.isupper():     #如果为大写字母，upper的值加一
            upper += 1
        elif i.islower():     #如果为小写，lower值加一
            lower += 1
        else:
            continue     #既不是大写又不是小写，继续执行
    return upper,lower     #返回大写和小写的数值
print(Fun('HELLO westos!'))    #调用函数，其中！不包括在upper和lower的值中

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

 import random
def fun(alist,k):
    if k < 0 or k > len(alist):
         return 'error key'
     # return alist[:k][::-1] + alist[k:][::-1]
      newl1 = alist[:k]
      newl2 = newl1[::-1]
      newl3 = alist[k:]
      newl4 = newl3[::-1]
      return newl2 + newl4

 list = []
 for i in range(30):
     num = random.randint(1,100)
     list.append(i)
     # if num not in list:
     #     list.append(num)
 print(list)
 a =fun(list,4)
 print(a)

给定一个仅包含数字 2-9 的字符串，
返回所有它能表示的字母组合。
给出数字到字母的映射如下
（与电话按键相同）。注意 1 不对应任何字母
输入：”23”
输出：[“ad”, “ae”, “af”, “bd”,
“be”, “bf”, “cd”, “ce”, “cf”].
说明：尽管上面的答案是按字典序排列的，
但是你可以任意选择答案输出的顺序

def phoneletter(digits):
    if not digits:
        return []
    keyboard = {
        '2':'abc',
        '3':'def',
        '4':'ghi',
        '5':'jkl',
        '6':'mno',
        '7':'pqrs',
        '8':'tuv',
        '9':'wxyz'
    }
    res = []
    if len(digits) == 0:
        return []
    if len(digits) == 1:
        return keyboard[digits] # 'ghi'
    result = phoneletter(digits[1:]) #phoneletter('4')
    for i in result:
        for j in keyboard[digits[0]]:
            res.append((j+i))
    return res
print(phoneletter('34'))

编写一个名为collatz()的函数,它有一个名为number的参数。
如果参数是偶数,那么collatz()就打印出number//2,并返回
该值。如果number是奇数,collatz()就打印并返回3*number+1。
然后编写一个程序,让用户输入一个整数,并不断对这个数
调用collatz(),直到函数返回值1(令人惊奇的是,这个序列
对于任何整数都有效,利用这个序列,你迟早会得到1!既使数学
家也不能确定为什么。你的程序在研究所谓的“Collatz序列”,
它有时候被称为“最简单的、不可能的数学问题”)。
输入:
3
输出:
10
5
16
8
4
2
1

题目：两个乒乓球队进行比赛，各出三人。
甲队为a,b,c三人，乙队为x,y,z三人。
已抽签决定比赛名单。有人向队员打听比赛的名单。
a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单

is 和 == 的区别

id():在内存中存储的位置
type():变量的类型
value:值
==:type value   ##判断值是否相等
is:type value id ##判断两个变量的id是否一致