2的三次方在python中用函数 python 2的10次方

转载

mob64ca13fb1f2e 2024-05-29 11:04:36

文章标签 2的三次方在python中用函数 python 开发语言字符串 bc 文章分类 Python 后端开发

3 基本数据类型

3.1 数字类型及操作

3.1.1 整数类型

3.1.2 浮点数类型

3.1.3 复数类型

3.1.4 数值操作运算符

3.2 实例三：天天向上的力量

3.2.1 每天进/退 1‰

3.2.2 每天进/退 5‰或 1%——参数

3.2.3 工作日进1% 休息日退1%

3.2.4 工作日要多努力？——函数

3.2.5 练习：两天打鱼三天晒网

3.3 字符串类型及操作

3.3.1 字符串类型的表示

3.3.2 字符串操作符

3.3.3 字符串处理函数

3.3.4 字符串处理方法

3.3.5 字符串类型的格式化

3.4 模块2：time库的使用

3.4.1 time库基本情况

3.4.2 时间获取

3.4.3 时间格式化

3.4.4 程序计时应用

3.5实例四：文本进度条

3.5.1问题分析

3.5.2 简单的开始

3.5.3 单行动态刷新

3.5.4 完整代码

3 基本数据类型

3.1 数字类型及操作

3.1.1 整数类型

pow()函数

计算幂指数xy

用法：pow(x,y) 求x的y次幂

四种进制

十进制

二进制：以0b或0B开头，如0b010、0B101

八进制：以0o或0O开头，如0o123、0O456

十六进制：以0x或0X开头，如0x9a、0X89

实例：

>>> 0b1+0b1
2
>>> 0b1+0B10
3
>>> 0B1+0O11
10
>>> 0Xa+0o12
20

3.1.2 浮点数类型

取值范围数量级约-10 308至10 308

精度数量级10 -16

浮点数间的运算，可能存在不确定的尾数（不是bug，多数编程语言都存在）

原因：计算机用二进制表示小数，计算时只取53位，约10^-16（转回十进制时只有16位小数）

例如：0.1

二进制表示为0.000110011······（共53位）

转回十进制为0.1000000000000000346494004316······

那么计算0.1+0.2时，可能等于0.30000000004

>>> 0.1+0.2＝＝0.3 #两个等号表示判断
False

如何解决？

round()函数：四舍五入

浮点数间的计算即比较需要用此函数辅助

用法：round(x,d)，对x四舍五入，d是小数截取位数

>>> 0.1+0.2
0.30000000000000004
>>> round(0.1+0.2,1)
0.3
>>> round(0.1+0.2,1)==0.3  #表示取一位小数比较
True

浮点数的科学计数法

用e或E作为幂的符号，以十为基数

用法：xey 表示 x*10b

例如：

4.3e-3 为4.3*10-3，即0.0043

9.6E5 为9.6*105，即960000.0

3.1.3 复数类型

在众多编程语言中只有Python提供复数类型

常规编程不常用，但在进行空间变换，特别是与复变函数相关的科学体系中常用

用法：a+bj，a为实部，b为虚部，只能用j或J

例如：z＝1.23e-4+5.6e+89j

用z.real获取实部

用z.imag获取虚部

用z.conjugate()获取共轭复数

complex()函数：表示复数

用法：complex(a,b) 表示a+bj

>>> z=2-3j
>>> z.real
2.0
>>> z.imag
-3.0
>>> z.conjugate()
(2+3j)

>>> (2+3j)+(3+2j)
(5+5j)

>>> complex(1.23e-4+5.6e+89j).real
0.000123
>>> complex(1.23e-4+5.6e+89j).imag
5.6e+89
>>> complex(1.23e-4+5.6e+89j).conjugate()
(0.000123-5.6e+89j)

3.1.4 数值操作运算符

六个功能函数

abs(x) 求x的绝对值

