#语法
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回的值

#函数名要能反映其意义

def auth(user:str,password:str)->int:
    '''
    auth function
    :param user: 用户名
    :param password: 密码
    :return: 认证结果
    '''
    if user == 'egon' and password == '123':
        return 1
# print(auth.__annotations__) #{'user': <class 'str'>, 'password': <class 'str'>, 'return': <class 'int'>}

user=input('用户名>>: ').strip()
pwd=input('密码>>: ').strip()
res=auth(user,pwd)
print(res)

#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#测试三
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() #会报错吗?

'''
结论:函数的使用,必须遵循原则:先定义,后调用
我们在使用函数时,一定要明确地区分定义阶段和调用阶段
'''
#定义阶段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

#定义阶段
def tell_tag(tag,n): #有参数
    print(tag*n)

def tell_msg(): #无参数
    print('hello world!')

#调用阶段
tell_tag('*',12)
tell_msg()
tell_tag()

#结论：
#1、定义时无参，意味着调用时也无需传入参数
#2、定义时有参，意味着调用时则必须传入参数

# 空函数
def auth(user,password):                             
    '''                                                           
    auth function                                                 
    :param user: 用户名                                              
    :param password: 密码                                           
    :return: 认证结果                                                 
    '''                                                           
    pass                                                          
                                                                  
