Python学习 - 数据类型

目录: 

一. Python标准的数据类型

二. Python数据类型 - 数字

三. Python数据类型 - 字符串

四. Python数据类型 - 列表

五. Python数据类型 - 元组

六. Python数据类型 - 字典

七. 数据类型转换

 

一. Python标准的数据类型

在内存中存储的数据可以有多种类型.

例如, 一个人的年龄可以用数字来存储, 他的名字可以用字符来存储.

Python 定义了一些标准类型, 用于存储各种类型的数据.

Python有五个标准的数据类型:

• Numbers(数字)
• String(字符串)
• List(列表)
• Tuple(元组)
• Dictionary(字典)

二. Python数据类型 - 数字

数字数据类型用于存储数值.

他们是不可改变的数据类型, 这意味着改变数字数据类型会分配一个新的对象.

当你指定一个值时, Number对象就会被创建:

var1 = 1
var2 = 10

您也可以使用del语句删除一些对象的引用.
del语句的语法是: 

del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象的引用. 例如: 

del var
del var_a, var_b

Python 2.x 支持四种不同的数字类型:

• int(有符号整型)
• long(长整型[也可以代表八进制和十六进制])
• float(浮点型)
• complex(复数)

一些数值类型的实例:

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

长整型也可以使用小写"L", 但是还是建议您使用大写"L", 避免与数字"1"混淆. Python使用"L"来显示长整型.
Python还支持复数, 复数由实数部分和虚数部分构成, 可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型

Python 3.x 中将long长整型替代了int整形, 支持三种不同的数字类型:

• int(整形) # 相当于Python 2.x 中的long
• float(浮点型)
• complex(复数)

数字类型内置方法:

def selfunc(obj):
    return filter(lambda x: not x.startswith("__"), dir(obj))

