今日内容

函数的基本使用

原则：先定义，后调用

#    def 函数名（参数1，参数2，...）:
#       """文档描述"""
#       函数体
#       return值

定义函数的语法：
1.def: 定义函数的关键字
2.函数名：函数名只想函数内存地址，是对函数体代码的引用。函数的命名应该反应出函数的功能
3.括号：括号内定义参数，参数是可有可无的，且无需指定参数的类型
4.冒号：括号后要加冒号，然后再下一行开始缩进编写函数体的代码
5."""文档描述"""：描述函数功能，参数介绍等i西南西的文档，非必要，但是建议加上，从而增强函数的可读性；
6.函数题：由语句和表达式组成；
7.return值：定义函数的返回值，return是可有可无的
            
# 1、函数的使用原则：先定义，后调用
def foo(x: int, y: int) ---> int:  # foo=函数的内存地址
    print(x)
    print(y)
    print(x + y)
    # return 123

# res = foo("22222213123123", "22222222")

# foo()

x = 10


# print(x)
#
# print(foo)

# foo()

# res = foo(1,2)
# res()

# 2、定义函数的三种格式
# def foo():
#     print("hello")
#
#
# def bar(x, y):
#     res = x + y
#
#
# def spam():
#     pass

# 3、函数的返回值
# def foo():
#     return 123,"xx",[1,2,3]
#
# a,b,c = foo()
# print(a,b,c)

# 4、调用函数的三种格式
def foo():
    return 123

foo()
res = foo() * 10
print(foo())

函数的参数

        位置参数
            关键字参数
            默认参数
            可变长参数*与**

            def wrapper(*args,**kwargs):
                index(*args,**kwargs)

            wrapper(1,a=2,b=3)
            
 形参：函数定义阶段，括号内指定的参数（变量名）
 实参：函数调用阶段，括号内传入的值（变量值）
 二者的关系：
    在函数调用时，会将实参值绑定给形参名
    函数调用完毕后则解除绑定
# 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)
# foo(3, 2, 1)

 三 关键字实参
      在函数调用阶段，按照key=value的格式来传值，称之为关键字实参
      特点：可以打乱顺序，但仍能为指定的形参赋值
# foo(x=1, y=2, z=3)
# foo(y=2, x=1, z=3)
#      注意：可以混用位置实参与关键字实参，但是
#            1 位置实参必须跟在关键字实参前面
#            2 不能为同一个形参重复赋值
# foo(1,y=2,z=3)
# foo(y=2,1,z=3)
# foo(1,2,3,z=4)

四 默认形参
     在函数定义阶段，就已经为形参赋值，称之为默认形参
     特点: 定义阶段就已经有值了,意味着在调用阶段可以不用为其传值,
# 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 = 200  # m -> 200的内存地址
# 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(*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):
    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))  #bas 绝对值(相反数)
print(all([True,"Abc","",0]))  #放一个可以被for循环遍历的类型（在这里放了列表）所有遍历出来的布尔值都为真
print(all([True,"sdjhsj","12",1]))

print(any([True,"bac","",1]))   #只要其中一个为真就都为真

print(all([]))   #True
print(any([]))   #False

print(bin(111)) #十进制转二进制
print(oct(222)) #十进制转八进制
print(hex(333)) #十进制转十六进制

#基本数据类型
# bool
# int
# float
# list
# dict
# tuple
# set
# bytes

x=0
print(callable(x))  #callable判断一个对象是否可以调用的
print(callable(len))

print(chr(65))  #数字转字母
print(ord("Z"))  #字母转数字

l = [1,2,3]
print(dir(l))  #打印对象或者类中的方法

print(divmod(10,3)) #10 % 3 取余  函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
print(divmod(11298,30))  #(除数，余数）

print(pow(10,2,3)) #10 ** 2 % 3

names = ['egon','tom','jack']
for i,name in enumerate(names):  #enumerrate()会将数组或列表组成一个索引序列,使我们再获取索引和索引内容的时候更加方便
    print(i,name)

string = "print('hello')"
string = "[1,2,3]"
eval(string)   #eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码


s1 = frozenset({1,2,3})  #frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
s2 = set({1,2,3})
s2.add(3)