1 #! /usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #__author__ = "tqtl"
4 # Date:2018/5/14 21:57
5 #f = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘r‘)#UnicodeDecodeError: ‘gbk‘ codec can‘t decode byte 0xaf in position 9: illegal multibyte sequence
6 file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘r‘,encoding=‘utf-8‘)#打开文件；
7 file_data = file.read()#阅读文件内容；
8 print(file_data)#打印文件内容；
9 file.close()#一定要关闭文件；
总结：以什么样的编码格式存储文件，一定要使用相同的编码格式打开；

1 #! /usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #__author__ = "tqtl"
4 # Date:2018/5/14 22:22
5 # E-Mail: tqtl911@163.com
6 file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘rb‘)#b是binary的缩写，以二进制的形式打开文件，用于网络传输，给机器看，适用于不知道文件编码格式的场景；
7 file_data = file.read()#阅读文件内容；
8 print(file_data)#打印文件内容；
9 file.close()#一定要关闭文件；

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/14 22:36
 5 # E-Mail: tqtl911@163.com
 6 # Wechat:cxz19930911
 7 #pip 安装第三方模块chardet，类似于yum安装第三方软件；
 8 
 9 import chardet
10 f = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘rb‘)
11 data = f.read()
12 print(data)
13 f.close()
14 print(chardet.detect(data))#{‘encoding‘: ‘utf-8‘, ‘confidence‘: 0.99, ‘language‘: ‘‘}#0.9表示相似程度；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/19 0019 10:29
 6 import chardet#导入模块；
 7 file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘rb‘)
 8 data = file.read()
 9 print(data)
10 print(chardet.detect(data))#{‘encoding‘: ‘GB2312‘, ‘confidence‘: 0.823045267489712, ‘language‘: ‘Chinese‘}
11 print(data.decode(‘GB2312‘))#解码操作，显示中文；

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/14 23:04
 5 # E-Mail: tqtl911@163.com
 6 # Wechat:cxz19930911
 7 file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘r‘,encoding=‘utf-8‘)
 8 for lines in file:
 9     print(lines)
10 file.close()
11 # 王心颜    上海 169 46    13813234424
12 #
13 # 马纤羽     深圳    173    50    13744234523
14 #
15 # 乔亦菲    广州    172    52    15823423525
16 #
17 # 罗梦竹     北京    175    49    18623423421
18 #
19 # 刘诺涵     北京    170    48    18623423765
20 #
21 # 岳妮妮     深圳    177    54    18835324553
22 #
23 # 贺婉萱     深圳    174    52    18933434452
24 #
25 # 叶梓萱    上海    171    49    18042432324
26 #
27 # 杜姗姗 北京  167 49 13324523342
28 #
29 # black girl  河北  167 50  13542342233
30 #为什么会有空行，如何消除文件之间的空行？！
31 #No.1文件中本身隐藏着\n换行符；
32 #No.2 print语句本身会换行，所以呈现的效果是换了两行；

1 #写文件操作
2 file = open(file=‘兼职.txt‘,mode=‘w‘,encoding=‘utf-8‘)
3 file.write(‘北大本科美国留学一次50,微信号:cxz19930911‘)#write方法；
4 file.close()#注意，一定要关闭文件；

1 file = open(file=‘兼职write.txt‘,mode=‘wb‘)
2 file.write("路飞学城！".encode(‘gbk‘))
3 file.close()#输出：路飞学城！

1 file = open(file=‘兼职write.txt‘,mode=‘wb‘)
2 file.write("原子二号！".encode(‘gbk‘))
3 file.close()#输出：原子二号！

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 18:20
file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘ab‘)#b代表binary，二进制模式追加；
file.write(‘\n杠娘 北京 167 55 135585834333‘.encode(‘gbk‘))
file.close()#如果不是使用with方法，记得一定要关闭文件；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 18:28
file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘r+‘,encoding=‘gbk‘)#读写模式操作文件；
data = file.read()
print("content",data)
file.write("\nnewline 1哈哈")
file.write("\nnewline 2哈哈")
file.write("\nnewline 3哈哈")
file.write("\nnewline 4哈哈")
print("\nnew content",file.read())
file.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 18:28

#w+写读模式
file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘w+‘,encoding=‘gbk‘)#写读模式操作文件；
data = file.read()
print("content",data)
file.write("\nnewline 1哈哈")
file.write("\nnewline 2哈哈")
file.write("\nnewline 3哈哈")
file.write("\nnewline 4哈哈")
print("\nnew content",file.read())
file.close()

 1 C:\Users\Administrator\PycharmProjects\LFXC2018\venv\Scripts\python.exe "C:\Program Files\JetBrains\PyCharm 2018.1.3\helpers\pydev\pydevconsole.py" 50524 50525
 2 import sys; print(‘Python %s on %s‘ % (sys.version, sys.platform))
 3 sys.path.extend([‘C:\\Users\\Administrator\\PycharmProjects\\LFXC2018‘, ‘C:/Users/Administrator/PycharmProjects/LFXC2018‘])
 4 PyDev console: starting.
 5 Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
 6 file = open(file=‘file_flush_test.txt‘,mode=‘w‘,encoding=‘gbk‘)
 7 file.write(‘\n测试文件的flush操作‘)
 8 13
 9 file.write(‘\n再次测试文件flush操作2‘)
10 15
11 file.flush()

C:\Users\Administrator\PycharmProjects\LFXC2018\venv\Scripts\python.exe "C:\Program Files\JetBrains\PyCharm 2018.1.3\helpers\pydev\pydevconsole.py" 50583 50584
import sys; print(‘Python %s on %s‘ % (sys.version, sys.platform))
sys.path.extend([‘C:\\Users\\Administrator\\PycharmProjects\\LFXC2018‘, ‘C:/Users/Administrator/PycharmProjects/LFXC2018‘])
PyDev console: starting.
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
file = open(file=‘file_flush_test.txt‘,mode=‘w‘,encoding=‘gbk‘)
file.write(‘\n测试文件的flush操作‘)
13
file.write(‘\n再次测试文件flush操作2‘)
15
file.flush()
file.readable()
False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 19:32
file = open(file=‘兼职白领学生空姐模特护士的联系方式.txt‘,mode=‘r+‘,encoding=‘utf-8‘)
file.seek(10)
file.write("[路飞学城]luffycity")
file.close()

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/19 0019 21:29
 6 import os
 7 file_name = "兼职白领学生空姐模特护士的联系方式.txt"
 8 file_new_name = "%s.new"%file_name
 9 old_str = "乔亦菲"
10 new_str = "杠娘"
11 file = open(file = file_name,mode=‘r‘,encoding=‘utf-8‘)
12 file_new = open(file = file_new_name,mode=‘w‘,encoding=‘utf-8‘)
13 #循环遍历整个文件；
14 for line in file:#定义临时变量line
15     if old_str in line:
16         line = line.replace(old_str,new_str)
17     file_new.write(line)
18 file.close()
19 file_new.close()
20 os.rename(file_new_name,‘123.txt‘)

王心颜 [路飞学城]luffycity424
马纤羽    深圳 173    50 13744234523
乔亦菲    广州 172    52 15823423525
罗梦竹    北京 175    49 18623423421
刘诺涵    北京 170    48 18623423765
岳妮妮    深圳 177    54 18835324553
贺婉萱    深圳 174    52 18933434452
叶梓萱    上海 171    49 18042432324
杜姗姗 北京  167 49 13324523342
black girl  河北  167 50  13542342233

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 22:45
def helloworld():#函数名sayhi;
    print("Hello,I‘m TQTL.")
print(helloworld)#直接打印是内存地址：<function sayhi at 0x0000020147E219D8>;
helloworld()#通过函数名进行调用；
#函数可以带有参数;
def sayhi(name):
    print("Hello",name)
    print("My name is black girl.")
#sayhi()#TypeError: sayhi() missing 1 required positional argument: ‘name‘ 报错，缺少位置参数；
sayhi(‘TQTL‘)#Hello TQTL

#写一个计算两个数的乘方的程序；
a,b = 5,3
c = a**b
print(c)#125;
#使用函数改造以上程序；
def calc(x,y):
    res = x**y
    print(res)
calc(2,10)#1024;
calc(2,5)#32;
#函数的特性：
"""
小结：
1、减少重复代码，提升程序员的逼格儿；
2、使程序变得可拓展，引用函数的位置，修改一处即可完成扩展操作；
3、使程序变得容易维护，比如之前报警使用邮件，现在改为微信，修改一处即可；
函数，即对功能的封装；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:TQTL911
# Version:python3.6.6
# Time:18/6/30 22:25
""
"""
1、函数参数-形参变量、实参变量；
"""
def stu_register(name,age,country,course):#形参；
     print("学生注册信息".center(30,‘-‘))
     print(name,age,country,course)

stu_register("王山炮",22,"CN","Python")#实参；
stu_register("张叫春",21,"CN","Linux")#实参；
stu_register("刘老根",25,"CN","Devops")#实参；
print("两段程序的分割线".center(40,‘#‘))

"""
------------学生注册信息------------
王山炮 22 CN Python
------------学生注册信息------------
张叫春 21 CN Linux
------------学生注册信息------------
刘老根 25 CN Devops
################两段程序的分割线################
"""
#def stu_register(name,age,country = "CN",course):#形参，SyntaxError: non-default argument follows default argument

#引出默认参数；
def stu_register(name,age,course,country = "CN"):#形参；
    print("学生注册信息".center(30,‘*‘))
    print(name,age,course,country)

stu_register("王山炮",22,"Python")#不传实参；
stu_register("张叫春",21,"Linux","JP")#传了其他的实参JP；
stu_register("刘老根",25,"Devops","CN")#传了默认参数CN；
"""
************学生注册信息************
王山炮 22 Python CN
************学生注册信息************
张叫春 21 Linux JP
************学生注册信息************
刘老根 25 Devops CN
"""
# 小结：默认参数必须放在位置参数之后；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 11:03
""
"正常情况下，给函数stu_register传入参数要按照顺序,不想按照顺序传入就可以使用关键参数，只需指定参数名即可（即指定了参数名的参数就叫做关键参数），但关键参数必须放在位置参数之后"
def stu_register(name,age,course=‘PY‘,country=‘CN‘):#形参下的位置参数
    print("学生注册信息".center(30,‘-‘))
    print(‘姓名:‘,name)
    print(‘年龄:‘,age)
    print(‘国籍:‘,country)
    print(‘课程:‘,course)

#stu_register("王山炮",course = ‘PY‘,22,country = "JP",)#不可以这样表示,course = ‘PY‘应该在22之后；
#stu_register("王山炮",course = ‘PY‘,22,age=25,country = "JP",)；#也不可以如此表示，因为相当于传了两个age参数；
stu_register("王山炮",course = ‘PY‘,age = 22,country = "JP")#此时cousre、age就从位置参数转变成了关键参数；
"""
------------学生注册信息------------
姓名: 王山炮
年龄: 22
国籍: JP
课程: PY
"""

#关键参数的错误举例：
def stu_register(name,age,course,country=‘CN‘):#形参name,age,cource,默认参数：country=‘CN‘
    print("学生注册信息".center(30,‘*‘))
    print(name,age,course,country)
stu_register("TQTL",course="Python",age = 22)#默认参数country不填写；关键参数为course\age可以打乱顺序传值；
"""
************学生注册信息************
TQTL 22 Python CN
"""
#stu_register("TQTL",course="Python",22)#SyntaxError: positional argument follows keyword argument
#stu_register("TQTL",23,course="Python",age = 22)#TypeError: stu_register() got multiple values for argument ‘age‘

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 12:04
""
"""
1、需求：发送报警任务，公司仅有1个运维人员；
"""
def send_alert(msg,users):
    print(msg,users)
send_alert("报警发送给Linux运维工程师:","alex")
"""
1、新需求：发送报警任务，公司已经具备10个运维人员该如何应对？；
"""
def send_alerts(msg,*users,age):
    for u in users:
        print(msg,"报警发送给:",u)
send_alerts("此处是位置参数msg","rain","eric",age=22)
#send_alerts("alex","rain","eric",22)#TypeError: send_alert() missing 1 required keyword-only argument: ‘age‘
"""
小结：
1、如果参数中出现*users,传递的参数就可以不再是固定的个数，穿过来的所有参数打包成元组形式；
2、一般不会使用*uers,约定俗成使用*args来表示传入非固定参数；

