python 初始函数

一、什么是函数

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

  函数能提高应用的模块儿性和代码的重复利用率。python提供了很多内置函数,比如print(),len()等等。我们也可以自己创建函数,这种函数叫做用户自定义函数。

二、函数的定义和调用

  让我们来定义一个能计算字符串长度的,类似于len()的函数

# s = "我的团长我的团"   # 1
# def my_len(): # 定义/声明一个函数 函数名的定义和变量名的规则一样 #3
#     i = 0  #4
#     for k in s: #5
#         i += 1
#     print(i)
# my_len() # 调用函数  # 2
# my_len()
# my_len()
# my_len()
# length = my_len()
# print(length)   # print: None  只是执行函数,并没有把结果返回给my_len

定义:def关键字开头,空格之后+函数名称和(),最后加" :" 冒号。

      def是固定的写法,他就是定义函数的关键字不能换其他关键字或者字符串

空格是为了将关键字def 和函数名分开,必须空,但是一般人只空一格。

函数名:函数名的命名规则和变量名的一样,由数字,字母下划线组成且不能以数字开头。函数名的定义并没有严格规定,但默认还是要尽量简短,并能表达函数功能。

括号:括号是必不可少的部分里面可以存放参数

注释:每一个函数都应该对其功能和参数进行相应的说明,应该写在函数下面的第一行,以增强代码的可读性。

调用: 很简单就是 函数名() 务必加上括号

三、函数的返回值

return关键字的作用

  return是一个关键字,在pycharm里,会自动变色。

  很显然return是“返回”的意思,我们管写在return后面的值叫做“返回值”。

返回值有如下三种情况:

  1.没有返回值    默认返回None

#  不写 return
#  只写return  结束一个函数的继续
#  return None  和不写return是一样的 都返回 None  最不常用
# def func=():
#     l1 = [‘狗哥‘, ‘狗智‘]
#     for i in l1:
#         print(i)
#         if i == ‘狗哥‘:
#             return  # 找到狗哥之后后面的就不循环了
# r1 = func()
# print(r1)

  2.返回一个值 可以是数字、列表、字典等

# 1.可以返回任何数据类型 2. 只要返回了就可以接收到
# 3.如果一个程序中有多个return的话只执行第一个
# def func():
#     return [1, 2, 3]
# print(func())

  3.返回多个值

# def func2():
#     return 1, 2, 3  # 相当于返回了一个元组 return(1,2,3) python特性
# r1, r2, r3 = func2()
# print(r1, r2, r3)  #  1 2 3

# r1, r2 = func2()
# print(r1, r2) # 会报错 两个变量不能接收三个返回值 不能平均分配

# r1 = func2()
# print(r1)   #可以用一个变量接收,返回一个元组 --> (1, 2, 3) 不可变类型
# 多个返回值用多个变量接收,有多少返回值就用多少变量接收

四、函数的参数

形参与实参:

我们调用函数的时候就是传参的过程,括号里的内容就是实际参数,是实际要交给函数的内容,简称实参。

当以函数的时候就是接受函数的过程,括号里的内容就是形式参数,在定义函数的时候他只是一个形式,表示这里有一个参数,简称形参。

# s = "我的团长我的团"
# l1 = [1, ‘barry‘, ‘大铁锤‘]
# def my_len(s):  # 接收参数 形式参数 形参
#     i = 0
#     for k in s:
#         i += 1
#     return i
# r1 = my_len(s) # 传参  传递参数  实际参数 实参
# r2 = my_len([1,2,3])
# print(r1, r2)  # -->7 3

 站在实参的角度上 

1.按照位置传参
  2.按照关键字传参
  3.可以混着用,但是必须先按照位置传参再按照关键字传参
         不能给同一个变量传多个值

# def my_sum(a, b):
#     print(a, b)
#     res = a + b # result
#     return res
# ret = my_sum(1, 2)  # 按照位置传 1-->a  2-->b
# ret = my_sum(b=2, a=1) # 按照关键字传参
# ret = my_sum(1, b=2) # 位置传参关键字传参混着用
# print(ret)