a = 10
print(list(selfunc(a))  # 打印a变量下的方法(私有方法不打印)
b = 10.5
print(list(selfunc(b))

# 执行结果
['bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
['as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']

通过上面的代码可以发现, 根据数字具体类型不同, 内置方法也有变化. 

bit_length: 返回一个int类型数据的二进制位数. 例如:

a = 10 
print(a.bit_length())
# 执行结果
4
# 10 的二进制表示为: 1010 
# 这里返回的 4 代表 10 的二进制最大长度为 4

# 待更新其他方法使用说明

 

三. Python数据类型 - 字符串

符串或串(String)是由数字、字母、下划线组成的一串字符.
一般记为 :

s="a1a2···an"(n>=0)

它是编程语言中表示文本的数据类型.

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的, 最大范围是字符串长度少1
• 从右到左索引默认-1开始的, 最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话, 可以使用变量 [头下标:尾下标], 就可以截取相应的字符串, 其中下标是从 0 开始算起, 可以是正数或负数, 下标可以为空表示取到头或尾. 例如:

# Python 3.x

s = "ilovepython"
print(s[1:5])

运行结果: love

当使用以冒号分隔的字符串, python返回一个新的对象, 结果包含了以这对偏移标识的连续的内容, 左边的开始是包含了下边界.
上面的结果包含了s[1]的值l, 而取到的最大范围不包括上边界, 就是s[5]的值p.
加号(+)是字符串连接运算符, 星号(*)是重复操作. 例如:

# Python 3.x

str = "Hello World!"

print(str)  # 输出完整字符串
print(str[0])  # 输出字符串中的第一个字符
print(str[2:5])  # 输出字符串中第三个至第五个之间的字符串
print(str[2:])  # 输出从第三个字符开始的字符串
print(str * 2)  # 输出字符串两次
print(str + "TEST")  # 输出连接的字符串

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

字符串内置方法: 

 capitalize() # 将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。

# Python 3.x
str = "this Is String Example....WOW!!!"
print("str.capitalize() : ", str.capitalize())
# 以上实例输出结果如下：
str.capitalize() : This is string example....wow!!!

 

casefold()  # 将字符串对象中大写字母转换为小写字母

# 待更新

 

center(width[, fillchar])  # 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。

• width -- 字符串的总宽度。
• fillchar -- 填充字符。

# Python 3.x
str = "this is string example....wow!!!";
print("str.center(40, 'a') : ", str.center(40, 'a'))
# 以上实例输出结果如下：
str.center(40, 'a') : aaaathis is string example....wow!!!aaaa

 

count(sub, start= 0,end=len(string)) # 用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

# Python 3.x
str = "this is string example....wow!!!";
sub = "i";
print("str.count(sub, 4, 40) : ", str.count(sub, 4, 40))
sub = "wow";
print("str.count(sub) : ", str.count(sub))
# 以上实例输出结果如下：
str.count(sub, 4, 40) : 2
str.count(sub, 4, 40) : 1

 

encode(encoding='UTF-8',errors='strict')  # 以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。

• encoding -- 要使用的编码，如"UTF-8"。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

# Python 3.x
str = "this is string example....wow!!!"
print("Encoded String: " + str.encode('base64','strict'))
# 以上实例输出结果如下：
Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=

 

decode(encoding='UTF-8',errors='strict')  # 以 encoding 指定的编码格式解码字符串。默认编码为字符串编码。

• encoding -- 要使用的编码，如"UTF-8"。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

# Python 3.x
str = "this is string example....wow!!!"
str = str.encode('base64','strict')
print("Encoded String: " + str)
print("Decoded String: " + str.decode('base64','strict'))
# 以上实例输出结果如下：
Encoded String: dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE=
Decoded String: this is string example....wow!!!

 

endswith(suffix[, start[, end]])  # 用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

• suffix -- 该参数可以是一个字符串或者是一个元素。
• start -- 字符串中的开始位置。
• end -- 字符中结束位置。

#Python 3.x
str = "this is string example....wow!!!";
suffix = "wow!!!";
print str.endswith(suffix);
print str.endswith(suffix,20);
suffix = "is";
print str.endswith(suffix, 2, 4);
print str.endswith(suffix, 2, 6);
# 以上实例输出结果如下：
True
True
True
False

 

expandtabs(tabsize=8)  # 把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。

• tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

# Python 3.x 
str = "this is\tstring example....wow!!!"
print("Original string: " + str)
print("Defualt exapanded tab: " + str.expandtabs())
print("Double exapanded tab: " + str.expandtabs(16))
# 以上实例输出结果如下：
Original string: this is string example....wow!!!
Defualt exapanded tab: this is string example....wow!!!
Double exapanded tab: this is string example....wow!!!

 

find(str, beg=0, end=len(string))   # 检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

# Python 3.x 
str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.find(str2))
print(str1.find(str2, 10))
print(str1.find(str2, 40))
# 以上实例输出结果如下：
15
15
-1

 

format() # 字符串格式化

# 待更新

 

format_map() # 字符串格式化

# 待更新

 

index(str, beg=0, end=len(string)) # 检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

#Python 3.x
str1 = "this is string example....wow!!!"
str2 = "exam"
print(str1.index(str2))
print(str1.index(str2, 10))
print(str1.index(str2, 40))
# 以上实例输出结果如下：
15
15
Traceback (most recent call last):
File "test.py", line 8, in 
print str1.index(str2, 40)
ValueError: substring not found
shell returned 1

 

isalnum()  # 检测字符串是否由字母和数字组成。

# Python 3.x 
str = "this2009" # 没有空格
print(str.isalnum())
str = "this is string example....wow!!!"
print(str.isalnum())
# 以上实例输出结果如下：
True
False

 

isalpha()  # 检测字符串是否只由字母组成。

# Python 3.x 
str = "this" # 没有空格与数字
print(str.isalpha())
str = "this is string example....wow!!!"
print(str.isalpha())
# 以上实例输出结果如下：
True
False

 

isdecimal()  # 检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

# Python 3.x
str = u"this2009"
print(str.isdecimal())
str = u"23443434"
print(str.isdecimal())
# 以上实例输出结果如下：
False
True

 

isdigit()  # 检测字符串是否只由数字组成。

str = "123456" # Only digit in this string
print(str.isdigit())
str = "this is string example....wow!!!"
print(str.isdigit())
# 以上实例输出结果如下：
True
False

 

isidentifier()  # 是不是一个合法的变量名

# 待更新

 

islower()  # 检测字符串是否由小写字母组成。

# Python 3.x
str = "THIS is string example....wow!!!"
print(str.islower())
str = "this is string example....wow!!!"
print(str.islower())
# 以上实例输出结果如下：
False
True

 

isnumeric()  # 检测字符串是否只由数字组成。这种方法是只针对unicode对象。

# Python 3.x
str = u"this2009"
print(str.isnumeric())
str = u"23443434"
print(str.isnumeric())
# 以上实例输出结果如下：
False
True

 

isprintable()  #

# 待更新

 

 

isspace()   # 检测字符串是否只由空格组成。

# Python 3.x
str = " "
print(str.isspace())
str = "This is string example....wow!!!"
print(str.isspace())
# 以上实例输出结果如下：
True
False

 

istitle()  # 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

# Python 3.x
str = "This Is String Example...Wow!!!"
print(str.istitle())
str = "This is string example....wow!!!"
print(str.istitle())
# 以上实例输出结果如下：
True
False

 

isupper()  # 检测字符串中所有的字母是否都为大写。

# Python 3.x
str = "THIS IS STRING EXAMPLE....WOW!!!"
print(str.isupper())
str = "THIS is string example....wow!!!"
print(str.isupper())
# 以上实例输出结果如下：
True
False

 

join(sequence)  # 用于将序列中的元素以指定的字符连接生成一个新的字符串。

• sequence -- 要连接的元素序列。

# Python 3.x
str = "-";
seq = ("a", "b", "c") # 字符串序列
print(str.join( seq ))
# 以上实例输出结果如下：
a-b-c

 

ljust(width[, fillchar]) # 返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

• width -- 指定字符串长度。
• fillchar -- 填充字符，默认为空格。

# Python 3.x
str = "this is string example....wow!!!"
print(str.ljust(50, '0'))
# 以上实例输出结果如下：
this is string example....wow!!!000000000000000000

 

lower()  # 转换字符串中所有大写字符为小写。

# Python 3.x
str = "THIS IS STRING EXAMPLE....WOW!!!"
print(str.lower())
# 以上实例输出结果如下：
this is string example....wow!!!

 

lstrip([chars]) # 用于截掉字符串左边的空格或指定字符。

• chars --指定截取的字符。

# Python 3.x
str = " this is string example....wow!!! "
print(str.lstrip())
str = "88888888this is string example....wow!!!8888888"
print(str.lstrip('8'))
# 以上实例输出结果如下：
this is string example....wow!!!
this is string example....wow!!!8888888

 

maketrans(intab, outtab)   # 用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。

• intab -- 字符串中要替代的字符组成的字符串。
• outtab -- 相应的映射字符的字符串。

# Python 3.x
from string import maketrans # 必须调用 maketrans 函数。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!"
print(str.translate(trantab))
# 以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

 

partition(str) # 用来根据指定的分隔符将字符串进行分割。方法是在2.5版中新增的。
# 如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

# Python 3.x
str = "http://www.w3cschool.cc/"
print(str.partition("://"))
# 输出结果为：
('http', '://', 'www.w3cschool.cc/')

 

replace(old, new[, max])   # 把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

# Python 3.x
str = "this is string example....wow!!! this is really string"
print(str.replace("is", "was"))
print(str.replace("is", "was", 3))
# 以上实例输出结果如下：
thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string

 

rfind(str, beg=0 end=len(string)) # 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

# Python 3.x
str = "this is really a string example....wow!!!"
substr = "is"
print(str.rfind(substr))
print(str.rfind(substr, 0, 10))
print(str.rfind(substr, 10, 0))
print(str.find(substr))
print(str.find(substr, 0, 10))
print(str.find(substr, 10, 0))
# 以上实例输出结果如下：
5
5
-1
2
2
-1

 

rindex(str, beg=0 end=len(string))   # 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

# Python 3.x
str1 = "this is string example....wow!!!"
str2 = "is"
print(str1.rindex(str2))
print(str1.index(str2))
# 以上实例输出结果如下：
5
2

 

rjust(width[, fillchar])  # 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

• width -- 指定填充指定字符后中字符串的总长度.
• fillchar -- 填充的字符，默认为空格。

# Python 3.x
str = "this is string example....wow!!!"
print(str.rjust(50, '0'))
# 以上实例输出结果如下：
000000000000000000this is string example....wow!!!

 

rpartition() #

# 待更新

 

 

rsplit() #

# 待更新

 

 

rstrip([chars])   # 删除 string 字符串末尾的指定字符（默认为空格）.

• chars -- 指定删除的字符（默认为空格）

# Python 3.x
str = " this is string example....wow!!! "
print(str.rstrip())
str = "88888888this is string example....wow!!!8888888"
print(str.rstrip('8'))
# 以上实例输出结果如下：
this is string example....wow!!!
88888888this is string example....wow!!!

 

split(str="", num=string.count(str))  # 通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

• str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num -- 分割次数。

# Python 3.x
str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str.split())
print(str.split(' ', 1 ))
以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

 

splitlines([keepends])  # 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

• keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。

# Python 3.x 
str1 = 'ab c\n\nde fg\rkl\r\n'
print(str1.splitlines())
str2 = 'ab c\n\nde fg\rkl\r\n'
print(str2.splitlines(True))
# 以上实例输出结果如下：
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

 

startswith(str, beg=0,end=len(string)) # 用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置。

# Python 3.x
str = "this is string example....wow!!!"
print(str.startswith( 'this' ))
print(str.startswith( 'is', 2, 4 ))
print(str.startswith( 'this', 2, 4 ))
# 以上实例输出结果如下：
True
True
False

 

strip([chars]) # 用于移除字符串头尾指定的字符（默认为空格）。

• chars -- 移除字符串头尾指定的字符。

# Python 3.x 
str = "0000000this is string example....wow!!!0000000"
print(str.strip('0'))
# 以上实例输出结果如下：
this is string example....wow!!!

 

swapcase()  # 用于对字符串的大小写字母进行转换。

str = "this is string example....wow!!!"
print(str.swapcase())
str = "THIS IS STRING EXAMPLE....WOW!!!"
print(str.swapcase())
# 以上实例输出结果如下：
THIS IS STRING EXAMPLE....WOW!!!
this is string example....wow!!!

 

title()  # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写

# Python 3.x 
str = "this is string example....wow!!!"
print(str.title())
# 以上实例输出结果如下：
This Is String Example....Wow!!!

 

translate(table[, deletechars])  # 根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

• table -- 翻译表，翻译表是通过maketrans方法转换而来。
• deletechars -- 字符串中要过滤的字符列表。

# Python 3.x
from string import maketrans # 引用 maketrans 函数。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!"
print(str.translate(trantab))
# 以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

 

# Python 3.x
from string import maketrans # 引用 maketrans 函数。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!"
print(str.translate(trantab, 'xm'))
# 以上实例输出结果：
th3s 3s str3ng 21pl2....w4w!!!

 

upper()  # 将字符串中的小写字母转为大写字母。

# Python 3.x 
str = "this is string example....wow!!!"
print("str.upper() : ", str.upper())
# 以上实例输出结果如下：
str.upper() : THIS IS STRING EXAMPLE....WOW!!!

 

zfill(width) # 返回指定长度的字符串，原字符串右对齐，前面填充0。

• width -- 指定字符串的长度。原字符串右对齐，前面填充0。

# Python 3.x
str = "this is string example....wow!!!"
print(str.zfill(40))
print(str.zfill(50))
# 以上实例输出结果如下：
00000000this is string example....wow!!!
000000000000000000this is string example....wow!!!

 

 

四. Python数据类型 - 列表

List(列表) 是 Python 中使用最频繁的数据类型.

列表可以完成大多数集合类的数据结构实现. 它支持字符, 数字, 字符串甚至可以包含列表(所谓嵌套).

列表用[ ]标识. 是python最通用的复合数据类型.

列表中的值得分割也可以用到变量[头下标:尾下标], 就可以截取相应的列表, 从左到右索引默认0开始的, 从右到左索引默认-1开始, 下标可以为空表示取到头或尾.

加号(+)是列表连接运算符, 星号(*)是重复操作. 例如: 

# Python 3.x

list = [ "runoob", 786 , 2.23, "john", 70.2 ]
tinylist = [123, "john"]

print(list)  # 输出完整列表
print(list[0])  # 输出列表的第一个元素
print(list[1:3])  # 输出第二个至第三个的元素 
print(list[2:])  # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2)  # 输出列表两次
print(list + tinylist)  # 打印组合的列表

["runoob", 786, 2.23, "john", 70.2]
runoob
[786, 2.23]
[2.23, "john", 70.2]
[123, "john", 123, "john"]
["runoob", 786, 2.23, "john", 70.2, 123, "john"]

列表内置方法: 

append(obj) # 方法用于在列表末尾添加新的对象。

• obj -- 添加到列表末尾的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc']
aList.append( 2009 )
print("Updated List : ", aList)
# 以上实例输出结果如下：
Updated List : [123, 'xyz', 'zara', 'abc', 2009]

 

count(obj) # 方法用于统计某个元素在列表中出现的次数。

• obj -- 列表中统计的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc', 123]
print("Count for 123 : ", aList.count(123))
print("Count for zara : ", aList.count('zara'))
# 以上实例输出结果如下：
Count for 123 : 2
Count for zara : 1

 

extend(seq) # 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

• seq -- 元素列表。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)
print("Extended List : ", aList)
# 以上实例输出结果如下：
Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

 

