Python基础(四) 基础拾遗、数据类型进阶

一、基础拾遗

(一)、变量作用域

外层变量，可以被内层变量直接调用；内层变量，无法被外层变量使用。这种说法在其它语言中适用，在python中除了栈以外，正常的变量作用域，只要执行声明并在内存中存在，该变量就可以在下面的代码中使用。

(二)、位运算符、三元运算

　　1，位运算符，请看下面代码

 128 64 32 16 8 4 2 1
   0  0  0  0 0 0 0 0

 #!/usr/bin/env python

  a=60      #00111100 (将十进制转换成二进制,进行位运算)
  b=13      #
  c=0

 c =  a&b  #00001100(12)  &:按位与运算符,取两个数的交集

 c =  a|b  #00111101(61)  |:按位或运算符,两个数只要有一个是1就行

 c =  a^b  #00110001(49)  ^:按位异或运算符, 取两个值不同

 c =  ~a   #11000011(-61) ~:按位取反运算符

 c = a<<2  #11110000(240) <<:左移动运算符,向左移动两位,结果就是11110000

 c = a>>2  #00001111(15)  >>:右移动运算符,向右移动两位,结果就是00001111

　　2，三元运算

     result = 值1 if 条件 else 值2    #这里我们用到了一个新的函数result，下面看下具体用法：

 name=input('name:')
 name:jack
 if name == 'jack':
     print('hello')
 else:
     print('see you')
 hello

 result = 'hello' if name == 'jack' else 'see you'            #使用result函数可以将上面复杂的流程判断，放到一行就行判断
 print(result)
 hello

二、数据类型进阶

一切事物皆对象，首先看几个查看对象的函数：

 type(类型名)                 #可以查看对象的类型
 dir(类型名)                  #查看类中提供的所有功能
 help(类型名)                 #查看类中所有详细的功能
 help(类型名.功能名)           #查看类中某功能的详细    

我们执行dir(list)的时候会出现带__add__的和append等，这种都属于类中的方法，分别是：

　　　1，　__方法__:内置方法，可能有多种执行方法，至少一种
　　   2，　方法：只用一种执行方法，对象.方法

下面分类型介绍其类中的方法：

（一）、整数

整数：34、45、56、整数的功能如下:

