字符编码的只是储配
1. 文本编辑器存取文件的原理（nodepad++，pycharm，word）
打开编辑器就打开了启动了一个进程，是在内存中的，所以在编辑器编写的内容也都是存放与内存中的，断电后数据丢失
因而需要保存到硬盘上，点击保存按钮，就从内存中把数据刷到了硬盘上。
在这一点上，我们编写一个py文件（没有执行），跟编写其他文件没有任何区别，都只是在编写一堆字符而已。
2. python解释器执行py文件的原理 ，例如python test.py
第一阶段：python解释器启动，此时就相当于启动了一个文本编辑器
第二阶段：python解释器相当于文本编辑器，去打开test.py文件，从硬盘上将test.py的文件内容读入到内存中
第三阶段：python解释器解释执行刚刚加载到内存中test.py的代码
总结：
- python解释器是解释执行文件内容的，因而python解释器具备读py文件的功能，这一点与文本编辑器一样
- 与文本编辑器不一样的地方在于，python解释器不仅可以读文件内容，还可以执行文件内容
二 什么是字符编码
计算机要想工作必须通电,也就是说‘电’驱使计算机干活,而‘电’的特性，就是高低电平(高低平即二进制数1,低电平即二进制数0),也就是说计算机只认识数字
编程的目的是让计算机干活，而编程的结果说白了只是一堆字符，也就是说我们编程最终要实现的是：一堆字符驱动计算机干活
所以必须经过一个过程：
字符--------（翻译过程）------->数字
这个过程实际就是一个字符如何对应一个特定数字的标准，这个标准称之为字符编码
三 字符编码的发展史
阶段一：现代计算机起源于美国，最早诞生也是基于英文考虑的ASCII
ASCII:一个Bytes代表一个字符（英文字符/键盘上的所有其他字符），1Bytes=8bit，8bit可以表示0-2**8-1种变化，即可以表示256个字符
ASCII最初只用了后七位，127个数字，已经完全能够代表键盘上所有的字符了（英文字符/键盘的所有其他字符）
后来为了将拉丁文也编码进了ASCII表，将最高位也占用了
阶段二:为了满足中文，中国人定制了GBK
GBK:2Bytes代表一个字符
为了满足其他国家，各个国家纷纷定制了自己的编码
日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里
阶段三：各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。
于是产生了unicode， 统一用2Bytes代表一个字符， 2**16-1=65535，可代表6万多个字符，因而兼容万国语言
但对于通篇都是英文的文本来说，这种编码方式无疑是多了一倍的存储空间（二进制最终都是以电或者磁的方式存储到存储介质中的）
于是产生了UTF-8，对英文字符只用1Bytes表示，对中文字符用3Bytes
需要强调的一点是：
unicode：简单粗暴，所有字符都是2Bytes，优点是字符->数字的转换速度快，缺点是占用空间大
utf-8：精准，对不同的字符用不同的长度表示，优点是节省空间，缺点是：字符->数字的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能够准确表示
- 内存中使用的编码是unicode，用空间换时间（程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快）
- 硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大与utf-8的转换延迟，而且I/O应该是尽可能地节省带宽，保证数据传输的稳定性。
所有程序，最终都要加载到内存，程序保存到硬盘不同的国家用不同的编码格式，但是到内存中我们为了兼容万国（计算机可以运行任何国家的程序原因在于此），统一且固定使用unicode，这就是为何内存固定用unicode的原因，你可能会说兼容万国我可以用utf－8啊，可以，完全可以正常工作，之所以不用肯定是unicode比utf－8更高效啊（uicode固定用2个字节编码，utf－8则需要计算），但是unicode更浪费空间，没错，这就是用空间换时间的一种做法，而存放到硬盘，或者网络传输，都需要把unicode转成utf－8，因为数据的传输，追求的是稳定，高效，数据量越小数据传输就越靠谱，于是都转成utf－8格式的，而不是unicode。
四 字符编码的发展史
计算机由美国人发明，最早的字符编码为ASCII，只规定了英文字母数字和一些特殊字符与数字的对应关系。最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号
当然我们编程语言都用英文没问题，ASCII够用，但是在处理数据时，不同的国家有不同的语言，日本人会在自己的程序中加入日文，中国人会加入中文。
而要表示中文，单拿一个字节表表示一个汉子，是不可能表达完的(连小学生都认识两千多个汉字)，解决方法只有一个，就是一个字节用>8位2进制代表，位数越多，代表的变化就多，这样，就可以尽可能多的表达出不通的汉字
所以中国人规定了自己的标准gb2312编码，规定了包含中文在内的字符－>数字的对应关系。
日本人规定了自己的Shift_JIS编码
韩国人规定了自己的Euc-kr编码（另外，韩国人说，计算机是他们发明的，要求世界统一用韩国编码）
这时候问题出现了，精通18国语言的小周同学谦虚的用8国语言写了一篇文档，那么这篇文档，按照哪国的标准，都会出现乱码（因为此刻的各种标准都只是规定了自己国家的文字在内的字符跟数字的对应关系，如果单纯采用一种国家的编码格式，那么其余国家语言的文字在解析时就会出现乱码）
所以迫切需要一个世界的标准（能包含全世界的语言）于是unicode应运而生（韩国人表示不服，然后没有什么卵用）
ascii用1个字节（8位二进制）代表一个字符
unicode常用2个字节（16位二进制）代表一个字符，生僻字需要用4个字节
例：
字母x，用ascii表示是十进制的120，二进制0111 1000
汉字中已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。
字母x，用unicode表示二进制0000 0000 0111 1000，所以unicode兼容ascii，也兼容万国，是世界的标准
这时候乱码问题消失了，所有的文档我们都使用但是新问题出现了，如果我们的文档通篇都是英文，你用unicode会比ascii耗费多一倍的空间，在存储和传输上十分的低效
本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：
| 字符 | ASCII | Unicode | UTF-8 |
|---|---|---|---|
| A | 01000001 | 00000000 01000001 | 01000001 |
| 中 | x | 01001110 00101101 | 11100100 10111000 10101101 |
从上面的表格还可以发现，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
五 字符编码的使用
1 文本编辑器
2 文本编辑器nodpad++
分析过程？什么是乱码
文件从内存刷到硬盘的操作简称存文件
文件从硬盘读到内存的操作简称读文件
乱码一：存文件时就已经乱码
存文件时，由于文件内有各个国家的文字，我们单以shiftjis去存，
本质上其他国家的文字由于在shiftjis中没有找到对应关系而导致存储失败，用open函数的write可以测试，f=open('a.txt','w',encodig='shift_jis')
f.write('你瞅啥\n何を見て\n') #'你瞅啥'因为在shiftjis中没有找到对应关系而无法保存成功，只存'何を見て\n'可以成功
但当我们用文件编辑器去存的时候，编辑器会帮我们做转换，保证中文也能用shiftjis存储（硬存，必然乱码），这就导致了，存文件阶段就已经发生乱码
此时当我们用shiftjis打开文件时，日文可以正常显示，而中文则乱码了
再或者，存文件时：
f=open('a.txt','wb')
f.write('何を見て\n'.encode('shift_jis'))
f.write('你愁啥\n'.encode('gbk'))
f.write('你愁啥\n'.encode('utf-8'))
f.close()
以任何编码打开文件a.txt都会出现其余两个无法正常显示的问题
乱码二：存文件时不乱码而读文件时乱码
存文件时用utf-8编码，保证兼容万国，不会乱码，而读文件时选择了错误的解码方式，比如gbk，则在读阶段发生乱码，读阶段发生乱码是可以解决的，选对正确的解码方式就ok了，而存文件时乱码，则是一种数据的损坏。
3 文本编辑器pycharm
以gbk格式保存
以utf-8格式打开
分析过程？
总结：
无论是何种编辑器，要防止文件出现乱码（请一定注意，存放一段代码的文件也仅仅只是一个普通文件而已，此处指的是文件没有执行前，我们打开文件时出现的乱码）
核心法则就是，文件以什么编码保存的，就以什么编码方式打开
4 程序的执行
阶段一：启动python解释器
阶段二：python解释器此时就是一个文本编辑器，负责打开文件test.py,即从硬盘中读取test.py的内容到内存中
此时，python解释器会读取test.py的第一行内容，#coding:utf-8，来决定以什么编码格式来读入内存，这一行就是来设定python解释器这个软件的编码使用的编码格式这个编码，
可以用sys.getdefaultencoding()查看，如果不在python文件指定头信息＃-*-coding:utf-8-*-,那就使用默认的
python2中默认使用ascii，python3中默认使用utf-8
阶段三：读取已经加载到内存的代码（unicode编码的二进制），然后执行，执行过程中可能会开辟新的内存空间，比如x="egon"
内存的编码使用unicode，不代表内存中全都是unicode编码的二进制，
在程序执行之前，内存中确实都是unicode编码的二进制,比如从文件中读取了一行x="egon",其中的x，等号，引号，地位都一样，都是普通字符而已，都是以unicode编码的二进制形式存放与内存中的
但是程序在执行过程中，会申请内存（与程序代码所存在的内存是俩个空间），可以存放任意编码格式的数据，比如x="egon",会被python解释器识别为字符串，会申请内存空间来存放"hello"，然后让x指向该内存地址，此时新申请的该内存地址保存也是unicode编码的egon,如果代码换成x="egon".encode('utf-8'),那么新申请的内存空间里存放的就是utf-8编码的字符串egon了
针对python3如下图
浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器
如果服务端encode的编码格式是utf-8， 客户端内存中收到的也是utf-8编码的二进制。
5 在python2中有两种字符串类型str和unicode
str类型
当python解释器执行到产生字符串的代码时（例如s='方'），会申请新的内存地址，然后将'方'encode成文件开头指定的编码格式，这已经是encode之后的结果了,所以s只能decode
1 #_*_coding:gbk_*_ 2 #!/usr/bin/env python 3 4 s='方'
5 print s.encode('gbk')
6 print s.decode('gbk')
所以很重要的一点是：
在python2中，str就是编码后的结果bytes，str=bytes,所以在python2中，unicode字符编码的结果是str/bytes
#coding:utf-8
s='方' #在执行时,'方'会被以conding:utf-8的形式保存到新的内存空间中
print repr(s) #'\xe6\x9e\x97' 三个Bytes,证明确实是utf-8
print type(s) #<type 'str'>
s.decode('utf-8')
# s.encode('utf-8') #报错，s为编码后的结果bytes，所以只能decode
unicode类型
当python解释器执行到产生字符串的代码时（例如s=u'林'），会申请新的内存地址，然后将'林'以unicode的格式存放到新的内存空间中，所以s只能encode，不能decode
s=u'林' print repr(s) #u'\u6797' print type(s) #<type 'unicode'>
# s.decode('utf-8') #报错，s为unicode，所以只能encode s.encode('utf-8')
打印到终端
对于print需要特别说明的是：
当程序执行时，比如
x='林'
print(x) #这一步是将x指向的那块新的内存空间（非代码所在的内存空间）中的内存，打印到终端，而终端仍然是运行于内存中的，所以这打印可以理解为从内存打印到内存，即内存->内存，unicode->unicode
对于unicode格式的数据来说，无论怎么打印，都不会乱码
6 python3中的字符串与python2中的u'字符串'，都是unicode，所以无论如何打印都不会乱码
在pycharm中
在windows终端
但是在python2中存在另外一种非unicode的字符串，此时，print x，会按照终端的编码执行x.decode('终端编码')，变成unicode后，再打印，此时终端编码若与文件开头指定的编码不一致，乱码就产生了
在pycharm中（终端编码为utf-8，文件编码为utf-8，不会乱码）
在windows终端（终端编码为gbk，文件编码为utf-8，乱码产生）
思考题：
分别验证在pycharm中和cmd中下述的打印结果
#coding:utf-8
s=u'林' #当程序执行时，'林'会被以unicode形式保存新的内存空间中
#s指向的是unicode，因而可以编码成任意格式，都不会报encode错误
s1=s.encode('utf-8')
s2=s.encode('gbk')
print s1 #打印正常否？
print s2 #打印正常否
print repr(s) #u'\u6797'
print repr(s1) #'\xe6\x9e\x97' 编码一个汉字utf-8用3Bytes
print repr(s2) #'\xc1\xd6' 编码一个汉字gbk用2Bytes
print type(s) #<type 'unicode'>
print type(s1) #<type 'str'>
print type(s2) #<type 'str'>
7 在python三种也有两种字符串类型str和bytes
str是unicode
#coding:utf-8
s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中,
#s可以直接encode成任意编码格式
s.encode('utf-8')
s.encode('gbk')
print(type(s)) #<class 'str'>
bytes是bytes
#coding:utf-8
s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中,
#s可以直接encode成任意编码格式
s1=s.encode('utf-8')
s2=s.encode('gbk')
print(s) #林
print(s1) #b'\xe6\x9e\x97' 在python3中，是什么就打印什么
print(s2) #b'\xc1\xd6' 同上
print(type(s)) #<class 'str'>
print(type(s1)) #<class 'bytes'>
print(type(s2)) #<class 'bytes'>
一 定义1个函数
初中数学函数定义：一般的，在一个变化过程中，如果有两个变量x和y，并且对于x的每一个确定的值，y都有唯一确定的值与其对应，那么我们就把x称为自变量，把y称为因变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域
例如y=2*x
python中函数定义：函数是逻辑结构化和过程化的一种编程方法。
1 python中函数定义方法： 2 3 def test(x): 4 "The function definitions" 5 x+=1 6 return x 7 8 def:定义函数的关键字 9 test：函数名 10 （）：内可定义形参 11 "":文档描述（非必要，但是强烈建议为你的函数添加描述信息） 12 x+=1：泛指代码块或程序处理逻辑 13 return：定义返回值
调用运行：可以带参数也可以不带
函数名()
无参函数的定义方法，就是def 后面加上函数名，函数名后面必须要有一个括号
格式：def 函数名():
函数体（也就是函数的功能）
def aa():
return 11
a=aa()
print(a)
def bb():
print(111)
bb()
有参函数的定义方法：def后面加上函数名，函数名的后面括号里传入一个参数。
格式：def 函数名(参数)： （参数可以时任意的数据类型）
函数体（函数的功能）
def aa(a,b):
return a,b
bb=aa(1,2)
print(bb)
def cc(c,d):
pass
cc(1,2)
二 函数的参数
在定义的阶段传入的参数，就叫做形式参数，简称形参，形参相当于一个变量名
在调用阶段传传入的参数，就叫做实在参数，简称实参，实参相当于一个变量名的值
def aa(a): #a就是一个形参
return a
bb=aa(5) #5 就是一个实参
print(bb)
注意：在定义 阶段时可以传人多个参数，但是在定义阶段传入几个形参（*）星号除外，在调用阶段就传入几个形参。
三 函数里面的return
return：返回内容，也可以当终止符使用，一个函数只要遇见了return，执行完return，就会终止。
def aa():
print(123)
return
print(456)
bb=aa()
print(bb)
调用时返回none的现象：1 直接返回的时None
2 没有return这个关键字
3 返回的内容为空
def aa():
pass
a=aa()
print(a)
def bb():
return
b=bb()
print(b)
def cc():
return None
c=cc()
print(c)
return可以返回多个内容，每个内容之间用逗号隔开，在调用时返回的值会以一个元组的格式返回。返回的值可以为任意的内容
def aa():
return 1,[2],'3',{4},(5),{6:7}
a=aa()
print(a)
接收返回值：
一个值接收，直到调用时遇见第一个return，就会返回第一个return返回的内容，然后终止这个函数
def aa(x):
return x
return x+x
a=aa(1)
print(a)
多个值接受，返回的变量有几个，就要用几个值去接收返回的内容。
def bb(x,y,z):
return x,y,z
b=bb(2,5,0)
print(b)
函数里如果有print（）打印，直接可以用函数名后面跟上一个括号去执行这个函数，如果在定义时函数传入了参数，在执行的时候也要传入相对应个数的参数值。
def a():
print(123)
a()
def b(x,y):
print(x,y)
b(3,4)
补充：
（1）.编程语言中的函数与数学意义的函数是截然不同的俩个概念，编程语言中的函数是通过一个函数名封装好一串用来完成某一特定功能的逻辑，数学定义的函数就是一个等式，等式在传入因变量值x不同会得到一个结果y，这一点与编程语言中类似（也是传入一个参数，得到一个返回值），不同的是数学意义的函数，传入值相同，得到的结果必然相同且没有任何变量的修改(不修改状态)，而编程语言中的函数传入的参数相同返回值可不一定相同且可以修改其他的全局变量值（因为一个函数a的执行可能依赖于另外一个函数b的结果，b可能得到不同结果，那即便是你给a传入相同的参数，那么a得到的结果也肯定不同）
（2）.函数式编程就是：先定义一个数学函数(数学建模)，然后按照这个数学模型用编程语言去实现它。至于具体如何实现和这么做的好处，且看后续的函数式编程。
执行时不依赖与外部调用者传入的的参数就能执行。定义为无参函数
函数的执行依赖于调用者传入的参数才能执行时定义为有参函数。
2 为何使用函数
- 代码重复过多，一个劲的copy and paste不符合高端程序员的气质
- 如果日后需要修改发邮件的这段代码，比如加入群发功能，那你就需要在所有用到这段代码的地方都修改一遍
-
总结使用函数的好处：
1.代码重用
2.保持一致性，易维护
3.可扩展性
1 while True： 2 if cpu利用率 > 90%: 3 #发送邮件提醒 4 连接邮箱服务器 5 发送邮件 6 关闭连接 7 8 if 硬盘使用空间 > 90%: 9 #发送邮件提醒 10 连接邮箱服务器 11 发送邮件 12 关闭连接 13 14 if 内存占用 > 80%: 15 #发送邮件提醒 16 连接邮箱服务器 17 发送邮件 18 关闭连接
3 函数和过程
过程的定义：过程就是简单特殊没有返回值的函数
这么看来我们在讨论为何使用函数的的时候引入的函数，都没有返回值，没有返回值就是过程，没错，但是在python中有比较神奇的事情
1 def test01(): 2 msg='hello The little green frog' 3 print msg 4 5 def test02(): 6 msg='hello WuDaLang' 7 print msg 8 return msg 9 10 11 t1=test01() 12 13 t2=test02() 14 15 16 print 'from test01 return is [%s]' %t1 17 print 'from test02 return is [%s]' %t2
总结：当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，
所以在python中即便是过程也可以算作函数。
1 def test01():
2 pass
3
4 def test02():
5 return 0
6
7 def test03():
8 return 0,10,'hello',['alex','lb'],{'WuDaLang':'lb'}
9
10 t1=test01()
11 t2=test02()
12 t3=test03()
13
14
15 print 'from test01 return is [%s]: ' %type(t1),t1
16 print 'from test02 return is [%s]: ' %type(t2),t2
17 print 'from test03 return is [%s]: ' %type(t3),t3
总结：
返回值数=0:返回None
返回值数=1:返回object
返回值数>1:返回tuple
显示返回值，函数里面可以多条return，但只能执行第一条。后面的全都终止掉了。
return返回最大值
返回最大值的倍数，这里面返回20的10倍
