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

In [1]: a = 123

In [2]: type(a)
Out[2]: int

In [3]: a
Out[3]: 123

In [4]: a  = -123

In [5]: type(a)
Out[5]: int

In [6]: a
Out[6]: -123

In [7]: int(2 ** 63)
Out[7]: 9223372036854775808L 

In [8]: int(2 ** 63 - 1 )
Out[8]: 9223372036854775807

In [9]: int(-(2 ** 63))
Out[9]: -9223372036854775808

In [1]: a = 123

In [2]: type(a)
Out[2]: int

In [3]: b = 129999999999999999999

In [4]: type(b)
Out[4]: long

In [5]: c = -1213123

In [6]: type(c)
Out[6]: int

In [7]: d = 2 ** 32

In [8]: d
Out[8]: 4294967296

In [9]: b
Out[9]: 129999999999999999999L

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

In [1]: a = 0.0 

In [2]: type(a)
Out[2]: float

In [3]: a = 12.2

In [4]: type(a)
Out[4]: float

In [5]: a = 3e+7

In [6]: type(a)
Out[6]: float

In [7]: a
Out[7]: 30000000.0

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

In [8]: a = 3.14j

In [9]: type(a)
Out[9]: complex

In [10]: a = 8.32e-36j

In [11]: type(a)
Out[11]: complex

(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]: 9

In [3]: b = a + '123456'

In [4]: b
Out[4]: 'abcdefghi123456'

In [5]: len(b)
Out[5]: 15

In [6]: c = a *3

In [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 c

NameError: name 'f' is not defined

In [9]: 'f' in c
Out[9]: True

In [10]: '9' in c
Out[10]: False

In [11]: max(c)
Out[11]: 'i'

In [12]: min(c)
Out[12]: 'a'

In [13]: cmp(a,b)
Out[13]: -1

In [14]: cmp(a,a)
Out[14]: 0

In [15]: cmp(a,c)
Out[15]: -1

In [16]: cmp(c,a)
Out[16]: 1

In [17]: cmp(c,b)
Out[17]: 1

- 有三种方法定义字符串类型
- 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'

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

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]: 

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

In [30]: t = (a,'123','f','d')

In [31]: t[0]
Out[31]: 1

In [32]: t[-1]
Out[32]: 'd'

In [33]: t[-2]
Out[33]: 'f'

In [34]: t[0] 
Out[34]: 1

In [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

In [25]: t = (1,2,3)

In [26]: a, b, c = t

In [27]: a
Out[27]: 1

In [28]: b
Out[28]: 2

In [29]: c
Out[29]: 3

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

In [71]: t = (1,1,2,3,4,'a','a','bcd')

In [72]: t.index(2)
Out[72]: 2

In [73]: t.index('a')
Out[73]: 5

In [74]: t.count(1)
Out[74]: 2

In [75]: t.count(3)
Out[75]: 1

In [76]: t.count('a')
Out[76]: 2

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

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]

In [83]: list3
Out[83]: ['a', 1, 2] 

In [84]: list3[0]
Out[84]: 'a'

In [85]: list3[1]
Out[85]: 1

In [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 list3

In [92]: list3
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-92-6a4e874e63a7> in <module>()
----> 1 list3

NameError: name 'list3' is not defined

In [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 list

In [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]: False

In [102]: '123' in list3
Out[102]: True

# 字典是使用花括号的，可以创建一个空字典
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]: 123

In [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]: 456

In [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/python

info = {}
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'] = Gender

for 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