divmod(x,y) 求商和余数(x//y,x%y)

pow(x,y[,z]) 求x的y次幂

如果有第三个参数还能将结果和z取余（也就是数太大了，取需要的后几位），即(x**y)%z

round(x[,d]) 对x四舍五入到d位小数，d默认为0

max(x1,x2,...,xn) 求最大值，n不限

min(x1,x2,...,xn) 求最小值，n不限

代码：

>>> abs(-6.5)
6.5
>>> divmod(10,3)
(3, 1)
>>> pow(7,10)
282475249
>>> pow(7,10,10)
9
>>> pow(7,10,100)
49
>>> round(23.92318415321)
24
>>> round(23.92318415321,4)
23.9232
>>> max(65,64,98,0,-6,pow(2,7))
128
>>> min(65,64,98,0,-6,pow(-2,7))
-128

数值类型转换函数

int(x) 将x变成整数

舍弃小数，浮点数，整数字符串，都可以

float(x) 将x变成浮点数

增加小数部分，整数，数字字符串，都可以

float（12）得12.0

float（“1.23”）得1.23

complex(x) 将整数x变成复数，补上虚数部分0j

>>> int(6.88)
6
>>> int(756e-2)
7
>>> int("7.5") #转不了两层
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    int("7.5")
ValueError: invalid literal for int() with base 10: '7.5'
>>> int("9")
9
>>> float(13)
13.0
>>> float("13.5")
13.5
>>> float("13")
13.0
>>> float(pow(2,3))
8.0
>>> complex(9)
(9+0j)

3.2 实例三：天天向上的力量

3.2.1 每天进/退 1‰

公式：1.001365

0.999365

代码：

dayup = pow(1.001,365)

daydown = pow(0.999,365)

print("DAYDAY UP :{:.2f},DAYDAY DOWN :{:.2f}".format(dayup,daydown))

结果：

DAYDAY UP:1.44,DAYDAY DOWN :0.69

3.2.2 每天进/退 5‰或 1%——参数

问题分析：有两个值，能否设一个变量呢？

代码：

factor = 0.005 #优势：只需修改变量fact为0.005或0.1

dayup = pow(1+factor,365)

daydown = pow(1-factor,365)

print("DAYDAY UP :{:.2f},DAYDAY DOWN :{:.2f}".format(dayup,daydown))

结果：

DAYDAY UP:6.17,DAYDAY DOWN :0.16

3.2.3 工作日进1% 休息日退1%

问题分析：365天，每7天为一个周期，七天中前五天为工作日，后两天为休息日

代码：

dayup = 1.0
factor = 0.01
for i in range (365):
        if i%7 in [6,0]:
               dayup=dayup*(1-factor)
        else:
               dayup=dayup*(1+factor)
print("工作日的力量:{:.2f}".format(dayup))

结果：

工作日的力量:4.63

3.2.4 工作日要多努力？——函数

问题：休息日退1%，工作日要进多少才能和每天进1%的结果相同？

分析：假设工作日努力值为x，把结果和每天进步1%的结果（37.78）比较，如果≥1.44则输出这个x；如果＜1.44，则把x再变大一丢丢。

解决办法：def…while…

代码：

#def定义一个函数
def DAYDAYUP(f):  #根据参数f计算工作日的进步值
    dayup=1
    for i in range(365):
        if i % 7 in [6, 0]:
            dayup = dayup * (1 - 0.1)
        else:
            dayup = dayup * (1 + f)
    return dayup
#开始编写
factor=0.01
while DAYDAYUP(factor)<37.78: #while循环调用函数DAYDAYUP()
    factor+=0.001  #等价于factor=factor+0.001
print('追平1%的日进步值是:{:.3f}'.format(factor))

结果：

追平1%的日进步值是:0.019

保留字def：自定义函数
保留字while：判断循环，当满足while后的条件时进行

3.2.5 练习：两天打鱼三天晒网

问题：假如两天进步1%，接下来三天偷懒进步5‰，再良心发现进步三天1%......

问题分析：跟3.2.3相似

代码：

#假如两天进步1%，接下来三天偷懒只进步5‰，再良心发现进步三天1%......
dayup=1
for i in range(365):
    if i%5 in[0,1,]:
        dayup=dayup*(1+0.01)
    else:
        dayup=dayup*(1-0.005)
print("两天打渔，三天晒网:{:.2f}".format(dayup))

结果：

两天打渔，三天晒网:1.43

3.3 字符串类型及操作

3.3.1 字符串类型的表示

表示方法-两类四种

由一对单引号或双引号表示，仅表示单行字符串

由一对三单引号或三双引号表示，可表示多行字符串

注：三单引号跟多行注释怎么一样呢？因为Python并没有多行注释的规定，多行注释本身就是多行字符串，只是因为这个多行字符串没给到变量中，也没有任何操作，可以当注释用。

如果在字符串中也要有单引号/双引号/单引号和双引号该如何操作？

>>> print("abc""abc")
abcabc
>>> print('"abc"')
"abc"
>>> print("'abc'")
'abc'
>>> print(""abc"") #不能两对双引号
SyntaxError: invalid syntax
>>> print("'abc"abc"'")
SyntaxError: invalid syntax
>>> print('''"abc"'abc'''')
SyntaxError: EOL while scanning string literal
#乱七八蕉，总之要向下面这样，不要让四个引号连一起
>>> print('''aaa"abc"'abc'ccc''')
aaa"abc"'abc'ccc

字符串是有序字符序列，可以对字符索引

字符串序号

正向递增序号：第一个为0，往后递增

反向递减序号：第一个为-1，往前递减

字符串的使用

使用 [ ] 获取字符串中一个或多个字符

索引：返回字符串中单个字符

格式：字符串[M]

切片：返回字符串中一段字符子串

格式：字符串[M:N]

字符串[M:] 默认到结尾

字符串[:N] 默认到开头

切片的高级用法：字符串[M:N:K] 根据步长K进行切片

>>> "壹贰叁肆伍陆柒捌玖拾"[5]
'陆'
>>> t="壹贰叁肆伍陆柒捌玖拾"
>>> t[5]
'陆'
>>> t[1:3]
'贰叁'
>>> t[0:-1]
'壹贰叁肆伍陆柒捌玖'
>>> t[-3]
'捌'
>>> t[2:]
'叁肆伍陆柒捌玖拾'
>>> t[:3]
'壹贰叁'
>>> t[1:9:2]
'贰肆陆捌'
>>> t[2:10:3]
'叁陆玖'

字符串的逆序

本质上是切片

格式:字符串[::-1]

>>> t[::-1]
'拾玖捌柒陆伍肆叁贰壹'

字符串的特殊字符

转义符：表达特定字符的本意

用法：反斜杠 \

例如：双引号里面还要出行双引号

>>> print("\"2022-2225\"")
"2022-2225"

常用转义符

\b 回退

\n 换行

\r 回车

3.3.2 字符串操作符

x+y 把字符串x和y连接起来

n*x或x*n 复制字符串n次

x in y 判断x是否为y的子串，是返回Ture，不是返回False

例如：

>>> "壹贰叁肆"+"伍陆柒捌"
'壹贰叁肆伍陆柒捌'
>>> '壹贰叁'*3
'壹贰叁壹贰叁壹贰叁'
>>> '壹贰叁' in "壹贰叁肆伍陆柒捌玖拾"
True
>>> '壹叁' in "壹贰叁肆伍陆柒捌玖拾"
False

实例：获取星期字符串

week="星期一星期二星期三星期四星期五星期六星期日"
num=eval（input("请输入星期数字："))
begin=(num-1)*3 #注意先减掉1
print(week[begin:begin+3])

改进：

week="一二三四五六日"
num=eval（input("请输入星期数字："))
print("星期"+week[num-1]) #注意要减1