站在形参的角度上;

  位置参数:必须传,且有几个参数就传几个值
  默认参数:可以不传,如果不传就用默认参数,如果传了就用传的

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘ %(name,sex))
classmate(‘二爷‘)
classmate(‘小五‘)
classmate(‘骚鑫‘)
classmate(‘马哥‘, ‘女‘)
classmate(‘coco‘, ‘女‘)

调用 函数时候:

  按照位置传:直接写参数的值
  按照关键字传: 关键字 = 值

定义参数的时候:

  位置参数:直接定义参数
  默认参数:默认参数:参数名=默认的值
  动态参数 可以接收任意多个参数
  参数名之前加* 习惯用args /参数的意思
  参数名之前加** 习惯用kwargs
  顺序:先定义位置参数,*args,默认参数,**kwargs

# 定义的时候使用按位置传参,传参的时候既可以用位置传参,又可以用关键字传参
def classmate(name, sex):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘, ‘男‘)
classmate(sex=‘男‘, name=‘鸡哥‘)

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘)
classmate(‘鸡哥‘, sex=‘女‘)
# 定义参数类型和传递参数类型之间没有必然联系

动态参数    

动态参数 可以接收任意多个参数  参数名之前加* 习惯用args /参数的意思

# def sum(*args): #args仅仅是参数名
#     n = 0
#     for i in args:
#         n += i
#     return n
# print(sum(1, 2))
# print(sum(1, 2, 3))
# print(sum(1, 2, 3, 4))

# 接收动态参数
# def func(*args): #只能接收到按位置传递的参数,不能接收关键字传参
#     print(args)
# func(1, 2, [‘jack‘, 5,], {‘name‘:‘barry‘}) #-->(1, 2, [‘jack‘, 5], {‘name‘: ‘barry‘})

# def func(*args, l1=[]):
#     print(args, l1)
# func(1, 2, [‘rose‘, ‘marry‘])
# func(3, 4,‘coco‘, l1=[‘jack ma ‘, ‘lucy‘])

# 按照关键字传多个参数
# def func(**kwargs):
#     print(kwargs)
# func(a=1, b=2, c=3)
# func(a=1, b=2)
# func(a=1)
# func(a=1, b=2, c=3)
# 动态参数有两种:可接收任意多个参数
    #*args : 接受的是按位置传参的值,组成一个元组
    #**kwargs : 接收的是按照关键字传参的值,组成一个字典
    #args必须在kwargs之前
# 双剑合璧 天下无敌

# def func(*args, **kwargs):
#     print(args, kwargs)
#  func(1, 2, a=3, b=‘sb‘) #-->(1, 2) {‘a‘: 3, ‘b‘: ‘sb‘}
                            # 只要在传参的时候符合先按位置再按关键字就OK

# def func(a, b,*args, default=1, **kwargs): #这几种参数少了谁都可以,但顺序必须牢记
#    print(a, b, args, default, kwargs)
# func(1, 2, default=2, a=3, b=‘sb‘)

# 动态参数的另一种传输方式
# def func(*args): #站在形参的角度,给变量加上* 就是组合所有传来的值
#     print(args)
# func(1,2, 3, 4)
# l1 = [1, 2, 3, 4]
# func(*l1) #站在实参的角度上,给序列加上* ,就是将序列按顺序打散

# def func(**kwargs):
# #     print(kwargs)
# # func(a=1, b=2)
# # dic1 = {‘a‘: 1, ‘b‘: 2}
# # func(**dic1)

五、函数的注释

def func():
    ‘‘‘
    这个函数实现了什么功能
    参数1:
    参数2:
    。
    。
    。
    :return:  是字符串或列表的长度
    ‘‘‘
    pass

  作业:

