LEMON

记录站

0%

Python常用方法及模块（五）

Python 常用方法

一、输出 print 和 阻塞 input

  • print 将一些内容输出到屏幕
  • input 从外部给予变量的值
  • 示例：
1
2
3
4
5
print("what is you name?", "lemon")   # (,)相当于一个空格
name = input("请输入您的姓名:")
age = input("请输入您的年龄：")
print("name =" ,name)
print("age =" ,age)

二、查看变量类型 type

1
2
3
4
5
6
name = ("lemon")
score = 18
age = 28.5
print(type(name))
print(type(score))
print(type(age))

三、查看变量的地址 id

1
2
name = ("lemon")
print(id(name))

四、数字类型转换 float & int

  • float 小数转换
  • int 整数转换
1
2
print(float(1))       # 1.0
print(int(1.9))       # 去除小数部分，保留整数部分；结果为1

五、返回数字的绝对值 abs

1
2
3
4
5
6
7
8
num1 = -10
print(abs(num1))    # 10

#或者

num2 = -20
to = abs(num2)
print(to)           # 20

六、返回给定参数的(最大、最小)值 max min

1
2
3
4
5
6
7
8
9
10
11
# 例1：最大值
a1 = 10
a2 = 20
print(max(a1, a2))     # 20
print(max(1, 2, 3))    # 3

# 例2：最小值
a3 = 2
a4 = 11
print(min(a3, a4))     # 2
print(min(1, 2, 3))    # 1

七、求x的y次方 pow

1
2
3
4
num1 = 5
num2 = 3
print(pow(num1, num2))   # 5 x 5 x 5 = 125
print(pow(2, 3))         # 2 x 2 x 2 = 8

八、round

1
2
3
4
5
6
7
# round (x,n)返回浮点数x四舍五入的值，如果给出n值，则代表舍入到小数点后n位
print(round(2.345))      # 2
print(round(2.543))      # 3

# 保留后面小数的位数
print(round(2.457, 2))    # 2.46
print(round(2.449, 1))    # 2.4

Python 常用模块

一、keyword 关键字模块

1
2
3
# -*- coding:utf-8 -*-
import keyword
print (keyword.kwlist)      # 查看python的关键字

二、math 数学模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# -*- coding:utf-8 -*-
import math

1、math.ceil向大数取整
print(math.ceil(18.1))
print(math.ceil(18.9))


2、math.floor向小数取整
print(math.floor(18.1))
print(math.floor(18.9))


3、math.modf 以元组的形式返回整数部分和小数部分
print(math.modf(22.3))


4、math.sqrt 开方
print(math.sqrt(16))

三、random 随机数模块

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
# -*- coding:utf-8 -*-
import random

# 1、random.choice 列表
# random.choice:既可以是数字也可以是字符串
print(random.choice([1,'ks',6,'d','a',9]))
print(random.choice(range(5)))
print(random.choice("Lemon-li"))

## 例如：怎么产生一个0~100之间的随机值
a1 = random.choice(range(101))
print(a1)

## 例如：怎么产生一个1~100之间的随机值
a2 = random.choice(range(100)) + 1
print(a2)


# 2、random.randrange    【start,   stop,    step】
#start--指定范围的开始值，包括本身数值
#stop--指定范围的结束值，不包括本身数值
#step--指令开始值的步数
print(random.randrange(100))         #从0~99选取一个随机值
print(random.randrange(100) + 1)     #从1~100选取一个随机值
print(random.randrange(1, 10, 2))    #他的结果（1, 3, 5, 7, 9）都是奇数
print(random.randrange(2, 10, 2))    #他的结果（ 2, 4, 6, 8）都是偶数


# 3、random.randint       【start,  stop】
#start--指定范围的开始值，包括本身数值
#stop--指定范围的结束值， 包括本身数值
print(random.randint(1, 5))          #他的结果（ 1, 2, 3, 4, 5） 


# 4、random.random 随机生产[0，1]之间的数；也就是浮点数
print(random.random())


# 5、random.shuffle 将列表的所有元素随机排序
list1 = [1,2,3,4,5]
random.shuffle(list1)
print(list1)


# 6、random.uniform 随机生成一个实数，他在【3，9】范围
print(random.uniform(3,9))