3.3.3 字符串处理函数

len(x) 求字符串的长度

str(x) 把任意类型的x变成字符串（加引号）

和eval（)函数功能相反

hex(x) 把整数x转为十六进制的字符串（大写o）

oct(x) 把整数x转为八进制的字符串（小写o）

hex和oct的作用：计算机内部用的二进制，转为十六或八进制方便程序猿查看操作

chr(u) u为Unicode编码，返回其对应的字符

ord(x) x为字符，返回其对应的Unicode编码

Unicode编码

Python字符串的编码形式

统一字符编码，即覆盖几乎世界所有字符的编码形式

>>> for i in range(12):
    print(chr(9800+i),end="")

结果：

♈♉♊♋♌♍♎♏♐♑♒♓

3.3.4 字符串处理方法

"方法"在编程中是一个专有名词

"方法"特指<a>.<b>()风格中的函数<b>()

方法本身也是函数，但与<a>有关，方法必须采用<a>.<b>()形式使用

字符串及变量也是<a>，存在一些方法

<a>.<b>()是面向对象的使用格式，a是对象，b是方法（功能）

字符串处理函数

str.lower() 把大写转为小写

str.upper() 把小写转为大写

str.split(sep＝None) 返回一个列表，由sep分割字符串

str.count(sub) 返回子串sub在str中出现的次数

