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)