python-第3章-基本数据类型

python-第3章-基本数据类型

数字类型

数字类型概述

计算机对数字的识别和处理的两个基本要求：确定性和高效性

确定性——准确解读数据代表的类型含义

高效性——程序为数字运算提供较高的计算速度，同时具备较少的存储空间

*整数和带有小数的数字分别由计算机中央处理器不同的硬件逻辑操作，故尽可能提高运行速度，需要区别不同运行速度的数字类型

整数类型

整数类型共4种进制表示：十进制（默认情况），二进制，八进制和十六进制

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

整数类型理论上的取值范围是[-∞,∞],实际上的取值范围受限于运行python程序的计算机内存大小

浮点数类型

浮点数有两种表示方法：十进制表示和科学计数法表示

科学计数法使用字母e或E作为幂的符号，以10为基数

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

eg. 4.3e-3=0.0043 ; 9.6E5=960000.0

python浮点数的数值范围和小数精度受不同计算机系统的限制，sys.float_info详细列出python解释器所运行系统的浮点数各项参数

>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
>>> sys.float_info.max
1.7976931348623157e+308

max	min	max_10_exp	min_10_exp	radix	max_exp	min_exp
浮点数类型所能表示的最大数	浮点数类型所能表示的最小数	科学计数法表示下最大值的幂	科学计数法表示下最小值的幂	基数	基数为2时最大值的幂	基数为2时最小值的幂

<a>	mant_dig	epsilon	dig
系数	科学计数法表示中系数的最大精度	计算机所能分辨的两个相邻浮点数的最小差值	能准确计算的浮点数最大个数

浮点数在超过15位数字计算中产生的误差与计算机内部采用二进制运算有关，使用浮点数无法进行极高精度的数字运算。使用整数表达浮点数的方法是高精度运算的基本方法之一

>>> 3.141592653*1.234567898        #浮点数运算
3.8785094379864535
>>> 3141592653*1234567898          #整数运算
3878509437986453394

*高精度浮点数运算

标准库decimal提供一个更精确的数字类型Decimal,使用getcontext().prec参数自定义浮点数精度的位数

>>> import decimal
>>> a=decimal.Decimal('3.141592653')     #使用decimal库，注意格式   Decimal('数字')
>>> b=decimal.Decimal('1.234567898')
>>> decimal.getcontext().prec=20
>>> a*b
Decimal('3.878509437986453394')

复数类型

如果将实数看成一个数轴，虚数看成与实数垂直的正交数轴，j表示“逆时针旋转90°”，或者“逆时针旋转 π/2”。

虚数的数轴表示

复数可以看作是二元有序实数对（a,b）,表示为a+bj,其中，a是实数部分（简称实部），b是虚数部分（简称虚部），python语言中，负数的虚部通过后缀 “J” 或 “j” 表示

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

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

数字类型的操作

内置的数值运算操作符

python提供9个基本得数值运算操作符——内置操作符（python解释器直接提供）

操作符	描述
x+y	x与y之和
x-y	x与y之差
x*y	x与y之积
x/y	x与y之商
x//y	x与y之整数商，即不大于x与y之商的最大整数
x%y	x与y之商的余数，也称为模运算
-x	x的负值，即x*(-1)
+x	x的本身
x**y	x的y次幂

操作符运算的结果可能改变数字类型，3个数字类型存在一种逐渐扩展的关系

整数 --> 浮点数 --> 复数

>>> 100/3
33.333333333333336
>>> 100//3
33
>>> 123+4.0
127.0
>>> 10.0-1+2j   #(10.0-1)+2j
(9+2j)

赋值操作符

x op= y 等价于 x = x op y

