python-基础学习篇（一）

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()转化十进制成为各种进制数。

 >>> bin(10)
 '0b1010'
 >>> oct(10)
 '0o12'
 >>> hex(10)
 '0xa'

• 浮点型（float）

浮点型是指浮点数类型，例如：1.0，1.1，1.21，...

注：浮点型和整型通过运算以后的结果为浮点型。另外需要了解IEEE 754浮点数算术标准，对小数精度要求高，需要使用decimal模块。

 integer_number = 1
 float_number = 2.0
 integer_number = 1
 float_number = 2.0
 addition = integer_number + float_number
 addition
 >>>3.0
 d_value = float_number - integer_number
 d_value
 >>>1.0
 product = float_number * integer_number
 product
 >>>2.0
 quotient_value = float_number / integer_number
 quotient_value
 >>>2.0

• 布尔型（bool）

布尔型就是布尔值，布尔值只有两个True和False。

注：布尔值存在逻辑真值的说法，表示方法是True和False，1和0可表示其逻辑真值，即1代表True，0代表False。同理，任何非0或者非空的数据类型都可表示True，反之，表示False。另外需要注意，这里逻辑真值是无法等同的，只是逻辑上表示同样的真假。False的逻辑真值有：None、0、0.0、Fasle、0j、‘’、[]、（）、set()、{}。

 >>> [] ==False
 False
 >>> set() == False #空集合的表示
 False
 >>> {} == False
 False
 >>> () == False
 False
 >>> '' == False
 False
 >>> 2 == True
 False
 >>> (1,) == True #单个元素的元组表示
 False
 >>> 1 == True   # 注意
 True
 >>> 0 == False  #注意
 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，表现更像是取商，如同%运算。

 >>> 5 % 3
 2
 >>> 3 ** 2
 9
 >>> 4 ** 3
 64
 >>> 5 // 3
 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值，逻辑真值就突出表现出来了。

 >>> not True
 False
 >>> not 2
 False
 >>> not False
 True
 >>> not None
 True
 >>> 1 and 0  # and运算：同真为真，一假即假。
 0
 >>> 2 or 0  # or运算：同假为假，一真即真
 2
 >>> 1 and 2 #1为真，and同真才为真，程序需要看到后面操作数再返回
 2
 >>> 1 or 2 #1为真，or一真为真，程序走到第一个操作数为真，直接返回
 1
 >>> 2 and True #逻辑真值和bool值，返回什么由逻辑决定
 True
 >>> 2 or False
 2
 >>> False or 2
 2

　　运算优先级：not > and > or，其意思从左向右运算，先not，再and，最后or运算。

　　序列数据类型

• 字符串类型（String）

　　字符串说简单点就是一串字符使用 ‘ ’（单引号）或者“ ”（双引号）括起来，考虑太多没意义，就是‘ ’（单引号）括起来的一串字符。

 >>> "Just'in" #当字符串中出现‘’(单引号)或者“”（双引号）时，交替使用
 "Just'in"
 >>> 'Just"in'
 '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这种区分英文和汉字的形式被称为可变长编码。

 >>> empty_str = ''  # 空字串的表示方法
 >>> empty_str
 ''
 >>> one_str = ''  # 单字符的字符串的表示方法
 >>> one_str
 ''
 >>> test_str = '[1,2,3,4]'  # 基本数据类型和序列数据类型都可以作为字符，自己尝试
 >>> test_str
 '[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个字节）   国人自己的编码方式

 >>> text = '哈' #python中字符串默认编码为Unicode
 >>> text.encode('UTF-8')
 b'\xe5\x93\x88'
 >>> text.encode('GBK')
 b'\xb9\xfe'
 >>> text = 'a'
 >>> text.encode('UTF-8')
 b'a'
 >>> text.encode('GBK')
 b'a'    

