一、基础拾遗
(一)、变量作用域
外层变量，可以被内层变量直接调用；内层变量，无法被外层变量使用。这种说法在其它语言中适用，在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