Python04补充

发表于 分类于 阅读次数：

Python补充

内建函数

序列sequence

下面的内建函数(built-in function)**可用于序列(列表，元组，字符串)**：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
s = (1,2,3,4,False)

print(len(s))   #5
# 返回可迭代对象的长度（元素的个数）。
# 参数可以是序列（如字符串，字节，元组，列表或者范围）或者集合（如字典，集合或者固定集合）。

print(min(s))   #False
# 返回可迭代的对象中的最小的元素，或者返回2个或多个参数中的最小的参数。

print(max(s))   #4
# 返回可迭代的对象中的最大的元素，或者返回2个或多个参数中的最大的参数。

print(all(s))   # False
# 如果可迭代对象的所有元素为真（或者iterable为空）， 返回True。

print(any(s))   # True
# 如果可迭代对象的任一元素为真，返回True。

print(s.count(2))   # 1
# 返回： x在s中出现的次数

print(s.index(False))   # 4
# 返回： x在s中第一次出现的下标

由于元组的元素不可变更，下面方法只适用于列表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 这些方法都是在原来的列表的上进行操作，会对原来的列表产生影响，而不是返回一个新表
l2 = [1,2,3]
l3 = ['a','b','c']

l2.extend(l3)
# 在表l2的末尾添加表l3的所有元素
print(l2)       # [1, 2, 3, 'a', 'b', 'c']

l2.append('na')
# 在l2的末尾附加元素
print(l2)       # [1, 2, 3, 'na']

l2.sort()
# 对l2中的元素排序
print(l2)       # [1, 2, 3]

l2.reverse()
# 将l中的元素逆序
print(l2)       # [3, 2, 1]

poped = l2.pop()
# 返回表l2的最后一个元素，并在表l2中删除该元素
print(poped)    # 3
print(l2)       # [1, 2]

del l2[2]
# 删除列表l2中下标为2的元素
print(l2)       # [1, 2]

字符串string

下面是一些用于字符串的方法。尽管字符串是定值表的特殊的一种，但字符串(string)类有一些方法是改变字符串的。这些方法的本质不是对原有字符串进行操作，而是建立一个新的字符串，所以并不与定值表的特点相矛盾。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

str = 'who is your daddy?'
sub = 'o'
width = 4

print(str.count(sub))   # 2
# 返回sub在str中出现的次数

print(str.find(sub))    # 2
print(str.find('mom'))   # -1
# 返回从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1

print(str.index(sub))   # 2
# print(str.index('mom'))   # ValueError: substring not found
# 返回从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误

print(str.rfind(sub))   # 8
print(str.rfind('mom')) # -1
# 返回从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1

print(str.rindex(sub))  # 8
# print(str.rindex('mom'))    #  ValueError: substring not found
# 返回从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误

print(str.isalnum())    # False
# 返回：True，如果所有的字符都是小写字母

print(str.isalpha())    # False
# 返回：True，如果所有的字符都是字母

print(str.isdigit())    # False
# 返回：True，如果所有的字符都是数字

print(str.istitle())    # False
# 返回：True，如果所有的词的首字母都是大写

print(str.isspace())    # False
# 返回：True，如果所有的字符都是空格

print(str.islower())    # True
# 返回：True，如果所有的字符都是小写字母

print(str.isupper())    # False
# 返回：True，如果所有的字符都是大写字母

print(str.split())      # ['who', 'is', 'your', 'daddy?']
print(str.split(' ',2)) # ['who', 'is', 'your daddy?']
# 返回从左开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。
# 将所得的子字符串放在一个表中返回。可以str.split(',')的方式使用逗号或者其它分割符

print(str.rsplit())     # ['who', 'is', 'your', 'daddy?']
print(str.rsplit(' ',1))# ['who is your', 'daddy?']
# 返回从右开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。
# 将所得的子字符串放在一个表中返回。可以str.rsplit(',')的方式使用逗号或者其它分割符

seq = ('01','02','03')
print(str.join(seq))      # 01who is your daddy?02who is your daddy?03
# 返回：将seq中的元素，以str为分割符，合并成为一个字符串。

print(str.strip())      # who is your daddy?
print(str.strip('?'))   # who is your daddy
# 返回：去掉字符串开头和结尾的空格。
# 也可以提供参数sub，去掉位于字符串开头和结尾的sub

print(str.replace(sub, 'naxx')) # whnaxx is ynaxxur daddy?
# 返回：用一个新的字符串new_sub替换str中的sub

print(str.capitalize()) # Who is your daddy?
# 返回：将str第一个字母大写

print(str.lower())  # who is your daddy?
# 返回：将str全部字母改为小写

print(str.upper())  # WHO IS YOUR DADDY?
# 返回：将str全部字母改为大写

print(str.swapcase())   # WHO IS YOUR DADDY?
# 返回：将str大写字母改为小写，小写改为大写

print(str.title())      # Who Is Your Daddy?
# 返回：将str的每个词(以空格分隔)的首字母大写

print(str.center(30))   #       who is your daddy?      ||end||
# 返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。

print(str.ljust(30))    # who is your daddy?            ||end||
# 返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。

