python数据类型（整型、序列、字典）

本文主要是介绍python数据类型（整型、序列、字典），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

环境： python2.7.5
系统：centos 7 x86_64

1.数值类型

1.1整型int

• 整数有正整数和负整数
• 在32位机器上，整型的位宽为32位，取值范围为-2147483648～2147483647
• 在64位系统上，整型的位宽通常为64位，取值范围为-9223372036854775808～9223372036854775807

In [1]: a = 123In [2]: type(a)
Out[2]: intIn [3]: a
Out[3]: 123In [4]: a  = -123In [5]: type(a)
Out[5]: intIn [6]: a
Out[6]: -123In [7]: int(2 ** 63)
Out[7]: 9223372036854775808L In [8]: int(2 ** 63 - 1 )
Out[8]: 9223372036854775807In [9]: int(-(2 ** 63))
Out[9]: -9223372036854775808

1.2长整型long

• 长整型long，Long的范围很大，几乎可以说任意大的整数均可以存储。为了区分普通整型，需要在整数后加L或l

In [1]: a = 123In [2]: type(a)
Out[2]: intIn [3]: b = 129999999999999999999In [4]: type(b)
Out[4]: longIn [5]: c = -1213123In [6]: type(c)
Out[6]: intIn [7]: d = 2 ** 32In [8]: d
Out[8]: 4294967296In [9]: b
Out[9]: 129999999999999999999L

1.3浮点型float

-  eg：0.0，12.0，-18.8，3e+7等

In [1]: a = 0.0 In [2]: type(a)
Out[2]: floatIn [3]: a = 12.2In [4]: type(a)
Out[4]: floatIn [5]: a = 3e+7In [6]: type(a)
Out[6]: floatIn [7]: a
Out[7]: 30000000.0

1.4复数型complex

-  Python对复数提供内嵌支持，这是其他大部分软件所没有的。
-  eg：：- 3.14j，8.32e-36j

In [8]: a = 3.14jIn [9]: type(a)
Out[9]: complexIn [10]: a = 8.32e-36jIn [11]: type(a)
Out[11]: complex

2.序列

(1)	字符串、列表和元组都是序列序列的两个主要特点是索引操作符和切片操作符- -索引操作符让我们可以从序列中抓取一个特定项目- -切片操作符让我们能够获取序列的一个切片，即一部分序列。(2)	序列的基本操作-	1. len()：  求序列的长度-	2. +：      连接2个序列-	3. *：      重复序列元素,乘号后必须是一个数字-	4. in：     判断元素是否在序列中-	a = 'abcde' ; f not in a + 'f'-	5. max()： 返回最大值-	6. min()： 返回最小值-	7. cmp(x, y)：比较两个序列是否相等，如果x<y，输出-1；如果x>y,输出1;如果x=y，输出0 

In [1]: a = 'abcdefghi'In [2]: len(a)
Out[2]: 9In [3]: b = a + '123456'In [4]: b
Out[4]: 'abcdefghi123456'In [5]: len(b)
Out[5]: 15In [6]: c = a *3In [7]: c
Out[7]: 'abcdefghiabcdefghiabcdefghi'In [8]: f in c
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-8-113e2c82387a> in <module>()
----> 1 f in cNameError: name 'f' is not definedIn [9]: 'f' in c
Out[9]: TrueIn [10]: '9' in c
Out[10]: FalseIn [11]: max(c)
Out[11]: 'i'In [12]: min(c)
Out[12]: 'a'In [13]: cmp(a,b)
Out[13]: -1In [14]: cmp(a,a)
Out[14]: 0In [15]: cmp(a,c)
Out[15]: -1In [16]: cmp(c,a)
Out[16]: 1In [17]: cmp(c,b)
Out[17]: 1

2.1字符串str

- 有三种方法定义字符串类型
- str = ' this is a string '
- str = " this is a string "
- str = '''this is a string'''
- 三重引号（docstring），三引号可以是三个单引号，也可以是三个双引号，三引号也可以换行，除了能定义字符串还可以用作注释，字符串是序列，可以通过索引取每个字符

In [1]: a = 'abcdef'In [2]: a[0]
Out[2]: 'a'In [3]: a[0] + a[1]
Out[3]: 'ab'In [4]: a[0:3]
Out[4]: 'abc'In [5]: a[:3]
Out[5]: 'abc'In [6]: a[:]
Out[6]: 'abcdef'In [7]: a[-1]
Out[7]: 'f'In [8]: a[:-1]
Out[8]: 'abcde'In [9]: a[-3:-1]
Out[9]: 'de'In [10]: a[::-2]
Out[10]: 'fdb'In [11]: a[-1:-4:-1]
Out[11]: 'fed'