(op= + , - , * , / , // , % , ** )

>>> x=3
>>> x**=3  #等价于   x=  x^3
>>> x
27

内置的数值运算函数

图11-18 1abs()可以计算复数的绝对值。复数的绝对值是二维坐标系中复数位置到坐标原点的长度。

>>> abs(-3+4j)
5.0

pow()函数第三个参数z是可选的，模运算与幂运算同时进行速度很快。

pow(3,pow(3,999))%10000 和 pow(3,pow(3,999),10000) 第二种计算结果更快

模运算（%）

在编程中十分常用，主要应用于具有周期规律的场景

day%7——表示星期

n%2——判断整数n的奇偶性（整数的模运算n%能够将整数n映射到[0,m-1]）

内置的数字类型转换函数

图11-18 2

复数不能直接转换为其他数字类型，可以通过.real和.imag将复数的实部或虚部分别转换

>>> int(10.99)
10
>>> complex(10.99)
(10.99+0j)
>>> float(10+99j)   #  错误例子
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: float() argument must be a string or a real number, not 'complex'
>>> float((10+99j).imag)
99.0

math库的使用

简介

本书不区分函数库和模块,对于所有需要import使用的代码统称为函数库，这种利用函数库编程的方式称为“模块编程”

这些库分为python环境中默认支持的函数库，以及第三方提供需要进行安装的函数库，其中默认支持的函数库也叫做标准函数库或内置函数库

math库是python提供的内置数学类函数库，不支持复数函数，仅支持整数和浮点数运算，一共提供了4个数学常数和44个函数

引用库的方式

第一种：import math 对math库中的函数采用math.<b>()形式使用

>>> import math
>>> math.ceil(10.2)
11

第二种：from math import <函数名> 对math库中的函数直接采用<函数名>()形式使用

>>> from math import floor
>>> floor(10.2)
10

库常数和函数

数字常数（4）

常数	数学表示	描述
math.pi	π	圆周率，值为3.1415926…
math.e	e	自然对数，值为2.718281…
math.inf	∞	正无穷大，负无穷大是-math.inf
math.nan		非浮点数标记，NaN（Not a Number）

数值表示函数（16）

当浮点数进行运算时，精度尾数可能会影响输出的结果。故在涉及浮点数的运算及结果比较，建议采用math库提供的函数。

>>> 0.1+0.2+0.3
0.6000000000000001
>>> import math
>>> math.fsum([0.1,0.2,0.3])   #组合数要在[]内，用,隔开
0.6

幂对数函数（8）

三角运算函数（16）

arctan 1 的值是π/4，利用math库的atan()函数得到π值

>>> import math
>>> math.atan(1)*4
3.141592653589793

高等特殊函数（4）

伽玛函数不属于初等数学，但它很有趣

1）x为任意数，Γ（x+1) = xΓ（x)

2）当x为整数时，Γ（x+1) = xΓ（x) = x(x-1)Γ（x-1)=…=x!

3)Γ（1/2) = √π

可以利用伽马函数计算浮点数的“阶乘”，math.factorial()函数只能计算非负整数的阶乘

>>> import math
>>> math.factorial(10)
3628800
>>> math.gamma(11)
3628800.0
>>> math.gamma(0.5)
1.7724538509055159
>>> math.gamma(-10.2)
-9.184935416782052e-07
>>> math.factorial(-10.2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>>

例子：天天向上的力量

import math                         #0.001版
dayup=math.pow((1.0+0.001),365)     #学习提高0.001，共365天
daydown=math.pow((1.0-0.001),365)   #不学习减少0.001，共365天
print("向上:{:.2f},向下：{:.2f}.".format(dayup,daydown))

============================= RESTART: D:/12234.py =============================
向上:1.44,向下：0.69.

import math                          #0.005版
dayup=math.pow((1.0+0.005),365)
daydown=math.pow((1.0-0.005),365)
print("向上:{:.2f},向下：{:.2f}.".format(dayup,daydown))
============================= RESTART: D:/12234.py =============================
向上:6.17,向下：0.16.

import math                             
dayfactor=0.01                        #添加变量值dayfactor
dayup=math.pow((1.0+dayfactor),365)
daydown=math.pow((1.0-dayfactor),365)
print("向上:{:.2f},向下：{:.2f}.".format(dayup,daydown))
============================= RESTART: D:/12234.py =============================
向上:37.78,向下：0.03.

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("向上5天向下2天的力量：{:.2f}.".format(dayup))
============================= RESTART: D:/12234.py =============================
向上5天向下2天的力量：4.63.

def dayUP(df):
    dayup=1.0
    for i in range(365):
        if i%7 in [6,0]:
            dayup=dayup*(1-0.01)
        else:
            dayup=dayup*(1+df)
    return dayup
dayfactor=0.01                  # 初始赋值
while (dayUP(dayfactor)<37.78):
    dayfactor +=0.001           #dayfactor逐渐增大，直到符合条件输出
print("每天的努力参数是：{:.3f}.".format(dayfactor))
============================= RESTART: D:/12234.py =============================
每天的努力参数是：0.019.

字符串类型及其操作

字符串类型的表示

单引号和双引号都可以表示单行字符串

三引号可以表示单行或双行字符串

单引号："我'非常'爱你"

双引号：'我"非常"爱你'

三引号：'''我

​ '非常'

​ "爱"你'''

input()函数将用户输入的内容当作一个字符串类型——获得用户输入的常用方式

print()函数可以直接打印字符串——输出字符串的常用方式

>>> name=input("请输入名字：")
请输入名字：汽水
>>> print(name)
汽水

python字符串也提供区间访问方式，采用[N,M]格式，表示字符串中从N到M（不包括M）的字符串。

如果表示中M或者N索引缺失，则表示字符串把开始或结束索引值设为默认值。

字符串以Unicode编码存储，因此，字符串的英文字符和中文字符都算作1个字符

>>> name="python语言程序设计"
>>> name[0]
'p'
>>> print(name[0],name[7],name[-1])
p 言 计
>>> print(name[:6])
python
>>> print(name[6:])
语言程序设计
>>> print(name[:])
python语言程序设计

反斜杠字符（\）是一个特殊符号，在字符串中表示转义——该字符与后面相邻的一个字符共同组成了新含义。例如：

\n ——换行 \\ ——反斜杠 \' ——单引号

\" ——双引号 \t ——制表符（Tab）

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

>>> "pig爱吃"+"青菜"              #连接
'pig爱吃青菜'
>>> name="pig爱吃"+"青菜"+"根部"  
>>> name
'pig爱吃青菜根部'                 #复制
>>> "pig!"*3
'pig!pig!pig!'
>>> "pig爱吃" in name            #判断子串
True
>>> "dog" in "pig爱吃"
False

例子：获取星期字符串

weekstr = "星期一星期二星期三星期四星期五星期六星期日"
weekid = eval(input("请输入星期数字（1-7）："))
pos = (weekid - 1)*3      #程序限制子字符串的长度要一样
print(weekstr[pos:pos+3])
============================= RESTART: D:/23133.py =============================
请输入星期数字（1-7）：1
星期一

内置的字符串处理函数

内置字符串处理函数（6）

len(x)返回字符串x的长度，python3以Unicode字符为计数基础，故字符串中英文字符和中文字符都是一个长度

>>> len("dog爱吃骨头")
7

str(x)返回x的字符串形式，其中，x可以是数字类型或其他类型

>>> str("3.1415926")
'3.1415926'

每一个字符在计算机中可以表示为一个数字，称为编码。字符串则以编码序列方式存储在计算机中。

计算机系统使用的一个重要编码是ASCII编码

python字符串中每一个字符都使用Unicode编码表示，Unicode编码x的取值范围是0到1114111（即十六进制数0x10FFFF）

ord(x)函数返回单字符x对应的Unicode编码

>>> "1+1=2"+chr(10004)
'1+1=2✔'
>>> "金牛座字符的Unicode值是："+str(ord("♉"))
'金牛座字符的Unicode值是：9801'

hen(x)和oct(x)函数分别返回整数x对应十六进制和八进制值的字符串形式，字符串以小写表示

>>> oct(-32)    #八进制
'-0o40'
>>> hex(32)     #十六进制
'0x20' 

例子：加密算法——凯撒密码

P原文：ABCDEFGHIJKLMNOPQRSTUVWXYZ

C密文：DEFGHIJKLMNOPQRSTUVWXYZABC

C=(P+3)mod26

P=(C-3)mod26

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='')
============================= RESTART: D:/23133.py =============================
请输入明文：dog is cute.
grj lv fxwh.

