python变量数据类型总结

小鱼儿 2022-09-27 15:27 244阅读 0赞

> 今日在对比shell编程和python编程时，对于关键字、数据类型、流程控制、异常处理这些有了新的看法，同时对“面向过程编程-函数式编程-面向对象编程”的编程思想也有了一些更深的看法，所以准备将这些依次总结一下，整理如下。
> 
> 对于python数据类型，是变量相关的重要概念，变量三要素：名称、数据类型、操作方法，这三者从三个方面描述了变量，而变量也就成为了整个python编程的重要基础。 
> 我对python中数据类型相关的重要概念，编写在一个python脚本中了，并测试脚本运行正常，通过脚本内容和运行结果，就可以把握python数据类型相关的内容了。
> 
> python数据类型相关脚本内容如下：
> 
> #!/usr/bin/env python
> # _*_ coding:utf-8 _*_
> 
> #################
> #python脚本的核心是关键字，变量，流程控制与编程思想；
> #################
> print '''
> python脚本的核心是关键字，变量，流程控制与编程思想.
> 变量也有三要素：变量名称，变量数据类型，变量操作方法（操作符，操作函数）。
> 
> python数据类型，按照特征可以划分为4个大类：数字类型，序列（数组）类型，映像类型，集合类型。
> 数字类型
> 整型
> 布尔型
> 标准整型
> 长整型
> 非整型
> 双精度浮点型
> 复数
> decimal（不是内建类型）
> 序列类型（shell中叫数组）
> 字符串 str
> 元祖 tuple
> 列表 list
> 映像类型
> 字典 dict
> 集合类型
> 可变集合 set
> 不可变集合 frozenset
> 
> python数据类型，安装可变性（是否可变）划分，可以划分为2大类，7小类。
> 可哈希的，不可变的数据类型
> 数字类型
> 不可变集合 frozenset
> 字符串 str
> 元祖 tuple
> 可变的数据类型
> 字典 dict
> 列表 list
> 可变集合 set
> '''
> 
> #################
> #Number数字类型
> #################
> print "Number数字类型，通常用于存储数字，是最常用的变量类型"
> print "整型 int ，有32位或64位长度范围限制"
> a = 12
> b = -405
> c = 0x3A
> print "整型取值有，正整数{a},负整数{b}，十六进制表示的正整数{c}".format(a=a, b=b, c=c)
> print 
> 
> print "长整型 long integer,数值后面以l或L结尾，没有固定位宽,理论可以表示很长的数值"
> a = 1239884
> b = -68123912
> c = 0xA32B9DDL
> print "长整型有，正长整型{a},负长整型{b}，十六进制表示的长整型{c}".format(a=a, b=b, c=c)
> print
> 
> print "布尔型 boolean，多用于判断场景，只有两个值：true,false"
> a = False
> b = True
> print "布尔型，假为{a}，真为{b}".format(a=a,b=b)
> print
> 
> print "双精度浮点数 double-precision floating,可以直接用十进制或科学计数法表示，每个数占8字节，可以在后面加小数点或e"
> a = 1.7946
> b = -30.
> c = 3e8
> print "双精度浮点数，普通小数{a}，复数浮点数{b}，科学计数法{c}".format(a=a,b=b,c=c)
> print
> 
> print "数值类型的操作符分两类，第一类是算术运算符，如加减乘除；第二类是二进制比特操作，如取反、异或，可以先转化二进制再考虑"
> print '''数值类型，算术操作符有13类
> a+b 加号，也可以单独放在数字前，用于表示正数
> a-b 减号，也可以单独放在数字前，用于表示复数
> a*b 乘号
> a/b 除号，b不能为0，整数相除仍为整数
> a%b 取余数，结果为a除以b后取余数
> a**b 幂操作符，结果为a的b次方
> a//b 取整除符，结果为a除以b后的结果的整数部分
> not a 取反操作，只用于布尔类型
> a>b 判断a是否大于b，结果为true或false
> a a==b 判断a是否等于b，结果为true或false
> a>=b 判断a是否大于等于b，结果为true或false
> a<=b 判断a是否小于等于b，结果为true或false
> '''
> 3 + 6.4
> 2 ** 3
> 6 /4
> 4.0 /2
> 7 // 3
> 9 % 4
> not True
> 3 == 3
> print
> 
> print '''数值类型，比特操作符有6类
> ~A 按二进制取反，安装补码规则，结果数字是-(A+1)
> A&B 并操作
> A|B 或操作
> A^B 异或操作
> A>>B 按比特位右移
> A< '''
> ~30
> 3 & 3
> 3 & 1
> 3 ^ 1
> 3 << 1
> print
> 
> print "除了算术操作符和比特操作符，python还有内置函数可以操作变量，内置函数可以分为能够操作各种数据类型变量的通用函数，和只能操作数据类型变量的特定函数"
> print '''python内置通用函数，即可操作数值类型的变量，也可以操作其他类型的变量
> cmp(A, B) 比较二者的大小，如果前者小则为-1，前者大为1，相等为0
> str(A) 将参数转换Wie可显示的字符串
> type(A) 返回参数的类型对象
> bool(A) 将参数转换为布尔类型
> int(A) 将参数转换为整数类型，以十进制表示
> long(A) 将参数转换为长整型，以十进制表示
> float(A) 将参数转换为浮点类型
> complex(A) 将参数转换为复数类型
> '''
> cmp(23, 12.43)
> cmp(0, -2)
> cmp(0x12, 18)
> str(0x20)
> type(3L)
> type(True)
> type(45+5.4j)
> bool("True")
> long("35")
> print
> 
> #################
> # 序列(数组)类型
> #################
> print "python除了数字类型，序列类型簇也在python中非常重要，序列类似与shell中数组的概念。"
> print "python中序列，就是有序的数列，既然有序，就可以用数组的处理方式，序列包含字符串str，元组tuple，列表三种类型。"
> print "字符串str是有字符组成的序列类型，元组tuple是有任意对象组成的不可修改的序列类型，列表list是有任意对象组成的可修改的序列类型。"
> print "字符串str，元祖tuple，列表list，既然都是有顺序的数列，就有一些共同的操作符和内置函数来操作。"
> print
> 
> print '''
> python中序列运算，字符串，元组，序列都可以进行的运算，主要包括元素提取、序列连接等"
> A[index] 获取序列中第index个元素，取值从0开始，如A[0]
> A[index1:index2] 切片操作，获取序列中从index1到index2-1的子序列，如A[1,4]
> A in B 判断B中是否有A，如果有则为True，如果没有则为False
> A not in B 判断序列B中是否没有A，如果没有则为True，如果有则为False
> A + B 连接序列A和B，生成新的序列并返回
> A * number 将A重复number次，生成新的序列并返回
> A > B 判断A是否大于B，结果为True或False
> A A == B 判断A是否等于B，结果为True或False
> A >= B 判断A是否大于等于B，结果为True或False
> A <= B 判断A是否小于等于B，结果为True或False
> '''
> a = "Hello, I like python practice!"
> print a
> print a[0]
> print a[6:13]
> print a[:13]
> print a[14:]
> print "like" in a
> print a + "!!"
> print a
> print 'ABC' * 3
> b = a[6:13]
> c = [2, 4, "apple", 5]
> print b[1:]
> print b + c[2]
> print
> 
> print '''
> python中，字符串str，元组tuple，列表list都可以使用的内置函数有求长度、类型转换、排序等
> enumerate(A) 对序列A生成一个可枚举对象，对象中每个元素都是一个二位元组，元组内容为(索引号,序列元素)
> len(A) 返回序列A的长度
> list(A) 转换序列A为list列表类型
> max(A) 返回序列A中的最大值
> max(a, b, ...) 返回所有参数中的最大值
> lin(A) 返回序列A中的最小值
> lin(a, b, ...) 返回所有参数中的最小值
> reversed(A) 生成A的反向序列
> sorted(A, func=None, key=None, reverse=False) 对序列A排序，排序规则安装参数func，key，reverse 指定的规则进行
> sum(A, init=0) 对A中的元素求和
> tuple(A) 转换序列A为tuple元组类型
> '''
> a = [34, 2, 1, 887, -0.5]
> print a
> print len(a)
> print max(a)
> print min(a)
> print list(reversed(a))
> print sorted(a)
> print
> 
> 
> 
> #################
> #String字符串类型
> #################
> print "字符串string是由零个或多个字符组成的有限序列，用单引号或双引号表示，具备序列的通用操作方法，也有自己一些独特的操作方法。"
> print "python中字符串的分为普通字符串和Unicode字符串两种，用引号声明的是普通字符串，引号前加u的，就是Unicode字符串，有汉字就应该声明为unicode字符串。"
> str1 = "Hello, World!"
> str2 = u"Hello, I'm Unicode!"
> str3 = u"你好，世界！"
> print str1+str2+str3
> print str1[5]
> print str1[7:]
> str1 = str2 = "Hello, World!"
> str1 = str1 + "Hello, World!"
> print str1
> str1 = str1[:6] + str1[-8:]
> print str1
> print
> 
> print "字符串格式化，是按照指定的规则连接、替换字符串并返回新的符合要求的字符串。"
> print "字符串格式化有%格式化和format格式化两种，format格式化以后会变成主流"
> print '''
> python中%格式化字符串的表格式语法为：
> format_string % string_to_convent
> format_string % (str_to_convent1, str_to_convent2, ...)
> '''
> charA = 65
> charB = 66
> print u"ASCII码65代表： %c " % charA
> print u"ASCII码%d代表： B " % charB
> print '''
> 字符串格式化时，常用的格式化符号表有：
> %c 转为单个字符
> %r 转换为repr()函数表达的字符串
> %s 转换为str()函数表达的字符串
> ...
> %% 输出 %
> 
> python中辅助格式化符号表
> * 定义宽度或小数点的精度
> - 左对齐
> + 对正数输出正值符号“+”
> <sp> 数字大小不足m.n要求时，用空格补位
> # 在八进制数千名显示0，在十六进制前面显示0x,或0X
> 0 数字大小不满足m.n的要求时，用0补位
> m.n m是显示的最小总宽度，n是小数点后的位数
> 
> 格式化字符串中固定内容，处理字母、数字、标点符号，还可以包含不同的显示字符，比如回车、缩进等。
> python中称这些字符为转义字符，常见的转义字符有：
> 转义字符 解释 ASCII值
> \a 响铃（BEL） 7
> \b 退格（BS），将当前位置移到前一列 8
> \f 换页（FF），将当前位置移到下页开头 12
> \n 换行（LF），将当前位置移到下一行开通 10
> \r 回车（CR），将当前位置移到本行开头 13
> \t 水平制表（HT），跳到下一个tab位置 9
> \v 垂直制表（VT） 11
> \\ 代表一个反斜线字符'\' 92
> \' 代表一个单引号（撇号）字符 39
> \" 代表一个双引号字符 34
> \? 代表一个问号 63
> \0 空字符（NULL） 0
> 在字符串中，如果出现转义字符，就会被解释成为相应含义，如果在字符串前面加r，就会禁用转义字符解释
> '''
> print "%#x" % 108
> print '%E' % 1234.567890
> print 'Host: %s\t Port: %d' %('python', 8)
> print 'MM/DD/YY = %02d/%02d/%d' % (2, 1, 95)
> print "Hi, \nToday is Friday."
> print r"Hi, \nToday is Friday."
> print
> 
> print '''
> 字符串str，作为处理数字类型外，python中最重要的常用类型之一，有很多内置函数，常用的str内置函数如下：
> capitalize(): 将字符串中第一个字符大写
> center(width): 返回一个长度至少为width的字符串，并使元字符串的内容居中
> count(str, beg=0, end=len(string)): 返回str在string里面出现的次数，可以用开始索引beg和结束索引end指定搜索的范围
> decode(encoding='UTF-8', errors='strict'): 以encoding指定的编码格式解码string
> encode(encoding='UTF-8', errors='strict'): 以encoding指定的编码格式编码string
> endswitch(obj, beg=0, end=len(string))b,e: 检查字符串是否以obj结束，如果是，返回True，否则返回False；beg和end指定索引范围
> expandtabs(tabsize=8): 把字符串string中的tab符号转成空格，默认的空格数tabsize是8
> find(str, beg=0, end=len(string)): 检测str是否包含在string中，beg和end指定范围
> index(str, beg=0, end=len(string)): 和find类似，如果str不在string中，则报一个异常
> isalnum(): 如果发现有一个字符，并且所有字符都是字母或数字，则返回True，否则返回False
> isalpha(): 如果发现有一个字符并且所有字符都是字母，则返回True，否则返回False
> isdecimal(): 如果可解释为十进制数字，则返回True，否则返回False
> isdigit(): 如果可解释为数字，则返回True，否则返回False
> islower(): 如果字符串中字符都是小写，则返回True，否则返回False
> isnumeric(): 如果可解释为字符，则返回True，否则返回False
> isspace(): 如果字符串是空格，则返回True，否则返回False
> istitle(): 如果字符串是标题化的，则返回True，否则返回False
> isupper(): 如果字符串中的字符都是大写的，则返回True，否则返回False
> ljust(width): 返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
> lower(): 转换所有大写字符为小写
> lstrip(): 截掉string左边的空格
> replace(str1, str2, num=count(str1)): 把string中str1替换成str2，num指定替换的最大次数
> rfind(str, beg=0, end=len(string)): 类似于find，但是从右边开始查找
> rindex(str, beg=0, end=len(string)): 类似于find，但是从右边开始查找
> rjust(width): 返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
> rpartition(str)e: 类似于partition，但是从右边开始查找
> rstrip(): 删除string字符串末尾的空格
> split(str="", num=count(str)): 以str为分割符切片string，如果num有指定的值，则分割num个字符串
> splitlines(num=count('\n')): 按照行分割，返回一个包含各行作为元素的列表，如果num已经指定，则进切片num个行
> startswith(obj, beg=0, end=len(string)): 检查字符串是否以obj开头，则返回True，否则返回False
> strip([obj]): 在string上执行lstrip()和 rstring()
> swapcase(): 翻转string中的大小写
> title: 将字符串标题化，即所有单词都以大写开始，其余字母为小写
> translate(str, del=""): 根据str给出的表转换string的字符，将要过滤的字符，放到del参数中
> upper(): 转换string中的小写字母为大写
> zfill(width): 返回长度为width的字符串，原字符串string右对齐，前面填充0
> '''
> str = "hello world"
> print str.title()
> print str.split()
> print
> 
> #################
> #元组tuple类型
> #################
> print '''
> tuple元组类型，是一种特殊的序列类型，用圆括号()表示，在不同元素间，用逗号隔开。
> python中元组的大小和其中的元素在初始化之后，就不能修改，所以速度也比可以修改的列表list类型操作速度快。
> 如果需要定一个值的常量集，并且唯一操作就是不断的读取，这时用元组truple就非常合适了。
> 元组tuple的操作方法，用()定义后,基本上用序列类型的通用操作方法即可。
> '''
> tuple1 = ('you', 456, 'Englist', 9.56)
> print tuple1[2]
> print tuple1[1:]
> tuple2 = (3, 'you and me')
> tuple1 = tuple1 + tuple2
> print tuple1
> print len(tuple1)
> print
> 
> #################
> #列表list类型
> #################
> print '''
> 列表list，是一种常用的sequence类型，用中括号[]表示，不同元素间，用逗号隔开。
> python中，list的大小和其中的元素在初始化后，可以被再次修改，这是列表list类型和元组tuple类型的主要区别。
> 如果开发中需要定义一组值，并且之后需要不断地进行增、删、改等操作，就比较合适用列表list类型了。
> 列表list用[]定义后，可以用序列的通用操作方法，也可以用专门针对list列表类型的内置函数操作。
> '''
> myList = ['you', 567, 'Englist', 7.56]
> print myList[2]
> print myList[1:]
> myList[2]='France'
> print myList
> print len(myList)
> numList = [2, 8, 16, 1, -6, 52, -1]
> print sorted(myList)
> print myList
> print sum(numList)
> print
> print '''
> 除了序列的通用操作外，列表list专门的内置函数有：
> append(obj): 在list最后一位添加一个对象
> count(obj): 计算读象在list中出现的次数
> extend(seq): 把序列seq的内容添加到list中
> index(obj, i=0, j=len(list)): 计算对象obj在列表中的索引位置
> insert(index, obj): 把读象插入到index指定的位置
> pop(index=-1): 读取并删除index位置的读写，默认为最后一个对象
> remove(obj): 从列表中删除对象obj
> reverse(): 获得反向列表
> list.sort(func=None, key=None, reverse=False)b: 以指定的方式排序列表中的成员
> '''
> numList = [3, 8, 16, 7, -6, 55, -2]
> print numList.count(8)
> numList.insert(1, 9)
> print numList
> print
> 
> 
> #################
> #集合set类型
> #################
> print '''
> 集合set类型，是一个数学概念，表示相互之间无序的一组对象。集合不是序列(数组)，所以是没有序号和位置索引的概念的。
> python中集合分为两种，普通集合和不可变集合，普通集合用set定义，可以用string或list进行初始化；不可变集合用frozenset定义。
> 集合在算术上的运算，包括并集、交集、补集等，普通集合在初始化后，支持并集、交集、补集等运算；不可变集合初始化后，就不能改变。
> '''
> sample1 = set('understand')
> print sample1
> myList = [3, 7, -1.3, 'English', 0, 'python']
> sample2 = set(myList)
> print sample2
> sample3 = frozenset(myList)
> print sample3
> print
> 
> print '''
> 根据集合的定义，在python中，对集合set类型，也有操作符和内置函数两种操作方式。
> python中常用的集合操作符有：
> in 判断包含关系
> not in 判断不包含关系
> == 判断等于
> != 判断不等于
> < 判断绝对子集关系
> <= 判断非绝对子集关系
> > 判断绝对超集关系
> >= 判断非绝对超集关系
> & 交运算
> | 并运算
> - 差运算
> ^ 对称差运算
> |= 执行并运算并赋值
> &= 执行交运算并赋值
> -= 执行差运算并赋值
> ^= 执行对称差运算并赋值
> '''
> myList = [4, 6, -1.1, 'English', 0, 'python']
> sample2 = set(myList)
> sample3 = frozenset([6, 'Englist', 9])
> print 6 in sample2
> print sample2 >= sample3
> print sample2 - sample3
> print sample2 & sample3
> sample3 |= sample2
> print sample3
> print
> 
> print '''
> 可变集合set类型，除了操作符，还可以用内置函数进行集合的增、删、改等操作，函数如下：
> add(): 增加新元素
> update(): 用序列更新集合，序列的每个元素都被添加到集合中
> remove(element): 删除元素
> '''
> sample2 = set([4, 6, -1.3, 'English', 0, 'python'])
> sample2.add('China')
> print sample2
> sample2.update('France')
> print sample2
> sample2.remove(-1.3)
> print sample2
> sample3 = frozenset([6, 'English', 9])
> #sample3.add('Chiand') #会报错，就不在脚本中执行了
> 
> print
> 
> #################
> #字典Dictionary类型
> #################
> print '''
> 字典Dictionary类型，用大括号{}表示，代表一个key/value 存储库，这种键/值存储库工作方式很像映射表，键值映射之间用逗号隔开。
> 给定一个键key，可以在一个字典dict对象中搜索该键对应的值，因此字典被认为是key/value 键值对的列表。
> 字典dict类型比较特殊，所以定义方式也比较特殊，可以使用{key1:value, key2:value, ...}操作也使用内置函数直接操作。
> '''
> dict1 = {'Language':'English', 'Title':'python book', 'Pages':450}
> print dict1
> print dict1['Title']
> dict1['Date'] = '2010-12-25'
> print dict1
> dict1['Language'] = 'Chinese'
> print dict1
> dict2 = {'Language':'English', 'Language':'Chinese'}
> print dict2
> print
> 
> print '''
> python中，对字段dict类型常用的内置函数操作有：
> clear(): 清除字典中的所有键值对
> copy(): 复制字典的一个副本
> fromkeys(seq, val=None)c: 用seq中的元素作为键key创建字典，所有键的值都设为 val,val默认为None
> get(key, default=None): 读取字典中的键 key，返回该键的值；如果找不到该键，则返回default所设的值
> has_key(key): 判断键key在字典中是否存在，如果存在则返回true，否则返回false
> items(): 返回一个包含字典中 (键，值)对元组的列表
> keys(): 返回一个字典中的所有键的列表
> iteritems(): 返回对字典中所有 （键，值）对的迭代器
> iterkeys(): 返回对字典中所有键的迭代器
> itervalues(): 返回对字典中所有值的迭代器
> pop(key[,default]): 读取某键的值，并且从字典中删除该键的值。如果键key不存在且没有设置default，则引发keyerror异常
> setdefault(key,default=None): 设置字典中键key的值为default
> update(dict): 合并字典
> values(): 返回一个包含字典张所有值的列表
> '''
> dict1 = {'Language':'English', 'Title':'python book', 'Pages':450}
> print dict1.get('Title', 'Todo')
> print dict1.get('Author', 'Anonymous')
> print dict1.pop('Language')
> print dict1
> dict2 = {'Author':'David', 'Price':32.00, 'Pages':409}
> dict1.update(dict2)
> print dict1
> print dict1.values()
> print
> 
> 
> 
> 
> 
> 执行结果如下：