2.2元组tuple()

元组和列表十分相似，定义的时候需要用括号，元组内容是一个内容的时候，需要加逗号，不加逗号你输入的内容是什么就是什么。
元组和字符串一样是不可变的
- 元组可以存储一系列的值
- 元组通常用在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

(1)创建元组

In [19]: a = ()In [20]: a
Out[20]: ()In [21]: a = (1,)In [22]: a
Out[22]: (1,)In [23]: a = ('james','kobe')In [24]: a
Out[24]: ('james', 'kobe')In [25]: 

(2)元组操作

元组和字符串一样属于序列类型，可以通过索引和切片操作
元组值不可变

In [30]: t = (a,'123','f','d')In [31]: t[0]
Out[31]: 1In [32]: t[-1]
Out[32]: 'd'In [33]: t[-2]
Out[33]: 'f'In [34]: t[0] 
Out[34]: 1In [35]: t[0] = 'anc'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-35-7b4f230b8f3c> in <module>()
----> 1 t[0] = 'anc'TypeError: 'tuple' object does not support item assignment

(3)元组的拆分

In [25]: t = (1,2,3)In [26]: a, b, c = tIn [27]: a
Out[27]: 1In [28]: b
Out[28]: 2In [29]: c
Out[29]: 3

(4)元组方法

t.index() 返回值的第一个索引，也就是说如果()内给的value值在这个元组中出现多次，显示第一次值的索引。
t.count() 返回值的出现次数，()内给的值出现多次的话，统计次数。

In [71]: t = (1,1,2,3,4,'a','a','bcd')In [72]: t.index(2)
Out[72]: 2In [73]: t.index('a')
Out[73]: 5In [74]: t.count(1)
Out[74]: 2In [75]: t.count(3)
Out[75]: 1In [76]: t.count('a')
Out[76]: 2

2.3列表[]

