a=1
b=2
c=3
def waibu():
    b=20
    a=30
    def neibu():
        a=100
        print(a)
        print(b)
        print(c)
        print(max)
    neibu()
waibu()
# LEGB法则，查找变量的顺序。local局部域，enclose嵌套域，global全局，built-in内置作用域
100
20
3
<built-in function max>
#

a=1
b=2
c=3
def waibu():
    a,b=10,20
    def neibu():
        a=100
        print(a)
        print(b)
        print(c)
    neibu()
waibu()

a,b,c=1,2,3
def waibu():
    a,b=10,20
    def neibu():
        a=100
        print(a)
        print(b)
        print(c)
    neibu()
waibu()
#********************************************

#可变参数的两种方式。列表输入，元组返回。  字典key=value赋值
# def list1(*args):
#     print(args)
#     for i in range(len(args)):
#         print(args[i])
# a=[2,4,6,7]
# list1(a)

# def list1(args):
#     print(args)
#     for i in range(len(args)):
#         print(args[i])
# a=[2,3,4,5]
# list1(a)

def list1(args):
    print(args)
list1([4,5,6])

def dict1(**kwargs):
    for k,v in kwargs.items():
        print(k,v)
dict1(name='张三',age=1,sex="男") # 必须key=value方式传值

def dict1(**kwargs):
    for k,v in kwargs.items():
        print(k,v)
dict1(name='李四',age=2,sex='male')

def dict1(**kwargs):
    for k,v in kwargs.items():
        print(k,v)
dict1(name='王五',age=3,sex='nan')
#rgs结果类型是元组，传递值是任意类型。**kwargs结果类型是字典，传递值是以key=value方式传入
#********************************************

a={
    '001':{'name':'张三','age':18,'address':"河北"},
    '002':{'name':"李四",'age':28,'address':"河南"}
}
def modify():
    number=input("请输入要插入的学号：")
    if number in a.keys():
        print('学号重复，覆盖')
        a[number]['name']=input('请输入姓名：')
        a[number]['age']=input('请输入年龄')
        a[number]['address']=input('请输入地址')
    else:
        zidian={}
        zidian['name'] = input('请输入姓名：')
        zidian['age'] = input('请输入年龄')
        zidian['address'] = input('请输入地址')
        a[number]=zidian
modify()
for k,v in a.items():
    print(k,v)
# 改二维字典的值。
def modify():
    number=input('请输入要插入的学号')
    if number in a.keys():
        print("学号重复，覆盖")
        a[number]['name']=input('请输入姓名')
        a[number]['age']=input('请输入年龄')
        a[number]['address']=input('请输入地址')
    else:
        zidian={}
        zidian['name']=input('请输入姓名')
        zidian['age']=input('请输入年龄')
        zidian['address']=input('请输入地址')
        a[number]=zidian
modify()

def modify():
    number=input("请输入要插入的学号")
    if number in a.keys():
        a[number]['name']=input("请输入姓名")
        a[number]['age']=input("请输入年龄")
        a[number]['address']=input('请输入地址')
    else:
        zd={}
        zd['name']=input("请输入姓名")
        zd['age']=input("请输入年龄")
        zd['address']=input("请输入地址")
        a[number]=zd
modify()
#*******************************************

#  以下开始文件操作
f=open('F:\\a.txt','w') # 只写的方式打开文件。文件路径，转义字符 双斜杠 表 单斜杠。
f.write('bei jing wo ai ni,\n北京欢迎你')
f.close()
#上面是绝对路径，通过路径找文件。下面是相对路径，相对于程序工作目录
f=open('a.txt','w')
f.write('asdf;lkj\n12430987')
f.close()
f=open('a.txt','r')
print(f.read(3))  #读三个字符
f.close()
f=open('a.txt','r')
print(f.readline()) # 读一行，这里读第一行
print(f.readline(4)) #读一行的前4个字符，这里读第二行
print(f.readline()) # 读一行，这里读完第二行剩下的
print(f.readline()) # 读一行，文件只有两行，这里无值
f.close()

f=open('a.txt','r')
print(f.readlines())
f.close()
# 读文件，每一行成为列表中的一个元素。
['asdf;lkj\n', '12430987']
#

# f=open('a.txt','w',encoding=UTF-8 或者 GBK) # 选择编码方式
# r只读，w只写，a追加，r+读写，w+读写，a+读写
f=open('a.txt','a')
f.write('\n北京你好123')
f.close()

f=open('a.txt','r')
print(f.tell())
print(f.read(4))
print(f.tell())
f.close()
# f.tell() 返回光标位置，返回的是字节数。f.read(4) 读4个字符。汉字一个字符对应两个字节，英文一个字符一个字节

f=open('a.txt','r')
print(f.read(4))
f.seek(8,0) # 从文件开始位置，偏移6个字节。6是偏移量。0代表从开头偏移，1从当前文字，2从结尾
print(f.read())
#******************************************