　　　　注：还有一种大字符串格式，使用‘’‘ ’‘’（三引号）包围的，这种字符串属于预定义格式，一般字符串是占据一个物理行的，要换行需要在换行处使用\（反斜杠），而大字符串是不需要使用\换行的，可以在字符串内部随意换行，也叫多行字符串。更多的，大字符串是被用于多行注释，可以理解为代码是不被执行的，只用作自己备注，或者让他人能了解你代码的功能，说到这，单行注释使用#来标注，同样也是不被执行的。

     def casefold(self, *args, **kwargs): # real signature unknown
         """ Return a version of the string suitable for caseless comparisons. """
         pass
     ’‘’代码取自builtins.py中str类中的casefold方法，简单说就是源码，有单行注释和功能介绍的大字符串注释‘’‘

• 列表类型（List）

　列表是由多个元素组成，多个元素使用 [ ](方括号)包围，由，(逗号)分隔。其中组成列表的元素多种多样，可以这么说，python中存在的数据类型都可以作为列表的元素，有基本数据类型：int、float、bool、complex，可以是序列数据类型：str、list、tuple、set、dict。

 >> empty_list = []  # 空列表的表示方法
 >>> empty_list
 []
 >>> one_list = [1]  # 单元素列表的表示方法
 >>> one_list
 [1]
 >>> type(one_list)  #type()内置函数判断数据类型
 <class 'list'>
 >>> full_list = [1, 1.2, True, 1+2j, 'python', [1,2], (1,2), {1,2},{'k1':1, 'k2':2}]  #表示列表元素的所有数据类型
 >>> full_list
 [1, 1.2, True, (1+2j), 'python', [1, 2], (1, 2), {1, 2}, {'k1': 1, 'k2': 2}]

注：列表中的元素是可以重复。

• 元组类型（Tuple）

　　列表表示形式像列表，注意我说的是表示形式，元组和列表区别还是有的，不然咱龟叔（python创始人）也没必要搞两个数据类型了。元组只是在列表的基础上，把[ ](方括号)换作了（）(圆括号)，其他一概不变，元素依旧用逗号隔开，所有类型都可以作为元素，仅此而已。

 >>> empty_tuple = ()  # 空元组的表示方法
 >>> empty_tuple
 ()
 >>> one_tuple = (1,)  #单元素的表示方法
 >>> one_tuple
 (1,)
 >>> type(one_tuple)
 <class 'tuple'>
 >>> singe_int = (1)  # 省略元素后面的逗号，就会表现成一个整数
 >>> type(singe_int)
 <class 'int'>
 >>> full_tuple = (1, 1.2, False, 1+2j, [1,2],(1,2),{1,2},{'k1':1,'k2':2})
 >>> full_tuple
 (1, 1.2, False, (1+2j), [1, 2], (1, 2), {1, 2}, {'k1': 1, 'k2': 2})
 >>> simple_tuple = 1,'',[1,]  # 元组省略圆括号的表示形式，记住没有括号的一串元素就是元组！
 >>> type(simple_tuple)
 <class 'tuple'>

注：我在上例解释无括号元组表示中用到了[1,]表示单元素列表，讲解列表时也提出[1]可以表示单元素列表，这两者都是对的，集合、字典都可以这么表示，唯独元组必须加上逗号，所以统一一下，序列数据类型需要逗号分隔的单元素序列，我们一律加上逗号表示。

• 集合类型（Set）

　　集合的表示形式又像列表和元组的表示形式，只不过这次把包围的括号换作了{ }(花括号)，看到这不禁感叹一门编程语言把符号应用的淋漓尽致，一共三括号，全用了就表示了三种数据类型。另外，不得不提一点，集合的元素是不重复的，重复的元素最终会合成一个元素表示。我还没理解的是，把是把后面重复的删除了，还是后面重复的覆盖了前面的。

