Python 基础语法 10 内建函数

2.0/2.1/2.2/2.3/2.4 内建函数

2.0/2.1/2.2/2.3/2.4 内建函数

内建函数也叫内置函数 Python自带的函数可以处理单个小问题 在python shell中我们可以同help()来查看内置函数的用法
官网内置函数地址 https://docs.python.org/2.7/library/functions.html

常用内置函数 作用
abs(number) 求数字的绝对值
max(iterable) 求最大值
min(iterable) 求最小值
len(object) 求序列或者字典的长度 返回整型
divmod(x, y) 求两个数的商 余数 返回元祖
pow(x, y[, z]) 两个数时求 x的y平方 三个数时求 x^y %z 返回整型
round(number[, ndigits]) 四舍五入 ndigits是保留小数点后几位 默认是0 返回浮点型
callable(object) 判断对象（函数，类）是否可调用 返回布尔值
type(object) 查看对象的类型
isinstance(object, class-or-type-or-tuple) 判断对象和后面参数是否是同一类型 返回布尔值
cmp(x, y) 比较两个对象的大小 返回整型 0表示相等 1表示左边大 -1表示右边大
range([i], j,[k]) 创建一个整数的列表 i开始值 j结束值后一位 k跨度（负数表向左）
xrange([i], j,[k]) 创建一个整数的列表 和range用法一样 但它返回xrange对象 遍历时才释放列表

abs()

1
2
In [10]: abs(-10)   ##求-10的绝对值
Out[10]: 10

max()

1
2
3
4
5
In [13]: max('a12135')  ##'a'是序列中的最大值
Out[13]: 'a'

In [15]: max('a12135','sadf')  ##'sadf'比'a12135'大
Out[15]: 'sadf'

min()

1
2
In [14]: min('a12135')  ##'1'是序列中的最小值
Out[14]: '1'

len()

1
2
3
4
5
In [19]: len({'a':1,'b':2})  ##求字典的长度
Out[19]: 2

In [20]: len('a12345')  ##求序列的长度
Out[20]: 6

divmod(x ,y)

1
2
In [22]: divmod(5,2)  ##5/2 商是2 余1
Out[22]: (2, 1)

pow(x, y[, z])

1
2
3
4
5
In [24]: pow(2,3)  ##2的3次方
Out[24]: 8

In [25]: pow(2,3,3)  ##2的3次方得8 8除于3余2
Out[25]: 2

round()

1
2
3
4
5
In [27]: round(11.1212 ,2)  ##小数点后保留两位
Out[27]: 11.12

In [28]: round(11.1212 )  ##返回浮点型 默认是小数点后不保留
Out[28]: 11.0

callable()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [3]: a='asdf'

In [4]: callable(a)   ##a是字符串 不可被调用
Out[4]: False

In [5]: def fun():
   ...:     pass
   ...:

In [6]: callable(fun)  ##fun是函数 可以被调用
Out[6]: True

In [7]: class A(object):
   ...:     pass
   ...:

In [8]: callable(A)   ##A是类 可以被调用
Out[8]: True

type()

1
2
3
4
5
In [10]: type('asd')
Out[10]: str

In [11]: type({'a':1,'b':2})
Out[11]: dict

isinstance()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [17]: isinstance('asdf',str)
Out[17]: True

In [18]: isinstance('asdf',(str,int,list))  ##只要是元祖中的其中一个就返回真
Out[18]: True

In [19]: class A(object):
    ...:     pass
    ...:

In [22]: a = A()  ##a是类A的实例化对象

In [23]: isinstance(a,A)  
Out[23]: True

cmp()

1
2
3
4
5
In [30]: cmp(1, 10)
Out[30]: -1

In [31]: cmp('a', 10)  ##字符串比较先按照字符逐个比较 相同时再比较长度
Out[31]: 1

range()

1
2
3
4
5
In [35]: range(11)  ##0-10的序列
Out[35]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

In [36]: range(10,0,-1)  ##10-1的序列 -1表示向左
Out[36]: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

xrange()

通常使用xrange更多，节省内存

1
2
3
4
5
In [19]: xrange(10)
Out[19]: xrange(10)

In [21]: for i in xrange(10):print i,
0 1 2 3 4 5 6 7 8 9

类型转换内置函数 作用
int() 转换为整型
long() 转换为长整型
float() 转换为浮点型
complex() 转换为复数型
str() 转换为字符串
list() 转换为列表
tuple() 转换为元祖
hex() 数字转换为十六进制 返回字符串
oct() 数字转换为八进制 返回字符串
eval() 执行一个字符串表达式，并返回表达式的值。
chr() 输入0-255 并返回对应的ascii码
ord() 和chr()相反 输入单个字符返回对应的数值

int()

1
2
3
4
5
In [53]: int('1212')
Out[53]: 1212

In [54]: int(121.2)
Out[54]: 121

long()

1
2
3
4
5
In [56]: long('1212')
Out[56]: 1212L

In [57]: long(121.2)
Out[57]: 121L

float()

1
2
3
4
5
In [58]: float('1212')
Out[58]: 1212.0

