0
点赞
收藏
分享

微信扫一扫

Python中这些简单的函数你还不会？

Sikj_6590 2022-03-11 阅读 54
python字符串调用函数局部变量Python编程语言



文章目录


  • ​​定义和调用函数​​


​​定义函数​​​​参数和返回值​​

  • ​​变量的作用域​​
  • ​​匿名函数​​
  • ​​内置函数​​

  • ​​数值运算函数​​
  • ​​字符串处理函数​​

  • ​​其他常用内置函数​​


​​help（）​​​​type（）​​



定义和调用函数

定义函数

  • 格式
def functionname([parameterlist])
  ["comments"]
  [funcitonbody]


functionname：函数名
parameterlist：参数。可以为空，可以为多个参数，用逗号隔开
comments：可选参数
functionbody：可选参数，语句体调用函数后要执行的功能代码



  • 函数：系统函数、自定义函数
  • 调用函数：

  • 调用函数就是执行函数
  • 系统函数、自定义函数都是用函数名来调用

  • pass空语句：不做任何事情，起到占位作用，可以用…来代替pass

​自定义函数​

def sum(num1,num2):
  print(num1+num2)

def printstring(str):
  print(str)


num1、num2、str都是函数的参数，在函数体中，函数类似于变量


​函数调用、调用函数​

  • 计算两个数相加
>>> def sum(num1,num2):
  print(num1+num2)

>>> sum(100,10)
110
>>>

参数和返回值


  • 主调函数和被调用函数之间一般都有数据传递关系
  • 参数：

  • 形参：定义函数时，括号里的参数
  • 实参：调用函数时，函数后面的参数

  • 参数的作用是传递数据给函数使用


  • 实参：

  • 值传递：实参为不可变对象时，改变形参的值，实参值不变
  • 引用传递：实参为可变对象时，改变形参的值，实参的值也会改变



  • 位置参数（必备参数）
  • 必须按照正确的顺序传递到函数中，即调用时数量和位置必须与定义的相同
  • 关键字参数：使用形参的名字来输入参数的值，不需要与形参的的位置一致

​例1​：

>>> def fun_bmi(person,height,weight):  //定义函数
  bmi = weight/height
  print (bmi)

>>> fun_bmi("坏坏",1.78)  //参数数量与定义的不同，缺少“weight”参数
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    fun_bmi("坏坏",1.78)
TypeError: fun_bmi() missing 1 required positional argument: 'weight'
>>> fun_bmi("坏坏",56,1.78)  //参数位置与定义不一致
0.031785714285714285
>>> >>> fun_bmi("坏坏",1.78,56)  //正确的输出
31.46067415730337
# 关键字参数，用形参的名字确定输入的参数值，指定实参时，无需与形参的位置相同
>>> fun_bmi(height=1.78,weight=56,person="坏坏")
31.46067415730337
>>>
  • 参数传递
>>> def func(num):
  num+=1

>>> a = 10
>>> func(a)
>>> print(a)
10
  • 列表作为参数传递
>>> def sum(list):
  total=0
  for i in range(len(list)):
    print(list[i],'+',end="")
    total+=list[i]
  print('=',total)

>>> list=[15,25,35,45,55]
>>> sum(list)
15 +25 +35 +45 +55 += 175
>>>


这里在最后的一个输出会多一个​​+​​号，可以优化


  • 字典作为参数传递
>>> def print_dict(dict):
  for (k,v) in dict.items():
    print("dict[%s]="%k,v)


>>> dict={"b":"bad","o":"boy","B":"Bad"}
>>> print_dict(dict)
dict[b]= bad
dict[o]= boy
dict[B]= Bad
>>>

  • 可变参数（不定参数）
  • 传入函数中的实际参数可以是0个、1个或多个
  • 可变参数的两种形式：

  • *parameter——接受任意多个实际参数并将其放到一个元组中
  • **parameter——接受任意多个显示赋值的实际参数，并将其放到一个字典中


# *parameter可变参数
>>> def printplayer(*name):
  print('我喜欢的歌手有：')
  for item in name:
    print(item)

>>> printplayer('许嵩')
我喜欢的歌手有：
许嵩
>>> printplayer('许嵩','孙子涵','owl ciy')
我喜欢的歌手有：
许嵩
孙子涵
owl ciy
>>>


>>> def printsign(**sign):
  print()
  for key,value in sign.items():
    print("["+key+"]的专辑是："+value)

# **可变参数
>>> printsign(许嵩="寻宝游戏",孙子涵="涵剧先森",owl="Good Time")

[许嵩]的专辑是：寻宝游戏
[孙子涵]的专辑是：涵剧先森
[owl]的专辑是：Good Time
>>>


