分享python变量数据类型总结

今日在对比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<b    判断a是否小于b，结果为true或false
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<<B  按比特位左移
'''
~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中辅助格式化符号表
*    定义宽度或小数点的精度
-    左对齐
+    对正数输出正值符号“+”
<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<b    判断a是否小于b，结果为true或false
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<<B  按比特位左移
 
除了算术操作符和比特操作符，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中辅助格式化符号表
*    定义宽度或小数点的精度
-    左对齐
+    对正数输出正值符号“+”
<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]

以上就是分享python变量数据类型总结的详细内容，更多请关注其它相关文章！