斗罗大陆1,姘头,加勒比海盗6-第十届ICC备案报名处,备案新闻早知道

admin 3周前 ( 11-20 13:38 ) 0条评论
摘要: 作者 | TK编译 | 后厂村码农Learning Python: From Zero to Hero首先,什么是 Python?...

作者 | TK

编译 | 后厂村码农

Le老铁腭arning Python: From Zero to Hero

首要,什么是 Python?依据 Python 创立者 Guido van Rossum 所言,Python 是一种高档编程言语,其规划的核心理念是代码的易读性,以及答应编程者经过若干行代码轻松表达主意构思。实际上,我挑选学习 Python 的首要原因是其编程的美丽性,用它编码和表达主意非常天然。

Python 是一个高层次的结合了解释性、编译性、互动性和面向方针的脚本言语。Python 的规划具有很强的可读性,比较其他言语常常运用英文关键字,其他言语的一些标点符号,它具有比其他言语更有特征语法结构。

另一个原因是 Python 的编写运用办法有多种,数据科学、网页开发、机器学习皆可运用 Python。Quora、Pinterest 和 Spotify 都运用 Python 作为其后端开发言语。

根底篇

变量

简略来讲,咱们能够把变量看作是存储一个值的词。

在 Python 中界说一个变量并为其赋值非常简略。幻想一下你在变量「one」中存储 1,便是:

one = 1

这是多么简略,咱们只要把 1 赋值给变量「one」。

two = 2
some_number = 10000

而且你能够把恣意值赋给恣意变量。如上所见,把整数 2 赋值给变量「two」,把 10,000 赋值给变量「some_number」。除了整数,咱们也能够赋值布尔运算、字符串、浮点数以及其他数据方式。

# booleans
true_boolean = True
false_boolean = False
#斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道 string
my_name = "Leandro Tk"
# float
book_price = 15.80

操控流:条件句子

「if」句子经过表达式评价一个句子是真或假。假如是真,则向下履行「if」条件中的子句子。比方:

if True:
print("Hello Python if")
if 2 > 1:
print("2 is greater than 1")

2 比 1 大,因而「print」代码被履行。假如「if」表达式是假的,则「else」下的子句子将被履行。

if 1 > 2:

print("1万能高手李怀风 is greater than 2")

else:

print("1 is not gr北京新风机械厂eater than 2")

你也能够运用一个「elif」句子以增加一个履行条件。

if 1 > 2:
print("1 is greater than 2")
elif 2 > 1:
print("1 is not greater than 2")
else:
print("1 is equal to 2")

循环/迭代器

在 Python 中,咱们可有不同方式的迭代。我将评论两个:while 与 for。

while 循环:当该句子为真,以下代码将被履行,并打印从 1 到 10 的数字。

num = 1
while num <= 10:
print(num)
num += 1

while 循环需求一个「循环条件」。假如它为真,则持续迭代。在以上实例中,梅尔塔怎样打当 num 为 11,则循环条件为假,咱们完毕循环。

以下代码有助于更好地了解它:

loop_condition = True
while loop_condition:
print("Loop Condition keeps: %s" %(loop_condition))
loop_condition = False

循环条件为真,则持续迭代,直到它为假。关于 For 循环:你能够把变量「num」运用需求循环的代码块中,而「for」句子会为你迭代它。该代码的打印与 while 代码相同:从 1 到 10。

for i in range(1, 11):
print(i)

看,如此简略。规模从 1 直到第 11 个元素(10 是第 10 个元素)。此外,假如我卢文超们直接确认一个数,那么 for 循环将从零开端一向迭代到该数字(不包括)。例如以下 for 循环将输出 0 到 9:

for i in range(10):
print(i)

列表:数组数据结构

列表是一个数组或调集,它可用于存储一系列值(比方那些你想要的整数)。因而让咱们用一下它:

my_integers = [1, 2, 3, 4, 5]

如上咱们创立了一个数组并赋值到 my_integers 变量中。而咱们能够经过索引取该数组中的值,如下所示,数组第一个元素的索引为 0,第二个元素的索引为 1,顺次类推。

运用以下句子或许更好了解:

my_integers = [5, 7, 1, 3, 4]
print尼麦兹修士(my_integers[0]) # 5
print(my_integers[1]) # 7
print(my_integers[4]) # 4

相同咱们列表元素的类型也能够是字符型,如下咱们创立斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道了一个元素为字符的列表:

relatives_names = [
"Toshiaki",
"Juliana",
"Yuji",
"Bruno",
"Kaio"
]
print(relatives_names[4]) # Kaio

以上咱们了解了列表的界说和索引运用办法,以下咱们将了解怎么增加一个元素到列表数据结构中。增加元素到列表最常见的办法是 append:

