Python3元组、字典及函数



Python3 元组

Python 的元组与列表类似，但元组的元素不能修改。

元组使用小括号（），列表使用方括号[ ]。

元组创建，在括号中添加元素，并使用逗号隔开即可。

>>> tup2 = (1, 2, 3, 4, 5 );

>>> tup3 = "a","b", "c", "d"; # 不需要括号也可以

>>> type(tup3) #判断类型

创建空元组: tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

>>> tup1 = (50)

>>> type(tup1) # 不加逗号，类型为整型

>>> tup1 = (50,)

>>> type(tup1) # 加上逗号，类型为元组

 

元组与字符串类似，下标索引从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)还是原结果