[Programación de Python (3)] Tipos de datos básicos

1 Tipo de número y operación

1.1 Tipo entero

Los tipos de enteros son consistentes con el concepto de enteros en matemáticas, pueden ser positivos o negativos, y no hay límite para el rango de valores.

pow (x, y) Función: calculado X ^Y , los operadores quieren contar la cantidad de

>>> pow(2,100)
1267650600228229401496703205376

Hay 4 representaciones hexadecimales

• Decimal: 1010, 99, -217
• Binario, comenzando con 0b o 0B: 0b010, -0B101
• Octal, comenzando con 0o o 0O: 0o123, -0O456
• Hexadecimal, comenzando con 0x o 0X: 0x9a, -0X89

1.2 Tipo de punto flotante

Los tipos de punto flotante son consistentes con el concepto de números reales en matemáticas

• Existen límites para el rango de valores de coma flotante y precisión decimal, pero los cálculos de rutina pueden ignorarse
• Magnitud que varía de aproximadamente -10 ³⁰⁷ a 10 ³⁰⁸ , la precisión del orden de 10 ^-16

Hay una mantisa incierta en la operación entre números de coma flotante, no un error

>>> 0.1 + 0.3
0.4
>>> 0.1 + 0.2
0.30000000000000004

0.1 representa una parte fraccionaria de 53 binario, de aproximadamente 10 ^-16
representación binaria: 0,00011001100110011001100110011001100110011001100110011010
representación decimal como: 0,1000000000000000055511151231257827021181583404541015625

La representación binaria de los decimales puede ser infinitamente cercana, pero no son exactamente iguales. El resultado de 0.1 + 0.2 es infinitamente cercano a 0.3, pero puede haber una mantisa. Las mantisas inciertas generalmente ocurren en ^10-16 , por lo que el juicio de igualdad de número de punto flotante no se puede usar directamente ==

>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1+0.2, 1) == 0.3
True

round (x, d): round x, d es el número de truncamiento decimal

Los números de coma flotante se pueden expresar en notación científica, usando las letras e o E como símbolo de poder, con 10 como base, y el formato es el siguiente:

<a> e <b> 表示 a * 10 ^b

Por ejemplo: el valor 4.3e-3 es 0.0043, el valor 9.6E5 es 960000.0

Sobre los números de coma flotante de Python, necesita saber estos:

1. El rango de valores y la precisión son básicamente ilimitados
2. La operación tiene ronda de mantisa incierta ()
3. Notación científica

1.3 Tipo complejo

De acuerdo con el concepto de números complejos en matemáticas
z = 1.23e-4 + 5.6e + 89 j
z.real obtiene la parte real, z.imag obtiene la parte imaginaria

1.4 Operador numérico

Operadores y uso	Descripción
x + y	Además, la suma de x e y
x – y	Menos, la diferencia entre x e y
x * y	Multiplicación, producto de x e y
x / y	Además, el cociente de x e y 10/3 resulta en 3.3333333333333335
x // y	División entera, el cociente entero de x e y es 10 // 3 y el resultado es 3

Operador mejorado y uso	Descripción
x op = y	Es decir x = x op y, donde op es un operador binario
	x += y， x -= y， x *= y， x /= y， x //= y， x %= y， x **= y

operación de tipo Inter puede ser mezclado para producir un resultado "más amplia" Tipo

• Existe una relación de "ampliación" gradual entre los tres tipos:
  entero-> coma flotante-> complejo
• Por ejemplo: 123 + 4.0 = 127.0 (entero + punto flotante = punto flotante)

1.5 Funciones de operación numérica

