Python内置方法详解

1. 字符串内置方法详解

       为何要有字符串？相对于元组、列表等，对于唯一类型的定义，字符串具有最简单的形式。

       字符串往往以变量接收，变量名. 可以查看所有的字符串的内置方法，如：

1> count：统计字符个数。

a = 'hello,world'
res = a.count('l')            #统计字符串hello，world里面l的个数
print(res)
result：
E:\Learning\python_vir\yunwei\Scripts\python.exe E:/Learning/python/字符串.py
3

 

2> index：索引。

       与Redis数据库类似，字符串索引从左往右从0开始，从右往左从-1开始。index从左往右查找字符的索引。

a = 'hello,world'
res = a.index('o')
print(res)
result：
 4

　　rindex从右往左查找字符的索引，要注意的是，rindex匹配的是从右到左符合条件的第一个字符，但其计数是从做往右进行的。

a = 'hello,world'
res = a.rindex('o')
print(res)
result：
7

       index、rindex还可以在指定的范围进行查找，如（0,6）表示范围。

a = 'hello,world'
res = a.rindex('o',0,6)
print(res)
result ：
4

 

3> istitle：判断字符串是否是抬头（首字母大写），返回布尔值。

a = 'hello,world'
res = a.istitle()
print(res)
result：
False

 
a = 'Hello,world'
res = a.istitle()
print(res)
result：
False
 

a = 'Hello,World'
res = a.istitle()
print(res)
result：
True

a = 'Helloworld'
res = a.istitle()
print(res)
result ：
True

 

a = '周xuej' #不识别汉字
res = a.istitle()
print(res)
result：
False

 

 4> isspace：判断字符串是否全是空格。返回布尔值。

a = 'hello,world'
res = a.isspace()
print(res)
result：
False

a = '      '
res = a.isspace()
print(res)
result：
True

 

5> isdigit：判断字符串是否是整数。返回布尔值。

a = 'hello,world'
res = a.isdigit()
print(res)
result：
False
 
a = '123'
res = a.isdigit()
print(res)
result：
True


a = '123.123'
res = a.isdigit()
print(res)
result：
False

 

6> endswith：判断是否以…结尾，返回布尔值；startswith：判断是否以…开头，返回布尔值。

a = 'hello,world'
res = a.endswith('d')
print(res)
result：
True
 

a = 'hello,world'
res = a.endswith('ld')
print(res)
result：
True
 

a = 'hello,world'
res = a.endswith('o')
print(res)
result：
False

 

7>find： 查找字符串的索引；rfind：从右往左查。

a = 'hello,world'
res = a.find('o')
print(res)
result：
4
 

a = 'hello,world'
res = a.find('ld')
print(res)
result：
9

　　find与index的区别在于，index找不到匹配值会报错，find找不到匹配值会返回-1。

a = 'hello,world'
res = a.find('123')
print(res)
result：
-1

 

8> isalnum：判断是否是字母或者数字或者是两者的任意组合（alpha number）。

a = 'hello,world'
res = a.isalnum()
print(res)
result：
False
 

a = 'helloworld'
res = a.isalnum()
print(res)
result：
True


a = '0706zxj'
res = a.isalnum()
print(res)
result：
True
 

a = '0706'
res = a.isalnum()
print(res)
result：
True

 

9> isalpha：判断是否全是字母。

a = '0706zxj'
res = a.isalpha()
print(res)
result：
False
 

a = 'littlezxj'
res = a.isalpha()
print(res)
result：
True

 

10> islower：判断字符串是否是小写。

a = 'littlezxj'
res = a.islower()
print(res)
result：
True
 
a = 'Littlezxj'
res = a.islower()
print(res)
result：
False

 

11> isupper：判断字符串是否是大写。

a = 'Littlezxj'
res = a.isupper()
print(res)
result：
False
 

a = 'LITTLEZXJ'
res = a.isupper()
print(res)
result：
True

 

12> lower：把大写字符变成小写。

a = 'LITTLEZXJ'
res = a.lower()
print(res)
result：
littlezxj

 

13> upper：把小写换成大写。

a = 'littlezxj'
res = a.upper()
print(res)
result：
LITTLEZXJ

 

14> title：字符串变抬头（首字母大写）。

a = 'littlezxj'
res = a.title()
print(res)
result：
Littlezxj
 

a = 'littlezxj lv'
res = a.title()
print(res)
result：
Littlezxj Lv

 

15> split：分割，从左往右将字符串切分成列表；rsplit：从右往左将字符串切分成列表。

a = 'hello,world'
res = a.split(',')           #以‘，’分割，切一次分成两块列表
print(res)
result：
['hello', 'world']


