python数据类型（二）

一。List（列表）

List（列表）是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号([])之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

实例

#!/usr/bin/python3 list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ] tinylist = [123, 'runoob'] print (list) # 输出完整列表

print (list[0]) # 输出列表第一个元素

print (list[1:3]) # 从第二个开始输出到第三个元素

print (list[2:]) # 输出从第三个元素开始的所有元素

print (tinylist * 2) # 输出两次列表

print (list + tinylist) # 连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = ['1','2','3','4']
>>> a[0]= 0
>>> print(a)
[0, '2', '3', '4']
>>> a[0:2]
[0, '2']
>>> a[:2]=[]
>>> a
['3', '4']
>>>

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

二。Tuple元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

tinytuple = (123, 'runoob')

print (tuple) # 输出完整元组

print (tuple[0]) # 输出元组的第一个元素

print (tuple[1:3]) # 输出从第二个元素开始到第三个元素

print (tuple[2:]) # 输出从第三个元素开始的所有元素

print (tinytuple * 2) # 输出两次元组

print (tuple + tinytuple) # 连接元组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)

abcd

(786, 2.23)

(2.23, 'runoob', 70.2)

(123, 'runoob', 123, 'runoob')

('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组

tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list和tuple都属于sequence（序列）。

注意：

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

三。set集合

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> a = set('abracadabra')

>>> b = set('alacazam')
>>> print(a)
{'d', 'r', 'a', 'c', 'b'}
>>> print(b)
{'m', 'l', 'a', 'c', 'z'}
>>> print(a - b) //最好的记忆办法就是想成具体的减法运算，在a中减去b中有的剩下的元素
{'d', 'b', 'r'}
>>> print(a | b)
{'z', 'r', 'm', 'l', 'd', 'a', 'c', 'b'} #取并
>>> print(a & b) #取与，两个都有的元素
{'a', 'c'}
>>> print(a ^ b) # a和b中不同时存在的元素
{'z', 'r', 'm', 'l', 'd', 'b'}
>>>

四。字典

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。（可以通过‘key’或者下标来访问具体建对应的值）

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3 dict = {}

dict['one'] = "1 - 菜鸟教程"

dict[2] = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} print (dict['one']) # 输出键为 'one' 的值

print (dict[2]) # 输出键为 2 的值

print (tinydict) # 输出完整的字典

print (tinydict.keys()) # 输出所有键

print (tinydict.values()) # 输出所有值

以上实例输出结果：

1 - 菜鸟教程

2 - 菜鸟工具

{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}

dict_keys(['name', 'site', 'code'])

dict_values(['runoob', 'www.runoob.com', 1])
====================================

注意：

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

Python数据类型转换

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

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

函数	描述
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)	将一个整数转换为一个八进制字符串

拓展：http://www.runoob.com/python3/python3-data-type.html

笔记列表

荆棘乱

llc***n@gmail.com
元组（小拓展）

一般来说，函数的返回值一般为一个。

而函数返回多个值的时候，是以元组的方式返回的。

示例（命令行下）：
```
>>>def example(a,b):

...     return (a,b)

...

>>>type(example(3,4))

<class 'tuple'>

>>>
```
python中的函数还可以接收可变长参数，比如以 "*" 开头的的参数名，会将所有的参数收集到一个元组上。

例如：
```
def test(*args):

    print(args)

    return args

print(type(test(1,2,3,4)))    #可以看见其函数的返回值是一个元组
```
字典（小拓展）

python中的字典是使用了一个称为散列表（hashtable）的算法（不具体展开），

其特点就是：不管字典中有多少项，in操作符花费的时间都差不多。

如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：
```
def example(d):

    # d 是一个字典对象

    for c in d:

        print(c)

        #如果调用函数试试的话，会发现函数会将d的所有键打印出来;

        #也就是遍历的是d的键，而不是值.
```
荆棘乱

荆棘乱

llc***n@gmail.com

6个月前 (05-05)
我去咬你啦

815***114@qq.com
针对楼上的字典拓展，做测试的时候，想要输出 kye:value的组合发现可以这样：
```
for c in dict:

    print(c,':',dict[c])
```
或者
```
for c in dict:

    print(c,end=':');

    print(dict[c])
```
于是发现 print()函数其实可以添加多个参数，用逗号隔开。

本来想要用
```
for c in dict:

    print(c+':');

    print(dict[c])
```
这样的方式打印 key：value结果发现其实 key不一定是 string类型，所以用+ 号会出问题。

我去咬你啦

我去咬你啦

815***114@qq.com

4个月前 (06-28)
愤怒的胸毛毛

zha***aijun2013@foxmail.com
在list的使用中，开始时很容易忽视的一点是：
```
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]

print (list[1:3])       # 从第二个开始输出到第三个元素
```
list[1:3] 其实输出的只有两个变量，即list中第二个元素到第三个元素，并不是第1 第2 第3三个元素，而且要注意的是
```
print (list[2])

print (list[2:3])
```
这两句话打印的内容其实是一样的，
```
2.23

[2.23]
```
但是第二句话有中括号

愤怒的胸毛毛

愤怒的胸毛毛

zha***aijun2013@foxmail.com

4个月前 (07-02)
hellowqp

wqp***a@foxmail.com
python 与 C 语言和 Java 语言的一点不同，表现在它的变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的，变量的类型由赋予它的值来决定，例如：
```
>>> a = 1

>>> a = 1.001

>>> a = "python"

>>> print(a)

python

>>>
```
第一次为变量 a 赋值为整型，第二次赋值是浮点数，第三次是一个字符串，最后输出时只保留了最后一次的赋值。

hellowqp

hellowqp

wqp***a@foxmail.com

3个月前 (07-08)
燕春

zqs***306010@qq.com

参考地址
type 是用于求一个未知数据类型对象，而 isinstance 是用于判断一个对象是否是已知类型。

type 不认为子类是父类的一种类型，而isinstance会认为子类是父类的一种类型。

可以用 isinstance 判断子类对象是否继承于父类，type 不行。

综合以上几点，type 与 isinstance 虽然都与数据类型相关，但两者其实用法不同，type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类：
```
# 判断子类对象是否继承于父类

class father(object):

    pass

class son(father):

    pass

if __name__ == '__main__':

    print type(son())==father

    print isinstance(son(),father)

    print type(son())

    print type(son)
```
运行结果：
```
False

True

<class '__main__.son'>

<type 'type'>
```
燕春

燕春

zqs***306010@qq.com

参考地址

1个月前 (09-15)