python语言程序设计基础
部分截图来自 北京理工大学 嵩天 的python基础设计课程的ppt，仅做个人笔记使用，特此声明。
三 基本数据类型
数字类型
-
整数类型 与数学中整数概念一致，可正可负，没有取值范围限制
四种进制表示形式：十进制，二进制，八进制，十六进制
-
浮点数类型 与数学中实数概念一致
带有小数及小数的数字，浮点数间运算存在不确定尾数
round(x,d)： 对x四舍五入，d是小数截取位数
浮点数可以采用科学记数法表示
-
复数类型 与数学复数的概念一致。
在python中，虚数的复数部分通过后缀“j”或”J”来表示，例如 12.3 +4j
复数类型中实数部分和虚数部分的数值都是浮点类型。对于复数，可以用z.real 和 z.imag来分别获得它的虚数部分和实数部分。
扩展关系：整数 -> 浮点数 -> 复数
整数和浮点数混合运算，输出结果是浮点数；整数和浮点数与复数混合运算，输出结果是复数
思考与练习
python浮点数精度问题
[只有1%的人搞懂过Python 浮点数陷阱_web开发与Python-CSDN博客](https://blog.csdn.net/meiguanxi7878/article/details/94658009?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2allsobaiduend~default-2-94658009.nonecase&utm_term=python 浮点用什么表示&spm=1000.2123.3001.4430)
(4条消息) 从0.1加0.2不等于0.3谈Python浮点数的前世今生_Python作业辅导员 - 天元浪子【许向武】-CSDN博客
python进制转换
(4条消息) Python进制转换详细介绍_Wonderful-CSDN博客_python进制转换
python 数字的格式化输出
Python 中如何实现数字的格式化输出？ (pythonf.cn)
3.2 Python语言中整数1010的二进制，八进制和十六进制表示分别是什么？
| 进制 | 数值 | 实现代码 |
|---|---|---|
| 十进制 | 1010 | print(f'{1010:d}') |
| 二进制 | 0b1111110010 | print(f'{1010:#b}') |
| 八进制 | 0o1762 | print(f'{1010:#o}') |
| 十六进制 | 0o3f2 | print(f'{1010:#x}') |
3.3 Python语言中-77.的科学记数法是什么？4.3e-3的十进制表示是什么？
| 结果 | 实现代码 |
|---|---|
| -7.700000e+01 | print(f'{-77.:e}') |
| 0.004300 | print(f'{(4.3e-3):f}') |
3.4 复数2.3e+3-1.3e-3j的实部和虚部分别是什么？用什么方法提取一个复数的实部和虚部？
| 代码 | 结果 | 含义 |
|---|---|---|
| print(2.3e+3-1.34e-3j) | (2300-0.00134j) | 运算结果 |
| print(2.3e+3-1.34e-3j.real) | 2300.0 | 实部 |
| print((2.3e+3-1.34e-3j).imag) | -0.00134 | 虚部，注意要加一个小括号给虚数 |
数字类型的操作
内置的数值运算操作符
| 操作符及使用 | 描述 |
|---|---|
| (+) | 加 |
| (-) | 减 |
| (*) | 乘 |
| (/) | 除，10/3结果是3.3333 |
| (//) | 整数除，x与y的整数商 10//3 结果是3 |
| % | 求余数，求模，10%3结果是1 |
| x**y | 幂函数运算 |
内置的数值运算函数
| 函数及使用 | 描述 |
|---|---|
| abs(x) | 绝对值，复数的绝对值是二维坐标位置到原点的距离 |
| divmod(x,y) | 商余,(x//y,x%y),同时输出商和余数 |
| pow(x,y[,z]) | 幂余，(x**y)%z,[..]表示参数z可以省略 |
| round(x[,d]) | 四舍五入，d是保留小数位数，默认值为0 |
| (max(x_1,x_2,cdots,x_n)) | 最大值，返回(x_1,x_2,cdots,x_n)中的最大值，n不限 |
| (min(x_1,x_2,cdots,x_n)) | 最小值，返回(x_1,x_2,cdots,x_n)中的最小值，n不限 |
内置的数字类型转换函数
| 函数及使用 | 描述 |
|---|---|
| int(x) | 将x变成整数，舍弃小数部分 |
| float(x) | 将x变成浮点数，增加小数部分 |
| complete(x) | 将x变成复数，增加虚数部分 |
思考与练习
python运算符优先级与结合性
当一个表达式中出现多个运算符时，Python 会先比较各个运算符的优先级，按照优先级从高到低的顺序依次执行；
当遇到优先级相同的运算符时，再根据结合性决定先执行哪个运算符：如果是左结合性就先执行左边的运算符，如果是右结合性就先执行右边的运算符。
3.5 思考各操作运算符的优先级，计算下列表达式
| 表达式 | 运算顺序 | 结果 |
|---|---|---|
| (30-3**2+8//3**2*10) | (30-(3^2)+[8//(3^2)]*10) | 21 |
| 3*4**2/8% 5 | ([3*(4^2)/8 ]mod 5) | 1.0 |
| 2 ** 2 ** 3 | (2^{2^3}=2^{8}) | 256 |
| (2.5+1.25j)*4j/2 | (frac{(2.5+1.25j)*4j}{2}) | (-2.5+5j) |
3.6 请将下列数学表达式用Python程序写出来，并运算结果
| 数学表达式 | Python代码 | 结果 |
|---|---|---|
| (frac{z^4+7-3*4}{5}) | print((2* *4+7-3 * 4)/5) | 2.2 |
| ((1+3^2)* (16mod7)/7) | print((1+3**2)*(16%7)/7) | 2.857142857142857 |
3.7 假设x=1 ,x*=3+5 **2的运算结果是什么
| 表达式 | 运算顺序 | 结果 |
|---|---|---|
| x*=3+5 **2 | (x={x *[ 3+(5^{2})]}) | 28 |
模块1： math库
表3.5 math库中的数学常数 共4个
| 常数 | 数学表示 | 描述 |
|---|---|---|
| math.pi | (pi) | 圆周率，值为3.141592565358979 |
| math.e | (e) | 自然对数，值为2.718281828459045 |
| math.inf | $ infty $ | 正无穷大，负无穷大为- math.inf |
| math.nan | 非浮点数标记,NAN(not a Number) |
表3.6 math库的数值表示函数 共16个
| 函 数 | 数学表示 | 描述 |
|---|---|---|
| math.fabs(x) | $ | x |
| math.fmod(x,y) | (x \% y) | 返回x与y的模 |
| math.fsum([x,y,...]) | (x+y+cdots) | 浮点数精确求和 |
| math.ceil(x) | (lceil x ceil) | 向上取整，返回不小于x的最小整数 |
| math.floor(x) | (lfloor x floor) | 向下取整，返回不大于x的最小整数 |
| math.factorial(x) | (x !) | 返回x的阶乘，如果x是小数或负数，返回ValueRrror |
| math.gcd(a,b) | 返回a与b的最大公约数 | |
| math.frexp(x) | (x = m * 2^e) | 返回(m,e),当x=0,返回(0,0) |
| math.ldexp(x,i) | (x * 2^i) | 返回(x * 2^i)运算值，mth.frexp(x)函数的反运算 |
| math.modf(x) | 返回x的小数和整数部分 | |
| math.trunc(x) | 返回x的整数部分 | |
| math.copysign(x,y) | $ | x |
| math.isclose(a,b) | 比较a和b的相似性，返回True或False | |
| math.isfinite(x) | 当x为无穷大，返回True,否则，返回False | |
| math.isinf(x) | 当x为正数或负数无穷大，返回False;否则，返回True | |
| math.isnan(x) | 当x是NaN,返回True;否则，返回False |
表3.7 math库的幂对数函数 共8个
| 函数 | 数学表示 | 描述 |
|---|---|---|
| math.pow(x,y) | (x^y) | 返回x的y次幂 |
| math.exp(x) | (e^x) | 返回e的x次幂，e是自然对数 |
| math.xpml(x) | (e^x-1) | 返回e的x次幂减1，e是自然对数 |
| math.sqrt(x) | (sqrt x) | 返回x的平方根 |
| math.log(x,[base]) | (log_{base}x) | 返回x的对数值，只输入x时，返回自然对数，即(ln x) |
| math.log1p(x) | (ln(1+x)) | 返回1+x 的自然对数值 |
| math.log2(x) | (log x) | 返回x的2对数值 |
| math.log10(x) | (log_{10}x) | 返回x的10对数值 |
表3.8 math库的三角运算函数 共16个
| 函数 | 数学表示 | 描述 |
|---|---|---|
| math.degrees(x) | 角度x的弧度转角度值 | |
| math.radians(x) | 角度x的角度转弧度 | |
| math.hypot(x,y) | (sqrt{x^2+y^2}) | 返回(x,y)坐标到原点(0,0)的距离 |
| math.sin(x) | (sin(x)) | 返回x的正弦函数值，x是弧度值 |
| math.cos(x) | (cos(x)) | 返回x的余弦函数值，x是弧度值 |
| math.tan(x) | (tan(x)) | 返回x的正切函数值，x是弧度值 |
| math.asin(x) | (arcsin(x)) | 返回x的反正弦函数值，x是弧度值 |
| math.acos(x) | (arcos(x)) | 返回x的反余弦函数值，x是弧度值 |
| math.atan(x) | (arctan(x)) | 返回x的反正切函数值，x是弧度值 |
| math.atan2(y,x) | (arctan(y/x)) | 返回y/x的反正切函数值，x是弧度值 |
| math.sinh(x) | (sinh(x)) | 返回x的双曲正弦函数值 |
| math.cosh(x) | (cosh(x)) | 返回x的双曲余弦函数值 |
| math.tanh(x) | (tanh(x)) | 返回x的双曲正切函数值 |
| math.asinh(x) | (arcsinh(x)) | 返回x的反双曲正弦函数值 |
| math.acosh(x) | (cosh(x)) | 返回x的双曲余弦函数值 |
| math.atanh(x) | (tanh(x)) | 返回x的双曲正切函数值 |
表3.9 math库的高等特殊函数 4个
| 函数 | 数学表达 | 描述 |
|---|---|---|
| math.erf(x) | (frac{2}{sqrt{pi}}int_{0}^{x}{e^{-t^2}dt}) | 高斯误差函数，应用于概率论、统计学等领域 |
| math.refc(x) | (frac{2}{sqrt{pi}}int_{x}^{infty}{e^{-t^2}dt}) | 余补高斯误差函数，math.erfc(x)=1 - math.erf(x) |
| math.gamma(x) | (int_{0}^{infty}{x^{t-1}e^{-x}dx}) | 伽马函数(Gamma)，也叫欧拉第二积分函数 |
| math.lgamma(x) | (ln (gamma(x))) | 伽马函数的自然对数 |
思考与练习
round函数
round函数，对浮点数进行近似取值，保留几位小数，第一个参数是一个浮点数，第二个参数是保留的小数位数，可选，如果不写的话默认保留到整数。python3.5的doc中，文档为"values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice." 如果距离两边一样远，会保留到偶数的一边。比如round(0.5)和round(-0.5)都会保留到0，而round(1.5)会保留到2。
除非对精确度没什么要求，否则尽量避开用round()函数。近似计算我们还有其他的选择：
- 使用math模块中的一些函数，比如math.ceiling（天花板除法）。
- python自带整除，python2中是/，3中是//，还有div函数。
- 字符串格式化可以做截断使用，例如 "%.2f" % value（保留两位小数并变成字符串……如果还想用浮点数请披上float()的外衣）。
- 数字的格式化输出， 例如f'{2.501:.2f}' 具体参考上文
- 当然，对浮点数精度要求如果很高的话，请用decimal模块
3.8 请利用math库运行下面语句，获得计算结果
-
math.sin(2*math.pi）
代码
print(math.sin(2*math.pi))结果 (-2.4492935982947064e-16)
进行格式化输出
print(f'{math.sin(2*math.pi):f}')结果 (-0.000000)
分析：在数学中sin(2pi)应该为0,但是math库进行的是浮点数运算，得到的结果无限接近于0，进行浮点数格式化输出结果就是-0.000，这个负号也蛮有意思，因为计算结果是负数，所以格式化之后依然是负数
-
math.floor(-2.5 )
代码
print(math.floor(-2.5))floor是向下取整，结果是-(-3)
-
math.ceil(3.5+math.floor(-2.5))
代码
print(math.ceil(3.5+math.floor(-2.5)))ceil是向上取整，结果是(1)
-
round(math.fabs(-2.5))
代码
print(round(math.fabs(-2.5)))round函数 结果是(2)
-
math.sqrt(math.pow(2,4))
代码
print( math.sqrt(math.pow(2,4)) )结果是(4.0)，math模块计算的结果是浮点数，pow计算幂方，sqrt开平方
-
math.log(math.e)
代码：
print( math.log(math.e) )结果是(1)
-
math.gcd(12,9)
代码
print( math.gcd(12,9) )结果是(3)，gcd计算最大公约数
-
math.fmod(36,5)
代码
import math print( math.fmod(36,5) )fmod 求模运算
3.9 利用math库将47度角转化为弧度制，并将结果赋值给一个变量
代码
rad = math.radians(47)
print(rad)
3.10 利用math库将(frac{pi}{7})的弧度值转为角度值，并将结果赋值给一个变量
代码
deg = math.degrees(math.pi/7)
print(deg)
代码示例3—— 天天向上的力量
示例代码3.1
问题描述：
一年265天，以第一天的能力值为基数，记为1.0,当好好学习时能力值相比前一天提高千分之一，当没有学习时的能力值比前一天下降千分之一，每天努力和每天放任，一年下来的能力值相差多少呢？
分析：
天天向上是((1+0.001)^{365})，放任或向下的力量是((1-0.001)^{365})
代码：
import math dayup = math.pow((1.0+0.001),365) #提高0.001 daydown = math.pow((1.0-0.001),365) #放任0.001 print("向上：{:.2f},向下{:.2f}.".format(dayup,daydown))
示例代码3.2
问题描述：
一年365天，如果好好学习时能力值相比前一天提高千分之五，当放任时相比前一天下降千分之五，效果相差多少呢？
分析：
天天向上是((1+0.005)^{365})，放任或向下的力量是((1-0.005)^{365})
代码：
import math day_up = math.pow(1.0+0.005,365) #每天提高0.005 day_down = math.pow(1.0-0.005,365) #每天减少0.005 print("向上： {:.2f}, 向下： {:.2f}。".format(day_up,day_down))
代码示例3.3
问题描述：
一年365天，如果好好学习时能力值相比前一天提高百分之一，当放任时相比前一天下降百分之一，效果相差多少呢？
分析：
天天向上是((1+0.01)^{365})，放任或向下的力量是((1-0.01)^{365})
我们发现上面的代码除了每天努力的大小不一样，代码其余部分是完全相同的。我们可以使用dayFactor这个变量来表示这个值，来提高代码的重新使用性。
代码：
import math dayFactor = 0.01 day_up = math.pow((1.0+dayFactor),365) #每天提高dayFactor day_down= math.pow((1.0-dayFactor),365) #每天放任dayFactor print("向上： {:.2f}， 向下：{:.2f} 。".format(day_up,day_down))
代码示例3.4
问题描述：
一年365天，一周5个工作日，如果每个工作日都很努力，可以提高百分之一，仅在周末放松一下，能力值下降百分之一，效果如何呢？
分析：
使用循环实现，被7整除，余数为1到5认为是工作日，努力程度应该为(1+dayFactor),余数为6,0认为是休息日，努力程度应为(1-dayFactor)
代码：
import math day_up, dayFactor = 1.0, 0.01 for i in range(365): if i % 7 in [0,6]: day_up = day_up *(1-dayFactor) else: day_up = day_up *(1+dayFactor) print("向上5天向下2天的力量： {:.2f}。".format(day_up))
代码示例3.5
问题描述：
如果对示例代码3.4的结果感到意外，那么自然会有如下疑问：每周工作5天，休息两天，休息日水平下降0.01，工作日要努力到什么程度，一年后的水平才能与每天努力百分之一取得的效果一样呢？
分析：
我门采用最最简单的方法，暴力尝试。我门发现，暴力尝试的每一次都需要使用前面写过的函数体，所以我们可以通过保留字def定义一个求解的函数，这样将增强代码的可读性
代码：
#代码示例 天天向上3.5 import math def dayUP(dayFactor): day_up = 1.0 for i in range(365): if i % 7 in [0,6]: day_up = day_up * (1.0 - 0.01) else: day_up = day_up * (1.0 + dayFactor) return day_up dayFactor = 0.01 while(dayUP(dayFactor)<37.78): dayFactor += 0.001 print("每天努力参数是: {:.3f}。".format(dayFactor))
思考与练习
3.12 一年365天，初始水平为1.0，每工作一天水平增加N,不工作时水平不下降，一周连续工作4天，请编写程序运行结果并填写下表：
| N | 0.001 | 0.002 | 0.003 | 0.004 | 0.005 | 0.006 | 0.007 | 0.008 | 0.009 | 0.01 |
|---|---|---|---|---|---|---|---|---|---|---|
| 年终值 | 1.231 | 1.515 | 1.865 | 2.294 | 2.822 | 3.470 | 4.267 | 5.246 | 6.447 | 7.922 |
代码
#思考与练习 3.12
import math
def dayUP(dayFactor):
day_up = 1.0
for i in range(365):
if i % 7 in [1,2,3,4]:
day_up = day_up * (1.0 + dayFactor)
return day_up
dayFactor = [0.001,0.002,0.003, 0.004 ,0.005 , 0.006, 0.007 , 0.008 ,0.009 ,0.01]
for i in dayFactor:
print(f'{dayUP(i):.3f}')
3.13 一年365天，初始水平为1.0，每工作一天水平增加N,不工作时水平不下降，一周连续工作5天，请编写程序运行结果并填写下表：
| N | 0.001 | 0.002 | 0.003 | 0.004 | 0.005 | 0.006 | 0.007 | 0.008 | 0.009 | 0.01 |
|---|---|---|---|---|---|---|---|---|---|---|
| 年终值 | 1.297 | 1.681 | 2.179 | 2.823 | 3.657 | 4.737 | 6.133 | 7.938 | 10.723 | 13.291 |
代码
#思考与练习 3.13
import math
def dayUP(dayFactor):
day_up = 1.0
for i in range(365):
if i % 7 in [1,2,3,4,5]:
day_up = day_up * (1.0 + dayFactor)
return day_up
dayFactor = [0.001,0.002,0.003, 0.004 ,0.005 , 0.006, 0.007 , 0.008 ,0.009 ,0.01]
for i in dayFactor:
print(f'{dayUP(i):.3f}')
3.14 一年365天，初始水平为1.0，每工作一天水平增加N,不工作时水平不下降，一周连续工作6天，请编写程序运行结果并填写下表：
| N | 0.001 | 0.002 | 0.003 | 0.004 | 0.005 | 0.006 | 0.007 | 0.008 | 0.009 | 0.01 |
|---|---|---|---|---|---|---|---|---|---|---|
| 年终值 | 1.367 | 1.869 | 2.554 | 3.489 | 4.764 | 6.504 | 8.876 | 12.110 | 16.517 | 22.521 |
代码
#思考与练习 3.14
import math
def dayUP(dayFactor):
day_up = 1.0
for i in range(365):
if i % 7 in [0,1,2,3,4,5]:
day_up = day_up * (1.0 + dayFactor)
return day_up
dayFactor = [0.001,0.002,0.003, 0.004 ,0.005 , 0.006, 0.007 , 0.008 ,0.009 ,0.01]
for i in dayFactor:
print(f'{dayUP(i):.3f}')
3.15 一年360天，初始水平为1.0，以每个月30天计算，在每个月初连续十天里，每工作一天水平增加N,该月其他时间工作与否都不增加水平值 ，请编写程序运行结果并填写下表：
| N | 0.001 | 0.002 | 0.003 | 0.004 | 0.005 | 0.006 | 0.007 | 0.008 | 0.009 | 0.01 |
|---|---|---|---|---|---|---|---|---|---|---|
| 年终值 | 1.127 | 1.271 | 1.433 | 1.615 | 1.819 | 2.050 | 2.310 | 2.602 | 2.930 | 3.300 |
代码
#思考与练习 3.15
import math
def dayUP(dayFactor):
day_up = 1.0
for i in range(360):
if i % 30 in [0,1,2,3,4,5,6,7,8,9]:
day_up = day_up * (1.0 + dayFactor)
return day_up
dayFactor = [0.001,0.002,0.003, 0.004 ,0.005 , 0.006, 0.007 , 0.008 ,0.009 ,0.01]
for i in dayFactor:
print(f'{dayUP(i):.3f}')
字符串类型及操作
字符串的表示
-
单引号字符串：‘单引号表示，可以使用“双引号”作为字符串的一部分’
-
双引号字符串：“双引号表示，可以使用‘单引号’作为字符串的一部分”
-
三引号字符串：“‘三引号表示可以使用“双引号”
‘单引号’
也可以换行
“’‘
print('单引号表示，可以使用"双引号"作为字符串的一部分')
print("双引号表示，可以使用'单引号'作为字符串的一部分")
print('''三引号表示可以使用"双引号'
'单引号'
也可以换行
''')
-
访问字符，python使用方括号[]来访问字符串
- 正向递增序号，最左侧字符为0，向右递增，最右侧字符序号为L-1
- 反向递减序号，最右侧字符序号为-1，想做依次递减，最左侧字符序号为-L
-
区间访问(切片)，采用[N:M]格式，表示字符串从N到M（不包含M）的子字符串，其中，N和M为字符串的索引序号，可以混合使用正序和逆序序号.如果表示中M或N索引缺失，则表示字符串把开始或结束索引值设置为默认值.
切片访问完整形式应该为[开始：结束：步长]，省略步长为1
基本的字符串操作符 5个
| 操作符 | 描述 |
|---|---|
| x + y | 连接两个字符串x和y |
| x * n 或 n * x | 复制n次字符串x |
| x in s | 如果x是s的子串，返回True,否则返回False |
| str[i] | 索引，返回第i个字符 |
| str[M:N] | 切片，返回索引第M到N的子串，其中不包含N |
print("Python语言"+"程序设计")
name = "Python语言"+"程序设计"+"基础"
print(name)
print("Good"* 3)
print("Python语言"in name)
print('Y' in "Python语言")
微实例3.1 获取星期字符串
描述：程序读入一个表示星期几的数字(1~7)，输出对应的星期字符串名称。
例如，输入3，返回”星期三”
代码：
#微实例3.1 weekStr = "星期一星期二星期三星期四星期五星期六星期日" weekID = eval(input("请输入星期数字（1~7）：")) pos = (weekID-1)*3 print(weekStr[pos:pos+3])思考：微实例3.1通过在字符串中截取适当子串实现星期名称的查找。问题关键是找出子串的剪切位置。因为每个星期的缩写都是3个字符组成，所以较容易。使用字符串作为查找表的缺点是，所剪切的子字符串长度必须相同。
代码：
#微实例3.1改进,采用列表 week= ["星期一","星期二","星期三","星期四","星期五","星期六","星期日"] weekID = eval(input("请输入星期数字（1~7）：")) pos = (weekID-1) print(week[pos])
特殊的格式化控制字符
| 控制字符 | 含义 |
|---|---|
| a | 蜂鸣，响铃 |
| 回退，向后退一格 | |
| f | 换页 |
| 换行，光标移动到下行首页 | |
| 回车，光标移动到本页首行 | |
| 水平制表 | |
| v | 垂直制表 |
| NULL 什么都不做 |
内置的字符串处理函数 6个
| 函数 | 描述 |
|---|---|
| len(x) | 返回字符串x的长度，也可以返回其他组合数据类型元素的个数 |
| str(x) | 返回任意类型x所对应的字符形式 |
| chr(x) | 返回Unicode编码x对应的单字符 |
| ord(x) | 返回单字符对应的Unicode编码 |
| hex(x) | 返回整数x对应十六进制数的小写形式字符串 |
| oct(x) | 返回整数x对应八进制的小写形式字符串 |
微实例3.2 凯撒密码
描述：凯撒面貌是古罗马大帝凯撒对军事情报加密的算法，它采用了替换方法对信息中的每一个英文字符循环替代为字母表序列中该字符后面的第三个字符
加密 ： (C=(P+3)mod 26)
解密：(P=(C-3)mod26)
代码：
#微实例 凯撒加密 plaintext = input("请输入明文：") ciphertext="" for p in plaintext: if ord("a")<=ord(p) <=ord("z"): ciphertext = ciphertext+ chr( ord("a") + (ord(p)-ord("a")+3)%26 ) print(ciphertext)#微实例 凯撒解密 ciphertext = input("请输入密文：") plaintext="" for p in ciphertext: if ord("a") <= ord(p) <= ord("z"): plaintext = plaintext + chr( ord("a") + ( ord(p)-ord("a")-3)%26 ) print(plaintext)
内置的字符串处理方法 16个
| 方法 | 描述 |
|---|---|
| str.lower() | 返回字符串str的副本，全部字符小写 |
| str.upper() | 返回字符str的副本，全部字符大写 |
| str.islower() | 当str所有字符都是小写时。返回True,否则返回False |
| str.isprintable() | 当str所有字符都是可打印的，返回True,否则返回False |
| str.isnumeric() | 当str所有字符都是数字，返回True,否则返回False |
| str.isspace() | 当str所有字符都是空格，返回True,否则返回False |
| str.endswith(suffix,[start,[end]]) | str[start:end] 以suffix 结尾返回True,否则返回False |
| str.stratswith(prefix,[start,[end]]) | str[start:end] 以prefix开头返回True,否则返回False |
| str.split(seq=None,maxspilt=-1) | 返回一个列表，由str根据seq分割的部分构成 |
| str.count(sub,[,start[,end]]) | 返回str[start:end]中sub子串出现的次数 |
| str.replace(old,new[,count]) | 返回字符串str的副本，在其左侧和右侧去掉chars中列出的字符 |
| str.center(width[,fillchar]) | 字符串居中函数 |
| str.strip([cjhars]) | 返回字符串str的副本，在其左侧和右侧去掉charz中列出的字符 |
| str.zfill(width) | 返回字符串str的副本，长度为width，不足部分在左侧添0 |
| str.format() | 字符串的格式化输出 |
| str.join(iterable) | 返回一个新的字符串，由组合数据类型iterable变量的每个元素组成，元素间用str分割 |
思考与练习
3.16 s=“hello” t=”world” ,s+=t，则s,s[-1],s[2:8],s{::3},s{-2::-1}分别表示什么
| 表达式 | 结果 |
|---|---|
| s | helloworld |
| s[-1] | d |
| s[2:8] | llower |
| s[::3] | hlod |
| s[-2::-1] | lrowolleh |
s[2:8]完整的形式应该是s[2:8:1]，分别对应着[开始: 结尾: 步长]
s[::3]完整形式为s[0:10:3]
s[-2::-1]完整形式为[-2:-11:-1],从倒数第二个开始，按着步长为-1，从-2,逐步长前进，及 -2，-3，-4，...,-10,-11
3.17 判断题 ：Python中“4”+”5”的结果为“9”
错误，“4”，“5”是字符串类型，+含义为连接，结果为“45”
3.18
3.19 s=“Python String”,写出下列操作的输出结果：
| 表达式 | 结果 |
|---|---|
| s.upper(） | PYTHON STRING |
| s.lower() | python string |
| s.find('i') | 10 |
| s.replace('ing','gni') | Python Strgni |
| s.split() | ['Python', 'String'] |
3.20 下列表达式错误的是（）
A。 ’abcd’ <‘ad’ B ‘abc’ <‘abcd’ C “<a” D ‘Hello’>‘hello’
字符串的比较是按着Unicode编码来的
字符串类型的格式化
str.format()
由于我学习语言是从C++开始的，所以很不适应c语言的print风格，发现format输出格式也可以通过之前
Python 中如何实现数字的格式化输出？ (pythonf.cn)介绍的f-string风格实现，这种风格更类似于C++的输出形式，也就是直接在占位符中插入变量。
F-string
F-string 采用 {content:format} 的形式设置字符串格式，采用默认格式时则不需要指定 {:format}。其中 content 是替换并填入字符串的内容，可以是变量、表达式或函数等，format 是格式描述符。
对齐格式描述符
| 格式描述符 | 含义与作用 |
|---|---|
| < | 左对齐（字符串默认对齐方式） |
| > | 右对齐（数值默认对齐方式） |
| ^ | 居中 |
数字符号格式描述符
| 格式描述符 | 含义与作用 |
|---|---|
| + | 负数前加负号(-)，正数前加正号(+) |
| - | 负数前加负号(-)，正数前不加任何符号(默认) |
| （空格） | 负数前加负号(-)，正数前加一个空格 |
宽度与精度格式描述符
| 格式描述符 | 含义与作用 |
|---|---|
| width | 整数width指定宽度 |
| 0width | 整数width指定宽度，开头的0指定高位用0补足宽度 |
| width.precison | 整数width指定宽度，整数precision指定显示精度 |
基本格式类型
| 使用变量类型 | 格式描述符 | 含义与作用 |
|---|---|---|
| 字符串 | s | 普通字符串类型 |
| 整数 | b | 二进制整数类型 |
| 整数 | c | 字符类型，按unicode编码将整数转换为对应字符 |
| 整数 | d | 十进制整数类型 |
| 整数 | o | 八进制整数类型 |
| 整数 | x | 十六进制整数格式（小写字母） |
| 整数 | X | 十六进制整数格式（大写字母） |
| 整数、浮点数、复数 | e | 科学记数格式，以e表示*10^ |
| 整数、浮点数、复数 | E | 与e等价，但以E表示& 10^ |
| 整数、浮点数、复数 | f | 定点数格式，默认精度(precision)是6 |
| 整数、浮点数、复数 | F | 与f等价，但将nan和inf换成NAN和INF |
| 整数、浮点数、复数 | g | 通用格式，小数用f，大数用e |
| 整数、浮点数、复数 | G | 与G等价，但小数用F，大数用E |
| 整数、浮点数、 | % | 百分比格式，数字自动乘上100后按f格式排版，用加%后缀 |
千位分隔符格式描述符
| 格式描述符 | 含义与作用 |
|---|---|
| , | 使用，作为千位分隔符 |
若不指定‘,’ ，则f-strin不使用任何千位分隔符，此为默认设置。‘，’仅用于十进制整数、浮点数和复数，对于浮点数和复数，只分割小数点前的数位。
数字显示格式描述符
| 格式描述符 | 含义与作用 |
|---|---|
| # | 切换数字显示方式，切换进制 |
number = 1234
#转为16进制
print(f'{number:x}')
print(f'{number:X}')
print(f'{number:#x}')
print(f'{number:#X}')
实例4：文本进度条
print()
-
默认情况下，print()函数在输出结尾出会自动产生一个‘ ’，即换行符，从而让光标自动移动到下一行行首。
-
在print()函数中跟换参数end的默认值为‘’，即每次使用print()函数输出是不换行。此时系统光标还停留在上一次输出的行尾。
print("1") print("2") print("1",end='') print("2",end='') print("3") print("4")
简单的开始
实例代码
问题描述：
基本思想是按着任务执行百分比将整个任务划分为100个单位，每执行N%输出一次进度条。每一行输出包括进度百分比，代表已经完成的部分(**)和未完成的部分(..)的两种字符，以及一个跟随完成度前进的小箭头。调用Python标准时间库time,使用time.sleep(t)函数将当前程序暂时挂起ts.
代码：
#实例代码4.1 简单的开始 import time scale = 10 print("------执行开始------") for i in range(scale+1): a,b = '**' * i , '..'*(scale-i) c = (i/scale)*100 print(f'%{c:^3.0f}[{a}->{b}]') time.sleep(0.1) print("-------执行结束-------")
单行动态刷新
描述：只在一行汇总改变进度比例，与上个实例相比，区别在于原地输出和动态输出，其基本思想是将每一次进度条输出都固定在同一行，并不断用新生成的字符串覆盖之前的输出，形成进度条不断刷新的动态效果。这种方法称为“单行动态刷新”
代码：
#实例代码4.2 import time for i in range(101): print(f' {i:2}%',end="") time.sleep(0.05)
带刷新的文本进度条
描述：将前两小节程序合并。
为了进一步提高用户体验，在文本进度条中增加运行时间的监控，这里采用time库中的time.clock()函数。
time.clock()函数一般多次使用，第一次调用时为计时开始，统一程序中第二次及后续调用时返回与第一次计时之间的时间差，单位为秒。该函数主要用于统计程序运行时间，增加用户体验。
代码：
#实例代码4.3 import time scale = 50 print("执行开始".center(scale//2,'-')) t = time.clock() for i in range(scale+1): a = '*' * i b = '-' * (scale-i) c = (i/scale) * 100 t = t - time.clock() print(f' {c:^3.0f}%[{a}->{b}]{-t:.2f}s',end='') time.sleep(0.05) print(" "+"执行结束".center(scale//2,'-'))
程序练习题
3.1 重量计算。月球上物体的体重是在地球上的16.5%，假如你在地球上每年增加0.5kg，编写程序输出未来十年你在地球和月球上的体重状况。
#3.1 体重计算
nowKG = eval(input("请输入你现在的体重（kg）"))
for i in range(10):
nowKG+=0.5
print(f'{i+1}年后， 地球：{nowKG:.2f}， 月球：{nowKG*0.165:.2f}')
3.2 天天向上续。尽管每天坚持，但人的能力发展并不是无限的，它符合特定模型。假设能力增长符合如下带有平台期的模型：以7天为一个周期，连续学习三天能力值不变，从第四天开始至第七天每天能力增长为前一天的1%，如果7天中有1天间断学习，则周期从头算起。请编程回答，如果初始能力值为1，连续学习365天后能力值是多少？
#3.2 天天向上续
ability = 1.0
for i in range(365):
if(i % 7 in [0,1,2] ):
ability = ability
else :
ability *= 1.01
print(ability)
3.3 天天向上续。采用程序练习题3.2的能力增长模型，如果初始能力值为1，固定每10天休息一天，365天后能力值是多少？如果每15天休息一天呢？
#3.3 天天向上续
ability = 1.0
for i in range(365):
if(i % 10 in [1,2,3] ):
ability = ability
elif (i % 10 in [4,5,6,7] ):
ability *= 1.01
elif (i % 10 in [8,9,0] ):
ability = ability
print(ability)
3.4 回文数判断。设n是一任意自然数，如果n的各位数字反向排列所得自然数与n相等，则n被称为回文数。从键盘输入一个5位数字，请编写程序判断这个数字是不是回文数。
#回文数判断
import math
number = input()
length = len( number )
flag=""
for i in range(math.trunc(length/2)):
if (number[0+ i] != number[length-(i+1)]):
flag+="F"
break
else:
flag+="T"
print(flag)
3.5 田字格的输出。使用print()函数输出如图所示的田字格。
def a():
for i in range(11):
if i%5 == 0 :
print("+ - - - - + - - - - +")
else :
print("| | |")
a()
3.6 文本进度条。仿照实例4，打印如下形式的进度条。
import time
print("Starting",end='')
for i in range(10):
print(f'.',end='')
time.sleep(0.5)
print("Done!")
3.7 文本风格。将如下程序段存为文件，在控制台终端（如W新动物是的cmd.exe)运行改程序，观察输出结果。更改print()函数的参数，例如，去掉end的赋值，再观察运行结果。
while True:
for i in ["/","-","|","\","|"]:
print ("%s
" % i ,end ='')
运行之后打开了记事本
3.8 小巧而精致的第三方进度条库tqdm。tqdm是一个快速、扩展性强的进度条工具库。tqdm是一个第三方库，首先需要安装，然后才能使用。请读者安装，运行如下程序，观察运行结果。
# 程序练习题3.8
from tqdm import tqdm
from time import sleep
for i in tqdm(range(1,100)):
sleep(0.01)
Python123
1 实例3：天天向上的力量
这是"实例"题，与课上讲解实例相同，请作答检验学习效果。
#代码示例 天天向上3.5
import math
def dayUP(dayFactor):
day_up = 1.0
for i in range(365):
if i % 7 in [0,6]:
day_up = day_up * (1.0 - 0.01)
else:
day_up = day_up * (1.0 + dayFactor)
return day_up
dayFactor = 0.01
while(dayUP(dayFactor)<37.78):
dayFactor += 0.001
print("工作日的努力参数是: {:.3f}".format(dayFactor))
2 实例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
dur = time.perf_counter() - start
print("
{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')
time.sleep(0.1)
print("
"+"执行结束".center(scale//2,'-'))
3 三次方格式化3
获得用户输入的一个数字，可能是整数或浮点数，a，计算a的三次方值，并打印输出。
输出结果采用宽度20个字符、居中输出、多余字符采用减号(-)填充。
如果结果超过20个字符，则以结果宽度为准。
输入示例
10输出示例
--------1000--------代码：
import math Cin = eval(input()) a =pow(Cin,3) print(f'{a:-^20}')
4 星号三角形
读入一个整数N，N是奇数，输出由星号字符组成的等边三角形，要求：
第1行1个星号，第2行3个星号，第3行5个星号，依次类推，最后一行共N的星号。
输入示例 输出示例 示例1 3 * *** 代码：
# 星号三角形 n = eval(input()) for i in range(1,n+1,2): a = '*' * i print( f'{a:^{n}}' )
5 凯撒密码
对于原文字符P，其密文字符C满足如下条件：C=(P+3) mod 26
上述是凯撒密码的加密方法，解密方法反之，即：P=(C-3) mod 26
假设用户可能使用的输入包含大小写字母azAZ、空格和特殊符号，请编写一个程序，对输入字符串进行恺撒密码加密，直接输出结果，其中空格不用进行加密处理。使用input()获得输入。
代码:
#凯撒密码 plaintext = input() ciphertext="" for p in plaintext: if 'a'<= p <= 'z': ciphertext += chr( ord('a') + ( (ord(p)-ord('a')) +3 )%26 ) elif 'A'<= p <= 'Z': ciphertext += chr( ord('A') + ( (ord(p)-ord('A')) +3)%26 ) else : ciphertext += p print(ciphertext)