第二模块：函数编程-第1章 函数、装饰器、迭代器、内置方法

• 01-鸡汤之人丑就要多读书
• 02-三元运算
• 03-文件处理
• 04-文件处理-二进制模式
• 05-文件处理-智能检测编码的工具
• 06-文件处理-写模式操作文件
• 07-文件处理-追加模式操作文件
• 08-文件处理-混合操作文件
• 09-文件操作其他功能
• 10-文件处理-文件修改功能
• 11-函数-基本介绍
• 12-函数-默认参数
• 13-函数-关键参数
• 14-函数-非固定参数
• 15-函数-非固定参数2
• 16-函数-返回值
• 17-函数-局部变量
• 18-函数-在函数里修改全局变量
• 19-函数-在函数里修改列表数据
• 20-函数-嵌套函数
• 21-函数-作用域
• 22-函数-匿名函数
• 23-函数-高阶函数
• 24-递归介绍
• 25-递归与栈的关系
• 26-递归的作用
• 27-递归的特性总结
• 28-递归的作用
• 29-尾递归优化
• 30-函数-内置方法1
• 31-函数-内置方法2
• 32-函数-内置方法3
• 33-函数-内置方法4
• 34-函数-内置方法5
• 36-函数-函数进阶-鸡汤
• 37-函数-函数进阶-命名空间
• 38-函数-函数进阶-作用域的查找空间
• 39-函数-函数进阶-闭包
• 40-函数-函数进阶-装饰器
• 41-函数-函数进阶-装饰器流程分析
• 42-函数-函数进阶-装饰器带参数的函数
• 43-函数-函数进阶-装饰器带参数2
• 44-函数-函数进阶-列表生成式
• 45-函数-函数进阶-生成器
• 46-函数-函数进阶-斐波那契数列
• 47-函数-函数进阶-生成器调用方法
• 48-函数-函数进阶-函数写生成器
• 49-函数-函数进阶-生成器send方法
• 50-函数-函数进阶-迭代器
• 51-函数-函数进阶-作业需求

01-鸡汤之人丑就要多读书；

1、一个好的讲师，不光传授知识，也能给学生带来心灵上的成长，鸡汤也是要喝的；

2、读书“真的”可以改变一个的气质，真的可以变得有内涵；

3、去豆瓣网上看书评、影评；

给豆瓣图书打个小广告——豆瓣图书TOP250：https://book.douban.com/top250?icn=index-book250-all

4、读书推荐《追风筝的人》、《白鹿原》；

5、任何有收益的事情，都不是“短平快”获取来的，“慢”是一种生活姿态；

6、套用钱钟书夫人杨绛（jiang）的一句话，我们大多数人的窘境都是：想法太多，读书太少！

7、我们的人生Level一定程度上可以由读书来决定，由内而外的感知到变化；

8、改变人生的几种方式：读书、看电影、去旅行、经历一些“别样的”事情；

9、电影推荐——《阿甘正传》、《辛德勒的名单》；

10、我们大多数人都不会觉得自己LOW，百分之八十的人都会觉得自己还“凑合”，但实际上结果,你懂得...；

02-三元运算

1、三元运算初识；

三元运算又称“三目运算”，是对简单条件语句的简写，如：

03-文件处理

1、我们大家日常如何操作文件呢；

• 1、安装文本编辑器软件，如windows自带记事本工具、notepad++；
• 2、选中鼠标右键，利用文本编辑器软件打开文件；
• 3、查看 or 写入内容；
• 4、保存、关闭；

2、文本的操作分为读、写、修改；

1）读；

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

兼职白领学生空姐模特护士的联系方式.txt

王心颜 上海 169 46  13813234424
马纤羽    深圳 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

04-文件处理-二进制模式

1、那么问题来了，如果我们事先不知道文件的编码格式怎么办？！

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

05-文件处理-智能检测编码的工具

1、chardet工具（动态监测编码的可能类型）；

#! /usr/bin/env python
# -*- coding:utf-8 -*-
#__author__ = "tqtl"
# Date:2018/5/14 22:36
# E-Mail: tqtl911@163.com
# Wechat:cxz19930911
#pip 安装第三方模块chardet，类似于yum安装第三方软件；