In [59]: float(1212)
Out[59]: 1212.0

complex()

1
2
3
4
5
In [61]: complex('1212')
Out[61]: (1212+0j)

In [62]: complex(1212.2)
Out[62]: (1212.2+0j)

str()

1
2
3
4
5
In [64]: str({'a':1,'b':1})
Out[64]: "{'a': 1, 'b': 1}"

In [65]: str(['a',1])
Out[65]: "['a', 1]"

list()

1
2
3
4
5
In [67]: list('abc')
Out[67]: ['a', 'b', 'c']

In [68]: list({'a':1,'b':2})
Out[68]: ['a', 'b']

tuple()

1
2
3
4
5
In [71]: tuple('abc')
Out[71]: ('a', 'b', 'c')

In [72]: tuple({'a':1,'b':2})
Out[72]: ('a', 'b')

hex()

1
2
3
4
5
In [80]: hex(22)
Out[80]: '0x16'

In [81]: hex(22L)
Out[81]: '0x16L'

oct()

1
2
3
4
5
In [83]: oct(22L)
Out[83]: '026L'

In [84]: oct(22)
Out[84]: '026'

eval()

1
2
3
4
5
In [92]: eval(hex(10))  ##把字符串'0xa'转化为值10
Out[92]: 10

In [97]: eval("['a',1]")
Out[97]: ['a', 1]

chr()

1
2
3
4
5
In [105]: chr(65)
Out[105]: 'A'

In [106]: chr(97)
Out[106]: 'a'

ord()

1
2
3
4
5
In [108]: ord('a')
Out[108]: 97

In [109]: ord('A')
Out[109]: 65
字符串的方法 作用
S.capitalize() 首字母大写
S.replace(old, new[, count]) 新的字符串替换旧的 count指替换的次数
S.split([sep [,maxsplit]]) 切割字符串 返回列表 默认空格是切割符 sep指定切割符 maxsplit切割次数
S.join(iterable) 用S连接可迭代对象 返回字符串 一般把元祖和列表合为字符串
S.isupper() 判断是否全大写 返回布尔值
S.islower() 判断是否全大写 返回布尔值
S.isalnum() 判断字符串是否由字母和数字组成 返回布尔值
S.isalpha() 判断字符串是否由字母组成 返回布尔值
S.isdigit() 判断字符串是否由数字组成 返回布尔值
S.isspace() 判断字符串是否由纯空格组成 返回布尔值
S.title() 判断字符串只有首字母大写 返回布尔值
S.center(width[, fillchar]) 居中 width表示总长度 fillchar表示填充物
S.count(sub[, start[, end]]) 统计指定字符串次数 sub指定字符串 start end搜索范围 指定下标
S.strip([chars]) 去除两边空格
S.lstrip([chars]) 去除左边空格
S.rstrip([chars]) 去除右边空格
S.startswith(prefix[, start[, end]]) 判断字符串是否以指定的字符串开头 返回布尔值
S.endswith(suffix[, start[, end]]) 判断字符串是否以指定的字符串结尾 返回布尔值

S.capitalize()

1
2
3
4
In [126]: s = 'hello'

In [127]: s.capitalize()  ##首字母大写
Out[127]: 'Hello'

S.replace()

1
2
3
4
5
In [130]: s.replace('l','L')  ##L替换l
Out[130]: 'heLLo'

In [132]: s.replace('l','L',1)  ##只替换一次
Out[132]: 'heLlo'

S.split()

1
2
3
4
5
6
7
8
9
10
11
12
In [134]: s = 'aasdf aa b'

In [135]: s.split()   ##默认是空格为切割符
Out[135]: ['aasdf', 'aa', 'b']  

In [136]: ip = '192.168.80.101'

In [137]: ip.split('.')  ##指定.来切割
Out[137]: ['192', '168', '80', '101']

In [138]: ip.split('.',1)  ##切割一次
Out[138]: ['192', '168.80.101']

S.join()

1
2
3
4
5
6
7
8
9
10
In [141]: s = 'abc'

In [147]: s.join('123')    ##用s连接123
Out[147]: '1abc2abc3'

In [161]: [str(i) for i in (range(10))]  ##列表中的元素必须是字符串
Out[161]: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

In [162]: ''.join([str(i) for i in (range(10))])  ##把列表连接为字符串
Out[162]: '0123456789'

string模块 也有类似的功能

1
2
3
4
5
6
7
8
9
10
In [164]: import string  ##导入模块

In [165]: string.lowercase  ##创建私有小写字母
Out[165]: 'abcdefghijklmnopqrstuvwxyz'

In [166]: string.uppercase  ##创建私有大写字母
Out[166]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

In [168]: string.replace('asdfffd','d','D')  ##替换
Out[168]: 'asDfffD'

S.isupper()

1
2
3
4
In [19]: s= 'ABC'

In [21]: s.isupper()  ##判断是否全大写
Out[21]: True

S.islower()

1
2
In [24]: s.islower()  ##判断是否全小写
Out[24]: False

S.isalnum()

