本篇文章为大家展示了python中有哪些变量数据类型，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

成都创新互联公司从2013年成立，是专业互联网技术服务公司，拥有项目成都网站制作、网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元邵阳做网站,已为上家服务,为邵阳各地企业和个人服务,联系电话:18980820575

      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 < B    判断A是否小于B，结果为True或False

• 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中辅助格式化符号表

• *    定义宽度或小数点的精度

• -    左对齐

• +    对正数输出正值符号“+”

•  数字大小不足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 < B    判断A是否小于B，结果为True或False

• 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中辅助格式化符号表

• *    定义宽度或小数点的精度

• -    左对齐

• +    对正数输出正值符号“+”

•  数字大小不足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(): 返回对字典中所有值的迭代器

• 
  当前文章：python中有哪些变量数据类型
  网页URL：http://hbruida.cn/article/igsoie.html