Python基础(四) 基础拾遗、数据类型进阶
一、基础拾遗
(一)、变量作用域
外层变量，可以被内层变量直接调用；内层变量，无法被外层变量使用。这种说法在其它语言中适用，在python中除了栈以外，正常的变量作用域，只要执行声明并在内存中存在，该变量就可以在下面的代码中使用。
(二)、位运算符、三元运算
1，位运算符，请看下面代码
1 128 64 32 16 8 4 2 1 2 0 0 0 0 0 0 0 0 3 4 5 #!/usr/bin/env python 6 7 a=60 #00111100 (将十进制转换成二进制,进行位运算) 8 b=13 #00001101 9 c=0 10 11 12 c = a&b #00001100(12) &:按位与运算符,取两个数的交集 13 14 c = a|b #00111101(61) |:按位或运算符,两个数只要有一个是1就行 15 16 c = a^b #00110001(49) ^:按位异或运算符, 取两个值不同 17 18 c = ~a #11000011(-61) ~:按位取反运算符 19 20 c = a<<2 #11110000(240) <<:左移动运算符,向左移动两位,结果就是11110000 21 22 c = a>>2 #00001111(15) >>:右移动运算符,向右移动两位,结果就是00001111
2，三元运算
result = 值1 if 条件 else 值2 #这里我们用到了一个新的函数result，下面看下具体用法：
1 name=input('name:') 2 name:jack 3 if name == 'jack': 4 print('hello') 5 else: 6 print('see you') 7 hello 8 9 result = 'hello' if name == 'jack' else 'see you' #使用result函数可以将上面复杂的流程判断，放到一行就行判断 10 print(result) 11 hello
二、数据类型进阶
一切事物皆对象，首先看几个查看对象的函数：
1 type(类型名) #可以查看对象的类型 2 dir(类型名) #查看类中提供的所有功能 3 help(类型名) #查看类中所有详细的功能 4 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 = '123' 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 1、clear() #清空字典内容
2
3 2、copy() #浅拷贝
4
5 3、get() #根据key获取值
6 >>> dic={'name':'jack'}
7 >>> dic['name'] #正常去key值的方法
8 'jack'
9 >>> dic.get('name') #使用get去取
10 'jack'
11 >>> dic.get('name1')
12 >>> print(dic.get('name1')) #如果key不存在，默认会返回None
13 None
14 >>> print(dic.get('name1','ok')) #也可以定义返回值，这个返回ok
15 ok
16
17 4、has_keys() #判key在不在字典里
18 >>> dic={'name':'jack'}
19 >>> dic.has_key('name') #在python3中没有此模块，使用in来判断在不在字典里
20 True
21
22 5、items() #所有项的列表形式
23 >>> dic={'name':'jack'}
24 >>> dic.items()
25 [('name', 'jack')]
26
27 6、iterkeys() #key可迭代
28 >>> dic={'name':'jack','age':17}
29 >>> for i in dic.iterkeys():
30 ... print(i)
31 ...
32 age
33 name
34
35 7、iteritems() #项可迭代
36
37 8、itervalue() #value值可迭代
38
39 9、pop() #获取并在字典中删除
40 >>> dic={'name':'jack','age':17}
41 >>> dic.pop('age')
42 17
43 >>> dic.items()
44 [('name', 'jack')]
45
46 10、setdefault() #如果key不存在，则创建，如果存在，则返回已存在的值且不修改
47 >>> dict ={}
48 >>> dict['key']='a'
49 >>> dict
50 {'key': 'a'}
51 >>> dict.setdefault('key','b') #如果key存在则返回存在的key
52 'a'
53 >>> dict.setdefault('key0','b') #不存在就会创建
54 'b'
55 >>> dict
56 {'key0': 'b', 'key': 'a'}
57
58 11、update() #更新,用法类似列表extend
59 >>> dic={'name':'jack','age':17}
60 >>> dic1={'sex':'female'}
61 >>> dic.update(dic1)
62 >>> dic
63 {'age': 17, 'name': 'jack', 'sex': 'female'}
64
65 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在实际工作中的用途：
1 练习：寻找差异 2 # 数据库中原有 3 old_dict = { 4 "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }, 5 "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } 6 "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } 7 } 8 9 # cmdb 新汇报的数据 10 new_dict = { 11 "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 }, 12 "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 } 13 "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 } 14 } 15 16 需要删除：？ 17 需要新建：？ 18 需要更新：？ 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
1 old_set = set(old_dict.keys()) #将old_dict的key转换成集合 2 update_list = list(old_set.intersection(new_dict.keys())) #对比old_dict的key值和new_doct的key值之间的交集保存成列表 4 new_list = [] 5 del_list = [] 6 7 for i in new_dict.keys(): 8 if i not in update_list: 9 new_list.append(i) 10 11 for i in old_dict.keys(): 12 if i not in update_list: 13 del_list.append(i) 14 15 print update_list,new_list,del_list
