python 函数

一.定义函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段

函数能提高应用的模块性，和代码的重复利用率

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

　　函数式编程最重要的是增强代码的重用性和可读性

1.定义函数规则：

• 使用def语句，依次写出函数名、括号、括号中的参数和冒号":"
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
• 在缩进 块中编写函数体
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

2.语法：

　　

def 函数名(参数):
       
    ...
    函数体
    ...
    返回值

• 返回值：

　　　函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者

• 参数

1. 无参数　　

def test():
    print("hello")
test()

　　2.有参数

• • 普通参数　　

def test(a):
    print(a)
test("hello")

• • 默认参数

def fun(a=123):

    print(a)

fun()

• • 动态参数

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#* 可以传入列表也可以是元组
def fun(*a):
    print(a,type(a))
fun(1,2,23,43)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#**传入参数形式是字典
def fun(**a):
    print(a,type(a))
fun(k1=78,k2=90)

　3.变量作用域

　　变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

　　定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域

　　局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问

#!/usr/bin/env python
# -*- coding:utf-8 -*-

GVAR = "GLOBAL_VAR" # 这是一个全局变量
def fun(par):
   loc_var = "local_var" # 局部变量.
   print("函数内是局部变量 : ", loc_var)
   return loc_var

#调用fun函数
fun("hello")
print("函数外是全局变量 : ", GVAR)

 函数传参注意事项：

1.默认参数一定要用不可变对象且有默认参数的一定要放到参数的尾部，如果是可变对象，程序运行时会有逻辑错误！

2.要注意定义可变参数和关键字参数的语法：

　　*args是可变参数，args接收的是一个tuple或者list；

　　**kw是关键字参数，kw接收的是一个dict。

3.调用函数时如何传入可变参数和关键字参数的语法：

　　动态参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

　　关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

例 ：

发送邮件实例

#发邮件
def email():
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    msg = MIMEText('邮件内容', 'plain', 'utf-8')
    msg['From'] = formataddr(["jl_bai", 'jl_bai@163.com'])
    msg['To'] = formataddr(["test", '80766@qq.com'])
    msg['Subject'] = "test"

    server = smtplib.SMTP("smtp.163.com", 25)
    server.login("jl_bai@163.com", "password")
    server.sendmail('jl_bai@163.com', ['80766@qq.com', ], msg.as_string())
    server.quit()

email()

 二. 三元运算

三元运算（三目运算），是对简单的条件语句的缩写

# 书写格式
 
result = 值1 if 条件 else 值2
 
# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

三.lambda表达式

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

# 普通条件语句
if 1 == 1:
    name = 'true'
else:
    name = 'false'
    
# 三元运算
name = 'true' if 1 == 1 else 'false'

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
    return arg + 1
    
# 执行函数
result = func(123)
    
# ###################### lambda ######################
    
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
    
# 执行函数
result = my_lambda(123)

四. 练习作业

1.寻找差异，并将new_dict的值更新到old_dict中

#!/usr/bin/env python
# -*- coding:utf-8 -*-


old_dict = {
    "#1":11,
    "#2":22,
    "#3": 100
}

new_dict = {
    "#1":33,
    "#4":22,
    "#7": 100
}
old_keys = old_dict.keys()
new_keys = new_dict.keys()
old_set = set(old_keys)
new_set = set(new_keys)
#old存在new不存在,并删除new中不存在，old 中存在的元素
del_set = old_set.difference(new_set)
for i in del_set:
    del old_dict[i]
#new存在old不存在
add_set =  new_set.difference(old_set)
for a in add_set:
    old_dict[a] = new_dict[a]
#更新旧数据表
update_set = old_set.intersection(new_set)
for u in update_set:
    old_dict[u] = new_dict[u]
print(old_dict)

2.简述普通参数、指定参数、默认参数、动态参数的区别

• 普通参数传递的个数和顺序要明确
• 默认参数如果不给值使用默认值，默认参数必须指向不变的对象
• 动态参数可同时传入多个元素，*传入列表或者元组；**传入字典
• 指定参数 明确的把元素传给给具体的形参

3.写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

def st(string):
    all_sum = 0
    space_sum = 0
    digit_sum = 0
    oth_sum = 0
    for i in string:
        if i.isdigit():
            digit_sum += 1
        elif i.isspace():
            space_sum += 1
        elif i.isalpha():
            all_sum += 1
        else:
            oth_sum += 1
    return (all_sum,space_sum,digit_sum,oth_sum)
r = st("hello,123 world")
print(r)

4.写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5
def length(p):
    if isinstance(p,str) or isinstance(p,list) or isinstance(p,tuple):
        if len(p) >5:
            return "长度大于5"
        else:
            return False
    return None
temp = "hello,,"
ret = length(temp)
print(ret)

5.写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容

def space(s):
    if not s.strip():
        return "str is null"
    else:
        return "str is not null"
ret = space(" a")
print(ret)

6.写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

#!/usr/bin/env python
# -*- coding:utf-8 -*-

#写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

def split1(*s):
    if len(s) > 2:
        ret = s[0:2]
        print(ret)
        return  True
    else:
        return False
split1(1,2,3,4,5)

7.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者

# 方法一
def odd(*a):
    result = []
    for k,v in enumerate(a):
        if k % 2 == 1:
            result.append(a[k])
    return result
ret = odd(7,6,9,5,3,4)
print(ret)

# 方法二
def new_li(*l):
    result = []
    for i in range(len(l)):
        if i%2 == 1:
            result.append(l[i])
    return result
ret = new_li(1,3,5,44,65,22,33,11,78)
print(ret)

8.写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

#!/usr/bin/env python
# -*- coding:utf-8 -*-

#写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者
"""
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
for i in dic.values():
    ret = len(i)
    if ret > 2:
        ret2 = i[0:2]
    print(ret2)
"""
def dic(**d):
    for i in d.values():
        if len(i) > 2:
            ret = i[0:2]
            print(ret)
result = dic(k1='hello,world',k2=[11,22,33,44])
print(result)