初学Python（三）

Tuple(元组)

        元组区别

     Python 的元组与列表类似，不同之处在于元组的元素不能修改

      元组使用小括号，列表使用方括号

     元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

        元组快速入门使用

                        元组可以使用下标索引来访问元组中的值

                        元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

       元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

        运算符

                       与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。表达式如下：

                                 1.     len()----------返回长度

                                 2.     +         ----------链接

                                 3.     *          ----------复制

                                 4.     in         ----------判断元素是否存在

                           5.     for x in (1,2)   ---代送

        索引和截取

     因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素.用法:变量【头下标:尾下标】（注:尾下标从-1开始）

   

         函数

                            len()            ---------列表元素个数

                            max             ---------返回列表元素最大值

                            min             ---------返回列表元素最小值

                            tuple(List)   ---------将列表转换为元组

dictionary(字典)

        快速入门

                  键唯一，值有序

                       字典是另一种可变容器模型，且可存储任意类型对象。

      字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。

      向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

      能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令

        字典健的特性

                  1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记

      2.键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行  

        函数

                    len()            --------- 计算字典元素个数，即键的总数。

                    str()             ---------输出字典，表示可以打印的字符串

                    type()            ---------返回输入的变量类型，如果变量是字典就返回字典类型。

        方法

                

              dict.clear() 清空字典所有值

             dict.copy()  返回一个字典潜复制

              dict.fromkeys()  创建一个新字典,以序列seq中元素做字典的键，val为字典所有键对应的初始值

              dict.get(key,default = None) 返回指定键的值,不存在返回default

              key in dict  如果key在字典中返回true 

              dict.items() 以列表返回可遍历的(键,值)元组数组

               dict.keys() 返回字典所有键

                dict.setdefault(key,default = None) 给指定键赋值,不存在给默认值

                dict.update(dict2) 把字典2 更新到dict中 

                dict.values() 以列表返回所有值

                dict.pop(key[,default]) 删除字典给定key的值,返回被删除的值,key必须给,否则返回default

                dict.popitem() 随机返回并删除字典的一对键和值(一般末尾)

Set(集合)

         快速入门

                    set:集 合 是 一 个 无 序 不 重 复 元素 的 集 

                    基 本 功 能 包 括 关 系 测 试 和 消 除 重 复 元 素

                    集 合 对 象 还 支 持 union( 联合),intersection(交),difference(差)和 sysmmetric difference(对称差集)等数学运算

                    大括号或 set() 函数可以用来创建集合。 注意:想要创建空集合,你必须使用set() 而不是 {} 。{}用于创建空字典；{}

                

         方法

                 set.add(x) 添加

                set.update(set2) 使set2更新set    

                set.pop()  删除并返回集合中任意

                set.remove(x)  删除集合中x,无则报错

                set.discard(x)  删除集合中x,无则什么也不做

                set.clear() 清空集合

函数

      快速入门

               函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

      任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数

                    函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明

     函数内容以冒号起始，并且缩进

     return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

      定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

      这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行

python 函数的参数传递：   

            不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

            可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

1.位置传递实例：  

def fun(a,b,c)

　　return a+b+c

 

print(f(1,2,3))

 

2.关键字传递

关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。

def fun(a,b,c)

　　return a+b+c

 

print(f(1,c=3,b=2))

 

3.参数默认值

在定义函数的时候，使用形如c=10的方式，可以给参数赋予默认值(default)。如果该参数最终没有被传递值，将使用该默认值。

def f(a,b,c=10):
　　return a+b+c

 

print(f(3,2))
print(f(3,2,1))

在第一次调用函数f时， 我们并没有足够的值，c没有被赋值，c将使用默认值10.第二次调用函数的时候，c被赋值为1，不再使用默认值。

4.包裹传递

在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。

下面是包裹位置传递的例子：

 

def func(*name):
　　print type(name)
　　print name

 

func(1,4,6)
func(5,6,7,1,2,3)

两次调用，尽管参数个数不同，都基于同一个func定义。在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递。

 

为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号。

下面是包裹关键字传递的例子：

def func(**dict):
　　print type(dict)
　　print dict

 

　　func((1,9))
　　func("a":2,"b":1,"c":11)

与上面一个例子类似，dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加**。

 包裹传递的关键在于定义函数时，在相应元组或字典前加*或**。

5.解包裹

*和**，也可以在调用的时候使用，即解包裹(unpacking), 下面为例：

 

def func(a,b,c):
　　print a,b,c

 

args = (1,3,4)
func(*args)

dict = {'a':1,'b':2,'c':3}
func(**dict)

在这个例子中，所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数。在调用func时使用*，是为了提醒Python：我想要把args拆成分散的三个元素，分别传递给a,b,c。（设想一下在调用func时，args前面没有*会是什么后果？） 

相应的，也存在对词典的解包裹，使用相同的func定义，然后：在传递词典dict时，让词典的每个键值对作为一个关键字传递给func