Función y uso	Descripción
abs (x)	Valor absoluto, el valor absoluto de x abs (-10.01) da como resultado 10.01
divmod(x,y)	Excedente de cociente, (x // y, x% y), cociente de salida simultáneo y resto divmod (10, 3) El resultado es (3, 1)
pow (x, y [, z])	Exceso de potencia, (x ** y)% z, [] significa que se puede omitir el parámetro z pow (3, pow (3, 99), 10000) El resultado es 4587
redondo (x [, d])	Redondeo, d es retener el número de lugares decimales, el valor predeterminado es 0 redondeo (-10.123, 2) El resultado es -10.12
max (x 1 , x 2 ,…, x n )	Valor máximo, devuelve el valor máximo en x 1 , x 2 , ..., x n , n no está limitado a max (1, 9, 5, 4, 3) El resultado es 9
min (x 1 , x 2 ,…, x n )	El valor mínimo, devuelve el valor mínimo de x 1 , x 2 , ..., x n , n no se limita a min (1, 9, 5, 4, 3) El resultado es 1
int (x)	Convierta x en un número entero y deseche la parte fraccional int (123.45) resulta en 123; int ("123") resulta en 123
flotador (x)	Convierta x en un número de coma flotante, aumente la parte fraccional flotante (12), el resultado es 12.0; flotante ("1.23") el resultado es 1.23
complejo (x)	Cambie x a un número complejo y agregue la parte imaginaria de complex (4). El resultado es 4 + 0j

2 Ejemplo: El poder de lo ascendente

Pregunta 1: El poder de 1 ‰

• 365 días al año, todos los días 1 ‰ progreso, ¿cuánto progreso acumulativo?
• 365 días al año, 1 ‰ por día, ¿cuánto queda?

dayfactor = 0.001
dayup = pow(1 + dayfactor, 365)
daydown = pow(1 - dayfactor, 365)
print("向上：{:.2f},向下：{:.2f}".format(dayup, daydown))

Resultado de la operación:

向上：1.44,向下：0.69

Pregunta 2: el poder de los días hábiles

• 365 días al año, 5 días hábiles a la semana, 1% de mejora todos los días
• 365 días al año, 2 días de descanso a la semana, 1% de la disminución diaria, ¿qué tal el poder de este día de trabajo?

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

Resultado de la operación:

工作日的力量：4.63

Pregunta 3: esfuerzo del día laboral

• ¿Qué nivel de esfuerzo debe realizarse en el modelo de jornada laboral para que sea igual al 1% por día?
• Jun A: 365 días al año, 1% de progreso todos los días, sin parar
• Jun B: 365 días al año, trabaja 5 días a la semana y toma 2 días de descanso. El día de descanso cae en un 1%. ¿Cuánto esfuerzo necesitas?

Aquí adoptamos un método estúpido, un poco de prueba, comenzando desde 0.01, aumentando en 0.001 cada vez, para ver cuándo y 1% de progreso todos los días, el mismo nivel de progreso continuo.

def dayUP(df):
    dayup = 1.0
    for i in range(365):
        if i%7 in [0, 6]:
            dayup *= (1 - 0.01)
        else:
            dayup *= (1 + df)
    return dayup;
dayfactor = 0.01
while dayUP(dayfactor) < 37.78:
    dayfactor += 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

Resultado de la operación

工作日的努力参数是：0.019

3 tipos de cadenas y operaciones

3.1 Representación del tipo de cadena

Hay 4 tipos de representación en 2 tipos de cadenas

• La cadena está representada por un par de comillas simples o un par de comillas dobles,
• Representado por un par de tres comillas simples o tres comillas dobles, que pueden representar una cadena de varias líneas

"abc" 
或者
'abc'
或者
''' Python
语言 '''

Nota: Tres comillas simples o tres comillas dobles también son comentarios. Un comentario en Python es esencialmente una cadena

• Índice: devuelve un solo carácter en la cadena <cadena> [M]
  "abc" [0] o TempStr [-1]
• División: devuelve una subcadena de caracteres en la cadena <cadena> [M: N]
  "abc" [1: 3] o TempStr [0: -1]

Uso avanzado de segmentación de cadenas: utilice [M: N: K] para segmentar cadenas de acuerdo con el tamaño del paso

• <String> [M: N], M faltante significa al principio , N faltante significa al final
  "〇 一二 三四五 六 七八 九十" [: 3] El resultado es "〇 一二"
• <String> [M: N: K], corte la cadena
  "〇 一二 三四五 六 七八 九十" de acuerdo con el paso K [1: 8: 2] El resultado es "一 三 五七"
  "〇 Uno dos tres cuatro cinco seis siete ocho noventa "[:: - 1] el resultado es " diecinueve ocho siete seis cinco cuatro tres dos uno 〇 "

Caracteres especiales: personaje de escape \

• La expresión de la intención específica carácter de escape
  "Hay una doble comilla (\") " como resultado que aquí hay una comilla doble (")
• Los caracteres de escape forman algunas combinaciones, expresando algunos significados no imprimibles
  "\ b" atrás
  "\ n" avance de línea (el cursor se mueve al principio de la línea)
  "\ r" retorno de carro (el cursor se mueve al principio de la línea)

3.2 Operadores de cadenas

Operadores y uso	Descripción
x + y	Concatenar dos cadenas x e y
n * x o x * n	Copiar cadena n veces x
x en s	Si x es una subcadena de s, devuelve True, de lo contrario devuelve False

example：获取星期字符串

weekStr = "星期一星期二星期三星期四星期五星期六星期日"
weekid = eval(input("请输入星期数字(1-7)："))
pos = (weekid-1) * 3
print(weekStr[pos : pos + 3])

或者

weekStr = "一二三四五六日"
weekid = eval(input("请输入星期数字(1-7)："))
print("星期" + weekStr[weekid-1])

3.3 字符串处理函数

操作符及使用	描述
len(x)	长度，返回字符串 x 的长度 len(“一二三456”) 结果为 6
str(x)	任意类型 x 所对应的字符串形式 str(1.23) 结果为 “1.23”，str([1,2]) 结果为 “[1,2]”
hex(x) 或 oct(x)	整数 x 的十六进制或八进制小写形式字符串 hex(425) 结果为 “0x1a9” oct(425) 结果为 “0o651”
chr(u)	x 为 Unicode 编码，返回其对应的字符
ord(x)	x 为字符，返回其对应的 Unicode 编码

3.4 字符串处理函数

字符串处理函数	描述
str.lower() 或 str.upper()	返回字符串的副本，全部字符小写/大写 "AbCdEfGh".lower() 结果为 “abcdefgh”
str.split(sep=None)	返回一个列表，由 str 根据 sep 被分隔的部分组成 "A,B,C".split(",") 结果为 [‘A’,‘B’,‘C’]
str.count(sub)	返回子串 sub 在 str 中出现的次数 "an apple a day".count(“a”) 结果为 4
str.replace(old, new)	返回字符串 str 副本，所有 old 子串被替换为 new "python".replace(“n”,“n123.io”) 结果为 “python123.io”
str.center(width[,fillchar])	字符串 str 根据宽度 width 居中，fillchar 可选 "python".center(20,"=") 结果为 ‘=======\python=======’
str.strip(chars)	从 str 中去掉在其左侧和右侧 chars 中列出的字符 "= python= “.strip(” =np") 结果为 “ytho”
str.join(iter)	在 iter 变量除最后元素外每个元素后增加一个 str ",".join(“12345”) 结果为"1,2,3,4,5" #主要用于字符串分隔等

3.5 字符串类型的格式化

格式化是对字符串进行格式表达的方式，字符串格式化使用 .format()方法，用法如下：

• <模板字符串>.format(<逗号分隔的参数>)

槽内部对格式化的配置方式
{ <参数序号> ： <格式控制标记>}

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

4 time 库的使用

time 库是 Python 中处理时间的标准库，包括三类函数

• 时间获取：time()，ctime()，gmtime()
• 时间格式化：strftime()，strptime()
• 程序计时：sleep()，perf_counter()

import time
time.()

4.1 时间获取

4.2 时间格式化

将时间以合理的方式展示出来，类似字符串格式化，需要有展示模板，展示模板由特定的格式化控制符组成

函数	描述
strftime(tpl, ts)	tpl是格式化模板字符串，用来定义输出效果 ts是计算机内部时间类型变量 >>>t = time.gmtime() >>>time.strftime("%Y-%m-%d %H:%M:%S",t) ‘2018-01-26 12:55:20’

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999，例如：1900
%m	月份	01~12，例如：10
%B	月份名称	January~December，例如：April
%b	月份名称缩写	Jan~Dec，例如：Apr
%d	日期	01~31，例如：25
%A	星期	Monday~Sunday，例如：Wednesday
%a	星期缩写	Mon~Sun，例如：Wed
%H	小时（24h制）	00~23，例如：12
%I	小时（12h制）	01~12，例如：7
%p	上/下午	AM, PM，例如：PM
%M	分钟	00~59，例如：26
%S	秒	00~59，例如：26

函数	描述
strptime(str, tpl)	str是字符串形式的时间值 tpl是格式化模板字符串，用来定义输入效果 >>>timeStr = ‘2018-01-26 12:55:20’ >>>time.strptime(timeStr, “%Y-%m-%d %H:%M:%S”) time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0)

