1.python语法基础-列表、数组、函数、元组和控制语句
1.列表、元组
9.变量
10.数字
12.字符串
20.什么都可以扔进去 
2.减(del、remove)
元组结构图：
一个：列表应该是长成这个样子的list_name = [item1,item2,item3]
一个元组的样式应该是这样的：tuple_name = (item1,item2,item3)
两者区别：列表可以更改其中的内容，但是元组一旦被声明了是不能改变的。
注意：元组如果只有一个元素必须最后加逗号即：tuple1=(item1,)
使用type(list)/type(tuple)
2. 字典初步 2.1 如果有其他语言背景的同学肯定知道关联数组或者哈希表。在python中他们是以“字典”的形式存在的，表现形式是： 键—值 （key—value）
在生活中我们会发现很多数据是“键-值”来组织的。比如一个家庭结构中：
父亲：李龙母亲：刘女神哥哥：李虎弟弟：李豹姐姐：李曼曼
下面我们来实际操作一下：
family = {‘father’:’dragon lee’, ’mother’:’liu’, ’ brother1’:’tiger lee’, ’brother2’:’leopard lee’, ’sister’:’manman lee’}print family
2.2 这里有几点需要强调：几乎所有类型的对象都可以作为“键”，不过一般还是以数字或者字符串最为常用；所有类型的对象都可以作为“值”，甚至是一个列表，每个“键—值”的搭配都是用逗号“，”来隔开。字典要用“{}”花括号来创建。
2.3 使用工厂方法：dict() 如：fdict=dict(['x',1],['y',2])
内建方法：fromkeys()字典中元素具有相同的值，默认none 如：ddict={}.fromkeys(('x','y'),-1)
2.4 访问字典中的值：
直接用key访问，key不存在会报错；可以使用had_key()或者in和not in判断，但是has_key()方法即将放弃
循环遍历：for key in dic1.key()
使用迭代器：for key in dict1
获取字典的key：family.keys() 输出：[’father',’mother’,’brother1’,’brother2’,’sister’]
获取字典的values:family.values() 输出：[’dragon lee’,’liu’,’tiger lee’,’leopard lee’,’manman lee’]
获取字典详细列表：family.items()
输出：[(‘father’,’dragon lee’), (’mother’,’liu’), (’brother1’,’tiger lee’), (’brother2’,’leopard lee’), (’sister’,’manman lee’)]
备注：keys()函数：输出所有键的值；values()函数：输出所有值的值；items()函数：输出一对键值的值
2.5 字典的更新删除
用键值访问更新，内建的update()可以将整个字典内容拷贝到另一个字典中
del dict1['a']:删除键值为a的元素
dict1.pop('a'):删除并返回键值为a的元素
dict1.clear():删除字典所有元素
del dict1:删除整个字典
常用字典方法：
3.判断初步
if-else 示例： 注意：使用python使用缩进作为语句分组的方法，比如c语言中的｛｝建议使用4个空格即1个table键
num = raw_input("please enter a number : ")num = int(num)if num <= 0: #注意：此处为逻辑值，True表示非空的量；False表示0，None，空的量print "the number is below 0"else:print "the number is over 0"
注意：python不允许if后没有分支语句就接着第二个if，会报错，此时应该给if加上代码桩：pass，起到占位作用
如：
if num <= 0: #注意：此处为逻辑值，True表示非空的量；False表示0，None，空的量
pass #此处用pass作为代码桩，占位，因为if后没有要执行的语句
if num >1:
print "hello"
4. while循环
4. while循环
while 条件： #一定得有条件让语句结束，否则将死循环，可以通过break结束while
执行语句（如果条件满足的情况下）
示例：
counter = 0while counter <3:print counter counter += 1
5.循环语句之 for
5.1 python中的for 循环与传统的（计数器）循环不太一样。如果你之前接触过shell脚本的foreach迭代，每次迭代其中的一个元素。
示例：
items = [1,2,3,4,5]for item in items：print item
备注：想在一行输入 不换行则可以：print item, 加上逗号，因为print默认给每一行加一个换行符
5.2 循环结构是用于迭代多个项的for语句，迭代形式可以循环序列的所有成员
6.range() 函数
range()函数会生成一个数字列表，具体列表依据传入的参数不同而定。
如果所创建的对象是整数，可以用range(m,n,[,步进值])
m:初始值，不选时默认0；n：终止值，但不包括在范围内，步进值为可选参数不选默认1
比如：range(n) 会生成一个0，1，2，3，4…n-1 的列表
range(m,n) 会生成一个m,m+1,m+2,…n-1 的列表
range(m,n,k) 会生成一个m,m+k,m+2k,…n-1的列表
7.函数def 函数名(参数列表)： #可以没有参数函数体
示例：
def showMyName(name):print name
7.1 定义 说明：让我们来分析下，关键字”def”是告诉解释器：我要写一个函数了 ! “showMyName”就是这个函数的名字，这个函数需要传入一个变量才能工作，这个变量的名字叫：name。别忘记要在末尾加一个”：“，他是告诉解释器，后面的这些内容是这个函数体内部的内容。具体是哪些内容呢？一般其他的语言会直接把它们放在一对“{}”中，在python中，我们不用花括号，我们用代码的缩进来展现一个程序内部的内容。
调用：
showMyName("jack wang")
打印结果：jack wang
·函数调用：通过函数名在程序的不同地方多次执行，不需要在所有地方重复编写这些语句
·自定义函数：用户自己编写的
·预定义python函数：系统自带的或者第三方编写的函数。如其他人员编写的拿来直接用的
·使用函数原因：降低编程难度；代码重用
7.2 函数参数
形式参数：在定义函数时，函数名后的圆括号中的变量成为形式参数，简称形参
实际参数：在调用函数时，函数名后的圆括号中的变量成为实际参数，简称实参
如：有参数
def fun(x,y): #无默认值
print x,"和",y,"是好朋友"
fun(tina，jack)
运行结果：tina 和 jack 是好朋友
如2：有参数，有默认值
def fun(x='tina',y='jack'): #加入默认值print x,"和",y,"是好朋友"fun() #无参fun('mike','bill') #赋值，用新参数fun('michle',) #赋值的用新参数，没有给出赋值的用默认值运行结果：tina 和 jack 是好朋友mike 和 bill 是好朋友
michle 和jack 是好朋友
7.3 函数-变量的作用域
局部变量：函数中定义的变量一般只能在该函数内部使用，这种在程序的特定部分使用的变量称为局部变量
全局变量：在一个文件顶部定义的变量可以供该文件中的任何函数调用，这些为整个程序使用的变量称为全局变量
强制声明全局变量：global 语句 #强制声明为全局变量，注意：必须运行global所在函数后才能使用
如：
#全局变量和局部变量实例
a=10def fun1():b=20global cc=30print "3者和为：",a+b+cprint "----------------打印全局变量a为：",aprint "---------------执行函数开始：------------------------"fun1()print "---------------执行函数结束：------------------------"print "----------------打印函数中global全局变量值为：",c
7.4 函数的返回值
·函数被调用后会返回一个指定的值
·函数调用后默认返回None
·return 人为的返回值
·返回值可以是任意类型
·return执行后，函数终止
·返回值和打印是有区别的
7.5 冗余参数
A.向函数传元组fun(*args)和字典fun(**kwords)
B.传参传递多余的值或者赋值表达式的处理方式：
多余的保存到元组里，如：def f(x,y,*args) #传递的多余值如j被放到元组args中
多余的保存到字典里，如：def f(x,y,z,**kwargs) #传递的多余的赋值如a=3被放到字典kwargs中
实例：
def f(name="mike",age=30):print '-----打印出2个参数内容：%s,%s' % (name,age)'向函数传递元组't1=(33,'mike')f(*t1) #用元组方式传值,根据实参参数顺序赋值传进去'向函数传递字典'dict={'age':35,'name':'Tina'}f(**dict) #用字典方式传值，根据key的名称对应传值进去dict2={'a':30,'b':'micheel'}f(dict2['b'],dict2['a']) #字典key和函数形参不同时，则带上key用values来传递'处理多余实参'def fun2(x,*args): #多余传参，用元组。使用*args元组作为不确定要输入多少种数据print x,print argsfun2(1,2,3,'','hello') #输出时,对于多余的实参放到args元组中def fun3(x,y,*args,**kwargs):#多余传参，用字典print x,print y,print args,print kwargsfun3(1,'abc',2,3,4,name='t1') #传参时,如果有赋值的参数传递的 用字典
8.python对象
python使用对象类型来存储数据，任何类型都是一个对象。 python 的对象都拥有三个特性：名字、类型、值，如同一个人。
“名字”是它的唯一的身份来标识自己，所以这个名字应该在“一定范围内”具有唯一性。
“类型”决定了这个对象可以保存什么样类型的值，可以进行什么样的操作。
“值”表示了对象的数据项。
举个例子： i = 10
这里就声明了一个对象，它的名字叫i，是一个int(整数)，它的值是10。在声明一个对象的时候，我们使用等号（=）。值得注意的是：在这里并没有显式地写出它是一个int（整数），当你给他赋值的时候，计算机会自动识别出来它是一个int。
对象（变量）的名字不是可以随便起的，它可以由字符、数字、下划线（_）组成。但是，它不能用数字作为开头，不能有空格。
示例：
数字： 1234
字符串："apam" 'god'
表： [1,[1,2],”name”]
元组： (1,(1,2),”name”)
字典： ｛”food”:”bean”,”drink”:”cocacola”｝
文件： myFile = open(‘xxx.txt’,’r’)
其他类型：None, Boolean 等等。
python 同时支持8进制和16进制的数字。
8进制（以数字0开头）： num2 = 017
16进制（以“0x”开头）： num3 =0x92
下面来看看长整型（就是很大很大的整数），
需要注意的是：python中的长整型与c或其他编译语言中的长整型不同，它不需要范围是32位或者是64位。python的长整型长度至于你机器支持的（虚拟）内存的大小有关。换句话说，它可以表达很大很大的数值。那么怎么表示一个长整型呢，在后面加一个小写的“l”就可以了。
例如：num = 123456789012345678901234567890l （想要多长就多长）
11.复杂的运算在python中当我们要表达乘方的意思的时候使用** 例如 3**3＝27
示例：
import math
print math.pi
print math.sqrt(64)
A.一致性原则：在表示一个完整的字符串的时候，在字符串的两头，要么全是双引号，要么全是单引号就可以。
B.复杂的一种情况是：如果字符串中本来就带有符号呢？
一种解决方法是：用双引号来包裹整个字符串。如：print "what's your name?"
一种更好的方法，隆重推出反斜杆符号“\”：我们通过反斜杠符号来告诉计算机，这里的引号不是用来标记字符串，而是字符串本身的字符之 一。如：print "what\'s your name?"
C.如果字符串太长我想分几行来写怎么办？ 用三引号（"""）
如：
text = """Hello, what is your name?
My name is hanmeimei
And you?
My name is lilei"""
print text
D.还有一个问题，如果想要打印出一个字符串的某个字符应该怎么做呢？
#打印第三个字符
str = "python"
print str[2]
E.字符串相关有用的函数
Find()函数是一个基本的查找操作，它返回传入参数的首位的位置。
如：str = “mengma.com”
print str.find(“ng”)
结果：2
replace（）函数会对字符串进行搜索，然后替换掉符合要求的字符。
如：print str.replace(“ma”,”ba”)
结果： ‘mengba.com’
split()函数可以依照传入的参数将字符串进行拆分，
如：s = ‘www.mengma.com.cn’
print s.split(‘.’)
结果：[‘www’,’mengma’,’com’,’cn’]
13.内建函数内建函数:绝大多数函数是我们自己写的，但是日常工作中有一些函数实现的功能是非常基本的，并且大家对结果的要求都一致，这些函数就预先被写好允许大家进行直接的调用，我们称之为“内建函数”。
如：
type(23)
print int("32")
print int(3.13)
14.数学函数我们首先用Import引入了模块：math。然后就通过“.”来直接调用math中的函数以及变量了。可以看到，通过math中内置好的函数，我们可以完成很多科学计算，而根本不用重写这些复杂的函数。
如：
import math
print math.sqrt(4)
print math.pi
print math.sin(30)
15.函数的组合 可以看到结果，试想如果我们把这些都写在playSong这个函数里，这个函数该有多么复杂！更为重要的是，我们在这里做了一个解耦的工作，当第一句歌词需要修改的时候，我们只需要在printLyrics1中修改即可，改正的结果就可以反映在其他调用它的函数中。也许你现在还感受不到，因为例子中只有一个函数调用了printLyrics1，当有很多函数都在调用它的时候，优势就会非常明显：一次修改，处处适用。
示例：
def printLyrics1():
print "what I got to do to make you love me "
print "what I got to do to make you care"
def printLyrics2():
print "what can I do when lighting strikes me"
print "and wake to find you not there"
def playSong():
printLyrics1()
printLyrics2()
print "it's sad,so sad,it's sad sad situation"
playSong()
16.函数变量的适用域
18. 取列表中的值
在编写函数的过程中，我们可能根据需要在函数内部声明一些变量。这些变量的寿命非常短，函数在使用它们的时候非常残忍，“狡兔死，走狗烹”，用完就毁灭它们是这些变量的命运。然而在外部本来就存在的变量不会遭此厄运。
示例：
dog = “wangwang ”
cat = “mimi ”
def friends(dog,cat):
animal = dog + “ ” + cat
print animal,”are friends!”
friends(dog,cat)
print dog
print cat
print animal
运行一下，可以看到。在函数运行后，在函数外本来就存在的dog, cat依然存在。但是在函数内部产生的变量：animal，虽然在函数运行的时候产生并存在，当函数执行完之后就死亡了。解释器会产生:name ‘animal’ is not definded。这样的错误。
这样的设定并不意味着残忍，而是一般在函数运行中产生的变量，一般只会在函数内部产生作用。如果让它一直存在下去，会是对资源极大的浪费。如果在函数之外你会多次用到animal这个变量，正确的做法是：把animal = dog + cat从函数中提出来，放在更“广阔”的域中。
17. 列表为了更好的组织数据，我们让一个电影列表长成这个样子：
movies = [“Avata”,”Titannic”,” The Dark Knight Rises”,” Jurassic Park”,” Dances with Wolves”]
year = [2009,1997,2012,1997,1990]
directors = [“James Cameron”,” James Cameron”,” Christopher Nolan”,” Steven Spielberg”,” Kevin Costner”]
可以看到，pyhon列表的可读性是非常好的。列表在外貌上有以下的特点：
列表的开始和结束要加上中括号
采用逗号将列表的项与项分开
使用“=”号操作符将整个列表赋予一个变量
列表中可以放置任意的数据类型，如果是字符串，需要打上引号（还记得吗？单引号、双引号都可以）
和数组一样，列表的第一个元素的索引是从0开始的。也就是说第一个元素的序号是0，第二个元素是1，第三个元素是2。但是你可能还不知道的是：它还可以倒着来数，最后一个的序号是-1，倒数第二的序号是-2。方法即：切片、索引
movies = [“Avata”,”Titannic”,” The Dark Knight Rises”,” Jurassic Park”,” Dances with Wolves”]
有了序号，我们来看看怎样来访问列表中的元素呢。Python采用中括号”[ ]”标记法来取出元素，中括号里是该元素的序号。
print movies[0]
print movies[-1]
示例：对于moives列表，如果我想访问列表中最后一个元素（Dances with Wolves）的第一个元素（D）怎么做呢？
movies = ["Avata", "Titannic", "The Dark Knight Rises", "Jurassic Park", "Dances with Wolves"]
print movies[-1][0]
19.切片
Python中采用":"来切片内容，":"前后是需要切片的元素。
这里大家需要特别注意的是：切片操作的两端意义并不相同，如果用数学符号来表示，那就是”[ )”的关系。或者简单的说[A ：B]表达的是：从A开始（包括A）到B之前（不包括B）的内容。 -------------口诀：左闭合右开启 或 左>= 右<
如：movies = ["A", "B", "C", "D", "E"]
访问第2个和第3个元素，正确的语法应该是：print movies[1:3]
print movies[:2] 截取第三个元素之前（不包括第3个元素）的所有元素
print movies[1:] 截取第二个元素之后（包括第2个元素在内）的所有元素
print movies[::1] 从起始点开始一步一取，即 ["A", "B", "C", "D", "E"]
print movies[::2] 从起点开始两步一取，即['A', 'C', 'E']
print movies[-1] 取倒数第一个值即E
print movies[::-1] 数组反过来取值，即['E', 'D', 'C', 'B', 'A']
print movies[-1:-3:-1] 数组反过来取值从倒数第一到第三个，即['E', 'D'] 备注：第三位是控制方向的顺序(正数)或逆序(负数)
列表是序列式的数据类型，可以通过下标来访问列表中的某一个元素或者一些元素。它可以保存任何数目，任意对象类型的非常灵活的容器。
示例:
avatar = ["Avatar", 2009, "James Cameron"]
titannic = ["Titannic",1997, "James Cameron"]
theDarkKnightRises = ["The Dark Knight Rises",2012,"Christopher Nolan"]
jurassicPark = ["Jurassic Park",1997, "Steven Spielberg"]
dancesWithWolves = ["Dances with Wolves",1990,"Kevin Costner"]
print [avatar,titannic,theDarkKnightRises,jurassicPark,dancesWithWolves]
结果：
终端：[['Avatar', 2009, 'James Cameron'], ['Titannic', 1997, 'James Cameron'], ['The Dark Knight Rises', 2012, 'Christopher Nolan'], ['Jurassic Park', 1997, 'Steven Spielberg'], ['Dances with Wolves', 1990, 'Kevin Costner']]
21.序列及特点什么都可以扔进去
列表、元组、字符串都是序列
序列的2个主要特点是索引操作符和切片操作符：
索引操作符让我们可以从序列中抓取一个特定项目；
切片操作符让我们获取到序列的一个切片，即一部分序列。
序列的基本操作：movies = ["A", "B", "C", "D", "E"] test1=["F"]
len():求序列长度 即：print len(movies) 结果：5+：连接2个序列 即：print movies+test1 结果： ["A", "B", "C", "D", "E","F"]*：重复序列元素 即：print test1*2 结果：["F","F"]in：判断元素是否在序列中 即：print "F" in test1 结果：Truemax()：返回最大值 即：print max(movies) 结果：Emin()：返回最小值 即：print min(movies) 结果：Acmp(tuple1,tuple2)：比较2个序列值是否相等 比对方式依次为：类型->长度->大小
即：print cmp(movies,test1) 结果：-1 相等为0，前大于后为1，前小于后会-1
#####列表操作
1.增（append()、extend()、insert()）
A.任何数据的容器都离不开四个操作：增、减、改、删。这些操作都是通过Python中自带的内建函数来实现的。在列表加入一个元素，使用到了内建函数append（）
如：
movies = ["Avata", "Titannic", "The Dark Knight Rises", "Jurassic Park", "Dances with Wolves"]
movies.append("Story")
print movies
运行结果：
['Avata', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves', 'Story']B.如果添加的不是一个元素，而是一个元素集合，比如一个列表呢？我们采用extend()内建函数来在一个列表的末尾添加一个元素集合。
如:
movies=["Avata","Titannic","The Dark Knight Rises","Jurassic Park","Dances with Wolves"]
movies.append("jack chen is chenglong")
otherMovies = ["King Kong","King Kong"]
movies.extend(otherMovies)
print movies
结果:
['Avata', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves', 'jack chen is chenglong', 'King Kong', 'King Kong']C.同样新的列表也是自动被加到了原列表的末尾。当然，我们不仅满足于此，还想把一个元素添加在其他位置，尤其是中间的某个位置怎么办呢？我们使用内建的insert（）函数。
Insert函数需要两个参数，一个是将要插入元素的位置，一个是即将插入元素的内容。新元素插入后，原来位置上以及之后的元素就顺移一个位置。比如我们要在movies列表中插入”Xman”,插入的位置是第二个。
movies = ["Avata", "Titannic", "The Dark Knight Rises", "Jurassic Park", "Dances with Wolves"]
movies.insert(1,"李天霸")
print movies
print movies[1]
print movies[1:]
结果:
['Avata', '李天霸', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']
李天霸
['李天霸', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']注意：插入元素的位置与序号之间关系，是从0开始的。删除列表中的元素，我们有两把刀，一把叫”del（delete的缩写）命令”，一把叫”remove函数”
A.使用del命令时候，我们需要传入被删元素的序号。这里我要删除第3个：del movies[2] 或：del movies
B.若想删除一个元素，却不知道它的序号，但是知道它的内容是什么，用remove函数，remove函数需要传入明确的参数内容，而不是序号。它会首先根据内容找到这个元素，然后删掉它。movies.remove(“Jurassic Park”)
3. 改如果想修改一个列表中元素的值，直接给它再次赋值就可以了。
如：
movies[0] = “hero”
print movies[0]
print movies
综合练习：
avatar = ["Avatar", 2009, "James Cameron"]
titannic = ["Titannic",1997, "James Cameron"]
theDarkKnightRises = ["The Dark Knight Rises",2012,"Christopher Nolan"]
jurassicPark = ["Jurassic Park",1997, "Steven Spielberg"]
dancesWithWolves = ["Dances with Wolves",1990,"Kevin Costner"]
#生成一个只有电影名称的列表
movies=[]
movies.append(avatar[0])
movies.append(titannic[0])
movies.append(theDarkKnightRises[0])
movies.append(jurassicPark[0])
movies.append(dancesWithWolves[0])
print movies
#删掉"avata"
del movies[0]
print movies
#把"hero"添加在列表的首位。
movies[0]="hero"
print movies
终端：
['Avatar', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']
['Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']
['hero', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']3. 查
var in list
4. 列表操作符
1.再来介绍两个列表的操作符 + 和 *
“+”就是所谓的连接操作符，通过它我们可以将两个或者多个列表和在一起。下面我们就把这两个列表连起来。
"*"被称为重复操作符，它可以将列表的内容复制相应的倍数。
list1 = [1,2,3]
list2 = ["a","b","c"]
list3=list1+list2 ##也可用list1.extend(list2)
print list3
list2=list2*3
print list2,
终端：[1, 2, 3, 'a', 'b', 'c']['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
示例2：
a = “@”
h = “1”
h *= 3
print a,h,a
终端：@ 111 @
5. 迭代一个列表
在python中采用for循环来迭代列表是大家首先会选择的方法：
示例：
movies = ["A","B","C","D"]
for movie in movies:
print movie
终端输出：A B C D注意：大家可以发现：使用for循环的优点之一是你根本不用考虑列表的大小，for循环适用于任意大小的列表，你不需要先计算出来列表的大小，然后从第0个开始迭代。同时它的可读性非常好。6.列表解析
图中显示了for循环的一种更加简洁的表达方式。
示例：
movies = ["Avata", "Titannic", "The Dark Knight Rises", "Jurassic Park", "Dances with Wolves"]
movie=[movie for movie in movies]
print movie
输出：
['Avata', 'Titannic', 'The Dark Knight Rises', 'Jurassic Park', 'Dances with Wolves']备注：列表解析分为两个部分，第一个部分是”movie”，他代表了列表中的每一个元素的抽象；第二个部分是控制描述语句，这里的”for movie in movies”，如此就遍历了items中的所有的元素，这与for循环中的遍历是一样的。
示例2：
for写法：
for movie in movies:
for letter in movie[0]:
print letter
列表解析写法：print [letter for movie in movies for letter in movie[0]]
输出：['A', 'T', 'T', 'J', 'D']
7. 元组
7.1 元组（tuple） 采用”（）”而不是方括号来包裹元素。是一种不可变的类型,这使得元组可以做很多列表不能做的事情。
7.2 元组是这样的：
元组结构图： 注意：因为一个元组不能被修改，那么”增、减、查、改、删”这些操作我们能做哪些呢？显然增加、减少、修改操作是不能进行的，只有查看和删除操作可以。
如：查看和删除示例：
movies = ["Avata", "Titannic", "The Dark Knight Rises", "Jurassic Park", "Dances with Wolves"]print "第一个：",movies[0];print "最后一个：",movies[-1];print "最后一个单词最后一个字母：",movies[-1][-1];print "第二个之后包含第二个单词的所有单词：",movies[1:];print "第三和第四个单词：",movies[3:];print "第一和第二个单词：",movies[:2];print "第二到第四个单词：",movies[1:3]del movies[-1];print "删除最后一个单词后：",movies;
7.3 元组的可变性： 即元组是可以被扩充的
如：
aTuple=("one","two","three");aTuple=aTuple+("four",);print aTuple;
输出：('one', 'two', 'three', 'four')
7.4 创建元组
一个空的元组：touple()
单个元素元组：touple(item1,)
一般元组：touple("jack",20,"china")
7.5 元组操作用法
如：t1=('jack',30,'male')
A.元组拆分：name,age,gender=t1 则:可以根据name、age、gender获取单独值
8.元组和列表的转化
如果你在维护一些敏感数据，并且需要把这些数据传递给一个你并不了解的函数；或者有时候你只是在维护软件开发的一部分，你并不知道这些敏感的数据将来会被他人如何使用。那么将数据设置成不可变的，会使得这些内容安全很多。
list() 函数用来生成一个空的列表，或者将其他数据转化为列表，包括元组。
tuple()函数用来生成一个空的元组，或者将其他数据转化为元组，包括列表。
如：
aTuple=("one","two","three")print "元组转换为列表：",list(aTuple)print "列表转换为元组：",tuple(list(aTuple))
输出：
9.遍历序列和字典
9.1 序列遍历：
如：
for i in list: #从序列中取值
print i
for i in range(len(list)): #从序列索引中取值
print list(i)
9.2 字典遍历有2种方法：用key来遍历和全遍历
如：
for x in d: #用key遍历
print d[x]
for k,v in d.items():
print k,v #用key和value全部遍历
路选择了就要一直走下去，不要怕跌倒，以后的以后回想起来，对得起自己足以。
posted on 2015-07-28 23:23 georgetest 阅读(811) 评论(0) 编辑 收藏 举报
