python 函数的一些基本使用

本文章讲解了python 函数的一些基本使用

函数

语法

定义

无返回值

def print_123():#定义函数
    print("123")
print_123()#调用函数 输出123

一个返回值

def jiachen(A):
    return A+1,A+2
print(jiachen(1),type(jiachen(1)))#2 <class 'int'>
date,date1=jiachen(1)
print(date,date1)#2 3

多个返回值

返回时候用逗号隔开

def jiachen1(A):
    return A+1
print(jiachen1(1),type(jiachen1(1)))#(2, 3) <class 'tuple'>

形参

定义函数时候用到的定义参数

实参

真正运行时候用到的参数

def zzs(arg,arg1=1):
    print(arg,arg1)
zzs(1)#11
zzs(1,2)#11

有默认值的调用时候可以只输入没默认值的

如果输入默认值的默认值会更换

默认值参数需要放后面

因为数要根据位置去匹配

也可以通过调用时候输入来确定

def zzs(arg,arg1=1,arg2=1):
    print(arg,arg1,arg2)
zzs(arg1=2,arg=1,arg2=5)

会按照输入参数来确定输入

特殊参数

*args

一个或者多个参数 aegs 名字可以改 重点是星号

def zzs(arg,*args):
    print(arg,*args )#1 2 3 4 5
    print(args,type(args))#(2, 3, 4, 5) <class 'tuple'>
	#	print(type(*args)) 会报错 因为他是多个数
zzs(1,2,3,4,5)

**kwargs

一个或者多个关键字参数

一言概之，*主要使用在函数参数中，在定义函数中添加是为了在调用该函数时直接将多个参数转换成一个元组，而在调用函数时参数添加，是为了将列表/元组转化成多个参数。

也主要使用在函数参数中，在定义函数中添加是为了在调用该函数时可以添加任意个键值对转出一个字典，而在调用函数时在列表中添加，是为了将字典转化成多个参数。

如例子：

def func1(*a):
	print(a)
	
def func2(**b):
	print(b)
func1(1,2,3,4,5)			#这样可以将多个参数变成一个元组
func2(name='mr',age='22')	#这样可以将多个键值对变成一个字典
	
def f1(a,b,c):
	print(a)
def f2(name,age,sex):
	print(name)
l = [1,2,3]
d = {"name":'mr',"age":22,"sex":'boy'}
f1(*l)						#将列表、元组变成多个参数`
`f2(**d)						#将字典转成赋值参数，name='mr',age=22,sex='boy'`

func1(*l)					#先将参数转成多个参数，在函数参数中又转成元组`		
func2(**d)					#先将参数转成多个键值对，在函数参数中又转成字典`

结果：

(1, 2, 3, 4, 5)
{'age': '22', 'name': 'mr'}
1
mr
(1, 2, 3)
{'age': 22, 'sex': 'boy', 'name': 'mr'}

/

作用 在它之前的参数只能以位置参数形式传入

def hunhe(X1,Y1,/,X=None,Y=None):
    return X1,Y1,X,Y
print(hunhe(X1=1,Y1=2,X=3,Y=2))
#报错因为x1y1不是以位置参数传入的

*

作用 在它之后的参数只能以关键字参数形式传入

def hunhe(*,X1,Y1,X=None,Y=None):
    return X1,Y1,X,Y
print(hunhe(X1=1,Y1=2,X=3,Y=2))#（1,2,3,4）
print(hunhe(1,2,3,4))#报错

调用

def print_123():
    print("123")
print_123()#调用函数 输出123
PPPP=print_123 #获取函数
PPPP()#调用函数 输出123

嵌套函数

定义

def outer():
    def inner():
        print("inner")
    print("outer")
    return inner()
outer()
#outer
#inner

递归

定义

函数自身调用自身

应用

累加

def num(N):
    if N==1:
        return 1
    else:
        return num(N-1)+N
print(num(100))#5050

时间函数

类

定义

语法格式

class 类名:

注意 类名 尽量使用驼峰命名 单词首字符大写

class Person:
    name="张三"
    age=18
    gender="男"
    def  test():
        print("this is test")
    pass

初始化变量定义

定义在 初始化类 _ init_ 中

注 外部的是类变量 如果一个修改了 就全修改了需要实例化

class Person:
    def __init__(self,name,age,gender):
        self.name=name
        self.agr=age
        self.gender=gender
    def  print(self):
        return self.name,self.agr,self.gender
student1=Person("li",18,"男")
student2=Person("si",18,"nv")
print(student1.print())#('li', 18, '男')
print(student2.print())#('si', 18, 'nv')

类变量实例化

实例化前

class delivery:
    location="beixin"
    def __init__(self, id, from1, to, type):
        self.id=id
        self.from1 = from1
        self.to=to
        self.type = type
    pass
kuaiid1=delivery
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#2

实例化后

class delivery:
    location="beixin"
    def __init__(self, id, from1, to, type):
        self.id=id
        self.from1 = from1
        self.to=to
        self.type = type
kuaiid1=delivery(1,1,1,1)#实例化
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#beixin

若实例化后 无对象类变量继续修改实例化类变量类变量不会改变

但是修改其他的类变量 实例化类变量类变量也会改变

kuaiid1=delivery(1,1,1,1)
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#beixin

修改未实例化的类变量

kuaiid1=delivery(1,1,1,1)
kuaiid2=delivery
kuaiid2.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#2

继承

父类默认为object

class delivery(object):
    pass

suber()

寻找父类方法

suber(A，c)

从A类之后开始寻找

具体百度

_和 _ _

在类中实现私有和不被继承

_name 即外部人直接调用时候 用 . . 不出来

但是如果全拼的时候还是可以找到的

_ _funt()

双下划线方法 被调用时候 会被改名为类名加_ _funt()

达到不被调用效果 但是全拼还是可以调用的

注：python中没有私有的概念：这是约定的东西 是希望可以遵守

区快概念

date=1
def txt():
    date=2
    print(date)#2
print(date)#1
txt()
print(date)#1

装饰器

@ 叫语法糖

def decorate(text):
    def innter():
        print("内部1")
        text()
        print("内部2")
    return innter
@decorate
def fund():
    print("东西")

fund()

下面更无敌 上面的不可传参数

def decorate(text):
    def innter(*args,**kwargs):
        print("内部1")
        text(*args,**kwargs)
        print("内部2")
    return innter
@decorate
def fund(i):
    print(f"东西{i}")

fund(1)

本文章还较为残缺 后续补 全随缘