python学习笔记-第3章-基本数字类型

3.1数字类型

3.1.1数字类型概述

python提供3种数字类型：整数、浮点数和复数，分别对应数学中的整数、实数和复数

3.1.2整数类型

进制种类	引导符号	描述
十进制	无	默认情况，录入，1010,-425
二进制	0b或0B	由字符0和1组成，例如，0b101,0B101
八进制	0o或0O	由字符0到7组成，例如0o711,0O711
十六进制	0x或0X	由字符0到9、a到f、A到F组成，例如，0xABC

pow(x,y,z)计算 x ^ y mod z

3.1.3浮点数类型

科学计数法使用字母e或E作为幂的特点，以10为奇数

<a>e<b> = a * (10) ^ b

例如
4.3e-3 的值为0.0043
9.6E5 也可表示为9.6E + 5 ，其值为960000.0

在python中超过15位数字计算浮点数会产生误差，，但python支持无限制且准确的整数运算

如果希望获得更高的精度计算结果，往往采用整数而不直接采用浮点数

例如

print(3.141592653 * 1.234567898)
print(3141592653  * 1234567898)

结果：
3.8785094379864535
3878509437986453394

扩展：高精度浮点运算类型

python通过标准库decimal提供了一个更精确的数字类型Decimal，这个类型利用上问所介绍的整数运算方法提供搞精度的浮点数运算，并可以使用getcontext().prec参数自定义浮点数精度的位数

import decimal
a = decimal.Decimal('3.141592653')
b = decimal.Decimal('1.234567898')
decimal.getcontext().prec = 20
print(a * b)

结果：

3.878509437986453394

注意在使用decimal库时，Decimal（‘数字’）是高精度数字的基本表示形式，需要使用单引号。

3.1.4复数类型

j = 根号（-1） ,复数可以看做是二元有序实数对（a，b）表示为a + bj

python 中复数的虚数部分通过后缀 “J” 或 “j” 来表示，例： 12.3 + 4j

复数类型中实数部分和虚数部分的数值都是浮点类型。对于复数z，可以用z.real和z.imag分别获得它的实数部分和虚数部分

print ((1.23e-4 + 5.67e+89j).real)
print ((1.23e-4 + 5.67e+89j).imag)

结果：
0.000123
5.67e+89

3.2数字类型的操作

3.2.1内置的数值运算操作符

操作符	描述
x // y	x与y之整数商，即不大于x与y之商的最大整数
x ** y	x的y次幂，即x ^ y

三种数字类型之间存在一种逐渐扩展的关系：
整数 -> 浮点数 -> 复数

3.2.2内置的数值运算函数

函数	描述
abs（x）	x的绝对值
divmod（x，y）	（x //y, x % y），输出为二元组形式（也称为元组类型）
round(x[,ndigits])	对x四舍五入，保留ndigits位小数。round（x）返回四舍五入的整数值
max（x1,x2…,xn）	求最大值，n没有限定
min(x1,x2…,xn)	求最小值，n没有限定

>>> divmod(3,7)
(0, 3)
>>> abs( -34)
34
>>> round(3.1415926,4)
3.1416

3.2.3内置的数字类型转换函数

函数	描述
int(x)	将x转换为整数，x可以是浮点数或字符串
float(x)	返回浮点数x或字符串x所对应的整数类型
complex(re[,im])	生成一个复数，实部为re，虚部为im，re可以是整数、浮点或字符串，im可以是整数或浮点数但不能为字符串

>>> int(10.99)
10
>>> complex(10.99)
(10.99+0j)
>>> float("123456")
123456.0
>>> float('456789')
456789.0
>>> int("234")
234
>>> int("abcde")
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    int("abcde")
ValueError: invalid literal for int() with base 10: 'abcde'

3.3模块1：math库的使用

引用方法
第一种： import math
第二种：from math import <函数名>

常数	数学表示	描述
math.pi	π	圆周率，值为3.141592653589793
math.e	e	自然对数，值为2.718281828459045
math.inf	无穷	正无穷大，负无穷大为-math.inf

>>> import math
>>> math.pi
3.141592653589793
>>> math.e
2.718281828459045
>>> math.inf
inf
>>> 

函数	描述
math.fmod(x,y)	返回x与y的模
math.fabs(x)	返回x的绝对值
math.fsum([x,y,…])	浮点数精确求和
math.factorial(x)	返回x的阶乘，如果x是小数或负数，返回ValueError
math.gcd(a,b)	返回a与b的最大公约数
math.modf(x)	返回x的小数和整数部分
math.trunc(x)	返回x的整数部分