print(str.rjust(30))    #             who is your daddy?||end||
# 返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。

Python小技巧

import模块

在Python经常使用import声明，以使用其他模块(也就是其它.py文件)中定义的对象。

使用__name__

当在运行本文件时, __name__的值为:’__main__‘, 引入文件中的__name__值为引入文件名
利用该特性, 可以保证一些测试语句在引入时不被执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# TestLib.py文件
def lib_func(a):
    return a + 10

def lib_func_another(a):
    return a + 20

if __name__ == '__main__':
    test = 101
    print(lib_func(test))

print('__name__ = ', __name__)  # 111  / __name__ =  __main__

# user.py文件
import  TestLib
print(TestLib.lib_func(120))   # 111  / __name__ =  __main__

更多import使用方式

  • import TestLib as test 引用TestLib模块，并将它改名为t

    1
    2
    import TestLib as test
    print(test.lib_func(120))

  • from TestLib import lib_func 只引用TestLib中的lib_func对象，并在使用时跳过TestLib引用字段

    1
    2
    from TestLib import lib_func
    print(lib_func(120))

  • from TestLib import * 引用所有TestLib中的对象，并在使用时跳过TestLib引用字段

    1
    2
    from TestLib import *
    print(lib_func(120))

查询

查询函数的参数

当我们想要知道某个函数会接收哪些参数的时候，可以使用inspect查询。

1
2
3
4
5
6
7
def lib_func(a,b=0):
    return a + b

import inspect
print(inspect.signature(lib_func))      # (a, b=0)
print(inspect.getfullargspec(lib_func)) # FullArgSpec(args=['a', 'b'], varargs=None, varkw=None, defaults=(0,), kwonlyargs=[], kwonlydefaults=None, annotations={})

查询对象的属性

除了使用dir()来查询对象的属性之外，我们可以使用内置函数hasattr()来确认一个对象是否具有某个属性：

1
print(hasattr(list,'count'))    # True

查询对象所属的类和类名称

1
2
3
a = [1,2,2,3]
print(a.__class__)              # <class 'list'>
print(a.__class__.__name__)     # list

查询父类

我们可以用 __base__ 属性来查询某个类的父类：

1
print(list.__base__)        # <class 'object'>

使用中文(以及其它非ASCII编码)

在Python程序的第一行加入#coding=utf8 或者 # -*- coding: UTF-8 -*-，例如:

1
2
3
4
# coding = utf8
print('你好!')
# -*- coding: UTF-8 -*-
print('你好!')

表示2进制，8进制和16进制数字

1
2
3
4
5
6
7
8
# 二进制,以0b开头
print(0b10)     # 2

# 八进制, 以0o开头
print(0o10)     # 8

# 十六进制, 以0x开头
print(0x10)     # 16

注释

一行内的注释可以以#开始。

多行的注释可以以'''开始，以'''结束，比如：

1
2
3
4
5
6
7
8
9
10
'''
This is demo
'''

def func():
    # print something
    print("Hello world!")  # use print() function

# main
func()

搜索路径

当import的时候，Python会在搜索路径中查找模块(module)
可以在Python运行的时候增加或者删除sys.path中的元素。
另一方面，可以通过在shell中增加PYTHONPATH环境变量，来为Python增加搜索路径。

1
2
import sys
print(sys.path)
1
2
3
# 增加/home/vamei/mylib到搜索路径中：
# 若添加到~/.bashrc中, 将长期改变搜索路径
$ export PYTHONPATH=$PYTHONPATH:/home/vamei/mylib

脚本与命令行结合

可以使用下面方法运行一个Python脚本，在脚本运行结束后，直接进入Python命令行。
这样做的好处是脚本的对象不会被清空，可以通过命令行直接调用。

1
$ python -i script.py

安装非标准包

  • 使用Linux repository (Linux环境)

  • 使用pip. pip是Python自带的包管理程序

    1
    2
    3
    $ pip install -i [网络路径] [本地包名]    			# 安装
    $ pip uninstall web.py                			 # 卸载
    $ pip install -i [网络路径] --upgrade [本地包名]  	# 更新

    如果Python安装在一个非标准的路径(使用$which python来确认python可执行文件的路径)中，比如/home/vamei/util/python/bin中，你可以使用下面方法设置pip的安装包的路径:

    1
    $ pip install -i http://mirrors.aliyuncs.com/pypi/simple --install-option="--prefix=/home/vamei/util/" web.py

  • 从源码编译

Python内置函数清单

数学运算

1
2
3
4
5
6
7
8
9
# 数学运算
print(abs(-5))  # 5 取绝对值
print(round(2.4))   # 2 四舍五入取整
print(pow(2,3)) # 8 乘方,相当于2**3
print(pow(2,3,5))   # 乘方再取余,相当于2 ** 3 % 5
print(divmod(9,2))  # (4,1) 返回除法结果和余数
print(max([1,3,6,2,9])) # 9 返回最大值
print(min([1,3,6,2,9])) # 1 返回最小值
print(sum([2,-1,9,12])) # 22 求和

