笔记_Python3学习笔记(n2.1：对象类型

因为超出限制所以分开发布
文章2传送门
Python在线编辑器

这次文章比no.1长许多，no.1是一些常用的IDLE指令和介绍IDLE特性。

Python 不是指Monty Python

#-*- coding: UTF-8 -*-是一个语句，作用是把文字类型改为UTF-8，使变量名能够填写中文

IDE是一个官方变形，这是为了纪念Eric Idle，IDLE又叫交互模式

很多东西绕过了，比如Python生成的.pvc后缀名文件和顶层文件的概念。

算法 + 数据结构 = 程序
Python可以分解成模块、语句、表达式以及对象，如下所示。
1.程序由模块构成
2.模块包含语句
3.语句包含表达式
4.表达式建立并处理对象

====================================================================

为什么使用内置类型
内置对象更容易编写。对于简单任务，内置类型往往能够表现问题领域的所有结构。免费得到了如此强大的工具，例如，集合（列表）和搜索表（字典），可以马上使用他们。

内置对象是扩展的组件。
使用Python的类或者C语言的接口。人工实现的对象往往建立在像列表和字典这样的内置类型基础之上。例如，堆栈（zhàn）数据

内置数据结构往往比定制的数据结构更有效率。
Python优化了用C实现数据结构算法。尽管可以实现属于自己的类似数据类型，但往往很难达到内置数据类型所提供的性能水平

下图常量(literal)的语法，下图所列内容不完整，因为PYthon处理的每一样的东西都是一种对象，例如在Python中进行文本匹配时，创建了模式对象，还有进项网络脚本编程时使用了套结对象。其他类型的对象往往是通过导入或使用模块建立的，而且他们都有各自行为。

常量(literal)：是指语法会生成表达式，有时也叫做常数(constant)。不同是常数不是指不可变的对象或变量

我们通常把上图的对象叫做核心数据类型，因为他在Python语言内部高效创建的，特定语法生成，例如：

>>>'spam

技术上讲你长在运行一个常量表达式，这个表达式返回并生成一个新的字符串对象。这是Python用来生成这个对象的一个特定语法。类似地，一个方括号中的表达式会生成一个列表，大括号中的表达式会建立一个字典等。Python不需要类型声明，运行的表达式的语法决定了创建和使用的对象类型。

Python是动态类型的，它会自动追踪你的类型，而不是要求声明代码。

推荐使用CMD来启动Python噢，更快，字体有点难看

---

====================分割线=====================

列表提供了其他对象的有序结合，而列表是通过键储存对象的。
列表和字典（集合和搜索）都可以嵌套，可以随要求扩展和赠减，并能够包含任意类型的对象

现在简单介绍Python核心对象，在后面深入了解。

数字：

整数：（没有小数部分的小数）
浮点数：（小数，有小数点的数，且小数点右边不为"0"）
更少见的数据：（有虚部的复数、固定精度的十进制数等）图片转字符串比较常见，这是Python非常有趣的部分

Python的IDLE可以直接作为

RESTART: Shell是中断，因为数字太大，所以尴尬的事情出现了

>>> 65498654565468+6546546#加法
65498661112014
>>> 25.6550066*3#乘法
76.9650198
>>> 2 ** 100#开方
1267650600228229401496703205376
>>> len(str(2 ** 10000))#计算2的10000方得数的位数
3011
>>> 

如果你是3.6以前的版本的Python那你就要小心了。
3.1415 * 2的得数可能是很长的一段数，这不是BUG，6.2830000000000004是全精度数值，6.283是友好的形式，3.6我不清楚怎么查看全精度数值了。

>>> import math#常用数学模块
>>> math.pi
3.141592653589793
>>> math.sqrt(85)#求平方根
9.219544457292887
>>> import random#随机数字生成器
>>> random.random()#取0~1之间的随机数
0.732426866439914
>>> random.choice([1,2,3,4])#choice中文是选择
4
>>> math.sqrt(5)#
2.23606797749979

字符串

字符串通过字节集保存，字符串是用来记录文本信息的

序列和操作

>>> S ='spam'#变量S创建时并给赋值
>>> len(S)#len函数也可以验证字符串长度
4
>>> S[0]#
's'
>>> S[1]
'p'

Python是通过偏移量进行编码的，从零开始，第一项索引为0，第二项索引为1，依此类推。

>>> S[-1]
'm'
>>> S[len(S)-1]
'm'

Python支持反向索引，一般来说索引会简单的与字符串相加，所以上面两种方法是等效的。

分片(slice)操作

>>>S
spam
>>> S[1:3]
'pa'

X[ I：J ]，表示取出X中从偏移量为I，直到不包括偏移量为J的内容，结果就是返回一个对象。(例如：S[1:3],从起点2开始，直到第四个字母停下)

>>> S
'spam'
>>> S[1:3]
'pa'
>>> S[1:]
'pam'
>>> S[1:0]
''
>>> S[0:3]
'spa'
>>> S[0:4]
'spam'
>>> S[:3]
'spa'
>>> S[:]
'spam'
>>> 

加号对不同的对象有着不提供的作用：对数字是加法，对字符串是合并

>>> S + 'abc'
'spamabc'
>>> S
'spam'
>>> S * 8
'spamspamspamspamspamspamspamspam'

字符串是具有不可变性的，不能对某一位置进行赋值

>>> S
'Spam'
>>> S[1] = C
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    S[1] = C
NameError: name 'C' is not defined
>>> S = 'z' + S[1:]
>>> S
'zpam'

在核心数据类型中数字、字符串、元组是不可变的；列表和字典可以完全自由的改变

find是一个基本的子字符串查找的操作，没有找到为-1。
replace会对全局搜索和替换
但都不会更改原始字符串

>>> S = 'Spam'
>>> S.find('pa')
1
>>> S.replace('pa','XYZ')
'SXYZm'
>>> S
'Spam'
>>>

split()将一个字符串分割为子字符串,然后将结果作为字符串数组返回。

>>> line = 'aaa,bbb,cccc,dd'
>>> line.split (',')
['aaa', 'bbb', 'cccc', 'dd']
>>> S = 'spam'
>>> S.upper()#大小写变换
'SPAM'
>>> S.isalpha()#测试字符串内容
True

格式化的高级替代功能

可以以一个表达式的形式和一个字符串的方法调用形式使用：

>>> '%s,eggs,and %s' % ('spam','SPAM')#适用于所有版本
'spam,eggs,and SPAM'
>>> '{0},eggs,and{1}'.format('spam','SPAM!')#适用于2.6和3.0版本
'spam,eggs,andSPAM!'

显然第二种方法更实用

寻找帮助

输入dir()列出所有属性

>>> S = 'spam'
>>> dir(S)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

一般来说以双下划线开头并结尾的变量名是用来表示Python实现细节的命名模式。而这个列表中没有下划线的属性是字符串对象能够调用的方法。

dir给出了方法名称，要查询做什么的，你可以将其传递给help函数

>>> help(S.replace)
Help on built-in function replace:

replace(...) method of builtins.str instance
    S.replace(old, new[, count]) -> str

    Return a copy of S with all occurrences of substring
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced.

>>> 

两个反斜杠是转义字符"//"
ord函数(这很好理解，Alt+小键盘97，看看输出的结果是是不是a)

>>> S = 'A\nB\tC'#\n是换行符，/t是缩进
>>> len(S)
5
>>> ord('\n')#/n是一个二进制十字节的ASCII字符串
10
>>> S = 'A\oB\oC'#转义
>>> len(S)
7
>>> 

输入表达式前面和末尾添加双引号（单引号也可以，因为效果是一样的）这是一个多行字符串的实例，中间的引号是为了理解她不会出错

>>> msg = """aaaaaaaaa
bbbbbb'''bbbbbbb
bbb""bbbbbb'bbbbbcccc"""
>>> msg
'aaaaaaaaa\nbbbbbb\'\'\'bbbbbbb\nbbb""bbbbbb\'bbbbbcccc'

字体是Comic Sans MS
如扩觉得很凌乱那就看图片，在引号中也可以包括多行字符或常量。这可以用来嵌入HTML或者XML代码很方便。

Python支持原始(raw)字符串常量，如掉反斜线转意机制（这样的字符串常量是以字母r开头的）

>>> print(r'\n\t\o')
\n\t\o

str字符串支持Unicode字符串形式从而国际化，ASCII是一个简单的Unicode，用bytes字节类型表示原始字节字符串。str处理8位字符串和二进制数据。在Python3中返回一个接受str,从而处理二进制数据的文本和字节。

模式匹配

re模块是一个文本处理的高级工具，这个模块包含了搜索、分隔、替换等调用。

>>> import re
>>> match = re.match('hello[\t]*(.*)world','hello     Python world')
>>> match.group(1)
'     Python '
>>> match
<_sre.SRE_Match object; span=(0, 22), match='hello     Python world'>

用打印字体打印出'hello[\t](.)world'，就会明白了
这个例子目的是搜索字符串，这个子字符串以Hello开始，接着任意字符保存至匹配的group中，最后以world结尾。如果找到把这样的字符串会保存为组（group）。

>>> match = re.match('/(.*)/(.*)/(.*)','/usr/home/lumberjack')
>>> match.groups()#注意有S，这是一个取出下划线操作
('usr', 'home', 'lumberjack')

列表

列表是任意对象位置的有序集合，没有固定大小，大小可变，通过偏移值进行赋值以及其他各种列表方法进行调用。

序列操作

列表是序列的一种，区别结果往往是列表，而不是字符串。

有三个元素的列表：

>>> L = [123,'spam',1.23]
>>> len(L)
3

易语言中有Python列表许多特性，但Python列表更强大。下图只是其他语言的一种表达方法，因为无关，只是展示一下。

>>> L.append('NI')#append() 方法用于在列表末尾添加新的对象。
>>> L#更新
[123, 'spam', 1.23, 'NI']
>>> L.pop(2)#删除列表中第三个，del语句是与pop等效的
1.23
>>> L#更新
[123, 'spam', 'NI']
>>> 

其他的列表方法可以在任意位置插入（insert）元素，按照值移除(remove)元素等，列表是可以改变的，而不是创建一个新的列表。

>>> M = ['bb','aa','cc']
>>> M.sort()#按照升序队列表排序
>>> M
['aa', 'bb', 'cc']
>>> M.reverse()#对列表进行翻转
>>> M
['cc', 'bb', 'aa']
>>> 

边界检查

超出列表末尾外的索引会出错，赋值也如此。

>>> L[99]
Traceback (most recent call last):
  File "<pyshell#40>", line 1, in <module>
    L[99]
IndexError: list index out of range
>>> L[99] = 1
Traceback (most recent call last):
  File "<pyshell#41>", line 1, in <module>
    L[99] = 1
IndexError: list assignment index out of range
>>> 

为了让列表增大可以用append(),C语言中没有边界检查，Python中他会提示一个错误.

嵌套

Python核心数据类型支持任意嵌套，并能够组合对其中嵌套，下图是Python中的多维数组。

对我来说使用偏移值反而更麻烦

>>> M[1]#你可以把他看作一个3*3的2D方阵
[4, 5, 6]
>>> M[1][20]#第2行，第3列
6

列表解析

列表解析表达式（list comprehenssion expression）
矩阵去第二列，矩阵按照行进储存的，所以通过简单的索引即可获得行，使用列表解析可以同样的获得列。

>>> col2 = [row[1] for row in M]
>>> col2
[2, 5, 8]
>>> M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> 

for循环,in定义
列表解析原子集合的概念。它是一个通过对序列中的每一项运动一个表达式来创建一个新列表的方法，每次一个，从左到右，列表解析是编写在括号里中的，并且由使用同一个变量的（这里row）,表达式和循环结构组成。之前这个列表解析表达基本上他就是字面上所讲的："把矩阵M的每个row中的row[1],放在一个新的列表中"。其结果就是一个包含矩阵的第二列的新列表。

>>> [ row[1] + 1 for row in M]#把他搜集到的每个元素都加1
[3, 6, 9]
>>> [row[1] for row in M if row[1] % 2 == 0]
[2, 8]
>>> 

第二行使用if条件语句，通过%求余表达式过滤了结果中的奇数。列表解析创建了新的列表做结果，但是能够在任何可迭(dié)代的，例如我们将会使用的列表解析去进坐标的一个硬编码列表和一个字符串：

>>> diag = [M[i][i] for i in [0,1,2]]
>>> diag
[1, 5, 9]
>>> doubles = [c * 2 for c in 'spam']
>>> doubles
['ss', 'pp', 'aa', 'mm']
>>> 

列表解析以及相关内容函数map和filter比较复杂，就不多讲述了。这里简要说明Python中有简单的工具，也有高级工具。列表解析是一个可先的特性，在实际应用中比较方便，并常常有处理速度上的优势。他们也能够Python任何序列类型中发挥作用，甚至一些不属于的类型。在后面将会学到这一类的内容。

括号中的解析语法也可以用来创建产生所需结果的生成器（例如内置的sum函数，按一种顺序汇总各项）：

>>> M = [[1,2,3],
     [4,5,6],
     [7,8,9]]
>>> G = (sum(row)for row in M)
>>> next(G)        #1+2+3的和
6
>>> next(G)        #4+5+6的和
15

在蟒蛇3中将其包装到列表中会使返回所有值：

>>> list(map(sum,M))
[6, 15, 24]

Python支持字典，这和我以前学过的易语言语法规则是基本一致的。

>>> {sum(row) for row in M}
{24, 6, 15}
>>> {i:sum(M[i]) for i in range(3)}
{0: 6, 1: 15, 2: 24}

蟒蛇3中列表、集合、字典可以用解析创建：

>>>[ord(x) for x in 'spaam']
[115,112,97,97,109]
>>> {ord(x) for x in 'spaam'}
{112, 97, 115, 109}
>>> {x:ord(x) for x in 'spaam'}
{'s': 115, 'p': 112, 'a': 97, 'm': 109}

要理解字典、生成器、集合等这样的对象你必须继续学习

字典

它们不是序列，而是一种映射(mapping)。映射是一个其他对象的集合，但他们通过键而不是相对位置来存储的。实际上，映射并没有任何可靠的从左至右的顺序。他们简单地将键映射到值。字典是Python核心对象集合中的唯一的一种映射类型，也具有可变性--------可以就地改变，并可以随要求增大减小，就像列表那样。

映射操作

常量编写时，字典编写在大括号里，并包含一系列的 "键：值"。
需要键与一些列值关联（例如为了表述某物的属性）的时候，字典很有用。

>>> D = {'food':'Spam','quantity':4,'color':'pink'}创建一个含有三个元素的字典（键分别为'食物、数字、颜色）
>>> D['food']#方括号的元素是键，不能输入相对位置。
'Spam'
>>> D['quantity'] +=2        #添加2到'quantity'值
>>> D
{'food': 'Spam', 'quantity': 8, 'color': 'pink'}

尽管可以使用大括号这种常量形式，最好还是见识一下不同的创建字典的方法：

例如下面创建一个空字典，然后每次以一个键来填写它，与列表进制边界不同，对一个新的字典的赋值会创建该键：

>>> D = {}
>>> D['name'] = 'Bob'
>>> D['job'] ='dev'
>>> D
{'name': 'Bob', 'job': 'dev', 'age': 40}
>>> print(D['name'])
Bob

字典也可以执行搜索，通过索引一个字典往往是Python编写搜索最快的方法。

重访嵌套

字典更复杂一些，下面这个字典一次将所有内容编写进一个变量，将可以记录更多结构化的信息。

>>> rec = {'name':{'first': 'Bob'  ,'last' : 'Smith'},
       'job':['dev','mgr'],
       'age':40.5}

提示：用cmd启动多行语句有省略号
键分别是:"name"、"job"、"age",这是字典的键，而不是偏移值。
值复杂的多。

>>> rec['name']                    #'name' 是一个嵌套的字典
{'first': 'Bob', 'last': 'Smith'}    

>>> rec['name']['last']        #索引嵌套词典
'Smith'

>>> rec['job']                    #'job'是一个嵌套的列表
['dev', 'mgr']
>>> rec['job'][-1]
'mgr'

>>> rec['job'].append('janitor')        #扩大字典中的列表
>>> rec
{'name': {'first': 'Bob', 'last': 'Smith'}, 'job': ['dev', 'mgr', 'janitor'], 'age': 40.5}

job列表是字典所包含的一部分独立的内存，他可以自由的增加或减少。