import chardet
f = open(file='兼职白领学生空姐模特护士的联系方式.txt',mode='rb')
data = f.read()
print(data)
f.close()
print(chardet.detect(data))#{'encoding': 'utf-8', 'confidence': 0.99, 'language': ''}#0.9表示相似程度；

2、chardet工具的pip安装；

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

C:UsersAdministratorPycharmProjectsLFXC2018venvScriptspython.exe C:/Users/Administrator/PycharmProjects/LFXC2018/文件操作&函数/05-文件处理-智能检测编码的工具.py
b'xcdxf5xd0xc4xd1xd5 xc9xcfxbaxa3 169 46  13813234424
xc2xedxcfxcbxd3xf0    xc9xeexdbxda 173    50 13744234523
xc7xc7xd2xe0xb7xc6    xb9xe3xd6xdd 172    52 15823423525
xc2xdexc3xcexd6xf1    xb1xb1xbexa9 175    49 18623423421
xc1xf5xc5xb5xbaxad    xb1xb1xbexa9 170    48 18623423765
xd4xc0xc4xddxc4xdd    xc9xeexdbxda 177    54 18835324553
xbaxd8xcdxf1xddxe6    xc9xeexdbxda 174    52 18933434452
xd2xb6xe8xf7xddxe6    xc9xcfxbaxa3 171    49 18042432324
xb6xc5xe6xa9xe6xa9 xb1xb1xbexa9  167 49 13324523342
black girl  xbaxd3xb1xb1  167 50  13542342233'
{'encoding': 'GB2312', 'confidence': 0.823045267489712, 'language': 'Chinese'}
王心颜 上海 169 46  13813234424
马纤羽    深圳 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

06-文件处理-写模式操作文件

1、如何不占用全部内存读取文件内容？！

• 循环文件，即每次只读取一部分；

#! /usr/bin/env python
# -*- coding:utf-8 -*-
#__author__ = "tqtl"
# Date:2018/5/14 23:04
# E-Mail: tqtl911@163.com
# Wechat:cxz19930911
file = open(file='兼职白领学生空姐模特护士的联系方式.txt',mode='r',encoding='utf-8')
for lines in file:
    print(lines)
file.close()
# 王心颜    上海 169 46    13813234424
#
# 马纤羽     深圳    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
#为什么会有空行，如何消除文件之间的空行？！
#No.1文件中本身隐藏着
换行符；
#No.2 print语句本身会换行，所以呈现的效果是换了两行；

2、写文件操作；

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

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

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

小结：

1、注意write模式操作文件，永远都不是修改，而是创建新文件；

2、如若原来文件与新文件名称相同，就是清空文件内容，再重新写入新内容；

3、So，使用write时候，一定要慎重！防止把源文件内容清空，过程不可逆；

07-文件处理-追加模式操作文件

1、追加模式，将内容追加至文件的尾部；

#!/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('
杠娘 北京 167 55 135585834333'.encode('gbk'))
file.close()#如果不是使用with方法，记得一定要关闭文件；

08-文件处理-混合操作文件

1、混合模式之r+读写模式；

