python--第二天总结

一、作用域
只要变量在内存中存在，则就可以使用.（栈）

二、三元运算
result = 值
result = 值1 if 条件 else 值2

如果条件为真：result = 值1
如果条件为假：result = 值2

三、帮助用法
type  查看对象的类型
dir(类型名) 查看类中提供的所有功能

help(类型名)  查看类中所有详细功能

help(类型名.功能名)  查看类中某一个功能的详细

类中的方法：
   __方法__   内置方法 ,可能有多种执行方法，至少一种
   
   方法       非内置方法    的执行只有一种
   
 四、函数 
divmod(a,b)函数
中文说明：
divmod(a,b)方法返回的是a//b（除法取整）以及a对b的余数

find()函数

find 找不到 -1
index 报错

五、字符串格式化
name = 'i am {0},age {1}'
name.format('alex',19)
        
name = 'i am {ss},age {dd}'
name.format(ss='alex',dd=80)       
   
li = [1,2]
name = 'i am {0},age {1}'
name.format(*li)

dic = {'ss':123,'dd':456}
name = 'i am {ss},age {dd}'

name.format(**dic)

截取字符串,如果索引为负数，就是相当于从后向前数,下标可以为空表示取到头或尾
 a = 'a1aa2'
 a[0:1]  [左包含，右不包含]
 a[0:-1]
 a[0:]

import string
intab = "aeiou"
outtab = "12345"
trantab = string.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print str.translate(trantab, 'xm')
        
        
 六、列表的功能      
  list.append(obj)                 # 向列表中添加一个对象obj
  list.count(obj)                  # 返回一个对象obj在列表中出现的次数
  list.extend(seq)                 # 把序列seq的内容添加到列表中
  list.index(obj,i=0,j=len(list))  # 返回list[k] == obj 的k值,并且k的范围在i<=k<j;否则异常 （##取出在列表中的位置）
  list.insert(index,obj)           # 在索引量为index的位置插入对象obj
  list.pop(index=-1)               # 删除并返回指定位置的对象,默认是最后一个对象 (##删除时按照下标删除)
  list.remove(obj)                 # 从列表中删除对象obj (##删除时按照内容删除,只删除第一个出现的)  
  list.reverse()                   # 原地翻转列表
  list.sort(func=None,key=None,reverse=False)  # 以指定的方式排序列表中成员,如果func和key参数指定,则按照指定的方式比较各个元素,如果reverse标志被置为True,则列表以反序排列     
     字母按照asic 中文按照unicode  
        
  七、元组    
 元组的元素不能被修改，元素的元素可以被修改。       
  八、字典的功能     
    dict.clear()                            # 删除字典中所有元素
    dict copy()                             # 返回字典(浅复制)的一个副本
    dict.fromkeys(seq,val=None)             # 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对的初始值
    dict.get(key,default=None)              # 对字典dict中的键key,返回它对应的值value,如果字典中不存在此键,则返回默认值
    dict.has_key(key)                       # 如果键在字典中存在,则返回True 用in和not in代替
    dicr.items()                            # 返回一个包含字典中键、值对元组的列表
    dict.keys()                             # 返回一个包含字典中键的列表
    dict.iter()                             # 方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表
    dict.pop(key[,default])                 # 和方法get()相似.如果字典中key键存在,删除并返回dict[key]
    dict.setdefault(key,default=None)       # 和set()相似,但如果字典中不存在key键,由dict[key]=default为它赋值
    dict.update(dict2)                      # 将字典dict2的键值对添加到字典dict
    dict.values()                           # 返回一个包含字典中所有值得列表