class int(object):
    """
    int(x=0) -> int or long
    int(x, base=10) -> int or long

    Convert a number or string to an integer, or return 0 if no arguments
    are given.  If x is floating point, the conversion truncates towards zero.
    If x is outside the integer range, the function returns a long instead.

    If x is not a number or if base is given, then x must be a string or
    Unicode object representing an integer literal in the given base.  The
    literal can be preceded by '+' or '-' and be surrounded by whitespace.
    The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
    interpret the base from the string as an integer literal.
    >>> int('0b100', base=0)
    """
    def bit_length(self):
        """ 返回表示该数字的时占用的最少位数 """
        """
        int.bit_length() -> int

        Number of bits necessary to represent self in binary.
        >>> bin(37)
        '0b100101'
        >>> (37).bit_length()
        """
        return 0

    def conjugate(self, *args, **kwargs): # real signature unknown
        """ 返回该复数的共轭复数 """
        """ Returns self, the complex conjugate of any int. """
        pass

    def __abs__(self):
        """ 返回绝对值 """
        """ x.__abs__() <==> abs(x) """
        pass

    def __add__(self, y):
        """ x.__add__(y) <==> x+y """
        pass

    def __and__(self, y):
        """ x.__and__(y) <==> x&y """
        pass

    def __cmp__(self, y):
        """ 比较两个数大小 """
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __coerce__(self, y):
        """ 强制生成一个元组 """
        """ x.__coerce__(y) <==> coerce(x, y) """
        pass

    def __divmod__(self, y):
        """ 相除，得到商和余数组成的元组 """
        """ x.__divmod__(y) <==> divmod(x, y) """
        pass

    def __div__(self, y):
        """ x.__div__(y) <==> x/y """
        pass

    def __float__(self):
        """ 转换为浮点类型 """
        """ x.__float__() <==> float(x) """
        pass

    def __floordiv__(self, y):
        """ x.__floordiv__(y) <==> x//y """
        pass

    def __format__(self, *args, **kwargs): # real signature unknown
        pass

    def __getattribute__(self, name):
        """ x.__getattribute__('name') <==> x.name """
        pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        """ 内部调用 __new__方法或创建对象时传入参数使用 """
        pass

    def __hash__(self):
        """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
        """ x.__hash__() <==> hash(x) """
        pass

    def __hex__(self):
        """ 返回当前数的 十六进制 表示 """
        """ x.__hex__() <==> hex(x) """
        pass

    def __index__(self):
        """ 用于切片，数字无意义 """
        """ x[y:z] <==> x[y.__index__():z.__index__()] """
        pass

    def __init__(self, x, base=10): # known special case of int.__init__
        """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
        """
        int(x=0) -> int or long
        int(x, base=10) -> int or long

        Convert a number or string to an integer, or return 0 if no arguments
        are given.  If x is floating point, the conversion truncates towards zero.
        If x is outside the integer range, the function returns a long instead.

        If x is not a number or if base is given, then x must be a string or
        Unicode object representing an integer literal in the given base.  The
        literal can be preceded by '+' or '-' and be surrounded by whitespace.
        The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
        interpret the base from the string as an integer literal.
        >>> int('0b100', base=0)
        # (copied from class doc)
        """
        pass

    def __int__(self):
        """ 转换为整数 """
        """ x.__int__() <==> int(x) """
        pass

    def __invert__(self):
        """ x.__invert__() <==> ~x """
        pass

    def __long__(self):
        """ 转换为长整数 """
        """ x.__long__() <==> long(x) """
        pass

    def __lshift__(self, y):
        """ x.__lshift__(y) <==> x<<y """
        pass

    def __mod__(self, y):
        """ x.__mod__(y) <==> x%y """
        pass

    def __mul__(self, y):
        """ x.__mul__(y) <==> x*y """
        pass

    def __neg__(self):
        """ x.__neg__() <==> -x """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more):
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __nonzero__(self):
        """ x.__nonzero__() <==> x != 0 """
        pass

    def __oct__(self):
        """ 返回改值的 八进制 表示 """
        """ x.__oct__() <==> oct(x) """
        pass

    def __or__(self, y):
        """ x.__or__(y) <==> x|y """
        pass

    def __pos__(self):
        """ x.__pos__() <==> +x """
        pass

    def __pow__(self, y, z=None):
        """ 幂，次方 """
        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
        pass

    def __radd__(self, y):
        """ x.__radd__(y) <==> y+x """
        pass

    def __rand__(self, y):
        """ x.__rand__(y) <==> y&x """
        pass

    def __rdivmod__(self, y):
        """ x.__rdivmod__(y) <==> divmod(y, x) """
        pass

    def __rdiv__(self, y):
        """ x.__rdiv__(y) <==> y/x """
        pass

    def __repr__(self):
        """转化为解释器可读取的形式 """
        """ x.__repr__() <==> repr(x) """
        pass

    def __str__(self):
        """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
        """ x.__str__() <==> str(x) """
        pass

    def __rfloordiv__(self, y):
        """ x.__rfloordiv__(y) <==> y//x """
        pass

    def __rlshift__(self, y):
        """ x.__rlshift__(y) <==> y<<x """
        pass

    def __rmod__(self, y):
        """ x.__rmod__(y) <==> y%x """
        pass

    def __rmul__(self, y):
        """ x.__rmul__(y) <==> y*x """
        pass

    def __ror__(self, y):
        """ x.__ror__(y) <==> y|x """
        pass

    def __rpow__(self, x, z=None):
        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
        pass

    def __rrshift__(self, y):
        """ x.__rrshift__(y) <==> y>>x """
        pass

    def __rshift__(self, y):
        """ x.__rshift__(y) <==> x>>y """
        pass

    def __rsub__(self, y):
        """ x.__rsub__(y) <==> y-x """
        pass

    def __rtruediv__(self, y):
        """ x.__rtruediv__(y) <==> y/x """
        pass

    def __rxor__(self, y):
        """ x.__rxor__(y) <==> y^x """
        pass

    def __sub__(self, y):
        """ x.__sub__(y) <==> x-y """
        pass

    def __truediv__(self, y):
        """ x.__truediv__(y) <==> x/y """
        pass

    def __trunc__(self, *args, **kwargs):
        """ 返回数值被截取为整形的值，在整形中无意义 """
        pass

    def __xor__(self, y):
        """ x.__xor__(y) <==> x^y """
        pass

    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分母 = 1 """
    """the denominator of a rational number in lowest terms"""

    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 虚数，无意义 """
    """the imaginary part of a complex number"""

    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 分子 = 数字大小 """
    """the numerator of a rational number in lowest terms"""

    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """ 实属，无意义 """
    """the real part of a complex number"""

int

整数类型功能

（二）、字符串

字符串：'name'、'file' ...字符串的功能如下:name = 'jack' 　　　　　　#声明字符串的两种方法

name = str('jack')

1、capitalize()                 　　　　 #capitalize将字符串首字母大写
name.capitalize()
'Jack'

2、center()                    　　　　　#center:内容居中,定义长度，空白用'_'填充
name.center(20,'_')
'________jack________'

3、count()                    　　　　　 #count:找子序列的个数
name = 'my name is jack'
name.count('m')
name.count('m',0,10)        　　　　　　 #从下标0到10之间,统计m出现的次数

4、decode()、encode()
编码之间的关系：unicode万国码<---编码、解码--->utf-8/gbk

'无'
'\xce\xde'
name='\xce\xde'
name.decode('gbk')   　　　　　　　　　　 #用decode解码成unicode，decode(当前使用的编码格式)
u'\u65e0'
name.decode('gbk').encode('utf-8')   　#解码成unicode,编码成utf-8
'\xe6\x97\xa0'
print name.decode('gbk').encode('utf-8')   #打印出乱码
鏃

5、endswith()、startswith()   　　　　  #判断以什么开始或结束
name = 'jack'
name.endswith('k')         　　　　　　 #以k结尾返回True
True
name.startswith('j')        　　　　　　#以j开始返回True
True

6、expandtabs()        　　　　　　　　  #将tab键转换成空格，默认一个tab转换8个空格
name = 'ja  ck'
name.expandtabs()    　　　　　　　　    #默认转换成了8个空格
'ja      ck'
name.expandtabs(1)   　　　　　　　　　　 #设置转换成1个空格
'ja ck'
name.expandtabs(0)     　　　　　　　　　 #去除空格
'jack'

7、find()                    　　　　　　#寻找第一个子序列的位置
name = 'jack'
name.find('c')            　　　　　　  #在字符串中找出c的下标
name.find('m')           　　　　　　   #如果字符串中不包含会返回-1
-1
name.find('ck')            　　　　　　 #如果输入两个，以第一个为准

8、format()               　　　　　　  #字符串格式化
name='my name is {0},age{1}'     　　  #定义占位符
name.format('jack',25)                #按顺序加进去
'my name is jack,age 25'

name='my name is {aa},age {bb}'
name.format(aa='jack',bb=25)          #可以不按顺序加到字符串中
'my name is jack,age 25'

name='my name is {0},age{1}'
list=['jack',25]
name.format(*list)                    #可以传入列表加*
'my name is jack,age25'

dic={'ss':123,'dd':456}               #字典必须跟字符串的位置一样
name='my name is {ss},age {dd}'
name.format(**dic)                          #传入字典加**
'my name is 123,age 456'

9、index()                    #子序列位置,如果没找到直接报错
name='jack'
name.index('k')
name.index('m')            #index和find的区别就是index会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

10、isalnum()               #判断是不是字母或数字
name='jack'
name.isalnum()
True
name='呵呵'
name.isalnum()
False

11、isalpha()                  #判断是不是字母

12、isdigit()                    #判断是不是数字
name = ''
name.isdigit()
True
name = 'jack'
name.isdigit()
False

13、islower()                    #判断是不是都是小写字母

14、isspace()                   #判断是不是空格

15、istitle()                      #判断是不是标题
name = 'jack'
name.title()                     #将name转换成标题
'Jack'
name = 'Hello,Alex'          #直接将首字母大写，就是标题
name.istitle()
True

16、isupper()                     #判断是不是全部都是大写

17、join()                          #连接
name = ['name','jack']
','.join(name)                     #将列表转换成字符串用','分割
'name,jack'

18、ljust()                         #内容左对齐,右侧自定义填充
name = 'Hello,Alex'
name.ljust(20,'=')              #20是宽度，'='为填充符
'Hello,Alex=========='

19、lower()                        #将大写字母变小写
name = 'Hello,Alex'
name.lower()                       #将大写变小写
'hello,alex'
name.upper()                       #将小写变大写
'HELLO,ALEX'
name.swapcase()                 #将小写变大写，大写变小写
'hELLO,aLEX'

20、lstrip()                       #移除左侧空白

21、partition()                 #将字符串分割成前、中、后三部分
name = 'Hello,Alex'
name.partition('ll')           #按ll分割，将字符串分割成三部分
('He', 'll', 'o,Alex')

22、replace()                   #替换
name = 'Hello,Alex'
name.replace('Al','xx')
'Hello,xxex'

23、splitlines()               #根据换行分割

24、translate()               #转换
>>> import string
>>> intab = 'aeiou'
>>> outtab = '12345'
>>> trantab = string.maketrans(intab,outtab)
>>> str = 'this is string example......wow!!!'
>>> print(str.translate(trantab,'xm'))
th3s 3s str3ng 21pl2......w4w!!!

更多字符串的功能使用请使用help(str),或在pycharm中按Ctrl + 左键点击输入的str可以调出帮助信息。

(二)、列表

列表:['jack','bob'],元组不再介绍，列表的具体用法如下：

1、append()                                                #添加到列表的最后
>>> name = ['jack','bob']
>>> name.append('tom')
>>> name
['jack', 'bob', 'tom']

2、count()                                                 #统计出现的次数

3、extend()                                                #将一个列表扩展到另一个列表里
>>> name = ['jack','bob']
>>> name1 = ['henry','tom']
>>> name.extend(name1)
>>> name
['jack', 'bob', 'henry', 'tom']

4、index()                                                 #找到值第一次出现的下标

5、insert()                                                #在指定下标位置插入

6、pop()                                                   #删除并返回指定下标的值，如果没有指定返回最后一个下标的值，还可以使用del进行删除
>>> name = ['jack','bob']
>>> name.pop()
'bob'
>>> name
['jack']

7、remove(值)                                              #移除列表里的匹配的第一个值

8、reverse()                                               #反转列表
>>> name = ['jack','bob']
>>> name.reverse()
>>> name
['bob', 'jack']

9、sort()                                                  #排序

（三）、字典

字典{'name':'jack'},下面介绍字典的功能：

 1、clear()                                          #清空字典内容

 2、copy()                                           #浅拷贝

 3、get()                                            #根据key获取值
 >>> dic={'name':'jack'}
 >>> dic['name']                                     #正常去key值的方法
 'jack'
 >>> dic.get('name')                                 #使用get去取
 'jack'
 >>> dic.get('name1')
 >>> print(dic.get('name1'))                         #如果key不存在，默认会返回None
 None
 >>> print(dic.get('name1','ok'))                    #也可以定义返回值，这个返回ok
 ok

 4、has_keys()                                       #判key在不在字典里
 >>> dic={'name':'jack'}
 >>> dic.has_key('name')                             #在python3中没有此模块，使用in来判断在不在字典里
 True

 5、items()                                          #所有项的列表形式
 >>> dic={'name':'jack'}
 >>> dic.items()
 [('name', 'jack')]

 6、iterkeys()                                       #key可迭代
 >>> dic={'name':'jack','age':17}
 >>> for i in dic.iterkeys():
 ...     print(i)
 ...
 age
 name

 7、iteritems()                                      #项可迭代

 8、itervalue()                                      #value值可迭代

 9、pop()                                            #获取并在字典中删除
 >>> dic={'name':'jack','age':17}
 >>> dic.pop('age')
 17
 >>> dic.items()
 [('name', 'jack')]

 10、setdefault()                                   #如果key不存在，则创建，如果存在，则返回已存在的值且不修改
 >>> dict ={}
 >>> dict['key']='a'
 >>> dict
 {'key': 'a'}
 >>> dict.setdefault('key','b')                    #如果key存在则返回存在的key
 'a'
 >>> dict.setdefault('key0','b')                   #不存在就会创建
 'b'
 >>> dict
 {'key0': 'b', 'key': 'a'}

 11、update()                                      #更新,用法类似列表extend
 >>> dic={'name':'jack','age':17}
 >>> dic1={'sex':'female'}
 >>> dic.update(dic1)
 >>> dic
 {'age': 17, 'name': 'jack', 'sex': 'female'}

 12、values()                                      #所有的值

(四)、set集合

python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。

>>> a = range(5,10)                               #生成一个5-10的列表
>>> b= range(7,12)                                #7-12的列表
>>> a,b
([5, 6, 7, 8, 9], [7, 8, 9, 10, 11])
>>> set(a)                                        #将a转换成集合类型定义给c
set([8, 9, 5, 6, 7])
>>> c = set(a)
>>> c
set([8, 9, 5, 6, 7])
>>> d = set(b)                                   #将b转换成集合类型定义给d
>>> c & d                                        #取 c 和 d 的交集,intersection()
set([8, 9, 7])
>>> c | d                                        #取 c 和 d 的并集union()
set([5, 6, 7, 8, 9, 10, 11])
>>> c - d                                        #取 c 和 d 的差集difference()
set([5, 6])
>>> c ^ d                                        #取 c 和 d 的对称差集（项在t或s中，但不会同时出现在二者中）symmetric_difference()
set([5, 6, 10, 11])

借鉴大王一个例子来阐述set在实际工作中的用途：

 练习：寻找差异
 # 数据库中原有
 old_dict = {
     "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
     "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
     "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
 }

 # cmdb 新汇报的数据
 new_dict = {
     "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
     "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
     "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
 }

 需要删除：？
 需要新建：？
 需要更新：？ 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新

 old_set = set(old_dict.keys())                              #将old_dict的key转换成集合
 update_list = list(old_set.intersection(new_dict.keys()))   #对比old_dict的key值和new_doct的key值之间的交集保存成列表
 new_list = []
 del_list = []

 for i in new_dict.keys():
     if i not in update_list:
         new_list.append(i)

 for i in old_dict.keys():
     if i not in update_list:
         del_list.append(i)

 print update_list,new_list,del_list