[Notas de estudio de Python] 07 operaciones básicas y tipos de datos integrados de Python

Esta serie de notas para aprender Python por ti mismo, si hay errores, corrígeme

Introducción a los tipos de datos integrados más básicos

Cada objeto tiene un tipo, el tipo de datos integrado más básico en Python:

1. Entero

   Entero 234

2. Punto flotante

   Decimal 3.14

3. Booleano

   Indica verdadero y falso solo contiene verdadero falso

4. Tipo de cadena

   Secuencia de cadenas

digital

Python admite números enteros y de coma flotante, podemos hacer las siguientes operaciones con números

Operador	Descripción	Ejemplo	estructura
+	adición	3 + 2	5
-	Sustracción	30-5	25
*	multiplicación	3 * 6	18
/	División de punto flotante	8/2	4.0
//	División entera	7 // 2	3
%	Módulo (tome el resto)	7% 4	3
**	poder	2 ** 3	8

---

• Dividir por 0 generará una excepción ZeroDivisionError

• Use la función divmod () para obtener el cociente y el resto al mismo tiempo

---

Entero

En python, además del decimal, hay otras tres bases

• 0b o 0B binario 0 1
• 0o o 0O ocho proceden 0 1 2 3 4 5 6 7
• 0x o 0X hexadecimal 0 1 2 3 4 5 6 7 8 9 abcdef

Estos tres procesos pueden ser muy convenientes para operaciones de "operación de bits"

Utilice int () para lograr la conversión de tipo

1. Los números de coma flotante redondean directamente la parte decimal
2. El valor booleano True se convierte en 1, False se convierte en 0
3. Si la cadena se ajusta al formato de entero (el formato de punto flotante no es aceptable), se convertirá directamente al entero correspondiente; de ​​lo contrario, se informará un error

Transformación automática

En la operación mixta de número entero y de punto flotante, la estructura de la expresión se convierte automáticamente en número de punto flotante

Que tan grande puede ser un entero

En python2, int es de 32 bits y puede almacenar enteros de -2147483648 a 2147483647. El tipo largo es de 64 bits y puede almacenar valores entre -2 ^{62 y 2} 63-1.

En python3, int puede almacenar enteros de cualquier tamaño, long se cancela, incluso podemos almacenar el siguiente valor: google = 10 ** 100

Googol es el nombre original de Google, que también es el significado original de Google.

El cálculo de números muy grandes se puede utilizar en python3 sin provocar un "desbordamiento de enteros", que también es una característica de pythonn especialmente adecuada para la informática científica.

Punto flotante

Número de coma flotante, llamado flotante

Los números de coma flotante usan $un\ast {segundo}^{}$La notación científica en forma de${}^e$ , por ejemplo, 3.14 se representa como$314E-2$ o$314e-2$ Estos números también se almacenan en la memoria con notación científica.

Conversión de tipos y redondeo

1. Similar a int () también podemos usar float () para convertirlo en un número de punto flotante
2. Cuando se mezclan el número entero y el número de punto flotante, el resultado de la expresión se convierte automáticamente en un número de punto flotante
3. round (valor) puede devolver el valor redondeado (no cambiará el valor original, pero generará un nuevo valor)

Operador de asignación mejorado

El operador + - * / // ** y el operador de asignación% se pueden combinar para formar un operador de asignación mejorado a = a + 1 es equivalente a a + = 1

Representación del tiempo

El tiempo en la computadora se expresa en milisegundos desde las 00:00:00 del 1 de enero de 1970. También llamamos a este momento en 1970 como el punto de tiempo Unix

En Python, la hora actual se puede obtener a través de time.time (), y el valor devuelto está en segundos.

Valor booleano

No hay un valor booleano en Python2, solo use el número para representar Falso y el número 1 para representar Verdadero

En Python3, True y False se definen como palabras clave, pero su esencia sigue siendo 1 y 0, e incluso se pueden agregar a números

Operador de comparación

Todos los operadores de comparación devuelven 1 para verdadero y 0 para falso, que son equivalentes a las variables especiales True y False respectivamente

==! => <> = <=

Operadores logicos

o y no

Mismo operador

