Quiero aprender Python en secreto y luego sorprender a todos (al día siguiente)

El título no pretende ofender, pero creo que este anuncio es divertido
. Toma el mapa mental anterior si te gusta. No puedo aprender mucho de todos modos.

Prefacio

Revisión inicial: quiero aprender Python en secreto y luego aturdir a todos (día uno). El
artículo anterior escribió algunos conocimientos básicos de Python, desde tipos de datos hasta cuatro operaciones aritméticas, ramas y bucles.

Así que hoy veremos las funciones y clases más abstractas. Si no está muy familiarizado con los conceptos básicos, puede solidificar la base. Después de todo, la base no es honesta, es muy peligrosa.

本系列文默认各位有一定的C或C++基础，因为我是学了点C++的皮毛之后入手的Python，这里也要感谢齐锋学长送来的支持。
本系列文默认各位会百度，会用在线编译器，因为我是突击学Python的，之前的编译环境都删了，但是吧，我发现在线编译是真的爽，浪费那时间去搭那环境干啥，学好了Python，会差那点请人搭环境的钱吗？

我要的不多，点个关注就好啦
然后呢，本系列的目录嘛，说实话我个人比较倾向于那两本 Primer Plus，所以就跟着它们的目录结构吧。

本系列也会着重培养各位的自主动手能力，毕竟我不可能把所有知识点都给你讲到，所以自己解决需求的能力就尤为重要，所以我在文中埋得坑请不要把它们看成坑，那是我留给你们的锻炼机会，请各显神通，自行解决。

Bien, pasemos al tema.

---

El cuello de botella del aprendizaje de la programación

Primero hablemos un poco más relajados, y hablaré de esos obstinadamente aburridos.

Independientemente de si tiene una base o no, si ha aprendido programación o matemáticas, más o menos encontrará dificultades. Por ejemplo, el primer problema que encontré en la forma de aprender a programar fue la transferencia de parámetros de función. Vaya, en ese momento, estaba muy animado. Después de todo, era una persona de C ++ que había pasado los 90 puntos y tenía que caminar de lado. Pero en el primer día de capacitación en la empresa, cuando el maestro nos mostró (explicó) un fragmento de código, toda la persona me dejó aturdido, era una estructura como un parámetro de tipo de datos, y un montón de esos parámetros. En la misma función. . .

Luego en otro lugar, para ser precisos, en otro archivo, llamé a esta función, en ese momento me quedé atónito, incluso olvidé grabar la pantalla, esperé la operación real. . .
¿Qué transmitir? ¿A donde se fué? ? ? Desmayado. . .

Está bien, es un largo camino. Puedes golpear el cuello de botella que encontraste en el área de comentarios. Tal vez tu pensamiento y meditación, otros ya tienen una solución.

Deje que una montaña pase una barrera de montaña, poder entender el código es solo el primer paso en lo básico, debe escribirlo usted mismo. Cuando escribo solo, es fácil encontrar varios problemas El segundo obstáculo es la depuración.

Si hablo demasiado, le enseñaré estas habilidades. En este artículo, primero veremos las funciones y las clases, y luego hablaremos sobre proyectos de subarchivo, depuración, diseño y arquitectura de proyectos básicos y otras cosas. Si lo desea, puede hacer un seguimiento.

---

Las funciones no dan tanto miedo

Función inicial

¿Función? Cualquiera que haya estudiado matemáticas en la escuela secundaria conoce funciones.
Esta función no es esa función.

Las funciones están organizadas, son reutilizables y se utilizan para implementar un segmento de código único o relacionado.
Las funciones pueden mejorar la modularidad de la aplicación y la reutilización del código. Ya sabe que Python proporciona muchas funciones integradas, como print (). Pero también puede crear una función usted mismo, que se denomina función definida por el usuario.

Definir una función

Una imagen vale mas que mil palabras:

Ejemplo:

def math(x):
    y = 3*x + 5
    return y

Esta función se usa para lograr: la evaluación de y = 3x + 5, donde x es el parámetro, no te preocupes, aquí hay muchas reglas, escúchame despacio.

En primer lugar, ¿tiene un compilador, como pycharm? No importa, todavía hay muchos compiladores en línea, como "Programming China", elija la programación Python.
Tome el párrafo anterior para compilarlo primero, ejecútelo, y aquellos que no puedan ejecutarlo pueden Baidu.

Después de correr, encontrarás que no hay nada en absoluto. Esto no es una mentira. Sí, esto no es una mentira. No lo llamamos, así que, naturalmente, no hay nada.

Reglas de función

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()，括号后面要紧跟冒号，不然会报错。def就相当于告诉编译器：我这里是一个函数，你注意一下哈