内置的字符串处理方法

常用的内置字符串处理方法（共16个）

str.zfill(width)方法返回长度为width的字符串，如果字符串长度不足width，在左侧添加字符"0"，但如果str最左侧是字符"+“或者”-“，则从第二个字符左侧添加"0”,当width小于字符串长度时，返回str

>>> "the little pig is so cute.".split()
['the', 'little', 'pig', 'is', 'so', 'cute.']
>>> "pig".center(40,'=')
'==================pig==================='
>>> "888".zfill(40)
'0000000000000000000000000000000000000888'
>>> "+888".zfill(40)
'+000000000000000000000000000000000000888'

字符串类型的格式化

format()方法的基本使用

format()方法的槽顺序和参数顺序

format()槽与参数的对应关系

如果大括号中指定了使用参数的序号，按照序号对应参数替换，参数从0开始

>>> "{}:今天的{}很好，{}明媚".format("2023-11-11","天气","阳光")
'2023-11-11:今天的天气很好，阳光明媚'

>>> "{}{}{}".format("圆周率是","3.1415926","...")
'圆周率是3.1415926...'
>>>"圆周率{{{1}{2}}}是{0}".format("无理数","3.1415926","...")
'圆周率{3.1415926...}是无理数'
>>> s="圆周率{{{1}{2}}}是{0}"
>>> s
'圆周率{{{1}{2}}}是{0}'
>>> s.format("无理数",3.1415926,"...")
'圆周率{3.1415926...}是无理数'

format()方法的格式控制

槽中格式控制标记的字段

<对齐>指参数在宽度内输出时的对齐方式，分别使用<、>和^，这3个符号表示左对齐、右对齐和居中对齐

>>>s="python"                             
>>>"{0:30}".format(s)                   #默认左对齐
'python                        '        
>>>"{0:>30}".format(s)                  #右对齐
'                        python'
>>>"{0:*^30}".format(s)                 #居中且使用*填充
'************python************'
>>>"{0:-^30}".format(s)                 #居中且使用-填充
'------------python------------'
>>>"{0:3}".format(s)                    #参数长度比宽度设定值大，使用参数实际长度
'python'

