入门知识：
一、关于作用域：
对于变量的作用域，执行声明并在内存中存在，该变量就可以在下面的代码中使用。
if 10 == 10:
name = 'allen'
print name
以下结论对吗？
外层变量，可以被内层变量使用
内层变量，无法被外层变量使用
以上结论，对于其他语言适用，对于python 不适用
** 记住：python，只要内存里存在，则就能适用 （栈 ）
二、三元运算：
1）、普通循环：
if name == “test”:
name = “坏人”
print name
else:
name = “好人”
print name
2）、以下是三元运算：
格式：
name = 值
name = 值1 if 条件 else 值2
如果条件为真：result = 值1
如果条件为假：result = 值2
name = ‘坏人’ if name == test else “好人”
#用户输入内容，得到值
#运算，得结果：如果用户输入 Allen, 坏人，否则，好人
python基础
对于Python，一切事物都是对象，对象基于类创建
一、整型：
如：1，2，3，4，5
学会查看帮助：
type(类型名) 查看对象的类型
dir(类型名) 查看类中提供的所有功能
help(类型名) 查看类中所有详细的功能
help( 类型名.功能名) 查看类中某功能的详细
内置方法，非内置方法
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
类中的方法：
方法： 内置方法，可能有多种执行方法，
>>> n1 = 1
>>> dir(n1)
['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']
以下都是整型一些方法：
add：求和：
>>> n2 = 2
>>> n1 + n2
3
>>> n1.__add__(n2)
3
abs 求绝对值
>>> n1 = -8
>>> n1.__abs__(）返回绝对值
8
>>> abs(-9)
9
int：整型转换：
>>> i = 10
>>> i = int(10)
>>> i
10
>>> i = int("10",base=2)
>>> i
2
>>> i = int("11",base=2) （2代表二进制）
>>> i
3
>>> i = int("F",base=16)
>>> i
15
cmp：两个数比较：
>>> age = 20
>>> age.__cmp__(18) 比较两个数大小
1
>>> age.__cmp__(22)
-1
>>> cmp(18,20)
-1
>>> cmp(22,20)
1
coerce：商和余数，强制生成一个元组：
>>> i1 = 10
>>> i1.__coerce__(2)
(10, 2) (强制生成一个元组)
divmod：分页，相除，得到商和余数组成的元组
>>> a = 98
>>> a.__divmod__(10)
(9, 8) #相除，得到商和余数组成的数组，这个一定要会
float：转换为浮点类型
>>> type(a)
<type 'int'>
>>> float(a) 转换为浮点类型
98.0
>>> a.__float__()
98.0
floordiv ：地板浮点型
>>> 5 /2
2
>>> 5 // 2
2
>>> 5.0/2
2.5
>>> 5.0//2
2.0
hash：
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。
>>> ha = "Allen"
>>> ha.__hash__()
85081331482274937
>>> h1 = 18
>>> h1.__hash__()
18
hex：16进制表示
>>> age = 18
>>> age.__hex__()
‘0x12'
oct:返回8进制表示：
>>> age = 18
>>> age.__oct__()
'022'
index:用于切片，数字表示无意义
init：
构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
>>> i = 10
>>> i = int(10)
int：转换为整型
>>> a = "2"
>>> type(a)
<type 'str'>
>>> a = int(a)
>>> type(a)
<type 'int'>
pow:幂次方：
>>> pow(2,4)
16
如下两个面试可能会遇到(repr,str)：
repr
"""转化为解释器可读取的形式 “""
str
"""转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
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"""
二、字符串：
str：转换成str类型：
>>> s = str("abc")
capitalize:首字母变大写:
>>> s.capitalize()
‘Abc'
center:内容居中：
>>> name = "Allen"
>>> name.center(20)
' Allen '
>>> name.center(20,"*”) """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 “""
'*******Allen********’
count：子序列个数：
>>> name = "skkkdssslklsiks"
>>> name.count('s',0,10) """ 子序列个数 """
4
>>> name.count('s',0,15)
6
>>> name.count('s',0,20)
6
三种字符编码转换知识：
unicode、 utf-8、 gbk
utf-8 —> unicode（通过解码方法转换：decode）
gbk —> unicode (通过解码方法转换：decode)
unicode —> utf-8 (通过编码方法转换：encode)
unicode —> gbk (通过编码方法转换：encode)
编码转换：
解码：
>>> str2 = “好"
>>> str2
'\xe5\xa5\xbd’
>>> print str2.decode('utf-8')
好
>>> print str2.decode('utf-8').encode('gbk')
endswith：以...结束：
>>> a = "backend www.yyh.com"
>>> a.endswith('com')
True
startswith：以...开始：
>>> a.startswith('backend')
True
expandtabs：将tab转换成空格，默认一个tab转换成8个空格
>>> name = 'hi allen'
>>> name.expandtabs(1)
'hi allen'
>>> name.expandtabs(2) #这里2，代表转换成2个空格
'hi allen’
>>> jj = name.expandtabs(2)
>>> len(jj)
10
find：找子序列位置，如果没找到，返回 -1
>>> name = ‘Allen'
>>> name.find('l’) """ 寻找子序列位置，如果没找到，则异常 “""
1
>>> name = 'Allen'
>>> name.find('a')
-1
find , index 区别：
find 找不到不会报错，index，找不到会报错
>>> name = "haowwss"
>>> name.find('s',0,4)
-1
>>> name.index('s',0,4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> name.index('s',0,10) """ 子序列位置，如果没找到，则返回-1 """
5
字符串格式化：
方法一：
>>> name = 'I am {0},age {1}’
>>> name
'I am {0},age {1}'
方法二：
format：字符串格式化
1）传入字符串：
>>> name.format('Allen',25) """ 字符串格式化 “”"
'I am Allen,age 25'
>>> name = 'I am {ss},age {dd}'
>>> name.format(ss="Allen",dd=26)
'I am Allen,age 26’
2）传入一个列表：
>>> li = [1111,3333]
>>> name = 'I am {0},age {1}’
>>> name.format(*li) (传列表加一个“*”)
'I am 1111,age 3333’
3）传入一个字典：
name = 'I am {ss},age {dd}’
>>> dic = {'ss':111,'dd':333}
>>> name.format(**dic)
'I am 111,age 333’
isalnum：是否是字母和数字
>>> a
‘howareyou’
>>> a.isalnum()
True
>>> a = "__"
>>> a.isalnum()
False
>>> a = '123'
>>> a.isalnum()
True
isalpha：是否是字母
>>> a
'123'
>>> a.isalpha()
False
>>> a = 'allen'
>>> a.isalpha()
True
isdigit：是否是数字
>>> a = '123'
>>> a.isdigit()
True
>>> a = 'allen'
>>> a.isdigit()
False
islower：是否小写
>>> a = 'allen'
>>> a.islower()
True
>>> a = 'Allen'
>>> a.islower()
False
istitle：是否是标题
>>> name = "Hello Allen"
>>> name.istitle()
True
>>> name = "Hello allen"
>>> name.istitle()
False
swapcase:大小写转换
>>> name = "Hello allen"
>>> name.swapcase()
'hELLO ALLEN’
split:分隔：
>>> name.split('l’)
['He', '', 'o a', '', 'en']
>>> name.rsplit('l')
['He', '', 'o a', '', 'en’]
python 字符串方法源码：
def isupper(self):
"""
S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
"""
return False
def join(self, iterable):
""" 连接 """
"""
S.join(iterable) -> string
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
def ljust(self, width, fillchar=None):
""" 内容左对齐，右侧填充 """
"""
S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
def lower(self):
""" 变小写 """
"""
S.lower() -> string
Return a copy of the string S converted to lowercase.
"""
return ""
def lstrip(self, chars=None):
""" 移除左侧空白 """
"""
S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def partition(self, sep):
""" 分割，前，中，后三部分 """
"""
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
"""
pass
def replace(self, old, new, count=None):
""" 替换 """
"""
S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
def rfind(self, sub, start=None, end=None):
"""
S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
def rindex(self, sub, start=None, end=None):
"""
S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
"""
return 0
def rjust(self, width, fillchar=None):
"""
S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
def rpartition(self, sep):
"""
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
"""
pass
def rsplit(self, sep=None, maxsplit=None):
"""
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
"""
return []
def rstrip(self, chars=None):
"""
S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def split(self, sep=None, maxsplit=None):
""" 分割， maxsplit最多分割几次 """
"""
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
"""
return []
def splitlines(self, keepends=False):
""" 根据换行分割 """
"""
S.splitlines(keepends=False) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return []
def startswith(self, prefix, start=None, end=None):
""" 是否起始 """
"""
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return False
def strip(self, chars=None):
""" 移除两段空白 """
"""
S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def swapcase(self):
""" 大写变小写，小写变大写 """
"""
S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
"""
return ""
def title(self):
"""
S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
"""
return ""
def translate(self, table, deletechars=None):
"""
转换，需要先做一个对应表，最后一个表示删除字符集合
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!"
print str.translate(trantab, 'xm')
"""
"""
S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256 or None.
If the table argument is None, no translation is applied and
the operation simply removes the characters in deletechars.
"""
return ""
def upper(self):
"""
S.upper() -> string
Return a copy of the string S converted to uppercase.
"""
return ""
def zfill(self, width):
"""方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
"""
S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
"""
return ""
def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
pass
def _formatter_parser(self, *args, **kwargs): # real signature unknown
pass
def __add__(self, y):
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y):
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y):
""" x.__eq__(y) <==> x==y """
pass
def __format__(self, format_spec):
"""
S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
"""
return ""
def __getattribute__(self, name):
""" x.__getattribute__('name') <==> x.name """
pass
def __getitem__(self, y):
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j):
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y):
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y):
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self):
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, string=''): # known special case of str.__init__
"""
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
# (copied from class doc)
"""
pass
def __len__(self):
""" x.__len__() <==> len(x) """
pass
def __le__(self, y):
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y):
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y):
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, n):
""" x.__mul__(n) <==> x*n """
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 __ne__(self, y):
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self):
""" x.__repr__() <==> repr(x) """
pass
def __rmod__(self, y):
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, n):
""" x.__rmul__(n) <==> n*x """
pass
def __sizeof__(self):
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __str__(self):
""" x.__str__() <==> str(x) """
pass
三、列表：常用的几个方法
以下方法需要学会：
append：追加到一个列表
count：次数
extend：添加
index：索引值，即下标
insert：插入
pop：弹出
remove：删除
reverse：翻转
sort：排序
四、元组
count：次数
>>> a = (1,2,3,4,1,2,3,4)
>>> a.count(2)
2
index：索引值，下标
>>> tu = ("a",'b','c')
>>> tu.index('a')
0
五、字典
字典取值：
>>> dic = {'allen':1234,'yyh':123}
>>> dic
{'allen': 1234, 'yyh': 123}
>>> dic['allen']
1234
get：get方法得到value，不存在返回None
>>> dic.get('kk')
>>> print dic.get('kk’)
None
>>> print dic.get('kk','OK’) #写上OK，则返回OK
OK
>>> print dic.get('kk','TT')
TT
以下方法需要学会
clear：清除内容
copy：浅拷贝
fromkeys：生成字典
has_key：是否有key
get：根据key获取值
items：所有项的列表形式
iteritems：项可迭代
keys：所有的key列表
iterkeys：key可迭代
itervalues：value可迭代
pop：获取并在字典中移除
popitem：获取并在字典中移除(从头开始删除)
del：删除元素
setdefault (不存在则创建，存在则不创建)
update：更新
values：所有项，只是将内容保存至view对象中
cmp：比较
name_dic= {1:11,2:22}
>>> type(name_dic) is dict
True
>>> a = {}
>>> a.fromkeys([12,32],'t')
{32: 't', 12: 't’}
六、set集合：
set是一个无序且不重复的元素集合
功能：去重 & | ^ -
issubset 查看是否是某个集合的子集
issuperset 查看是否是某个集合的父集
以下方法多加练习：
add：添加
clear：清除
copy：浅copy
difference：
difference_update：删除当前set中的所有包含在 new set 里的元素
discard：移除元素
intersection：取交集，新创建一个set
intersection_update：取交集，修改原来set "
isdisjoint：如果没有交集，返回true
issubset：是否是子集
issuperset：是否是父集
pop：移除
remove：移除
symmetric_difference：差集，创建新对象
symmetric_difference_update：差集，改变原来
union：并集
update：更新
and
cmp
练习：寻找差异
数据库中原有
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())
update_list = list(old_set.intersection(new_dict.keys()))
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
collection系列:
1)计数器:Counter
Counter是对字典类型的补充，用于追踪值的出现次数
具备字典的所有功能 + 自己的功能
c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
2）有序字典
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序
3默认字典
defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}
作业：
1.打印购物车列表
死循环
输入一共多少钱
iphone 6s
mac
输入要买的：1
已把【iphone】加入购物车，还有多少钱
最后退出
打印已买的商品 （第二次输入不需要输入工资，相当于存入文件）
2.开发一个简单的计算器程序
*实现对加减乘除、括号优先级的解析,并实现正确运算 （如果用到递归会有A+）
3*5/ -2 - (8 * 3/(20+3/2-5) +4 /(3-2)* -3) = 3