在python中,一个对象的特征也称为属性(attribute)。它所具有的行为也称为方法(method)
结论:对象=属性+方法
在python中,把具有相同属性和方法的对象归为一个类(class)
比如人类,动物,植物等等,这些都是类的概念。
类是对象的模板或蓝图,类是对象的抽象化,对象是类的实例化。类不代表具体的事物,而对象表示具体的事物。
具有的功能:
1
|
class int ( object ):
|
(1).返回表示该数字的时占用的最少位数
1
2
3
4
|
def bit_length( self ):
例: >>> bin ( 10 )
'0b1010' #0b是二进制,1010是所占位数
|
(2).返回绝对值
1
2
3
4
5
6
7
|
def __abs__( self ):
例: >>> absolute = - 10
>>> absolute.__abs__() 10 >>> abs ( - 10 )
10 |
(3).相除,得到商和余数组成的元组
1
2
3
4
5
6
|
def __divmod__( self )
例: >>> age = 21
>>> sb = age.__divmod__( 6 )
>>> print (sb)
( 3 , 3 )
|
(4).int转换为浮点类型
(5).__cmp__(self, y)比较两个数大小 注:在3.x版本被
(6).__coerce__(self, y)强制生成一个元组 注:在3.x版本被取消
(7).数值相加
1
2
3
4
5
6
7
8
|
def __add__( self ,other)
例: >>> num1 = 15
>>> num2 = 20
>>> print (num1 + num2)
35 >>> print (num1.__add__(num2))
35 |
(8).布尔值
1
2
3
4
5
6
|
>>> bool = 0
>>> print ( bool .__bool__())
False >>> bool = 1
>>> print ( bool .__bool__())
True |
9. 判断是是否相等
1
2
3
4
|
>>> zhi1 = 10
>>> zhi2 = 11
>>> print (zhi1.__eq__(zhi2))
False |
10. 返回浮点
1
2
3
|
>>> zhi = 10
>>> print (zhi.__float__())
10.0 |
11. 地板除
1
2
3
4
|
>>> a= 10
>>> b= 3
>>> print(a.__floordiv__(b)) 3 |
12. 大于等于
1
2
3
4
|
>>> a = 20
>>> b = 12
>>> print (a.__ge__(b))
True |
13. 大于
1
2
|
>>> print (a.__gt__(b))
True |
14.哈希
1
|
print (num.__hash__())
|
15.__invert__ :取反
1
2
3
|
>>> a = 45
>>> print (a.__invert__())
- 46
|
16.小于等于
1
2
3
4
|
>>> a = 10
>>> b = 20
>>> print (a.__lt__(b))
True |
17. __lshift__ :左移位
1
2
3
4
|
>>> num1 = 10
>>> num2 = 10
>>> print (num1.__lshift__(num2))
10240 |
18.求模
1
2
3
4
|
>>> a = 20
>>> b = 11
>>> print (a.__mod__(b))
9 |
19.相乘
1
2
3
4
|
>>> a = 10
>>> b = 2
>>> print (a.__mul__(b))
20 |
20.取反
1
2
3
|
>>> a = 21
>>> print (a.__neg__())
- 21
|
21.不等于
1
2
3
4
|
>>> a = 20
>>> b = 10
>>> print (a.__ne__(b))
True |
22.取正数
1
2
3
4
5
6
|
>>> a = - 10
>>> print (a.__pos__())
- 10
>>> a = 10
>>> print (a.__pos__())
10 |
23 乘方
1
2
3
|
>>> a = 10
>>> print (a.__pow__( 10 ))
10000000000 |
24.右加(以下前缀为r的都是右;前缀为l的都是左)
1
|
print (a.__radd__(b))
|
25.右或
1
|
print (a.__repr__())
|
26.右除以左,返回商和余数
1
|
print (a.__repr__())
|
27.转换为解释器可读取的形式
1
|
print (a.__repr__())
|
28.转换为字符串
1
2
3
|
>>> a = 10
>>> print (a.__pow__( 10 ))
10000000000 |
29.求差
1
2
3
|
>>>num= 10
>>>num2= 20
print(num.__sub__(num2)) |
2、long型
具有的功能:
1
|
class long ( object ):
|
同int型
3.float型
1.返回分子分母数构成的元祖
1
|
as_integer_ratio() |
2.将十六进制数转换为浮点数
1
|
print ( float .fromhex( '0x1.ffffp10' ))
|
3.将浮点数转换为十六进制数
1
|
print ( 2047.984375 . hex ())
|
4.判断浮点数是不是整数
1
2
3
|
f1 = 10.2
f2 = 10.0
print (f1.is_integer()) 31print (f2.is_integer())
|
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
二.字符串
具有的功能:
1
|
class str ( basestring ):
|
1.首字母变大写
1
2
3
4
5
|
def capitalize( self ):
例: >>> name = 'yaoyao'
>>> print (name.capitalize())
Yaoyao |
2.内容居中
1
2
3
4
5
6
|
def center( self , width, fillchar = None ):
""" 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """ 例: >>> name = 'liuyao'
>>> print (name.center( 20 , '*' ))
* * * * * * * liuyao * * * * * * *
|
3.查询个数
1
2
3
4
5
6
7
|
count( self , sub, start = None , end = None )子序列个数 sub:要查询的子序列 start:开始位置 end:结束位置
例: >>> cou = 'asdfghjasdfgjqweryuzxcvbnm'
>>> print (cou.count( 'as' ))
2 >>> print (cou.count( 'as' , 1 , 25 ))
1 |
4.编码修改
1
2
3
4
5
6
|
encode( self , encoding = None , errors = None )编码,针对 unicode encoding = '解码的格式'
例: >>> name = '刘耀'
>>> print (name.encode( 'gbk' ))
b '\xc1\xf5\xd2\xab'
>>> |
5.endswith
1
2
3
4
5
6
7
|
endswith( self , suffix, start = None , end = None )是否以xxx结尾 suffix:填入结尾的字符串 start = 在第几个字符开始 end = 在第几个字符结束
endswith() 方法用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回 True ,否则返回 False 。可选参数 "start" 与 "end" 为检索字符串的开始与结束位置。
例: >>> name = 'asdfghjklo'
>>> print (name.endswith( 'lo' , 0 , 6 ))
False >>> |
6.expandtabs()
1
2
3
4
5
|
expandtabs() 方法把字符串中的 tab 符号( '\t' )转为空格,默认的空格数 tabsize 是 8
例: >>> extab = 'one\ttwo'
>>> print (extab.expandtabs())
one two |
7.find
1
2
3
4
5
6
7
|
find( self , sub, start = None , end = None )寻找子序列位置,如果没找到,返回 - 1
例: >>> name = 'yaotwosiji'
>>> print (name.find( 'two' , 1 , 8 ))
3 >>> print (name.find( 'two' , 1 , 3 ))
- 1
|
8.casefold
1
2
|
casefold( self )大写转小写 注: 3.x 新增方法, 2.x 没有
例: |
9.format格式化
1
2
3
4
5
6
|
format ( * args, * * kwargs)字符串格式化
例: >>> name = 'liuyao'
>>> age = '21'
>>> print ( '姓名{0},年龄{1}' . format (name,age))
姓名liuyao,年龄 21
|
10.index
1
2
3
4
5
6
7
8
9
|
index( self , sub, start = None , end = None )子序列位置,如果没找到,报错
例: >>> name = 'asdfghjklqwertyui'
>>> print (name.index( 'fg' ))
3 >>> print (name.index( 'fg' , 1 , 3 ))
Traceback (most recent call last): File "<stdin>" , line 1 , in <module>
ValueError: substring not found
|
11.isalnum
1
2
3
4
5
6
7
8
|
isalnum( self )如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True ,否则返回 False
例: >>> zifu = 'yao1995'
>>> print (zifu.isalnum())
True >>> zifutab = 'yao 1995'
>>> print (zifutab.isalnum())
False |
12.isalpha
1
2
3
4
5
|
isalpha( self )如果字符串至少有一个字符并且所有字符都是字母则返回 True ,否则返回 False
例: >>> zifutab = 'yao'
>>> print (zifutab.isalpha())
True |
13.isdigit
1
2
3
4
5
|
isdigit( self )如果字符串只包含数字则返回 True 否则返回 False
例: >>> shuzi = '1995'
>>> print (shuzi.isdigit())
True |
14.islower
1
2
3
4
5
|
islower( self )如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True ,否则返回 False
例: >>> zifu = 'Liuyao'
>>> print (zifu.islower())
False |
15.isspace
1
2
3
4
5
|
isspace( self )如果字符串中只包含空格,则返回 True ,否则返回 False
例: >>> kongge = ' '
>>> print (kongge.isspace())
True |
16.istitle
1
2
3
4
5
|
istitle( self )如果字符串中所有的单词拼写首字母是否为大写,且其他字母为小写则返回 True ,否则返回 False
例: >>> zifu = 'Liu Yao'
>>> print (zifu.istitle())
True |
17.isupper
1
2
3
4
5
|
isupper( self )如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True ,否则返回 False
例: >>> zifu = 'LIU YAO'
>>> print (zifu.isupper())
True |
18.join
1
2
3
4
5
6
|
join( self , iterable)返回通过指定字符连接序列中元素后生成的新字符串
例: >>> lj = '^'
>>> name = ( 'y' , 'a' , 'o' )
>>> print (lj.join(name))
y^a^o |
19.ljust
1
2
|
ljust( self , width, fillchar = None )返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
例: |
20.lower
1
2
3
4
|
lower( self )返回将字符串中所有大写字符转换为小写后生成的字符串
>>> name = 'LIUYAO'
>>> print (name.lower())
liuyao |
21.lstrip
1
2
3
4
|
lstrip( self , chars = None )返回截掉字符串左边的空格或指定字符后生成的新字符串
>>> name = 'liuyaoliuyaoliuyao'
>>> print (name.lstrip( 'liu' ))
yaoliuyaoliuyao |
22.partition
1
2
3
4
|
partition( self , sep)返回一个 3 元的元组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串
>>> who = 'wo shi liuyao'
>>> print (who.partition( 'shi' ))
( 'wo ' , 'shi' , ' liuyao' )
|
23.replace
1
2
3
4
5
6
|
replace( self , old, new, count = None )返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串,如果指定第三个参数 max ,则替换不超过 max 次
>>> str1 = 'ni shi wo shi shei shi'
>>> print (str1.replace( 'shi' , 'ta' ))
ni ta wo ta shei ta >>> print (str1.replace( 'shi' , 'ta' , 1 ))
ni ta wo shi shei shi |
24.split
1
2
3
4
5
6
|
split( self , sep = None , maxsplit = None )通过指定分隔符对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串
>>> str1 = 'a1 b2 c3 d4'
>>> print (str1.split())
[ 'a1' , 'b2' , 'c3' , 'd4' ]
>>> print (str1.split( ' ' , 2 ))
[ 'a1' , 'b2' , 'c3 d4' ]
|
25.splitlines
1
2
3
4
5
6
7
8
9
10
11
12
13
|
splitlines( self , keepends = False )按照行分隔,返回一个包含各行作为元素的列表,如果 num 指定则仅切片 num 个行
>>> str1 = '\na1b2 c3 d4'
>>> str1 = '\na1b2\nc3\nd4\n'
>>> print (str1)
a1b2 c3 d4 >>> print (str1.splitlines())
[' ', ' a1b2 ', ' c3 ', ' d4']
>>> print (str1.splitlines( 2 ))
[ '\n' , 'a1b2\n' , 'c3\n' , 'd4\n' ]
|
26.startswith
1
2
3
4
5
6
|
startswith( self , prefix, start = None , end = None )用于检查字符串是否是以指定子字符串开头,如果是则返回 True ,否则返回 False 。如果参数 beg 和 end 指定值,则在指定范围内检查
>>> name = 'LIUyao'
>>> print (name.startswith( 'LI' ))
True >>> print (name.startswith( 'ya' ))
False |
27.swapcase
1
2
3
4
|
swapcase( self )用于对字符串的大小写字母进行转换
>>> name = 'LIUyao'
>>> print (name.swapcase())
liuYAO |
28.translate
1
|
translate( self , table, deletechars = None )根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中,table - - 翻译表,翻译表是通过maketrans方法转换而来,deletechars - - 字符串中要过滤的字符列表。
|
29.upper
1
2
3
4
|
upper( self )将字符串中的小写字母转为大写字母
>>> name = 'yaoyao'
>>> print (name.upper())
YAOYAO |
30.zfill
1
2
3
4
5
6
|
zfill( self , width)返回指定长度的字符串,width - - 指定字符串的长度。原字符串右对齐,前面填充 0 。
>>> str1 = 'a1 b2 c3 d4'
>>> print (str1.zfill( 10 ))
a1 b2 c3 d4 >>> print (str1.zfill( 15 ))
0000a1 b2 c3 d4
|
三.列表
具有以下方法:
1、追加
1
2
3
4
5
|
append( self , p_object)用于在列表末尾添加新的对象,obj - - 添加到列表末尾的对象,该方法无返回值,但是会修改原来的列表。
>>> lie = [ 1 , 2 , 3 , 4 , 5 ]
>>> lie.append( 6 )
>>> print (lie)
[ 1 , 2 , 3 , 4 , 5 , 6 ]
|
2、统计
1
2
3
4
|
count( self , value)用于统计某个元素在列表中出现的次数,value - - 列表中统计的对象,返回元素在列表中出现的次数。
>>> lie = [ 1 , 2 , 3 , 4 , 5 , 1 , 2 , 3 ]
>>> print (lie.count( 2 ))
2 |
3、合并
1
2
3
4
5
6
7
8
|
extend( self , iterable)用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表),seq - - 元素列表,该方法没有返回值,但会在已存在的列表中添加新的列表内容
>>> list1 [ 1 , 2 , 3 , 4 , 5 ]
>>> list2 [ 'a' , 'b' , 'c' , 'd' , 'f' ]
>>> list1.extend(list2) >>> list1 [ 1 , 2 , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' , 'f' ]
|
4、索引
1
2
3
4
5
|
index( self , value, start = None , stop = None )用于从列表中找出某个值第一个匹配项的索引位置,value - - 查找的对象,该方法返回查找对象的索引位置,如果没有找到对象则抛出异常。
>>> list1 [ 1 , 2 , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' , 'f' ]
>>> print (list1.index( 'a' ))
5 |
5、指定插入
1
2
3
4
5
6
|
insert( self , index, p_object)用于将指定对象插入列表,index - - 对象obj需要插入的索引位置,obj - - 要插入列表中的对象,该方法没有返回值,但会在列表指定位置插
>>> list1 [ 1 , 2 , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' ]
>>> list1.insert( 2 , '6' )
>>> list1 [ 1 , 2 , '6' , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' ]
|
6、删除最后一个元素
1
2
3
4
5
|
pop( self , index = None )用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值,index - - 可选参数,要移除列表元素的对象,该方法返回从列表中移除的元素对象。
>>> list1.pop() 'f' >>> list1 [ 1 , 2 , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' ]
|
7、指定删除
1
2
3
4
5
6
|
remove( self , value)用于移除列表中某个值的第一个匹配项,value - - 列表中要移除的对象,该方法没有返回值但是会移除两种中的某个值的第一个匹配项。
>>> list1 [ 1 , 2 , '6' , 3 , 4 , 5 , 'a' , 'b' , 'c' , 'd' ]
>>> list1.remove( 5 )
>>> list1 [ 1 , 2 , '6' , 3 , 4 , 'a' , 'b' , 'c' , 'd' ]
|
8、反向存放
1
2
3
4
5
6
|
reverse( self )用于反向列表中元素,该方法没有返回值,但是会对列表的元素进行反向排序。
>>> list1 [ 1 , 2 , '6' , 3 , 4 , 'a' , 'b' , 'c' , 'd' ]
>>> list1.reverse() >>> list1 [ 'd' , 'c' , 'b' , 'a' , 4 , 3 , '6' , 2 , 1 ]
|
9、排序
1
2
3
4
5
|
sort( self , cmp = None , key = None , reverse = False )用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数,该方法没有返回值,但是会对列表的对象进行排序。
>>> list1 = [ 1 , 2 , 3 , 4 , 5 , 7 , 8 , 6 , 5 ]
>>> list1.sort() >>> list1 [ 1 , 2 , 3 , 4 , 5 , 5 , 6 , 7 , 8 ]
|
10、反序
1
|
sorted 内建函数:对序列进行反序,并返回一个列表
|
四.元祖
元组的意义:
元组可以在映射中当作键使用;
元组作为很多内建函数和方法的返回值存在。
元组的元素是不能被修改,但元素的元素能可以被被修改的
具有以下方法:
1.统计
1
2
3
4
5
|
>>> boy = ( 'kelin' , 'yaoyao' , 'liuyao' , 'shabi' )
>>> type (boy)
< class 'tuple' >
>>> boy.count( 'yaoyao' )
1 |
2.索引
1
2
|
>>> boy.index( 'liuyao' )
2 |
五.字典
当数据量达到上百万时,循环字典就不适合用dict.items(),因为首先会把一对对key和value转化为列表,然后在循环遍历输出,会增加内存使用。建议使用如下:
1
2
3
4
5
6
7
|
>>> a = { 1 : 'a' , 2 : 'b' }
>>> for k in aa: print (k,aa[k])
( 1 , 'a' )
( 2 , 'b' )
>>> for k in aa.keys(): print (k,aa[k])
( 1 , 'a' )
( 2 , 'b' )
|
具有以下方法:
1、删除字典内所有元素
1
2
3
4
5
6
7
|
clear( self )用于删除字典内所有元素,该函数没有任何返回值。
>>> dic = { 'k1' : 'v1' , 'k2' : 'v2' }
>>> dic { 'k2' : 'v2' , 'k1' : 'v1' }
>>> dic.clear() >>> dic {} |
2、浅复制
1
2
3
4
5
|
copy( self )返回一个字典的浅复制。
>>> dic = { 'k1' : 'v1' , 'k1' : 'v2' }
>>> dic.copy() { 'k1' : 'v2' }
>>> |
3、get
1
2
3
4
5
|
get (self, k, d=None)返回指定键的值,如果值不在字典中返回默认值,key -- 字典中要查找的键, default -- 如果指定键的值不存在时,返回该默认值值。
>>> dic = { 'k1' : 'v1' , 'k2' : 'v2' }
>>> dic. get ( 'k1' )
'v1' >>> |
4、has_key
1
|
has_key( self , k)用于判断键是否存在于字典中,如果键在字典 dict 里返回true,否则返回false,k - - 要在字典中查找的键。注: 3.x 已删除该函数
|
5、items
1
2
3
4
|
items( self )以列表返回可遍历的(键, 值) 元组数组。
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.items() dict_items([( 'age' , '21' ), ( 'name' , 'yaoyao' ), ( 'job' , 'IT' )])
|
6、iteritems
1
|
iteritems( self )项可迭代。注: 3.x 已删除该函数
|
7、iterkeys
1
|
iterkeys( self )key可迭代。注: 3.x 已删除该函数
|
8、itervalues
1
|
itervalues( self )value可迭代。注: 3.x 已删除该函数
|
9、keys
1
2
3
4
|
keys( self )以列表返回一个字典所有的键。
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.keys() dict_keys([ 'age' , 'name' , 'job' ])
|
10、删除键
1
2
3
4
5
6
|
pop(self, k, d=None)获取并在字典中移除,k -- 要在字典中查找的键。 >>> dic={ 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.pop( 'job' )
'IT' >>> dic { 'age' : '21' , 'name' : 'yaoyao' }
|
11、popitem
1
2
3
4
5
6
|
popitem( self )获取并在字典中移除
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.popitem() ( 'age' , '21' )
>>> dic { 'name' : 'yaoyao' , 'job' : 'IT' }
|
12、setdefault
1
2
3
4
5
|
setdefault( self , k, d = None )如果key不存在,则创建,如果存在,则返回已存在的值且不修改
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.setdefault( 'sex' )
>>> dic { 'sex' : None , 'age' : '21' , 'name' : 'yaoyao' , 'job' : 'IT' }
|
13、更新
1
2
3
4
5
6
|
update( self , E = None , * * F)更新
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic_1 = { 'sex' : 'man' }
>>> dic.update(dic_1) >>> dic { 'sex' : 'man' , 'age' : '21' , 'name' : 'yaoyao' , 'job' : 'IT' }
|
14、values
1
2
3
4
|
values( self )以列表返回字典中的所有值。
>>> dic = { 'name' : 'yaoyao' , 'age' : '21' , 'job' : 'IT' }
>>> dic.values() dict_values([ '21' , 'yaoyao' , 'IT' ])
|
15、viewitems
1
|
viewitems( self )所有项,只是将内容保存至view对象中。注: 3.x 已删除该函数
|