str.replace(old,new) 把所有old子串替换为new的内容

str.center(宽度，填充字符) 字符串根据宽度居中（如果小于字符长度，则不填充字符）

str.strip(要删除的字符) 去掉两侧的某些字符（和顺序无关，删到两侧字符不是指定字符串里的字符）

str.join(字符串)在字符串两个字符之间添加字符str

例如：

>>> "a,b,c,A,B,C".lower()
'a,b,c,a,b,c'
>>> z="a,b,c,A,B,C"
>>> z.upper()
'A,B,C,A,B,C'
>>> z.split(",")
['a', 'b', 'c', 'A', 'B', 'C']
>>> z.count(",")
5
>>> z.replace("c,A","C,a")
'a,b,C,a,B,C'
>>> z.center(30,chr(9802))
'♊♊♊♊♊♊♊♊♊a,b,c,A,B,C♊♊♊♊♊♊♊♊♊♊'
>>> z.center(20,"&")
'&&&&a,b,c,A,B,C&&&&&'
>>> z.center(6,"&")
'a,b,c,A,B,C'
>>> z.strip("cA")
'a,b,c,A,B,C'
>>> z.strip(",aCb")
'c,A,B'
>>> "abcbbdghjcbag".strip("bca")
'dghjcbag'
>>> "喔".join(z)
'a喔,喔b喔,喔c喔,喔A喔,喔B喔,喔C'

3.3.5 字符串类型的格式化

用.format()

槽

相当于C语言的 %d，用来占位，填写内容为format()括号内的内容，一一对应

槽内部对格式化的配置方式

2的三次方在python中用函数 python 2的10次方_python

例如：

>>> "{0:*^10}".format("四果汤汤")  #必须按照{：要填充的单字符+对齐方式+字符串宽度}的数序设定
'***四果汤汤***'
>>> "{:5}".format("四果汤")   #如果只给了宽度，默认左对齐，空格填充
'四果汤  ' 
>>> z=202121511.456
>>> "{:,}".format(z) #加千位符
'202,121,511.456'
>>> "{:.1f}".format(z) #保留几小数，会四舍五入
'202121511.5'
>>> "{:.6}".format('202121511.456') #保留左起几个字符
'202121'

# b是二进制，c是unicode值对应字符，d是十进制，o是八进制，x是十六进制（含大小写x/X）
>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(123) #没有0不行
'1111011,{,123,173,7b,7B'

# e/E是大小写的科学计数法，f为浮点数，%为百分数形式
>>> "{0:e}&{0:E}&{0:f}&{0:%}".format(3.14)
'3.140000e+00&3.140000E+00&3.140000&314.000000%'

3.4 模块2：time库的使用

3.4.1 time库基本情况

处理时间的标准库之一

表达计算机时间

提供获取系统时间并格式化输出的功能

提供系统及精确计时功能，用于程序性能分析

用法：

import time

time.函数（）

time库包括三类函数

时间获取：time（），ctime（），gmtime（）

时间格式化：strftime（），strptime（）

程序计时：sleep（），perf_counter()

3.4.2 时间获取

time()

获取当前时间戳（即计算机内部表示时间的一个浮点数值）

表示1970年1月1日00:00（科学家选的）到当前的一个以秒为单位的数值，看不出什么

ctime()

获取当前时间并返回可读的字符串

gmtime()

获取当前时间并返回计算机可处理的形式

>>> import time
>>> time.time()
1658675509.249697
>>> time.ctime()
'Sun Jul 24 23:15:31 2022'
>>> time.gmtime()
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=17, tm_sec=28, tm_wday=6, tm_yday=205, tm_isdst=0)

