菜鸟 学习笔记
# /Users/xxxxx/Desktop/HelloPythion.py
# -*- coding: UTF-8 -*-
# life Is Short, You Need Python!
print ("Hello, Python!")
print ("life Is Short, You Need Python!")
编码
# -*- coding: UTF-8 -*-
默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：
# -*- coding: cp-1252 -*-
上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。
标识符
1,第一个字符必须是字母表中字母或下划线 _ 。
2,标识符的其他的部分由字母、数字和下划线组成。
3, 标识符对大小写敏感。
在 Python 3 中，非 ASCII 标识符也是允许的了。
#python保留字
保留字即关键字，我们不能把它们用作任何标识符名称。
Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
输出如下:
import keyword
print (keyword.kwlist)
注释:
Python中单行注释以 # 开头，实例如下:
print ("Hello, Python!") # 第一个注释
多行注释:
方法1: 书写多个 #
# 注释内容1
#注释内容2
方法2:
'''
注释内容1
注释内容2
'''
方法3:
"""
注释内容1
注释内容2
"""
行与缩进:
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：
if True:
print ("True")
else:
print ("False")
# 以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False") # Answer 缩进与Answer不一致，会导致运行错误
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，例如：
item_one = 1
item_two = 2
item_three = 3
total = item_one + \
item_two + \
item_three
print (total)
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如：
total = ['item_one', 'item_two',
'item_three', 'item_four',
'item_five','sex']
print (total)
数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
bool (布尔), 如 True，False 。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j
a= 1
b = False
b = True
b = False ; b = True
c = 0.001
d = a+3*c+4
print (a,b,c,d)
字符串(String)
python中单引号和双引号使用完全相同。
使用三引号可以指定一个多行字符串。
转义符 '\'
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
Python中的字符串不能改变。
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
字符串的截取的语法格式如下：变量[头下标:尾下标]
sentence = r"\n不\n换\n行\n" # 使用r可以让反斜杠不发生转义
paragraph = """
这是一个段落， 可以由
多行组成
"""
print ( sentence,paragraph)
输出结果为：
\n不\n换\n行\n
这是一个段落， 可以由
多行组成
str='Runoob'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始的后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。但不是Python语法的一部分。
等待用户输入 （？）
执行下面的程序在按回车键后就会等待用户输入：
input("\n\n按下 enter 键后退出。")
# 以上代码中 ，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。
同一行显示多条语句
import sys; x = 'runoob'; sys.stdout.write(x + '\n') # 打点调用什么意思
输出：runoob
多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
expression = False
if expression :
print ('123')
elif expression :
print ('456')
else :
print ('789')
输出：789
Print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
x="a"
y="b"
# 换行输出
print( x )
print( y )
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()
输出：
a
b
---------
a b
import 与 from...import (？)
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
# 导入 sys 模块
import sys
print('================Python import mode==========================');
print ('命令行参数为:')
for i in sys.argv: # sys.argv 不理解
print (i)
print ('\n python 路径为',sys.path)
命令行参数 (不懂)
很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
[ etc. ]
我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数，具体使用可以参照 Python 3 命令行参数。
# 第二课时：Python3 基本数据类型
Python 中的变量不需要声明。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串 print (counter)print (miles)print (name)
输出：1001000.0runoob
多个变量赋值
Python 允许你同时为多个变量赋值。
a = b = c = 1 #创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
print (a,b,c) #(1 1 1)
a=2 ;b=3 ;c=4 print a,b,c #2 3 4
Python 也可以为多个对象指定多个变量。
a, b, c = 1, 2, "runoob" #两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。
print (a,b,c)
输出：1 2 runoob
标准数据类型
Python3 中有六个标准的数据类型：
Number（数字）String（字符串）List（列表）Tuple（元组）Sets（集合）Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（四个）：Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）；
可变数据（两个）：List（列表）、Dictionary（字典）。
Number（数字）Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
a, b, c, d = 20, 5.5, True, 4+3j # d 是复数,声明复数 其虚部只能使用 j 。
print(type(a), type(b), type(c), type(d))
输出：<class 'int'>, <class 'float'>, <class 'bool'>, <class 'complex'>
此外还可以用 isinstance 来判断：
a = 111
isinstance(a, int) # 不懂
isinstance 和 type 的区别在于：
type(a) #输出a的类型
isinstance(a, int) #判断a是不是 int 类型
class A: # 不懂
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
区别就是:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象引用。
del语句的语法是：
var1 = 1
var2 = 10
print (var1,var2)
# del var1[,var2[,var3[....,varN]]]] #，报错，不懂
您可以通过使用del语句删除单个或多个对象。例如：
del var1, var2
print (var1,var2) # 提示 NameError: name 'var1' is not defined 就是说var1 没有被定义，也就是已经被删除
数值运算
5 + 4 # 加法 9
4.3 - 2 # 减法 2.3
3 * 7 # 乘法 21
2 / 4 # 除法，得到一个浮点数 0.5
2 // 4 # 除法，得到一个整数 0
17 % 3 # 取余 2
2 ** 5 # 乘方 32
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
a=1
a='6666'
print type(a)#<type 'str'>
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数。
数值类型实例
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
String（字符串）
Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。
字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：
str = 'Runoob'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串
输出：
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST
Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
print('Ru\noob')
输出：
Ru
oob
print(r'Ru\noob')
输出：Ru\noob
另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。
word = 'Python'
print(word[0], word[5])
print(word[-1], word[-6])
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。
廖雪峰官网学习
文章特色：浅显易懂，知识面广；
用Python开发程序，完全可以一边在文本编辑器里写代码，一边开一个交互式命令窗口，在写代码的过程中，把部分代码粘到命令行去验证，事半功倍！前提是得有个27'的超大显示器！
print ('I' ,'love' ,'bingbing')
print会依次打印每个字符串，遇到逗号“,”会输出一个 空格 ，因此，输出的字符串是这样拼起来的：
>>> print ('100+200 =',100+200)
输出：100+200 = 300
输入和输出 (Input和print,Input/Output,IO)
输入:
print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：
print ('The quick brown fox','jumps over', 'the lazy dog')
print也可以打印整数，或者计算结果：
print (100+200)
们可以把计算100 + 200的结果打印得更漂亮一点：
print ('100 + 200 =', 100 + 200)
输出:100 + 200 = 300
输出:
如果要让用户从电脑输入一些字符怎么办？Python提供了一个raw_input，可以让用户输入字符串，并存放到一个变量里。比如输入用户的名字：
bingYan = input('please enter the name:\n')
bingYan = bingYan+' is so beautiful !'
print (bingYan)
输出:bingbing is so beautiful !
# 在2.x中存在input和raw_input两个类似功能的函数，在3.X认为这是冗余函数，Python3.0系列将raw_input作为垃圾扔掉了。因此我们在运行2.x的程序前需要将其中的raw_input全部替换为input
输入是Input，输出是Output，因此，我们把输入输出统称为Input/Output，或者简写为IO。
Input和print是在命令行下面最基本的输入和输出，但是，用户也可以通过其他更高级的图形界面完成输入和输出，比如，在网页上的一个文本框输入自己的名字，点击“确定”后在网页上看到输出信息。
Python基础
Python是一种计算机编程语言。计算机编程语言和我们日常使用的自然语言有所不同，最大的区别就是，自然语言在不同的语境下有不同的理解，而计算机要根据编程语言执行任务，就必须保证编程语言写出的程序决不能有歧义，所以，任何一种编程语言都有自己的一套语法，编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码，然后执行。Python也不例外。
Python的语法比较简单，采用缩进方式，写出来的代码就像下面的样子：
以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。其他每一行都是一个语句，当语句以冒号 “:” 结尾时，缩进的语句视为 代码块。
缩进有利有弊。好处是强迫你写出格式化的代码，但没有规定缩进是几个空格还是Tab。按照约定俗成的管理，应该始终坚持使用4个空格的缩进。
缩进的另一个好处是强迫你写出缩进较少的代码，你会倾向于把一段很长的代码拆分成若干函数，从而得到缩进较少的代码。
缩进的坏处就是“复制－粘贴”功能失效了，这是最坑爹的地方。当你重构代码时，粘贴过去的代码必须重新检查缩进是否正确。此外，IDE很难像格式化Java代码那样格式化Python代码。
最后，请务必注意，Python程序是大小写敏感的，如果写错了大小写，程序会报错。
数据类型和变量
计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：
整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：
print ('I\'m \"OK" !')
输出 :I'm "OK" !
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print打印字符串看看：
如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：
print ('\\\t\\')
print (r'\\\t\\')
输出 :
\ \
\\\t\\
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用``` ..... ```的格式表示多行内容，可以自己试试：
# 多行字符串``` ..... ```还可以在前面加上r使用，请自行测试。()
print (r'''
\n
\t
\\
''')
输出：
\n
\t
\\
布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：
print (1 > 2)
输出 :False
布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为True，and运算结果才是True：
print (1<2 and 2<3 and 3<4)
输出 :True
not运算是非运算，它是一个单目运算符，把True变成False，False变成True：
print (not 1 > 2)
输出 :True
布尔值经常用在条件判断中，比如：
age = 17
if age >= 18:
print ('could marry !')
else:
print ('cant`t marry !')
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。(自定义数据类型?)
变量
变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。(厉害了!)
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头.(注意：不能带标点)比如：
a=1
t_01=2
answer = True
print (a,t_01,answer)
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量.(厉害了 ！)例如：
a=1
a='bingbinig'
a=True
print (a)
这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：
int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量
和静态语言相比，动态语言更灵活，就是这个原因。
请不要把赋值语句的等号等同于数学的等号。比如下面的代码：
a=10
a=a+10
print (a)
如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。
最后，理解变量在计算机内存中的表示也非常重要。当我们写：
a = 'ABC' 时，Python解释器干了两件事情：
1，在内存中创建了一个'ABC'的字符串；
2，在内存中创建了一个名为a的变量，并把它指向'ABC'。
也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：
a='abc'
b=a
a='def'
print (b)
输出:abc
最后一行打印出变量b的内容到底是'ABC'呢还是'XYZ'？如果从数学意义上理解，就会错误地得出b和a相同，也应该是'XYZ'，但实际上b的值是'ABC'，让我们一行一行地执行代码，就可以看到到底发生了什么事：
执行a = 'ABC'，解释器创建了字符串'ABC'和变量a，并把a指向'ABC'：
执行b = a，解释器创建了变量b，并把b指向a指向的字符串'ABC'：
执行a = 'XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，但b并没有更改：
所以，最后打印变量b的结果自然是'ABC'了。
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。
除法
最后解释一下整数的除法为什么也是精确的。在Python中，有两种除法，一种除法是/：
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
print (10/3)
print (9/3)
输出 :
3.3333333333333335
3.0
还有一种除法是//，称为地板除，两个整数的除法仍然是整数：
你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。
因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：
无论整数做//除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。
print (10//3)
print (10%3)
输出:
3
1
# 请打印出以下变量的值：
n = 123
f= 456.789
s1='hello, word'
s2='hello,\'adam\''
s3=r'hello,"bart"'
s4=r```hello,
lista!```
print (n,f,s1,s2,s3,s4)
输出:
123 456.789 hello, word hello,'adam' hello,"bart" hello,
lista!
小结
Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。
对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向。
注意：Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，例如Java对32位整数的范围限制在-2147483648-2147483647。
Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
字符编码
我们已经讲过了，字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。
因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。
由于计算机是美国人发明的，因此，最早只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。
但是要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
你可以想得到的是，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。
你可以想得到的是，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。
因此，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode标准也在不断发展，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。
现在，捋一捋ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。
字母A用ASCII编码是十进制的65，二进制的01000001；
字符0用ASCII编码是十进制的48，二进制的00110000，注意字符'0'和整数0是不同的；
汉字 中 已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。
你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。
新的问题又出现了：如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。
所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：
用UTF-8编码就能节省空间
从上面的表格还可以发现，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
搞清楚了ASCII、Unicode和UTF-8的关系，我们就可以总结一下现在计算机系统通用的字符编码工作方式：
在计算机内存中，统一使用Unicode编码，当需要 保存到硬盘 或者需要 传输 的时候，就转换为UTF-8编码。
用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：
记事本编辑的时候的存储
Python的字符串
搞清楚了令人头疼的字符编码问题后，我们再来研究Python的字符串。
在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言，例如：
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
ord_A = ord ('A')
chr66 = chr (66)
print (ord_A,chr66)
输出:65 B
如果知道字符的整数编码，还可以用十六进制这么写str,两种写法完全是等价的。：
print ('\u4e2d\u6587')
输出:中文
由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
Python对bytes类型的数据用带b前缀的单引号或双引号表示：
x=b'ABC'
y='ABC'
print (x,y)
输出:b'abc' abc
要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
str1='ABC'.encode('ascii')
str2='中文'.encode('utf-8')
print (str1,str2)
输出:
b'ABC'
b'\xe4\xb8\xad\xe6\x96\x87'
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
例如：'中文'.encode('ascii')
报错：UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
~~~~~~ 20180502 ~~~~~~
在bytes中，无法显示为ASCII字符的字节，用\x##显示。
反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
print (b'ABC'.decode('ascii'))
print (b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))
输出:
ABC
中文
如果bytes中包含无法解码的字节，decode()方法会报错：
print (b'\xe4\xb8\xad\xff'.decode('utf-8'))
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 3: invalid start byte
如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：
要计算str包含多少个字符，可以用len()函数：
print (len('ABC'))
print (len('中文'))
输出:
3
2
len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
print (len(b'ABC'))
print (len(b'\xe4\xb8\xad\xe6\x96\x87'))
print (len('中文'.encode('utf-8')))
输出:
3
6
6
可见，1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。
在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。
由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码 (??????)：
如果.py文件本身使用UTF-8编码，并且也申明了# -*- coding: utf-8 -*-，打开命令提示符测试就可以正常显示中文：
格式化
问题总结：
1，Traceback (most recent call last): File "/Users/zhengxiaowei/Desktop/HelloPythion.py", line 113, in item_two + \NameError: name 'item_one' is not defined
Answer：Traceback 追溯到 实例 item_one 没有被定义；
2，Python 编码过程中怎么输入中文？
Answer：？？？
3，测试Python脚本的时候，发现脚本不能启动了，弹出了“IDLE's subprocess didn't make connection. Either IDLE can't start a subprocess or personal firewall software is blocking the connection.”的警告！！
Answer：？？？
4，invalid syntax
Answer：出现语法错误；
如下会报错：
int a = 1
bool b = False 或 b = false
正确写法：
a = 1
b = False 或 b = True
5，Traceback (most recent call last): File "/Users/zhengxiaowei/Desktop/HelloPythion.py", line 140, in b = false NameError: name 'false' is not defined >>>
Answer： python大小写敏感，假的写法是False，真的写法True，首字母大写，正确写法是：
所以：b = false 提示错误； 正确写法为 ： b = False 或者 b = True
贵有恒！
网友评论