a = '192.168.16.16'
res = a.split('.')           #以‘.’分割，切三次分成四块列表
print(res)
result：
['192', '168', '16', '16']

 
a = '192.168.16.16'
res = a.split('.',1)         #以‘.’分割，从左往右只切一次
print(res)
result：
['192', '168.16.16']

a = '192.168.16.16'
res = a.rsplit('.',2)
print(res)
result：
['192.168', '16', '16']

 

 16> encode：转码。

a = '192.168.16.16'
res = a.encode('utf-8')
print(res)
result：
b'192.168.16.16' #转化成bit


a = '言念君子温润如玉'
res = a.encode('utf-8')
print(res)
result：
b'\xe8\xa8\x80\xe5\xbf\xb5\xe5\x90\x9b\xe5\xad\x90\xe6\xb8\xa9\xe6\xb6\xa6\xe5\xa6\x82\xe7\x8e\x89'      #转换成16进制

　　decode：解码。

print(res.decode('utf-8'))
result：
言念君子温润如玉

　　gbk为中国的字符编码，国外为ASSIC码。

 

17> format：格式化输出。

　　占位符 {}、%S（字符串）、%D（整型数）等。

1. 替换占位符

name = '颜如玉'
age = 23
res = 'my name is {},my age is {}'.format(name,age)   #前后顺序对应
print(res)
result：
my name is 颜如玉,my age is 23
 

2. 以数字标明顺序
name = '颜如玉'
age = 23
res = 'my name is {0},my age is {1}'.format(name,age) 
print(res)
result：
my name is 颜如玉,my age is 23
 

name = '颜如玉'
age = 23
res = 'my name is {1},my age is {0}'.format(name,age)
print(res)
result：
my name is 23,my age is颜如玉
 

3. 变量赋值，可以一次性给相同的变量赋值
name = '颜如玉'
age = 23
res = 'my name is {name},my age is {age},my little name is {name}'.format(name=name,age=age)
print(res)
result：
my name is 颜如玉,my age is 23,my little name is 颜如玉

 

18>  join：将可迭代对象变成字符串。括号里可以是字典、列表、元组、字符串。

res = ' '.join(['a','b','c'])    #列表      
print(res)
result：
a b c
res = '&'.join(['a','b','c'])
print(res)
result：
a&b&c
 

res = ' '.join(('a','b','c'))    #元组
print(res)
result：
a b c
res = '&'.join(('a','b','c'))
print(res)
result：
a&b&c

res = ' '.join({'a':'1','b':'2','c':'3'})   #字典，默认循环的身世key
print(res)
result：
a b c

 

19> strip：去除左右两边的字符，默认为空格。

a = '      齐静春      '
res =  a.strip()
print(a)
print(res)
result：
      齐静春     
齐静春

a = '===齐=静=春==='
res =  a.strip('=')
print(a)
print(res)
result：
===齐=静=春===
齐=静=春                                #只去除两边的字符

　　lscrip：去除左边的字符，默认为空格。

a = '===齐~静~春==='
res =  a.lstrip('=')
print(a)
print(res)
result：
===齐~静~春===
齐~静~春===    

　　rscrip：去除右边的字符，默认为空格。

a = '===齐~静~春==='
res =  a.rstrip('=')
print(a)
print(res)
result：
===齐~静~春===
===齐~静~春

 

20> replace：替换括号内的字符。

a = '===齐~静~春==='
res =  a.replace('=','')
print(a)
print(res)
result：
===齐~静~春===
齐~静~春
 

去掉多类型的字符：另起一行继续去除或者
a = '------齐~静~春==='
res =  a.replace('=','').replace('-','')
print(a)
print(res)
result：
------齐~静~春===
齐~静~春

 
a = '------齐~静~春==='
res =  a.replace('-','+',3)          #从左往右替换3个‘-’为‘+’
print(a)
print(res)
result：
------齐~静~春===
+++---齐~静~春===

 

2. 列表内置方法详解

　　定义列表用中括号[]。包含多个元素时首先使用列表，列表调用元素较简单。定义列表后用列表名.可以查看所有的内置列表方法。

1> index：返回元素的索引，没有就报错。

li = ['a','b','c','d']
res = li.index('c')
print(res)
result：
2

li = ['a','b','c','d']
res = li.index('e')
print(res)
result：
Traceback (most recent call last):
  File "E:/Learning/python/列表.py", line 2, in <module>
    res = li.index('e')
ValueError: 'e' is not in list

 

2> count：统计元素个数。

li = ['a','b','c','d','a']
res = li.count('a')
print(res)
result：
2

 