"""

#传入参数的方式一：
send_alerts(‘发送报警给运维人员1‘,‘cuixiaozhao‘,‘lijingping‘,‘cuixiaoshan‘,age=28)
send_alerts(‘发送报警给运维人员2‘,‘cuixiaozhao‘,‘cuixiaoshan‘,age=28)
send_alerts(‘发送报警给运维人员3‘,‘cuixiaozhao‘,‘lijingping‘,‘cuixiaoshan‘,age=28)
send_alerts(‘发送报警给运维人员4‘,‘cuixiaozhao‘,‘lijingping‘,age=28)

#方式二：
send_alerts(‘发送报警给运维人员5‘,*[‘cuixiaozhao‘,‘lijingping‘,‘cuixiaoshan‘,‘cuixiaosi‘],age=28)#列表之前加*号；
"""
报警发送给Linux运维工程师: alex
此处是位置参数msg 报警发送给: rain
此处是位置参数msg 报警发送给: eric
发送报警给运维人员1 报警发送给: cuixiaozhao
发送报警给运维人员1 报警发送给: lijingping
发送报警给运维人员1 报警发送给: cuixiaoshan
发送报警给运维人员2 报警发送给: cuixiaozhao
发送报警给运维人员2 报警发送给: cuixiaoshan
发送报警给运维人员3 报警发送给: cuixiaozhao
发送报警给运维人员3 报警发送给: lijingping
发送报警给运维人员3 报警发送给: cuixiaoshan
发送报警给运维人员4 报警发送给: cuixiaozhao
发送报警给运维人员4 报警发送给: lijingping
发送报警给运维人员5 报警发送给: cuixiaozhao
发送报警给运维人员5 报警发送给: lijingping
发送报警给运维人员5 报警发送给: cuixiaoshan
发送报警给运维人员5 报警发送给: cuixiaosi
""" 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 12:10
""
"""
1、**kwargs形式的非固定参数，即字典形式数据；
"""
def user_info(name,*args,**kwargs):#**kwargs接受的是字典形式的数据；
    print(name,args,kwargs)
user_info("TQTL",22,"Model-3","1000ww")#TQTL (22, ‘Model3‘, ‘1000ww‘) {},最后一位返回空字典；
user_info("TQTL",22,"Model-3","1000ww",addr="河北省",tel=13811221893)#TQTL (22, ‘Model-3‘, ‘1000ww‘) {‘addr‘: ‘河北省‘, ‘tel‘: 13811221893}

d = {‘degree‘:‘primary school‘}
user_info(‘Peiqi‘,d)#Peiqi ({‘degree‘: ‘primary school‘},) {},此时d为字典形式；
user_info(‘Peiqi‘,**d)#Peiqi () {‘degree‘: ‘primary school‘}，字典前面加上**，即可传参正常；
"""
TQTL (22, ‘Model-3‘, ‘1000ww‘) {}
TQTL (22, ‘Model-3‘, ‘1000ww‘) {‘addr‘: ‘河北省‘, ‘tel‘: 13811221893}
Peiqi ({‘degree‘: ‘primary school‘},) {}
Peiqi () {‘degree‘: ‘primary school‘}
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 12:19
""
"""
1、函数外部的代码想要获取函数的执行结果，就可以在函数里用return语句把结果返回；
"""
def stu_register(name,age,course=‘PY‘,country=‘CN‘):#形参，默认参数为course,country，位置参数为name,age;
    print("学生注册信息".center(30,‘-‘))
    #print(‘\n姓名:‘,name,‘\n年龄:‘,age,‘\n国籍:‘,country,‘\n课程:‘,course)#显示效果同下方；
    print(‘姓名:‘,name)
    print(‘年龄:‘,age)
    print(‘国籍:‘,country)
    print(‘课程:‘,course)

    if age > 22:
        return False
        #return age,name#此处的返回值可以是任意值，比如False、字符串、列表、元组、字典；默认的函数返回值为None；
        #print("判断函数是否结束")#return代表函数的结束，即遇见return就代表函数的结束，未指定就返回None；
    else:
        return True#此处的返回值可以是任意值；默认的函数返回值为None
    #return name,age#使用逗号分隔变量名称；
    #return [name,age]#这种形式也可以；
registriation_status = stu_register("王山炮",29,course="PY全栈开发",country="JP")
print(registriation_status)#(‘王山炮‘, 24)，函数只能返回一个值，元组也是一个值；

if  registriation_status:
    print("学生信息注册成功")
else:
    print("年龄太大，不予注册学生信息。")
"""
小结：
1、函数在执行过程中，只要遇到return语句，就会停止执行并返回结果，so可以理解为return意味着函数的结束；
2、如果在函数中未指定return语句，那这个函数的返回值为None。
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 12:47
#局部变量初识；
""
"""
1、在函数内部里面定义的变量为局部变量，只能局部生效；
2、定义在函数外部一级代码的变量，叫做全局变量，全局通用使用；
"""
name = "Black Girl"
def change_name():
    name = "黑皮肤的姑娘"
    print("在",name,"里面，函数内部name变量的内存地址为:",id(name))

change_name()

print(name,"，函数外部name变量的内存地址为:",id(name))

def modify_name():
    name = "我是非洲的姑娘哦"
    print("在", name, "里面，函数内部name变量的内存地址为:", id(name))

modify_name()
print(name,"，函数外部name变量的内存地址为:",id(name))
"""
总结：
1、外部不可以引用里面的name变量，里面可以引用外部的变量，前提是内部未定义name的情况下；
2、如果全局和局部均有一个变量叫做name，函数查找变量的顺序是由内而外的；
3、定义两个不同的函数如change_name和modify_name，两者是独立的空间，相同的name变量各自不会影响；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 13:15
""
"""
1、在函数里面修改全局变量，进入global关键字，用来声明变量为全局变量；
"""
name = "Black Girl"#全局变量
def change_name():
    global name#声明name变量为全局变量且位置必须在name之前，global全局的；从实际开发的角度，不建议使用global，
    name = "黑皮肤的姑娘"
    print("在",name,"里面，函数内部name变量的内存地址为:",id(name))
change_name()
print(name,"，函数外部name变量的内存地址为:",id(name))
"""
1、因为实际场景中，其他位置还是调用全局变量，将函数内部的变量声明为全局变量后，函数一执行，即就修改了，后续拍错难度加大；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 14:23
""
"""
1、在函数里修改列表的数据；
"""
#No.01
names = ["Alex","Black girl","Peiqi"]
def change_name():
    #names = ["Alex", "Black girl"]#列表的重新赋值，不生效；整体的内存地址不可修改，但是内部的元素的内存地址可修改；
    del names[2]
    names[1] = "黑姑娘"
    print(names)
change_name()#[‘Alex‘, ‘黑姑娘‘]
print(names)#[‘Alex‘, ‘黑姑娘‘]


#No.02
names = ["Alex","Black girl","Peiqi"]

def change_name():
    global names
    names =[12,3,4]#声明全局变量后，对names变量进行重新赋值操作；
    print(names)
change_name()#[12, 3, 4]
print(names)#[12, 3, 4]
"""
小结：
1、修改整个列表本身的内存地址是不可以的，但是修改列表中某个元素的内存地址是可以的；
2、global关键字不建议使用；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 14:37
""
"""
嵌套函数
1、即函数里面继续写函数；
"""
def func1():
    print("No.01:",‘alex‘)
    def func2():
        print("No.02:",‘eric‘)
    func2()
#Question1：执行func1()#返回结果为alex
func1()
#Question2：执行func1()#返回结果为alex;eric
"""
总结：
1、函数内部可以再次定义函数；
2、函数定义之后，无论是内部还是外部，需要被调用方能执行；比如func2()语句即调用了函数；
"""

#Question3：执行func3()#返回结果为73,84,100
age = 19#一级变量age；全局变量
def func3():
    age = 73#二级变量age；局部变量
    print("No.03:",age)
    def func4():
        age = 84#三级变量age；次局部变量；
        print("No.04:",age)
        def func5():
            age = 100
            print("No.05:",age)
        func5()
    func4()
func3()
#小结：变量age会从下往上递归查找；

#No.06
age = 19
def func6():
    age = 75
    def func7():
        print("No.06:",age)
    func7()
func6()
#小结：如果子函数内部没有age变量，会从下往上进行查找，直到找到为止；

#No.08、09
age = 19
def func8():
    age = 179#将age移动至函数名func9()上面；
    print("No.08:",age)
    def func9():
        print("No.09:",age)
    age = 79
    age = 88
    func9()
func8()

#No.10、11
# age = 19
# def func10():
#     #age = 79
#     def func11():
#         print("No.11:",age)#NameError: free variable ‘age‘ referenced before assignment in enclosing scope
#     func11()
#     age = 79#将age移动至函数名func11()上面；放在此处；
# func10()
# print(age)
#No.11、12
age = 19
def func11():
    global age
    #age = 79
    def func12():
        print("No.11:",age)#
    func12()
    age = 79#将age移动至函数名func12()上面；放在此处；
func11()
print("No.12:",age)#此处的age应为声明为global全局变量，所以打印结果为79

#最难的题-#No.13、14：
age = 19
def func13():
    global age
    def func14():
        print("No.13:",age)#No.13: 77
    age = 77
    func14()
func13()
print("No.14:",age)#No.14: 77

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 15:57
""
"""
函数的作用域初识：
1、在Python中，一个函数就是一个作用域；
2、Java、C#中作用域，使用{}来区分作用域的；
3、局部变量放置在其作用域中；
4、代码定义完成后，作用域已经生成，作用域链向上查找；
"""
age = 18
def func1():
    age = 73
    def func2():
        print(age)
    #return 666
    return func2#返回函数名，而非函数名+括号(),
#func1()
val = func1()
#print(val)#666
print(val)#<function func1.<locals>.func2 at 0x000001C159E61EA0>

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 20:00
""
"""
匿名函数：
1、
"""
def calc(x,y):
    if x < y:
        return x * y
    else:
        return x / y
    #return x * y
#func = lambda x,y:x * y#lamda关键字来声明一个匿名函数；
func = lambda x, y:x * y if x < y else x / y#lamda关键字结合三元运算来声明一个匿名函数；
print(calc(3,3))
print(func(3,3))

data = list(range(10))
print(data)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for index, i in enumerate(data):
    data[index] = i*i
print(data)#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

#以上程序的优化；
data = list(range(10))
print(data)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

def power(n):#定义一个乘方函数power；
    return n*n