# 1. 写函数,检查获取传入列表或元组对应的所有奇数位索引对应的元素,并将其作为新列表返回给调用者
# def func(l1):
#     return l1[1::2] # 切片
# print(func([1, 2, 3, 4, 5, 6]))
# 2.写函数,判断用户输入的值(字符串,列表,元组)长度是否大于5
# def func(x):
#     return len(x) > 5
#
# print(func(‘everything i never told you!‘)) #返回的是布尔值
#
# if func(‘sad‘):
#     print(‘确实大于五‘)
# else:
#     print(‘小于五‘)
# 3.写函数,检查传入列表的长度,如果>2,那么仅保留前两个长度的内容,并将新内容返回给调用者
# def func(l1):
#     if len(l1) > 2: # 这一步完全可以省略
#         return l1[:2]
# print(func([1, 2, 3, 4])) #-->[1, 2]

# 4. 写函数 计算传入字符串中,数字,字母,空格,以及其他 的个数,并返回结果
# def func(s):
#     dic = {‘num‘: 0, ‘alpha‘: 0, ‘space‘: 0, ‘other‘: 0 }
#     for i in s:
#         if i.isdigit():
#             dic[‘num‘] += 1
#         elif i.isalpha():
#             dic[‘alpha‘] += 1
#         elif i.isspace():
#             dic[‘space‘] += 1
#         else:
#             dic[‘other‘] += 1
#     return dic
# print(func(s = ‘+*[email protected] s c d‘))

# 5. 写函数,检查用户输入的对象(字符串,列表,元组)的每一个元素是否含有空内容,并返回结果

# def func(x):
#     if type(x) is str and x:
#         for i in x:
#             if i == ‘ ‘:
#                 return True
#     elif x and type(x) is list or type(x) is tuple:
#         for i in x:
#             if not i:
#                 return True
#     elif not x:
#         return True
# print(func(‘dasd asd‘))
# print(func([1, 2, []]))
# print(func([]))
# print(func((1, 2, ())))

# 6.写函数,检查传入字典的每一个value的长度,如果>2,那么仅保留两个长度的内容,并将新内容返回给调用者
# dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: 1246, ‘k3‘: [1, 2, 3]}
# ps 字典中的value只能是字符串或列表
# def func(dic):
# #     for k in dic:
# #         if len(dic[k]) > 2:
# #             dic[k] = dic[k][:2]
# #     return dic
# # dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: ‘1333324‘, ‘k3‘: [1, 2, 3]}
# # print(func(dic))

# 7. 写函数,接收两个数字参数,返回比较大的那个数字
# def func(a, b):
#     if a > b:
#         max = a
#     else:
#         max = b
#     return max
#
# print(func(2, 1))
# 三元运算
# 变量 = 条件返回true的结果 if 条件 else 条件返回false的结果
# 必须要有结果  必须要有 if 和 else   只能是简单的情况
# def func(a, b):
#     max = a if a > b else b
#     return max  # 可以直接 return a if a > b
# print(func(10, 5))

# 8. 写函数,用户传入修改的文件名儿,与要修改的内容
# 执行函数完成整个文件的批量修改操作
# def func(filename, old, new):
#     with open(filename, encoding=‘utf-8‘) as f1, #             open(‘%s.bak‘ % filename, ‘w‘, encoding=‘utf-8‘) as f2:
#         for line in f1:
#             if old in line:
#                 line = line.replace(old, new)
#             f2.write(line)
#     import os
#     os.remove(filename)
#     os.rename(‘%s.bak‘ % filename, filename)
#     return ‘修改完毕‘
#
# print(func(‘H:\python\大学生兼职.txt‘, ‘快递小哥‘, ‘家政主妇‘))

# def func(l1=[]):
#     l1.append(1)
#     print(l1)
# func() # [1]
# func([]) #[1]
# func([‘a‘]) #[‘a‘,1]
# func() #[1,1]
# func() #[1,1,1]
# 如果默认参数是一个可变数据类型,
# 那么每次调用函数的时候,
# 如果不传值就公用这个数据类型的资源

