1.1 无参函数def foo():print('hello word ')
foo()1.2有参函数
def foo(x,y):print(x,y)foo(1,2)
1.3 空函数
def f1():pass
def f2():pass

2.1语句形式
2.1 #语句形式
def foo():print('from foo')
foo()2.2 表达式形式2.2 表达式形式
def foo(x,y):res = x + yreturn resres=foo(1,2) #表达式形式
res1=foo(1,2)*100
print(res1)2.3 可以当做参数传给另一个函数def max2(x,y):if x > y:return xelse:return y1 2 3
res=max2(max2(1,2),3)
print(res)

# 形参和实参的具体分类
一:位置参数
1.1 位置形参:在定义函数阶段按照从左到右的顺序依次定义的形参
注意:凡是按照位置传值得形参,即位置形参,必须被传值,多一个少一个都不行def foo(x,y):  #此处的x,y皆为位置形参print(x,y)foo(1,2) #此处的x,y皆为位置实参1.2位置实参:在函数调用阶段按照从左到右的顺序依次传入的值,叫做位置实参
注意:凡是按照位置定义的实参,会与形参意义对应二:关键字参数:
关键字实参:在调用阶段,按照key=value 的形式指名道姓的为形参传值
注意:1.可以完全打乱顺序,但仍然能指名道姓的为指定的形参传值2可以混合使用位置实参和关键字实参,但是必须的注意:2.1 位置参数必须放到关键字实参的前面2.2 不能对一个形参重复赋值def foo(name,age):print(name,age)foo(name='andy',age=21) #按照关键字实参为形参指名道姓的传值
foo(age=21,name='andy') #顺序发生变法关键字实参依然可以为形参传值
foo('andy',21) #按照位置传值也可以
三:默认参数
默认参数 :指的是在定义函数阶段,就已经为某个形参赋值了,将形参改为有默认值的形参,简称为默认形参
注意:1.在定义阶段就已经被赋值,意味着在调用阶段可以不为赋值2.位置形参应该放到默认形参前面3默认参数的值在通常情况下是不可变类型(要是想改变,在调用阶段为其传值即可)位置形参vs 默认形参对于大多数情况下值不相同的,应该被定义为位置形参对于大多数情况下的值是相同的,应该被定义为默认参数(比如人的分类)def classify('name','age','hight','sex'=男):print(name,age,hight,sex)classify('张三','12','129')
classify('李四','15','192')
classify('王五','17','180')
classify('小猪','18','172','女')四:可变长参数站在实参的角度,参数长度指的是再调用函数时, 传入实参值的个数不固定
而实参的定义方式无非两种:位置实参和关键字实参对应着形参也必须有两解决方案*与**,
类分别应对溢出的位置实参1.在形参中带* 会将调用的函数溢出的部分保存成元祖的形式,然后复制给*后面的变量名def foo(x,y,*z): #z=(3,4,5,6)print(x,y,z)foo(1,2,3,4,5,6)2.在实参中带*,但凡 在实参中带*,在传值之前都先将其打散成位置实参,再进行赋值
def foo(x,y):print(x,y)foo(*(1,2,3,4,5))3.在实参中带**,但凡在实参中带**号,在传值之前会将其打散成关键字实参,在再进行赋值
4.在形参中dai**,但凡在形参中带**号,会将调用函数时溢出的关键词实参保存成字典的格式,
然后赋值给**号后面的变量名#5. 规范: 在形参中带*与**的,*后的变量名应该为args,**后跟的变量名应该时kwargs"""

# def func(): # func=函数的内存地址
#     print('hello word')
#
# print(func())

'''def login():print("登录")
def register():print("注册")def shopping():print("购物")def pay():print("付钱")def tramsfer():print("transfer")dic={'1':login,'2':register,'3':shopping,'4':pay,'5':tramsfer}
msg="""
0 退出
1 登陆
2 注册
3 购物
4 支付
5 转账
"""
while True:print(msg)choice=input("请输入你的选择")if choice == '0':breakif choice in dic:dic[choice]()else:print("请重新输入")
'''