类型转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 类型转换
print(int('5'))  			# 5 转换为整数
print(float(2))     		# 2 转换为浮点数
print(str(2.3))        	 	# 2.3 转换为字符串
print(type(str(2.3))) # <class 'str'>
print(complex(3,9))         # (3+9j) 转化为复数
print(type(complex(3,9))) # <class 'complex'>
print(ord('A')) 			# 65 返回字符A对应的ASCLL码
print(chr(65))  # A 返回ASCLL码对应的字符
print(bool(0))  # False 返回对应布尔值 在Python中，下列对象都相当于False:[], (), {}, 0, None, 0.0, ''
print(bin(56))  # 0b111000 返回二进制数
print(oct(56))  # 0o70 返回八进制数
print(hex(56))  # 0x38 返回十六进制数
print(list((1,2,3,4)))  # [1, 2, 3, 4] 转化为表list
print(tuple([1,2,3,4])) # (1, 2, 3, 4) 转化为元组tuple
print(dict(a=1,b='hello',c=[1,2,3]))    # {'a': 1, 'b': 'hello', 'c': [1, 2, 3]} 构建词典

序列操作

1
2
3
4
5
# 序列操作
print(all([True,1,'hello']))    	# True 是否所有的元素都相当于True值
print(any(['',0,False,[],None]))    # False 是否有任意一个元素相当于True值
print(sorted([1,4,2,3,6]))  		# [1, 2, 3, 4, 6] 返回正序的序列
print(list(reversed([1,3,6,4,2])))  # [2, 4, 6, 3, 1] 返回反序的迭代器

类、对象、属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 4、类、对象、属性
class Me(object):
    def test(self):
        print('hello')
def new_test():
    print('new hello')
me = Me()

print(hasattr(me,'test'))   	# True 检查me对象是否有test属性
test = getattr(me,'test')  		# 返回me的test属性
test()  # hello
setattr(me,'test',new_test)   	# 将test属性设置为new_test
me.test()   # new hello
delattr(me,"test")  			# 删除test属性
print(isinstance(me,Me))    	# True 判断me对象是否为Me类生成的对象
print(issubclass(Me,object))    # True 判断Me类是否为object类的子类
print(repr(me)) # <__main__.Me object at 0x00C8F118> 返回对象的字符串表达

编译、执行

1
2
3
4
5
6
c = compile("print('hello')",'test.py','exec')	# 编译字符串成为code对象
print(c)    # <code object <module> at 0x016E33C8, file "test.py", line 1>
exec(c) 	# hello 解释字符串表达式, 参数也可以是compile()返回的code对象
exec("print('hel')")    # hel
eval(c) 	# hello 解释并执行字符串, 参数也可以是compile()返回的code对象
eval("print('hel')")    # hel

其他

1
2
3
4
input = input('Please input:')  # 等待输入
print(input)
print(globals())    # 返回全局命名空间，比如全局变量名，全局函数名
print(locals())     # 返回局部命名空间

字符串格式化（%操作符）

Python中内置有对字符串进行格式化的操作%。

模板

格式化字符串时，Python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。Python用一个tuple将多个值传递给模板，每个值对应一个格式符。

在模板和tuple之间，有一个%号分隔，它代表了格式化操作

1
print("I'm %s. I'm %d years old" % ('ni9ne',99))	# I'm ni9ne. I'm 99 years old

还可以用词典来传递真实值,命名使用()括起来。每个命名对应词典的一个key。

1
print("I'm %(name)s. I'm %(age)d years old" % {'name':'ni9ne','age':99})

格式符

格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
%s    字符串 (采用str()的显示)
%r    字符串 (采用repr()的显示)
%c    单个字符
%b    二进制整数
%d    十进制整数
%i    十进制整数
%o    八进制整数
%x    十六进制整数
%e    指数 (基底写为e)
%E    指数 (基底写为E)
%f    浮点数
%F    浮点数，与上相同
%g    指数(e)或浮点数 (根据显示长度)
%G    指数(E)或浮点数 (根据显示长度)

%%    字符"%"

格式进行进一步的控制：

1
2
3
4
5
6
7
%[(name)][flags][width].[precision]typecode
# 如:
print("%+10s" % 10)     #         10||end||
print("%04d" % 5)       # 0005||end||
print("%7.3f" % 2.3)    #   2.300||end||
print("%+7.3f" % 2.3)   #  +2.300||end||
print("%.*f" % (4, 1.2))#     1.2000||end||
1
2
3
4
5
6
7
8
9
(name)为命名
flags可以有+,-,' '或0。
	+表示右对齐。
	-表示左对齐。
	' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。
	0表示使用0填充。
width表示显示宽度
precision表示小数点后精度
width, precision为两个整数。可以利用*，来动态代入这两个量。

其他方式

Python3.6新增加了格式化字符串字面值的特性，可以方便的格式化字符串。

1
2
3
name = 'ni9ne'
age = 99
print(f'我叫{name},今年{age}岁')		# 我叫ni9ne,今年99岁

字符串format方法

1
2
print('我叫{},今年{}岁'.format('ni9ne','99'))		# 我叫ni9ne,今年99岁
print('我叫{name},今年{age}岁'.format(name='ni9ne',age='99'))		# 我叫ni9ne,今年99岁