#!/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("
newline 1哈哈")
file.write("
newline 2哈哈")
file.write("
newline 3哈哈")
file.write("
newline 4哈哈")
print("
new content",file.read())
file.close()

PS：先读取内容，然后写入，再次去读取，内容在写入后读取，所以未打印出来，但文件中的确已经写入新的内容；

1、混合模式之w+写读模式；

#!/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("
newline 1哈哈")
file.write("
newline 2哈哈")
file.write("
newline 3哈哈")
file.write("
newline 4哈哈")
print("
new content",file.read())
file.close()

总结：

1、r+读写模式，即先读后写，相当于以“读”的模式打开，支持向后面追加内容至文件中；

2、w+写读模式，以写的模式打开，支持读取，我们知道，写模式是以创建的模式打开文件，会把之前的内容先覆盖掉，然后再写入，但可以读取到后续写入的内容，使用场景：几乎用不到；

09-文件操作其他功能

1、文件操作的其他方法；

1）手工将buffer刷入硬盘中，file.flush()方法；

C:UsersAdministratorPycharmProjectsLFXC2018venvScriptspython.exe "C:Program FilesJetBrainsPyCharm 2018.1.3helperspydevpydevconsole.py" 50524 50525
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('
测试文件的flush操作')
13
file.write('
再次测试文件flush操作2')
15
file.flush()

2）Linux中一切皆文件，在Linux系统中判断文件的属性是否可读，返回值为布尔值，buffer中的内容不可读取；

C:UsersAdministratorPycharmProjectsLFXC2018venvScriptspython.exe "C:Program FilesJetBrainsPyCharm 2018.1.3helperspydevpydevconsole.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('
测试文件的flush操作')
13
file.write('
再次测试文件flush操作2')
15
file.flush()
file.readable()
False

3、file.readline()每次只读一行；

4、seek及tell方法，读取以及跳转至制定光标的位置；

seek方法找到的是字符吗？

总结：

1、tell与seek方法是按照字节来读取内容的，而read是按照字符来读取；

2、具体内容的展示，与编码格式有关，比如gbk占2个字节，utf-8占用3个字节（中文情况下）；

5、truncate方法，按照制定长度截断文件；

10-文件处理-文件修改功能

1、替换模式修改文件；

#!/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()

2、vim与word打开文件的原理说明（硬盘存储机制与原理决定）；

3、既省内存又能读取大文件的方法——边读边改（不占内容空间但是读取过程中多占用一份硬盘空间）；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/19 0019 21:29
import os
file_name = "兼职白领学生空姐模特护士的联系方式.txt"
file_new_name = "%s.new"%file_name
old_str = "乔亦菲"
new_str = "杠娘"
file = open(file = file_name,mode='r',encoding='utf-8')
file_new = open(file = file_new_name,mode='w',encoding='utf-8')
#循环遍历整个文件；
for line in file:#定义临时变量line
    if old_str in line:
        line = line.replace(old_str,new_str)
    file_new.write(line)
file.close()
file_new.close()
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

练习题

练习题1 —— 全局替换程序：

• 写一个脚本，允许用户按以下方式执行时，即可以对指定文件内容进行全局替换；

    `python your_script.py old_str new_str filename`
  

• 替换完毕后打印替换了多少处内容；

练习题2 —— 模拟登陆：

• 用户输入帐号密码进行登陆；
• 用户信息保存在文件内；
• 用户密码输入错误三次后锁定用户，下次再登录，检测到是这个用户也登录不了；

11-函数-基本介绍

书籍推荐——JInPIngMei（博客园，不让使用中文）；

1、函数初识；

#!/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、使程序变得容易维护，比如之前报警使用邮件，现在改为微信，修改一处即可；
函数，即对功能的封装；
"""

12-函数-默认参数

1、函数参数的作用；

• 形参变量；
• 实参变量；

2、默认参数；

#!/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
"""
# 小结：默认参数必须放在位置参数之后；

13-函数-关键参数

1、关键参数； 

#!/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不填写；关键参数为courseage可以打乱顺序传值；
"""
************学生注册信息************
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'

14-函数-非固定参数

1、参数可以传入多个值的使用场景；

#!/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
""" 

15-函数-非固定参数2

1、字典类型的非固定参数；

#!/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'}
"""

16-函数-返回值

1、判断函数功能是否执行成功；

#!/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('
姓名:',name,'
年龄:',age,'
国籍:',country,'
课程:',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。
"""

17-函数-局部变量

1、局部变量初识；

• 定义在函数外部的一级代码的变量，叫做全局变量，全局能引用，但遵循“从上到下”的顺序；
• 局部变量，是指定义在函数里的变量，只能在局部生效；
• 在函数内部可以引用全局变量；如果在全局和局部均存在相同变量如name，那么函数查找变量的顺序是“由内而外”的；

#!/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变量各自不会影响；
"""

 

18-函数-在函数里修改全局变量

1、global关键字修改局部变量为全局变量；

#!/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、因为实际场景中，其他位置还是调用全局变量，将函数内部的变量声明为全局变量后，函数一执行，即就修改了，后续拍错难度加大；
"""

19-函数-在函数里修改列表数据

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关键字不建议使用；
"""

20-函数-嵌套函数

1、嵌套函数初识；

#!/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

21-函数-作用域

1、函数的作用域初识；

• 在Python中，一个函数就是一个作用域（JavaScript相似）所有的局部变量放置在其作用域中；
• 在C#、Java中的作用域为｛｝；
• 代码定义完成后，作用域已经生成，作用域链向上查找；
• 函数名可以当做返回值；比如return func2；

#!/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>

22-函数-匿名函数

1、匿名函数初识；

#!/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、代码质量高；
"""

• 节省代码量；
• 逼格儿高超；

23-函数-高阶函数

1、高阶函数初识；

#!/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返回另外一个函数；
"""

24-递归介绍

1、递归初识（在函数的执行过程中调用自己）；

#!/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;

25-递归与栈的关系

1、我之前也没明白递归这个东西；

http://www.cnblogs.com/alex3714/articles/8955091.html 堆栈扫盲博文分享；

26-递归的作用

1、解决数学上的问题；

#!/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)#返回值为：521  125
calc(10)

27-递归的特性总结

1、一层一层的进入，一层层的退出；

2、递归特性总结：

1、递归必须有结束条件，要不然就会成为死循环，最终内存撑爆系统；

2、每进入更深一层时，问题规模相比上次递归都有所减少：

3、递归的执行效率不太高，递归层次过多会导致栈溢出，

28-递归的作用

1、可以用于解决很多算法问题，把复杂的问题分成一个个小问题，一一解决。

2、比如求斐波那契数列、汉诺塔、多级评论树、二分查找、求阶乘等。用递归求斐波那契数列、汉诺塔 对初学者来讲可能理解起来不太容易，所以我们用阶乘和二分查找来给大家演示一下。

#!/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

29-尾递归优化

1、尾递归初识；

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

30-函数-内置方法1

1、Python的内置方法；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/21 0021 21:36
print("abs-绝对值函数:",abs(-11))
#dict,将一些数据转为字典类型；
#print(help(int))#Help on class int in module builtins:
numbers = [1,4,5,-1,3]
print("min-返回最小值函数:",min(numbers))#返回最小值-1
print("max-返回最大值函数:",max(numbers))#返回最大值5

print(all([]))#True,所有值为True才返回True
print(any([False,0,-1,1]))#True,有任何一个值为为True就返回True

print("打印当前程序中的所有变量:",dir())#['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'numbers']

print(hex(12))#将十进制数值12转换为16进制：0xc

#print(help(slice))#不会就help，就像Linux中的man
li = list(range(10))
print(li)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
s = slice(1,7,2)#切片，步长为2，没什么卵用；提起定义切片的规则；
print(s)#slice(1, 7, 2)
print(li[1:3])#[1,2]
print(li[s])#[1, 3, 5]

print(divmod(15,6))#(2, 3)返回值为商和余数
"""
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
10//3
3
10/3
3.3333333333333335
10%3
1
"""
li = [0, 1, 2, 3, 4, 5,-1,37,33,100,15,16, 7, 8, 9]
print(sorted(li))#[-1, 0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 33, 37, 100]
dic = {}
for a in range(20):
    dic[a] = a - 50
print(dic)#字典本身无序；
print(dic.items())#dict_items([(0, -50), (1, -49), (2, -48), (3, -47),
print(sorted(dic.items()))#[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45),
print(sorted(dic.items(),key = lambda x:x[1]))
dic[0] = 399
print(sorted(dic.items(),key = lambda x:x[1]))#最大值在最后面；
print(sorted(dic.items(),key = lambda x:x[1],reverse=True))#最大值在最前面[(0, 399), (19, -31), (18, -32), (17, -33)

s = 'abcd天晴天朗'
print(ascii(s))#'abcdu5929u6674u5929u6717',将字符转成二进制，没什么卵用；

#enumerate()枚举，返回列表的索引；
print(oct(12))#0o14，将10进制转换成为8进制；
print(bin(12))#0b1100，将10进制转换成为2进制；

31-函数-内置方法2

1、内置方法2；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/21 0021 22:19
f = "1+3/2"
print(f)#1+3/2
print(eval(f))#eval()函数，将字符串转成数字，返回值：2.5，只能处理单行代码；

code = """
def foo():
    prinr("run foo")
    return 1234
foo()
"""
res = eval("1+3+3")
res2 = exec("1+3+3")
print('res',res)#res 7
print('res',res2)#res None
"""
小结：
eval只能处理单行代码，而exec可以处理多行代码；
但exec没有返回值，eval有返回值；
"""

print(ord('a'))#返回字符在ASCII码表中的位置97；
print(ord('b'))#返回字符在ASCII码表中的位置98；
print(chr(98))#通过ASCII码表中的位置，返回字符b
print(chr(97))#通过ASCII码表中的位置，返回字符a
a = [1,4,5,-1,3,0]
print(sum(a))#求列表中元素的和；

#bytearray
a = [1,4,5,-1,3,0]
s = 'abcd路飞学城'
print(s)#abcd天晴天朗
#s[0]='AA'#TypeError: 'str' object does not support item assignment
#s = bytearray(s)#TypeError: string argument without an encoding
s = s.encode('utf-8')
print(s[0])#a在ASCII码表中的位置：97
#s[0] =98#TypeError: 'bytes' object does not support item assignment
s = bytearray(s)
print(s[0])#97
s[0] = 65
print(s)#bytearray(b'Abcdxe8xb7xafxe9xa3x9exe5xadxa6xe5x9fx8e')
print(s[4])#232
s[4]=233
print(s)#bytearray(b'Abcdxe8xb7xafxe9xa3x9exe5xadxa6xe5x9fx8e')
print(s.decode())#Abcd鷯飞学城
print(id(s))#2166037941024
s[0]=66
print(id(s))#2166037941024

#map filter reduce三剑客；
map(lambda x:x*x,[1,2,3,4,5])
print(list(map(lambda x:x*x,[1,2,3,4,5])))#[1, 4, 9, 16, 25]
print(list(filter(lambda x:x>3,[1,2,3,4,5])))#[4, 5]返回值
import functools
print(functools.reduce(lambda x,y:x+y,[1,3,4,5,6678,4,2]))#求和：6697
print(functools.reduce(lambda x,y:x+y,[1,3,4,5,6678,4,2],3))#求和：6700
print(functools.reduce(lambda x,y:x*y,[1,3,4,5,6678,4,2]))#求乘积：3205440

print(pow(2,10))#返回2的10次幂；

32-函数-内置方法3

1、内置方法3；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/21 0021 22:54
#print(help(print()))
"""
C:/UsersAdministratorPycharmProjectsLFXC2018venvScriptspython.exe C:/Users/Administrator/PycharmProjects/LFXC2018/文件操作&函数/函数/32-函数-内置方法3.py
Help on NoneType object:
class NoneType(object)
 |  Methods defined here:
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
None"""
s = 'Hey, My name is alex
,from shandong province.'
print(s)#默认end结尾是一个
换行符；
'''
Hey, My name is alex
,from shandong province.
'''
print(s,end='||')#
'''
Hey, My name is alex
,from shandong province.||
'''

print('
崔晓昭','李静瓶',sep='--->')#崔晓昭--->李静瓶
print('崔晓昭','李静瓶',sep='<---')#崔晓昭<---李静瓶

33-函数-内置方法4

1、内置方法4；

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

a = [1,2,3,4,5]
b = ['a','b','c','d','e']
print(list(zip(a,b)))#[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]使得列表一一对应；

34-函数-内置方法5

1、内置方法5；

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

36-函数-函数进阶-鸡汤

1、电影推荐-《荒野求生》

https://v.qq.com/x/cover/4vle2tvyudfpaky.html

2、书籍推荐-《百年孤独》

https://item.jd.com/12152685.html

37-函数-函数进阶-命名空间

1、name space（名称空间）初识；

1）名称空间总分3种：

• locals：是函数内的名称空间，包括局部变量和形参；
• globals：全局变量，函数定义所在模块的名字空间；
• builtins：内置模块的名字空间；

#!/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']
"""

总结：不同变量的作用域不同，就是由这个变量所在命名空间决定的。

2) 作用域（scope）即范围：

• 全局范围：全局存活，全局有效；
• 局部范围：临时存活，局部有效；

查看作用域的方法——globals()，locals()

C:UsersAdministratorPycharmProjectsLFXC2018venvScriptspython.exe "C:Program FilesJetBrainsPyCharm 2018.1.3helperspydevpydevconsole.py" 63904 63905
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
x = 1
globals()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.

Noteworthy: 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.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
All Rights Reserved.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.
Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved., 'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
    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}
locals()
{'__builtins__': {'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.

Noteworthy: 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.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
All Rights Reserved.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.
Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved., 'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
    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}
__buildins__
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name '__buildins__' is not defined
__builtins__
{'__name__': 'builtins', '__doc__': "Built-in functions, exceptions, and other objects.

Noteworthy: 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.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
All Rights Reserved.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.
Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved., 'credits':     Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
    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}
dir(__builtins__)
['__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']

38-函数-函数进阶-作用域的查找空间

1、作用域的查找顺序；

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

39-函数-函数进阶-闭包

1、闭包的概念；

#!/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
#以上就是闭包的概念；
#在外部拿到了内部的函数，并且还可以使用内部函数的作用域里面的值；

40-函数-函数进阶-装饰器

1、装饰器是Python基础中的最重要知识点；http://www.cnblogs.com/alex3714/articles/5765046.html

41-函数-函数进阶-装饰器流程分析

1、装饰器初识；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/23 0023 22:13
# _*_coding:utf-8_*_
"""
user_status = False  # 用户登录了就把这个改成True；
def login():
    _username = "alex"  # 假装这是DB里存的用户信息；
    _password = "abc!23"  # 假装这是DB里存的用户信息；
    global user_status
    if user_status == False:
        username = input("user:")
        password = input("pasword:")
        if username == _username and password == _password:
            print("welcome login....")
            user_status = True#用户登录了，把这个改成True；
        else:
            print("wrong username or password!")
    else:
        print("用户已登录，验证通过...")


def home():
    print("---首页----")
def america():
    login()  # 执行前加上验证；
    print("----欧美专区----")
def japan():
    print("----日韩专区----")
def henan():
    login()  # 执行前加上验证；
    print("----河南专区----")
home()
america()
henan()
"""

"""
封闭：已实现的功能代码块不应该被修改;
开放：对现有功能的扩展开放;
"""
user_status = False  # 用户登录了就把这个改成True；
def login(func):#把要执行的模块从这里传进来
    _username = "alex"  # 假装这是DB里存的用户信息；
    _password = "abc!23"  # 假装这是DB里存的用户信息；
    global user_status
    if user_status == False:
        username = input("user:")
        password = input("pasword:")
        if username == _username and password == _password:
            print("welcome login....")
            user_status = True#用户登录了，把这个改成True；
        else:
            print("wrong username or password!")
    else:
        print("用户已登录，验证通过...")
    if user_status == True:
        func()


def home():
    print("---首页----")
def america():
    #login()  # 执行前加上验证；
    print("----欧美专区----")
def japan():
    print("----日韩专区----")
def henan():
    #login()  # 执行前加上验证；
    print("----河南专区----")
home()#首页不需要认证登录，
login(america)#america专区，需要验证，所以调用 login，把需要验证的功能 当做一个参数传给login
#america()
login(henan)#america专区，需要验证，所以调用 login，把需要验证的功能 当做一个参数传给login

#思路继续优化中；
def plus(n):
    return n+1
plus(6)
plus2 = lambda n:n+1

#继续解释；
def login(func):  # 把要执行的模块从这里传进来；
    def inner():  # 再定义一层函数；
        _username = "alex"  # 假装这是DB里存的用户信息；
        _password = "abc!23"  # 假装这是DB里存的用户信息；
        global user_status
        if user_status == False:
            username = input("user:")
            password = input("pasword:")
            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")
        if user_status == True:
            func()  # 看这里看这里，只要验证通过了，就调用相应功能；
    return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数；

42-函数-函数进阶-装饰器带参数的函数

1、带装饰器的参数；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/24 0024 7:03
#最终代码；
user_status = False  # 用户登录了就把这个改成True；
def login(func):  # 把要执行的模块从这里传进来；
    def inner(*args, **kwargs):  # 使用非固定参数；
        _username = "alex"  # 假装这是DB里存的用户信息；
        _password = "abc!23"  # 假装这是DB里存的用户信息；
        global user_status
        if user_status == False:
            username = input("user:")
            password = input("pasword:")
            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")
        if user_status == True:
            #func(args,kwargs) # 使用非固定参数；
            func(args,kwargs) # 使用非固定参数,支持多个参数；
    return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数；

def home():
    print("---首页----")
@login
def america():
    # login() #执行前加上验证
    print("----欧美专区----")
@login
def japan():
    print("----日韩专区----")
# @login
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    # login() #执行前加上验证
    print("----河南专区----",style)
home()
# america = login(america) #你在这里相当于把america这个函数替换了
henan = login(henan)
#那用户调用时依然写
america()
henan("3p")#传入了参数；
japan()#不需要传入参数；

43-函数-函数进阶-装饰器带参数2

1、装饰器带参数2；

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

44-函数-函数进阶-列表生成式

1、列表生成式初识；

#!/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']

45-函数-函数进阶-生成器

1、受到机器内存的限制，列表不能无限制大，比如生成100w个数字；

2、通过“工厂生产器皿”的案例，引入“生成器”的概念；generator-生成器；

#!/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)方法进行生产；
"""

• numbers2 = (i for i in range(8))#注意此处与“列表生成式”的区别，使用的是圆括号，为方便记忆，本人将之命名为“元组生成式”即生成器！类比元组等价于“只读列表”的概念；
• print(numbers2)#<generator object <genexpr> at 0x0000019298BDF5C8>#存在内存中，生成器；

46-函数-函数进阶-斐波那契数列

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/26 0026 17:16
""
"""
上节我们学会了"生成器"，虽然节省了内存空间，但是使用过程中不能一直print(next(numbers2)),如此效率就太低下了；
so,我们可以使用for循环或者while循环来打印“生成器”中的数据；
"""
# a = (i for i in range(10))#生成器对象a
# for l in a:
#     print(l)#for循环，不会出StopIteration
#a = (i for i in range(10))
# while True:
#      next(a)#StopIteration

# print(range(100))#range(0, 100)

"""
#range就是生成器的原理生成的；
下面我们了解一下，在Python3与Python2中range的区别；
1、Python2 中，range(100),如下所示：
C:UsersAdministrator>python2
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> range(100)
[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]
>>>

2、Python3中，range则是生成器，如下所示：
C:UsersAdministrator>python
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> range(100)
range(0, 100)#不会占用内存；
>>>

3、那么问题来了，Python2中，如何用生成器方式表示range呢？
C:UsersAdministrator>python2
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> xrange(1000000)
xrange(1000000)
>>>
总结：Python2中的xrange(1000)等价于Python3中的range(1000)
"""
#斐波那契数列；
"""
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……....
这个数列从第3项开始，每一项都等于前两项之和。
"""
def fibo(max):
    n,a,b = 0,0,1#新引入的赋值方法；
    while n < max:
        print(b)
        a,b = b,a+b#将b的值赋值给a,同时将a+b的值赋值给b;
        n += 1
    return 'done'
fibo(10)#1 1 2 3 5 8 13 21 34 55

#通过斐波那契数列，引出yield关键字;
def fibo(max):
    n,a,b = 0,0,1#新引入的赋值方法；
    while n < max:
        print("before yield.")
        yield b#yield的作用，把函数的执行过程冻结在这一步并且把b的值返回给外面的next()方法；
        print(b)
        a,b = b,a+b#将b的值赋值给a,同时将a+b的值赋值给b;
        n += 1
    return 'done'
#fibo(10)
#print(fibo(10))#<generator object fibo at 0x0000024EE92AF5C8>
#通过返回值判断，此时的fibo就是生成器；
f = fibo(10)#将功能转换成一个“生成器”
next(f)
next(f)
next(f)
"""
小结：
引出yield的作用：
1、yield把函数的执行过程冻结在这一步；
2、此时可以把b的值，返回给外面的next()方法；
3、函数名添加()，内部代码不执行，只是生成一个生成器对象；
可以把函数执行过程中的每一个状态，返回到外面来；原来的函数只能在里面打印，不能往外返回值，以return函数就终止了；
"""

47-函数-函数进阶-生成器调用方法

1、生成器的调用方法；

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

In Python3：
range == 生成器；
xrange == 不存在了；
"""

48-函数-函数进阶-函数写生成器

1、生成器的创建方式；

• 列表生成式方法（），只能写一个“三元运算”：
• 通过函数创建生成器；

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

49-函数-函数进阶-生成器send方法

1、生成器中next()方法与send()方法的区别；

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

50-函数-函数进阶-迭代器

1、迭代器Iterator；

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# __Author__:Administrator
# Version:python3.6.5
# Date:2018/5/26 0026 19:04
#迭代可以理解为循环；
""
"""
迭代器：
我们已经知道，可以直接作用与for 循环的数据类型有以下几种：
一类是集合数据类型，比如list、tuple、dict、set、str等；
一类是generator,包括生成器和带yield的generator function；
这些可以直接作用于for循环的对象统称为可迭代对象，Iterable；
可以使用isinstance()判断一个对象是否是Iterable对象：
"""
from collections import Iterable
print(Iterable)
print(isinstance('abc',Iterable))#True#字符串；
print(isinstance([],Iterable))#True#列表；
print(isinstance((),Iterable))#True#元组；
print(isinstance({},Iterable))#True#字典；
print(isinstance((i for i in range(10)),Iterable))#True
print(isinstance(100,Iterable))#False
"""
#生成器不但可以作用于for循环，还可以被next()函数不断调用并返回一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了；
#可以被next()函数调用并不断返回下一个值的对象成为迭代器：Iterator；
#可以使用isinstance()判断一个对象是否是Iterator对象，生成器只是迭代器的一种；
"""
print('-------------------------------')
from collections import Iterator
print(Iterator)#<class 'collections.abc.Iterator'>
print(isinstance('abc',Iterator))#False
print(isinstance([],Iterable))#True
print(isinstance((),Iterable))#True
print(isinstance({},Iterable))#True
print(isinstance((i for i in range(10)),Iterator))#True
print(isinstance(100,Iterable))#False
"""
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator；
把list、dict、str等Iterable变成Iterator可以使用iter()函数；


我们可能会问起，为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个“数据流”，Iterator对象可以被next（）函数调用并不断返回
下一个数据，直到没有数据时候抛出异常StopIteration错误。可以把这个数据看做是一个有序序列，
但我们却不能提前知道序列的长度，只能不断通过next（）函数实现按需计算下一个数据，所以
Iterator的计算是“惰性的”，只有在需要返回下一个数据时他才会计算。

当前的阶段，generator与Iterator基本是一致的。

总结：
1、凡是可作用于for循环的对象都是Iterable类型；
1、凡是可作用于next()函数的对象都是Iterator类型，他们表示一个惰性计算的序列；
3、集合数据类型如list、dict、str等都是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
4、Python3的for循环本质上就是通过不断调用next()函数实现的，例如：
"""
# for x in [1,2,3,4,5]:
#     pass
# #等价于
it = iter([1,2,3,4,5])
#循环
while True:
    try:
        x = next(it)
    except StopIteration:#注意冒号不能丢；
        break

51-函数-函数进阶-作业需求

#!/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.以上每条语名执行完毕后，要显示这条语句影响了多少条纪录。 比如查询语句 就显示 查询出了多少条、修改语句就显示修改了多少条等。

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