Compare la unidad de almacenamiento de dos objetos, la comparación real es la dirección del objeto

Operador	descripción
es	es determinar si dos identificadores se refieren al mismo objeto
no es	no es juzgar si dos identificadores se refieren a objetos diferentes

La diferencia entre is y ==:

Se utiliza para determinar si los dos objetos de referencia variables son iguales, es decir, para comparar la dirección del objeto.

== se usa para determinar si el valor del objeto de referencia de la variable de referencia es igual, y el __eq__()método del objeto se llama por defecto

Problema constante de caché

Python solo almacena en caché los objetos enteros más pequeños ([-5,256]). Tenga en cuenta que esto solo se ejecuta en la línea de comando y es diferente cuando se ejecutan archivos de guardado o pycharm. Esto se debe a que el intérprete está parcialmente optimizado ([-5, cualquier entero positivo])

para resumir:

1. Esto compara si los valores de identificación de dos objetos son iguales y si apuntan a la misma dirección de memoria
2. == compara si el contenido de los dos objetos es igual y si los valores son iguales
3. Los objetos enteros pequeños [-5,256] se colocan en la caché para su reutilización en el alcance del intérprete global
4. El operador is es más eficiente que ==. Cuando una variable se compara con None, se debe usar is

Cuerda

Características básicas de las cuerdas

Cuando muchas personas aprenden programación, siempre se preocupan porque no son buenas en matemáticas, y subconscientemente piensan que las matemáticas son buenas para programar. De hecho, la mayoría de los programadores se ocupan de "cadenas" en lugar de "números". Porque programar es para resolver Problemas realistas, por lo que la importancia del pensamiento lógico a menudo excede la capacidad matemática.

La esencia de la cuerda es:Secuencia de caracteres. Las cadenas de Python son inmutables y no podemos realizar ningún cambio en las cadenas originales. Sin embargo, puede copiar parte de la cadena en la cadena recién creada para lograr el efecto de "apariencia modificada".

Python no admite tipos de caracteres únicos y los caracteres únicos también se utilizan como una cadena.

Codificación de cadenas

Python3 es compatible directamente con Unicode y puede representar caracteres en cualquier lenguaje escrito del mundo. Los caracteres Python3 tienen codificación Unicode de 16 bits de forma predeterminada y el código ASCII es un subconjunto de la codificación Unicode.

• Utilice la función incorporada ord () para convertir caracteres en los códigos Unicide correspondientes;
• Utilice la función incorporada chr () para convertir números decimales en los caracteres correspondientes

print(ord('A'))#65
print(ord('桑'))#26705
print(chr(66))#B
print(chr(20001))#両

Las comillas crean una cadena

Podemos crear una cadena mediante comillas simples o dobles, por ejemplo: a = 'abc' b = "slp"

La ventaja de utilizar dos tipos de comillas es que podemos crear cadenas que contengan comillas sin utilizar caracteres de escape.

Tres comillas simples consecutivas o tres comillas dobles pueden ayudarnos a crear cadenas de varias líneas.

Función cadena vacía y len ()

Python permite la existencia de cadenas vacías, no contiene ningún carácter y tiene una longitud de 0.

len () se usa para calcular cuántos caracteres contiene la cadena.

Personaje de escape

Podemos utilizar para "\+特殊字符"lograr algunos efectos que son difíciles de expresar en caracteres, como: salto de línea. Los caracteres de escape comunes son:

Personaje de escape	descripción
\(在行尾时)	Continuación de línea
\\	Barra invertida
\'	apóstrofe
\"	Doble comillas
\segundo	retroceso
\norte	Envolver
\ t	Pestaña horizontal
\ r	Retorno de carro

Empalme de cuerdas

1. Puede usar + para concatenar múltiples cadenas
   • Si ambos lados de + son cadenas, concatenar
   • Si ambos lados de + son números, suma
   • Si los dos lados de + son de tipos diferentes, se lanza una excepción
2. Puede poner varias cadenas literales directamente juntas para lograr el empalme

Copia de cadena

Use * para lograr la copia de cadena

a = 'Slp'*3
a #SlpSlpSlp

Imprimir sin salto de línea