此外，非常重要的一点：集合的元素必须是不可变的数据类型。什么是不可变的数据类型，相对于可变类型来说，基本就是无法通过赋值改变其内元素值的类型，记住python中可变数据类型只有3个：list、set、dict，其余都是不可变数据类型。延申说一点，不可变数据类型是可以哈希运算（一种系列算法）的，是hashable数据类型，那么，可变数据类型就是hashable的。

 >>> empty_set = set()  # 空集合的表示方法
 >>> empty_set
 set()
 >>> type(empty_set)
 <class 'set'>
 >>> empty_dict = {}  # 空字典的表示方法，注意！！！
 >>> empty_dict
 {}
 >>> type(empty_dict)
 <class 'dict'>
 >>> empty_set = {1,}   # 单元素集合的表示，下同，不做说明了
 >>> one_set = {1,}
 >>> one_set
 {1}
 >>> single_set = {1}
 >>> single_set
 {1}
 >>> full_set = {1, 1.2, False, 1+2j, 'python', [1,2]}  # 列表是可变数据类型，是unhashable的，不可作为集合元素
 Traceback (most recent call last):
   File "<pyshell#37>", line 1, in <module>
     full_set = {1, 1.2, False, 1+2j, 'python', [1,2], (1,2), {1,2},{'k1':1, 'k2':2}}
 TypeError: unhashable type: 'list'
 >>> test_set = {{'k1':1,}}  # 字典是可变数据类型，是unhashable的，不可作为集合元素
 Traceback (most recent call last):
   File "<pyshell#38>", line 1, in <module>
     test_set = {{'k1':1,}}
 TypeError: unhashable type: 'dict'
 >>> full_set = {1, 1.2, False, 1+2j, 'python', {1,2}}  # 集合是可变数据类型，是unhashable的，不可作为集合元素
 Traceback (most recent call last):
   File "<pyshell#39>", line 1, in <module>
     full_set = {1, 1.2, False, 1+2j, 'python', {1,2}}
 TypeError: unhashable type: 'set'
 >>> full_set = {1, 1.2, False, 1+2j, 'python',(1,2,3)}  # 输出改变了输入集合的元素顺序，集合是无序的
 >>> full_set
 {False, 1, 1.2, (1+2j), (1, 2, 3), 'python'}

• 字典类型（Dictionary）

　　字典从表示形式来看是在集合基础上做出的新突破，字典通过键和值的对应来表示，依旧像集合使用花括号来包围，只是在元素上出现key：value（键：值）的形式。通俗来看，就是用两个元素结合：(冒号)表示成一个字典元素。那么既然说了是两个元素结合一个元素，两个结合的元素分别称为：key（键）和Value（值）。键和值又使用什么数据类型表示：字典中的键要求是不可变数据类型，就如同集合元素一般，而值的类型像列表一样，所有数据类型都可以表示。

 >>> empty_dict = {}  # 空字典的表示方法
 >>> empty_dict
 {}
 >>> type(empty_dict)
 <class 'dict'>
 >>> single_dict = {'k':1,}  #单元素字典的表示方法
 >>> single_dict
 {'k': 1}
 >>> len(single_dict)   #len()内置函数表示数据类型的长度
 1
 >>> test_dict = {[1,2]:1}  # 列表是可变数据类型，是unhashable的，不能作为字典的键
 Traceback (most recent call last):
   File "<pyshell#55>", line 1, in <module>
     test_dict = {[1,2]:1}
 TypeError: unhashable type: 'list'
 >>> test_dict = {{1,2}:1}  # 集合是可变数据类型，是unhashable的，不能作为字典的键
 Traceback (most recent call last):
   File "<pyshell#56>", line 1, in <module>
     test_dict = {{1,2}:1}
 TypeError: unhashable type: 'set'
 >>> test_dict = {{'k':1}:2}  # 字典是可变数据类型，是unhashable的，不能作为字典的键
 Traceback (most recent call last):
   File "<pyshell#57>", line 1, in <module>
     test_dict = {{'k':1}:2}
 TypeError: unhashable type: 'dict'

　　操作方法

　　基本数据类型可以通过运算符进行操作，而序列数据类型通常是一组元素组成的序列，这样的数据类型又会有各自的独特的操作方法，熟悉操作方法才能对数据进行更加准确和有效的分析。

另见 python基础学习篇（二）（三）（四）（五）（六）

备注：序列数据类型操作方法繁多，根据序列数据类型：string,list,tuple;set,dict分为5篇整理。