Python3 元组
Python 的元组与列表类似，但元组的元素不能修改。
元组使用小括号（），列表使用方括号[ ]。
元组创建，在括号中添加元素，并使用逗号隔开即可。
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a","b", "c", "d"; # 不需要括号也可以
>>> type(tup3) #判断类型
<class 'tuple'>
创建空元组: tup1 = ();
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
元组可以使用下标索引来访问元组中的值
元组中的元素值不允许修改、不允许删除，但可使用del语句来删除整个元组（会有异常信息）
可以对元组进行+和*运算
元组内置函数
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。
>>> list1= ['Google', 'Taobao','Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')
注意：
"可变的"tuple：
代码如下:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
tuple所谓的"不变"是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
Python3 字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
d = {key1 : value1, key2 :value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
字典-增删改查
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令
键值对：
d = {key1 : value1, key2 : value2 }
增：d["键"]=值
删：del d["键"]
改：d["已存d在的键"]=值
查：d.get("键"),d["键"]
字典遍历：len(d)
keys()：所有键组成的列表
values()：所有值组成的列表
items():是键和值组成的元组再组成的列表
字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
字典内置函数&方法
函数len(dict) 计算字典元素个数，即键的总数。
str(dict) 输出字典，以可打印的字符串表示。
>>> dict = {'Name': 'Runoob','Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First','Age': 7}"
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
内置方法：
radiansdict.clear() 删除字典内所有元素
radiansdict.copy() 返回一个字典的浅复制
radiansdict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
key in dict 如果键在字典dict里返回true，否则返回false
radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() 以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
radiansdict.values() 以列表返回字典中的所有值
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。
Set集合：set （集合）。集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合），intersection（交），difference（差）和 sysmmetric difference（对称差集）等数学运算。
大括号或 set() 函数可以用来创建集合。 注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典
Python3函数
1. 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
语法：
def 函数名（参数列表）:
函数体
return XXX
可以返回多个值，返回的多个值组成一个元组，返回值加上一对中括号，则返回一个列表
函数分为定义和调用
2. 可更改(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也会受影响
3. 调用函数时可使用的正式参数类型：
必需参数
关键字参数：关键字参数允许你传入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。
默认参数:(缺省参数)缺省参数必须写在后面,可以不指定参数名，但是顺序要保证，否则要指定参数名
不定长参数(可变参数):
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
但是调用的时候，需要先组装出一个list或tuple：
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：
如果已经有一个list或者tuple，要调用一个可变参数怎么办？
Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
参数组合使用
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。
eg：定义一个函数，包含上述若干种参数：
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)
调用上述函数：
>>> 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)的形式调用它，无论它的参数是如何定义的。
小结：默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
4. 匿名函数：
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)
5. 三个重要的大数据用到的函数：
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
>>> print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]
>>> print map(lambda x: x * 2 + 10, foo)
[14, 46, 28, 54, 44, 58, 26, 34, 64]
>>> print reduce(lambda x, y: x + y, foo)
139
pythonmap()
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
使用lambda函数
pythonfilter():对于序列中的元素进行筛选，最终获取符合条件的序列
li = [11, 22, 33]
new_list = filter(lambda arg: arg > 22, li)
注意:s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时，默认删除空白符（包括'\n','\r', '\t', ' ')
python中的reduce
python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 func()（必须是一个二元操作函数）先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。
如：
def myadd(x,y):
return x+y
sum=reduce(myadd,(1,2,3,4,5,6,7))
print sum
#结果就是输出1+2+3+4+5+6+7的结果即28
当然，也可以用lambda的方法，更为简单：
sum=reduce(lambdax,y:x+y,(1,2,3,4,5,6,7))
print sum
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。
reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
6、python中的排序：
python中自定义排序函数:
Python内置的 sorted()函数可对list进行排序：
>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]
但 sorted()也是一个高阶函数，可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。
因此，实现倒序排序：只需要编写一个reversed_cmp函数：调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序：
sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较
排序方法与排序函数区分
sort()排序方法
shus.sort()对原有列表进行排序，改变原来列表的顺序，无返回值
print(shus)就是改变后的列表
sorted()排序函数
排序时不影响原数据，产生新的排序数据
print(sorted(shus))排序后的结果
print(shus)还是原结果