Python干货——函数(2)

# 函数的返回值
​
# 使用 return 返回函数的计算结果
def add(a, b):
    return a + b
​
print(add(1, 2))
复制代码

# 函数的嵌套调用
​
# 使用 return 返回函数的计算结果
def add(a, b):
    return a + b
​
def substruction(a, b):
    c: int = add(a, b)
    return c - b
​
# 函数的嵌套调用
result: int = substruction(1, 2)
print(result)
# 1
复制代码

def odd(char):
    # 定义一个列表存储奇数位的数据
    list_new: list = []
    # 定义一个变量来对应列表的下标值
    index: int = 0
    for data in char:
        if index % 2 == 1:
            list_new.append(data)
            # pass只是在书写代码跳出代码块的，并不会对代码的执行产生影响
            pass
        index += 1
        continue
        pass
    return list_new
​
print(odd(range(1, 11)))
复制代码

# 只获取一个字典的value的前两位，把这个前两位作为value值传递给一个新的字典
​
def obtain(**kwargs):
    # 定义一个新字典
    wordbook: dict = {}
    for key, value in kwargs.items():
        # 将旧字典的key以及value值赋值给新的字典
        if len(value) > 2:
            # 关键代码。因为向字典中添加一个新元素的时候，如果在key存在会替换value值
            # 如果key不存在会添加一个新的元素
            # 所提在这里使用这种方式相当于直接在字典中添加 key--value
            wordbook[key] = value[:2]
            pass
        else:
            wordbook[key] = value
            pass
        pass
    return wordbook
​
# 调用函数
dictionary: dict = {'name': '张三','hobby': ['游泳', '健身', '打豆豆'], 'room': 'Python1105班'}
print(obtain(**dictionary))
# {'name': '张三', 'hobby': ['游泳', '健身'], 'room': 'Py'}
​
复制代码

# 如果使用全局变量的时候直接拿来使用即可。不需要使用 global 关键字声明
# 只有在修改变量值的时候需要使用 global 关键字声明
复制代码

public class Test {
    private static String name = "张三";
    public static void main(String[] args) {
        add(); // 周六
    }
    // Java中在一个函数中可以直接修改全局变量
    public static void add(){
        name = "李四";
        System.out.println(name);
    }
}
复制代码

# 全局变量和局部变量
# 定义一个全局变量
name: str = '张三'
# 定义一个函数修这个全局变量
def modify():
    """
    在一个函数中修改全局变量
    此时这种形式不能修改，这种形式县相当于在函数中创建了一个name的局部变量
    :return:
    """
    name = '李四'
    print(name)
    pass
modify()
# 李四
​
print(name)
# 张三。Python中修改全局变量和Java是不一样的
# Java中直接获取就可以修改，而Python不可以
复制代码

# 全局变量和局部变量
# 定义一个全局变量
name: str = '张三'
# 定义一个函数修这个全局变量
def modify():
    """
    在一个函数中修改全局变量，必须在变量名的前面加上 global 关键字
    此时的 变量name就不是函数中从新声明的一个局部变量name
    而是全局变量中的name变量
    :return:
    """
    # 如果使用全局变量的时候直接拿来使用即可。不需要使用 global 关键字声明
    # 只有在修改变量值的时候需要使用 global 关键字声明
    print(name)
    global name
    name = '李四'
    print(name)
    pass
modify()
# 李四 (函数中的name代表全局变量中的name)
​
print(name)
# 李四 (全局变量的name)
复制代码

alobal char
char = [1, 2, 3, 4]
复制代码

   	2. **使用类型中的方法修改数据直接修改即可。不需要 global 关键字**
复制代码

char.append(5)
复制代码

# 全局变量和局部变量
# 定义一个全局变量的list列表
char: list = []
​
# 定义一个函数修这个全局变量
def modify():
    """
    当在函数中修改一个可变类型的数据的时候如果直接赋值需要使用 global 关键字
    :return:
    """
    # 全局的变量名可以大写，函数中的变量名字、形参、函数名一般小写
    # 直接赋值需要关键字
    global char
    char = [1, 2, 3, 4]
    return char
    pass
​
def modify2():
    """
    如果使用列表对应的方法可以进行直接的添加数据和修改数据，不需要 global 关键字
    :return:
    """
    char.append(5)
    return char
    pass
​
# 直接修改需要关键字 global
print(modify())
# [1, 2, 3, 4]
​
print(char)
# [1, 2, 3, 4]
​
# 使用列表中的方法修改不需要关键字
print(modify2())
# [1, 2, 3, 4, 5]
​
print(char)
# [1, 2, 3, 4, 5]
​
复制代码

lambda 参数1,参数2,参数3:执行代码语句(这个代码语句必须是表达式)
复制代码

# 这个test并不是函数名，而是变量名，相当于把这个匿名函数赋值给了一个变量
# 当在调用这个函数的时候使用这个变量名调用
test = lambda x,y:x+y
print(test(1,3))
# 4
print(test(4,5))
# 9
复制代码

# 此时的test叫做函数名
def test(x,y):
    reuturn x+y
复制代码

if a:
    b
else:
    c
复制代码

b if a else c 
复制代码

'可以参军' if age > 18 else '继续上学'
复制代码

greater = (lambda x, y: x if x > y else y)
print(greater(3, 5))
# 5
greater(6, 2)
# 6
复制代码

# 匿名函数可以参军
var = (lambda age: '可以参军' if age > 18 else '不可以参军')
​
# 调用匿名函数
print(var(20))
# 可以参军
复制代码

# 在定义lambda表达式的时候直接调用
rs = (lambda x, y: x if x > y else y)(3, 4)
print(rs)
# 4
复制代码

# 一个参数使用 lambda 表达式
parameter = lambda x: x*800+1
# 返回值是一个 int 类型，不能直接与字符串拼接，需要格式化操作
print('结果是：{}'.format(parameter(1)))
# 结果是：801
print('结果是：%d' % parameter(1))
# 结果是：801
复制代码