九、set集合

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

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object

    Build an unordered collection of unique elements.
    """
    def add(self, *args, **kwargs): # real signature unknown
        """ 添加 """
        """
        Add an element to a set.

        This has no effect if the element is already present.
        """
        pass

    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. """
        pass

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. """
        pass

    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set.

        (i.e. all elements that are in this set but not the others.)
        """
        pass

    def difference_update(self, *args, **kwargs): # real signature unknown
        """ 删除当前set中的所有包含在 new set 里的元素 """
        """ Remove all elements of another set from this set. """
        pass

    def discard(self, *args, **kwargs): # real signature unknown
        """ 移除元素 """
        """
        Remove an element from a set if it is a member.

        If the element is not a member, do nothing.
        """
        pass

    def intersection(self, *args, **kwargs): # real signature unknown
        """ 取交集，新创建一个set """
        """
        Return the intersection of two or more sets as a new set.

        (i.e. elements that are common to all of the sets.)
        """
        pass

    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ 取交集，修改原来set """
        """ Update a set with the intersection of itself and another. """
        pass

    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ 如果没有交集，返回true  """
        """ Return True if two sets have a null intersection. """
        pass

    def issubset(self, *args, **kwargs): # real signature unknown
        """ 是否是子集 """
        """ Report whether another set contains this set. """
        pass

    def issuperset(self, *args, **kwargs): # real signature unknown
        """ 是否是父集 """
        """ Report whether this set contains another set. """
        pass

    def pop(self, *args, **kwargs): # real signature unknown
        """ 移除 """
        """
        Remove and return an arbitrary set element.
        Raises KeyError if the set is empty.
        """
        pass

    def remove(self, *args, **kwargs): # real signature unknown
        """ 移除 """
        """
        Remove an element from a set; it must be a member.

        If the element is not a member, raise a KeyError.
        """
        pass

    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """ 差集，创建新对象"""
        """
        Return the symmetric difference of two sets as a new set.

        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ 差集，改变原来 """
        """ Update a set with the symmetric difference of itself and another. """
        pass

    def union(self, *args, **kwargs): # real signature unknown
        """ 并集 """
        """
        Return the union of sets as a new set.

        (i.e. all elements that are in either set.)
        """
        pass

    def update(self, *args, **kwargs): # real signature unknown
        """ 更新 """
        """ Update a set with the union of itself and others. """
        pass

    def __and__(self, y): # real signature unknown; restored from __doc__
        """ x.__and__(y) <==> x&y """
        pass

    def __cmp__(self, y): # real signature unknown; restored from __doc__
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __contains__(self, y): # real signature unknown; restored from __doc__
        """ x.__contains__(y) <==> y in x. """
        pass

    def __eq__(self, y): # real signature unknown; restored from __doc__
        """ x.__eq__(y) <==> x==y """
        pass

    def __getattribute__(self, name): # real signature unknown; restored from __doc__
        """ x.__getattribute__('name') <==> x.name """
        pass

    def __ge__(self, y): # real signature unknown; restored from __doc__
        """ x.__ge__(y) <==> x>=y """
        pass

    def __gt__(self, y): # real signature unknown; restored from __doc__
        """ x.__gt__(y) <==> x>y """
        pass

    def __iand__(self, y): # real signature unknown; restored from __doc__
        """ x.__iand__(y) <==> x&=y """
        pass

    def __init__(self, seq=()): # known special case of set.__init__
        """
        set() -> new empty set object
        set(iterable) -> new set object

        Build an unordered collection of unique elements.
        # (copied from class doc)
        """
        pass

    def __ior__(self, y): # real signature unknown; restored from __doc__
        """ x.__ior__(y) <==> x|=y """
        pass

    def __isub__(self, y): # real signature unknown; restored from __doc__
        """ x.__isub__(y) <==> x-=y """
        pass

    def __iter__(self): # real signature unknown; restored from __doc__
        """ x.__iter__() <==> iter(x) """
        pass

    def __ixor__(self, y): # real signature unknown; restored from __doc__
        """ x.__ixor__(y) <==> x^=y """
        pass

    def __len__(self): # real signature unknown; restored from __doc__
        """ x.__len__() <==> len(x) """
        pass

    def __le__(self, y): # real signature unknown; restored from __doc__
        """ x.__le__(y) <==> x<=y """
        pass

    def __lt__(self, y): # real signature unknown; restored from __doc__
        """ x.__lt__(y) <==> x<y """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more): # real signature unknown; restored from __doc__
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __ne__(self, y): # real signature unknown; restored from __doc__
        """ x.__ne__(y) <==> x!=y """
        pass

    def __or__(self, y): # real signature unknown; restored from __doc__
        """ x.__or__(y) <==> x|y """
        pass

    def __rand__(self, y): # real signature unknown; restored from __doc__
        """ x.__rand__(y) <==> y&x """
        pass

    def __reduce__(self, *args, **kwargs): # real signature unknown
        """ Return state information for pickling. """
        pass

    def __repr__(self): # real signature unknown; restored from __doc__
        """ x.__repr__() <==> repr(x) """
        pass

    def __ror__(self, y): # real signature unknown; restored from __doc__
        """ x.__ror__(y) <==> y|x """
        pass

    def __rsub__(self, y): # real signature unknown; restored from __doc__
        """ x.__rsub__(y) <==> y-x """
        pass

    def __rxor__(self, y): # real signature unknown; restored from __doc__
        """ x.__rxor__(y) <==> y^x """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ S.__sizeof__() -> size of S in memory, in bytes """
        pass

    def __sub__(self, y): # real signature unknown; restored from __doc__
        """ x.__sub__(y) <==> x-y """
        pass

    def __xor__(self, y): # real signature unknown; restored from __doc__
        """ x.__xor__(y) <==> x^y """
        pass

    __hash__ = None

set

十、深浅拷贝

为什么要拷贝？

当进行修改时，想要保留原来的数据和修改后的数据

数字字符串 和 集合 在修改时的差异？ （深浅拷贝不同的终极原因）
  在修改数据时：
       数字字符串：在内存中新建一份数据
           集合：修改内存中的同一份数据
对于集合，如何保留其修改前和修改后的数据？
    在内存中拷贝一份

对于集合，如何拷贝其n层元素同时拷贝？
    深拷贝