四、time 时间模块

  • UTC (世界协调时间)：格林尼治天文时间，世界标准时间，对中国来说是 UTC+8(东八区)

  • DST (夏令时)：是一种节约能源二人为规定的时间制度，在夏季时调快一个小时

  • 时间的表示形式：

    • 时间戳
      • 以整型或浮点型表示时间的一个以秒为单位的时间间隔，这个时间间隔的基础值是从1970年1月1日零点开始算起
    • 元组一种 python的数据结构表示，这个元组有9个整形内容
      • year
      • month
      • day
      • hours
      • minutes
      • seconds
      • weekday
      • Julia day
      • fiag (1 或 -1 或 0)
    • 格式化字符串：
      • %y 两位数的年份表示（00-99）
      • %Y 四位数的年份表示（000-9999）
      • %m 月份（01-12）
      • %d 月内中的一天（0-31）
      • %H 24小时制小时数（0-23）
      • %I 12小时制小时数（01-12）
      • %M 分钟数（00=59）
      • %S 秒（00-59）
      • %a 本地简化星期名称
      • %A 本地完整星期名称
      • %b 本地简化的月份名称
      • %B 本地完整的月份名称
      • %c 本地相应的日期表示和时间表示
      • %j 年内的一天（001-366）
      • %p 本地A.M.或P.M.的等价符
      • %U 一年中的星期数（00-53）星期天为星期的开始
      • %w 星期（0-6），星期天为星期的开始
      • %W 一年中的星期数（00-53）星期一为星期的开始
      • %x 本地相应的日期表示
      • %X 本地相应的时间表示
      • %Z 当前时区的名称
      • %% %号本身

  • 示例

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
# -*- coding:utf-8 -*-
import time

# 1 返回当前时间的时间戳，浮点型，不需要参数
a = time.time()
print(f"a = {a}", type(a))


# 2 根据时间戳，返回对应的格林尼治时间元组
b = time.gmtime(a)
print(f"b = {b}", type(b))


# 3 将时间戳转为当地时间元组
c = time.localtime(a)
print(f"c = {c}", type(c))


# 4 将时间元组转为时间戳
d = time.mktime(c)
print(f"d = {d}", type(d))


# 5 将时间元组转为时间字符串
e = time.asctime(c)
print(f"e = {e}", type(e))


# 6 将时间戳转为时间字符串
f = time.ctime(a)
print(f"f = {f}", type(f))


# 7 将时间元组转为指定格式的字符串，参数2为时间元组，默认转为当地时间
g = time.strftime("%Y-%m-%d %H:%M:%S", c)
print(f"g = {g}", type(g))

# 8 将时间字符串转为时间元组，需要指定格式，参数2用于指定格式
h = time.strptime(g, "%Y-%m-%d %H:%M:%S")
print(f"h = {h}", type(h))

# 9 延迟一个时间，值可以为整形或者浮点型，单位秒
time.sleep(2)
print("时间过了两秒")

# 10 返回当前程序的CPU执行时间:
# 1、Unix系统始终返回全部的运行时间
# 2、Windows从第二次开始，都是以第一次调用此函数的开始时间戳作为基数
# 以第一个clock作为基数，共有三个的时候，会计算出第1~3个clock之间的代码运行时间
i = time.clock()
print("i = %d" % i, type(i))

time.sleep(2)
i1 = time.clock()
print("i1 = %d" % i1, type(i1))

time.sleep(2)
i2 = time.clock()
print("i2 = %d" % i2, type(i2))

# 测试CPU、内存性能
time.clock()
sum = 0
for i in range(100000000):
    sum += i

print(time.clock())

五、datetime 高级时间模块

  • 作用
    • 比time高级了不少，可以理解为 datetime 基于time进行了封装，提供了更为实用的函数，datetime模块的接口更直观、更容易调用。
  • 模块中的类
    • datetime 同时有日期和时间
    • timedelta 主要用于计算时间的跨度
    • tzinfo 时区相关
    • time 只关注时间
    • date 只关注日期
  • 示例
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
# -*- coding:utf-8 -*-
import datetime

#1 获取当前时间
d1 = datetime.datetime.now()
print(f"d1 = {d1}", type(d1))

#2 获取指定的时间
d2 = datetime.datetime(1999, 10, 1, 10, 28, 25, 12345)
print(f"d2 = {d2}", type(d2))

#3 将时间转为字符串
d3 = d1.strftime("%y-%m-%d %X")
print(f"d3 = {d3}", type(d3))

#4 将格式化字符串转为datetime对象；注意：转换的格式必须要与字符串一致
d4 = datetime.datetime.strptime(d3, "%y-%m-%d %X")
print(f"d4 = {d4}", type(d4))

#5 进行加减乘除；在此直列出常用的减法
d5 = datetime.datetime(1999, 10, 1, 10, 28, 25, 12345)
d6 = datetime.datetime.now()
d7 = d6 - d5
print(f"d7 = {d7}", type(d7))
print(f"d7.days = {d7.days}")           # 提取间隔的天数
print(f"d7.seconds = {d7.seconds}")     # 提取间隔天数除外的秒数

六、calendar 日历模块

  • 示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# -*- coding:utf-8 -*-

import calendar

#1 返回指定某年某月的日历
print(calendar.month(2019, 10))

#2 返回指定年的所有日历
print( calendar.calendar(2019))

#3 判断；闰年返回True，否则返回Fales
print(calendar.isleap(2000))
print(calendar.isleap(2001))