print(list(map(power,data)))#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print(list(map(lambda x:x*x,data)))#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]#lambda一般和其他方法联合使用，比如map；
"""
小结：
1、节省代码量；
2、代码质量高；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 20:46
""
"""
高阶函数初识：
1、变量可以指向函数；
2、函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就可以称之为‘高阶函数‘；
"""
def calc(x):
    return x*x
#func = lambda x:x*x
func = calc#变量名指向函数
func(2)#等价于calc(2)
print(func(2))

def func(x,y):
    return x + y
def calc(x):
    return x
f = calc(func)#calc()此刻就是高阶函数;
print(f(5,9))#5 + 9 = 14

def func2(x,y):
    #return abs(x+y)
    return abs,x,y
res = func2(3,-10)
print(res)#(<built-in function abs>, 3, -10)

"""
小结：
"高阶函数"只需要满足以下任意一个条件：
1、接收一个或多个函数作为输入；
2、return返回另外一个函数；
"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 21:58
""
"""
递归初识；在函数执行过程中，调用自己；
"""

import sys#导入sys模块；
print(sys.getrecursionlimit())#Python中最大值的限制为1000，防止将内存占用完毕；
sys.setrecursionlimit(1500)#修改为1500次限制；
def recursion(n):
    print(n)
    recursion(n+1)
recursion(1)#RecursionError: maximum recursion depth exceeded while calling a Python object
#递归是循环的一种；Python;

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 22:14
""
"""
递归的作用:
1、用来解决数学中的难题：比如斐波那契数列；
10/2 = 5
5/2= 1
2/2 = 1
"""
def calc(n):
    v = int(n/2)
    if v == 0:#添加一个条件判断；
        return "Done"
    print(v)
    calc(v)
    print(v)#返回值为：5\2\1  1\2\5
calc(10)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/20 0020 22:34
""
"""
求阶乘:
1、公式：n!=n*(n-1)!
2、n！=1*2*3*4....*n
"""

def factorial(n):
    if n == 1:
        return 1
    return  n * factorial(n-1)
print(factorial(4))#24

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/20 0020 22:43
 6 #通过尾部递归来优化递归；
 7 def calc(n):
 8     print(n)
 9     return calc(n+1)#尾部递归，但在Python中不生效，不节省内存，C语言中存在，使用场景不多；
10 calc(1)#依旧会报错，RecursionError: maximum recursion depth exceeded while calling a Python object

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/21 0021 21:36
 6 print("abs-绝对值函数:",abs(-11))
 7 #dict,将一些数据转为字典类型；
 8 #print(help(int))#Help on class int in module builtins:
 9 numbers = [1,4,5,-1,3]
10 print("min-返回最小值函数:",min(numbers))#返回最小值-1
11 print("max-返回最大值函数:",max(numbers))#返回最大值5
12 
13 print(all([]))#True,所有值为True才返回True
14 print(any([False,0,-1,1]))#True,有任何一个值为为True就返回True
15 
16 print("打印当前程序中的所有变量:",dir())#[‘__annotations__‘, ‘__builtins__‘, ‘__cached__‘, ‘__doc__‘, ‘__file__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘numbers‘]
17 
18 print(hex(12))#将十进制数值12转换为16进制：0xc
19 
20 #print(help(slice))#不会就help，就像Linux中的man
21 li = list(range(10))
22 print(li)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
23 s = slice(1,7,2)#切片，步长为2，没什么卵用；提起定义切片的规则；
24 print(s)#slice(1, 7, 2)
25 print(li[1:3])#[1,2]
26 print(li[s])#[1, 3, 5]
27 
28 print(divmod(15,6))#(2, 3)返回值为商和余数
29 """
30 PyDev console: starting.
31 Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
32 10//3
33 3
34 10/3
35 3.3333333333333335
36 10%3
37 1
38 """
39 li = [0, 1, 2, 3, 4, 5,-1,37,33,100,15,16, 7, 8, 9]
40 print(sorted(li))#[-1, 0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 33, 37, 100]
41 dic = {}
42 for a in range(20):
43     dic[a] = a - 50
44 print(dic)#字典本身无序；
45 print(dic.items())#dict_items([(0, -50), (1, -49), (2, -48), (3, -47),
46 print(sorted(dic.items()))#[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45),
47 print(sorted(dic.items(),key = lambda x:x[1]))
48 dic[0] = 399
49 print(sorted(dic.items(),key = lambda x:x[1]))#最大值在最后面；
50 print(sorted(dic.items(),key = lambda x:x[1],reverse=True))#最大值在最前面[(0, 399), (19, -31), (18, -32), (17, -33)
51 
52 s = ‘abcd天晴天朗‘
53 print(ascii(s))#‘abcd\u5929\u6674\u5929\u6717‘,将字符转成二进制，没什么卵用；
54 
55 #enumerate()枚举，返回列表的索引；
56 print(oct(12))#0o14，将10进制转换成为8进制；
57 print(bin(12))#0b1100，将10进制转换成为2进制；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/21 0021 22:19
 6 f = "1+3/2"
 7 print(f)#1+3/2
 8 print(eval(f))#eval()函数，将字符串转成数字，返回值：2.5，只能处理单行代码；
 9 
10 code = """
11 def foo():
12     prinr("run foo")
13     return 1234
14 foo()
15 """
16 res = eval("1+3+3")
17 res2 = exec("1+3+3")
18 print(‘res‘,res)#res 7
19 print(‘res‘,res2)#res None
20 """
21 小结：
22 eval只能处理单行代码，而exec可以处理多行代码；
23 但exec没有返回值，eval有返回值；
24 """
25 
26 print(ord(‘a‘))#返回字符在ASCII码表中的位置97；
27 print(ord(‘b‘))#返回字符在ASCII码表中的位置98；
28 print(chr(98))#通过ASCII码表中的位置，返回字符b
29 print(chr(97))#通过ASCII码表中的位置，返回字符a
30 a = [1,4,5,-1,3,0]
31 print(sum(a))#求列表中元素的和；
32 
33 #bytearray
34 a = [1,4,5,-1,3,0]
35 s = ‘abcd路飞学城‘
36 print(s)#abcd天晴天朗
37 #s[0]=‘AA‘#TypeError: ‘str‘ object does not support item assignment
38 #s = bytearray(s)#TypeError: string argument without an encoding
39 s = s.encode(‘utf-8‘)
40 print(s[0])#a在ASCII码表中的位置：97
41 #s[0] =98#TypeError: ‘bytes‘ object does not support item assignment
42 s = bytearray(s)
43 print(s[0])#97
44 s[0] = 65
45 print(s)#bytearray(b‘Abcd\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe5\x9f\x8e‘)
46 print(s[4])#232
47 s[4]=233
48 print(s)#bytearray(b‘Abcd\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe5\x9f\x8e‘)
49 print(s.decode())#Abcd鷯飞学城
50 print(id(s))#2166037941024
51 s[0]=66
52 print(id(s))#2166037941024
53 
54 #map filter reduce三剑客；
55 map(lambda x:x*x,[1,2,3,4,5])
56 print(list(map(lambda x:x*x,[1,2,3,4,5])))#[1, 4, 9, 16, 25]
57 print(list(filter(lambda x:x>3,[1,2,3,4,5])))#[4, 5]返回值
58 import functools
59 print(functools.reduce(lambda x,y:x+y,[1,3,4,5,6678,4,2]))#求和：6697
60 print(functools.reduce(lambda x,y:x+y,[1,3,4,5,6678,4,2],3))#求和：6700
61 print(functools.reduce(lambda x,y:x*y,[1,3,4,5,6678,4,2]))#求乘积：3205440
62 
63 print(pow(2,10))#返回2的10次幂；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/21 0021 22:54
 6 #print(help(print()))
 7 """
 8 C:/Users\Administrator\PycharmProjects\LFXC2018\venv\Scripts\python.exe C:/Users/Administrator/PycharmProjects/LFXC2018/文件操作&函数/函数/32-函数-内置方法3.py
 9 Help on NoneType object:
10 class NoneType(object)
11  |  Methods defined here:
12  |  
13  |  __bool__(self, /)
14  |      self != 0
15  |  
16  |  __new__(*args, **kwargs) from builtins.type
17  |      Create and return a new object.  See help(type) for accurate signature.
18  |  
19  |  __repr__(self, /)
20  |      Return repr(self).
21 None"""
22 s = ‘Hey, My name is alex\n,from shandong province.‘
23 print(s)#默认end结尾是一个\n换行符；
24 ‘‘‘
25 Hey, My name is alex
26 ,from shandong province.
27 ‘‘‘
28 print(s,end=‘||‘)#
29 ‘‘‘
30 Hey, My name is alex
31 ,from shandong province.||
32 ‘‘‘
33 
34 print(‘\n崔晓昭‘,‘李静瓶‘,sep=‘--->‘)#崔晓昭--->李静瓶
35 print(‘崔晓昭‘,‘李静瓶‘,sep=‘<---‘)#崔晓昭<---李静瓶

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/21 0021 22:54
 6 #print将内容直接重定向至文件中；
 7 msg = "又回到最初的起点"
 8 f = open(file=‘那些年.txt‘,mode=‘w‘,encoding=‘utf-8‘)
 9 print(msg,"记忆中你青涩的脸。",sep="|",end="",file=f)
10 print(msg,"记忆中你青涩的脸。",sep="|",end="",file=f)
11 #又回到最初的起点|记忆中你青涩的脸。又回到最初的起点|记忆中你青涩的脸。
12 #callable()判断一个对象是否可调用；
13 a = [1,23]
14 print(callable(a))#False
15 print(vars())#打印当前所有的变量名和变量值；
16 print(locals())#打印函数的局部变量；
17 print(globals())#打印全局变量;
18 b = {1,2,45}
19 print(repr(b))#{1, 2, 45}
20 
21 a = [1,2,3,4,5]
22 b = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
23 print(list(zip(a,b)))#[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘), (4, ‘d‘), (5, ‘e‘)]使得列表一一对应；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/21 0021 23:23
 6 print(complex(3,5))#(3+5j)#变为复数
 7 print(round(1.553433))#四舍五入取值；
 8 print(round(1.453433))#四舍五入取值；
 9 print(round(1.343433,5))#保留5位小数；
