Python学习_第二模块_三元运算&函数

三元运算

a = 2
b = 5
val = a if  a < b else  b
print(val)  #2


# 如果 a 小于 b  val 就等于a    反之等于b

函数

例1 定义一个函数

def sayhi():
    print('hhhhh')

print(sayhi)    # 函数的内存地址
sayhi()     #调用函数

#结果
#<function sayhi at 0x0000000002592488>
#hhhhh

函数传参

# 2 函数传参
def  calc(x,y):
    res = x**y
    return  res 　　#返回函数的执行结果

c = calc(2,2)
print(c)  # 4

函数参数说明

"""
函数参数：
    形参变量
        只有在被调用时才分配内存单元，在调用结束时，即释放所分配的内存单元，因此形参只在函数内部有效。
        函数调用结束返回主调用函数后则不能再使用该形参变量

    实参
        可以是常量 变量 表达式 函数等，无论实参是何种类型的量，在进行函数调用时，它们必须有确定的值，
        以便把这些值传送给形参。 因此应预先用赋值    输入等办法使参数获得确定值

"""

形参与实参例子说明

# 形参  与实参的说明

def calc(x,y):      # x, y 是形参
    res = x**y
    return  res

c = calc(2,4)       # 2, 4 是实参
print(c)    #16

默认参数

def stu_register(name,age,country,course):
    print("--------注册学生信息---------")
    print("姓名：",name)
    print("age: ",age)
    print("国籍：",country)
    print("课程：",course)

stu_register("张三",22,"CN","python")

'''
--------注册学生信息---------
姓名： 张三
age:  22
国籍： CN
课程： python

'''

# course 设置默认参数   默认参数都是放在最后位
def stu_register(name,age,course,country="CN"):
    print("--------注册学生信息---------")
    print("姓名：",name)
    print("age: ",age)
    print("国籍：",country)
    print("课程：",course)

stu_register("张三",22,"python")

'''
--------注册学生信息---------
姓名： 张三
age:  22
国籍： CN
课程： python
'''

关键参数
　　　　正常情况下 给函数传参数要按顺序， 不想按顺序机可以用关键参数， 只需指定参数名即可（指定了参数名的参数就叫关键参数） 关键参数必须放在位置参数之后

def stu_register(name, age, course='PY' ,country='CN'):
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)



stu_register("王山炮",course='PY', age=22,country='JP' )

######下面2种调用方式是不允许的
# stu_register("王山炮",course='PY',22,country='JP' )
# stu_register("王山炮",22,age=25,country='JP' )

非固定参数 *args **kwargs

# *args
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)

stu_register("Alex",22)     #Alex 22 ()
stu_register("Jack",32,"CN","Python")   #Jack 32 ('CN', 'Python')

#**kwargs
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)


stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
# Jack 32 ('CN', 'Python') {'sex': 'Male', 'province': 'ShanDong'}

函数返回值说明

## 函数返回值
def stu_register(name, age, course='PY' ,country='CN'):
    print("----注册学生信息------")
    print("姓名:", name)
    print("age:", age)
    print("国籍:", country)
    print("课程:", course)
    if age > 22:
        return False
    else:
        return  True

resgistriation_status = stu_register("张三",19,course="py",country='JP')

if resgistriation_status:
    print("注册成功")
else:
    print("too old to be a student.")

# 说明   函数在执行过程中只要遇到return语句， 就会停止执行并返回结果， return 代表着函数的结束
# 如果未来函数中指定return, 那这个函数返回值为None

全局变量与局部变量

作用域即活动的范围

    全局范围：全局存活，全局有效
    局部范围：临时存活，局部有效
    在函数中修改全局变量可使用global来进行修改

name = 'augustyang'
# global  修改全局变量
def change_name():
    global  name
    name = 'alex'
    print(name)

change_name()
print(name)

'''
结果
    alex
    alex
'''

匿名函数 lambda

def calc(x,y):
    if  x < y:
        return  x*y
    else:
        return  x/y
print(calc(1,2))    # 2


func = lambda  x,y:x*y  if x < y else  x/y
print(func(1,2))   #2


# lambda
data = list(range(10))

for index, i in enumerate(data):
    data[index] = i*i
print(data)
## 结果 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]



def  f2(n):
    return  n*n

func = (map(lambda x:x*x,[1,2,3,4,5,6,7,8,9]))
print(list(func))
# 结果 [1, 4, 9, 16, 25, 36, 49, 64, 81]

递归函数

def calc(x):
    v = int(x/2)
    print(v)
    if v > 0:
        calc(v)
    else:
        print("----------------")
    print(x)

calc(10)

'''
结果：
5
2
1
0
----------------
1
2
5
10
'''

# 递归1
def  calc(n):
    v = int(n/2)
    print(v)
    if v == 0:
        return
    calc(v)

calc(10)

'''
5
2
1
0
'''

# 递归2
def  calc1(n):
    v = int(n/2)
    print(v)
    if v > 0:
        calc1(v)
    print(n)

calc1(10)

'''
5
2
1
0
1
2
5
10
'''

import time

person_list=['alex','wupeiqi','yuanhao','linhaifeng']
def ask_way(person_list):
    print('-'*60)
    if len(person_list) == 0:
        return '没人知道'
    person=person_list.pop(0)
    if person == 'linhaifeng':
        return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person
    print('hi 美男[%s],敢问路在何方' %person)
    print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
    time.sleep(3)
    res=ask_way(person_list)
    # print('%s问的结果是: %res' %(person,res))
    return res

res=ask_way(person_list)
print(res)

尾递归

# 尾递归
def factorial(n):

    if n == 1:
        return 1
    return n * factorial(n-1)

print(factorial(996))

递归特性

必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

来源：https://www.cnblogs.com/augustyang/p/10477184.html

标签

python函数

递归

python