Cuando llamamos a imprimir antes, se imprimía automáticamente un carácter de nueva línea. A veces, no queremos ajustar o agregar nuevas líneas automáticamente. Podemos agregar cualquier contenido al final especificando end = "any string" por nosotros mismos.

Leer la cadena del control

Podemos usar input () para leer la entrada del teclado desde la consola.

str () implementa la cadena de transformación digital

str () puede ayudarnos a convertir otros tipos de datos en cadenas

Cuando llamamos a la función print (), el intérprete llama automáticamente a str () para convertir el objeto de cadena en una cadena.

Utilice [] para extraer caracteres

La esencia de una cadena es una secuencia de caracteres. Podemos agregar [] después de la cadena y especificarlo en [], que puede extraer un solo carácter en esa posición.

• Búsqueda hacia adelante: el primer carácter a la izquierda, el desplazamiento es 0, el segundo desplazamiento es 1, y así sucesivamente, hasta len (str) -1
• Búsqueda inversa: el primer carácter en el extremo derecho, el desplazamiento es -1, el segundo desplazamiento de la derivada es -2, y así sucesivamente, hasta -len (str)

replace () implementa el reemplazo de cadenas

La cadena es inmutable, podemos obtener el carácter en la posición especificada de la cadena a través de [], pero no podemos cambiar la cadena, si intentamos cambiar un carácter, habrá un error.TypeError :'str' object does not support item assignment

La cadena no se puede cambiar, pero a veces necesitamos reemplazarla. En este momento, solo podemos lograrlo creando una nueva cadena.

a = '123'
a = a.replace('1','4')

Durante todo el proceso, se crea un nuevo objeto de cadena y se apunta a a en lugar de modificar la cadena anterior.

Operación de corte de cadena

La operación de corte nos permite extraer rápidamente subcadenas, el formato estándar es: [inicio del desplazamiento inicial: final del desplazamiento final: tamaño del paso]

La operación típica (cuando las tres cantidades son positivas) es la siguiente:

Operación e instrucciones	Ejemplo	resultado
[:] Extrae toda la cadena	a B C D e F[:]	a B C D e F
[stsrt:] Desde el índice inicial hasta el final	abcdef [2:]	cdef
[: end] Desde el principio hasta el final-1	abcdef [: 2]	desde
[inicio: final] De principio a fin-1	abcdef [2: 4]	discos compactos
[start:end:step]De principio a fin-1, la longitud del paso es paso	abcdef [1: 5: 2]	bd

Otras operaciones (tres números son negativos):

Ejemplo	Descripción	resultado
“Abcdefghijk” [- 3:]	Cuenta regresiva 3	ijk
"Abcdefghijkstuvwxyz" [- 8: -3]	El 8 de abajo hacia el 3 de abajo (el encabezado no incluye la cola)	Stuvw
"Abcdefghijkstuvwxyz" [:: - 1]	El tamaño del paso es negativo y la extracción se invierte de derecha a izquierda	zyxwvutsrqponmlkjihgfedcba

Durante la operación de corte, el desplazamiento inicial y final no están en el rango de [0, longitud de cadena-1] y no se informará ningún error. El desplazamiento inicial menor que 0 se tratará como 0, el desplazamiento final mayor que la longitud -1, se tratará como -1

split () separación y join () fusionar

split () puede dividir una cadena en varias subcadenas (almacenadas en una lista) según el separador especificado. Si no se especifica un delimitador, los caracteres en blanco (nueva línea / espacio / tabulación) se utilizan de forma predeterminada

El papel de join () es el opuesto al de split (), que se utiliza para unir una serie de subcadenas.

print(a.split())
b=['s','l','p']
print("".join(b))

Puntos clave de empalmar cuerdas:

El uso del carácter de empalme de cadenas + producirá nuevos objetos de cadena, por lo que no se recomienda utilizar + para empalmar cadenas. Se recomienda utilizar la función de unión, porque la función de unión calcula la longitud de todas las cadenas antes de concatenar las cadenas y luego las copia una por una, creando un nuevo objeto solo una vez.

Mecanismo residente de cadena y juicio de identidad de cadena