10 #四剑客：delattr(),hasattr(),getattr(),setattr()面向对象时候讲述；
11 print(hash("崔晓昭"))#hash值：8836266252390594456；
12 print(set([1,3,4,5,6]))#将列表变为集合：{1, 3, 4, 5, 6}

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/23 0023 21:31
""
"""
命名空间：
1、又名name space，即存放变量名与变量值绑定关系的地方；
"""
x = 1
print(globals())#{‘__name__‘: ‘__main__‘, ‘__doc__‘: ‘‘, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x000001F32965D0F0>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘C:/Users/TQTL911/PycharmProjects/LFXC2018/第2模块函数编程/第1章函数、装饰器、迭代器、内置方法/37-函数-函数进阶-命名空间.py‘, ‘__cached__‘: None, ‘x‘: 1}
print(locals())#{‘__name__‘: ‘__main__‘, ‘__doc__‘: ‘‘, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x0000025D1C6DD0F0>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘C:/Users/TQTL911/PycharmProjects/LFXC2018/第2模块函数编程/第1章函数、装饰器、迭代器、内置方法/37-函数-函数进阶-命名空间.py‘, ‘__cached__‘: None, ‘x‘: 1}
print(__builtins__)#<module ‘builtins‘ (built-in)>
print(dir(__builtins__))
"""
[‘ArithmeticError‘, ‘AssertionError‘, ‘AttributeError‘, ‘BaseException‘, ‘BlockingIOError‘, ‘BrokenPipeError‘, ‘BufferError‘, ‘BytesWarning‘, 
‘ChildProcessError‘, ‘ConnectionAbortedError‘, ‘ConnectionError‘, ‘ConnectionRefusedError‘, ‘ConnectionResetError‘, 
‘DeprecationWarning‘,
‘EOFError‘, ‘Ellipsis‘, ‘EnvironmentError‘, ‘Exception‘,
‘False‘, ‘FileExistsError‘, ‘FileNotFoundError‘, ‘FloatingPointError‘, ‘FutureWarning‘, 
‘GeneratorExit‘,
‘IOError‘, ‘ImportError‘, ‘ImportWarning‘, ‘IndentationError‘, ‘IndexError‘, ‘InterruptedError‘, ‘IsADirectoryError‘, 
‘KeyError‘, ‘KeyboardInterrupt‘,
‘LookupError‘,
‘MemoryError‘, ‘ModuleNotFoundError‘,
‘NameError‘, ‘None‘, ‘NotADirectoryError‘, ‘NotImplemented‘, ‘NotImplementedError‘, 
‘OSError‘, ‘OverflowError‘, 
‘PendingDeprecationWarning‘, ‘PermissionError‘, ‘ProcessLookupError‘,
‘RecursionError‘, ‘ReferenceError‘, ‘ResourceWarning‘, ‘RuntimeError‘, ‘RuntimeWarning‘, 
‘StopAsyncIteration‘, ‘StopIteration‘, ‘SyntaxError‘, ‘SyntaxWarning‘, ‘SystemError‘, ‘SystemExit‘, 
‘TabError‘, ‘TimeoutError‘, ‘True‘, ‘TypeError‘,
‘UnboundLocalError‘, ‘UnicodeDecodeError‘, ‘UnicodeEncodeError‘, ‘UnicodeError‘, ‘UnicodeTranslateError‘, ‘UnicodeWarning‘, ‘UserWarning‘, 
‘ValueError‘, 
‘Warning‘, ‘WindowsError‘, 
‘ZeroDivisionError‘, 
‘__build_class__‘, ‘__debug__‘, ‘__doc__‘, ‘__import__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, 
‘abs‘, ‘all‘, ‘any‘, ‘ascii‘, ‘bin‘, ‘bool‘, ‘bytearray‘, ‘bytes‘, ‘callable‘, ‘chr‘, ‘classmethod‘, ‘compile‘, ‘complex‘, ‘copyright‘, 
‘credits‘, ‘delattr‘, ‘dict‘, ‘dir‘, ‘divmod‘, ‘enumerate‘, ‘eval‘, ‘exec‘, ‘exit‘, ‘filter‘, ‘float‘, ‘format‘, ‘frozenset‘, ‘getattr‘,
‘globals‘, ‘hasattr‘, ‘hash‘, ‘help‘, ‘hex‘, ‘id‘, ‘input‘, ‘int‘, ‘isinstance‘, ‘issubclass‘, ‘iter‘, ‘len‘, ‘license‘, ‘list‘, ‘locals‘, 
‘map‘, ‘max‘, ‘memoryview‘, ‘min‘, ‘next‘, ‘object‘, ‘oct‘, ‘open‘, ‘ord‘, ‘pow‘, ‘print‘, ‘property‘, ‘quit‘, ‘range‘, ‘repr‘, ‘reversed‘, 
‘round‘, ‘set‘, ‘setattr‘, ‘slice‘, ‘sorted‘, ‘staticmethod‘, ‘str‘, ‘sum‘, ‘super‘, ‘tuple‘, ‘type‘, ‘vars‘, ‘zip‘]
"""

 1 C:\Users\Administrator\PycharmProjects\LFXC2018\venv\Scripts\python.exe "C:\Program Files\JetBrains\PyCharm 2018.1.3\helpers\pydev\pydevconsole.py" 63904 63905
 2 import sys; print(‘Python %s on %s‘ % (sys.version, sys.platform))
 3 sys.path.extend([‘C:\\Users\\Administrator\\PycharmProjects\\LFXC2018‘, ‘C:/Users/Administrator/PycharmProjects/LFXC2018‘])
 4 PyDev console: starting.
 5 Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
 6 x = 1
 7 globals()
 8 {‘__builtins__‘: {‘__name__‘: ‘builtins‘, ‘__doc__‘: "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil‘ object; Ellipsis represents `...‘ in slices.", ‘__package__‘: ‘‘, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__spec__‘: ModuleSpec(name=‘builtins‘, loader=<class ‘_frozen_importlib.BuiltinImporter‘>), ‘__build_class__‘: <built-in function __build_class__>, ‘__import__‘: <bound method ImportHookManager.do_import of <module ‘_pydev_bundle.pydev_import_hook.import_hook‘>>, ‘abs‘: <built-in function abs>, ‘all‘: <built-in function all>, ‘any‘: <built-in function any>, ‘ascii‘: <built-in function ascii>, ‘bin‘: <built-in function bin>, ‘callable‘: <built-in function callable>, ‘chr‘: <built-in function chr>, ‘compile‘: <built-in function compile>, ‘delattr‘: <built-in function delattr>, ‘dir‘: <built-in function dir>, ‘divmod‘: <built-in function divmod>, ‘eval‘: <built-in function eval>, ‘exec‘: <built-in function exec>, ‘format‘: <built-in function format>, ‘getattr‘: <built-in function getattr>, ‘globals‘: <built-in function globals>, ‘hasattr‘: <built-in function hasattr>, ‘hash‘: <built-in function hash>, ‘hex‘: <built-in function hex>, ‘id‘: <built-in function id>, ‘input‘: <built-in function input>, ‘isinstance‘: <built-in function isinstance>, ‘issubclass‘: <built-in function issubclass>, ‘iter‘: <built-in function iter>, ‘len‘: <built-in function len>, ‘locals‘: <built-in function locals>, ‘max‘: <built-in function max>, ‘min‘: <built-in function min>, ‘next‘: <built-in function next>, ‘oct‘: <built-in function oct>, ‘ord‘: <built-in function ord>, ‘pow‘: <built-in function pow>, ‘print‘: <built-in function print>, ‘repr‘: <built-in function repr>, ‘round‘: <built-in function round>, ‘setattr‘: <built-in function setattr>, ‘sorted‘: <built-in function sorted>, ‘sum‘: <built-in function sum>, ‘vars‘: <built-in function vars>, ‘None‘: None, ‘Ellipsis‘: Ellipsis, ‘NotImplemented‘: NotImplemented, ‘False‘: False, ‘True‘: True, ‘bool‘: <class ‘bool‘>, ‘memoryview‘: <class ‘memoryview‘>, ‘bytearray‘: <class ‘bytearray‘>, ‘bytes‘: <class ‘bytes‘>, ‘classmethod‘: <class ‘classmethod‘>, ‘complex‘: <class ‘complex‘>, ‘dict‘: <class ‘dict‘>, ‘enumerate‘: <class ‘enumerate‘>, ‘filter‘: <class ‘filter‘>, ‘float‘: <class ‘float‘>, ‘frozenset‘: <class ‘frozenset‘>, ‘property‘: <class ‘property‘>, ‘int‘: <class ‘int‘>, ‘list‘: <class ‘list‘>, ‘map‘: <class ‘map‘>, ‘object‘: <class ‘object‘>, ‘range‘: <class ‘range‘>, ‘reversed‘: <class ‘reversed‘>, ‘set‘: <class ‘set‘>, ‘slice‘: <class ‘slice‘>, ‘staticmethod‘: <class ‘staticmethod‘>, ‘str‘: <class ‘str‘>, ‘super‘: <class ‘super‘>, ‘tuple‘: <class ‘tuple‘>, ‘type‘: <class ‘type‘>, ‘zip‘: <class ‘zip‘>, ‘__debug__‘: True, ‘BaseException‘: <class ‘BaseException‘>, ‘Exception‘: <class ‘Exception‘>, ‘TypeError‘: <class ‘TypeError‘>, ‘StopAsyncIteration‘: <class ‘StopAsyncIteration‘>, ‘StopIteration‘: <class ‘StopIteration‘>, ‘GeneratorExit‘: <class ‘GeneratorExit‘>, ‘SystemExit‘: <class ‘SystemExit‘>, ‘KeyboardInterrupt‘: <class ‘KeyboardInterrupt‘>, ‘ImportError‘: <class ‘ImportError‘>, ‘ModuleNotFoundError‘: <class ‘ModuleNotFoundError‘>, ‘OSError‘: <class ‘OSError‘>, ‘EnvironmentError‘: <class ‘OSError‘>, ‘IOError‘: <class ‘OSError‘>, ‘WindowsError‘: <class ‘OSError‘>, ‘EOFError‘: <class ‘EOFError‘>, ‘RuntimeError‘: <class ‘RuntimeError‘>, ‘RecursionError‘: <class ‘RecursionError‘>, ‘NotImplementedError‘: <class ‘NotImplementedError‘>, ‘NameError‘: <class ‘NameError‘>, ‘UnboundLocalError‘: <class ‘UnboundLocalError‘>, ‘AttributeError‘: <class ‘AttributeError‘>, ‘SyntaxError‘: <class ‘SyntaxError‘>, ‘IndentationError‘: <class ‘IndentationError‘>, ‘TabError‘: <class ‘TabError‘>, ‘LookupError‘: <class ‘LookupError‘>, ‘IndexError‘: <class ‘IndexError‘>, ‘KeyError‘: <class ‘KeyError‘>, ‘ValueError‘: <class ‘ValueError‘>, ‘UnicodeError‘: <class ‘UnicodeError‘>, ‘UnicodeEncodeError‘: <class ‘UnicodeEncodeError‘>, ‘UnicodeDecodeError‘: <class ‘UnicodeDecodeError‘>, ‘UnicodeTranslateError‘: <class ‘UnicodeTranslateError‘>, ‘AssertionError‘: <class ‘AssertionError‘>, ‘ArithmeticError‘: <class ‘ArithmeticError‘>, ‘FloatingPointError‘: <class ‘FloatingPointError‘>, ‘OverflowError‘: <class ‘OverflowError‘>, ‘ZeroDivisionError‘: <class ‘ZeroDivisionError‘>, ‘SystemError‘: <class ‘SystemError‘>, ‘ReferenceError‘: <class ‘ReferenceError‘>, ‘BufferError‘: <class ‘BufferError‘>, ‘MemoryError‘: <class ‘MemoryError‘>, ‘Warning‘: <class ‘Warning‘>, ‘UserWarning‘: <class ‘UserWarning‘>, ‘DeprecationWarning‘: <class ‘DeprecationWarning‘>, ‘PendingDeprecationWarning‘: <class ‘PendingDeprecationWarning‘>, ‘SyntaxWarning‘: <class ‘SyntaxWarning‘>, ‘RuntimeWarning‘: <class ‘RuntimeWarning‘>, ‘FutureWarning‘: <class ‘FutureWarning‘>, ‘ImportWarning‘: <class ‘ImportWarning‘>, ‘UnicodeWarning‘: <class ‘UnicodeWarning‘>, ‘BytesWarning‘: <class ‘BytesWarning‘>, ‘ResourceWarning‘: <class ‘ResourceWarning‘>, ‘ConnectionError‘: <class ‘ConnectionError‘>, ‘BlockingIOError‘: <class ‘BlockingIOError‘>, ‘BrokenPipeError‘: <class ‘BrokenPipeError‘>, ‘ChildProcessError‘: <class ‘ChildProcessError‘>, ‘ConnectionAbortedError‘: <class ‘ConnectionAbortedError‘>, ‘ConnectionRefusedError‘: <class ‘ConnectionRefusedError‘>, ‘ConnectionResetError‘: <class ‘ConnectionResetError‘>, ‘FileExistsError‘: <class ‘FileExistsError‘>, ‘FileNotFoundError‘: <class ‘FileNotFoundError‘>, ‘IsADirectoryError‘: <class ‘IsADirectoryError‘>, ‘NotADirectoryError‘: <class ‘NotADirectoryError‘>, ‘InterruptedError‘: <class ‘InterruptedError‘>, ‘PermissionError‘: <class ‘PermissionError‘>, ‘ProcessLookupError‘: <class ‘ProcessLookupError‘>, ‘TimeoutError‘: <class ‘TimeoutError‘>, ‘open‘: <built-in function open>, ‘quit‘: Use quit() or Ctrl-Z plus Return to exit, ‘exit‘: Use exit() or Ctrl-Z plus Return to exit, ‘copyright‘: Copyright (c) 2001-2018 Python Software Foundation.
 9 All Rights Reserved.
10 Copyright (c) 2000 BeOpen.com.
11 All Rights Reserved.
12 Copyright (c) 1995-2001 Corporation for National Research Initiatives.
13 All Rights Reserved.
14 Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
15 All Rights Reserved., ‘credits‘:     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
16     for supporting Python development.  See www.python.org for more information., ‘license‘: Type license() to see the full license text, ‘help‘: Type help() for interactive help, or help(object) for help about object., ‘execfile‘: <function execfile at 0x0000019EBE74D840>, ‘runfile‘: <function runfile at 0x0000019EBE273EA0>, ‘_‘: None}, ‘sys‘: <module ‘sys‘ (built-in)>, ‘x‘: 1}
17 locals()
18 {‘__builtins__‘: {‘__name__‘: ‘builtins‘, ‘__doc__‘: "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil‘ object; Ellipsis represents `...‘ in slices.", ‘__package__‘: ‘‘, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__spec__‘: ModuleSpec(name=‘builtins‘, loader=<class ‘_frozen_importlib.BuiltinImporter‘>), ‘__build_class__‘: <built-in function __build_class__>, ‘__import__‘: <bound method ImportHookManager.do_import of <module ‘_pydev_bundle.pydev_import_hook.import_hook‘>>, ‘abs‘: <built-in function abs>, ‘all‘: <built-in function all>, ‘any‘: <built-in function any>, ‘ascii‘: <built-in function ascii>, ‘bin‘: <built-in function bin>, ‘callable‘: <built-in function callable>, ‘chr‘: <built-in function chr>, ‘compile‘: <built-in function compile>, ‘delattr‘: <built-in function delattr>, ‘dir‘: <built-in function dir>, ‘divmod‘: <built-in function divmod>, ‘eval‘: <built-in function eval>, ‘exec‘: <built-in function exec>, ‘format‘: <built-in function format>, ‘getattr‘: <built-in function getattr>, ‘globals‘: <built-in function globals>, ‘hasattr‘: <built-in function hasattr>, ‘hash‘: <built-in function hash>, ‘hex‘: <built-in function hex>, ‘id‘: <built-in function id>, ‘input‘: <built-in function input>, ‘isinstance‘: <built-in function isinstance>, ‘issubclass‘: <built-in function issubclass>, ‘iter‘: <built-in function iter>, ‘len‘: <built-in function len>, ‘locals‘: <built-in function locals>, ‘max‘: <built-in function max>, ‘min‘: <built-in function min>, ‘next‘: <built-in function next>, ‘oct‘: <built-in function oct>, ‘ord‘: <built-in function ord>, ‘pow‘: <built-in function pow>, ‘print‘: <built-in function print>, ‘repr‘: <built-in function repr>, ‘round‘: <built-in function round>, ‘setattr‘: <built-in function setattr>, ‘sorted‘: <built-in function sorted>, ‘sum‘: <built-in function sum>, ‘vars‘: <built-in function vars>, ‘None‘: None, ‘Ellipsis‘: Ellipsis, ‘NotImplemented‘: NotImplemented, ‘False‘: False, ‘True‘: True, ‘bool‘: <class ‘bool‘>, ‘memoryview‘: <class ‘memoryview‘>, ‘bytearray‘: <class ‘bytearray‘>, ‘bytes‘: <class ‘bytes‘>, ‘classmethod‘: <class ‘classmethod‘>, ‘complex‘: <class ‘complex‘>, ‘dict‘: <class ‘dict‘>, ‘enumerate‘: <class ‘enumerate‘>, ‘filter‘: <class ‘filter‘>, ‘float‘: <class ‘float‘>, ‘frozenset‘: <class ‘frozenset‘>, ‘property‘: <class ‘property‘>, ‘int‘: <class ‘int‘>, ‘list‘: <class ‘list‘>, ‘map‘: <class ‘map‘>, ‘object‘: <class ‘object‘>, ‘range‘: <class ‘range‘>, ‘reversed‘: <class ‘reversed‘>, ‘set‘: <class ‘set‘>, ‘slice‘: <class ‘slice‘>, ‘staticmethod‘: <class ‘staticmethod‘>, ‘str‘: <class ‘str‘>, ‘super‘: <class ‘super‘>, ‘tuple‘: <class ‘tuple‘>, ‘type‘: <class ‘type‘>, ‘zip‘: <class ‘zip‘>, ‘__debug__‘: True, ‘BaseException‘: <class ‘BaseException‘>, ‘Exception‘: <class ‘Exception‘>, ‘TypeError‘: <class ‘TypeError‘>, ‘StopAsyncIteration‘: <class ‘StopAsyncIteration‘>, ‘StopIteration‘: <class ‘StopIteration‘>, ‘GeneratorExit‘: <class ‘GeneratorExit‘>, ‘SystemExit‘: <class ‘SystemExit‘>, ‘KeyboardInterrupt‘: <class ‘KeyboardInterrupt‘>, ‘ImportError‘: <class ‘ImportError‘>, ‘ModuleNotFoundError‘: <class ‘ModuleNotFoundError‘>, ‘OSError‘: <class ‘OSError‘>, ‘EnvironmentError‘: <class ‘OSError‘>, ‘IOError‘: <class ‘OSError‘>, ‘WindowsError‘: <class ‘OSError‘>, ‘EOFError‘: <class ‘EOFError‘>, ‘RuntimeError‘: <class ‘RuntimeError‘>, ‘RecursionError‘: <class ‘RecursionError‘>, ‘NotImplementedError‘: <class ‘NotImplementedError‘>, ‘NameError‘: <class ‘NameError‘>, ‘UnboundLocalError‘: <class ‘UnboundLocalError‘>, ‘AttributeError‘: <class ‘AttributeError‘>, ‘SyntaxError‘: <class ‘SyntaxError‘>, ‘IndentationError‘: <class ‘IndentationError‘>, ‘TabError‘: <class ‘TabError‘>, ‘LookupError‘: <class ‘LookupError‘>, ‘IndexError‘: <class ‘IndexError‘>, ‘KeyError‘: <class ‘KeyError‘>, ‘ValueError‘: <class ‘ValueError‘>, ‘UnicodeError‘: <class ‘UnicodeError‘>, ‘UnicodeEncodeError‘: <class ‘UnicodeEncodeError‘>, ‘UnicodeDecodeError‘: <class ‘UnicodeDecodeError‘>, ‘UnicodeTranslateError‘: <class ‘UnicodeTranslateError‘>, ‘AssertionError‘: <class ‘AssertionError‘>, ‘ArithmeticError‘: <class ‘ArithmeticError‘>, ‘FloatingPointError‘: <class ‘FloatingPointError‘>, ‘OverflowError‘: <class ‘OverflowError‘>, ‘ZeroDivisionError‘: <class ‘ZeroDivisionError‘>, ‘SystemError‘: <class ‘SystemError‘>, ‘ReferenceError‘: <class ‘ReferenceError‘>, ‘BufferError‘: <class ‘BufferError‘>, ‘MemoryError‘: <class ‘MemoryError‘>, ‘Warning‘: <class ‘Warning‘>, ‘UserWarning‘: <class ‘UserWarning‘>, ‘DeprecationWarning‘: <class ‘DeprecationWarning‘>, ‘PendingDeprecationWarning‘: <class ‘PendingDeprecationWarning‘>, ‘SyntaxWarning‘: <class ‘SyntaxWarning‘>, ‘RuntimeWarning‘: <class ‘RuntimeWarning‘>, ‘FutureWarning‘: <class ‘FutureWarning‘>, ‘ImportWarning‘: <class ‘ImportWarning‘>, ‘UnicodeWarning‘: <class ‘UnicodeWarning‘>, ‘BytesWarning‘: <class ‘BytesWarning‘>, ‘ResourceWarning‘: <class ‘ResourceWarning‘>, ‘ConnectionError‘: <class ‘ConnectionError‘>, ‘BlockingIOError‘: <class ‘BlockingIOError‘>, ‘BrokenPipeError‘: <class ‘BrokenPipeError‘>, ‘ChildProcessError‘: <class ‘ChildProcessError‘>, ‘ConnectionAbortedError‘: <class ‘ConnectionAbortedError‘>, ‘ConnectionRefusedError‘: <class ‘ConnectionRefusedError‘>, ‘ConnectionResetError‘: <class ‘ConnectionResetError‘>, ‘FileExistsError‘: <class ‘FileExistsError‘>, ‘FileNotFoundError‘: <class ‘FileNotFoundError‘>, ‘IsADirectoryError‘: <class ‘IsADirectoryError‘>, ‘NotADirectoryError‘: <class ‘NotADirectoryError‘>, ‘InterruptedError‘: <class ‘InterruptedError‘>, ‘PermissionError‘: <class ‘PermissionError‘>, ‘ProcessLookupError‘: <class ‘ProcessLookupError‘>, ‘TimeoutError‘: <class ‘TimeoutError‘>, ‘open‘: <built-in function open>, ‘quit‘: Use quit() or Ctrl-Z plus Return to exit, ‘exit‘: Use exit() or Ctrl-Z plus Return to exit, ‘copyright‘: Copyright (c) 2001-2018 Python Software Foundation.
19 All Rights Reserved.
20 Copyright (c) 2000 BeOpen.com.
21 All Rights Reserved.
22 Copyright (c) 1995-2001 Corporation for National Research Initiatives.
23 All Rights Reserved.
24 Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
25 All Rights Reserved., ‘credits‘:     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
26     for supporting Python development.  See www.python.org for more information., ‘license‘: Type license() to see the full license text, ‘help‘: Type help() for interactive help, or help(object) for help about object., ‘execfile‘: <function execfile at 0x0000019EBE74D840>, ‘runfile‘: <function runfile at 0x0000019EBE273EA0>, ‘_‘: None}, ‘sys‘: <module ‘sys‘ (built-in)>, ‘x‘: 1}
27 __buildins__
28 Traceback (most recent call last):
29   File "<input>", line 1, in <module>
30 NameError: name ‘__buildins__‘ is not defined
31 __builtins__
32 {‘__name__‘: ‘builtins‘, ‘__doc__‘: "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil‘ object; Ellipsis represents `...‘ in slices.", ‘__package__‘: ‘‘, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__spec__‘: ModuleSpec(name=‘builtins‘, loader=<class ‘_frozen_importlib.BuiltinImporter‘>), ‘__build_class__‘: <built-in function __build_class__>, ‘__import__‘: <bound method ImportHookManager.do_import of <module ‘_pydev_bundle.pydev_import_hook.import_hook‘>>, ‘abs‘: <built-in function abs>, ‘all‘: <built-in function all>, ‘any‘: <built-in function any>, ‘ascii‘: <built-in function ascii>, ‘bin‘: <built-in function bin>, ‘callable‘: <built-in function callable>, ‘chr‘: <built-in function chr>, ‘compile‘: <built-in function compile>, ‘delattr‘: <built-in function delattr>, ‘dir‘: <built-in function dir>, ‘divmod‘: <built-in function divmod>, ‘eval‘: <built-in function eval>, ‘exec‘: <built-in function exec>, ‘format‘: <built-in function format>, ‘getattr‘: <built-in function getattr>, ‘globals‘: <built-in function globals>, ‘hasattr‘: <built-in function hasattr>, ‘hash‘: <built-in function hash>, ‘hex‘: <built-in function hex>, ‘id‘: <built-in function id>, ‘input‘: <built-in function input>, ‘isinstance‘: <built-in function isinstance>, ‘issubclass‘: <built-in function issubclass>, ‘iter‘: <built-in function iter>, ‘len‘: <built-in function len>, ‘locals‘: <built-in function locals>, ‘max‘: <built-in function max>, ‘min‘: <built-in function min>, ‘next‘: <built-in function next>, ‘oct‘: <built-in function oct>, ‘ord‘: <built-in function ord>, ‘pow‘: <built-in function pow>, ‘print‘: <built-in function print>, ‘repr‘: <built-in function repr>, ‘round‘: <built-in function round>, ‘setattr‘: <built-in function setattr>, ‘sorted‘: <built-in function sorted>, ‘sum‘: <built-in function sum>, ‘vars‘: <built-in function vars>, ‘None‘: None, ‘Ellipsis‘: Ellipsis, ‘NotImplemented‘: NotImplemented, ‘False‘: False, ‘True‘: True, ‘bool‘: <class ‘bool‘>, ‘memoryview‘: <class ‘memoryview‘>, ‘bytearray‘: <class ‘bytearray‘>, ‘bytes‘: <class ‘bytes‘>, ‘classmethod‘: <class ‘classmethod‘>, ‘complex‘: <class ‘complex‘>, ‘dict‘: <class ‘dict‘>, ‘enumerate‘: <class ‘enumerate‘>, ‘filter‘: <class ‘filter‘>, ‘float‘: <class ‘float‘>, ‘frozenset‘: <class ‘frozenset‘>, ‘property‘: <class ‘property‘>, ‘int‘: <class ‘int‘>, ‘list‘: <class ‘list‘>, ‘map‘: <class ‘map‘>, ‘object‘: <class ‘object‘>, ‘range‘: <class ‘range‘>, ‘reversed‘: <class ‘reversed‘>, ‘set‘: <class ‘set‘>, ‘slice‘: <class ‘slice‘>, ‘staticmethod‘: <class ‘staticmethod‘>, ‘str‘: <class ‘str‘>, ‘super‘: <class ‘super‘>, ‘tuple‘: <class ‘tuple‘>, ‘type‘: <class ‘type‘>, ‘zip‘: <class ‘zip‘>, ‘__debug__‘: True, ‘BaseException‘: <class ‘BaseException‘>, ‘Exception‘: <class ‘Exception‘>, ‘TypeError‘: <class ‘TypeError‘>, ‘StopAsyncIteration‘: <class ‘StopAsyncIteration‘>, ‘StopIteration‘: <class ‘StopIteration‘>, ‘GeneratorExit‘: <class ‘GeneratorExit‘>, ‘SystemExit‘: <class ‘SystemExit‘>, ‘KeyboardInterrupt‘: <class ‘KeyboardInterrupt‘>, ‘ImportError‘: <class ‘ImportError‘>, ‘ModuleNotFoundError‘: <class ‘ModuleNotFoundError‘>, ‘OSError‘: <class ‘OSError‘>, ‘EnvironmentError‘: <class ‘OSError‘>, ‘IOError‘: <class ‘OSError‘>, ‘WindowsError‘: <class ‘OSError‘>, ‘EOFError‘: <class ‘EOFError‘>, ‘RuntimeError‘: <class ‘RuntimeError‘>, ‘RecursionError‘: <class ‘RecursionError‘>, ‘NotImplementedError‘: <class ‘NotImplementedError‘>, ‘NameError‘: <class ‘NameError‘>, ‘UnboundLocalError‘: <class ‘UnboundLocalError‘>, ‘AttributeError‘: <class ‘AttributeError‘>, ‘SyntaxError‘: <class ‘SyntaxError‘>, ‘IndentationError‘: <class ‘IndentationError‘>, ‘TabError‘: <class ‘TabError‘>, ‘LookupError‘: <class ‘LookupError‘>, ‘IndexError‘: <class ‘IndexError‘>, ‘KeyError‘: <class ‘KeyError‘>, ‘ValueError‘: <class ‘ValueError‘>, ‘UnicodeError‘: <class ‘UnicodeError‘>, ‘UnicodeEncodeError‘: <class ‘UnicodeEncodeError‘>, ‘UnicodeDecodeError‘: <class ‘UnicodeDecodeError‘>, ‘UnicodeTranslateError‘: <class ‘UnicodeTranslateError‘>, ‘AssertionError‘: <class ‘AssertionError‘>, ‘ArithmeticError‘: <class ‘ArithmeticError‘>, ‘FloatingPointError‘: <class ‘FloatingPointError‘>, ‘OverflowError‘: <class ‘OverflowError‘>, ‘ZeroDivisionError‘: <class ‘ZeroDivisionError‘>, ‘SystemError‘: <class ‘SystemError‘>, ‘ReferenceError‘: <class ‘ReferenceError‘>, ‘BufferError‘: <class ‘BufferError‘>, ‘MemoryError‘: <class ‘MemoryError‘>, ‘Warning‘: <class ‘Warning‘>, ‘UserWarning‘: <class ‘UserWarning‘>, ‘DeprecationWarning‘: <class ‘DeprecationWarning‘>, ‘PendingDeprecationWarning‘: <class ‘PendingDeprecationWarning‘>, ‘SyntaxWarning‘: <class ‘SyntaxWarning‘>, ‘RuntimeWarning‘: <class ‘RuntimeWarning‘>, ‘FutureWarning‘: <class ‘FutureWarning‘>, ‘ImportWarning‘: <class ‘ImportWarning‘>, ‘UnicodeWarning‘: <class ‘UnicodeWarning‘>, ‘BytesWarning‘: <class ‘BytesWarning‘>, ‘ResourceWarning‘: <class ‘ResourceWarning‘>, ‘ConnectionError‘: <class ‘ConnectionError‘>, ‘BlockingIOError‘: <class ‘BlockingIOError‘>, ‘BrokenPipeError‘: <class ‘BrokenPipeError‘>, ‘ChildProcessError‘: <class ‘ChildProcessError‘>, ‘ConnectionAbortedError‘: <class ‘ConnectionAbortedError‘>, ‘ConnectionRefusedError‘: <class ‘ConnectionRefusedError‘>, ‘ConnectionResetError‘: <class ‘ConnectionResetError‘>, ‘FileExistsError‘: <class ‘FileExistsError‘>, ‘FileNotFoundError‘: <class ‘FileNotFoundError‘>, ‘IsADirectoryError‘: <class ‘IsADirectoryError‘>, ‘NotADirectoryError‘: <class ‘NotADirectoryError‘>, ‘InterruptedError‘: <class ‘InterruptedError‘>, ‘PermissionError‘: <class ‘PermissionError‘>, ‘ProcessLookupError‘: <class ‘ProcessLookupError‘>, ‘TimeoutError‘: <class ‘TimeoutError‘>, ‘open‘: <built-in function open>, ‘quit‘: Use quit() or Ctrl-Z plus Return to exit, ‘exit‘: Use exit() or Ctrl-Z plus Return to exit, ‘copyright‘: Copyright (c) 2001-2018 Python Software Foundation.
33 All Rights Reserved.
34 Copyright (c) 2000 BeOpen.com.
35 All Rights Reserved.
36 Copyright (c) 1995-2001 Corporation for National Research Initiatives.
37 All Rights Reserved.
38 Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
39 All Rights Reserved., ‘credits‘:     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
40     for supporting Python development.  See www.python.org for more information., ‘license‘: Type license() to see the full license text, ‘help‘: Type help() for interactive help, or help(object) for help about object., ‘execfile‘: <function execfile at 0x0000019EBE74D840>, ‘runfile‘: <function runfile at 0x0000019EBE273EA0>, ‘_‘: None}
41 dir(__builtins__)
42 [‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘]

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/23 0023 21:49
 6 #作用域的查找空间
 7 n = 10
 8 def func():
 9     n = 20#局部变量；