index(obj) # 函数用于从列表中找出某个值第一个匹配项的索引位置。

• obj -- 查找的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc']
print("Index for xyz : ", aList.index( 'xyz' ))
print("Index for zara : ", aList.index( 'zara' ))
# 以上实例输出结果如下：
Index for xyz : 1
Index for zara : 2

 

insert(index, obj) # 函数用于将指定对象插入列表的指定位置。

• index -- 对象 obj 需要插入的索引位置。
• obj -- 要插入列表中的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc']
aList.insert( 3, 2009)
print("Final List : ", aList)
# 以上实例输出结果如下：
Final List : [123, 'xyz', 'zara', 2009, 'abc']

 

pop(obj=list[-1]) # 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

• obj -- 可选参数，要移除列表元素的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc']
print("A List : ", aList.pop())
print("B List : ", aList.pop(2))
# 以上实例输出结果如下：
A List : abc
B List : zara

 

remove(obj) # 函数用于移除列表中某个值的第一个匹配项。

• obj -- 列表中要移除的对象。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.remove('xyz')
print("List : ", aList)
aList.remove('abc')
print("List : ", aList)
# 以上实例输出结果如下：
List : [123, 'zara', 'abc', 'xyz']
List : [123, 'zara', 'xyz']

 

reverse() # 函数用于反向列表中元素。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()
print("List : ", aList)
# 以上实例输出结果如下：
List : ['xyz', 'abc', 'zara', 'xyz', 123]

 

