一.作用域
变量只有在内存中存在，我们才可以应用这个变量。换句话说，只要声明即可使用
二.三元运算 ： name = 值1 if 条件 else 值2
eg1:
name = "jachy" if true: name = "sd" else: name = "2d"
eg2:
name = 值1 if 条件 值2 （如果条件为真，name=值1，否则，name=值2）
即：name = "sd" if true else "2d"
value = raw_input("plz input :")
name = "sd" if value == "jachy" else "good people"
print name
三 进制
1.二进制，01
2.十进制，0-9
3.八进制，0-7
4.十六进制，0123456789ABCDE
四.字符串、列表、集合
1.查看列表功能的方法1
>>> li=[11,12] >>> type(li) #通过type()查看对象类型 <type 'list'> >>> dir(li) #查看列表类的所有的功能 ['__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'] >>>help list #查看列表类的所有的详细功能
>>>help(list.append) #查看指定列表类的append的功能的详细
2.查看列表功能的方法2
>>>dir(list) _方法_ #带下划线的，表示内置方法，其执行方法有多种或一种： 方法： #不带下划线的，非内置方法，其执行方式只有一种：对象.方法
3.创建数
>>> int('11',base=2) #创建二进制的数'11'
3
>>> int('11',base=10) ##创建十进制的数'11'
11
>>> int('11',base=16) #创建一个16进制的数'11'
17
4.数据类型的犯法
整型和浮点型 :int 和 float
x.__cmp__(y) <==> cmp(x,y) #比较两个数x和y的大小
>>> cmp(1,2) -1 或 >>> x=1 >>> y=2 >>> x.__cmp__(y) #这里是双下划线 -1
>>> x.__add__(y) 3 >>> x+y 3
x.__abs__() <==> abs(x) #用于返回x的绝对值
>>> z=-3 >>> abs(z) 3 或 >>> z.__abs__() 3
x.__divmod__(y) <==> divmod(x, y) #将x/y得到商和余数，用于web网页分页使用
>>> x=6 >>> y=4 >>> x.__divmod__(y) (1, 2) #返回一个元组，其中1为商，2为余数 >>> divmod(x,y) (1, 2)
x.__float__() <==> float(x) #将整型x转化为float类型
>>> x.__float__() 6.0 >>> float(x) 6.0
x.__coerce__(y) <==> coerce(x, y) #强制生成一个元组
>>> x
6
>>> y
4
>>> x.__coerce__(y) (6, 4)
x.__hash__() <==> hash(x) #如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。
x.__hex__() <==> hex(x) #返回当前数的 十六进制 表示
>>> age=18
>>> age.__hex__()
'0x12'
x.__oct__() <==> oct(x) #返回改值的 八进制 表示
>>> oct(x) '06'
x.__int__() <==> int(x) #转换为整数
>>> int(2.0) 2 >>> int(2.3) 2
x.__str__() <==> str(x) #转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式
x.__repr__() <==> repr(x) #转化为解释器可读取的形式 """
str---字符串:
S.capitalize() -> string #首字母变大写
>>> s='jachy' >>> s.capitalize() 'Jachy'
S.center(width[, fillchar]) -> string #内容居中，width：总长度；fillchar：空白处填充内容，默认无
>>> s='jachy' >>> s.center(10,'-') #分配10个位，并将jachy居中，空位用-填充 '--jachy---'
S.count(sub[, start[, end]]) -> int # 子序列个数(也可以指明start、end--开始、结束位置，不包括结束位置，类似于切片)
>>> s='hello jachy'
>>> s.count('l',0)
2
>>> s.count('l',3)
1
>>> s.count('l',4)
0
>>> s.count('l',4)
0
>>> s.count('l',3)
1
>>> s.count('l',2,3)
1
S.expandtabs([tabsize]) -> string #将tab转换成空格，默认一个tab转换成8个空格 ，tabsize可以指定空格数量
>>> s='jachy ' >>> s.expandtabs(2) 'jachy '
S.find(sub [,start [,end]]) -> int #寻找子序列位置并返回该位置，如果没找到，则返回-1
>>> s='hello jachy'
>>> s.find('e')
1
>>> s.find('j',8,9)
-1
S.format(*args, **kwargs) -> string #字符串格式化，动态参数，将函数式编程时细说
""" 子序列位置，如果没找到，则就报错 """
S.index(sub [,start [,end]]) -> int
>>> s='hello jachy'
>>> s.index('ll')
2
>>> s.index('he')
0
""" 是否是字母和数字 """
S.isalnum() -> bool
""" 是否是字母 """
S.isalpha() -> bool
""" 是否小写 """
S.islower() -> bool
""" 连接 """
S.join(iterable) -> string
""" 内容左对齐，右侧填充 """
S.ljust(width[, fillchar]) -> string
""" 分割，前，中，后三部分 """
S.partition(sep) -> (head, sep, tail)
""" 替换 """ 找到所有的进行转换
S.replace(old, new[, count]) -> string
""" 分割， maxsplit最多分割几次 """
S.split([sep [,maxsplit]]) -> list of strings
>>> a='hello world,jachy'
>>> a.split(' ')
['hello', 'world,jachy']
>>> s='i love china'
>>> s.split(' ')
['i', 'love', 'china']
>>> s='iphone,and,ipad'
>>> s.split(',')
['iphone', 'and', 'ipad']
S.translate(table [,deletechars]) -> string
""""转换，需要先做一个对应表，最后一个表示删除字符集合
intab = "aeiou"
outtab = "12345"
trantab = string.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print str.translate(trantab, 'xm') #先去str中'xm'删除，完了以后再做转换
"""
>>> import string >>> itab='aeiou' >>> outtab='12345' >>> trantab=string.maketrans(itab,outtab) #使用之前需要导入string包
>>> str='this is string example .....wow!!!'
>>> print str.translate(trantab,'xm') #先去str中'xm'删除，完了以后再做转换
th3s 3s str3ng 21pl2 .....w4w!!!
注意：
import string
string.maketrans(xx,xx)
===>unicode经过编码可以变成utf-8，utf-8经过解码可以变成unicode
===>unicode经过编码可以变成GBK，GBK经过解码可以变成unicode
编码用===>.encode('utf-8')或.encode('gbk')
解码用===>.decode('utf-8')或.
>>> "无"
'\xe6\x97\xa0'
>>> str1 = "'\xe6\x97\xa0'"
>>> str1.decode('utf-8') #将utf-8的解码成Unicode
u"'\u65e0'"
>>> str1.decode('utf-8').encode('gbk') #再将其编码成gbk格式的码
"'\xce\xde'"
>>> print str1.decode('utf-8').encode('gbk')
'Ϟ'
============================
字符串格式化
>>> name = "i am {0},age {1}"
>>> name.format("jachy",21)
'i am jachy,age 21'
或
>>> name = "i am {a},age {b}" #指定参数名{a},{b}
>>> name.format(a="jachy",b=21) #给定的参数名赋值
'i am jachy,age 21'
或
>>> name = "i am {0},age {1}"
>>> li = ["jachy",21] #可以构造列表/元组，向里面传参数
>>> name.format(*li) #但是列表/元组名上面必须加*
'i am jachy,age 21'
或
>>> name = "i am {ss},age {dd}"
>>> dic = {'ss':"jachy",'dd':21} #也可以使用字典，向里面传参数
>>> name.format(**dic) #但是字典必须在字典名前面加2个*
'i am jachy,age 21'
===========================
大小写转换
>>> name = "HAHAHHA" >>> name.lower() #让大写变小写 'hahahha' >>> name.lower().upper() #让小写变大写 'HAHAHHA' 或 >>> name = "Hello" >>> name.swapcase() #将大小写相互转换 'hELLO'
字符串分割
>>> name
'Hello'
>>> name.partition('e')
('H', 'e', 'llo')
=================================
字符串拼接
>>> 'jachy'*5 'jachyjachyjachyjachyjachy'
===================================
list：
#返回value在L列表中出现的次数
""" L.count(value) -> integer -- return number of occurrences of value """
#在源列表扩展
""" L.extend(iterable) -- extend list by appending elements from the iterable """
=====================
>>> li [11, 33, 44] >>> li.extend([99,22]) >>> li [11, 33, 44, 99, 22]
======================
#返回第一个出现的值的下标，不出现就返回异常
L.index(value, [start, [stop]]) -> integer -- return first index of value.
>>> li [11, 12] >>> li.index(12) 1
#在指定位置插入元素
""" L.insert(index, object) -- insert object before index """
>>> li [11, 12] >>> li.insert(1,14) #在第1个位置插入10 >>> li [11, 14, 12]
#删除并且返回指定下标的值，
L.pop([index]) -> item -- remove and return item at index
=====================================
>>> li [11, 44, 99, 22] >>> age = li.pop() >>> print age 22
==================================
#移除列表中的某一项（若有重复的的value，就移除第一个）
L.remove(value) -- remove first occurrence of value.
>>> li [11, 14, 12] >>> li.remove(14) >>> li [11, 12]
#将原来的列表进行翻转
""" L.reverse() -- reverse *IN PLACE* """
>>> li [11, 12] >>> li.reverse() >>> li [12, 11]
#数字按从小到大排序，字母按ASCII码排序
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
>>> li [12, 11] >>> li.sort() >>> li [11, 12]
dict：
#移除字典里面的所有项
"" D.clear() -> None. Remove all items from D.
# 根据key获取值，d是默认值 。若key存在就返回value，否则返回none
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
========================
>>> dic = {1:'hello',2:'world'}
>>> dic.get(1)
'hello'
>>> dic.get(2)
'world'
=========================
#浅copy()只能copy第一层 ，用于修改字典多层里使用
""" D.copy() -> a shallow copy of D """
# 深copy
import copy
f = copy.deepcopy(c) #在字典的多层
#按列表中的值为键，返回一个字典
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
=================
>>> a = {}
>>> a.fromkeys([1,2,3],'t') #以列表中的值为键，NEW一个字典
{1: 't', 2: 't', 3: 't'}
>>>c = {}
================
#
""" 返回所有项的列表形式 """
""" D.items() -> list of D's (key, value) pairs, as 2-tuples """
>>> dic.items() [(1, 'hello'), (2, 'world')]
#如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
>>> dic
{1: 'hello', 2: 'world'}
>>> dic.setdefault(1) #存在则返回
'hello'
>>> dic
{1: 'hello', 2: 'world'}
>>> dic.setdefault(3,'jachy') #不存在则创建
'jachy'
>>> dic
{1: 'hello', 2: 'world', 3: 'jachy'}
#更新
{'name':'alex', 'age': 18000}
[('name','sbsbsb'),]
"""
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
""" 所有的值 """
""" D.values() -> list of D's values """
>>> dic
{1: 'hello', 2: 'world', 3: 'jachy'}
>>> dic.values()
['hello', 'world', 'jachy']
#判断是否是字典
>>> type(dic) is dict True
set:
>>> a=[1,2,3]
>>> c=set(a)
>>> c
set([1, 2, 3])
c & d #取两个集合的交集
>>> c set([1, 2, 3]) >>> b=set([2,3,4]) >>> b set([2, 3, 4]) >>> b & c set([2, 3]
c | d #去两个集合的并集
>>> b | c set([1, 2, 3, 4])
c ^ d #取两个的集合的非交集
>>> b set([2, 3, 4]) >>> c set([1, 2, 3]) >>> b ^ c set([1, 4])
c -d #取c里面有 ，d里面没有的
d -c #取d里面有，c里面没有的
>>> c set([1, 2, 3]) >>> b set([2, 3, 4]) >>> c-b set([1]) >>> b-c set([4])
c.issubset(d) #判断c是否是d的子集
c.issuperset(d) #判断c是否是d的父集
>>> b.issubset(c) False >>> d=set([2,3]) >>> d set([2, 3]) >>> d.issubset(c) True
>>> c.issuperset(d)
True