10     print("func:",n)
11     def func2():
12         n = 30
13         print("func2:",n)
14         def func3():
15             print("func3:",n)
16         func3()#func3: 30
17     func2()#func2: 30
18 func()#func: 20
19 """
20 作用域的查找顺序LEGB；一层一层往上查找；
21 L:locals#局部的；是函数内的名字空间，包括局部变量和形参；
22 E:enclosing#相邻的上一级；外部嵌套函数的名字空间；
23 G:globals#全局的；全局变量，函数定义所在模块的名字空间；
24 B:builtins#内置的；内置模块的名字空间；name space；
25 """

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/23 0023 21:59
""
"""
闭包：
1、概念性的东西；
2、闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域；
"""
def func():
    n = 10
    def func2():
        print("func2:",n)
    #func2()
    return  func2#返回func2的内存地址；
f = func()
print(f)#<function func.<locals>.func2 at 0x000002B0D5A91AE8>
f()#按常理来讲，执行完func()函数后，func2()已经释放掉了，但是它存在返回值；func2: 10
#以上就是闭包的概念；
#在外部拿到了内部的函数，并且还可以使用内部函数的作用域里面的值；

  1 #!/usr/bin/env python
  2 # -*- coding:utf-8 -*-
  3 # __Author__:Administrator
  4 # Version:python3.6.5
  5 # Date:2018/5/23 0023 22:13
  6 # _*_coding:utf-8_*_
  7 """
  8 user_status = False  # 用户登录了就把这个改成True；
  9 def login():
 10     _username = "alex"  # 假装这是DB里存的用户信息；
 11     _password = "abc!23"  # 假装这是DB里存的用户信息；
 12     global user_status
 13     if user_status == False:
 14         username = input("user:")
 15         password = input("pasword:")
 16         if username == _username and password == _password:
 17             print("welcome login....")
 18             user_status = True#用户登录了，把这个改成True；
 19         else:
 20             print("wrong username or password!")
 21     else:
 22         print("用户已登录，验证通过...")
 23 
 24 
 25 def home():
 26     print("---首页----")
 27 def america():
 28     login()  # 执行前加上验证；
 29     print("----欧美专区----")
 30 def japan():
 31     print("----日韩专区----")
 32 def henan():
 33     login()  # 执行前加上验证；
 34     print("----河南专区----")
 35 home()
 36 america()
 37 henan()
 38 """
 39 
 40 """
 41 封闭：已实现的功能代码块不应该被修改;
 42 开放：对现有功能的扩展开放;
 43 """
 44 user_status = False  # 用户登录了就把这个改成True；
 45 def login(func):#把要执行的模块从这里传进来
 46     _username = "alex"  # 假装这是DB里存的用户信息；
 47     _password = "abc!23"  # 假装这是DB里存的用户信息；
 48     global user_status
 49     if user_status == False:
 50         username = input("user:")
 51         password = input("pasword:")
 52         if username == _username and password == _password:
 53             print("welcome login....")
 54             user_status = True#用户登录了，把这个改成True；
 55         else:
 56             print("wrong username or password!")
 57     else:
 58         print("用户已登录，验证通过...")
 59     if user_status == True:
 60         func()
 61 
 62 
 63 def home():
 64     print("---首页----")
 65 def america():
 66     #login()  # 执行前加上验证；
 67     print("----欧美专区----")
 68 def japan():
 69     print("----日韩专区----")
 70 def henan():
 71     #login()  # 执行前加上验证；
 72     print("----河南专区----")
 73 home()#首页不需要认证登录，
 74 login(america)#america专区，需要验证，所以调用 login，把需要验证的功能 当做一个参数传给login
 75 #america()
 76 login(henan)#america专区，需要验证，所以调用 login，把需要验证的功能 当做一个参数传给login
 77 
 78 #思路继续优化中；
 79 def plus(n):
 80     return n+1
 81 plus(6)
 82 plus2 = lambda n:n+1
 83 
 84 #继续解释；
 85 def login(func):  # 把要执行的模块从这里传进来；
 86     def inner():  # 再定义一层函数；
 87         _username = "alex"  # 假装这是DB里存的用户信息；
 88         _password = "abc!23"  # 假装这是DB里存的用户信息；
 89         global user_status
 90         if user_status == False:
 91             username = input("user:")
 92             password = input("pasword:")
 93             if username == _username and password == _password:
 94                 print("welcome login....")
 95                 user_status = True
 96             else:
 97                 print("wrong username or password!")
 98         if user_status == True:
 99             func()  # 看这里看这里，只要验证通过了，就调用相应功能；