使用已存在的列表作为函数的可变参数，在列表名称前加​​*​​ 使用已存在的字典作为函数的可变参数，可在字典的名称前面加​​**​​


  • 返回值

  • 作用：将函数处理的结果返回给调用它的程序
  • 返回值不是必须的，如果没有return语句，默认返回None



  • 返回值可以是任意类型，只要return得到执行，就会直接结束函数的执行
  • 返回一个值，该值可以是任意类型
  • 返回多个值，保存为一个元组


>>> def sum(num1,num2):  #无返回值
  num1+num2

>>> print(sum(2,3))
None
>>> def sum(num1,num2):  #有返回值
  num1+num2
  return num1+num2

>>> print(sum(2,3))
5
>>>

​例​：输出一个列表中的偶数

>>> def filter_even(list):
  list1=[]
  for i in range(len(list)):
    if list[i]%2==0:
      list1.append(list[i])
      i-=1
  return list1

>>> list=[1,2,3,4,5,6,7]
>>> list2=filter_even(list)
>>> print(list2)
[2, 4, 6]
>>>

变量的作用域


  • ​作用域​指程序代码能够访问该变量的区域，即变量的有效范围
  • ​局部变量​：

  • 在函数内部定义的变量，只能在函数内使用
  • 只在函数运行时创建，运行之前、之后都不存在

  • ​全局变量​：

  • 在函数外定义的变量
  • 函数内定义，但是用global关键字修饰后的变量
  • 在定义后的任何地方都有效



如果全局变量和局部变量重名，函数体内只有局部变量有效


>>> a = 50  #定义全局变量a
>>> def setNumber():  #定义函数内为局部变量，只在函数内有效
  a=10
  print(a)

>>> setNumber()  #调用函数，输出函数内的变量值
10
>>> print(a)  #未调用函数，输出全局变量的值
50
>>>

​例​：

>>> total=5  #全局变量
>>> def sum(num1,num2):
  total=num1+num2   #函数内的为局部变量
  print ("函数内是局部变量：",total)
  return total

>>> sum(5,15)  #调用函数，输出局部变量
函数内是局部变量： 20
20
>>> print("函数外是全局变量：",total)  #未调用函数，输出全局变量
函数外是全局变量： 5
>>>

匿名函数


  • python使用lambda来创建匿名函数

  • lambda是一个表达式，函数体比def简单
  • lambda的主体是表达式，不是代码块。仅能在lambda表达式中封装有限的逻辑
  • lambda函数拥有自己的命名空间，不能访问自有参数列表以外或全局命名空间里的参数

  • 语法：​​lambda[arg1[,arg2,...argn]]:expression​​



  • 匿名函数主要应用在需要一个函数而不必去命名这个函数
  • lambda函数看似只能写一行，却不同于C或C++的内联函数
  • 内联函数的目的是调用小函数时不占用栈内存从而增加运行效率


# 使用def定义函数
>>> def aaa(i):
  return 2+3*i

>>> aaa(5)
17
# 使用lambda定义函数
>>> d=lambda i :2+3*i
>>> d(5)
17
>>> 

>>> def add(a,b):
  return a+b

>>> add(2,3)
5
>>> e=lambda a,b :a+b
>>> e(2,3)
5
>>>


  • lambda优势：

  • 更精简，省略定义普通函数的过程，适合写脚本
  • 提高了代码可读性
  • 替代比较抽象且调用次数不多的函数，简化命名


内置函数

数值运算函数

函数

原型

说明

abs()

abs(x)

返回x的绝对值

pow（）

pow（x,y）

返回x​y​的值

round()

round(x,n )

返回浮点数x的四舍五入值，参数n指定保留的小数位数

divmod()

divmod(a,b)

返回a除以b的商和余数，返回一个元组

字符串处理函数

函数

原型

说明

lower()

str.lower()

将字符串str中的字母转换为小写字母

upper()

str.upper()

将字符串str中的字母转换为大写字母

swapcase()

str.swapcase()

将字符串str中的字母大小写互换

capitalize()

str.capitalize()

将字符串str中的首字母大写

title()

str.title()

将字符串str中的首字母大写，其余小写

ljust()

str.ljust(width,[fillchar] )

左对齐输出字符串str，总宽度为width，不足部分以参数fillchar填充，默认为空格

rjust()

str.rjust(width,[fillchar])

右对齐输出字符串str，总宽度为width，不足部分以参数fillchar填充，默认为空格

center()

str.center(width,[fillchar])

居中对齐输出字符串str，总宽度为width，不足部分以参数fillchar填充，默认为空格

zfill()

str.zfill(width)

将字符串str变成width长，并且右对齐，不足部分用0填充

​例​：

  • 数学运算函数