bookshelf = []
bookshelf.append("The Effective Engineer")
bookshelf.append("The 4 Hour Work Week")
print(bookshelf[0]) # The Effective Engineer
print(bookshelf[1]) # The 4 Hour Work Week

append 办法非常简略,咱们只需求对需求增加的元素运用该办法就能将其增加到列表的结尾。

字典:键-值数据结构

咱们现已知道列表是经过整数索引来获取某个元素,而若咱们不期望运用整数作为索引,那么就能够运用字典数据结构。经过这种数据结构,咱们能够运用数值型、字符型或其它类型的索引。字典的每个键值 (key=>value) 对用冒水煮西游号 (:) 切割,每个对之间用逗号 (,) 切割,整个字典包括在花括号 ({})中。如下,字典(Dictionary)是键(Key)与值(Value)的调集:

dictionary_example = {
"key1": "value1",
"key2": "value2",
"key3": "value3"
}

其间键是指向对应值的索引,咱们需求运用键而拜访对应的元素值:

dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian"
}
print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I m %s" %(dictionary_tk["nationality"])) # And by the way I m Brazilian

以上创立了一个字典,其间界说了四个键与对应的值,print 函数内运用了字典的键以获取对应的值。此外,字典的值能够运用任何类型的数据,如下咱们增加了一个键为字符型,值为数值型的键-值对。

dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian",
"age": 24
}
print("My name is %s" %(dictionary_tk["name"])) # My name is Leandro
print("But you can call me %s" %(dictionary_tk["nickname"])) # But you can call me Tk
print("And by the way I m %i and %s" %(dictionary_tk["age"], dictionary_tk["nationality"])) # And by the way I m 24 and Brazilian

下面咱们需求了解怎么增加元素到字典中,其实字典的实质便是指向特定值的关键字的调集。因而咱们能够直接将某个值赋予到字典某个关键字(能够不存在)中而修正或增加键值对。

dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian"
}
dictionary_tk[ age ] = 24
print(dictionary_tk) # 瘦妮小腹{ nationality : Brazilian , age : 24, nickname : Tk , name : Leandro }

迭代:数据结构中的循环

列表循环相同非常简略,咱们能够循环地修正或输出某个列表。如下,咱们常用 for 循环顺次提取列表中的元素:

bookshelf = [
"The Effective Engineer",
"The 4 hours work week",
"Ze斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道ro to One",
"Lean Startup",
"Hookedxaxkiz"
]
for book in bookshelf:
print(book)

关于哈希数据结构,咱们相同能够运用字典中的键和 for 循环顺次读取键与对应的值:

dictionary = { "some_key": "some_value" }
for key in dictionary:
print("微光逐星者%s --> %s" %(key, dictionary[key]))
# some_key --> some_value

运用 iteritems 办法相同能够完结相同的作用:

dictionary = { "some_key": "some_value" }
for key, value in dictionary.items():
print("%s --> %s" %(key, value))
# some_key --> some_value

咱们命名了两个参数 key 和 value,但咱们相同能够命名为其它的,如下咱们运用 attribute 和 value 作为字典键值的参数,它相同有用:

dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian",
"age": 24
}
for attribute, value in dictionary_tk.items():
print("My %s is %s" %(attribute, value))
# My name is Leandro
# My nickname is Tk
# My nationality is Brazilian
# My age is 24

类与方针

方针(Object)表征的是实在国际中的方针,如狗、猫和自行车等,一般方针有两个特征,即数据(Data)与行为(Behavior)。方针「车辆」有一些数据,如车轮的数量、车门的数量与作为容量等,它相同还有一些行为,例如车辆能够加快、刹车、展现燃油运用量等。

在面向方针的编程中,咱们将数据表明为特点,将行为表明为办法。

类(Class)是创立独立方针的蓝图。在实际国际中,咱们常常发现许多相同类型的方针。例如车辆,同类型的车辆都有引擎、车轮、座位等组件,而每一辆车都是依据相同的规划图构建且有相同的组件。

因而,方针是对客观事物的笼统,类是对方针的笼统。方针是类的实例,类是方针的模板。