100     return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/24 0024 7:03
 6 #最终代码；
 7 user_status = False  # 用户登录了就把这个改成True；
 8 def login(func):  # 把要执行的模块从这里传进来；
 9     def inner(*args, **kwargs):  # 使用非固定参数；
10         _username = "alex"  # 假装这是DB里存的用户信息；
11         _password = "abc!23"  # 假装这是DB里存的用户信息；
12         global user_status
13         if user_status == False:
14             username = input("user:")
15             password = input("pasword:")
16             if username == _username and password == _password:
17                 print("welcome login....")
18                 user_status = True
19             else:
20                 print("wrong username or password!")
21         if user_status == True:
22             #func(args,kwargs) # 使用非固定参数；
23             func(args,kwargs) # 使用非固定参数,支持多个参数；
24     return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数；
25 
26 def home():
27     print("---首页----")
28 @login
29 def america():
30     # login() #执行前加上验证
31     print("----欧美专区----")
32 @login
33 def japan():
34     print("----日韩专区----")
35 # @login
36 def henan(style):
37     ‘‘‘
38     :param style: 喜欢看什么类型的，就传进来
39     :return:
40     ‘‘‘
41     # login() #执行前加上验证
42     print("----河南专区----",style)
43 home()
44 # america = login(america) #你在这里相当于把america这个函数替换了
45 henan = login(henan)
46 #那用户调用时依然写
47 america()
48 henan("3p")#传入了参数；
49 japan()#不需要传入参数；

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/24 0024 7:25
 6 user_status = False  # 用户登录了就把这个改成True
 7 def login(auth_type):#再包括一层在外面；
 8     def outer(func):# 把要执行的模块从这里传进来
 9         def inner(*args, **kwargs):  # 使用非固定参数