import os
# os.rename('a','ab') # FileNotFoundError: [WinError 2] 系统找不到指定的文件。: 'a' -> 'ab'
os.rename('a.txt','ab.txt')
f=open('a.txt','r') # FileNotFoundError: [Errno 2] No such file or directory: 'a.txt'

import os
os.remove('ab.txt')
f=open('a.txt','w')
f.write('南京df;lkj\n12430987北京你好123\n北京你好123\n北京你好123')
f.close()
#*************************************************

# 目录操作
import os
# os.mkdir('F:\\workpy\\test\\a\\b',0x777) #创建目录，3个7 分别代表 自己，同组，其他，的权限  这个mkdir需要一层一层创建目录

# os.rmdir('test') #删除目录 。test文件夹里面有东西时，报错 OSError: [WinError 145] 目录不是空的。: 'test'

# print(os.getcwd())

print(os.listdir())

print(os.path.exists('a.txt')) # 检验给出的路径是否存在
print(os.path.exists('b.txt'))
print(os.path.exists('D:\\作业录屏_杨欢\\第一天0218'))
#************************************************************

# 关于赋值，copy，deepcopy
a=3
b=3
print(a==b)  # 值相等 True
print(id(a)==id(b))  # True a b在内存中的值都指向3
c=3
d=c
print(id(c)==id(d)) # True 整型，都指向3

a=[23,34]
b=[23,34]
print(a==b) # True
print(id(a)==id(b)) # False 列表，可变量，每个列表单独赋值，就是不同的内存地址 #loop1
c=a
print(id(a)==id(c)) # True
a.append(4)
print(c)
print(id(a)==id(c)) # True

a=3
b=a
a=4
print(a,id(a)) # a=4, b=3, id不同，a重新赋值了
print(b,id(b))

a=[2,3,4]
b=a
# a=[3,4,5]
print(a,id(a)) # a=4, b=3, id不同，a重新赋值了。不重新给a赋值则ab 的id相同
print(b,id(b))

import copy
a=3
b=copy.copy(a)
c=copy.deepcopy(a)
print(a,b,c)
print(id(a),id(b),id(c))
# a b c的id相同，都指向整型 3

a=[1,2,3]
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
print(id(a),id(b),id(c),id(d)) # a b的id相同，a c d的id不同,相当于上面loop1位置

a=[1,2,3,[4,5,6]]
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
print(id(a),id(b),id(c),id(d)) # a b的id相同，a c d的id不同
print(id(a[3]),id(b[3]),id(c[3]),id(d[3])) # a b c的id相同，d 的id不同. c是浅拷贝，内层列表只拷贝了id,

import copy
a=[1,2,3,[4,5,6]]
b=a
c=copy.copy(a)
d=copy.deepcopy(a)
print(id(a),id(b),id(c),id(d)) # a b的id相同，a c d的id不同
print(id(a[3]),id(b[3]),id(c[3]),id(d[3])) # a b c同
a.append(9) #在外层追加了值，和a的id相同的b跟着变
print(b,c,d)
print(id(a),id(b),id(c),id(d)) # a b的id相同，a c d的id不同
print(id(a[3]),id(b[3]),id(c[3]),id(d[3]))# a b c同
a[3].append(99)
print(c,d) # 浅拷贝的，拷贝内层的地址，a的内层改变，c内层地址对应的内容改了。
print(id(a),id(b),id(c),id(d)) # a b的id相同，a c d的id不同
print(id(a[3]),id(b[3]),id(c[3]),id(d[3]))# a b c同


#迭代器
a=[1,23,3]
b=iter(a) # 生成迭代器

# for i in b:
#     print(i)

print(next(b),type(b))
print(next(b),type(b))
print(next(b),type(b))
# print(next(b),type(b)) # 报错 StopIteration
#
1 <class 'list_iterator'>
23 <class 'list_iterator'>
3 <class 'list_iterator'>
#

a=(2,5,56)
b=iter(a)
# for i in b:
#     print(i)
print(next(b),type(b))
print(next(b),type(b))
print(next(b),type(b))

a={2,65,3,8}  #集合无序，每次运行，打印结果也会改变顺序
b=iter(a)
# for i in b:
#     print(i)
print(next(b),type(b))
print(next(b),type(b))
print(next(b),type(b))
print(next(b),type(b))
# 迭代器的用处
#**************************************

#生成器
def hanshu(n):
    i=0
    while i<n:
        print("不要跑")
        yield i # 这个“放弃”关键字，程序到这儿，循环暂停，返回i。  程序跳出去执行next(a)及其下面行，又回到这里继续
        print("等一下")
        i+=1
a=hanshu(1000)
print("现在执行我4")
print(next(a))
print("现在执行我1")
print(next(a))
print("现在执行我2")
print(next(a))
print("现在执行我3")
#
现在执行我4
不要跑
0
现在执行我1
等一下
不要跑
1
现在执行我2
等一下
不要跑
2
现在执行我3
# 所以，生产器的作用是