Python 是一种面向方针的程序言语,因而它也有类(Class)与方针(Object)这两个概念。在了解 Python 面向方针编程的事例前,咱们需求先了解面向方针编程的一些基本概念:

  • 类 (Class):用来描绘具有相同的特点和办法的方针的调集。它界说了该调集中每个方针所共有的特点和办法。方针是类的实例。
  • 类变量:类变量在整个实例化的方针中是共用的。类变量界说在徐誉腾类中且在函数体之外。类变量一般不作为实例变量运用。
  • 数据成员:类变量或许实例变量用于处理类及其实例方针的相关的数据。
  • 办法重写:假如从父类承继的办法不能满意子类的需求,能够对其进行改写,这个进程叫办法的掩盖(override),也称为办法的重写。
  • 实例变量:界说在办法中的变量,只作用于当时实例的类。
  • 承继:即一个派生类(derived class)承继基类(base class)的字段和办法。承继也答应把一个派生类的方针作为一个基类方针对待。例如,一个「狗」类的方针派生自「动物」类,这是模仿"是一个(is-a)"联系(狗是一种动物)。
  • 实例化:创立一个类的实例,类的详细方针。
  • 办法:类中界说的函数。
  • 方针:经过类界说的数据结构实例。方针包括两个数据成员(类变量和实例变量)和办法。

下面首要检查经过声明界说类的句子:

class Vehicle:
pass

方针是类的实例,咱们能够运用类的称号创立一个实例:

car = Vehicle()
print(car) # <__main__.vehicle at="at" instance="instance" x7fb1de6c2638="x7fb1de6c2638">

如上,car 为 Vehicle 类的一个方针或实例。

若咱们的 vehicle 类有四个特点,即车轮数、储能类型、座位容量和最大时速,那么咱们在创立 vehicle 类时能够设置这些特点。下面,咱们界说了初始化类时所承受的数据。self 代表类的实例,self 在界说类的办法时是有必要有的,虽然在调用时不用传入相应的参数。

class Vehicl斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道e:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity

__init__() 办法是一种特别的办法,被称为类的结构函数或初始化办法,当创立 vehicle 类的实例时就会调用该办法来界说这些特点。若咱们期望能创立 Tesla Model S 这一个方针,依据其有四个车轮、电力驱动、四座容量和最大时速为 250km/hour 的特征,咱们能创立方针:

tesla_model_s = Vehicle(4, electric , 5, 250)

现在一切的特点现已设定了,那么咱们该怎么拜访这些特点值?咱们将发送信息到方针的进程称为办法,即方针的行为:

class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocit斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道y = maximum_velocity
def number_of_wheels(self):
return self.number_of_wheels
def set_number_of_wheels(self, number):
self.number_of_wheels = number

以上句子完结了两个办法,number_of_wheels 和 set_number_of_wheels。咱们能够称为 getter & setter,由于第一个办法获取了特点值,而第二个办法将为该特点设置一个新的值。在类的内部,运用 def 关键字能够为类界说一个办法,与一般函数界说不同,类办法有必要包括参数 self,且为第一个参数。

在 Python 中,咱们能运用 @prop隆林山歌erty (decorators) 界说 getter & setter:

