python基础2

 

一.作用域
变量只有在内存中存在，我们才可以应用这个变量。换句话说，只要声明即可使用

二.三元运算 ： 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) <==> x+y #用于返回x+y的和

>>> 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) #返回当前数的 十六进制 表示 

>>> x 6 >>> hex(x) '0x6'

>>> 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