>>> math.factorial(40)
815915283247897734345611269596115894272000000000
>>> 0.1+0.2+0.3
0.6000000000000001
>>> import math
>>> math.fsum([0.1+0.2+0.3])
0.6000000000000001
>>> math.fsum([0.1,0.2,0.3])
0.6
>>> 

浮点数，在python解释器内部表示时存在一个小数点后若干位的精度尾数，当浮点数进行运算时，这个精度尾数可能会影响输出结果。因此，在涉及浮点数运算及结果比较时，建议采用math库提供的函数，而不直接采用python提供的运算符

幂对函数	描述
math.pow(x,y)	返回x的y次幂
math.exp(x)	返回e的x次幂，e是自然对数
math.expml(x)	返回e的x次幂减1
math.sqrt(x)	返回x的平方根
math.log(x[,base])	返回x的对数值，只输入x时，返回自然对数，即lnx

>>> math.exp(3)
20.085536923187668
>>> math.pow(10,1/3)
2.154434690031884

3.4实例：天天向上

一年365天，一周工作5个工作日，每天可以提高1% ，在周末放任一下，能力下降1%

dayup,dayfactor = 1.0,0.01
for i in range(365):
    if i % 7 in [6,0]:  #周末休息
        dayup = dayup * (1 - dayfactor)
    else:
        dayup  = dayup * ( 1 + dayfactor)


print("向上五天，向下2天的力量：{:.2f}".format(dayup))

结果：
向上五天，向下2天的力量：4.63

3.5 字符串类型及操作

3.5.1 字符串类型的表示

一对单引号（‘’）：仅可表示单行字符串
一对双引号（“”）：仅可表示单行字符串
一对三引号（’’’ ‘’’）:可以表示单行或多行字符串

3.5.2基本的字符串操作符

操作符	描述
x + y	连接两个治疗费从x与y
x*n 或n * x	复制n次字符串x
x is s	如果x是s的字串，返回True ，否则返回False
str[i]	索引，返回第i个字符
str[N:M]	切片，返回索引第N到第M的子串，其中不包括M

>>> "hello" +  "world"
'helloworld'
>>> "我好帅" * 3
'我好帅我好帅我好帅'
>>> "帅" in "我好帅"
True

【实例】:获取星期字符串

weekstr = "星期一星期二星期三星期四星期五星期六星期天"
day = eval(input("请输入星期数字（1 - 7）："))
pos = (day - 1) * 3
print(weekstr[pos:pos+3])

结果：
请输入星期数字（1 - 7）：3
星期三

特殊的格式化控制字符	描述
\a	蜂鸣，响铃
\b
\f	换页
\n	换行，光标移动到下行首行
\r	回车，光标移动到本行首行
\t	水平制表
\v	垂直制表
\0	NULL，什么也不做

3.5.3内置的字符串处理函数

python3以Unicode字符为计数基础， 因此，字符串中英文字符和中文字符都是1个单位长度