def get(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
    pass                                                          
                                                                  
def put(filename):                                                
    '''                                                           
    :param filename:                                              
    :return:                                                      
    '''                                                           
def ls(dirname):                                                  
    '''                                                           
    :param dirname:                                               
    :return:                                                      
    '''                                                           
    pass                                                          

#程序的体系结构立见           

print('+ - - - - + - - - - +')
print('|         |         |')
print('|         |         |')
print('|         |         |')
print('+ - - - - + - - - - +')
print('|         |         |')
print('|         |         |')
print('|         |         |')
print('+ - - - - + - - - - +')

- 无return->None

- return 1个值->返回1个值

- return 逗号分隔多个值->元组

name = "c"
def change_name():
    name = "Jerry"
    print("After change:", name)
change_name()
print("在外面看看name改了么?",name)

name = "Tom"
def change_name():
    global name #声明一个全局变量
    name = "Jerry"
    print("After change:", name)
change_name()
print("在外面看看name改了么?", name)

d = {"name":"Alex","age":26,"hobbie":"运动"}
l = ["Rebeeca","Katrina","Rachel"]
def change_data(info,name):
    info["hobbie"] = "学习"
    name.append("XiaoHong")
change_data(d,l)
print(d,l)

def calc(x, y):
    res = x ** y
    return res
a, b = 5, 8
c = calc(a, b)
print(c)

def calc(x, y):
    res = x ** y
    return res
a, b = 5, 8
c = calc(a, b)
print(c)

def calc(x, y):
    res = x ** y
    return res
a, b = 8, 5
c = calc(a, b)
print(c)

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
stu_register("王",22,"CN","python_devops")
stu_register("张",21,"CN","linux")
stu_register("刘",25,"CN","linux")

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

help(print)

# 「默认参数」可以是多个
def instrument3( id, ntl=1, curR='CNY' ):
    print( 'id:', id )
    print( 'notional:', ntl )
    print( 'reporting currency:', curR)
#instrument3( 'MM1001', 100, 'USD' )
# 有时在调用函数时，我们会记不住参数的顺序，比如 ntl 和 curR 的位置写反了
#instrument3( 'MM1001', 'USD', 100 )
# 在调用参数把它的「关键字」也带上，我们就可以随便调换参数的顺序。
#instrument3( 'MM1001', curR='USD', ntl=100 )

def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
    print(name,age,args)
stu_register("Alex",22)
#输出
#Alex 22 () #后面这个()就是args,只是因为没传值,所以为空
stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python')

def stu_register(name,age,*args,**kwargs): 
    print(name,age,args,kwargs)
stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

# 除了直接传入多个参数之外，还可以将所有参数先组装成字典 Conv，用以「**Conv」的形式传入函数
# Conv 是个字典，前面加个通配符 ** 是拆散字典，把字典的键值对传入函数中
DCF = (1, 2, 3, 4, 5)
Conv = {'dc':'act/365', 'bdc':'following'}
instrument( 'MM1001', 10, 'EUR', *DCF, **Conv )

print('hello', end = '')

# 用户希望 ctp 是个关键字参数
def instrument( id, ntl=1, curR='CNY', *, ctp, **kw ):
    print( 'id:', id )
    print( 'notional:', ntl )
    print( 'reporting currency:', curR )
    print( 'counterparty:', ctp )
    print( 'keyword:', kw)
#instrument( 'MM1001', 100, 'EUR', dc='act/365', ctp='GS' )
# 使用命名关键字参数时，要特别注意不能缺少参数名。
# 如果没有写参数名 ctp， 'GS' 被当成「位置参数」
# 原函数只有 3 个位置函数，现在调用了 4 个，因此程序会报错
instrument( 'MM1001', 100, 'EUR','GS', dc='act/365' )

# lambda x, y: x*y；函数输入是 x 和 y，输出是它们的积 x*y
func = lambda x, y: x*y
func(2, 3)

# lambda *args: sum(args)；输入是任意个数的参数，输出是它们的和
func = lambda *args: sum(args)
func( 1, 2, 3, 4, 5 )

# lambda **kwargs: 1；输入是任意键值对参数，输出是 1
func = lambda **kwargs: 1
func( name='Steven', age='36' )

# 下面的例子演示了在其他函数中使用匿名函数
# testfunc函数传入一个参数，将它与一个未知数相乘。
def testfunc(num):
    return lambda x : x * num
result1 = testfunc(10)
result2 = testfunc(1000)
print(result1(9))
print(result2(9))

# 用 map 函数对列表每个元素平方
lst = (1, 2, 3, 4, 5)
map_iter = map( lambda x: x**2, lst )
print( map_iter )
print( list(map_iter) )

#  filter 函数，顾名思义就是筛选函数
# 使用filter 函数把刚才列表中的奇数筛选出来
filter_iter = filter(lambda n: n % 2 == 1, lst)
print( filter_iter )
print( list(filter_iter) )

# reduce 函数，顾名思义就是累积函数
# 用reduce 函数把一组数减少 (reduce) 到一个数
from functools import reduce
reduce( lambda x,y: x*y, lst )

reduce( lambda x,y: x+y, lst, 100 )

def make_counter(init):
    counter = [init]
    
    def inc(): counter[0] += 1
    def dec(): counter[0] -= 1
    def get(): return counter[0]
    def reset(): counter[0] = init
        
    return inc, dec, get, reset

inc, dec, get, reset = make_counter(0)
inc()
inc()
inc()
get()

dec()
get()

reset()
get()

# list comprehension
[值 for 元素 in 可迭代对象 if 条件]
# dict comprehension
{键值对 for 元素 in 可迭代对象 if 条件}
# set comprehension
{值 for 元素 in 可迭代对象 if 条件} 

# 用带if的for循环
lst = [1, 2, 3, 4, 5]
odds = []
for n in lst:
    if n % 2 == 1:
        odds.append(n*2)
odds

# 用列表解析式
lst = [1, 2, 3, 4, 5]
odds = [n*2 for n in lst if n % 2 == 1]
odds

#「列表解析式」实现「在列表中先找出奇数再乘以 2」
[ n*2 for n in lst if n%2 == 1]
#「map/filter」实现「在列表中先找出奇数再乘以 2」
list( map(lambda n: n*2, filter(lambda n: n%2 == 1, lst)) )

tup = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

flattened = [x for t in tup for x in t]
flattened

# here is a mostly-straightforward solution to the
# two-by-two version of the grid.

def do_twice(f):
    f()
    f()

def do_four(f):
    do_twice(f)
    do_twice(f)

def print_beam():
    print('+ - - - -', end=' ')

def print_post():
    print('|        ', end=' ')

def print_beams():
    do_twice(print_beam)
    print('+')

def print_posts():
    do_twice(print_post)
    print('|')

def print_row():
    print_beams()
    do_four(print_posts)

def print_grid():
    do_twice(print_row)
    print_beams()

print_grid()

def one_four_one(f, g, h):
    f()
    do_four(g)
    h()

def print_plus():
    print('+', end=' ')

def print_dash():
    print('-', end=' ')

def print_bar():
    print('|', end=' ')

def print_space():
    print(' ', end=' ')

def print_end():
    print()

def nothing():
    "do nothing"

def print1beam():
    one_four_one(nothing, print_dash, print_plus)

def print1post():
    one_four_one(nothing, print_space, print_bar)

def print4beams():
    one_four_one(print_plus, print1beam, print_end)

def print4posts():
    one_four_one(print_bar, print1post, print_end)

def print_row():
    one_four_one(nothing, print4posts, print4beams)

def print_grid():
    one_four_one(print4beams, print_row, nothing)

print_grid()

def even_items(seq):
    return seq[1::2]
print(even_items([1,2,3,4,5,6,7]))

def my_sum(*num):
    return sum(num)
out = my_sum(1, 2, 3, 4)
print(out)

abs # 求绝对值 

all #Return True if bool(x) is True for all values x in the iterable.If the iterable is empty, return True.

any #Return True if bool(x) is True for any x in the iterable.If the iterable is empty, return False.

ascii #Return an ASCII-only representation of an object,ascii(“中国”) 返回”‘\u4e2d\u56fd’”

bin #返回整数的2进制格式 

bool # 判断一个数据结构是True or False, bool({}) 返回就是False, 因为是空dict

bytearray # 把byte变成 bytearray, 可修改的数组

bytes # bytes(“中国”,”gbk”) 

callable # 判断一个对象是否可调用 

chr # 返回一个数字对应的ascii字符 ， 比如chr(90)返回ascii里的’Z’

classmethod #面向对象时用，现在忽略

compile #py解释器自己用的东西，忽略

complex #求复数，一般人用不到

copyright #没用

credits #没用

delattr #面向对象时用，现在忽略

dict #生成一个空dict

dir #返回对象的可调用属性

divmod #返回除法的商和余数 ，比如divmod(4,2)，结果(2, 0) 

enumerate #返回列表的索引和元素，比如 d = [“alex”,”jack”]，enumerate(d)后，得到(0, ‘alex’) (1, ‘jack’)

eval #可以把字符串形式的list,dict,set,tuple,再转换成其原有的数据类型。 

exec #把字符串格式的代码，进行解义并执行，比如exec(“print(‘hellworld’)”)，会解义里面的字符串并执行

exit #退出程序

filter #对list、dict、set、tuple等可迭代对象进行过滤， filter(lambda x:x>10,[0,1,23,3,4,4,5,6,67,7])过滤出所有大于10的值

float #转成浮点

format #没用

frozenset #把一个集合变成不可修改的

getattr #面向对象时用，现在忽略

globals #打印全局作用域里的值 

hasattr #面向对象时用，现在忽略

hash #hash函数

help 

hex #返回一个10进制的16进制表示形式,hex(10) 返回’0xa’

id #查看对象内存地址

input 

int

isinstance #判断一个数据结构的类型，比如判断a是不是fronzenset, isinstance(a,frozenset) 返回 True or False

issubclass #面向对象时用，现在忽略

iter #把一个数据结构变成迭代器，讲了迭代器就明白了

len

list

locals

map # map(lambda x:x**2,[1,2,3,43,45,5,6,]) 输出 [1, 4, 9, 1849, 2025, 25, 36]

max # 求最大值 

memoryview # 一般人不用，忽略 

min # 求最小值 

next # 生成器会用到，现在忽略 

object #面向对象时用，现在忽略

oct # 返回10进制数的8进制表示

open 

ord # 返回ascii的字符对应的10进制数 ord(‘a’) 返回97，

print

property #面向对象时用，现在忽略

quit

range 

repr #没什么用

reversed # 可以把一个列表反转

round #可以把小数4舍5入成整数 ，round(10.15,1) 得10.2

set

setattr #面向对象时用，现在忽略

slice # 没用

sorted 

staticmethod #面向对象时用，现在忽略

str

sum #求和,a=[1, 4, 9, 1849, 2025, 25, 36],sum(a) 得3949

super #面向对象时用，现在忽略

tuple 

type 

vars #返回一个对象的属性，面向对象时就明白了

zip #可以把2个或多个列表拼成一个， a=[1, 4, 9, 1849, 2025, 25, 36]，b = [“a”,”b”,”c”,”d”]，