3.4.3 时间格式化

将时间以合适方式展现出来

strftime()

用法：time.strftime(时间格式模板，时间)

例如：

>>> time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime())
'2022-07-24 15:28:16'
>>> time.strftime("%Y/%m/%d %H:%M:%S",time.gmtime())
'2022/07/24 15:28:31'
>>> t=time.gmtime()
>>> time.strftime("%Y/%m/%d %H:%M:%S",t)
'2022/07/24 15:27:46'

时间控制符

%Y 年份 0000-9999

%m 月份 01-12

%B 月份全称 January-December
%b 月份缩写 Jan-Dec（三位）
%d 日期 01-31
%A 星期全称 Monday-Sunday

%a 星期缩写 Mon-Wed

%H 24小时制 00-23

%I 12小时制 01-12

%p 上/下午 AM/PM

%M 分 00-59

%S 秒 00-59

strptime()

不常用，strftime()的反用法，获取计算机内部能操作的时间格式（浮点数）

用法：time.strptime(时间字符串，相应控制符及格式)

例如：

>>> time.strptime("2022-07-24 15:28:16","%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=28, tm_sec=16, tm_wday=6, tm_yday=205, tm_isdst=-1)
>>> t="2022-07-24 15:28:16"
>>> time.strptime(t,"%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=28, tm_sec=16, tm_wday=6, tm_yday=205, tm_isdst=-1)

3.4.4 程序计时应用

程序计时指测量起止动作所经历时间

sleep()

程序休眠一定时间，单位秒，可以是浮点数

用法：sleep(时间秒)

例如程序最后休眠（停留）几秒再关闭退出

perf_counter()

测量时间，CPU纳秒级别，单位秒

不是从0开始计时，所以要两次调用，减去差值

例如：

>>> import time
>>> start=time.perf_counter()
>>> end=time.perf_counter()
>>> end-start
71.58440914899984

3.5实例四：文本进度条

3.5.1问题分析

需求分析：

采用字符串方式打印可以动态变化的文本进度条

能在一行中逐渐变化

问题分析：

如何获得文本进度条的变化时间？

采用sleep()模拟一个持续的进度

3.5.2 简单的开始

import time
scale=10#文本进度条的宽度
print("-----执行开始-----")
for i in range(scale+1):
    a='*' * i #完成进度
    b='.' *(scale-i) #未完成进度
    c=(i/scale)*100 #当前百分百
    print("{:^3.0f}%[{}–＞{}]".format(c,a,b))
    time.sleep(0.1)
print("-----执行结束-----")

结果：

------执行开始------
 0 %[–＞..........]
10 %[*–＞.........]
20 %[**–＞........]
30 %[***–＞.......]
40 %[****–＞......]
50 %[*****–＞.....]
60 %[******–＞....]
70 %[*******–＞...]
80 %[********–＞..]
90 %[*********–＞.]
100%[**********–＞]
------执行结束------

3.5.3 单行动态刷新

刷新的本质：用后来打印的字符覆盖之前的字符

不能换行：end="" #空字符串

end=""，如果要在句末加什么信息，就填入引号内，没填默认换行

要能回退：\r

import time
for i in range(101):
    print("\r{:3}%".format(i),end="") # \r让光标保留在行首
    time.sleep(0.1)

结果：从 0%运行到100%

3.5.4 完整代码

import time
scale=50 #文本进度条的长度/变化次数
print("执行开始".center(scale//2,"-"))
start=time.perf_counter() #获取文件起始时间
for i in range(scale+1):
    a='*' * i #完成进度
    b='.'  *(scale-i) #未完成进度
    c=(i/scale)*100 #当前百分比
    d=time.perf_counter()-start  #开始到当前经历的时间
    print("\r{:^3.0f}%[{}–＞{}]{:.2f}s".format(c,a,b,d),end="")
    time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,"-"))

结果：

-----------执行开始----------

100%[**************************************************–＞]5.46s

-----------执行结束----------

运行一半的效果：

38 %[*******************–＞...............................]2.07s

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：tess4j训练模型 tess4j怎么训练

下一篇：项目库管理 python 项目库管理实施细则

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