sort([func]) # 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

• func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

# Python 3.x 
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.sort()
print("List : ", aList)
# 以上实例输出结果如下：
List : [123, 'abc', 'xyz', 'xyz', 'zara']

 

clear() # 清空列表内容

copy() # 浅拷贝列表

# 待更新深浅拷贝的区别

 

五. Python数据类型 - 元组

元组是另一个数据类型, 类似于List(列表).

元组用"()"标识. 内部元素用逗号隔开. 但是元组不能二次赋值, 相当于只读列表.

# Python 3.x

tuple = ( "runoob", 786 , 2.23, "john", 70.2 )
tinytuple = (123, "john")

print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组的第一个元素
print(tuple[1:3])  # 输出第二个至第三个的元素 
print(tuple[2:])  # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2)  # 输出元组两次
print(tuple + tinytuple)  # 打印组合的元组

("runoob", 786, 2.23, "john", 70.2)
runoob
(786, 2.23)
(2.23, "john", 70.2)
(123, "john", 123, "john")
("runoob", 786, 2.23, "john", 70.2, 123, "john")

以下是元组无效的, 因为元组是不允许更新的. 而列表是允许更新的:

# Python 3.x
tuple = ( "runoob", 786 , 2.23, "john", 70.2 )
list = [ "runoob", 786 , 2.23, "john", 70.2 ]

