一、函数的基本使用
# 1、函数的使用原则：先定义，后调用
# 函数传值时跟“:”，注释的意思，不会对值本身产生影响
def foo(x: int, y: int) -> int: # foo=函数的内存地址
print(x)
print(y)
print(x + y)
# return 123
foo(1,2)
函数传值时跟“:”，注释的意思，并不能强制你根据注释来传值
# res = foo("22222213123123", "22222222")
# def foo() #函数的定义，就是将函数里的代码对应的内存地址给函数foo
# pass
# print(foo)
# x = 10 #变量名的定义，就是对10这个值对应的内存地址给变量x，打印变量x为10的原因是pycharm解释器对变量进行了特殊的处理。
# print(x)
# res = foo(1,2)
# res()
# 2、定义函数的三种格式
# def foo(): #无参函数
# print("hello")
#
#
# def bar(x, y): #有参函数
# res = x + y
#
#
# def spam(): #空函数
# pass
# 3、函数的返回值
# return是可有可无的，可返回单个值或多个值，也允许函数里有多个return，默认运行到第一个return返回值，函数立马结束，后面不返回值。可以用来结束一大段循环代码。
# def foo():
# return 123,"xx",[1,2,3]
#
# res = foo() #return返回多个值时是一个元组
# print(res)
# a,b,c = foo() #对返回值元组进行解压赋值
# print(a,b,c)
# 4、调用函数的三种格式
def foo():
return 123
foo() #语句形式
res = foo() * 10 #表达式形式
print(foo()) #把函数运行的值当做另一个函数的参数
二、函数的参数
# 形参：函数定义阶段，括号内指定的参数（变量名）
# 实参：函数调用阶段，括号内传入的值（变量值）
# 二者的关系：
# 在函数调用时，会将实参值绑定给形参名
# 函数调用完毕后则解除绑定
# def foo(x,y):
# print(x,y)
#
# foo(1,2)
# 一 位置形参
# 在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参
# 特点：必须被传值
# def foo(x, y, z):
# print(x, y, z)
# foo(1,2) #少了不行
# foo(1,2,3,4) #多了也不行
# foo(1,2,3)
# 二 位置实参
# 在函数调用阶段，按照左到右的顺序依次传入的值，称之为位置实参
# 特点：按照顺序依次为形参赋值
def foo(x, y, z):
print(x, y, z)
# foo(1, 2, 3) # x=1 y=2 z=3
# foo(3, 2, 1) # x=3 y=2 z=1
# 三 关键字实参
# 在函数调用阶段，按照key=value的格式来传值，称之为关键字实参
# 特点：可以打乱顺序，但仍能为指定的形参赋值
def foo(x, y, z):
print(x, y, z)
# foo(x=1, y=2, z=3)
# foo(y=2, x=1, z=3)
# 注意：可以混用位置实参与关键字实参，但是
# 1 位置实参必须跟在关键字实参前面
# 2 不能为同一个形参重复赋值
# foo(1,y=2,z=3) # x=1 y=2 z=3
# foo(y=2,1,z=3) # 报错1
# foo(1,2,3,z=4) # 报错2
# 四 默认形参
# 在函数定义阶段，就已经为形参赋值，称之为默认形参
# 特点: 定义阶段就已经有值了,意味着在调用阶段可以不用为其传值,当传值时，其值覆盖默认值。
# def foo(x,y=2222):
# print(x)
# print(y)
#
# foo(111,)
# foo(111,33333)
# 应用场景举例：
# def register(name, age, gender="male"):
# print(name)
# print(age)
# print(gender)
#
#
# # register("egon", 18, )
# # register("tom", 19, )
# # register("jack", 39, )
# register("lili", 19, 'female')
# 注意:
# 1 可以混用位置形参与关键字形参参，但是位置形参必须跟在默认形参的前面
# 2 默认形参的值推荐指向不可变类型
# 3 默认形参的值只在函数定义阶段被赋值一次
# # 例1
# m = 100 # m -> 100的内存地址
#
# def foo(x, y=m): # y -> 100的内存地址
# print(x, y)
#
# m = 200 # m -> 200的内存地址，不影响函数的值，不可变类型一定影响不了函数值
# foo(1)
# # 例2
# m = [111,222,333] # m -> [111,222,333]的内存地址
#
#
# def foo(x, y=m): # y -> [111,222,333]的内存地址
# print(x, y)
#
# m.append(6666) #影响函数的值，可变类型可能对函数值有影响
# foo(1)
# 例3
# def register(name, hobby, hobbies=None):
# if hobbies is None:
# hobbies = []
#
# hobbies.append(hobby)
# print("%s的爱好%s" % (name, hobbies))
#
# register("egon","read")
# register("tom","music")
# register("jack","drink")
# 五 可变长参数：*与**
# 在形参中带*: *会将溢出的位置实参值汇总成元组，然后赋值给紧跟其后的形参名
# def foo(x,*y): # y=(2,3,4,5,6)
# print(x,y)
# foo(1)
# foo(1,2,3,4,5,6)
# 在形参中带**: **会将溢出的关键字实参值汇总成字典，然后赋值给紧跟其后的形参名
# def foo(x,**y): # y={"a":111,"c":333,"b":222}
# print(x,y)
#
# foo(1,a=111,b=222,c=333)
# 在实参中带*
# def foo(x, y, z):
# print(x, y, z)
# foo(*[11, 22, 33]) # foo(11,22,33)
# foo(*"hello") # foo("h","e","l","l","o")
# 在实参中带**
# def foo(x, y, z):
# print(x, y, z)
# foo(*{"a":1,"b":2,"c":3}) # foo("a","b","c")
# foo(**{"a": 1, "b": 2, "c": 3}) # foo(c=3,a=1,b=2)
# foo(**{"x": 1, "z": 3, "y": 2}) # foo(y=2,z=3,x=1)
# 方法：基本
# def index(a,b,c):
# print(a,b,c)
#
# def wrapper(a,b,c):
# index(a,b,c)
#
# wrapper(1,2,3)
#这种方法可以将wrapper里的形参，完全给index里的实参
# 加强：
# def index(a, b, c，d, e, f):
# print(a, b, c, d, e, f)
# def wrapper(*args,**kwargs): # args=(1,2,3) kwargs={"x":111,"y":222,"z":333}
# index(*args,**kwargs) # index(*(1,2,3),**{"x":111,"y":222,"z":333})
# # index(1,2,3,x=111,y=222,z=333)
#
# # wrapper(1, 2, 3, x=111, y=222, z=333)
# wrapper(1,c=3,b=2)
#这种方法完善上面的方法
# 了解：命名关键字参数
def foo(x,y,*args,m=666,n): # m，n命名关键字形参
print(x,y)
print(m,n)
# foo(1,2,m=777,n=888)
# foo(1,2,n=999)
def foo(x,y=111,*args,m,n,**kwargs): #形参的顺序
pass
三、内置函数
# print(abs(-111)) #打印所取绝对值
#all后面跟可遍历的数据类型，判断其中所有元素的布尔值是否为真，值为True，只要有错，值为False。
# print(all([True, "abc", "", 0])) #False
# print(all([True, "adsf", "asd", 1])) #True
#any后面跟可遍历的数据类型，判断其中所有元素的布尔值只要有一个元素为真，值为True，只有所有元素都为假时，值为False。
# print(any([True, "abc", "", 0])) #True
# print(all([])) # True
# print(any([])) # False
# print(bin(11))
# print(oct(11))
# print(hex(11))
# bool
# int
# float
# list
# dict
# tuple
# set
# bytes
# x=10
# print(callable(x))
# print(callable(len))
# print(chr(65))
# print(ord("A"))
# print(ord("Z"))
# l = [1,2,3]
# print(dir(l)) #打印出l.出来的所有功能
# print(divmod(10,3)) # 10 % 3 值为一个元组(值，余数)
# print(divmod(36584,30)) # 36584 % 30 （1219,14）
# print(pow(10,2,3)) # 10 ** 2 % 3 取出的值为余数1
#给for循环出来的值标序
# names = ["egon",'tom',"jack"]
# for i,name in enumerate(names):
# print(i,name)
# string = "print('hello')"
# string = "[1,2,3]"
# eval(string) #将字符串里面的代码拿出来运行
# s1 = frozenset({1,2,3}) #定义一个不可变的集合
# s2 = set({1,2,3})
# s2.add(3)
# 面向对象
# object
# classmethod
# staticmethod
# property
# setattr
# getattr
# hasattr
# delattr
浙公网安备 33010602011771号