python 学习day6

# 面向过程没有返回值，隐式返回None
# 函数式编程（和函数不是一回事）
import time
def fun1():
    time_format = '%Y-%m-%d %X'
    time_now = time.strftime(time_format)
    print(time_now)
    return 0

# 面向过程
def fun2():
    time_format = '%Y-%m-%d %X'
    time_now = time.strftime(time_format)
    print(time_now)

def fun3():
    time_format = '%Y-%m-%d %X'
    time_now = time.strftime(time_format)
    print(time_now)
    return 1,'sad',['aaa','bbb'],{'name':'aaa'}

x = fun1()
y = fun2()
z = fun3()

print(x)
print(y)
print(z)
# 总结：
# 返回值数=0：返回None
# 返回值数=1：返回一个对象
# 返回值数>1：返回一个元组

# 形参不占内存，实参占内存
# 位置实参顺序要一致，若关键字实参的话，则顺序无关紧要
def animal(type,name):
    '''宠物信息'''
    print('I have a ' + type + '.')
    print('My ' + type + "'s name is " + name.title() + '.')
animal('hamster','harry')
animal(type = 'hamster',name = 'harry')
animal(name = 'harry',type = 'hamster')

print('------------------------------')

# 形参指定默认值,有默认值的形参一定要放在无默认值的后面
def animal(type,name='harry'):
    '''宠物信息'''
    print('I have a ' + type + '.')
    print('My ' + type + "'s name is " + name.title() + '.')
animal('hamster')

print('--------------------------')

# 实参变成可选化
def name(first_name,last_name,middle_name=''):
    '''返回完整名字'''
    if middle_name:
        full_name = first_name+' '+middle_name+' '+last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name.title()

new_name = name('jimi','hendrix')
print(new_name)
new_name = name('john','hooker','lee')
print(new_name)


# 传递列表
def get_users(names):
    '''问候列表中的多有用户'''
    for name in names:
        print('Hello, ' + name.title() +'!')

usernames = ['刘备','关羽','张飞']
get_users(usernames)


# 函数中对列表的修改都是永久性的
def print_models(unprinted_designs , completed_models):
    '''
    模拟打印每个设计，知道没有未打印的设计为止
    打印每个设计后，都将其移到列表completed_models中
    '''
    while unprinted_designs:
        current_design = unprinted_designs.pop()
        # 模拟打印模型过程
        print('Printing model: ' + current_design)
        completed_models.append(current_design)

def show_completed_models(completed_models):
    '''显示打印好的所有模型'''
    print('\nThe following models have been printed:')
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs = ['iphone case' , 'robot pendant' , 'dodecahedron']
completed_modes =[]
print_models(unprinted_designs , completed_modes)
show_completed_models(completed_modes)
print(unprinted_designs)
print(completed_modes)

# 若禁止函数修改列表，可以使用切片表示法[:]创建列表的副本
# print_models(unprinted_designs[:] , completed_modes)
# show_completed_models(completed_modes)
# print(unprinted_designs)
# print(completed_modes)

# 传递任意数量的实参
def make_pizza(*toppings):   # 形参*toppings创建了一个空元组，并将收到的所有值都封装到这个元组中
    '''打印顾客点的配料'''
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

# 如果要让函数接收不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后，
# 先匹配位置实参和关键字实参。
def make_pizza(size , *toppings):
    '''概述要制作的pizza'''
    print("\nMaking a " + str(size) + "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)

make_pizza(12,'pepperoni')
make_pizza(16,'mushrooms','green peppers','extra cheese')


# 使用任意数量的关键字实参
# 形参**user_info创建了一个空字典，并将收到的所有名称—值对都封装到这个字典中。
def build_profile(first,last,**user_info):
    profile = {}
    profile ['first name'] = first
    profile ['last name'] = last
    for key , value in user_info.items():
        profile [key] = value
    return  profile

user_profile = build_profile('albert','einstein',
                             location = 'princeton',
                             field = 'physics')
user_profile1 = build_profile('albert','einstein',
                             **{'location':'princeton',
                             'field':'physics'}
                             )
print(user_profile)
print(user_profile1)

# *接收N个位置参数，转化为元组形式；**接收N个关键字参数，转化为字典形式
def test(name,age = 18,*args,**dic):
    print(name)
    print(age)
    print(args)
    print(dic)

test('刘备',50,60,'关羽','张飞',sex='m',location='China')


def funx(x):
    def funy(y):
        return x*y
    return funy   #return funy返回的是一个对象，可理解为funx是funy的一个对象

print(funx(7)(8))

def funx1(x):
    def funy1(y):
        return x*y
    return funy1() # return funy()返回的是funy的函数返回值，所以此处报错
print(funx1(7)(8))

def funx1(x):
    def funy1(y):
        return x*y
    return funy1(8)
print(funx1(7))

# 高阶函数：变量可以指向函数，函数的参数能接受变量，
# 那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y):
  return x+y

def add_twice(func,x,y):
  return func(func(x,y),func(x,y)) # 计算(5+10)+(5+10)

a=5
b=10
print(add_twice(add,a,b))


# 匿名函数，关键字：lambda
# lambda只是一个表达式，函数体比def简单很多。
# lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
# lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
# 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
# 匿名函数经常和其他函数配合使用,比如map(),reduce()

sum = lambda arg1, arg2: arg1 + arg2;
print("相加后的值为 : ", sum(10, 20))

# python2：map返回的是一个list；python3：map返回的是一个迭代器。
res1 = map(lambda x:x**2,[1,2,3,4])
for item in res1:
    print(item)

res2 = reduce(lambda x,y:x*y,range(1,6))
print(res2)

# 1.必须有一个明确的结束条件
# 2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
# 3.递归效率不高，递归层次过多会导致栈溢出

def fun(n):
    print(n)
    if n > 0:
        return  fun(n//2) # 取整除，返回商的整数部分（向下取整）
    print('---',n)
fun(10)

age = 18 # 这里的age是全局变量
lis = [1,2,3,4,5] # 这里的lis是全局变量
def change_name(name):
    global age # 强制性在函数内更改全局变量，强烈建议不这样做
    age = 20 # 这里的age是局部变量，简单的变量是无法更改全局的
    lis[0] = 6 #复杂的变量是会将全局更改的
    print("before change: ",name,age)
    name = '关羽' # 这里的name是局部变量
    print("after change",name,age)
    print(lis)

print(age)
name = '刘备'
change_name(name)
print(name,age)
print(lis)
age=14
print(age)