python基础第八课_函数2

函数作用域&内置函数

 

一、不定长参数

1.*args：表示不定长位置参数，存储在一个元组中，*b在函数内打印b, b 是一个元组，接收了所有其他的位置参数

例子1：

def add(a, *b):#*b表示不定长位置参数，b是一个元组，接收了所有其他位置参数
    print(f"a:{a}")
    print(f"b:{b}")



add(2, 3, 4, 5)

例子2：
def add(*args):#args是元组，sum(元组)，可以把元组中的元素加起来
    print(sum(args))


add(4, 5, 6, 7)

2.**kwargs表示不定长的关键字参数, 存储在一个字典当中
#c在函数内打印C会得到一个字典，接收所有的关键字参数，存放在字典中。
def add(a, *b, **c):
    print("a:", a)#a: 3
    print("b:", b)#b: ()
    print("c:", c)#c: {'x': 6, 'y': 10}


add(3, x=6, y=10)

3.python 经常这么写： *args, **kwargs

def add(a, *args, **kwargs):
    pass

4.函数定义的时候
def add(a, *b, **c):
    print("a", a)
    print("b", b)
    print("c", c)

5.在函数调用的时候，用*args和**kwargs
first = (3, 4, 5)
second = {"name": "yuz", "age": 1}

6.在函数定义时，在元组前面加一个*号，它会把元组拆开，小括号去掉，然后丢到一个函数里面。
7.在函数定义时，在字典前面加**，直接把字典转换成关键字形式，然后丢到函数里面。
8.调用时，*first会把元组外的小括号去掉，然后再把元组中的元素存储在元祖中。
9.调用时 **second会把字典的花括号去掉，里面的元素转换成关键字，然后再把里面的关键字参数，存储到字典中。

def add(a, *b, **c):
    print("a", a)
    print("b", b)
    print("c", c)


first = (3, 4, 5)
second = {"name": "yuz", "age": 1}

add(8, *first, **second)
#等价于
add(8, 3, 4, 5, name="yuz", age=1)

 

• 拆包

1. 元组拆包的语法，脱衣服

def add(a, *b, **c):
    print("a", a)
    print("b", b)
    print("c", c)


first = (2, 3, 4)
# 拆包的语法， 脱衣服
add(*first)

2.字典拆包的语法，脱衣服

def add(**c):
    print("c", c)


first = {"name": "yuz", "age": 3}
add(**first)

3.在函数定义的时候， *args, 接收不确定个数的位置参数
4.**kwargs, 接收不确定长度的关键字参数
5.在函数调用的时候， 先定义一个元组或者列表
 5.1 定义一个元组

def add(a):
    print(a)


first = (2, 3, 4)
add(first)#(2, 3, 4)


#a = (1,2,3)
# run(*a)  等价于 run(1,2,3)

def run(a,b,c):
    print(a)
    print(b)
    print(c)
x = (1,2,3)
run(*x)

5.2 定义一个列表
def run(a, b, c):
    print(a)
    print(b)
    print(c)


x = [1, 2, 4]
run(*x)

 

5.4 定义一个字符串

def run(a, b, c):
    print(a)
    print(b)
    print(c)

x = 'yuz'
run(*x)

 

• 作用域

1.局部变量：函数内可以定义变量，局部变量。
def run():
    a = 'pirate'
    print(a)

run()

2.全局变量：函数外定义变量，全局变量。
name = 'q'


def run():
    print(name)

run()


3.全局变量可以和局部变量重名
def run():
    name = "apple"
    print(name)

run()
name = 'new pirate'
print(name)


4.局部优先使用自己的变量，如果自己没有，再获取全局的变量
age = 15
def get_age():
    age = 18
    print(age)
get_age()


5.全局变量不能获取局部变量
def get_gender():
    gender = '男'
    print(gender)

get_gender()
# print(gender) #gender没有定义全局变量

6.global:对全局变量进行修改，必须先声明,不必要时，不要用

username = 'yuz'
def change_username():
    # 声明这是一个全局变量
    global username
    username = username + 'wang'
    print(username)


change_username()


print(username)

• 函数调用函数

1. 一个函数调用另外一个函数 

def eat(address, food):
    print(f"{address}狂吃了2斤{food}")


def get_offer(name, offer):
    print(f"{name}拿到了{offer}K 的 offer")
    # 一个函数调用了另一个函数
    eat('在家', '小龙虾')


get_offer('shelly', 20)

2.函数不要自己调自己，会超出了最大递归深度，报错
def get_offer(name, offer):
    print(f"{name}拿到了{offer}K 的 offer")
    # 函数自己调用自己，会超出了最大递归深度，报错
    get_offer(name, offer)

get_offer("岩里", 20)

 

 

• 内置函数

1.函数都是先定义，再调用。
def run():
    pass

run()

2.内置函数：函数不定义，也可以用, 因为这个函数python已经事先定义好了，就称为内置函数。

3.print()内置函数
print("hello")

4.eval()内置函数：是把一个字符串左右两边的引号去掉，脱字符串的衣服

string = "1 + 6"
print(string)
print(eval(string))

#等价于
print(1 + 6)

string = '{"name": "yuz"}'
print(type(string))
print(type(eval(string)))

5.sum() 求和内置函数
print(sum([3, 4, 5]))

6. zip（）内置函数：可以把两个列表转换成字典

a = ['case_id', 'url', 'method']
b = [1, 'http://www.baidu.com', 'get']

print(list(zip(a, b)))#[('case_id', 1), ('url', 'http://www.baidu.com'), ('method', 'get')]
# 两个列表可以转化成字典
print(dict(zip(a, b)))#{'case_id': 1, 'url': 'http://www.baidu.com', 'method': 'get'}


7.id() 是获取一个数据（对象） 在内存当中的位置

8.判断两个变量是否是同一个对象，看在内存中存在同样的位置
a = 'gibert'
b = 'gibert'
print(id(a))
print(id(b))


c = [3,4,5]
d = [3,4,5]
print(id(c))
print(id(d))

9.全部内置函数
地址：https://docs.python.org/zh-cn/3/library/functions.html