格式控制标记中逗号（，）用于显示数字类型的千位分隔符

>>> "{0:-^20,}".format(123456789)
'----123,456,789-----'
>>> "{0:-^20}".format(123456789)   #无分隔符
'-----123456789------'
>>> "{0:-^20,}".format(12345.67890)
'----12,345.6789-----'

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

>>> "{0:2f}".format(12345.67890)
'12345.678900'
>>> "{0:H^20.3f}".format(12345.67890)
'HHHHH12345.679HHHHHH'
>>> "{0:.4}".format("python")
'pyth'

<类型>表示输出整数和浮点数类型的格式规则

对整数类型，输出格式包括以下六种

1）b:二进制

2）c：对应的Unicode字符

3）d：十进制

4）o：八进制

5）x：小写十六进制

6）X：大写十六进制

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

对浮点数类型，输出格式包括以下四种

1）e：对应的小写字母e的指数形式

2）E：对应的大写字母E的指数形式

3）f：标准浮点形式

4）%：百分形式

>>> "{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)
'3.14e+00,3.14E+00,3.14,314.00%'

例子：文本进度条

由于程序执行速度远超人眼的视觉停留时间，直接进行字符输出几乎是瞬间完成，不利于观察。为了模拟任务处理的时间效果，调用python标准时间库time，使用time.sleep(t)函数将当前程序暂时挂起t秒，t可以是小数。由此可以接近真实的模拟进度条效果输出。使用import保留字调用time库

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("-----执行结束-----")
============================ RESTART: D:/1212121.py ============================
-----执行开始-----
% 0 [->....................]
%10 [**->..................]
%20 [****->................]
%30 [******->..............]
%40 [********->............]
%50 [**********->..........]
%60 [************->........]
%70 [**************->......]
%80 [****************->....]
%90 [******************->..]
%100[********************->]
-----执行结束-----

import time                        #单行动态刷新
for i in range(101):
    print("\r{:3}%".format(i),end="")
    time.sleep(0.05)
============================ RESTART: D:/1212121.py ============================

  0%
  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%
 91%
 92%
 93%
 94%
 95%
 96%
 97%
 98%
 99%
100%

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,'-'))
============================ RESTART: D:/1212121.py ============================
-----------执行开始----------

 0 %[->..................................................]0.00s
 2 %[*->.................................................]90211.28s
 4 %[**->................................................]180422.74s
 6 %[***->...............................................]270634.47s
 8 %[****->..............................................]360846.50s
10 %[*****->.............................................]451058.89s
12 %[******->............................................]541271.74s
14 %[*******->...........................................]631485.09s
16 %[********->..........................................]721698.99s
18 %[*********->.........................................]811913.57s
20 %[**********->........................................]902128.90s
22 %[***********->.......................................]992345.22s
24 %[************->......................................]1082562.57s
26 %[*************->.....................................]1172781.01s
28 %[**************->....................................]1263000.68s
30 %[***************->...................................]1353221.73s
32 %[****************->..................................]1443444.39s
34 %[*****************->.................................]1533668.72s
36 %[******************->................................]1623894.90s
38 %[*******************->...............................]1714123.29s
40 %[********************->..............................]1804353.93s
42 %[*********************->.............................]1894586.71s
44 %[**********************->............................]1984821.96s
46 %[***********************->...........................]2075059.91s
48 %[************************->..........................]2165303.81s
50 %[*************************->.........................]2255551.40s
52 %[**************************->........................]2345803.09s
54 %[***************************->.......................]2436059.37s
56 %[****************************->......................]2526320.21s
58 %[*****************************->.....................]2616585.58s
60 %[******************************->....................]2706855.73s
62 %[*******************************->...................]2797131.46s
64 %[********************************->..................]2887413.11s
66 %[*********************************->.................]2977700.20s
68 %[**********************************->................]3067993.40s
70 %[***********************************->...............]3158293.28s
72 %[************************************->..............]3248599.33s
74 %[*************************************->.............]3338912.21s
76 %[**************************************->............]3429231.99s
78 %[***************************************->...........]3519559.47s
80 %[****************************************->..........]3609895.25s
82 %[*****************************************->.........]3700240.02s
84 %[******************************************->........]3790592.01s
86 %[*******************************************->.......]3880953.09s
88 %[********************************************->......]3971324.55s
90 %[*********************************************->.....]4061709.62s
92 %[**********************************************->....]4152107.48s
94 %[***********************************************->...]4242520.09s
96 %[************************************************->..]4332947.48s
98 %[*************************************************->.]4423389.38s
100%[**************************************************->]4513846.02s
-----------执行结束----------

亲，看完这篇笔记，点个赞吧！