tuple[2] = 1000 # 元组中是非法应用
list[2] = 1000 # 列表中是合法应用

元组内置方法:

元组与列表类似, 可以理解为是不可变的列表, 所以只有查询统计的方法 count 与 index, 具体使用方法参考列表.

 

六. Python数据类型 - 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型. 列表是有序的对象结合, 字典是无序的对象集合.

两者之间的区别在于: 字典当中的元素是通过键来存取的, 而不是通过偏移存取.

字典用"{ }"标识. 字典由索引(key)和它对应的值value组成.

# Python 3.x

dict = {}
dict["one"] = "This is one"
dict[2] = "This is two"

tinydict = {"name": "john","code":6734, "dept": "sales"}


print(dict["one"])  # 输出键为"one" 的值
print(dict[2])  # 输出键为 2 的值
print(tinydict)  # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())  # 输出所有值

This is one
This is two
{"dept": "sales", "code": 6734, "name": "john"}
["dept", "code", "name"]
["sales", 6734, "john"]

 字典内置方法: 

clear() # 函数用于删除字典内所有元素。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
print("Start Len : %d" % len(dict))
dict.clear()
print("End Len : %d" % len(dict))
# 以上实例输出结果为：
Start Len : 2
End Len : 0

copy()  # 函数返回一个字典的浅复制。