#4 返回某个月的weekady的第一天和这个月所有的天数
print(calendar.monthrange(2019, 10))

#5 返回某个月以每一周为元素的列表
print(calendar.monthcalendar(2019, 10))

七、os 操作系统接口模块

  • 作用: 包括了普遍的操作系统功能，有些方法存在与 OS 模块里，还有些方法存在于 os.path 里
  • os 模块示例
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
# -*- coding:utf-8 -*-

import os

#1 os.name 获取操作系统类型 > {nt --> windown    posin --> Linux、Unix 或 Mac OS X}
print("k1 ==", os.name)

#2 os.uname() 打印操作系统详细信息；(windown不支持)
print("k2 == ", os.uname())

#3 os.environ 获取操作系统中所有的环境变量
print("k3 == ", os.environ)

#4 os.environ.get(self, k)获取指定环境变量
print("k4 == ", os.environ.get("ALLUSERSPROFILE"))

#5 os.curdir 获取当前目录{.}
print("k5 ==", os.curdir)

#6 os.getcwd() 获取当前工作目录，也就是当前python脚本的目录位置
print("k6 ==", os.getcwd())

#7 os.listdir(path) 以list列表的形式返回指定目录下的所有目录及文件
print("k7 ==", os.listdir(r"D:\文件处理\"))

#8 os.mkdir("name") 在当前目录或绝对路径下创建新目录; 注意：不要重复创建！
os.mkdir("etc")                         # 相对路径:当前python脚本的目录下
os.mkdir(r"D:\文件处理\opt")             # 绝对路径

#9 os.rmdir() 删除目录
os.rmdir(r"D:\文件处理\opt")             # 绝对路径
os.rmdir("etc")                         # 相对路径:当前python脚本的目录下

#10 os.remove() 删除文件
os.remove("file.txt")                   # 相对路径:当前python脚本的目录下
os.remove(r"D:\文件处理\4.txt")          # 绝对路径

#11 os.stat() 获取目录或文件的属性
print("k8 ==", os.stat("good.txt"))    # 相对路径{文件}:当前python脚本的目录下
print("k9 ==", os.stat(r"D:\文件处理))  # 绝对路径{目录}

#12 os.rename() 重命名目录或文件
os.rename("lemon", "handsome")        # 相对路径:当前python脚本的目录下
os.rename(r"D:\文件处理\file.txt", r"D:\文件处理\verygood.txt")      # 绝对路径

#13 os.system() 运行shell命令
# 例如：
# os.system("mstsc")                        # 打开远程桌面
# os.system("notepad")                      # 打开记事本
# os.system("mspaint")                      # 打开画板
# os.system("msconfig")                     # 系统设置 
# os.system("shutdown -s -t 500")           # 系统将在500秒内自动关机
# os.system("shutdown -a")                  # 取消系统自动注销
# os.system("taskkill /f /im notepad.exe")  # 关闭记事本的程序；想关什么程序就写什么程序名
  • os.path 示例
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
#1 os.path.abspath(".") 查看当前python脚本文件的绝对路径
print(os.path.abspath("."))

#2 os.path.join() 拼接路径; 注意：必须由长到短，否则拼接不上！
f1 = r"D:\pycharm\.idea\文件处理"
f2 = "handsome.txt"
print(os.path.join(f1, f2))     #返回值：D:\pycharm\.idea\文件处理\handsome.txt

#3 os.path.split() 以元组的形式拆分路径、 splitext()获取后缀名，如果没有后缀名则为空元素
f3 = r"D:\pycharm\.idea\文件处理\handsome.txt"
print("split ==", os.path.split(f3), "splitext ==", os.path.splitext(f3))

#4 os.path.isdir() 判断是否为目录,是就返回True，不是则返回False
f4 = r"G:\Bandizip\data"
f5 = r"G:\Bandizip\不存在哦"
print(os.path.isdir(f4), os.path.isdir(f5))

#5 os.path.exists() 判断目录是否存在，存在就返回True，不存在则返回False
f6 = r"G:\Bandizip\data"
f7 = r"G:\Bandizip\不存在哦"
print(os.path.exists(f6), os.path.exists(f7))

#6 os.path.isfile() 判断文件是否存在，存在就返回True，不存在则返回False
f8 = r"G:\Bandizip\data\local.html"
f9 = r"G:\Bandizip\data\local.htms"
print(os.path.isfile(f8), os.path.isfile(f9))

#7 os.path.getsize() 获得文件大小(字节)
f10 = r"G:\Bandizip\data\local.html"
print(os.path.getsize(f10))

#8 os.path.dirname()获得文件的目录、os.path.basename()获得文件名
f11 = r"G:\Bandizip\data\local.html"
print("dirname ==", os.path.dirname(f11), "basename ==", os.path.basename(f11))
# 返回值：dirname == G:\Bandizip\data basename == local.html
-------------本文结束感谢您的阅读-------------