列表(list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。
列表是可变类型的数据

(1)创建列表

In [77]: list1 = []In [78]: list1
Out[78]: []In [79]: list2 = list()In [80]: list2
Out[80]: []In [81]: list3 = ['a',1,2]In [82]: list3
Out[82]: ['a', 1, 2]

(2)列表操作

list方法	含义
list.append(value)	将对象追加到结尾
list.count(value)	返回值的出现次数
list.extend()	通过附加iterable中的元素来扩展列表
list.index(value)	返回第一个索引中的值
list.insert(index,object)	在索引前插入对象
list.mro(…)	返回类型的方法解析顺序
list.pop([index])	删除并返回索引处的项（默认为最后一个）。如果列表为空或索引超出范围，则引发索引器错误。
list.remove(…)	删除第一次出现的值,如果值不存在，则引发ValueError
list.reverse()	列表内的object反转排序
list.sort()	升序排序

列表的取值可以通过切片和索引得到

In [83]: list3
Out[83]: ['a', 1, 2] In [84]: list3[0]
Out[84]: 'a'In [85]: list3[1]
Out[85]: 1In [86]: list3[:1]
Out[86]: ['a']In [87]: list3[:2]
Out[87]: ['a', 1]

  列表中添加value，可以使用list.append方法，添加值到list的最后

In [88]: list3
Out[88]: ['a', 1, 2]In [89]: list3.append('abc')In [90]: list3
Out[90]: ['a', 1, 2, 'abc']

列表中删除列表可以使用 del list_name直接删除列表
列表中删除某个值，可以使用list.remove方法，删除某个值

In [90]: list3
Out[90]: ['a', 1, 2, 'abc']In [91]: del list3In [92]: list3
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-92-6a4e874e63a7> in <module>()
----> 1 list3NameError: name 'list3' is not definedIn [93]: list3 = ['a', 1, 2, 'abc']In [94]: list3.remove(-1)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-94-a45c1fcec35a> in <module>()
----> 1 list3.remove(-1)ValueError: list.remove(x): x not in listIn [95]: list3.remove(1)In [96]: list3
Out[96]: ['a', 2, 'abc']

列表中修改某个索引位置的值，可以直接使用list[]=value，直接进行替换

In [96]: list3
Out[96]: ['a', 2, 'abc']In [97]: list3[0] = '123'In [98]: list3
Out[98]: ['123', 2, 'abc']

在列表中查找某个value是否在列表中可以用 value in list

In [100]: list3
Out[100]: ['123', 2, 'abc']In [101]: 123 in list3
Out[101]: FalseIn [102]: '123' in list3
Out[102]: True

3.字典{}

字典是python中的唯一的映射类型（哈希表）
字典对象是可变的，但是字典的键必须使用不可变对象，键值创建可以是字符串和元组，但是不能是列表，因为列表是可变的 ，一个字典中可以使用不同类型的键值，字典中的key是唯一的。

字典方法	含义
dict.clear()	清楚整个字典
dict.get()	得到字典中key的值，如果值不存在，显示None。可以同时给key的时候，给value值，如果key不存在显示value的值。
dict.keys()	打印出字典中所有的key，并且以list的形式显示。
dict.popitem()	popitem() 用来随机删除一个键值对
dict.values()	打印出字典中所有的value，并且以list的形式显示。
dict.copy()	可以复制字典到另外一个字典
dict.has_key()	同get方法，判断值是否在字典中
dict.setdefault()	返回指定 key 对应的 value，如果该 key 存在，那么直接返回该 key 对应的 value；如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。
dict.fromkeys()	函数用于创建一个新字典
dict.items()	把字典中的key-value保存在一个元组中作为元组的两个元素，多个元组组成一个列表
dict.itervalues()	tervalues() 方法比 values() 方法节省了生成 list 所需的内存。python3.6已经移除
dict.pop()	删除指定的key和value，并且返回value的值
dict.update()	最长见合并两个字典
dict.viewkeys()	返回字典中key的集合，把key组合为一个列表，最后组合为一个元组。 eg：dict_keys([‘c’, ‘abc’, (‘a’,)])
dict.viewvalues()	返回字典中value的集合，把value组合成一个列表，最后组合为一个元组。 eg：dict_values([‘xihaji’, 123, 456])
dict.viewitems()	返回字典中key-value的集合，把这2个元素存储为一个元组，之后把所有的元组组成一个列表，最后组成一个元组。 eg：dict_items([(‘c’, ‘xihaji’), (‘abc’, 123), ((‘a’,), 456)])

# 字典是使用花括号的，可以创建一个空字典
In [1]: dic = {}# 可以使用type函数查看我们创建的dic类型是字典类型
In [2]: type(dic)
Out[2]: dict# 创建一个新的字典
In [3]: dict1 = {'abc':123,('a',):456,'c':79}In [4]: dict1
Out[4]: {'abc': 123, 'c': 79, ('a',): 456}# 可以使用len函数查看字典的长度
In [5]: len(dict1)
Out[5]: 3# keys显示出所有的keys，以列表形式展示
In [6]: dict1.keys()
Out[6]: ['abc', 'key', ('a',)]# values可以显示出所有的value，以列表展示
In [7]: dict1.values()
Out[7]: [123, 79, 456]# 清空字典
In [8]: dict1 = {'abc':123,('a',):456,'c':79}In [9]: dict1.clear
Out[9]: <function clear>In [10]: dict1.clear()In [11]: dict1
Out[11]: {}# popitem随机删除字典中一个key对应的value值
In [12]: dict1 = {'abc':123,('a',):456,'c':79}In [13]: dict1.popitem()
Out[13]: ('c', 79)In [14]: dict1
Out[14]: {'abc': 123, ('a',): 456}# 删除指定的key
In [15]: dict1.pop('abc')
Out[15]: 123In [16]: dict1
Out[16]: {('a',): 456}# 复制字典
In [17]: dict2 = dict1.copy()In [18]: dict2
Out[18]: {('a',): 456}# 判断key是否在字典中
In [19]: dict2.has_key(('a',)) 
Out[19]: True# setdefault方法查询字典中的key，可以给默认一个值
In [20]: dict2.setdefault(('a',))
Out[20]: 456In [21]: dict2.setdefault('a',123)
Out[21]: 123# 把字典中的key-value保存在一个元组中作为元组的两个元素，多个元组组成一个列表
In [22]: dict2.items()
Out[22]: [('a', 123), (('a',), 456)

字典小脚本

[root@linux-001 ~]# cat input.py 
#!/usr/bin/pythoninfo = {}
Name = raw_input('Please input Name :')
Age = raw_input('Please input Age : ')
Gender = raw_input('Please input Gender :')info['Name'] = Name
info['Age'] = Age
info['Gender'] = Genderfor k, v  in info.items():print '%s: %s' % (k, v)[root@linux-001 ~]# python input.py 
Please input Name :james
Please input Age : 34
Please input Gender :man
Gender: man
Age: 34
Name: james

这篇关于python数据类型（整型、序列、字典）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---