3> insert：在指定位置插入（按索引的位置）。

li = ['a','b','c','d','a']
li.insert(3,'a')
print(li)
result：
['a', 'b', 'c', 'a', 'd', 'a']

 

4> reverse：倒序、反转。

li = ['a','b','c','d','a','e']
li.reverse()
print(li)
result：
['e', 'a', 'd', 'c', 'b', 'a']

 

5> sort：排序。

li = ['a','e','c','d','a','b']
li.sort()
print(li)
result：
['a', 'a', 'b', 'c', 'd', 'e']
 
li = ['a','e','c','d','1','b']
li.sort()
print(li
result：
['1', 'a', 'b', 'c', 'd', 'e']

li = ['a','e','c','_','1','b','$','@']
li.sort()
print(li)
result：
['$', '1', '@', '_', 'a', 'b', 'c', 'e']
 
li = ['a','e','c',1,'b',]
li.sort()
print(li)
result：                                    #整型与字符串无法比较
TypeError: '<' not supported between instances of 'int' and 'str'

 

6>copy：复制列表。

li = ['a','e','c',1,'b',]
li.copy()
print(li)
result：
['a', 'e', 'c', 1, 'b']

 

7> clear：清空列表。

li = ['a','e','c',1,'b',]
li.clear()
print(li)
result：
[]

 

8>pop：取出表中指定的元素并从列表中删除该元素。

li = ['a','e','c',1,'b',]
res = li.pop(2)          #按索引取
print(li)
print(res)
result：
['a', 'e', 1, 'b']
c

 

9> append：追加到列表最后。

li = ['a','e','c',1,'b',]
li.append('zxj')
print(li)
result：
['a', 'e', 'c', 1, 'b', 'zxj']

  

10> remove：按默认从左往右的顺序删除指定的元素。

li = ['a','e','c',1,'b',]
li.remove('c')
print(li)
result：
['a', 'e', 1, 'b']

 

11> extend：传入可迭代对象，以单个元素为个体添加到列表中。

li = ['a','e','c',1,'b',]
li.extend('hello')
print(li)
result：
['a', 'e', 'c', 1, 'b', 'h', 'e', 'l', 'l', 'o']    #将字符串拆分成单个元素添加

li = ['a','e','c',1,'b',]
li.extend(['hello','world'])
print(li)
result：
['a', 'e', 'c', 1, 'b', 'hello', 'world']           #将列表拆分成单个元素添加 
li = ['a','e','c',1,'b',]
li.extend({'name':'zxj','age':23})
print(li)
result：
['a', 'e', 'c', 1, 'b', 'name', 'age']              #字典循环的是key

 

3. 元组内置方法详解

　　列表可以用来放置元素，同时能够修改，元组可以储存多个值，元组通常是用来读的，不能修改。存放同样的元素，列表通常比元组占用的空间大。

 1> count：统计元素个数。

tu = ('1','2','3','2','4','3')
res = tu.count('2')
print(res)
result：
2

 

2> index：返回元素的索引值，没有则报错。

tu = ('1','2','3','2','4','3')
res = tu.index('2')
print(res)
result：
1

tu = ('1','2','3','2','4','3')
res = tu.index('6')
print(res)
result：
ValueError: tuple.index(x): x not in tuple

 

4. 整数和浮点数

a = 100
print(a)
result：
100
 
a = 88.88
print(a)
result：
88.88


保留两位小数
a = 88.954
res = '%.2f' % a
print(res)
result：
88.95

 

5. 集合内置方法详解

　　集合元素不能重复，会自动去重。

s1 = {1,2,3,4,4,4,4,4}
print(s1)
result：
{1, 2, 3, 4}

       集合内置方法中copy、clear、remove、pop等于其他类型的内置方法相同，在此不做赘述。

 

1> intersection：求交集。

s1 = {1,2,3,5,6,2,4}
s2 = {1,2,3}
res = s1.intersection(s2)
print(res)
result：
{1, 2, 3}

 

2> difference：求差集。

s1 = {1,2,3,5,6,2,4}
s2 = {1,2,3}
res = s1.difference(s2)            #求s1和s2的差集，以s1-s2
print(res)
result：
{4, 5, 6}
 
res = s2.difference(s1)            #s2-s1
print(res)
result：
set()

 

3> union：求并集。

s1 = {1,5,6,4}
s2 = {1,2,3}
res = s2.union(s1)
print(res)
result：
{1, 2, 3, 4, 5, 6}

 

4>issubset：是否是子集。

s1 = {1,5,6,4}
s2 = {1,2,3}
res = s1.issubset(s2)
print(res)
result：
False


s1 = {1,2,3,5,6,4}
s2 = {1,2,3}
res = s2.issubset(s1)                       #s2是s1的子集
print(res)
result：
True

 

6. 字典内置方法详解

       定义字典可以同时声明key和对应的value，简单清晰的表名元素的属性。

　　定义字典用{}。定义完字典后用字典名.可以查看所有的字典内置方法。

 

1> copy：复制一份字典。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.copy()
print(info)
result：
{'name': '陌上人如玉', 'chara': '公子世无双'}

 

2> pop：取出key对应的value，并将该value从字典中删除。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res = info.pop ('name')
print(res)
print(info)
result：
陌上人如玉
{'chara': '公子世无双'}

 

3> clear：清除字典。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.clear( )
print(info)
result：
{}

 

4> setdefault：设置默认值。如果没有该key，则默认添加。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.setdefault( 'name','北方有佳人')
print(info)
result：
{'name': '陌上人如玉', 'chara': '公子世无双'}


info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.setdefault( 'hobby','北方有佳人')
print(info)
result:
{'name': '陌上人如玉', 'chara': '公子世无双', 'hobby': '北方有佳人'}

 

5> fromkeys：快速定义一个空字典。

res = {}.fromkeys(['name','age','high'], None)
print(res)
result：
{'name': None, 'age': None, 'high': None}
 
res = {}.fromkeys(['name','age','high'], [1,2,3])
print(res)
result：
{'name': [1, 2, 3], 'age': [1, 2, 3], 'high': [1, 2, 3]}

 

6> values：列出所有的value

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info.values()
print(res)

result：

dict_values(['陌上人如玉', '公子世无双'])

 

7> keys：列出所有的key

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info.keys()
print(res)
result：
dict_keys(['name', 'chara'])

 

8> items：列出所有的key、value。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info.items()
print(res)
result：
dict_items([('name', '陌上人如玉'), ('chara', '公子世无双')])

 

9> get：根据key取值，并不删除字典内容。没有对应内容返回None，不可以赋值。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info.get('name')
print(res)
print(info)
result：
陌上人如玉
{'name': '陌上人如玉', 'chara': '公子世无双'}

 
info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info.get('颜如玉')
print(res)
result：
None

 

10> 取值还可以用[‘key’]进行，其没取到时会报错。如：

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info['name']
print(res)
result：
陌上人如玉
 
info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
res =  info['颜如玉']
print(res)
result：
    res =  info['颜如玉']
KeyError: '颜如玉'

　　利用[ ]取值可以进行赋值。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info['name'] =  '遗世而独立'
print(info)
result：
{'name': '遗世而独立', 'chara': '公子世无双'}

 

11> update：把两个字典合并成一个字典，如果键值重复，则值更新键值对应的value。

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.update({'lover':'一顾倾人城'})
print(info)
result：
{'name': '陌上人如玉', 'chara': '公子世无双', 'lover': '一顾倾人城'}

info = {
    'name' : '陌上人如玉',
    'chara' : '公子世无双'
}
info.update({'name':'一顾倾人城'})
print(info)
result：
{'name': '一顾倾人城', 'chara': '公子世无双'}

 

7. 切片

　　切片即取值。

　　定义列表、元组、字符串、字典：

l1 = [1,2,3,4]
t1 = (1,2,3,4)
str1 = 'wonderful'
info = {'yeal':'so','adj':'beautiful'}

　　利用[index]取值。需要注意的是，字典并没有index，因此该方法对字典无效。其余类型正向取值index依次为0、1、2……，反向取值依次为……-2、-1。

取列表里的值：
res = l1[3]
print(res)
result：
4


res = l1[-3]
print(res)
result：
2
 

取元组里的值：
res = t1[3]
print(res)
result：
4
 

取字符串里的值
res = str1[3]
print(r
result：
d

res = str1[-3]
print(res)
result：
f

　　用[index]截取区域元素，即切片。主要格式为[start : end : step]，这种方法顾头不顾尾，即能取到start，但不包括end；step表示步长，在start-end范围内每隔step取一次。

res = l1[0:3]
print(res)
result：
[1, 2, 3]

 
res = t1[-1:-4]               #取值是从左到右正向取的，因此-1~-4取不到任何值，
print(res)
result：
() 
res = t1[-4:-1]
print(res)
result：
(1,2,3)

res = str1[4:]               #只取index>=4的元素
print(res)
result：
erful

res = str1[:6]               #只取index<6的元素
print(res)
result：
wonder

 
res = str1[0:8:2]           #以步长为2截取0<=index<8范围的元素
print(res)
result：
wnef