# def bar():
#     print('bar')
#
# def foo():
#     print('foo')
#     bar()
# foo()
#
# 举一个小栗子:
# def max1(x,y):
#     return  x if x>y else y
# def max2(a,b,c,d):
#     res1=max1(a,b)
#     res2=max1(res1,c)
#     res3=max1(res2,d)
#     return res3
# l=max2(2,4,5,6)
# print(l)
#

'''
from math import pi
def lll(r,action=0):"""计算圆的面积和周长:param r:传入圆的半径:param action:传入你要选个的数 ,:return:     返回选1就是面积,选2 就是周长"""def area(r):return  pi*(r**2)def perimeter(r):return 2*pi*rif action==1:return area(r)elif action=='2':return  perimeter(r)print("下面是你的选择界面")
radius=int(input("请输入你要计算的圆的半径")     )
inp=int(input("请输入你要选择的方面1 面积  2'周长")    )res=lll(radius,inp)
print(res)'''

# # len=111
#
# def foo():
#     len=222
#     print(len)
#
# foo()
# print('站在全局找len: ',len)# x=111
#
# def f1():
#     x=222
#     def f2():
#         def f3():
#             # x=444
#             print(x)
#         x=333
#         f3()
#     f2()
# f1()

# x=111
# def outer():
#     def inner():
#         print('from inner',x) # x访问的时全局名称空间中x
#     return inner
#
# f=outer()
# # print(f)
#
# x=222
# f()# 案列三:
# x=111
# def outer():
#     def inner():
#         print('from inner',x) # x访问的时全局名称空间中x
#     return inner
#
# f=outer()
#
# # x=222
# def func():
#     x=333
#     f()
#
# x=444
#
# func()# 案列四:
# x=111
# def outer():
#     def inner():
#         print('from inner',x) # x是来自于当前层的名字
#         x=2222222222
#     return inner
#
# f=outer()
#
# f()
'''

"""
# global，nonlocal# x=1
# def foo():
#     x=2
#
# foo()
# print(x)# l=[]
# def foo():
#     l.append(1)
#     # l=33333
# foo()
# print(l)#global:在局部声明一个名字是来自于全局作用域的，可以用来在局部修改全局的不可变类型
# x=1
# def foo():
#     global x
#     x=2
#
# foo()
# print(x)#nonlocal:声明一个名字是来自于当前层外一层作用域的，可以用来在局部修改外层函数的不可变类型
x=0
def f1():x=111def f2():# global xnonlocal xx=222f2()print(x)f1()
# print(x)"""

def get(url):response=requests.get(url)if response.status_code == 200:print(len(response.text))# get('https://www.baidu.com')
# get('https://www.baidu.com')
# get('https://www.baidu.com')
# get('https://www.tmall.com')
# get('https://www.tmall.com')# url1='https://www.baidu.com'
# url2='https://www.tmall.com'
#
# get(url1)
# get(url1)
# get(url1)
#
# get(url2)
# get(url2)
# get(url2)
#

# def outter(url):
#     # url='https://www.baidu.com'
#     def get():
#         response=requests.get(url)
#         if response.status_code == 200:
#             print(len(response.text))
#     return get
#
# baidu=outter('https://www.baidu.com')
# baidu()
# baidu()
# baidu()
#
# tmall=outter('https://www.tmall.com')
# tmall()
# tmall()
"""

# 补充:所有的数据类型的值自带布尔值,可以直接当作条件去用,只需要记
# 住布尔值为假的那一些值即可(0,空,None)
import time
current_user={'username':None}
def login(engine='file'):def auth(func):def wrapper(*agrs,**kwargs):if current_user['username']:print('已经登陆过了')res = func(*agrs,**kwargs)return resif engine=='file':user=input("请输入你的用户名")pwd=input("请输入密码")if user=='andy' and pwd=='123':print("登陆成功")current_user['username']=userres=func(*agrs,**kwargs)return reselse:print("username or password error")elif engine=='mysql':print("基于mysql的认证机制")elif engine=='ldap':print('基于ldap的认证机制')else:print("无法识别的认证源")return wrapperreturn auth@login('mysql')
def index():print("welcome to index page")time.sleep(3)index()

"""
import  timedef outter(func):def inner(*args,**kwargs):print("这里是装饰器")start_time=time.time()res=func(*args,**kwargs)stop_time=time.time()print("所用时间是%s"%(stop_time-start_time))return inner
# @outter
# def index():
#     print("快点叫爸爸")
#     time.sleep(3)@outter
def home(name):print("快点回家%s"%name)time.sleep(1)home('andy')
# index()"""

def outter(func): # func=foo  被装饰函数的地址def inner(*args,**kwargs): #括号里面是被装饰函数的参数#这个地方填上被装饰函数前面要添加的东西res=func(*args,**kwargs)  #此时的func ()就是调用foo函数,并将韩绘制赋值给res#这个地方添加被装饰函数后面要添加的东西return resreturn inner@outter
def foo():print("hello word")return 'foo 函数的返回值'foo()

import time
def auth(func):def wrapper(*args,**kwargs):username=input("please input you username ")password=input("please input you password")if username=='andy'and password =='123':print("登陆成功")start_time=time.time()res=func(*args,**kwargs)stop_time = time.time()print("中间的时间间隔是%s"%(stop_time-start_time))return reselse:print("登录失败")return wrapper#下面是装饰一个无参函数
# @auth
# def index():
#     print("这是一个被调用的函数")
#     time.sleep(3)
#     return '加油,少年'#下面是装饰一个有参函数
@auth
def home(age):print("我的年龄是%s"%age)time.sleep(1)return '加油'# print(index())  #无参时的调用
print(home('欧阳')) #有参时候的调用"""

"""
def auth(x):  # 此处的x 就是装饰器里面传来的参数def outter(func):  # 此时的func 就是以前foo的内存地址def inner(*args, **kwargs):  # inner里面的参数就是 foo里面的参数if x=='1':res = func(*args, **kwargs)  # 执行以前的foo函数return reselse:print("我本可以更强大,只是压力不够")return inner  # 此时的inner就是fooreturn outter@auth('1')
def foo(name):print("hello word %s"%name)return '加油'foo('ouyang')
"""

# age(5)=18  age4=age(3)+2
# def age(n):
#     if n==5:
#         return 18
#     return age(n+1)-2
#
# # age(5)
# print(age(1))

# name=input('user').strip()
# res='loser' if name=='andy' else '强大'
# print(res)
"""# def foo(x,y):
#     if x>y:
#         return x
#     else:
#         return y
#
# foo(1,2)# def max1(x,y):
#     return x if x > y else y
#
# print(max1(1,2))# name=input('user').strip()
# res='loser' if name=='andy' else '强大'
# print(res)
# """

# l=[name+'dsb' for name in names ]
# print(l)# 将下面列表里面的元素后面有dsb的添加到另外的列表
# names=['alex_dsb', 'lqz_dsb', 'yyh_dsb', 'fm_dsb','andy','ouyang']
# l=[]
# for name in names:
#     if name.endswith('dsb'):
#         l.append(name)
#
# print(l)# 列表生成式如下
# l=[name for name in names if name.endswith('dsb')  ]
# print(l)# 补充,为列表加上序号
# dic={key:vals[x] for x,key in enumerate(keys) }# l=['a','b','c','d','e']
# for i,j in enumerate(l):
#     print(i,j)
keys=['name','age','sex']
vals=['egon',18,'male']
# dic={}
# for x,key in enumerate(keys):
#     dic[key]=vals[x]
# print(dic
#
# )# dic={key:vals[x] for x,key in enumerate(keys) }

'''# l=['a','b','c']
# l='hello'
# l=('a','b','c')
# i=0
# while i < len(l):
# print(l[i])
# i+=1#一 ：可迭代的对象iterable：但凡内置有__iter__方法的对象都称之为可迭代的对象
#可迭代的对象：str，list，tuple，dict，set,文件对象
# a=1
# b=1.1
# c='hello'
# d=['a','b']
# e=('a','b')
# j={'x':1}
# g={1,2,3}
# f=open('a.txt','w')# 执行可迭代对象下的__iter__方法，返回的值就是一个迭代器对象iterator# dic={'x':1,'y':2,'z':3}
# iter_dic=dic.__iter__()
#
# # print(iter_dic)
# print(iter_dic.__next__())
# print(iter_dic.__next__())
# print(iter_dic.__next__())
# print(iter_dic.__next__()) #StopIteration应该被当成一种结束信号# f=open('a.txt','rt',encoding='utf-8')
# iter_f=f.__iter__()
# print(iter_f.__next__())
# print(iter_f.__next__())
# print(iter_f.__next__())
# print(iter_f.__next__())# l=['a','b','c']
# iter_l=l.__iter__()
#
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())
# print(iter_l.__next__())# l=['a','b','c']
# print(l.__iter__().__next__())
# print(l.__iter__().__next__())
# print(l.__iter__().__next__())
# iter_l=l.__iter__()
# print(iter_l.__next__())
# print(iter_l.__next__())#二： 迭代器对象
#1. 既内置有__next__方法的对象，执行迭代器__next__方法可以不依赖索引取值
#2. 又内置有__iter__方法的对象，执行迭代器__iter__方法得到的仍然是迭代器本身
# ps:
# 1.迭代器对象一定是可迭代的对象，而可迭代的对象却不一定是迭代器对象
# 2.文件对象本身就是一个迭代器对象
# l=['a','b','c']
# iter_l=l.__iter__() # 调用可迭代的对象__iter__得到的是迭代对象，
# print(iter_l is iter_l.__iter__().__iter__().__iter__().__iter__().__iter__().__iter__())# dic={1,2,3,4}
# dic={'x':1,'y':2,'z':3}
# # print(len(dic)) #dic.__len__()
# iter_dic=iter(dic) # dic.__iter__()
#
# while True:
# try:
# print(next(iter_dic)) #iter_dic.__next__()
# except StopIteration:
# break
#
# print('='*100)
# # 同一个迭代器只能完整地取完一次值
# iter_dic=iter(dic) #dic.__iter__()
# while True:
# try:
# print(next(iter_dic)) #iter_dic.__next__()
# except StopIteration:
# break#for本质应该称之为迭代器循环
#工作原理
#1. 先调用in后面那个对象的__iter__方法，将其变成一个迭代器对象
#2. 调用next(迭代器)，将得到的返回值赋值给变量名k
#3. 循环往复直到next(迭代器)抛出异常，for会自动捕捉异常然后结束循环# ps：从for角度，可以分辨出但凡可以被for循环循环取值的对象都是可迭代的对象
# dic={'x':1,'y':2,'z':3}
#
# for k in dic:
# print(k)
#
# for k in dic:
# print(k)

def func():print("111")yield 1print('222')yield 2g=func()
res=next(g)
print(res)

object.__dict__classmethod
staticmethod
propertydelattr
hasattr
getattr
setattrisinstance
issubclass

def talk():while True:username=input("please  input you username ")if username.isalpha():breakelse:print("用户名必须为字母")while True:password1=input("please input you password ")password2=input("please again input you password ")if password1 == password2:breakelse:print("两次输的密码不一致")role_dic={'1':'user','2':'admin'}while True:for k in role_dic:print(k,role_dic[k])choice=input("请输入您的身份>>").strip()if choice not in role_dic:print("数人的身份不存在")continuerole=role_dic[choice]breakreturn username,password2,role#将账号密码平成固定的格式
def register_interface(username,password,role):format_str='%s:%s:%s\n'%(username,password,role)return format# 将拼好的密码写成固定的格式def handle_file(format_str ,filepath):with open(r'%s' %filepath,'at',encoding='utf-8') as f:f.write(format_str)def register ():user,name,role=talk()format_str=register_interface(user,pwd,role)handle_file(format_str,'user.txt')register()