python基础学习（一）
不积硅步，无以至千里。基础的学习越加透彻，才能更清楚的理解和分析需求，我贯彻基础学习“永无止境”的理念，故把自学的知识梳理在博客中，基础学习篇无限更新。
python介绍
python是一种动态解释型的强类型定义语言。
动态：python变量类型不在声明时指定，而是通过赋值的数据类型确定变量类型。有一种后指定的意思，举个例子：两个人A和B选择书情形，若先给A定义文科生，再“协定”他选择语文书，这种形式被称之为静态；若直接“给”B一本数学书，则认定B为理科生，这种形式被称为动态。
解释型：python代码单行执行。举个例子：一个不懂英文的人A想要找人B来帮他翻译一本纯英文文档的情形，B有两种选择：
1.B一句一句翻译给A听，这种形式为解释型（一句一句解释给A听）；
2.B准备一下翻译完整个文档，再给A听，这种形式称为编译型。
OK，随之而来的优缺点，显而易见。解释型：B一句一句翻译，开发效率高，A听完整份英文文档，运行效率低；编译型：B通篇翻译完，开发效率低；A通篇一次听完，运行效率高。提个问题：A在两种方式听文档的过程中，发现结果不符合自己的推测，中间某个部分出现问题（bug），对B来说，有何感想？
语言学习方法
编程语言也是一种语言，就如同我们学习的汉语、英语，没有什么神奇的地方。先学习字，再到组词，造句，作文，中间穿插部分语法规则，可以理解文章都是积累而成，同样，编程也是一种积累的过程，好词好句摘，好文背，需要透彻理解语法，理解他人好文的精髓之处，学以致用。又有不同之处，编程好文都是逻辑性很强的，抛却感性的天马行空，一切按清晰流程来表现出来的，所以学习过程中，学习画流程图和思维导图是非常有必要的，这势必会帮助理清思路，就如同好文形成之前的提纲。
基础数据类型
- 整型（int）
整型就是整数类型，例如：1，2，3，4，...
注：我们默认使用的整数都是十进制数，这点要清楚。python中二进制表示：0b，八进制表示：0o，十六进制表示：0x，分别使用bin(),oct(),hex()转化十进制成为各种进制数。
1 >>> bin(10) 2 '0b1010' 3 >>> oct(10) 4 '0o12' 5 >>> hex(10) 6 '0xa'
- 浮点型（float）
浮点型是指浮点数类型，例如：1.0，1.1，1.21，...
注：浮点型和整型通过运算以后的结果为浮点型。另外需要了解IEEE 754浮点数算术标准，对小数精度要求高，需要使用decimal模块。
1 integer_number = 1 2 float_number = 2.0 3 integer_number = 1 4 float_number = 2.0 5 addition = integer_number + float_number 6 addition 7 >>>3.0 8 d_value = float_number - integer_number 9 d_value 10 >>>1.0 11 product = float_number * integer_number 12 product 13 >>>2.0 14 quotient_value = float_number / integer_number 15 quotient_value 16 >>>2.0
- 布尔型（bool）
布尔型就是布尔值，布尔值只有两个True和False。
注：布尔值存在逻辑真值的说法，表示方法是True和False，1和0可表示其逻辑真值，即1代表True，0代表False。同理，任何非0或者非空的数据类型都可表示True，反之，表示False。另外需要注意，这里逻辑真值是无法等同的，只是逻辑上表示同样的真假。False的逻辑真值有：None、0、0.0、Fasle、0j、‘’、[]、（）、set()、{}。
1 >>> [] ==False 2 False 3 >>> set() == False #空集合的表示 4 False 5 >>> {} == False 6 False 7 >>> () == False 8 False 9 >>> '' == False 10 False 11 >>> 2 == True 12 False 13 >>> (1,) == True #单个元素的元组表示 14 False 15 >>> 1 == True # 注意 16 True 17 >>> 0 == False #注意 18 True
- 复数型（complex）
复数型是指复数，复数 = 实部 + 虚部，例如： 1+1.5j，1.5j是虚数表示形式，为虚部。
注：工程学中，虚数使用j作为表示，而基础数学中，使用i作为表示，注意区分。
运算符
运算符是通过特定的符号进行通用协议上的运算，优先级是运算自左向右进行，哪一部分要优先运算的规定，通常而言，算术运算符>关系运算发>逻辑运算符
- 算术运算符
算术运算符就是我们数学中平常的加减乘除一类，下面详细了解一下python中基本算术运算符：+、-、*、/、%、**、//。
注：/ 中0不能作为除数，这个是不可忘记的；
% 表示取余 例如：5%3 商为1，余数为2；
** 表示幂次方，例如：3的平方：3**2，4的三次方：4**3；
// 表示整除，可以认为地板除，向下取整，例如：5/3 结果为1.6666...，而5//3 结果为1，表现更像是取商，如同%运算。
1 >>> 5 % 3 2 2 3 >>> 3 ** 2 4 9 5 >>> 4 ** 3 6 64 7 >>> 5 // 3 8 1
运算优先级：*、/、%、**、// 同级，+、-同级。
- 关系运算符
关系运算符：==、!=、>=、<=、>、<，关系运算符其实就是比较大小的问题，例如：A和B比较：A == B、 A !=B、A >=B、A <=B、A<B、A>B返回结果为bool值True或者False。
运算优先级：关系运算符都处于同级。
- 逻辑运算符
逻辑运算符有：not、and、or，运算结果返回bool值True或者False，当然如果操作数都不是bool值，逻辑真值就突出表现出来了。
1 >>> not True 2 False 3 >>> not 2 4 False 5 >>> not False 6 True 7 >>> not None 8 True 9 >>> 1 and 0 # and运算：同真为真，一假即假。 10 0 11 >>> 2 or 0 # or运算：同假为假，一真即真 12 2 13 >>> 1 and 2 #1为真，and同真才为真，程序需要看到后面操作数再返回 14 2 15 >>> 1 or 2 #1为真，or一真为真，程序走到第一个操作数为真，直接返回 16 1 17 >>> 2 and True #逻辑真值和bool值，返回什么由逻辑决定 18 True 19 >>> 2 or False 20 2 21 >>> False or 2 22 2
序列数据类型
- 字符串类型（String）
字符串说简单点就是一串字符使用 ‘ ’（单引号）或者“ ”（双引号）括起来，考虑太多没意义，就是‘ ’（单引号）括起来的一串字符。
1 >>> "Just'in" #当字符串中出现‘’(单引号)或者“”（双引号）时，交替使用 2 "Just'in" 3 >>> 'Just"in' 4 'Just"in'
要了解字符串，先了解一下字符什么意思。提出一个概念：字符和字节。计算机嘛，只认识0和1两种状态，为什么这么说？我的理解是对于一个机器而言，只有断电和上电，稍显高级一点能够区分高电平和低电平，使用0和1表示两种状态，一般而言，0表示断电和低电平，1表示上电和高电平。如此复杂的生活和生产情景，仅仅使用两种状态表示计算机也就无法迈进我们的生活了，举个例子：使用计算机让A和B比大小，0表示小，1表示大，如果A和B相等怎么办？这个时候引入的编码思想，简直是计算机领域的马克思主义思想，注意，我这里提到的是编码思想，一段理论上升到思想的高度，其重要性不言而喻。
举个例子感受一下编码思想：说一个国王在酒宴上发现100桶酒中有1桶酒被坏人下了毒药，国王很生气，下令让看守酒的侍卫试酒，找出哪一桶是毒酒，一个侍卫可以试多桶酒，多个侍卫也可以试一桶酒，问怎样可以让尽量少的侍卫最少时间内参与试酒找出毒酒？
一维思维：100桶酒，一人一桶试酒。 结果：100人
二维思维：100桶酒摆成10*10的方阵。 结果：20人
三维思维：100桶酒摆成5*5*4的立方体。 结果：14人
能想到三维解决问题，已经不简单了吧。
编码思维：100桶酒，每个人按照转身和不转身表示1和0，给100桶酒编号1-100，2**7 = 128，0000001表示试到1号桶，01100100表示试到100号桶。 结果：7人
上面的编码思维在没有认识编码以前可能不太理解，解释一下：对0和1不限位次组合可以表示N种状态：1位_ 可以是0或者1表示两种状态，2位_ _ 可以是00、01、10、11四种状态，3位_ _ _ 可以是八种状态，n位就可以表示2**n种状态了。注意，我提到的一直是状态，这个状态可以是数字，文字，符号，只要协商一致（协议），相互就可以理解了。举个例子：我们协商3位表示一个字符，000表示P，001表示Y，010表示T，011表示H，100表示O，101表示N，那000001010011100可以轻易解释为：PYTHON，符号相同。当然这只是我们的协商，算不得通用。数字表示：000表示0，001表示1，010表示2，011表示3，100表示4，100100表示0*2**0+0*2**1+1*2**2+0*2**3+0*2**4+1*2**5=36（其实就是位由右至左1，2，4，8，16，32，64，...，乘以0或者1再求和的问题），这种数字表示方法不是我们协商而定的，是通用的表示方法，我们称为二进制表示，至于八进制表示就是位由右至左1，8，64，...，而像二进制每个比特位是0或者1，不超过2，由0和1两种，八进制是0-7表示不超过8，十六进制类推。OK，那么1位，2位，这个位就是所谓的比特位。继续延申，我们知道英文的基础就是26个字母，算上大小写为52个，还有一些特殊符号：+、-、*、/等等一共127个，2**7=128，使用7个比特位就可以表示，但是考虑后续补充，预留1位，这就是ASCII编码。ASCII编码一共使用8个比特位，最左边一位始终为预留位，表示为0。计算机的发明者是英语为母语的人，他认为预留1位，2**8 = 512，去除英语使用的127个，剩余的完全够其他语言使用或者其他状态表示，然而，亚洲语种的出现，例如汉语，512个都完全不够，汉字的数量90000多，我们就需要增加比特位数进行编码，比特位的增多势必影响表示方法的复杂，为了简便表示我们按照最早的ASCII编码8个比特位（bit）记为1个字节（byte），就如同克（g）和千克（kg），表示大质量的物体，我们可以使用kg表示，这样一来，ASCII码使用8bit表示1个字符，即1个字节表示1个字符。那么增加多少位呢？Unicode编码出现了，Unicode编码认为统一万国文字，全部使用4个字节（32bit）表示字符，一个汉字4个字节，一个英文字母也是4个字节，但是考虑一下，2**32是42亿，完全超了，这种表示造成了极大的资源浪费（硬件存储：按位存储和按字节存储，即耗费硬件资源）。演变至今，UTF-8编码出现，UTF-8编码规定一个英文字符使用1个字节表示，一个汉字使用3个字节表示（2**24=16777216），UTF-8这种区分英文和汉字的形式被称为可变长编码。
1 >>> empty_str = '' # 空字串的表示方法 2 >>> empty_str 3 '' 4 >>> one_str = '1' # 单字符的字符串的表示方法 5 >>> one_str 6 '1' 7 >>> test_str = '[1,2,3,4]' # 基本数据类型和序列数据类型都可以作为字符，自己尝试 8 >>> test_str 9 '[1,2,3,4]'
上文核心梳理：比特位、字节、字符、数字表示（二进制、八进制、十进制、十六进制）、文字和符号表示（ASCII编码、Unicode编码、UTF-8编码）
比特位：01010101010，每一个0或者1表示1个比特位
字节：01010101，8个比特位表示1个字节（8bit = 1Byte，1KB = 1024 Bytes，1MB = 1024KB，1GB = 1024MB，1TB = 1024GB，1PB = 1024TB）
注：bit，Byte，KB，MB，GB，TB，PB就如同g，kg，ton之间的单位换算。
字符：每一个数字、符号、字母、汉字等文字代表一个字符。
数字表示
十进制：1，2，3，15，48，...，我们平时使用的数字表示就是十进制表示
二进制：0b011100010，0b（零b）为二进制标志，使用0或者1占据每个比特位，不能超过2。换算为十进制的方法：比特位由右至左分别为1，2，4，8，16，...，（2的n-1次幂，n为右至左第n位），乘以各比特位上的实际数值，最后加和。例如：0b101 ：1*2**(1-1)+0*2**(2-1)+1*2**(3-1) = 1*1+0*2+1*4 = 5。
八进制：0o0123456701，0o（零o）为八进制标志，使用0-7之间的数占据每个比特位，不能超过8。换算为十进制的方法：比特位由右至左分别为1，8，64，512，...，（8的n-1次幂，n为右至左第n位），乘以各比特位上的实际数值，最后加和。例如：0o201 ：1*8**(1-1)+0*8**(2-1)+2*8**(3-1) = 1*1+0*8+2*64= 129。
十六进制：0x0158ADF01，0o（零x）为十六进制标志，使用0-9之间的数和A(10)、B(11)、C(12)、D(13)、E(14)、F(15)占据每个比特位，不能超过16。换算为十进制的方法：比特位由右至左分别为1，16，256，...，（8的n-1次幂，n为右至左第n位），乘以各比特位上的实际数值，最后加和。例如：0oB01 ：1*16**(1-1)+0*16**(2-1)+11*16**(3-1) = 1*1+0*16+11*256= 2817。
文字和符号表示（英文：一个英文字母，中文：一个汉字）
ASCII编码：英文（8bit----------1个字节）、中文（无表示，毫无根据的认为ASCII编码因中文退出使用）
Unicode编码：英文（32bit----------4个字节）、中文（32bit----------4个字节）
UTF-8编码：英文（8bit----------1个字节）、中文（24bit----------3个字节）
GBK编码：英文（8bit----------1个字节）、中文（16bit----------2个字节） 国人自己的编码方式
1 >>> text = '哈' #python中字符串默认编码为Unicode 2 >>> text.encode('UTF-8') 3 b'xe5x93x88' 4 >>> text.encode('GBK') 5 b'xb9xfe' 6 >>> text = 'a' 7 >>> text.encode('UTF-8') 8 b'a' 9 >>> text.encode('GBK') 10 b'a'
1 def casefold(self, *args, **kwargs): # real signature unknown 2 """ Return a version of the string suitable for caseless comparisons. """ 3 pass 4 ’‘’代码取自builtins.py中str类中的casefold方法，简单说就是源码，有单行注释和功能介绍的大字符串注释‘’‘
- 列表类型（List）
列表是由多个元素组成，多个元素使用 [ ](方括号)包围，由，(逗号)分隔。其中组成列表的元素多种多样，可以这么说，python中存在的数据类型都可以作为列表的元素，有基本数据类型：int、float、bool、complex，可以是序列数据类型：str、list、tuple、set、dict。
1 >> empty_list = [] # 空列表的表示方法 2 >>> empty_list 3 [] 4 >>> one_list = [1] # 单元素列表的表示方法 5 >>> one_list 6 [1] 7 >>> type(one_list) #type()内置函数判断数据类型 8 <class 'list'> 9 >>> full_list = [1, 1.2, True, 1+2j, 'python', [1,2], (1,2), {1,2},{'k1':1, 'k2':2}] #表示列表元素的所有数据类型 10 >>> full_list 11 [1, 1.2, True, (1+2j), 'python', [1, 2], (1, 2), {1, 2}, {'k1': 1, 'k2': 2}]
- 元组类型（Tuple）
列表表示形式像列表，注意我说的是表示形式，元组和列表区别还是有的，不然咱龟叔（python创始人）也没必要搞两个数据类型了。元组只是在列表的基础上，把[ ](方括号)换作了（）(圆括号)，其他一概不变，元素依旧用逗号隔开，所有类型都可以作为元素，仅此而已。
1 >>> empty_tuple = () # 空元组的表示方法 2 >>> empty_tuple 3 () 4 >>> one_tuple = (1,) #单元素的表示方法 5 >>> one_tuple 6 (1,) 7 >>> type(one_tuple) 8 <class 'tuple'> 9 >>> singe_int = (1) # 省略元素后面的逗号，就会表现成一个整数 10 >>> type(singe_int) 11 <class 'int'> 12 >>> full_tuple = (1, 1.2, False, 1+2j, [1,2],(1,2),{1,2},{'k1':1,'k2':2}) 13 >>> full_tuple 14 (1, 1.2, False, (1+2j), [1, 2], (1, 2), {1, 2}, {'k1': 1, 'k2': 2}) 15 >>> simple_tuple = 1,'1',[1,] # 元组省略圆括号的表示形式，记住没有括号的一串元素就是元组！ 16 >>> type(simple_tuple) 17 <class 'tuple'>
注：我在上例解释无括号元组表示中用到了[1,]表示单元素列表，讲解列表时也提出[1]可以表示单元素列表，这两者都是对的，集合、字典都可以这么表示，唯独元组必须加上逗号，所以统一一下，序列数据类型需要逗号分隔的单元素序列，我们一律加上逗号表示。
- 集合类型（Set）
集合的表示形式又像列表和元组的表示形式，只不过这次把包围的括号换作了{ }(花括号)，看到这不禁感叹一门编程语言把符号应用的淋漓尽致，一共三括号，全用了就表示了三种数据类型。另外，不得不提一点，集合的元素是不重复的，重复的元素最终会合成一个元素表示。我还没理解的是，把是把后面重复的删除了，还是后面重复的覆盖了前面的。
此外，非常重要的一点：集合的元素必须是不可变的数据类型。什么是不可变的数据类型，相对于可变类型来说，基本就是无法通过赋值改变其内元素值的类型，记住python中可变数据类型只有3个：list、set、dict，其余都是不可变数据类型。延申说一点，不可变数据类型是可以哈希运算（一种系列算法）的，是hashable数据类型，那么，可变数据类型就是hashable的。
1 >>> empty_set = set() # 空集合的表示方法 2 >>> empty_set 3 set() 4 >>> type(empty_set) 5 <class 'set'> 6 >>> empty_dict = {} # 空字典的表示方法，注意！！！ 7 >>> empty_dict 8 {} 9 >>> type(empty_dict) 10 <class 'dict'> 11 >>> empty_set = {1,} # 单元素集合的表示，下同，不做说明了 12 >>> one_set = {1,} 13 >>> one_set 14 {1} 15 >>> single_set = {1} 16 >>> single_set 17 {1} 18 >>> full_set = {1, 1.2, False, 1+2j, 'python', [1,2]} # 列表是可变数据类型，是unhashable的，不可作为集合元素 19 Traceback (most recent call last): 20 File "<pyshell#37>", line 1, in <module> 21 full_set = {1, 1.2, False, 1+2j, 'python', [1,2], (1,2), {1,2},{'k1':1, 'k2':2}} 22 TypeError: unhashable type: 'list' 23 >>> test_set = {{'k1':1,}} # 字典是可变数据类型，是unhashable的，不可作为集合元素 24 Traceback (most recent call last): 25 File "<pyshell#38>", line 1, in <module> 26 test_set = {{'k1':1,}} 27 TypeError: unhashable type: 'dict' 28 >>> full_set = {1, 1.2, False, 1+2j, 'python', {1,2}} # 集合是可变数据类型，是unhashable的，不可作为集合元素 29 Traceback (most recent call last): 30 File "<pyshell#39>", line 1, in <module> 31 full_set = {1, 1.2, False, 1+2j, 'python', {1,2}} 32 TypeError: unhashable type: 'set' 33 >>> full_set = {1, 1.2, False, 1+2j, 'python',(1,2,3)} # 输出改变了输入集合的元素顺序，集合是无序的 34 >>> full_set 35 {False, 1, 1.2, (1+2j), (1, 2, 3), 'python'}
- 字典类型（Dictionary）
字典从表示形式来看是在集合基础上做出的新突破，字典通过键和值的对应来表示，依旧像集合使用花括号来包围，只是在元素上出现key：value（键：值）的形式。通俗来看，就是用两个元素结合：(冒号)表示成一个字典元素。那么既然说了是两个元素结合一个元素，两个结合的元素分别称为：key（键）和Value（值）。键和值又使用什么数据类型表示：字典中的键要求是不可变数据类型，就如同集合元素一般，而值的类型像列表一样，所有数据类型都可以表示。
1 >>> empty_dict = {} # 空字典的表示方法 2 >>> empty_dict 3 {} 4 >>> type(empty_dict) 5 <class 'dict'> 6 >>> single_dict = {'k':1,} #单元素字典的表示方法 7 >>> single_dict 8 {'k': 1} 9 >>> len(single_dict) #len()内置函数表示数据类型的长度 10 1 11 >>> test_dict = {[1,2]:1} # 列表是可变数据类型，是unhashable的，不能作为字典的键 12 Traceback (most recent call last): 13 File "<pyshell#55>", line 1, in <module> 14 test_dict = {[1,2]:1} 15 TypeError: unhashable type: 'list' 16 >>> test_dict = {{1,2}:1} # 集合是可变数据类型，是unhashable的，不能作为字典的键 17 Traceback (most recent call last): 18 File "<pyshell#56>", line 1, in <module> 19 test_dict = {{1,2}:1} 20 TypeError: unhashable type: 'set' 21 >>> test_dict = {{'k':1}:2} # 字典是可变数据类型，是unhashable的，不能作为字典的键 22 Traceback (most recent call last): 23 File "<pyshell#57>", line 1, in <module> 24 test_dict = {{'k':1}:2} 25 TypeError: unhashable type: 'dict'
操作方法
基本数据类型可以通过运算符进行操作，而序列数据类型通常是一组元素组成的序列，这样的数据类型又会有各自的独特的操作方法，熟悉操作方法才能对数据进行更加准确和有效的分析。
另见 python基础学习篇（二）（三）（四）（五）（六）
备注：序列数据类型操作方法繁多，根据序列数据类型：string,list,tuple;set,dict分为5篇整理。