python之函数

案例一：用户输入一句英文句子
打印出每一个单词及其重复的次数：
s=raw_input('s')
#把每个单词分割处理
s_li=s.split()
print s_li
#通过字典存储单词和改单词出现的次数
word_dirt={}
"""
依次循环遍历列表
如果列表元素不在字典的key中，将元素作为key，1作为value值
如果列表元素在字典的key中，直接更新元素value值，在原有的基础加一
for item in s_li:
    if item not in word_dirt:
        word_dirt[item]=1
    else:
        word_dirt[item]+=1
#打印生成的字典
print word_dirt

案例二：数字重复统计：
随即生成1000个整数
数字的范围【20，100】
#升序输出所有不同的数字及其每个数字重复的次数
import random
随机生成1000个整数
all_nums=[]
for item  in range (1000):
    #数字的范围
    all_nums.append(random.randint(20,100))
#升序输出所有不同的数字及其每个数字重复的次数
sorted_num=sorted(all_nums)
nums_dict={}
for num in sorted_num:
    if num in nums_dict:
        nums_dict[num]+=1
    else:
        nums_dict[num]=1
print nums_dict

#定义函数
#如果不主动调用函数，函数是不会执行的
def say_hello():
    print 'hello'
    print 'hello1'
    print 'hello3'
#函数的调用
say_hello()
def sum_2_sum():
    num1=20
    num2=23
    result=num1+num2  #对两个数字的求和
    print '%d+%d=%d'%(num1,num2,result)
sum_2_sum()

函数参数的使用
在函数名后面的小括号内填写参数，多个参数之间使用，分隔
def sum(num1,num2):
    result=num1+num2
    print '%d+%d=%d'%(num1,num2,result)
#在调用函数时传递的参数称为实参（真实的数据信息）
sum(11,11)

编写一个collatz（）函数，他有一个名为number的参数：
奇数 打印3*number+1   偶数 number//2

def collatz(num):
    if num%2==0:
        print num//2
    else:
        print 3*num+1
collatz(2)

def collatz(number):
    if number%2==0:
        number1=number/2
        print '%d'%number1
    else:
        number2=3*number+1
        print '%d'%number2
collatz(3)

def collatz(num):
    print num //2 if num%2==0 else  3*num+1
collatz(2)

参数：形参  实参
形参：位置参数 默认参数 可变参数 关键参数
#位置参数： 形参和实参个数必须保持一致
def getinfo(name,age):
    print name,age
getinfo(age=18,name='westos')

#默认参数：形参和实参的个数可以不一致
def mypow (x,y=2):
    """
     求x的y次方，y的默认值为2
    :param x:
    :param y:
    :return:
    """
    print x**y
mypow(4)
#默认形参可以改变
mypow(2,3)

#可变参数
def mysum (*args):                      
    """                                 
    *args：是可变参数                         
    args：是元组类型的数据                       
    args：名字可变（因为是形参，名字可变）               
    :param agrs:                        
    :return:                            
    """                                 
    print agrs                          
    sum =0                              
    for item in agrs:                   
        sum +=item                      
    print sum                           
mysum (1,2,3,4)
#对list tuple set  解包时，只需要在变量前加*                       
nums=[1,2,3,4]  nums1=(1,2,3,4) nums2={1,2,3,4}
# *nums：解包
mysum (*nums)   

#关键字参数
def getstuinfo(name,age,**kwargs) :                              
    """                                                          
      **kwargs:是一个字典，可以传递任意多的key_value 值                         
    :param name:                                                 
    :param age:                                                  
    :param kwargs:                                               
    :return:                                                     
    """                                                          
    print name,age                                               
    print kwargs                                                 
getstuinfo('westos',18,hobbies=['running','swiming'],gende='girl')        

      
         
返回值：函数运算的结果，还需要进一步操作时，给一个返回值return用来返回函数执行结果的，如果没有返回值，默认为None，python可以间接返回多个值（返回了一个元组），一旦遇到return，函数执行结束，后面的代码不会执行
def mypow(x,y=2):
    return x**y,x+y
a=mypow(3)
print a
#对元组进行解包
a,b=mypow(3)
print a,b

#局部变量：在函数内部定义的普通变量，只在函数内部作用，函数执行结束变量会自动删除
全局变量： a，b只是便利贴，只是在数字区域贴上便利贴
a=1
print 'out:',id(a)
def fun():
    global a  #声明a为全局变量
    a=5
    print 'inset',id(a)
fun()
print a
print id(a)

def test(num):
    print '在函数内部%d对应的内存地址是%d'%(num,id(num ))
a=10
print 'a变量保存的内存地址为%d'%id(a)          ##此时id地址一样
test(a)

def test(num):
    print '在函数内部%d对应的内存地址是%d'%(num,id(num ))
    result='hello'
    print '函数要返回的内存地址%d'%id(result)
    return result
a=10
print 'a变量保存的内存地址为%d'%id(a)
r=test(a)
print '%s的地址是%d'%(r,id(r))

编写一个函数cacluate，可以接受任意多个数，返回的是一个元组，元组的第一个值为所有参数的平均值，其余为大于平均值的所有数
def cacluate(*num):
    li=[]
    avg=sum (num)/len(num)
    for i in num:
        if i > avg:
            li.append(i)
    return avg,li
count =cacluate(12,23,4,5,67)
print count

编写函数，接受一个列表（包含30个整形数）和一个整形数k，返回一个新列表
函数要求：将下标k之前对应（不包含k）的元素逆序，k之后的元素逆序
import random
def fun(alist, k):
    if k < 0 or k > len(alist):
        return'error key'
    new1 = alist[:k]
    new2 = new1[::-1]     ##也可以写成return alist[:k][::-1]+alist[k:][::-1]
    new3 = alist[k:]
    new4 = new3[::-1]
    return new2 + new4
list = []
for i in range(30):
    num = random.randint(1, 100)
    list.append(num)
print list
a = fun(list, 8)
print a

模拟轮盘抽奖游戏，轮盘分为三部分：一等奖，二等奖和三等奖
转盘转的时候是随机的
如果范围在【0，0.08）之间，一等奖
如果范围在【0.08，0.3）之间，二等奖
如果范围在【0，1.0）之间，三等奖
模拟本次活动1000人参加，模拟游戏时需要准备各等级奖品的个数
import random
dict={
    'one':(0,0.08),
    'two':(0.08,0.3),
    'three':(0.3,1)
}
def fun():
    num=random.random()   #生成一个0～1之间的随机数
    for k,v in dict.items():    ##判断转盘转的几等奖
        if v[0]<=num<v[1]:     #这里的v时元组
            return k
resultdict={}
for i in range(1000):
    res=fun()    #res：本次转盘的等级（一/二/三等奖）
    if  res not in resultdict:
        resultdict[res]=1
    else:
        resultdict[res]+=1
for k,v in resultdict.items():
    print k,'------>',v

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

范例:
    输入: 51 5000 10000
    输出: 3
def f(n):
    n=str(n)  #先把数字转换成字符串
    sum =0
    for i in n:                #计算字符串中每个数的平方
        sum +=int(i)**2
    return sum
print f(13)
print f(207)
s=raw_input('请输入(k,a,b):')       #接受变量 ‘51 5000 10000’
li=[]
for item in s.split():             #【‘51’，‘5000’，‘10000’】
    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

#列表生成式 [experssion for i in 序列 if ...]
1.
s='51 5000 10000'
# li=[]
# for item in s.split():
#     li.append(int(item))
# k,a,b=li
k,a,b=[int(item) for item in s.split()]
print k,a,b

2.
li=[]
for i in range(1,8):
    li.append(i**2)
print li
print [ i**2 for i in range(1,8)]
print [ i**2 for i in range(1,8) if i%2==0]

3.
import math
#找出1-10之间的所有偶数，并且返回一个列表（包含以这个偶数为半径的圆的面积）
li =[]
for r in range(2,11,2):
    square=math.pi*r*r
    li.append(square)
print li
print [math.pi*r*r  for r in range(2,11,2)]

4.找出1-10之间的所有奇数，并且返回一个列表（所有的奇数转换为字符串）
print [str(r) for r in range(1,11,2)]

5.找出1～num之间的所有质数
def ispre(num):
    for i in range(2,num):
        if num%i==0:
            return False
    else:
        return True
print [i for i in range(2,6) if ispre(i)]

6.
给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输
入值小于1000。
如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别为(5,5),(3,7)）
# [2,3,5,7]
- 输入描述:
输入包括一个整数n,(3 ≤ n < 1000)
- 输出描述:
输出对数
- 示例1 :
输入:
    10
输出:
    2
"""
player=int(raw_input('请输入一个数字':))
def isPrime(num):
    for i in range(2,num):
        if num % i == 0:
            return False
    else:
        return True