4.3 程序计时

函数	描述
perf_counter()	返回一个CPU级别的精确时间计数值，单位为秒 由于这个计数值起点不确定，连续调用差值才有意义 >>>start = time.perf_counter() 318.66599499718114 >>>end - start 22.724523540384666
sleep(s)	s拟休眠的时间，单位是秒，可以是浮点数 >>>def wait(): time.sleep(3.3) >>>wait() #程序将等待3.3秒后再退出

5 实例: 文本进度条

需求分析：采用字符串方式打印可以动态变化的文本进度条，进度条需要能在一行中逐渐变化

Para cambiar gradualmente en una línea, se requiere una actualización dinámica. No se permiten saltos de línea. Los caracteres impresos después de sobrescribir los caracteres anteriores. Después de imprimir, el cursor vuelve a la posición anterior. Aquí, se usa \ r.

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() 语句打印完一行自动换行，end=''可以不换行
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end = '')
    time.sleep(0.1)
print("\n" + "执行结束".center(scale//2, '-'))

Resultado de la operación:

6 Resumen

1. Tipo de número y operación

• Rango infinito de tipos enteros y 4 representaciones hexadecimales
• Rango aproximadamente infinito de tipos de coma flotante, little endian y notación científica
• +, -, *, /, //,%, **, operador de asignación mejorado binario
• abs () 、 divmod () 、 pow () 、 round () 、 max () 、 min ()
• int () 、 float () 、 complex ()

2. Tipos de cadenas y operaciones

• Número de secuencia ascendente hacia adelante, número de secuencia descendente inversa, <cadena> [M: N: K]
• + 、 * 、 En 、 len () 、 str () 、 hex () 、 oct () 、 ord () 、 chr ()
• .lower () 、. upper () 、. split () 、. count () 、. replace ()
• Formato .center (), .strip (), .join (), .format ()