函数基础初识

一，初始函数

　　1,什么是函数：函数就是 对代码块和功能的封装和定义．(就是对一种功能的封装)

　　函数的定义, 函数名, 函数体以及函数的调⽤

def 函数名():         # 在定义的时需要的参数,类似于占位符
    函数体

＃调用
函数名()　　　　　　　 # 在调用时需要传入的参数是实参

＃这里的函数名的命名规则和使⽤和变量量基本一样.⾃⼰己回顾⼀下变量的命名规则. 函数体: 就是函数被执行之后要执行的代码

　　2,return的用法和作用:

　　　　2.1,函数中遇到return,此函数结束,不再继续执行

def yue():    
    print("回家")    
    print("吃饭")    
    print("约小姐姐")    
    return    
    print("约起看电影")    # 这句话不会被执⾏ 

yue()    # 这里的执行结果没有'约谁啊'

　　　　2.2, 给函数的调用者一个访问结果

def yue():    
print("回家")    
print("早点回家")    
print("约小姐姐")    
return "等我"  #直接给函数一个返回值

a = yue() 
print(a)    # 等我

def fun():
    print('没有')
     # return 5

print(fun())           # 没有  None   当没有return时,函数的值永远时None
print(fun)             #只要定义了一个函数都会生成一个地址,就像门牌号 <function fun at 0x00000158B8FD2E18>

 

　　　2.3,函数的返回值可以有多个结果,且返回的结果是一个元组,我们可以通过解构的方式获取,如 return 4,5    ,可以通过 a,b = 函数名()

def yue():    
    print("回家")    
    print("七夕了")    
    print("约小姐姐")    
    return "去游泳", "去吃火锅"

girl = yue()     # (去游泳 ,去吃火锅)
print(type(girl))   # tuple   

 

　　　总结:  如果return什么都不写 或者 ⼲脆不写return .那么返回的就是None           

　　　　　　如果return后⾯写了⼀个值. 则调⽤者可以接收一个结果 ，注意我们经常使用的print等常用的内置函数，也有retrun，如下          

　　　　　　如果return后⾯写了多个结果, 则调用者可以接收一个tuple, 调用者可以直接解构成 多个变量

a = 3
c = print(a)
print(c)

# 结果是  3  None   这里print中也有return 只是后面没有跟值

 三元运算：

　　形如：a if a > b else b   的运算形式的结构。 如果满足则a，否则b

注意这里三元运算还可以执行更多操作：

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

def leng(a):
    if a.startswith('[') and a.endswith(']'):
        a=a.strip('[]').split(',')  # strip()可以成对切割
        print('大于5') if len(a)>5 else print('小于或等于5')
    elif a.startwith('(') and a.endwith(')'):
        print('大于5') if len(a)>5 else print('小于5')
    else:
        print('大于5') if len(a)>5 else print('小于5')

usr_input = input('请输入：').strip()
leng(usr_input)

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

def li(a):
    return a[:2] if len(a)>2  else '长度小于2'
a =[1,2,3]
print(li(a))

三元运算的例题

 

二, 函数的参数:

　　1,参数, 函数在调⽤的时候指定具体的⼀个变量的值. 就是参数.  语法:

def 函数名(参数列列表):    
    函数

def my_len(l):  # l 形式参数 形参
     print(l)
     count = 0
     for j in l:
         count += 1
     return count

a = 'fdsafdsafdsagfsadf'
print(my_len(a))  # 实际参数 ，实参
print(my_len([1,2,3]))

 

　　2,1. :        1,形参:  写在函数声明的位置的变量叫形参.  形式上的一个完整. 表示这个函数需要xxx

　　　　　　  2. 实参: 在函数调用的时候给函数传递的值. 叫实参, 实际执行的时候给函数传递的信息. 表⽰给函数 xxx

　　　　　　  3. 传参: 给函数传递信息的时候将实际参数交给形式参数的过程被称为传参. 

　　3.1:    按照实参的角度,可以把参数分为: 位置参数, 混合参数,关键字参数   分别如下:

#1,位置传参  (位置必须按照顺序一一对应)
 def func(a,b,c):
     print(a)
     print(b)
     print(c)
# 位置参数必须给它传值否则会报错!!!
func('fdsafdas',3,4)

# 有点⼉儿麻烦, 我们在这里学⼀个三元运算符. 
def my_max(a, b):    
c = a if a > b else b   # 当a>b成立返回a, 否则返回b    
return c

my_max(5,21)


#2,关键字参数  (可以没有顺序,但是必须是全部关键字加上一个值)
def max_min(a,b):
    return a if a > b else b
print(max_min(b = 300,a = 200))


3.混合传参,就是包含关键字和位置参数的混合   (但是必须把关键字参数放在最后)
def func1(a,b,c,d,e):
     print(a)
     print(b)
     print(c)
     print(d)
     print(e)
func1(1,2,d=4,c=3,e=5)
func1(1,4,d=2,c=3,e=5)

　　4,按照形式参数分类: 位置参数 , 默认参数 （还有动态形参）

#位置参数
def func(a,b,c):
     print(a)
     print(b)
     print(c)
func('fdsafdas',3,4)


#默认参数
def stu_info(name,sex = "male"):
    """打印学生信息函数，由于班中大部分学生都是男生，
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)


stu_info('alex')  # 默认是男的
stu_info('eva','female')


注意,默认参数这里有一个坑,默认参数是个可变类型时:  这里有坑，注意当默认参数是一个可变数据类型，如list，字典时，它的内存地址不会随调用轻易的改动，具体请看第二个例子
ef defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')    #结果['alex']    ['alex', 'egon']

请问一下的代码的运行结果分别是：______、______、_______           [10,'a']、[123]、[10,'a']           

def extendList(val,list=[]):
    list.append(val)
    return list

list1 = extendList(10)
　　#print(list)
list2 = extendList(123,[])
print(list)
list3 = extendList('a',)

print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)

　　5,动态参数:  按位置传值多余的参数都由args统一接收，保存成一个元组的形式

def trans_para(*args,**kwargs):  #无敌形参
    print(args,type(args))
    print(kwargs,type(kwargs))
trans_para("jinxin",12,[1,2,3,4],[3,4,],(1,4,7),{"a":"123","c":456},country="china")


动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

在函数里我们把args和kwargs分别进行调用就可以得到想要的值了

练习题：

1、.写函数，计算传入函数的字符串中,[数字]、[字母]、[空格] 以及 [其他]的个数，并返回结果。
def count_str(li):
    a,b,s,z = 0,0,0,0
    for i in li:
        if i.isdigit():a += 1
        elif i.isalpha(): b +=1
        elif i ==' ': s += 1
        else : z +=1
    return '数字%s个,字母%s个，空格%s个，其他字符%s个'%(a,b,s,z)
a =input('请输入：')
print(count_str(a))

2、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
 dic = {"k1": "v1v1", "k2": [11,22,33,44]}
 PS:字典中的value只能是字符串或列表

dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def check(dic):
    for i in dic:
        if len(dic[i]) >2:
            dic[i]=dic[i][:2]
    return dic
print(check(dic))

3.写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作（升级题）。

def modifie(file_path,src,new):
    with open(file_path,'r',encoding='utf8') as f2,\
    open('1.txt','w',encoding='utf8') as f:
            for i in f2:
                if src in i:
                    i =i.replace(src,new)
                    f.write(i)
                    continue
                f.write(i)
modifie('a1.txt','alex','sb')

课后练习题

 

转载于:https://www.cnblogs.com/double-W/p/9446499.html