class Vehicle:
def __init__(self, nu095187mber_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels =古河胜 n吃双环醇片几天可降酶umber_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
@property
def number_of_wheels(self):
return self.number_of_wheels
@number_of_wheels.setter
def number_of_wheels(self, number):
self.number_of_wheels = number

相同咱们能运用这些办法作为特点:

tesla_model_s = Vehicle(4, electric , 5, 250)
print(tesla_model_s.number_of_wheels) # 4
tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2
print(tesla_model_s.number_of_wheels) # 2

这和界说办法有一些不同,这些办法作为了一种特点。如上当咱们设定新的车轮数量,咱们不需求将「2」作为参数设定,而是将 number_of_wheels 数值设定为 2

咱们还能运用办法做一些其他的操作,例如办法「make_noise」能够设置为:

class Vehicle:
def __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.type_of_tank = type_of_tank
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity
def make_noise(self):
print( VRUUUUUUUM )

当咱们调用该办法时,它将回来字符串「VRRRRUUUUM」。

tesla_model_s = Vehicle(4, electric , 5, 250)
tesla_model_s.make_noise() # VRUUUUUUUM

封装:躲藏信息

封装是一种约束直接拜访方针特点和办法的机制,但一起它又有利于对数据(方针的办法)进行操作。

封装是一种将笼统性函数接口的完结细节部分包装、躲藏起来的办法。一起,它也是一种避免外界调用端,去拜访方针内部完结细节的手法,这个手法是由编程言语自身来供给的。

方针一切的内部表征关于外部来说都是躲藏的,只要方针能直接与内部数据交互。首要,咱们需求了解揭露(public)和私有(non-public)实例变量和办法。

揭露实例变量

关于 Python 的类,咱们能够运用 constructor 办法初始化揭露实例变量:

class Person:
def __init__(self, first_name):
self.first_name = first_name

下面咱们运用 first_name 的值作为揭露实例变量的变元。

tk = Person( TK )
print(tk.first_name) # => TK

在类内:

class Person:
first_name = TK

现在咱们不需求再对 first_name 赋值,一切赋值到 tk 的方针都将有类的特点:

tk = Person()
print(tk.first_name) # => TK

现在咱们现已学会怎么运用揭露实例变量和类特点。除此之外,咱们还能办理揭露部分的变量值,即方针能够办理其变量女王御狼的值:Get 和 Set 变量值。保存 Person 类,咱们期望能给 first_name 变量赋别的一个值:

tk = Person( TK )
tk.first_name = Kaio
print(tk.first_name) # => Kaio

如上咱们将别的一个值(kaio)赋予了 first_name 实例变量,由于它又是一个揭露变量,所以会更新变量值。

私有实例变量

和揭露实例变量相同,咱们能够运用 constructor 办法或在类的内部声明而界说一个私有实例变量。语法上的不同在于私有实例变量在变量名前面加一个下划线:

class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email

上述界说的 email 变量便是私有变量。

tk = Person( TK , tk@mail.com )
print(tk._email) # tk@mail.com

咱们能够拜访而且更新它,私有变量仅是一个约好,即他们需求被视为 API 非揭露的部分。所以咱们能够运用办法在类的界说中完结操作,例如运用两种办法展现私有实例的值与更新实例的值:

class Person:
def __init__(self, first_name, email):
self.first_name = first_name
self._email = email
def update_email(self, new_email):
self._email = new_email
def email(self):
return self._email

现在咱们能够运用办法更新或拜访私有变量。

tk = Person( TK , tk@mail.com )
print(tk.email()) # => tk@mail.com
tk._email = new_tk@mail.com
print(tk.email()) # => tk@mail.com
tk.update_email( new_tk@mail.com )
print(tk.email()) # => new_tk@mail.com

咱们先初始化 Person 类并赋值,然后经过界说的办法拜访并打印私有变量的值。如咱们直接赋值给私有变量新的值,那么打印出来仍是原有的值,咱们只能经过在类里边界说的办法进行操作而更新私有变量。

揭露办法

关于揭露办法(public methods),咱们相同能在类以外的当地调用,以下界说了一个类与办法:

class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def sh华势喔刷ow_age(self):
return self._age

让咱们测验一下该办法:

tk = Person( TK , 25)
print(tk.show_age()) # => 25

私有办法

可是关于私有办法来说,并不能这样操作。若咱们界说相同的类,且运用下划线界说 show_age 为私有办法:

class Person:
def __init__(self, first_name, age):
self.first_name = first_name
self._age = age
def _show_age(self):
return self._age

咱们相同能调用方针的私有办法:

tk = Person( TK , 25)
print(tk._show_age()) # => 25

咱们也能拜访并更新它,私有办法应该要看作 API 的私有部分。下面的事例能够展现了怎么运用它:

class Person:
def __init__(self, 佐仓树里first_name, age):
self.first_name = first_name
self._age = age
def show_age(self):
return self._get_age()
def _get_age(self):
return self._age
tk = Person( TK , 25)
print(tk.show_age()) # => 25

如上咱们声明晰私有办法_get_age 和揭露办法 show_age。show_age 办法能够在类的外部调用,而_get_age 只能在类内部运用。

封装小结

经进程序封装,咱们保证了方针的内部表征对外是躲藏的。而面向方针的编程带来的首要优点之一是代码的重用,完结这种重用的办法之一是经过承继机制。承继完万能够了解成类之间的类型和子类型联系。

若咱们有一辆车,且知道车轮数、座位容量和最大时速,那么一辆电动车类就承继惯例轿车类中的相同特点。

class Car:
def __init__(self,斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道 number_of_wheels, seating_capacity, maximum_velocity):
self.number_of_wheels = number_of_wheels
self.seating_capacity = seating_capacity
self.maximum_velocity = maximum_velocity

更新类中的一个方针:

my_car = Car(4, 5, 250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)

初始化方针后,Py斗罗大陆1,姘头,加勒比海盗6-第十届ICC存案报名处,存案新闻早知道thon 能够将父类(parent class)作为参数运用到子类(child class)中。因而电动车类能够从轿车类承继方针。

class ElectricCar(Car):
def __init__(self素然女装官方旗舰店, number_of_wheels, seating_capacity, maximum_velocity):
Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity

咱们不需求完结其他办法,由于电动轿车类现已从轿车类承继了方针:

my_electric_car = ElectricCar(4, 5, 250)
print(my_electric_car.number_of_wheels) # => 4
print(my_electric_car.seating_capacity) # => 5
print(my_electric_car.maximum_velocity) # => 250

查找进入咱们的CDA小程序,解锁更多新鲜资讯和优质内容,还有许多专业课程和试听课,不要错失哟!

文章版权及转载声明:

作者:admin本文地址:http://www.icc10th2009.com/articles/4452.html发布于 3周前 ( 11-20 13:38 )
文章转载或复制请以超链接形式并注明出处第十届ICC备案报名处,备案新闻早知道