1
2
3
4
5
6
7
8
9
In [26]: s = 'asdf1213'

In [27]: s.isalnum()
Out[27]: True

In [28]: s = 'asdf1213 '  ##字符串中有空格

In [29]: s.isalnum()
Out[29]: False

S.isalpha()

1
2
3
4
In [31]: s = 'asdf'

In [33]: s.isalpha()
Out[33]: True

S.isdigit()

1
2
3
4
In [31]: s = 'asdf'

In [36]: s.isdigit()
Out[36]: False

S.isspace()

1
2
3
4
In [38]: s = '   '  

In [39]: s.isspace()  ##字符串中是由纯空格组成
Out[39]: True

S.title()

1
2
3
4
5
6
7
8
9
In [41]: s = 'ABC'

In [42]: s.istitle()
Out[42]: False

In [43]: s = 'Abc'

In [44]: s.istitle()
Out[44]: True

S.strip() / S.lstrip() / S.rstrip()

1
2
3
4
5
6
7
8
9
10
In [76]: s = '    ABC     '

In [77]: s.strip()  ##去除两边空格
Out[77]: 'ABC'

In [78]: s.lstrip()  ##去除左边空格
Out[78]: 'ABC     '

In [79]: s.rstrip()  ##去除右边空格
Out[79]: '    ABC'

S.startswith() / S.endswith()

1
2
3
4
5
6
7
8
9
10
In [89]: s = 'asdfsdfsd'

In [90]: s.startswith('a')  ##是否以'a'开头
Out[90]: True

In [91]: s.startswith('as') ##是否以'as'开头
Out[91]: True

In [92]: s.endswith('d')  ##是否以'd'结尾
Out[92]: True

S.center()

1
2
In [62]: s.center(9, '*')  ##居中 字符串总长度是9 用*填充
Out[62]: '***ABC***'

S.count()

1
2
3
4
In [64]: s = 'abcea'

In [65]: s.count('a')  ##统计'a'的次数
Out[65]: 2
序列处理函数 作用
len() 求长度
max() 求最大值
min() 求最小值
zip(seq1 [, seq2 […]]) 合并序列 序列中的元素一一对应
filter(function or None, sequence) 通过函数过滤序列 None不过滤
map(function, sequence[, sequence, …]) 各序列传参到函数中处理 参数和序列数量要一致
reduce(function, sequence[, initial]) 遍历把序列sequence的元素并通过函数function（只能带两个参数）进行处理

zip()

1
2
3
4
5
6
7
8
9
10
11
In [174]: l1 = [1,2,3]

In [176]: l2 = ['a','b','c']

In [177]: l3 = ['I','II']

In [178]: zip(l1,l2,l3)  ##默认向最小的序列看起
Out[178]: [(1, 'a', 'I'), (2, 'b', 'II')]

In [179]: zip(l1,l2)   ##下标相同的组成一组
Out[179]: [(1, 'a'), (2, 'b'), (3, 'c')]

filter()

1
2
3
4
5
6
7
8
9
10
In [170]: def f(x):  ##判断偶数的函数
     ...:     if x % 2 == 0:  
     ...:         return 1
     ...:     

In [171]: filter(f, range(11)) ##通过函数过滤range(11)
Out[171]: [0, 2, 4, 6, 8, 10]

In [190]: filter(lambda x : x % 2 == 0 ,range(11) )  ##使用匿名函数
Out[190]: [0, 2, 4, 6, 8, 10]

map()

1
2
3
4
5
6
7
8
9
10
11
12
13
In [186]: def f(x,y):  函数中有两个参数
     ...:     return x + y
     ...:

In [187]: l1=[1,2]

In [188]: l2=[2,3]

In [189]: map(f,l1,l2)  ##从两个序列中各自传参给函数处理
Out[189]: [3, 5]

In [193]: map(lambda x,y : x + y , range(4),range(4))  ##使用匿名函数 
Out[193]: [0, 2, 4, 6]

reduce()

1
2
3
4
5
6
7
8
9
In [194]: def f(x,y):  
     ...:     return x + y
     ...:

In [195]: reduce(f , range(1,101))  ##函数逐个处理序列中的元素 但函数必须只有两个参数
Out[195]: 5050

In [197]: reduce(lambda x,y : x+y,range(1,101))  ##使用匿名函数 
Out[197]: 5050

总结

filter map reduce都可以通过匿名函数来处理序列
filter 单参数的函数 单序列 返回序列
map 多参数的函数 多序列 返回列表
reduce两个参数的函数 单序列 返回值

列表表达式

列表表达式也叫列表重写，返回列表

语法格式

1
[变量 for 变量 in 表达式 代码块]
1
2
3
4
5
In [201]: [i for i in range(1,11) if i % 2 == 0 ]
Out[201]: [2, 4, 6, 8, 10]

In [202]: [i**2 for i in range(1,11) if i % 2 == 0 ]
Out[202]: [4, 16, 36, 64, 100]

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

欢迎光临<br><br>本博客是用来记录学习Linux Python Shell和Perl<br>谢谢大家