# Python 3.x
dict1 = {'Name': 'Zara', 'Age': 7} 
dict2 = dict1.copy()
print("New Dictinary : %s" % str(dict2))
# 以上实例输出结果为：
New Dictinary : {'Age': 7, 'Name': 'Zara'}

fromkeys(seq[, value]))  # 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

• seq -- 字典键值列表。
• value -- 可选参数, 设置键序列（seq）的值。

# Python 3.x
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print("New Dictionary : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print("New Dictionary : %s" % str(dict))
# 以上实例输出结果为：
New Dictionary : {'age': None, 'name': None, 'sex': None}
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}

get(key, default=None)  # 函数返回指定键的值，如果值不在字典中返回默认值。

• key -- 字典中要查找的键。
• default -- 如果指定键的值不存在时，返回该默认值值。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 27}
print("Value : %s" % dict.get('Age'))
print("Value : %s" % dict.get('Sex', "Never"))
# 以上实例输出结果为：
Value : 27
Value : Never

items()  # 函数以列表返回可遍历的(键, 值) 元组数组。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.items())
# 以上实例输出结果为：
Value : [('Age', 7), ('Name', 'Zara')]

keys()  # 函数以列表返回一个字典所有的键。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.keys())
# 以上实例输出结果为：
Value : ['Age', 'Name']

setdefault(key, default=None)   # 函数和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

• key -- 查找的键值。
• default -- 键不存在时，设置的默认键值。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.setdefault('Age', None))
print("Value : %s" % dict.setdefault('Sex', None))
# 以上实例输出结果为：
Value : 7
Value : None

update(dict2)  # 函数把字典dict2的键/值对更新到dict里。

• dict2 -- 添加到指定字典dict里的字典。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female'}
dict.update(dict2)
print("Value : %s" % dict)
# 以上实例输出结果为：
Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

values()  # 函数以列表返回字典中的所有值。

# Python 3.x
dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.values())
# 以上实例输出结果为：
Value : [7, 'Zara']

has_key(key)   # 函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。
注: Python 2.x 中有这个属性, 在Python 3.x 中被移除了.

• key -- 要在字典中查找的键。

# Python 2.x
dict = {'Name': 'Zara', 'Age': 7}
print "Value : %s" % dict.has_key('Age')
print "Value : %s" % dict.has_key('Sex')
# 以上实例输出结果为：
Value : True
Value : False

 

七. 数据类型转换

有时候, 我们需要对数据内置的类型进行转换, 数据类型的转换, 你只需要将数据类型作为函数名即可.

以下几个内置的函数可以执行数据类型之间的转换. 这些函数返回一个新的对象, 表示转换的值. 

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

 

# 待补充集合类型, 另外各数据类型方法分别引向单独的博客进行说明