任何传入参数必须放在圆括号中间，关于这个参数的规矩嘛：
1、在调用函数时，对函数进行参数传递必须与函数声明时的参数列表对应。
2、函数声明时可以声明默认参数，在函数调用时如果没有对默认参数进行传值，这默认参数使用预设值，默认参数要放在参数列表最右侧
3、函数外传参的参数数据类型须一一对应（有些可以强转，碧如float转int）
4、参数类型多种多样，并不局限于常见的int、float、str等参数类型，也可以传类对象等

函数内容以冒号起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

对于函数的调用，直接输入函数名，并传入参数（这里不考虑跨文件）

Específicamente, lea más.

Ejemplo 2:

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print(str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

Ejemplo 3:

def menu(appetizer, course):
    print('一份开胃菜：' + appetizer)
    print('一份主食：' + course)
menu('话梅花生','牛肉拉面')
def list(list1,list2):
    print('fast food:'+list1)
    print('slow food:'+list2)
list('宫保鸡丁','水煮鱼')

resultado:

一份开胃菜：话梅花生
一份主食：牛肉拉面
fast food:宫保鸡丁
slow food:水煮鱼

Ejemplo 4:

Método de parámetro predeterminado:

def menu(appetizer, course, dessert = '绿豆沙'):
    print('一份开胃菜：' + appetizer)
    print('一份主食：' + course)
    print('一份甜品：' + dessert)


menu('话梅花生','牛肉拉面')
menu('话梅花生','牛肉拉面','银耳羹')
#银耳羹对应参数dessert

resultado:

一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：绿豆沙
一份开胃菜：话梅花生
一份主食：牛肉拉面
一份甜品：银耳羹

Ejemplo 5:

Parámetro de longitud variable

Su formato es especial, es un asterisco * más el nombre del parámetro, y su valor de retorno también es especial, veamos el siguiente ejemplo.

def menu(*barbeque):
    return barbeque

order = menu('烤鸡翅','烤茄子','烤玉米')
#括号里的这几个值都会传递给参数barbeque

print(order)
print(type(order))

Resultado:
Verá que la función devuelve el resultado: ('alitas de pollo asadas', 'berenjena asada', 'maíz tostado'), podemos usar la función type () para saber que este tipo de datos se llama tupla

Como una lista, una tupla es un objeto iterable, lo que significa que podemos usar un bucle for para recorrerlo, y el código en este momento se puede escribir como:

def menu(*barbeque):
    for i in barbeque:
        print('一份烤串：' + i)

menu('烤香肠', '烤肉丸')        
menu('烤鸡翅', '烤茄子', '烤玉米')
# 不定长参数可以接收任意数量的值

一份烤串：烤香肠
一份烤串：烤肉丸
一份烤串：烤鸡翅
一份烤串：烤茄子
一份烤串：烤玉米

Variables globales y variables locales

Las variables definidas dentro de una función tienen un alcance local y las variables definidas fuera de una función tienen un alcance global.

Solo se puede acceder a las variables locales dentro de la función en la que están declaradas, mientras que a las variables globales se puede acceder dentro del alcance de todo el programa. Cuando se llama a la función, todos los nombres de variables declarados en la función se agregarán al alcance.

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print("函数内是局部变量 : ", total)
   return total
 
#调用sum函数
sum( 10, 20 )
print("函数外是全局变量 : ", total)

Resultado de salida:

函数内是局部变量 :  30
函数外是全局变量 :  0

---

Lo pienso de nuevo.

Oh, anidamiento multifunción.
Al igual que una matrioska, puede haber otra función en una función.

De hecho, esto es fácil de entender. Piense en imprimir. Es solo una función. A menudo usamos imprimir en otras funciones antes.

---

Función pequeño proyecto

Escriba una calculadora pequeña que admita cuatro operaciones aritméticas sin paréntesis. Es muy difícil escribir paréntesis.

---

Las cosas se recopilan por "clase"

¿Qué es una clase? ¿Qué es un objeto?
Los lenguajes de programación de alto nivel de hoy tienen un umbral, es decir, tienes que ser programación orientada a objetos, y programación orientada a objetos, tienes que tener el soporte de clases.
Entonces, ¿qué es la programación orientada a objetos? Se trata de describir las características y funciones de un tipo de asuntos, como los seres humanos, entonces el objeto es humano, y las características y funciones humanas deben realizarse en esta categoría.
característica:

没什么毛
两个肩膀扛一个脑袋
等等

habilidad:

直立行走
使用火
能写字
等等

Bien, si junta estas características y habilidades, eres humano.

Permítanme hablar de dos conceptos, objetos e instancias más: ¿Qué es un objeto? Esta es la clase que desea construir y cuál es el modelo construido. Tome el ejemplo humano anterior, se puede entender como el molde cuando Nuwa pellizca a las personas. , Nu Wa estaba exprimiendo la tierra frente al objeto de 'humano'.
Cual es la instancia? Está construido por esta clase, y las cosas con todas las características y funciones de la clase pueden entenderse como las personas reales atrapadas por Nuwa.

Creación de clases

Mira imágenes y habla, una imagen vale más que mil palabras.

Instanciación de clase

Llamada de clase

Aquí, solucionemos el servicio todo en uno:
cree un ser humano, tiene dos piernas, puede correr y saltar, ¿cómo escribir? Escribe así:

class People:
	leg = 2
	def run(self):
		print('他是一个人，他能跑')
	def jump(self):
		print('He is a man,he can jump')

lihua = People()
lihua.run()

De acuerdo, todavía hay algo que no he dejado claro aquí, qué dice exactamente Biru sobre el "yo".

1. Yo, como su nombre lo indica. Bueno, veamos cómo usarlo directamente.

class People:
	leg = 2
	def run(self):
		print('他是一个人，他有%d条腿，所以他能跑',self.leg)
	def jump(self):
		print('He is a man,he can jump because of his %d legs',legs)

lihua = People()
lihua.run()

Si desea llamar al atributo de clase fuera de la clase, primero tenemos que crear una instancia y luego llamarla en el formato de nombre de instancia.

Entonces, si queremos llamar al atributo de clase dentro de la clase, y antes de que se cree la instancia, necesitamos una variable para reemplazar la instancia para recibir datos, esta variable es el parámetro self.

El rol del yo equivale a ocupar primero un lugar para la instancia, y cuando se crea la instancia, "se retirará y renunciará al virtuoso".

De la misma manera, si queremos llamar a otros métodos dentro de un método de clase, también necesitamos usar self para representar la instancia.

2. Método de inicialización
   En C ++, hay una inicialización de clases, y debe haber algunas en las clases de Python. Echemos un vistazo a las castañas:

El formato para definir el método de inicialización es def init (self), que se compone de init más los guiones bajos izquierdo y derecho (la abreviatura de initialize "initialization").
La función del método de inicialización es: cuando se crea cada objeto de instancia, el código del método se ejecutará automáticamente sin llamarlo.

class People:
	def __init__(self):
		print('恭喜你，你造了个人')
lihua1 = People()

Este es un tipo, otro tipo

class People:
	def __init__(self,num):
		self.num = num
	def born()
		print('恭喜你，你获得了'+self.num+'个好朋友')
lihua2 = People()
lihua2.born()

---

Cuenca, la dificultad es aún mayor

Herencia de clases

Lo que es la herencia, la herencia en C ++ sigue siendo muy divertido, al igual que tu padre es una clase, heredas algunas de las características y habilidades de tu padre, también puedes tener tus propias habilidades, esto es herencia.

Entonces implementemos lo que dijimos anteriormente:

class Father:
	skin = 'yellow'
	def clever():
		print('他是个聪明人')

class Son(Father):
	def strugle():
		print('他很努力')

lihua = Son()
lihua.clever()
print(lihua.skin)
lihua.strucle()

Herencia múltiple

Una clase puede heredar varias clases al mismo tiempo. La sintaxis es clase A (B, C, D):

Aquí puedes realizar una persona por ti mismo y heredar las ventajas de ambos padres, por ejemplo, el padre es inteligente, la madre es guapa, él es inteligente, guapa y motivada.

Pequeño consejo: el principio de proximidad: cuanto más cerca del padre de la subclase (es decir, cuanto más a la izquierda), cuanto más cerca esté, más prioridad se considerará. Cuando las subclases llaman a propiedades y métodos, primero buscarán la clase principal a la izquierda y luego buscarán la derecha cuando no puedan encontrarla.

Aprende más:

---

Anulación de súper función

La reescritura del código es una modificación del código de la clase principal en la subclase.

Simplemente dale una castaña, de hecho, este sigue siendo un punto muy importante:

class Father:
	skin = 'yellow'
	def clever():
		print('他的智商100')

class Son(Father):
	def clever():
		print('他的智商110')
	def strugle():
		print('他很努力')
lihua = Son()
lihua.clever()

---

Pequeño proyecto práctico

Aquí, hagamos una breve historia de la herencia familiar para consolidar lo que hemos aprendido hoy:

Pertenecía a una familia privilegiada. Su abuelo comenzó el negocio de las gasas desde cero. En la generación de su abuelo, el negocio se expandió aún más, agregando nuevas farmacias y casas de dinero. En la generación de su padre, los piratas japoneses invadieron, la situación era turbulenta y la gente se vio desplazada. Entonces su padre decidió resueltamente abrir el cobertizo a papilla y esparcir la medicina. Después de algunos años de perseverancia, finalmente disipó su riqueza, pero no se arrepintieron. ¿Dónde está roto el país?

En su generación, en respuesta al eslogan del gran rejuvenecimiento de la nación china, practicó duro sus habilidades y esperaba reconstruir la gloria de la familia algún día ...

Oye, sigue tú mismo, implementemos cuatro categorías: su abuelo, su abuelo, su padre y él. Encadena esta historia.

¡Venga! !

En la actualización continua, puede hacer un seguimiento si lo desea.