Residencia de la cadena: solo guarde una copia de la misma cadena inmutable, se almacenan diferentes valores en el grupo de residencia de la cadena, Python admite el mecanismo de residencia de la cadena, para las cadenas que se ajustan a las reglas de identificación (número de letras de subrayado) habilitará la persistencia de la cadena

Resumen de métodos de cadena comunes

Métodos de búsqueda habituales

Métodos y ejemplos de uso	Descripción	resultado
len (a)	Longitud de la cuerda
a.startwith ('ss')	Comience con la cadena especificada
a.endswith ('tt')	Termina con la cadena especificada
a.find ('s')	La primera aparición de la cadena especificada
a.rfind ('t')	La posición de la última aparición de la cadena especificada
a.count ('a')	Cuántas veces aparece la cadena especificada
a.isalnum()	所有字符全是字母或数字

去除首尾信息

我们可以使用strip()去除字符串收尾指定信息，通过lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息

大小写转换

示例	说明	结果
a.capitalize()	产生新的字符串，首字母大写
a.title()	产生新的字符串，每个单词都首字母大写
a.upper()	产生新的字符串，所有字符全部转成大写
a.lower()	产生新的字符串，所有字符全转成小写
a.swapcase()	产生新的，所有字母大小写转换

格式排版

center() ljust() rjust()这3个函数用于对字符串实现排版

字符串格式化

• format()基本用法：基本语法是通过{}和：来代替以前的%，format函数可以接受不限个数参数，位置可以不按顺序。

  a="名字是：{0}，年龄是：{1}"
  print(a.format('slp','18'))
  b="名字是：{0}，年龄是{1}，{0}是个努力的小姑娘"
  print(b.format('slp',18))
  c="名字是{name},年龄是{age}"
  print(c.format(age=18,name='slp'))
  

  我们可以通过{索引}/{参数名}，直接映射参数值，实现对字符串的格式化。

• 填充与对齐

  填充常跟对齐一起使用

  ^ < > 分别是居中，左对齐 右对齐后面带宽度

  ：后面带填充的字符，只能是一个字符不指定则默认用空格填充。

• 数字格式化

  浮点数通过f,整数通过d进行需要的格式化

  格式	描述	输出
  {:.2f}	保留小数点后两位
  {:+.2f}	带符号保留小数点后两位
  {:.0f}	不带小数
  {:0>2d}	数字补0，填充左侧，宽度为2
  {:x<4d}	数字补x,填充右边，宽度为4
  {:,}	以逗号分隔的数字格式
  {:.2%}	百分比格式
  {:.2e}	指数记法
  {:10d}	右对齐，（默认，宽度为10）
  {:<10d}	左对齐，（宽度为10）
  {:^10d}	中间对齐（宽度为10）

可变字符串

在python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象，但是，经常我们确实需要原地修改字符串，可以使用ioStringIO对象或array模块

import io
s = 'hello slp'
sio = io.StringIO(s)
print(sio)
print(sio.getvalue())
print(sio.seek(7))
print(sio.write('g'))
print(sio.getvalue())

其他方法

1. isalnum():是否为字母或数字
2. isalphal():检测字符串是否只由字母组成（含汉字）
3. isdigit():检测字符串是否只由数字组成
4. isspace():检测是否为空白符
5. isupper():是否为大写字母
6. islower():是否为小写字母

基本运算符

运算符	说明
or and not	布尔或 布尔与 布尔非
is 、 is not	同一性判断，判断是否为同一个对象
< <= > >= != ==	比较值是否相当，可以连用
| ^ &	按位或 按位异或 按位与
<< >>	移位
~	按位翻转
+ - * / // %	加 减 乘 除 整数除 取余
**	幂运算

运算符优先级

由高到低

运算符	描述
**	指数
~ + -	按位翻转 一元加号和减号
* / // %	乘 除 取模 取整除
+ -	加法 减法
>> <<	右移 左移运算符
&	位 AND
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= *= **=	赋值运算符
is 、is not	身份运算符
in 、not in	成员运算符
not and or	逻辑运算符

微信搜一搜【梓莘】或扫描下方二维码交个朋友共同进步。文章持续更新中。目前在整理python百战学习笔记，期待后续更多的更新哦。