Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号内添加元素，并用逗号隔开即可。
例如:
tup=('Google',"Runoob",1997,2000)
不需要括号也可以
tup1='a','b','c',12,12.3
创建空元组: tup1=();
元组中只包含一个元素时，需要在元素后面添加逗号，否则数据类型就不是元组了
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
通过下标访问元组或者可以遍历
修改元组:
元组中的元素值是不能修改的，但我们可以对元组 进行连接组合。
删除元组:
元组中的元素值是不允许删除的，但我们可以使用del语句删除整个元组，
元组被删除后，输出 变量会有异常信息。
元组运算符:
与字符串一样，元组之间可以 使用 + 号 和 * 号进行运算，这就意味着他们可以组成和复制，
运算后会生成一个新的元组 。
元组的内置函数:
计算元组的个数 len(tuple)
返回 元组中元素最大值: max(tuple);
返回元组中元组最小值 : min(tuple);
将列表转换为元组 ： tuple(list)
Python3字典
字典是另一种可变容器模型，且可存储任意类型对象
字典的每个键值(key => value)对用冒号(:)分割，每个对之间用逗号分割，
整个字典包括在花括号{}中，格式如下:
d = {key1: value1 , key2 : value2};
键必须是唯一的，但值则不必。
值可以是任意数据类型，但键必须是不可变的，如字符串，数字或元组。
删除字典元素:
del dict["Name"] #删除键 'Name'
dict.clear() #清空字典
del dict #删除字典
字典的内置函数和方法:
计算字典元素的个数，即键的总数 len(dict)
输出字典，以字符串的形式表示 ： str(dict)
返回变量类型 : type(vaiable)
python字典的内置方法:
直接赋值：其实就是对象的引用（别名）。
浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
深度拷贝需要导入模块 #import copy
删除字典内所有元素 : dict.clear()
返回一个字典的浅复制: dict.copy()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 ： dict.fromkeys()
返回指定键的值，如果值不在字典中放回defalut值 ： dict.get(key,defalut=None)
如果键在字典中返回true，否则返回 false ： key in dict
以列表返回可遍历的(键，值)元组数组 ： dict.items()
以列表返回一个字典所有的键 ： dict.keys()
和get()相似，但如果键不存在字典中，将会添加并将值设为default ： dict.setdefault
将dict2的键和值更新到dict字典中 dict.update(dict2);
以列表返回字典中的所有值 ： dict.values()
删除字典给定键key所对应的值，返回值为别删除的值。key必须给出，否则，返回default值。
Set集合:
set集合是一个无序不重复元素的集合。基本功能包括关系测试和消除重复元素。集合 对象还支持
union(联合)，intersection(交)，difference(差)和sysmmetric_difference(对称差集)等数学运算。
大括号或set()函数可以 用来创建集合 。
注意:
想要创建空集合，你必须使用set()而不是{}。{}用于 创建空字典；
a={"peace","peace","rong","rong","nick"}
b=set(["peace","peace","rong","rong"])
#演示联合
print(a|b)
#演示交
print(a&b)
#演示差
print(a-b)
#对称差集
print(a^b)
#输出：
{'peace', 'rong', 'nick'}
{'peace', 'rong'}
{'peace', 'rong', 'nick'}
{'peace', 'rong'}
{'nick'}
{'nick'}
Python3函数:
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
参数
以下是调用函数时可使用的正式参数类型：
- 必需参数
- 关键字参数
- 默认参数
- 不定长参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误
关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
例：# 关键字参数:**kw
def person(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
person('Frank','37')
person('Frank','37',city='Shanghai')
person('Frank','37',gender='M',job='Engineer')
也可以写成下面的简约形式：
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)
注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
默认参数:(缺省参数)缺省参数必须写在后面,可以不指定参数名，但是顺序要保证，否则要指定参数名
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：
>>> calc(1, 2)
5
>>> calc()
0
如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
比如定义一个函数，包含上述若干种参数：
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
最神奇的是通过一个tuple和dict，你也可以调用上述函数：
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = () kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
小结
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
变量作用域：
全局变量与局部变量的作用域不同
生命周期不同
全局变量:
g_a=10
def test2():
global g_a#告诉程序这里是一个全局变量
g_a=20
print(g_a)
def test3():
print(g_a)
test2()
test3()
当全局变量和局部变量同名时，局部变量优先
匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式，函数体比 def 简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
python 使用 lambda 来创建匿名函数
语法：lambda [arg1 [,arg2,.....argn]]:expression
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
def XXX(arg1,arg2):
return arg1+arg2
sum=XXX(10,20)
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
def add(a,b,fun):
print(fun(a,b))
add(11,22,lambda arg1, arg2: arg1 - arg2)