内置的字符串处理函数	描述
len(x）	返回字符串x的长度，也可返回其他组合数据类型元素个数
str(x)	返回任意类型x所对应的字符串形式
chr(x)	返回Unicode编码x对应的单字符
ord(x)	返回单字符表示的Unicode编码
hex(x)	返回整数x对应十六进制的小写形式字符串
oct(x)

凯撒密码

plaincode = input("请输入明文:")   #加密
for p in plaincode:
    if ord('a') <= ord(p) <= ord('z'):
        print(chr(ord('a') + (ord(p) - ord('a') + 3) % 26),end='')
    else:
        print(p,end='')

print()

t = input("请输入密文：")  #解密
for i in t:
    if ord('a') <= ord(i) <= ord('z'):
        print(chr((ord(i) - ord('a') - 3 )% 26  + ord('a')),end = '')
    else:
        print(i,end='')


结果：
请输入明文:hello world
khoor zruog
请输入密文：khoor zruog
hello world

3.5.4内置的字符串处理方法

方法	描述
str.lower()	返回字符串str的副本，全部字符小写
str.upper()	返回字符串str的副本，全部字符大写
str.islower()	当str所有字符都是小写时，返回True，否则返回False
str.isprintable()	当str所有字符都是可打印的，返回True，否则返回False
str.isnumberic()	当str所有字符都是数字时，返回True，否则返回False
str.split(sep=None,maxsplit= -1)	返回一个列表，由str根据sep被分割的部分构成，默认分隔符为空格，maxsplit阐述为最大分割次数，默认maxsplit参数可以不给出
str.count(sub[,start[,end]])	返回str[start:end]中sub子串出现的次数
str.replace(old,new[,count])	返回字符串str的副本，所有old子串被替换成new，如果count给出，则前count次old出现被替换
str.zfill(width	返回字符串str的副本，长度为width，不足的部分在左侧添‘0’，但如果str最左侧是字符‘+’ 或者‘-’，则从第二个字符左侧添加‘0’

>>> hex(255)
'0xff'
>>> "python is an excellent language.".split()
['python', 'is', 'an', 'excellent', 'language.']
>>> "-123".zfill(10)
'-000000123'
>>> "python is an excellent language".replace('s','a')
'python ia an excellent language'

3.6字符串类型的格式化

3.6.1 format（）方法的基本使用

字符串format()方法的基本使用格式如下：
<模板字符串>.format(<逗号分隔的参数>)

模板字符串由一系列槽组成，用来控制字符串中嵌入值出现的位置，其基本思想是将format()方法中逗号分隔的阐述按照序号关系替换到模板字符串的槽中。槽用大括号（{}）表示，如果大括号中没有序号，则按照出现顺序替换

>>> "{}最高，{}最胖，{}最帅。".format("老大","老二","老三")   #下标从0开始
'老大最高，老二最胖，老三最帅。'
>>> "{2}最高，{0}最胖，{1}最帅。".format("老大","老二","老三")
'老三最高，老大最胖，老二最帅。'

3.6.2 format()方法的格式控制

format()方法中模板的字符串的槽除了包括参数符号，还可以包括格式控制信息，此时，槽的内部样式如下：

{<参数序号>: <格式控制标记>},其中格式控制标记用来控制参数显示时的格式：

:	<填充>	<对齐>	<宽度>	< , >	<.精度>	类型
引导符号	用于填充的单个字符	<左对齐；>右对齐；^居中对齐；	槽的设定输出宽度	数字的千位分割符，适用于整数和浮点数	浮点数小数部分的精度或字符串的最大输出长度	整数类型b,d,o,x,X；浮点数类型e,E,f,%

>>> s = "PYTHON"
>>> "{0:30}".format(s)              #默认使用空格填充
'PYTHON                        '
>>> "{0:>30}".format(s)               #右对齐
'                        PYTHON'
>>> "{0:*^30}".format(s)               #居中且使用*填充
'************PYTHON************'
>>> "{0:-^30}".format(s)              #居中且使用-填充
'------------PYTHON------------'
>>> "{0:-^30,}".format(1234567890)    #使用，分隔
'--------1,234,567,890---------'
>>> "{0:-^30}".format(1234567890)    #对比输出
'----------1234567890----------'
>>> "{0:-^30,}".format(12345.67890)
'---------12,345.6789----------'

<精度>表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度

>>> "{0:.2f}".format(123456.6547890)
'123456.65'
>>> "{0:H^20.2f}".format(123456.6547890)
'HHHHH123456.65HHHHHH'
>>> "{0:H^.4}".format("python")
'pyth'
>>> 

整数类型格式

类型	描述
b	输出整数的二进制方式
c	输出整数对应的Unicode字符
d	输出整数的十进制方式
o	输出整数的八进制方式
x	输出整数的小写16进制方式
X	输出整数的大写16进制方式

>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
'110101001,Ʃ,425,651,1a9,1A9'

浮点数类型

类型	描述
e	输出浮点数对应的小写字母e的指数形式
E	输出浮点数对应的大写字母E的指数形式
f	输出浮点数的标准浮点形式
%	输出浮点数的百分形式

3.7 实例4：文本进度条

3.7.1 简单的开始

import time

scale = 10
print("------执行开始-----")
for i in range(scale + 1):
    a, b = '**' * i, '..' * (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.7.2单行动态刷新

import time

for i in range(101):
    print("\r{:3}%".format(i),end='')  #回到行首
    time.sleep(0.5)

执行结果为动态刷新

 53%

3.7.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 -= time.clock()
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,-t),end='')
    time.sleep(0.05)
print("\n" + "执行结束".center(scale//2,'-'))

出现了个异常

-----------执行开始----------
Traceback (most recent call last):
  File "F:\pythonworkspace\1example\main.py", line 4, in <module>
    t = time.clock()
AttributeError: module 'time' has no attribute 'clock'

找了下原因

Python3.8不再支持time.clock，但在调用时依然包含该方法；

有效处理：
用 time.perf_counter() 替换

import time
scale = 50
print("执行开始".center(scale//2,'-'))  #居中
t = time.perf_counter()
for i in range(scale + 1):
    a = '*' * i
    b = '.' * (scale - i)
    c = (i / scale) * 100
    t -= time.perf_counter()
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,-t),end='')
    time.sleep(0.05)
print("\n" + "执行结束".center(scale//2,'-'))

执行结果

-----------执行开始----------
100%[**************************************************->]89.38s
-----------执行结束----------