primeLi =[i for i in range(2,100) if isPrime(i)]
print primeLi

[2,3,5,7]
"""
1.先从列表中拿出两个数
2.判断这两个数之和是否等于num
"""
primePairCount = 0
# for item1 in primeLi:
#     for item2 in primeLi:
#         if item1 + item2 == player and item1 <= item2:
#             primePairCount += 1
# print primePairCount

# [2,3,5,7] 2 === 10-2 3 ===10-3 5 ===10-5 7 ===10-7
for item1 in primeLi:
    if (player - item1) in primeLi and item1 <= player - item1:
        primePairCount +=1
print  primePairCount

#字典生成式
1.将字典中的key值和value值调换
d={'a':'apple','b':'bob','c':'cat'}
# print { v:k for k,v in d.items()}

2.假设有20个学生，学分在60～100之间，筛选成绩在90分以上的学生
import random
# stuInfo={}
# for i in range (20):
#     stuInfo['westos'+str(i)]=random.randint(60,100)
# print stuInfo
#hightscore={}
#for name,score in stuInfo.items():
#    if score>90:
#    highscore[name]=score
#print hightscore
stuInfo={'westos'+str(i):random.randint(60,100)  for i in range(20)}
print stuInfo
print {name:score for name,score in stuInfo.items() if score>90}

3.大小写合并，key值最终全部为小写
d1={'A':10,'b':5,'a':6,'B':9}
print {k.lower():d1.get(k.upper(),0)+d1.get(k.lower(),0)for k,v in  d1.items()}

###函数装饰器
装饰器在不改变元函数的基础上，给函数增加功能
def  say(age):
    print 'man in %d years old'%age
def outer(func):
    def inner(age):
        if age<0:
            age=0
        func(age)
    return inner
say=outer(say)
say(-10)

def fun1():
    print 'have a nice day'
def fun2():
    print 'good luck'
def outer(fun):
    def inner():
        print '*******'
        fun()
        print '&&&&&&&'
    return inner
fun1=outer(fun1)
fun1()

def desc(fun):
    def add_info():
        print '节日快乐'
        fun()
        print '西开欢迎你'
    return  add_info
@desc   ##语法糖   @desc---->logout=desc(logout)
def login():
    print 'logint ....'
def logout():
    print 'logout...'
logout=desc(logout)
login()
logout()