初学python(三)

一.细说元组(tuple)

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

               不支持对元组内容增删改,但对于引用类型,可以修改其空间的内容

                我们也可以对元组进行连接组合，

    1.创建空元组,

tup1 = ();

    2. 删除整个元组

del tup;

    3.元组运算符可以使用 +(代表连接) *(代表复制) 最后产生新的元组

    4.函数    len(),max(),min(),tuple() :将列表转化为元组 

    in , for x in tup:遍历,并且支持切片[:]

    5.元组的打包,解包 t = 'a','b','c'       a,b,c = t

    优势:元组运算速度比列表快,鉴于不能修改,所以安全

二.细说字典(dictionary)

    字典:可变类型,可以存储任意类型对象,键值对形式,键唯一且必须是不可变类型,值则不必,

    语法 d = {key1 : value1,key2 : value2}

    创建字典 dict = {'abc' : 456} 键一般是字符串,也可以是数字或其他不可变类型

    增和改 dict['aaa'] = 888  如果字典中不存在改键则新增,否则修改. 

    删除 del dict  也可删除一个元素 del dict['aaa']

     函数 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() 随机返回并删除字典的一对键和值(一般末尾)

三,细说集合(Sets)

   1. 集合:无序,唯一

        语法: set =  {1,2,3}

    set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象

    2.顺口一题什么是不可变对象  

        对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这        样，就保证了不可变对象本身永远是不可变的。

    3.定义集合 当定义一个空集合是 使用 set()函数,如果直接 = { } 被视为字典

        这这里说一下,一开始我的疑惑,因为set集合是只能存放不可变对象,也就是不能放字典,或列表 ,那我就用set()试了下,发现可 以,这个主要是因为,set(seq)是将其他类型,转换成set集合,所以当你放集合是,直接强转了.

        如果 你是 set = {[1],2},这样编译实惠报错的,你放字符串的或是会默认拆分的,但因为是无序,可能位置会不一样

   4.集合的方法:

        set.add(x) 添加

        set.update(set2) 使set2更新set    

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

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

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

        set.clear() 清空集合

5.集合的数学运算

并且支持 差集,并集,交集,对称差集
print(set1.union(set2))#1,2,3,4,5,6 并集(但集合不会重复)    同(set1|set2)
print(set1.intersection(set2))#3,4  交集  同 (set1&set2)
print(set1.difference(set2))#{1, 2} 差集  同 (set1 - set2)
print(set1.symmetric_difference(set2))#对称差集{1, 2, 5, 6}  同 (set1^set2)

set1<=set2     等同于s1.issubset(s2)               判断s1是否s2的子集

set1>=set2     等同于s1.issuperset(s2)            判断s1是否s2的超集

                                  s1.isdisjoint(s2)              判断s1和s2是否交集                           

四,细说函数

    函数:函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段

      语法 :

def 函数名（参数列表）:
    函数体        

   [return <返回值>]

    调用函数 直接函数名即可,有返回值变量直接接收

python 函数的参数传递：

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

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

注:以下内容开始一直疑惑,后来看到这篇帖子,就copy了下.嘿嘿出自忍冬的你

Python中函数传递参数的形式主要有以下五种，分别为位置传递，关键字传递，默认值传递，不定参数传递（包裹传递）和解包裹传递。

声明函数时，参数中星号(*)可以单独出现，例如:

def f(a,b,*,c):
    return a+b+c

用法：星号（*）后的参数必须用关键字传入,也就是c。经过测试,*,c这种和*d只能同时出现一个

Python中函数的参数有4种形式，分别是：

1. 位置或关键字参数(Positional-or-keyword parameter)  就是最普通的
2. 仅位置的参数(Positional-only parameter)                    很少,没见过
3. 任意数量的位置参数(var-positional parameter)            *d
4. 任意数量的关键字参数(var-keyword parameter)           *kw

1. 位置或关键字参数应该在最前面，其中，没有默认值的应该在有默认值的参数前面
2. 任意数量位置参数应该放在所有位置或关键字参数的后面
3. 任意数量关键字参数应该放在任意数量位置参数的后面

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

五.匿名函数

    所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

sum = lambda [arg1 [,arg2,.....argn]]:expression

    调用匿名函数 :sum(1,2)

六,变量的作用域

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

    global  修改全局作用作用域

    nonlocal 修改嵌套函数的外部作用域

a = 10
def test():
    a = a + 1
    print(a)
test()

错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。