> # python py_data_type.py 
> 
> python脚本的核心是关键字，变量，流程控制与编程思想.
> 变量也有三要素：变量名称，变量数据类型，变量操作方法（操作符，操作函数）。
> 
> python数据类型，按照特征可以划分为4个大类：数字类型，序列（数组）类型，映像类型，集合类型。
> 数字类型
> 整型
> 布尔型
> 标准整型
> 长整型
> 非整型
> 双精度浮点型
> 复数
> decimal（不是内建类型）
> 序列类型（shell中叫数组）
> 字符串 str
> 元祖 tuple
> 列表 list
> 映像类型
> 字典 dict
> 集合类型
> 可变集合 set
> 不可变集合 frozenset
> 
> python数据类型，安装可变性（是否可变）划分，可以划分为2大类，7小类。
> 可哈希的，不可变的数据类型
> 数字类型
> 不可变集合 frozenset
> 字符串 str
> 元祖 tuple
> 可变的数据类型
> 字典 dict
> 列表 list
> 可变集合 set
> 
> Number数字类型，通常用于存储数字，是最常用的变量类型
> 整型 int ，有32位或64位长度范围限制
> 整型取值有，正整数12,负整数-405，十六进制表示的正整数58
> 
> 长整型 long integer,数值后面以l或L结尾，没有固定位宽,理论可以表示很长的数值
> 长整型有，正长整型1239884,负长整型-68123912，十六进制表示的长整型171096541
> 
> 布尔型 boolean，多用于判断场景，只有两个值：true,false
> 布尔型，假为False，真为True
> 
> 双精度浮点数 double-precision floating,可以直接用十进制或科学计数法表示，每个数占8字节，可以在后面加小数点或e
> 双精度浮点数，普通小数1.7946，复数浮点数-30.0，科学计数法300000000.0
> 
> 数值类型的操作符分两类，第一类是算术运算符，如加减乘除；第二类是二进制比特操作，如取反、异或，可以先转化二进制再考虑
> 数值类型，算术操作符有13类
> a+b 加号，也可以单独放在数字前，用于表示正数
> a-b 减号，也可以单独放在数字前，用于表示复数
> a*b 乘号
> a/b 除号，b不能为0，整数相除仍为整数
> a%b 取余数，结果为a除以b后取余数
> a**b 幂操作符，结果为a的b次方
> a//b 取整除符，结果为a除以b后的结果的整数部分
> not a 取反操作，只用于布尔类型
> a>b 判断a是否大于b，结果为true或false
> a a==b 判断a是否等于b，结果为true或false
> a>=b 判断a是否大于等于b，结果为true或false
> a<=b 判断a是否小于等于b，结果为true或false
> 
> 
> 数值类型，比特操作符有6类
> ~A 按二进制取反，安装补码规则，结果数字是-(A+1)
> A&B 并操作
> A|B 或操作
> A^B 异或操作
> A>>B 按比特位右移
> A< 
> 
> 除了算术操作符和比特操作符，python还有内置函数可以操作变量，内置函数可以分为能够操作各种数据类型变量的通用函数，和只能操作数据类型变量的特定函数
> python内置通用函数，即可操作数值类型的变量，也可以操作其他类型的变量
> cmp(A, B) 比较二者的大小，如果前者小则为-1，前者大为1，相等为0
> str(A) 将参数转换Wie可显示的字符串
> type(A) 返回参数的类型对象
> bool(A) 将参数转换为布尔类型
> int(A) 将参数转换为整数类型，以十进制表示
> long(A) 将参数转换为长整型，以十进制表示
> float(A) 将参数转换为浮点类型
> complex(A) 将参数转换为复数类型
> 
> 
> python除了数字类型，序列类型簇也在python中非常重要，序列类似与shell中数组的概念。
> python中序列，就是有序的数列，既然有序，就可以用数组的处理方式，序列包含字符串str，元组tuple，列表三种类型。
> 字符串str是有字符组成的序列类型，元组tuple是有任意对象组成的不可修改的序列类型，列表list是有任意对象组成的可修改的序列类型。
> 字符串str，元祖tuple，列表list，既然都是有顺序的数列，就有一些共同的操作符和内置函数来操作。
> 
> 
> python中序列运算，字符串，元组，序列都可以进行的运算，主要包括元素提取、序列连接等"
> A[index] 获取序列中第index个元素，取值从0开始，如A[0]
> A[index1:index2] 切片操作，获取序列中从index1到index2-1的子序列，如A[1,4]
> A in B 判断B中是否有A，如果有则为True，如果没有则为False
> A not in B 判断序列B中是否没有A，如果没有则为True，如果有则为False
> A + B 连接序列A和B，生成新的序列并返回
> A * number 将A重复number次，生成新的序列并返回
> A > B 判断A是否大于B，结果为True或False
> A A == B 判断A是否等于B，结果为True或False
> A >= B 判断A是否大于等于B，结果为True或False
> A <= B 判断A是否小于等于B，结果为True或False
> 
> Hello, I like python practice!
> H
> I like
> Hello, I like
> python practice!
> True
> Hello, I like python practice!!!
> Hello, I like python practice!
> ABCABCABC
> I like
> I likeapple
> 
> 
> python中，字符串str，元组tuple，列表list都可以使用的内置函数有求长度、类型转换、排序等
> enumerate(A) 对序列A生成一个可枚举对象，对象中每个元素都是一个二位元组，元组内容为(索引号,序列元素)
> len(A) 返回序列A的长度
> list(A) 转换序列A为list列表类型
> max(A) 返回序列A中的最大值
> max(a, b, ...) 返回所有参数中的最大值
> lin(A) 返回序列A中的最小值
> lin(a, b, ...) 返回所有参数中的最小值
> reversed(A) 生成A的反向序列
> sorted(A, func=None, key=None, reverse=False) 对序列A排序，排序规则安装参数func，key，reverse 指定的规则进行
> sum(A, init=0) 对A中的元素求和
> tuple(A) 转换序列A为tuple元组类型
> 
> [34, 2, 1, 887, -0.5]
> 5
> 887
> -0.5
> [-0.5, 887, 1, 2, 34]
> [-0.5, 1, 2, 34, 887]
> 
> 字符串string是由零个或多个字符组成的有限序列，用单引号或双引号表示，具备序列的通用操作方法，也有自己一些独特的操作方法。
> python中字符串的分为普通字符串和Unicode字符串两种，用引号声明的是普通字符串，引号前加u的，就是Unicode字符串，有汉字就应该声明为unicode字符串。
> Hello, World!Hello, I'm Unicode!你好，世界！
> ,
> World!
> Hello, World!Hello, World!
> Hello,, World!
> 
> 字符串格式化，是按照指定的规则连接、替换字符串并返回新的符合要求的字符串。
> 字符串格式化有%格式化和format格式化两种，format格式化以后会变成主流
> 
> python中%格式化字符串的表格式语法为：
> format_string % string_to_convent
> format_string % (str_to_convent1, str_to_convent2, ...)
> 
> ASCII码65代表： A 
> ASCII码66代表： B 
> 
> 字符串格式化时，常用的格式化符号表有：
> %c 转为单个字符
> %r 转换为repr()函数表达的字符串
> %s 转换为str()函数表达的字符串
> ...
> %% 输出 %
> 
> python中辅助格式化符号表
> * 定义宽度或小数点的精度
> - 左对齐
> + 对正数输出正值符号“+”
> <sp> 数字大小不足m.n要求时，用空格补位
> # 在八进制数千名显示0，在十六进制前面显示0x,或0X
> 0 数字大小不满足m.n的要求时，用0补位
> m.n m是显示的最小总宽度，n是小数点后的位数
> 
> 格式化字符串中固定内容，处理字母、数字、标点符号，还可以包含不同的显示字符，比如回车、缩进等。
> python中称这些字符为转义字符，常见的转义字符有：
> 转义字符 解释 ASCII值
> 响铃（BEL） 7
> 退格（BS），将当前位置移到前一列 8
> 
> 换页（FF），将当前位置移到下页开头 12
> 
> 换行（LF），将当前位置移到下一行开通 10
> 回车（CR），将当前位置移到本行开头 13
> 水平制表（HT），跳到下一个tab位置 9
> 
> 垂直制表（VT） 11
> \ 代表一个反斜线字符'' 92
> ' 代表一个单引号（撇号）字符 39
> " 代表一个双引号字符 34
> \? 代表一个问号 63
> 空字符（NULL） 0
> 在字符串中，如果出现转义字符，就会被解释成为相应含义，如果在字符串前面加r，就会禁用转义字符解释
> 
> 0x6c
> 1.234568E+03
> Host: python Port: 8
> MM/DD/YY = 02/01/95
> Hi, 
> Today is Friday.
> Hi, \nToday is Friday.
> 
> 
> 字符串str，作为处理数字类型外，python中最重要的常用类型之一，有很多内置函数，常用的str内置函数如下：
> capitalize(): 将字符串中第一个字符大写
> center(width): 返回一个长度至少为width的字符串，并使元字符串的内容居中
> count(str, beg=0, end=len(string)): 返回str在string里面出现的次数，可以用开始索引beg和结束索引end指定搜索的范围
> decode(encoding='UTF-8', errors='strict'): 以encoding指定的编码格式解码string
> encode(encoding='UTF-8', errors='strict'): 以encoding指定的编码格式编码string
> endswitch(obj, beg=0, end=len(string))b,e: 检查字符串是否以obj结束，如果是，返回True，否则返回False；beg和end指定索引范围
> expandtabs(tabsize=8): 把字符串string中的tab符号转成空格，默认的空格数tabsize是8
> find(str, beg=0, end=len(string)): 检测str是否包含在string中，beg和end指定范围
> index(str, beg=0, end=len(string)): 和find类似，如果str不在string中，则报一个异常
> isalnum(): 如果发现有一个字符，并且所有字符都是字母或数字，则返回True，否则返回False
> isalpha(): 如果发现有一个字符并且所有字符都是字母，则返回True，否则返回False
> isdecimal(): 如果可解释为十进制数字，则返回True，否则返回False
> isdigit(): 如果可解释为数字，则返回True，否则返回False
> islower(): 如果字符串中字符都是小写，则返回True，否则返回False
> isnumeric(): 如果可解释为字符，则返回True，否则返回False
> isspace(): 如果字符串是空格，则返回True，否则返回False
> istitle(): 如果字符串是标题化的，则返回True，否则返回False
> isupper(): 如果字符串中的字符都是大写的，则返回True，否则返回False
> ljust(width): 返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
> lower(): 转换所有大写字符为小写
> lstrip(): 截掉string左边的空格
> replace(str1, str2, num=count(str1)): 把string中str1替换成str2，num指定替换的最大次数
> rfind(str, beg=0, end=len(string)): 类似于find，但是从右边开始查找
> rindex(str, beg=0, end=len(string)): 类似于find，但是从右边开始查找
> rjust(width): 返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
> rpartition(str)e: 类似于partition，但是从右边开始查找
> rstrip(): 删除string字符串末尾的空格
> split(str="", num=count(str)): 以str为分割符切片string，如果num有指定的值，则分割num个字符串
> splitlines(num=count('
> ')): 按照行分割，返回一个包含各行作为元素的列表，如果num已经指定，则进切片num个行
> startswith(obj, beg=0, end=len(string)): 检查字符串是否以obj开头，则返回True，否则返回False
> strip([obj]): 在string上执行lstrip()和 rstring()
> swapcase(): 翻转string中的大小写
> title: 将字符串标题化，即所有单词都以大写开始，其余字母为小写
> translate(str, del=""): 根据str给出的表转换string的字符，将要过滤的字符，放到del参数中
> upper(): 转换string中的小写字母为大写
> zfill(width): 返回长度为width的字符串，原字符串string右对齐，前面填充0
> 
> Hello World
> ['hello', 'world']
> 
> 
> tuple元组类型，是一种特殊的序列类型，用圆括号()表示，在不同元素间，用逗号隔开。
> python中元组的大小和其中的元素在初始化之后，就不能修改，所以速度也比可以修改的列表list类型操作速度快。
> 如果需要定一个值的常量集，并且唯一操作就是不断的读取，这时用元组truple就非常合适了。
> 元组tuple的操作方法，用()定义后,基本上用序列类型的通用操作方法即可。
> 
> Englist
> (456, 'Englist', 9.56)
> ('you', 456, 'Englist', 9.56, 3, 'you and me')
> 6
> 
> 
> 列表list，是一种常用的sequence类型，用中括号[]表示，不同元素间，用逗号隔开。
> python中，list的大小和其中的元素在初始化后，可以被再次修改，这是列表list类型和元组tuple类型的主要区别。
> 如果开发中需要定义一组值，并且之后需要不断地进行增、删、改等操作，就比较合适用列表list类型了。
> 列表list用[]定义后，可以用序列的通用操作方法，也可以用专门针对list列表类型的内置函数操作。
> 
> Englist
> [567, 'Englist', 7.56]
> ['you', 567, 'France', 7.56]
> 4
> [7.56, 567, 'France', 'you']
> ['you', 567, 'France', 7.56]
> 72
> 
> 
> 除了序列的通用操作外，列表list专门的内置函数有：
> append(obj): 在list最后一位添加一个对象
> count(obj): 计算读象在list中出现的次数
> extend(seq): 把序列seq的内容添加到list中
> index(obj, i=0, j=len(list)): 计算对象obj在列表中的索引位置
> insert(index, obj): 把读象插入到index指定的位置
> pop(index=-1): 读取并删除index位置的读写，默认为最后一个对象
> remove(obj): 从列表中删除对象obj
> reverse(): 获得反向列表
> list.sort(func=None, key=None, reverse=False)b: 以指定的方式排序列表中的成员
> 
> 1
> [3, 9, 8, 16, 7, -6, 55, -2]
> 
> 
> 集合set类型，是一个数学概念，表示相互之间无序的一组对象。集合不是序列(数组)，所以是没有序号和位置索引的概念的。
> python中集合分为两种，普通集合和不可变集合，普通集合用set定义，可以用string或list进行初始化；不可变集合用frozenset定义。
> 集合在算术上的运算，包括并集、交集、补集等，普通集合在初始化后，支持并集、交集、补集等运算；不可变集合初始化后，就不能改变。
> 
> set(['a', 'e', 'd', 'n', 's', 'r', 'u', 't'])
> set([0, 3, 7, 'python', -1.3, 'English'])
> frozenset([0, 3, 7, 'python', -1.3, 'English'])
> 
> 
> 根据集合的定义，在python中，对集合set类型，也有操作符和内置函数两种操作方式。
> python中常用的集合操作符有：
> in 判断包含关系
> not in 判断不包含关系
> == 判断等于
> != 判断不等于
> < 判断绝对子集关系
> <= 判断非绝对子集关系
> > 判断绝对超集关系
> >= 判断非绝对超集关系
> & 交运算
> | 并运算
> - 差运算
> ^ 对称差运算
> |= 执行并运算并赋值
> &= 执行交运算并赋值
> -= 执行差运算并赋值
> ^= 执行对称差运算并赋值
> 
> True
> False
> set([0, 'python', -1.1, 4, 'English'])
> set([6])
> frozenset([0, 4, 6, 'python', 9, 'Englist', 'English', -1.1])
> 
> 
> 可变集合set类型，除了操作符，还可以用内置函数进行集合的增、删、改等操作，函数如下：
> add(): 增加新元素
> update(): 用序列更新集合，序列的每个元素都被添加到集合中
> remove(element): 删除元素
> 
> set([0, 4, 6, 'python', -1.3, 'China', 'English'])
> set([0, 'a', 'c', 4, 6, 'F', 'python', -1.3, 'n', 'r', 'China', 'English', 'e'])
> set([0, 'a', 'c', 4, 6, 'F', 'python', 'n', 'r', 'China', 'English', 'e'])
> 
> 
> 字典Dictionary类型，用大括号{}表示，代表一个key/value 存储库，这种键/值存储库工作方式很像映射表，键值映射之间用逗号隔开。
> 给定一个键key，可以在一个字典dict对象中搜索该键对应的值，因此字典被认为是key/value 键值对的列表。
> 字典dict类型比较特殊，所以定义方式也比较特殊，可以使用{key1:value, key2:value, ...}操作也使用内置函数直接操作。
> 
> {'Pages': 450, 'Language': 'English', 'Title': 'python book'}
> python book
> {'Date': '2010-12-25', 'Pages': 450, 'Language': 'English', 'Title': 'python book'}
> {'Date': '2010-12-25', 'Pages': 450, 'Language': 'Chinese', 'Title': 'python book'}
> {'Language': 'Chinese'}
> 
> 
> python中，对字段dict类型常用的内置函数操作有：
> clear(): 清除字典中的所有键值对
> copy(): 复制字典的一个副本
> fromkeys(seq, val=None)c: 用seq中的元素作为键key创建字典，所有键的值都设为 val,val默认为None
> get(key, default=None): 读取字典中的键 key，返回该键的值；如果找不到该键，则返回default所设的值
> has_key(key): 判断键key在字典中是否存在，如果存在则返回true，否则返回false
> items(): 返回一个包含字典中 (键，值)对元组的列表
> keys(): 返回一个字典中的所有键的列表
> iteritems(): 返回对字典中所有 （键，值）对的迭代器
> iterkeys(): 返回对字典中所有键的迭代器
> itervalues(): 返回对字典中所有值的迭代器
> pop(key[,default]): 读取某键的值，并且从字典中删除该键的值。如果键key不存在且没有设置default，则引发keyerror异常
> setdefault(key,default=None): 设置字典中键key的值为default
> update(dict): 合并字典
> values(): 返回一个包含字典张所有值的列表
> 
> python book
> Anonymous
> English
> {'Pages': 450, 'Title': 'python book'}
> {'Title': 'python book', 'Price': 32.0, 'Author': 'David', 'Pages': 409}
> ['python book', 32.0, 'David', 409]
> 
> 
> 
>