# def func(k, dic={}):
#     dic[k] = ‘v‘
#     print(dic)
# func(1) # {1 :‘v‘}
# func(2) #{1 :‘v‘,2 :‘v‘}
# func(3) #{1 :‘v‘,2 :‘v‘,3 :‘v‘}
# func(4) #{1 :‘v‘,2 :‘v‘,3 :‘v‘,4: ‘v‘}

 

原文地址:https://www.cnblogs.com/-1206-/p/9520981.html

时间: 2024-10-10 17:13:51

python 初始函数的相关文章

Python:初始函数

Python:初始函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可以自己创建函数,这被叫做用户自定义函数. 函数的定义: #函数在定义阶段,只检测语法,不执行代码. def 函数名(参数1参数2,...): '''注释信息''' 函数体 return 返回值 定义函数的三种形式: 无参: #函数无需外部传入参数 有参: #函数体的代码,需要外部传入值的时候才

python之路---09 初始函数 参数

二十七.初始函数 1.函数: 对代码块和功能的封装和定义 2.格式及语法 def  函数名()           #  定义 函数体 函数名()              #  调用 3.    return      返回None return "x"        返回值为   'x' return "x","y"     同时返回多个结果时,    返回的是元组 一遇到return 就结束函数  到达调用函数的位置 4.三目运算 c =

python之函数用法fromkeys()

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python之函数用法fromkeys() #fromkeys() #说明:用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值 ''' >>> help(dict.fromkeys) Help on built-in function fromkeys: fromkeys(...) dict.fromkeys(S[,v]) -> New dict with

python的函数

一 函数是什么? 函数一词来源于数学,但编程中的「函数」概念,与数学中的函数是有很大不同的,具体区别,我们后面会讲,编程中的函数在英文中也有很多不同的叫法.在BASIC中叫做subroutine(子过程或子程序),在Pascal中叫做procedure(过程)和function,在C中只有function,在Java里面叫做method. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可以自己创建函数,这被叫做用户自定义函数. 定

python中函数的使用方法

本文主要介绍:python中函数的使用方法 代码: #!/usr/bin/env python# -*- coding:utf-8 -*-# author by lh #函数里默认形参如果有初始值的话,调用的时候如果不写实参,则默认是形参里的初始值(ps:如果有多个形参,有默认值的参数一定要放到后面)def f1(a='rt'): temp='Welcome '+a return tempret=f1('lh')print retret1=f1()print ret1 #实参可以是任意类型的参数

python之函数用法capitalize()

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python之函数用法capitalize() #capitalize() #说明:将字符串的第一个字母变成大写,其他字母变小写. ''' capitalize(...) S.capitalize() -> string Return a copy of the string S with only its first character capitalized. ''' #案例 str='xiaoden

关于python的函数的*和**参数:

1.将足够的参数解包以后传递给函数:>def f(p1, p2, p3, p4):>     print p1+p2+p3+p4>>li = [1, 2, 3, 4]>f(*li)10>>tu = (1, 2, 3, 4)>f(*tu)10>>di = {'p1':1, 'p2':2, 'p3':3, 'p4':4}>f(**di)>10 2.使用封包的方法访问多余的参数>>> def funct(*para, **

python之函数用法setdefault()

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python之函数用法setdefault() #D.get(k,d) #说明:k在D中,则返回 D[K],如果k不在D中,则返回d值 #D.get(k,d), also set D[k]=d if k not in D ''' >>> help(dict.setdefault) Help on built-in function setdefault: setdefault(...) D.set

python之函数用法islower()

# -*- coding: utf-8 -*- #python 27 #xiaodeng #python之函数用法islower() #http://www.runoob.com/python/att-string-islower.html #islower() #说明:检测字符串是否都由小写字母组成 str = "THIS is string example....wow!!!" print str.islower()#False str = "this is string