def hanshu(n):
    i=0
    while i<n:
        yield i
        i+=1
a=hanshu(10)
print(next(a))
print(next(a))

def hanshu(n):
    i=0
    while i<n:
        yield i
        i+=1
a=hanshu(10)
next(a)
print('a')
next(a)
print('b')
next(a)
print('c')

def hanshu(n):
    i=0
    while i<n:
        yield i
        i+=1
a=hanshu(10)
next(a)
print(next(a))
next(a)


def fbnq(n):
    a,b=0,1
    i=0
    while i<n:
        a,b=b,a+b
        print(a,b)
        yield a
        i+=1
f=fbnq(5)
next(f)
next(f)
next(f)
next(f)
next(f)
# next(f) #  6 个了，就报错StopIteration

def fbnq(n):
    a,b=0,1
    i=0
    for i in range(n):
        a,b=b,a+b
        yield a
f=fbnq(10)
# next(f)
for j in range(1,10):  #
    print(next(f))
next(f)
#***********************************************

import time
def jisuan():
    a=[i for i in range(100000000)]
    for n in a:
        pass
start=time.time()
jisuan()
end=time.time()
print(end-start)
# 计算程序运行的耗时，看程序运行效率

a=[1,2,3]
b=iter(a)  # 迭代器 iter  next
print(next(b))
next(b)
next(b)

def hanshu(n):
    for i in range(n):
        yield i # 和下面的next  ，生成器。
a=hanshu(6
next(a)
print("执行这里")
next(a)
print(next(a)) # 2
next(a)

def fbnq(n):
    a,b=0,1
    for i in range(n):
        a,b=b,a+b
        yield a
f=fbnq(8)
# for j in range(8):
#     print(next(f))
for fys in f:
    print(fys)
#****************************************

def a(b): # 用这个函数去传递函数名，从而调用了函数名对应的函数
    b()
def x():
    print('223')
a(x)

import time
def hx(f):
    print("看这里")
    def neibu():
        print('等一下')
        f()
        print("谁先谁后")
    print('ying gai shi ')

    return neibu
@hx
def jisuan():
    print('234353')
print("往哪里跑")
jisuan()
print("不要跑")

# 先检测到有 @hx,hx要装饰下面的函数
# 然后，执行hx()
# 从hx()跳出来后正常向下到jisuan()
# jisuan()这里不是跳入它的定义里面，而是调到hx的neibu()定义
# 最后到jisuan()的定义里面
# 综上，装饰器执行顺序是：装饰器函数hx，hx出来到jisuan(),进内部函数而不是计算(),内部函数执行到f(),f()调到jisuan()定义内部，f()后面的
#
# 看这里
# 往哪里跑
# 等一下
# 234353
# 谁先谁后
# 不要跑
#


def decor(f):
    i=0
    def neibu():
        # i=i+1
        print(i)
        f() # 内部函数调用外部变量

    return neibu
@decor
def jisuan():
    print('234343')

jisuan()
# 没有传参数的装饰函数
# 装饰器可以修饰多个函数，按 @ 顺序执行多个函数
@decor
def jisuan2():
    print("iwejoweifo")
jisuan2()

def decor(func):            # 2
    def neibu(canshu):       # 5
        print("*******")    #6
        func(canshu)        #7
        print('*******')    # 10
    return neibu            # 3
@decor                      # 1
def ych(name):              # 8
    print(name,"开演唱会")  # 9
ych('刘德华')              # 4


def decor(func):
    def neibu(canshu):
        print("*********")
        func(canshu)
        print('*********')
    return neibu
@decor
def ych(name):
    print(name,"开演唱会")
ych('刘德华')



def decor(func):
    def neibu(canshu):
        print("***********")
        func(canshu)
        print("***********")
    return neibu
def decor2(func):
    def neibu(canshu):
        print("###########")
        func(canshu)
        print("############")
    return neibu
@decor
@decor2
def ych(name):
    print(name,"开演唱会")
ych('刘德华')
"""

def hanshu(b): # 1 包含内部函数的函数
    a=3
    def neibu(c):
        d=a*b+c # 3内部函数用了外部函数的变量
        return d
    return neibu # 2 返回内部函数名
x=hanshu(4)
print(x(5))
print(x(6))

def hanshu(b):
    a=3
    def neibu(c):
        d=a*b+c
        return d
    return neibu
x=hanshu(4)
print(x(5))
print(x(6))

def hanshu(b):
    a=3
    def neibu(c):
        d=a*b+c
        return d
    return neibu
x=hanshu(4)
print(x(5))
print(x(6))

def hanshu(b):
    a=3
    def neibu(c):
        d=a*b+c
        return d
    return neibu
x=hanshu(4)
print(x(5))
print(x(6))

def waibu(func):
    def neibu(canshu):
        print("********")
        func(canshu)
        print("*******")
    return neibu
@waibu
def ych(name):
    print(name,"开演唱会")
ych('刘德华')