1.解释器
编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码，然后执行。Python也不例外。同时Python解释器承担了内存管理的复杂任务，这大大简化了应用程序的编写。
Python的解释器有很多，有CPython，IPython，PyPy，Jython，IronPython等。其中 CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。( CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。)
2.语法特点
以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。其他每一行都是一个语句，当语句以冒号:结尾时，缩进的语句视为代码块。
Python程序是大小写敏感的，如果写错了大小写，程序会报错。
3. 数据类型
python能够直接处理的数据类型有：
3.1 整数(包括负整数)：
数学方法表示：1，100，-8080，0，等等。
用十六进制表示： 十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
3.2 浮点数(小数)：
数学方法表示： 如1.23，3.14，-9.01，等等。用科学计数法表示(很大/很小的浮点数)： 把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。注： 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的(除法难道也是精确的？是的！)，而浮点数运算则可能会有四舍五入的误差。
3.3 字符串：
字符串是以单引号'或双引号"括起来的任意文本，需要注意的是 ''或""本身只是一种表示方式，不是字符串的一部分。
(1):如果'本身也是一个字符，那就可以用""括起来
(2):如果字符串内部既包含'又包含"则可以用转义字符\来标识。比如 'I\'m \"OK\"!'
(3):转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。
(4):如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义。比如
>>> print(r'\\\t\\')\\\t\\
(5):字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容。比如
>>> print('''line1... line2... line3''')line1line2line3
(6):字符编码: 字符串比较特殊的是还有一个编码问题
- 历史：
最早计算机采用8bit作为一个字节(byte)，所以一个字节能表示的最大的整数是255(二进制11111111=十进制255)，如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。
最早出现的是ASCII编码，只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号。可是这个要处理中文的话，就需要两个字节，而且还不能和ASCII码冲突。
中国制定了GB2312编码，用来把中文编进去。日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。
之后出现了Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。
所以又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：
- 计算机内存中的运用：
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件.
浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：所以你看到很多网页的源码上会有类似的信息，表示该网页正是用的UTF-8编码。
- python中字符串编码：
在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言
单个字符的编码：
ord()函数获取字符的整数表示chr()函数把编码转换为对应的字符
str和byte的互相转换:
(为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。)：
str-> bytes (encode方法)：
如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。以Unicode表示的str通过encode()方法可以编码为指定的bytes。
ASCII 只能表示英文 ，UTF-8可以表示所有语言。 所以 'ABC'.encode('ascii') ， '中文'.encode('utf-8') 都是对的，可是 '中文'.encode('ascii')就是错的。
bytes -> str (decode方法):
如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
如果bytes中包含无法解码的字节，decode()方法会报错：
如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节。比如：
>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')'中'
- 在python源文件里指定编码
由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。
通常在文件开头写上这两行：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Py
同时必须并且要确保文本编辑器正在使用UTF-8 without BOM编码
(7):格式化：
- 用%运算符就是用来格式化字符串:
有几个%?占位符，后面就跟几个变量或者值，顺序要对应好如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：
>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'有些时候，
字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：
>>> 'growth rate: %d %%' % 7'
growth rate: 7 %'
常见的占位符有：
| 占位符 | 替换内容 |
| %d | 整数 |
| %f | 浮点数 |
| %s | 字符串 |
| %x | 十六进制整数 |
- 使用字符串的format()方法格式化字符串
它会用传入的参数依次替换字符串内的占位符{0}、{1}……，不过这种方式写起来比%要麻烦得多
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)'
Hello, 小明, 成绩提升了 17.1%'
3.4 布尔值：
-
- 用True、False表示布尔值(请注意大小写)
- 布尔值可以用and、or和not运算
- 布尔值经常用在条件判断中，比如：
if age >= 18:print('adult')else:print('teenager')
3.5 空值：
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。
4.数据结构：
4.1列表list：
list是一种有序的集合，可以随时添加和删除其中的元素。
list 特征：
(1): list 里面的元素的数据类型也可以不同
(2): list元素也可以是另一个list，此时list可以看成是一个二维数组，类似的还有三维、四维……数组
s = ['python', 'java', ['asp', 'php'], 'scheme']则s[2][1]就是指php
(3): list中一个元素也没有，就是一个空的list，它的长度为0
(4): python中数组(list/array)不会复制，而是直接引用，此时要特别注意，如下图，b = a，此时改变b就会改变a，所以有时候使用不当，会导致某个变量莫名其妙就发生了变化。
对于单个变量，如：
将数据直接赋值进行复制后，变量前后独立，是位于两块空间内的。但对于数组(list 或 numpy.array)：
相当于引用，是位于同一块空间内的
(5):列表是python内置的可变序列，是包含若干元素的有序连续内存区间，其元素数据类型可以各不相同。当列表增加或删除元素时，列表对象将自动进行内存的扩展或收缩，从而保证元素间没有间隙。python列表内存的自动管理可以大幅减少程序员负担，但是也可能造成列表内大量元素的移动，效率低。所以，除非必要，否则应该尽量从列表尾部进行元素的增删操作。
因为列表的指针使用的是连续内存空间存储-元素不是，所以耗内存。
list可以进行的操作有：
(1):用len()函数可以获得list元素的个数
(2):用索引来访问list中每一个位置的元素，记得索引是从0开始的。
比如classmates[0].
还可以用-1做索引，直接获取最后一个元素。比如classmates[-1] 以此类推，可以获取倒数第2个、倒数第3个。
当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1
(3): 用append()函数往list中追加元素到末尾
(4):用insert()函数把元素插入到指定的位置。
比如 classmates.insert(1, 'Jack')，是指在索引为1的地方插入数据。
(5):用pop()方法删除list末尾的元素
要删除指定位置的元素，用pop(i)方法，其中i是索引位置
(6): 要把某个元素替换成别的元素，可以直接赋值给对应的索引位置
>>> classmates[1] = 'Sarah'>>> classmates['Michael', 'Sarah', 'Tracy']
4.2 元组tuple：
tuple特征：
tuple和list非常类似，但是tuple一旦初始化就不能修改. 因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
tuple的定义用圆括号 (), list的定义用方括号[]
tuple操作：
(1):用len()函数可以获得list元素的个数
(2):用索引来访问list中每一个位置的元素，记得索引是从0开始的。
tuple不能变，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
tuple的陷阱：
(1):定义只有一个元素的tuple的时候，记得加上逗号。 因为括号()既可以表示tuple，又可以表示数学公式中的小括号，如果没有逗号，则会认为是数学公式的小括号，计算结果自然是1。 比如：定义只有一个元素1的tuple，应该是 t = (1,)
(2):tuple变成“可变”了：
比如下面的代码，tuple里面的list的值变了。其实 表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list.
所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t('a', 'b', ['X', 'Y'])
4.3 字典dict：
dict全称dictionary，在其他语言中也称为map，使用键-值(key-value)存储，具有极快的查找速度。
表示：d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
dict特征：
(1):为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。dict就是第二种实现方式。
(2):由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
(3):如果key不存在，dict就会报错。
要避免key不存在的错误，有两种办法，
一是通过in判断key是否存在
>>> 'Thomas' in dFalse
二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：
>>> d.get('Thomas')
>>> d.get('Thomas', -1)-1
(4): dict内部存放的顺序和key放入的顺序是没有关系的
(5):dict的key必须是不可变对象， 这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。 要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。
(6): 和list比较，dict有以下几个特点：
1.查找和插入的速度极快，不会随着key的增加而变慢；
2.需要占用大量的内存，内存浪费多。
所以，dict是用空间来换取时间的一种方法。
dict操作:
(1): 用pop(key)方法删除一个key
(2): 根据key值查询value值 比如： d['Michael']
(3): 用in方法判断是否存在某个key
(4): 用get方法判断是否存在某个key
4.4 集合set：
set和dict类似，也是一组key的集合，但不存储value。
由于key不能重复，所以，在set中，没有重复的key。
set特征：
(1):重复元素在set中自动被过滤
(2): set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set就会报错。
set操作：
(1): 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果，因为set会自动过滤重复元素
(2): 通过remove(key)方法可以删除元素
(3): 两个set可以做数学意义上的交集、并集等操作
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2{2, 3}
>>> s1 | s2{1, 2, 3, 4}
5.条件判断
5.1 if语句的完整形式：
if :
elif :
elif :
else:
5.2 if判断条件还可以简写：
if x: print('True')
只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
5.3 有输入的条件判断：
用input()读取用户的输入，然后进行判断。
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00后')
需要注意因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数
6.循环
6.1 for...in循环
依次把list或tuple中的每个元素迭代出来。比如：
sum = 0for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:sum = sum + xprint(sum)
6.2 while循环
只要条件满足，就不断循环，条件不满足时退出循环。比如：
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
3-4总结：
1.数据类型，数据结构汇总：
| 类型 | 特征 | 表示 | 操作 |
| 整数 | 正整数负整数 | 0xff00 ； 9 | |
| 浮点数 | 小数(正负) | 1.23 ； 1.23e9 | |
| 字符串 | 1.utf-8 编码 2.格式化 %d 整数， %f浮点数， %s字符串， %x十六进制 format() | 1. 'abc' 2. 表示单引号 "'" 3. 转义字符\ 'I\'m \"OK\"!' 4. 用r表示不转义 print(r'\\\t\\') 5. 多行 print('''line1... line2... line3''') | |
| 布尔值 | True、False | ||
| 空值 | None | ||
| list | 1.有序连续内存区间 2.元素的数据类型也可以不同 3.list元素也可以是另一个list 4.不会复制，而是直接引用,所以改变引用的变量的值会导致原来的值变化 | a = [1,2,3] | 1.len()2.索引访问，赋值3.append()4.insert()5.pop() |
| tuple | tuple和list非常类似，但是tuple一旦初始化就不能修改 | t = (1,)t = (1,2,3) | 1.len() 2.索引访问 |
| dict | 1.dict的key必须是不可变对象,而list是可变的，就不能作为key 2.使用键-值(key-value)存储 | d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} | 1.用pop(key)方法删除一个ke y2.根据key值查询value值 比如： d['Michael'] 3.用in方法判断是否存在某个key : 'Thomas' in d 4.用get方法判断是否存在某个key : d.get('Thomas') |
| set | 1.set和dict类似，也是一组key的集合，但不存储value 2.set不可以放入可变对象，list是可变对象，不能放入set3.set会自动过滤重复元素 | set([1, 2, 3]) | 1.通过add(key)方法可以添加元素到set中 2.通过remove(key)方法可以删除元素 3.两个set可以做数学意义上的交集、并集等操作 |
2.不可变对象
str是不变对象，而list是可变对象可变对象：
对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，
比如：
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a['a', 'b', 'c']
不可变对象，比如str，对str进行操作后，str内部的内容不会变化，比如：
>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b'Abc'
>>> a'abc'
a是一个变量，它指向的内容是‘abc’，当我们调用replace方法的时候，作用是在字符串对象‘abc’上，replace方法创建了一个新字符串‘Abc’并返回变量b指向这个新的字符串。所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。