Python数据类型

5种数据类型：
数值
字符串 （序列）
列表（序列）
元组（序列）
字典（可迭代对象）

序列
序列：字符串、列表、元组
序列的两个主要特点是索引操作符和切片操作符：
- 索引操作符让我们可以从序列中抓取一个特定项目
- 切片操作符让我们能够获取序列的一个切片，即一部分序列
序列的基本操作
1. len()： 求序列的长度
2. +： 连接2个序列
3. *： 重复序列元素
4. in/not in： 判断元素是否在序列中
5. max()： 返回最大值
6. min()： 返回最小值
7. cmp(x, y)：比较两个序列是否相等 返回值大于0 ，等于0，小于0
cmp：按照字符串比较，字符串比较的原则就是一个字符一个字符的比较，字符按照ASCII码来比较，字符1比字符2小，所以gene1001小于gene2。

数值类型

- 整型  2^32个数字，范围-2,147,483,648到2147483647
- 长整型  区分普通整型，需要在整数后加L或l。2345L，0x34al
- 浮点型  0.0，12.0，-18.8，3e+7
- 复数型  - 3.14j，8.32e-36j


字符串类型
字符串是不可变数据类型
有三种方法定义字符串类型
str = 'this is a string'
str = "this is a string"
str = '''this is a string'''  或 """this is a string"""
三重引号（docstring）除了能定义字符串还可以用作注释
python里面单引号和双引号没有任何区别

\n：换行

str = "this is a \nstring"

字符串索引

字符串是序列，可以通过索引取每个字符
加号 ：字符串连接符
str = 'abcde'
str[0] + str[1]
字符串切片
str[start:end:step]
step：为负数表示从右向左，步长为正数，start那个数字的值不要，步长为负数，end那个数字的值不要
实例：
>>> str[1:3]
'bc'
>>> str[:3]
'abc'
>>> str[3:]
'de'
>>> str[::1]
'abcde'
>>> str[::2]
'ace'
>>> str[-1]
'e'
>>> str[-4:-1]
'bcd'
>>> str[-2:-4:-1]
'dc'

元组（）类型
元组和列表十分相似
元组和字符串一样是不可变的，不可变的意思是元组里面的元素不能修改，比如a[-1] = xx 会报错
- 元组可以存储一系列的值
- 元组通常用在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
创建元组
t= ()
t= (2,) 一定要加逗号才是元组，否则会当普通字符串对待
t = ('james', 'M')
t = ('james', 'M',(1,)) 元组里面包含元组
j = 'sd'
t = (j, 'M') 包含变量
print t
('sd', 'M')
print(t[0]) 返回第一个元素
元组操作
- 元组和字符串一样属于序列类型，可以通过索引和切片操作
- 元组值不可变

元组的拆分

实:1：

t = (1,2,3)
a, b, c = t
a
1
b
2
c
3
实例2：
M=2
t = ('james', M,'gg','cc')
for a in t:
    print(a)
james
2
gg
cc

列表[]类型
列表(list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。
列表是可变类型的数据类型
创建列表
list1 = []
list2 = list()   list()函数
list3 = ['a',1,2]
list4 = ['a',1,(1,),['sdf','sww]]
对某项目赋值，下标从0开始
list3[0] = 'b'

列表操作

操作1：

- 取值
切片和索引
实例：
切片
l = list(range(10))
l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l[5:0:-1]  输出：[5, 4, 3, 2, 1]
l[5:4:-1]  输出：[5]
l[:3:-1]   输出：[9, 8, 7, 6, 5, 4]
l[0:3:-1]  输出：[]
l[9::-1]   输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
l[-2:]（ l[-2:10:1]）     输出：[8, 9]
l[2:]（ l[2:10:1]）   输出：[2, 3, 4, 5, 6, 7, 8, 9]
l[:-2]（ l[0:-2:1]）       输出：[0, 1, 2, 3, 4, 5, 6, 7]
l[0]     输出：0
l[列表最小值:列表最大值:步进]
步长为正数情况下输出不包含列表最大值
列表最小值下标从0开始
-1：9
-2：8
操作2：
- 添加
list.append()
list1[2].append('abc')  如果列表里面又有列表使用下标来访问
添加 list= list +[6]  ，list2 =[1,2]   list = list + list2
操作3：
- 删除
del list[x] 删除某个元素  del list 删除整个列表
list.remove(列表里面实际的值)

操作4：

- 修改

list[] = x

操作5：

- 查找

var in list

操作6：

- 插入 

list.insert(list[x],object)  在下标前插入一个对象

操作7：

- 排序

list.sort()

操作8：

- 反转

list.reverse()

操作9：

- 弹出

list.pop([index])  返回一个元素并删除这个元素，参数是下标，没有参数会删除最后一个元素

操作10：

- 扩展
list.extend(iterable)  可迭代的，相比append()方法可以追加多个值，l.extend(range(10))

字典{}类型
字典是python中的唯一的映射类型（哈希表）
字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的键值。
跟redis的set类型一样，字典里的key不能重复，赋值的时候如果发现已有key则替换
字典的方法：
- keys() 返回所有key
- values() 返回所有value
- items() 返回一个列表，key和value在一个元组里
创建字典
dic = {}
dic = dict()
dict()函数
help(dict)
字典创建
第一种
dict((['a',1],['b',2]))  #dict()函数方式1
aa=dict((['a',1],['b',2]))
print(aa)
{'a': 1, 'b': 2}
第二种
dict(a=1, b=2)  #dict()函数方式2
bb=dict(a=1, b=2)
print(bb)
{'a': 1, 'b': 2}
第三种
dd = {'line':1,'char':2,'word':3} 或dd = {1:1,2:2,3:3} 
print(dd)
{'char': 2, 'line': 1, 'word': 3}
第四种
info = {}  #创建一个空字典
info['name'] = 'name'
info['age'] = 'age'
info['gender'] = 'gender'
print(info)
{'gender': 'gender', 'age': 'age', 'name': 'name'}

tip1:

fromkeys()函数

fromkeys(S[,v]) S指定一个序列，v指定value的值，默认为None。
dic.fromkeys(range(3),100)
In [4]: dic.fromkeys(range(3),100)
Out[4]: {0: 100, 1: 100, 2: 100}
fromkeys函数创建的字典需要赋值到另一个字典才能保存
ddict = {}.fromkeys(('x','y'), 100)
tip2:
update()函数
将一个字典添加到另一个字典
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict1.update(dict2)

print("dict1 : %s" %  dict1)
访问字典
直接使用key访问：key不存在会报错，可以使用has_key()或者in和not in判断。
循环遍历：
例1：
for i in dic.keys():
for i in dic: 
print(i) 读取的是key
print(dic[i]) 读取的是value
for i, o in dic.items(): 
print(i, o)
例2:
#!/usr/bin/python
info = {}  创建一个空字典
name = raw_input("Please input name: ")
age = raw_input("Please input age: ")
gender = raw_input('Please input (M/F): ')
info['name'] = name
info['age'] = age
info['gender'] = gender
for k, v in info.items():
print "%s: %s" % (k, v)
print 'main end'