1.字符串：标识" "

PS：字符串是%s；整数是%d；浮点数%f

strip：移除(空白或者特定字符)

split：分割

len：长度(获取元素的个数)

索引

切片

2.列表list：方括号[ ]

PS:先了解

序列是Python中最基本的数据结构，Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。

列表是最常用的Python数据类型

list=["alex","oldboy","nosong","noway","nobody","jack"]

number=[1,2,3,4,5,6,7,8,9]print("索引",list.index("nosong"))print("切片",number[2:5])print("步长",number[1:8:2])

number.append(10)print("追加",number)

number.insert(3,444)print("插入",number)print("长度",len(number))delnumber[0]print("删除",number)#循环输出值

for i inlist:print(i)#带下标输出

for k,v inenumerate(list):print(k,v)#包含

if "alex" inlist:print("包含：yes")

View Code

删除list末尾元素，用pop()：

>>> classmates.append('Tom')>>> printclassmates

['john', 'jack', 'Tom']>>>classmates.pop()'Tom'

删除指定位置元素，用pop(i):

>>> printclassmates

['john', 'jack', 'Tom']>>>classmates.pop()'Tom'

>>>classmates.pop(0)'john'

替换某个元素，直接赋值给对应的索引位置：例子省略

list 元素也可以是另一个list，它只是表示一个元素：

>>> s=['python','java',['c','c++'],'php']>>>len(s)4

接着要拿到' c '可以写成s[2][1]，因此s可以看成一个二维数组，类似三维，四位

空的list，长度为0：

>>> L=[]>>>len(L)

0

python 创建二维列表，将需要的参数写入 cols 和 rows 即可:

#创建二维列表：list_2d = [[0 for col in range(cols)] for row in range(rows)]

list_2d=[[0 for i in range(5)]for i in range(6)]printlist_2d

list_2d[0].append(3)

list_2d[0].append(5)

list_2d[2].append(8)print list_2d

View Code

列表排序：

#list.sort() 对列表元素排序，数字的话从小到大

>>> a=[1,4,3,4,7,8]>>>a.sort()>>>a

[1, 3, 4, 4, 7, 8]#list.reverse() 对列表元素进行倒序

>>> a=[1,4,3,4,7,8]>>>a.reverse()>>>a

[8, 7, 4, 4, 3, 1]

View Code

3.元组tuple：小括号()

PS：元组不能二次赋值，相当于只读列表。即元组的元素不能修改

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

list= [ 'runoob', 786 , 2.23, 'john', 70.2]

tuple[2] = 1000 　　#元组中是非法应用

list[2] = 1000　　 #列表中是合法应用

View Code

#创建空元组

tup1=()#元组中只包含一个元素时，需要在元素后面添加逗号，因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义

tup1=(50,)

注意：不可变指的是tuple的元素，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。

>>> t=('a','b',['A','B'])>>> t[2][0]='X'

>>> t[2][1]='Y'

>>>t

('a', 'b', ['X', 'Y']) #一个“可变”的tuple，实际上是list的元素变了

输出：

tuple=('runoob',78,2.23,'john',70.2)

tinytuple=(123,'john')printtupleprinttuple[0]print tuple[1:3] #输出第二个至第三个的元素

print tuple[2:] #输出从第三个开始至列表末尾的元素

print tinytuple*2

print tuple+tinytuple

View Code

访问元组：

#!/usr/bin/env python#-*- coding:utf-8 -*-

tup1=('physics','chemistry',1990,2001)

tup2=(1,2,3,4,5)print "tup1[0]:",tup1[0]print "tup2[1:4]:",tup2[1:4]

View Code

元组元素值不能修改，但能进行元组连接组合：

tup1=(12,23,34)

tup2=('abc','xyz')#创建一个新的元组，进行连接组合

tup3=tup1+tup2print tup3

View Code

元组不能增加元素，没有append和extend方法

元组不能删除元素，tuple没有remove或pop，但可使用del语句来删除整个元组:

tup=('abc','john',123,446)printtupdeltupprint "After deleting tup:"

print tup

View Code

迭代：

tup=(1,2,3)for i intup:print i

View Code

计算元素个数：

tup=(2,3,4,5,6,7)print len(tup)

View Code

索引：

L=('a','b','c','d')print L[-2] #反向读取，读取倒数第二个元素：c

View Code

无关闭分隔符：任意无符号的对象，以逗号隔开，默认为元组，如：

print 'abc',-4.2e21,18+6j,'xyz'x,y=1,2

print "Value of x,y:",x,y

View Code

比较两个元组：cmp(tup1,tup2)

返回元组中元素最大值，最小值：max(tup)； min(tup)

将列表转换为元组：tuple(seq)

print tuple([1,2,3,4])print tuple({1:2,3:4}) #针对字典 会返回字典的key组成的tuple:(1,3)

#元组会返回元组本身

View Code

4.字典dict：花括号{ }

组成：由索引(key)和它对应的值value组成，格式：d= {key1: value1, key2: value2}

字典是另一种可变容器模型，且可存储任意类型对象。字典是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

键必须是唯一的，但值则不必。

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

创建：

dict1={'abc':111,'Age':37}

View Code

访问字典中的值：(如果用字典里没有的键访问数据，会输出错误)

dict={'Name':'john','Age':7,'Class':'First'}print "dict['Name']:",dict['Name']print "dict['Age']:",dict['Age']

View Code

修改字典：

#修改字典的方法是增加新的键/值对，修改或删除已有的键/值对

dict={'Name':'john','Age':7,'Class':'First'}

dict['Age']=8 #修改

dict['School']='Yi Ling School' #增加

del dict['Name'] #删除键为'Name'的条目

printdict

dict.clear()#清除dict字典的所有条目

printdictdeldictprint dict

View Code

字典键的特性：

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住：

View Code

键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行:

View Code

5.set:  set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

1.要创建一个set，需要提供一个list作为输入集合:

>>> a=set([1,2,3])

>>> a

set([1, 2, 3])