# 计算绝对值
>>> print(abs(-5))
5
>>> print(abs(5))
5
# 计算x的y次方
>>> print(pow(2,3))
8
>>> print(pow(3,2))
9
# 计算浮点数x保留n位小数
>>> print(round(4.567,1))
4.6
>>> print(round(4.567,0))
5.0
# 计算a除以b的商和余数，返回元组
>>> print(divmod(10,3))
(3, 1)
>>> print(divmod(16,3))
(5, 1)
>>>
  • 字符串处理函数
>>> str1 = "i am bad boy"
>>> str2 = "I AM BAD BOY"
>>> str3 = "I Am Bad Boy"
>>> str4 = "i am Bad Boy"
# 将字母转换为小写
>>> print(str2.lower())
i am bad boy
>>> str2  #变量的值不会改变
'I AM BAD BOY'
# 将字母全部转换为小写
>>> print(str1.upper())
I AM BAD BOY
# 将字母的大小写互换
>>> print(str3.swapcase())
i aM bAD bOY
# 字符串中的首字母大写
>>> print(str1.capitalize())
I am bad boy
# 将字符串中的首字母大写（每个）
>>> print(str4.title())
I Am Bad Boy
>>> 


>>> str="i am bad boy"
# 字符串居左对齐，长度为20，不足部分用*补齐
>>> print(str.ljust(20,"*"))
i am bad boy********
# 字符串居右对齐，长度为20，不足部分用+补齐
>>> print(str.rjust(20,"+"))
++++++++i am bad boy
# 字符串居中对齐，长度为20，不足部分用-补齐
>>> print(str.center(20,"-"))
----i am bad boy----
# # 字符串居右对齐，长度为20，不足部分由0补充
>>> print(str.zfill(20))
00000000i am bad boy
>>>

​拓展​：


  • ​​split()​​ 通过指定分隔符对字符串进行切片
  • 语法：​​str.split(str="", num=string.count(str))​​

  • str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等
  • num – 分割次数。默认为 -1, 即分隔所有
  • 如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。

  • ​​splitlines()​​按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表
  • 语法：​​str.splitlines([keepends])​​

  • keepends – 在输出结果里是否去掉换行符
  • 默认False，不包含换行符
  • True则保留换行符

  • ​​join()​​将序列中的元素以指定的字符连接生成一个新的字符串
  • 语法：​​str.join(sequence)​​
  • sequence – 要连接的元素序列

# 以空格为分隔符，将字符串分割
>>> str1="i am Bad boy"
>>> list1=str1.split(" ")
>>> print(list1)
['i', 'am', 'Bad', 'boy']
# 去除换行，将字符串一行输出
>>> str1="I am \nBad boy"
>>> print(str1)
I am 
Bad boy
>>> list1=str.splitlines()
>>> print(list1)
['i am bad boy']
# 以*连接list1中的元素
>>> list1=["I","Am","Bad","boy"]
>>> str1="*"
>>> print(str1.join(list1))
I*Am*Bad*boy
>>>

其他常用内置函数

help（）

  • 查看命令帮助手册
>>> help()  #进入命令查询
...
help> print  #查询命令帮助
...
help> quit  #退出
...
>>> help(list)  #查看命令帮助手册
双击就可以查看命令帮助手册
>>>

type（）

  • 查看变量类型
>>> a="555"
>>> print(type(a))
<class 'str'>  #字符串
>>> b=555
>>> print(type(b))
<class 'int'>  #整型
>>> c=["b","a","d"]
>>> print(type(c))
<class 'list'>  #列表

​作业练习​:答案参考​​【GitHub】​​


  2. 定义一个getMax( )函数，返回三个数（从键盘输入的整数）中的最大值
  3. 定义一个函数，判断输入的三个数字是否能够构成三角形的三条边
  4. 定义一个函数，求两个正整数的最小公倍数
  5. 编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和


以上内容均属原创，如有不详或错误，敬请指出。


本文作者： ​​ 坏坏 ​​



举报

相关推荐

Kafka与Zookeeper这些题你还不会吗？

日记本Java技术问答程序员

Java开发岗还不会这些问题，干货分享

后端开发程序员Java编程语言

看完这篇Elasticsearch还不会，你打我

ElasticsearchES搜索引擎搜索部署分布式Amazing...项目架构

参加这些，你不会后悔

openstack云计算服务器

Android开发岗还不会这些问题，重难点整理

androidandroid开发设计模式OpenStack云计算

我去，你竟然还不会用 synchronized

趣味JavaJava web我不想再做Ja...

CAD中平分角操作你还不会吗？

在线CAD开发语言javascript前端java编程语言

面试10000次依然会问的【ThreadLocal】，你还不会？

线程安全用户信息数据Java后端开发

面试10000次依然会问的【volatile】，你还不会？

Java同步机制重排序后端开发

看什么看啊，你不会还不会抓HTTPS请求报文吧？

https抓包Fiddler重放
0 条评论