10             _username = "alex"  # 假装这是DB里存的用户信息
11             _password = "abc!23"  # 假装这是DB里存的用户信息
12             global user_status
13             if user_status == False:
14                 username = input("user:")
15                 password = input("pasword:")
16                 if username == _username and password == _password:
17                     print("welcome login....")
18                     user_status = True
19                 else:
20                     print("wrong username or password!")
21             else:
22                 print("用户已登录，验证通过...")
23             if user_status == True:
24                 #func(args,kwargs) # 使用非固定参数,错误
25                 func(*args,**kwargs) # 使用非固定参数,支持多个参数；TypeError: ‘str‘ object is not callable
26         return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数
27     return outer
28 def home():
29     print("---首页----")
30 def america():
31     print("----欧美专区----")
32 #@login(‘WeChat‘)
33 def japan():
34     print("----日韩专区----")
35 @login(‘QQ‘)
36 def henan(style):
37     print("----河南专区----",style)
38 #henan = login(‘qq‘)
39 #print(henan)#<function login.<locals>.outer at 0x00000272E80880D0>
40 # xx = login(‘qq‘)
41 # print(xx)
42 # henan = xx(henan)
43 # print(henan)
44 henan("3p")#传入了参数；
45 #print(r)#<function login.<locals>.outer.<locals>.inner at 0x00000272E8088048>
46 #TypeError: ‘str‘ object is not callable

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/26 0026 16:36
#列表生成式
"""
现在有个需求，看列表[0,1,2,3,4,5,6,7,8,9],要求把列表中的每个值增加1，如何实现？
如何实现？
"""
#二逼青年版本；
a = list(range(10))
print(a)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = []
for i in a:
    b.append(i+1)
print(b)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = b#将b列表赋值给a列表；
print("二逼青年版本:",a)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#普通青年版
a = list(range(10))
print(a)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for index,i in enumerate(a):
    a[index] += 1#通过索引增加值
print("普通青年版本:",a)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#文艺青年版
a = list(range(10))
print(a)
a = map(lambda x:x+1,a)#使用lambda匿名函数；
print("文艺青年版:",a)#文艺青年版: <map object at 0x0000018A392D09E8>
for i in a:
    print(i)

#装逼青年版(引出列表生成式概念)
a = list(range(10))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = [i+1  for i in a  ]#此处的写法就是列表生成式；
print(a)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

b = list(range(10))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [i if i < 5 else i*i  for i in b]#内部使用了“三元运算”
print(b)#[0, 1, 2, 3, 4, 25, 36, 49, 64, 81]

#既可以循环元组，字典，还可以循环字符串；
name = "lijingping"
name = [i for i in name]#[‘l‘, ‘i‘, ‘j‘, ‘i‘, ‘n‘, ‘g‘, ‘p‘, ‘i‘, ‘n‘, ‘g‘]
print(name)
name = [i*2 for i in name]#字符串可以“相乘”
print(name)#[‘ll‘, ‘ii‘, ‘jj‘, ‘ii‘, ‘nn‘, ‘gg‘, ‘pp‘, ‘ii‘, ‘nn‘, ‘gg‘]

name = "lijingping"#字符串可以“相加”
name = [i+"cxz" for i in name]
print(name)#[‘lcxz‘, ‘icxz‘, ‘jcxz‘, ‘icxz‘, ‘ncxz‘, ‘gcxz‘, ‘pcxz‘, ‘icxz‘, ‘ncxz‘, ‘gcxz‘]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/26 0026 17:01
""
"""
如何生成一百万个杯子？！
"""
#以生产100万个杯子（器皿）举例，引入“生成器”的概念；
numbers = [i for i in range(1000)]
print(numbers)#生成100个数字的列表 numbers 中；
#生成器写法;
numbers2 = (i for i in range(8))#注意此处与“列表生成式”的区别，使用的是圆括号，为方便记忆，本人将之命名为“元组生成式”即生成器！类比元组等价于“只读列表”的概念；
print(numbers2)#<generator object <genexpr> at 0x0000019298BDF5C8>
#开始生产数据
print(next(numbers2))#0
print(next(numbers2))#1
print(next(numbers2))#2
print(next(numbers2))#3
print(next(numbers2))#4
print(next(numbers2))#5
print(next(numbers2))#6
print(next(numbers2))#7
#print(next(numbers2))#StopIteration，到这里就不再生产；
#通过以上来看，是一个一个的生产；而 numbers 则是具备生产“1000”个器皿的能力，但不占用内存空间大小；
#但只能按照“序号”来生产；只能向前，向前，不能后退后退！generator即生成器;
"""
特性总结:
1、从0开始生产；
2、不能后退，只能向前；
3、通过next(numbers)方法进行生产；
"""

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/26 0026 17:16
 6 ""
 7 """
 8 上节我们学会了"生成器"，虽然节省了内存空间，但是使用过程中不能一直print(next(numbers2)),如此效率就太低下了；
 9 so,我们可以使用for循环或者while循环来打印“生成器”中的数据；
10 """
11 # a = (i for i in range(10))#生成器对象a
12 # for l in a:
13 #     print(l)#for循环，不会出StopIteration
14 #a = (i for i in range(10))
15 # while True:
16 #      next(a)#StopIteration
17 
18 # print(range(100))#range(0, 100)
19 
20 """
21 #range就是生成器的原理生成的；
22 下面我们了解一下，在Python3与Python2中range的区别；
23 1、Python2 中，range(100),如下所示：
24 C:Users\Administrator>python2
25 Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)] on win32
26 Type "help", "copyright", "credits" or "license" for more information.
27 >>> range(100)
28 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
29 >>>
30 
31 2、Python3中，range则是生成器，如下所示：
32 C:Users\Administrator>python
33 Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
34 Type "help", "copyright", "credits" or "license" for more information.
35 >>> range(100)
36 range(0, 100)#不会占用内存；
37 >>>
38 
39 3、那么问题来了，Python2中，如何用生成器方式表示range呢？
40 C:Users\Administrator>python2
41 Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)] on win32
42 Type "help", "copyright", "credits" or "license" for more information.
43 >>> xrange(1000000)
44 xrange(1000000)
45 >>>
46 总结：Python2中的xrange(1000)等价于Python3中的range(1000)
47 """
48 #斐波那契数列；
49 """
50 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……....
51 这个数列从第3项开始，每一项都等于前两项之和。
52 """
53 def fibo(max):
54     n,a,b = 0,0,1#新引入的赋值方法；
55     while n < max:
56         print(b)
57         a,b = b,a+b#将b的值赋值给a,同时将a+b的值赋值给b;
58         n += 1
59     return ‘done‘
60 fibo(10)#1 1 2 3 5 8 13 21 34 55
61 
62 #通过斐波那契数列，引出yield关键字;
63 def fibo(max):
64     n,a,b = 0,0,1#新引入的赋值方法；
65     while n < max:
66         print("before yield.")
67         yield b#yield的作用，把函数的执行过程冻结在这一步并且把b的值返回给外面的next()方法；
68         print(b)
69         a,b = b,a+b#将b的值赋值给a,同时将a+b的值赋值给b;
70         n += 1
71     return ‘done‘
72 #fibo(10)
73 #print(fibo(10))#<generator object fibo at 0x0000024EE92AF5C8>
74 #通过返回值判断，此时的fibo就是生成器；
75 f = fibo(10)#将功能转换成一个“生成器”
76 next(f)
77 next(f)
78 next(f)
79 """
80 小结：
81 引出yield的作用：
82 1、yield把函数的执行过程冻结在这一步；
83 2、此时可以把b的值，返回给外面的next()方法；
84 3、函数名添加()，内部代码不执行，只是生成一个生成器对象；
85 可以把函数执行过程中的每一个状态，返回到外面来；原来的函数只能在里面打印，不能往外返回值，以return函数就终止了；
86 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/26 0026 18:08
 6 # a = (i for i in range(10))
 7 # while True:
 8 #     print(next(a))#while循环会抛出异常，但我们还没有学习异常处理方法，所以返回值StopIteration
 9 #for循环方法：
10 a = (i for i in range(10))# 生成器；
11 for i in a:
12     print(i)#一般会用for循环方法，且省去了next；
13 #以上的for循环等价于如下，因为在Python3中的range底层就是生成器；：
14 for i in range(100):
15     print(i)
16 """
17 小结：
18 In Python2：
19 range == list；
20 xrange(100000) == 生成器；
21 
22 In Python3：
23 range == 生成器；
24 xrange == 不存在了；
25 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/26 0026 18:18
 6 #自己通过函数写range生成器；
 7 # def range2(n):
 8 #     count = 0
 9 #     while count < n:
10 #         print(count)
11 #         count += 1
12 # range2(10)#函数内部执行；
13 #把函数range2做成生成器，只需要一步之遥；
14 def range2(n):
15     count = 0
16     while count < n:
17         print("count",count)
18         count += 1
19         yield count#类似于return,yield使程序冻结，next才解冻！
20 range2(10)#函数调用了，但是没有返回结果；因为引入了yield关键字；
21 print(range2(10))#<generator object range2 at 0x00000254BAAFF5C8>
22 new_range = range2(10)
23 r1 = next(new_range)
24 print(r1)
25 r2 = next(new_range)
26 print(r2)
27 #除了使用next()方法外，还可以使用new_range.__next__()
28 new_range.__next__()#返回值count 2
29 """
30 小结：
31 yield vs return
32 1、return 返回并终止function；
33 2、yield 会返回数据并冻结当前的执行过程；
34 3、next方法唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield;
35 """
36 """
37 生成器的牛逼之处在于：
38 1、之前的函数，从调用起，就必须等待执行结果结束，并返回计算值；
39 2、生成器可以把函数整个运行过程中的结果，返回至外面；为什么叫做yield,是暂停的意思，欧洲路牌就是标记这个单词；
40 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/26 0026 18:47
 6 def range2(n):
 7     count = 0
 8     while count < n:
 9         print("count",count)
10         count += 1
11         sign = yield count#类似于return,yield使程序冻结，next才解冻！
12         if sign == ‘stop‘:
13             break
14         print("---sing",sign)
15     return 3333#实验证明，函数中有了yield 就不会被执行；
16 #range2(3)#函数调用了，但是没有返回结果；
17 #print(range2(3))#<generator object range2 at 0x00000254BAAFF5C8>
18 new_range = range2(3)
19 next(new_range)
20 print("做了一些其他的事情，此时还剩余2次，但是我想终止后面的两次，如何操作？")
21 #此时还剩余2次，但是我想终止后面的两次，如何操作？
22 new_range.send("stop")
23 #send方法的作用：
24 #1、唤醒并继续执行；next方法只能唤醒；
25 #2、发送一个信息到生成器内部；
26 """
27 函数有了yield之后：
28 1、函数名称加()，就得到了一个生成器；
29 2、return 在生成器里代表生成器的终止，直接报错；
30 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 # __Author__:Administrator
 4 # Version:python3.6.5
 5 # Date:2018/5/26 0026 19:04
 6 #迭代可以理解为循环；
 7 ""
 8 """
 9 迭代器：
10 我们已经知道，可以直接作用与for 循环的数据类型有以下几种：
11 一类是集合数据类型，比如list、tuple、dict、set、str等；
12 一类是generator,包括生成器和带yield的generator function；
13 这些可以直接作用于for循环的对象统称为可迭代对象，Iterable；
14 可以使用isinstance()判断一个对象是否是Iterable对象：
15 """
16 from collections import Iterable
17 print(Iterable)
18 print(isinstance(‘abc‘,Iterable))#True#字符串；
19 print(isinstance([],Iterable))#True#列表；
20 print(isinstance((),Iterable))#True#元组；
21 print(isinstance({},Iterable))#True#字典；
22 print(isinstance((i for i in range(10)),Iterable))#True
23 print(isinstance(100,Iterable))#False
24 """
25 #生成器不但可以作用于for循环，还可以被next()函数不断调用并返回一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了；
26 #可以被next()函数调用并不断返回下一个值的对象成为迭代器：Iterator；
27 #可以使用isinstance()判断一个对象是否是Iterator对象，生成器只是迭代器的一种；
28 """
29 print(‘-------------------------------‘)
30 from collections import Iterator
31 print(Iterator)#<class ‘collections.abc.Iterator‘>
32 print(isinstance(‘abc‘,Iterator))#False
33 print(isinstance([],Iterable))#True
34 print(isinstance((),Iterable))#True
35 print(isinstance({},Iterable))#True
36 print(isinstance((i for i in range(10)),Iterator))#True
37 print(isinstance(100,Iterable))#False
38 """
39 生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator；
40 把list、dict、str等Iterable变成Iterator可以使用iter()函数；
41 
42 
43 我们可能会问起，为什么list、dict、str等数据类型不是Iterator？
44 这是因为Python的Iterator对象表示的是一个“数据流”，Iterator对象可以被next（）函数调用并不断返回
45 下一个数据，直到没有数据时候抛出异常StopIteration错误。可以把这个数据看做是一个有序序列，
46 但我们却不能提前知道序列的长度，只能不断通过next（）函数实现按需计算下一个数据，所以
47 Iterator的计算是“惰性的”，只有在需要返回下一个数据时他才会计算。
48 
49 当前的阶段，generator与Iterator基本是一致的。
50 
51 总结：
52 1、凡是可作用于for循环的对象都是Iterable类型；
53 1、凡是可作用于next()函数的对象都是Iterator类型，他们表示一个惰性计算的序列；
54 3、集合数据类型如list、dict、str等都是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
55 4、Python3的for循环本质上就是通过不断调用next()函数实现的，例如：
56 """
57 # for x in [1,2,3,4,5]:
58 #     pass
59 # #等价于
60 it = iter([1,2,3,4,5])
61 #循环
62 while True:
63     try:
64         x = next(it)
65     except StopIteration:#注意冒号不能丢；
66         break

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/27 0027 8:37
""
"""
本章总节
练习题
文件处理相关
编码问题

请说明python2 与python3中的默认编码是什么？
为什么会出现中文乱码？你能列举出现乱码的情况有哪几种？
如何进行编码转换？
#-*-coding:utf-8-*- 的作用是什么？
解释py2 bytes vs py3 bytes的区别

文件处理
r和rb的区别是什么？
解释一下以下三个参数的分别作用
open(f_name,‘r‘,encoding="utf-8")
函数基础：
写函数，计算传入数字参数的和。（动态传参）
写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作；
写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表
解释闭包的概念

函数进阶：
写函数，返回一个扑克牌列表，里面有52项，每一项是一个元组
例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃A’)]
写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}

例如:min_max(2,5,7,8,4)
返回:{‘max’:8,’min’:2}
写函数，专门计算图形的面积

其中嵌套函数，计算圆的面积，正方形的面积和长方形的面积
调用函数area(‘圆形’,圆半径) 返回圆的面积
调用函数area(‘正方形’,边长) 返回正方形的面积
调用函数area(‘长方形’,长，宽) 返回长方形的面积
def area():
    def 计算长方形面积():
        pass

    def 计算正方形面积():
        pass

    def 计算圆形面积():
        pass
写函数，传入一个参数n，返回n的阶乘

例如:cal(7)
计算7*6*5*4*3*2*1
编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），要求登录成功一次，后续的函数都无需再输入用户名和密码

生成器和迭代器
生成器和迭代器的区别？
生成器有几种方式获取value？
通过生成器写一个日志调用方法， 支持以下功能

根据指令向屏幕输出日志
根据指令向文件输出日志
根据指令同时向文件&屏幕输出日志
以上日志格式如下

2017-10-19 22:07:38 [1] test log db backup 3
2017-10-19 22:07:40 [2]    user alex login success 
#注意：其中[1],[2]是指自日志方法第几次调用，每调用一次输出一条日志
代码结构如下

 def logger(filename,channel=‘file‘):
    """
  #  日志方法
   ##  :param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both)
  #  :return:
"""
    ...your code...

 #调用
 log_obj = logger(filename="web.log",channel=‘both‘)
 log_obj.__next__()
 log_obj.send(‘user alex login success‘)
内置函数
用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb

name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]
用filter函数处理数字列表，将列表中所有的偶数筛选出来

num = [1,3,5,6,7,8]
如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格

portfolio = [
    {‘name‘: ‘IBM‘, ‘shares‘: 100, ‘price‘: 91.1},
    {‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22},
    {‘name‘: ‘FB‘, ‘shares‘: 200, ‘price‘: 21.09},
    {‘name‘: ‘HPQ‘, ‘shares‘: 35, ‘price‘: 31.75},
    {‘name‘: ‘YHOO‘, ‘shares‘: 45, ‘price‘: 16.35},
    {‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}
]
计算购买每支股票的总价

用filter过滤出，单价大于100的股票有哪些

1、请分别介绍文件操作中不同的打开方式之间的区别：

模式    含义
r    
rb    
r+    
rb+    
w    
wb    
w+    
wb+    
a    
ab    
a+    
ab+
2、有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请将以字母“a”开头的元素的首字母改为大写字母；

3、有如下程序, 请给出两次调用show_num函数的执行结果，并说明为什么：

   num = 20

   def show_num(x=num):
       print(x)

   show_num()

   num = 30

   show_num()
4、有列表 li = [‘alex‘, ‘egon‘, ‘smith‘, ‘pizza‘, ‘alen‘], 请以列表中每个元素的第二个字母倒序排序；

5、有名为poetry.txt的文件，其内容如下，请删除第三行；

   昔人已乘黄鹤去，此地空余黄鹤楼。

   黄鹤一去不复返，白云千载空悠悠。

   晴川历历汉阳树，芳草萋萋鹦鹉洲。

   日暮乡关何处是？烟波江上使人愁。
6、有名为username.txt的文件，其内容格式如下，写一个程序，判断该文件中是否存在"alex", 如果没有，则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在；

   pizza
   alex
   egon
7、有名为user_info.txt的文件，其内容格式如下，写一个程序，删除id为100003的行；

   pizza,100001
   alex, 100002
   egon, 100003
8、有名为user_info.txt的文件，其内容格式如下，写一个程序，将id为100002的用户名修改为alex li；

   pizza,100001
   alex, 100002
   egon, 100003
9、写一个计算每个程序执行时间的装饰器；

10、lambda是什么？请说说你曾在什么场景下使用lambda？

11、题目：写一个摇骰子游戏，要求用户压大小，赔率一赔一。

要求：三个骰子，摇大小，每次打印摇骰子数。

作业
现要求你写一个简单的员工信息增删改查程序，需求如下：

当然此表你在文件存储时可以这样表示

1,Alex Li,22,13651054608,IT,2013-04-01
2,Jack Wang,28,13451024608,HR,2015-01-07
3,Rain Wang,21,13451054608,IT,2017-04-01
4,Mack Qiao,44,15653354208,Sales,2016-02-01
5,Rachel Chen,23,13351024606,IT,2013-03-16
6,Eric Liu,19,18531054602,Marketing,2012-12-01
7,Chao Zhang,21,13235324334,Administration,2011-08-08
8,Kevin Chen,22,13151054603,Sales,2013-04-01
9,Shit Wen,20,13351024602,IT,2017-07-03
10,Shanshan Du,26,13698424612,Operation,2017-07-02
1.可进行模糊查询，语法至少支持下面3种查询语法:

find name,age from staff_table where age > 22

find * from staff_table where dept = "IT"

find * from staff_table where enroll_date like "2013"
2.可创建新员工纪录，以phone做唯一键(即不允许表里有手机号重复的情况)，staff_id需自增

语法: add staff_table Alex Li,25,134435344,IT,2015-10-29
3.可删除指定员工信息纪录，输入员工id，即可删除

语法: del from staff_table where  id=3
4.可修改员工信息，语法如下:

UPDATE staff_table SET dept="Market" WHERE  dept = "IT" 把所有dept=IT的纪录的dept改成Market
UPDATE staff_table SET age=25 WHERE  name = "Alex Li"  把name=Alex Li的纪录的年龄改成25
5.以上每条语名执行完毕后，要显示这条语句影响了多少条纪录。 比如查询语句 就显示 查询出了多少条、修改语句就显示修改了多少条等。

注意：以上需求，要充分使用函数，请尽你的最大限度来减少重复代码！
"""