<small id='boCF4s'></small> <noframes id='jzTuKe'>

  • <tfoot id='YlfV'></tfoot>

      <legend id='yZ27lgYib0'><style id='2flpL'><dir id='K7twYWe'><q id='NCXy8c7Ov9'></q></dir></style></legend>
      <i id='IHp1S'><tr id='acpuvDgz'><dt id='NJI1'><q id='5G8dLlyQv'><span id='ysOl2R8nI'><b id='dVXjKsGquW'><form id='E7cqf'><ins id='h9qsfVRY7E'></ins><ul id='FzSmJoxYpA'></ul><sub id='7wmOrn'></sub></form><legend id='VBhLSsN2'></legend><bdo id='NDAkE'><pre id='PVLdgQb'><center id='Q53M4ugi6'></center></pre></bdo></b><th id='x3Wy6oTtni'></th></span></q></dt></tr></i><div id='xqkDgG01TN'><tfoot id='PUd3JDHQ'></tfoot><dl id='ZzUrv5w'><fieldset id='vnTIbao9GZ'></fieldset></dl></div>

          <bdo id='rIAP'></bdo><ul id='SMUJ4Ts'></ul>

          1. <li id='yO72ktKfE5'></li>
            登陆

            汇总丨Python 密布知识点全知道

            admin 2019-11-05 245人围观 ,发现0个评论

            第一个问题,什么是 Python ?依据 Python 之父 Guido van Rossum 的话,Python 是:

            一种高档程序言语,其间心规划哲学是代码可读性和语法,能够让程序员用很少的代码来表达自己的主意。

            关于我来说,学习 Python 的首要原因是,Python 是一种能够高雅编程的言语。它能够简略自然地写出代码和完成我的主意。

            另一个原因是咱们能够将 Python 用在许多当地:数据科学、Web 开发和机器学习等都能够运用 Python 来开发。Quora、Pinterest 和 Spotify 都运用 Python 来进行他们的后端 Web 开发。那么让咱们来学习一下 Python 吧。

            Python 根底

            1、变量

            你能够把变量幻想成一个用来存储值的单词。咱们看个比方。

            Python 中界说一个变量并为它赋值是很简略的。假设你想存储数字 1 到变量 “one” ,让咱们试试看:

            one = 1

            超级简略吧?你只需求把值 1 分配给变量 “one” 。

            two = 2

            some_number = 10000

            只需你想,你能够把恣意的值赋给任何其他的变量。正如你从上面看到的那样,变量 “two” 存储整型变量 2 ,变量 “some_number” 存储 10000 。

            除了整型,咱们还能够运用布尔值(True/Flase)、字符串、浮点型和其他数据类型。

            # booleanstrue_boolean = Truefalse_boolean = False# stringmy_name = "Leandro Tk"# floatbook_price = 15.80

            2、操控流程:条件句子

            “If” 运用一个表达式来判别一个句子是 True 仍是 False ,假设是 True ,那么履行 if 内的代码,比方如下:

            if True:

            print("Hello Python If")

            if 2 > 1:

            print("2 is greater than 1")

            2 比 1 大,所以 print 代码被履行。

            当“if”里边的表达式是 false 时,“else” 句子将会履行。

            if 1 > 2:

            print("1 is greater than 2")

            else:

            print("1 is not greater than 2")

            1 比 2 小,所以 “else” 里边的代码会履行。

            你也能够运用 “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")

            3、循环和迭代

            在 Python 中,咱们能够用不同的办法进行迭代。我会说下 while 和 for。

            While 循环:当句子是 True 时,while 内部的代码块会履行。所以下面这段代码会打印出 1 到 10 。

            num = 1

            while num <= 10:

            print(num)

            num += 1

            while 循环需求循环条件,假设条件一向是 True ,它将会一向迭代,当 num 的值为 11 时,循环条件为 false 。

            另一段代码能够帮你更好的了解 while 句子的用法:

            loop_condition = Truewhile loop_condition:

            print("Loop Condition keeps: %s" %(loop_condition))

            loop_condition = False

            循环条件是 True 所以会一向迭代,直到为 False 。

            For 循环:你能够在代码块上运用变量 “num” ,而 “for” 句子将为你迭代它。此代码将打印与 while 中相同的代码:从 1 到 10 。

            for i in range(1, 11):

            print(i)

            瞧见没?这太简略了。i 的规模从 1 开端一向到第 11 个元素(10是第十个元素)

            List:调集 | 数组 | 数据结构

            假设你想要在一个变量里存储整数 1 ,可是你也要存储 2 和 3 , 4 , 5 ...

            不是用成百上千个变量,我有其他办法存储这些我想要存储的整数吗?你现已猜到了,的确有其他存储它们的办法。

            列表是一个调集,它能够存储一列值(就像你想要存储的这些),那么让咱们来用一下它:

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

            这真的很简略。咱们创立了一个叫做 my_integer 的数组而且把数据存到了里边。

            或许你会问:“我要怎样获取数组里的值?”

            问得好。列表有一个叫做索引的概念。第一个元素鲟鱼的下表是索引0(0)。第二个的索引是1,以此类推,你应该了解的。

            为了使它愈加简练,咱们能够用它的索引代表数组元素。我画了出来:

            用 Python 的语法,也很好去了解:

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

            print(my_integers[0]) # 5print(my_integers[1]) # 7print(my_integers[4]) # 4

            假设你不想存整数。你只想去存一些字符串,像你亲属姓名的列表。我的看起来是相似这样的:

            relatives_names = [ "Toshiaki", "Juliana", "Yuji", "Bruno", "Kaio"]

            print(relatives_names[4]) # Kaio

            它的原理跟存整数相同,很友爱。

            咱们只学习了列表的索引是怎么作业的,我还需求告知你怎么向列表的数据结构中增加一个元素(向列表中增加一个项目)。

            最常用的向列表中增加新数据的办法是拼接。咱们来看一下它是怎么运用的:

            bookshelf = []

            bookshelf.append("The Effective Engineer")

            bookshelf.append("The 4 Hour Work Week")

            print(bookshelf[0]) # The Effective Engineerprint(bookshelf[1]) # The 4 Hour Work W

            拼接超级简略,你仅需求把一个元素(比方“有用的机器”)作为拼接参数。

            好了,关于列表的常识这些就够了,让咱们来看一下其它的数据结构。

            字典:Key-Value 数据结构

            现在咱们知道 List 是有索引的整型数字调集。但假设咱们不像运用整型数字作为索引呢?咱们能够用其他的一些数据结构,比方数字、字符串或许其他类型的索引。

            让咱们学习下字典这种数据结构。字典是一个键值对的调集。字典差不多长这样:

            dictionary_example = {

            "key1": "value1",

            "key2": "value2",

            "key3": "value3"

            }

            Key 是指向 value 的索引。咱们怎么拜访字典中的 value 呢?你应该猜到了,那便是运用 key 。咱们试一下:

            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 汇总丨Python 密布知识点全知道the way I'm %s" %(dictionary_tk["nationality"])) # And by the way I'm Brazilian

            咱们有个 key(age)value(24),运用字符串作为 key 整型作为 value 。

            我创立了一个关于我的字典,其间包括我的姓名、昵称汇总丨Python 密布知识点全知道和国籍。这些特点是字典中的 key 。

            就像咱们学过的运用索引拜访 list 相同,咱们相同运用索引(在字典中 key 便是索引)来拜访存储在字典中的 value 。

            正如咱们运用 list 那样,让咱们学习下怎么向字典中增加元素。字典中主要是指向 value 的 key 。当咱们增加元素的时分相同如此:

            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 Brazilian

            咱们只需求将一个字典中的一个 key 指向一个 value 。没什么难的,对吧?

            迭代:经过数据结构进行循环

            跟咱们在 Python 根底中学习的相同,List 迭代非常简略。咱们 Python 开发者一般运用 For 循环。咱们试试看:

            bookshelf = [

            "The Effective Engineer",

            "The 4 hours work week",

            "Zero to One",

            "Lean Startup",

            "Hooked"

            ]

            for book in bookshelf:

            print(book)

            关于在书架上的每本书,咱们打印(能够做任何操作)到操控台上。超级简略和直观吧。这便是 Python 的美好之处。

            关于哈希数据结构,咱们相同能够运用 for 循环,不过咱们需求运用 key 来进行。

            dictionary = { "some_key": "some_value" }

            for key in dictionary:

            print("%s --> %s" %(key, dictionary[key])) # some_key --> some_value

            上面是怎么在字典中运用 For 循环的比方。关于字典中的每个 key ,咱们打印出 key 和 key 所对应的 value 。

            另一种办法是运用 iteritems 办法。

            dictionary = { "some_key": "some_value" }

            for key, value in dictionary.items():

            print("%s --> %s" %(key, value))# some_key --> some_value

            咱们命名两个参数为 key 和 value ,可是这不是必要的。咱们能够随意命名。咱们看下:

            dictionary_tk = {

            "name": "Leandro",

            "ni汇总丨Python 密布知识点全知道ckname": "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

            能够看到咱们运用了 attribute 作为字典中 key 的参数,这与运用 key 命名具有相同的作用。真是太棒了!

            类&目标

            一些理论:

            目标是对实践国际实体的表明,如轿车、狗或自行车。这些目标有两个一起的主要特征:数据和行为。

            轿车有数据,如车轮的数量,车门的数量和座位的空间,而且它们能够表现出其行为:它们能够加快,中止,显现剩下多少燃料,以及许多其他的作业。

            咱们将数据看作是面向目标编程中的特点和行为。又表明为:

            数据→ 特点和行为 → 办法

            而类是创立单个目标的蓝图。在实践国际中,咱们常常发现许多相同类型的目标。比方说轿车。一切的轿车都有相同的结构和模型(都有一个引擎,轮子,门等)。每辆车都是由同一套蓝图结构成的,并具有相同的组件。

            Python 面向目标编程形式:ON

            Python,作为一种面向目标编程言语,存在这样的概念:类和目标。

            一个类是一个蓝图,是目标的模型。

            那么,一个类是一个模型,或许是一种界说特点和行为的办法(正如咱们在理论部分评论的那样)。举例来说,一个车辆类有它自己的特点来界说这个目标是个什么样的车辆。一辆车的特点有轮子数量,动力类型,座位容量和最大时速这些。

            考虑到这一点,让咱们来看看 Python 的类的语法:

            class Vehicle:

            pass

            上边的代码,咱们运用 class 句子来界说一个类。是不是很简略?

            目标是一个类的实例化,咱们能够经过类名来进行实例化。

            car = Vehicle()

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

            在这儿,car 是类 Vehicle 的目标(或许实例化)。

            记住车辆类有四个特点:轮子的数量,油箱类型,座位容量和最大时速。当咱们新建一个车辆目标时要设置一切的特点。所以在这儿,咱们界说一个类在它初始化的时分承受参数:

            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

            这个 init 办法。咱们称之为结构函数。因而当咱们在创立一个车辆目标时,能够界说这些特点。幻想一下,咱们喜爱 Tesla Model S ,所以咱们想创立一个这种类型的目标。它有四个轮子,运用电动力,五座而且最大时时速是250千米(155英里)。咱们开端创立这样一个目标:

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

            四轮+电动力+五座+最大时速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_velocity = 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。由于第一个函数是获取特点值,第二个函数是给特点设置新的值。

            在 Python 中,咱们能够运用@property (修饰符)来界说getters和setters。让咱们看看实践代码:

            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 @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) # 4tesla_model_s.number_of_wheels = 2 # setting number of wheels to 2print(tesla_model_s.number_of_wheels) # 2

            这和办法界说有细微的不同。这儿的办法是依照特点履行的。例如当咱们设置新的轮胎数目时,咱们并不将这两个看做参数,而是将数值2设置给number_of_wheels。这是编写python风格的getter和setter代码的一种办法。

            但咱们也能够将该办法用于其他事项,例如“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

            封装: 躲藏信息

            封装是一种约束直接拜访目标数据和办法的机制。但与此同时,它使得在数据上操作更简略(目标的办法)。

            “封装可被用于躲藏数据成员和成员函数。依照这个界说,封装意味着 目标的内部表明一般在目标界说的外部视图中躲藏。” — Wikipedia

            目标的一切内部表明都对外部躲藏了。只要目标自身能够与其内部数据交互。

            首要,咱们需求了解揭露的、非揭露的实例变量和办法的作业原理。

            公共实例变量

            关于 Python 类,咱们能够在咱们的结构函数办法中初始化一个公共实例变量。让咱们看看这个:

            在这个结构办法中:

            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

            这就能够了,咱们仅仅为 first_name 实例变量设置另一个值(kaio),并更新了值。就这么简略。由于这是一个公共变量,咱们是能够这么做的。

            Non-public 实例变量

            这儿咱们并没有运用术语“private”,由于在Python中一切特点都不是真的私有的(没有一般不必要的作业量)。 — PEP 8

            作为 public instance variable(公共实例变量),咱们能够在结构办法或类内部界说 non-public instance variable (非公共实例变量)。语法上的区别是:关于 non-public instance variables (非公共实例变量),在变量名前运用下划线(_)。

            “除了从目标内部外无法被拜访的‘Private’实例变量在Python中并不存在。可是,这儿有一个大都Python代码都会恪守的常规:运用下划线作为前缀的命名(例如 _spam)应该被认为是API的非揭露部分(不管是函数、办法仍是数据成员)” — Python软件根底

            这儿是示例代码:

            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的非公共部分。

            所以咱们运用一个在类界说内部的办法来完成该功用。让咱们完成两个办法(email 和update_email)以加深了解:

            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.comtk._email = 'new_tk@mail.com'print(tk.email()) # => tk@mail.comtk.update_email('new_tk@mail.com')

            print(tk.email()) # => new_tk@mail.com

            ● 咱们运用first_name TK和email tk@mail.com初始化了一个新目标

            ● 运用办法拜访非揭露变量email并输出它

            ● 测验在类外部设置一个新的email

            ● 咱们需求将非揭露变量视为API的非揭露部分

            ● 运用咱们的实例办法来更新非揭露变量

            ● 成功!咱们运用辅佐办法在类内部更新了它。

            公共办法

            关于公共办法,咱们也能够在类中运用它们:

            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

            很好 - 咱们在类中运用它没有任何问题。

            非公共办法

            可是用非揭露的办法,咱们无法做到这一点。假设咱们想完成相同的 Person 类,现在运用有下划线(_)的 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 只用在咱们的类界说里边运用(在 show_age 办法里边)。可是相同的,这样的做法一般是常规。

            封装小结

            经过封装,咱们能够保证目标的内部表明是对外部躲藏的。

            承继:行为和特征

            某些物体有一些一起之处:它们的行为和特征。

            例如,我承继了我父亲的一些特征和行为。我承继了他的眼睛和头发的特征,以及他的烦躁和内向的行为。

            在面向目标编程中,类能够承继另一个类的一起特征(数据)和行为(办法)。

            咱们来看另一个比方,并用 Python 完成它。

            幻想一下轿车。车轮数量,座位容量和最大速度都是一辆车的特点。咱们能够说 ElectricCar 类从一般的 Car 类承继了这些相同的特点。

            class Car:

            def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):

            self.number_of_wheels = number_of_wheels

            self.seating_capacity = seating_capacity

            self.maximum_velocity = maximum_velocity

            咱们 Car 类的完成:

            my_car = Car(4, 5, 250)

            print(my_car.number_of_wheels)

            print(my_car.seating_capacity)

            print(my_car.maximum_velocity)

            一旦初始化,咱们就能够运用一切创立的实例变量。太棒了。

            在 Python 中,咱们将父类作为子的参数来进行承继。ElectricCar 类能够承继咱们的 Car 类。

            class ElectricCar(Car):

            def __init__(self, number_of_wheels, seating_capacity, maximum_velocity):

            Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)

            就这么简略。咱们不需求完成任何其他办法,由于这个类现已完成了父类的承继(承继自 Car 类)。咱们来证明一下:

            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

            原文:Learning Python: From Zero to Hero

            链接:https://medium.freecodecamp.org/learning-python-from-zero-to-hero-120ea540b567

            译者:rever4433, Tocy, Tony, 南宫冰郁, 透过树叶的光

            免责声明:

            本文内容出于传递更多信息之意图,归于非营利性的转载。如无意中侵犯了某个媒体或个人的常识产权,请联络咱们,咱们将当即删去相关内容。其他媒体、网络或个人从本网下载运用须自傲版权等法律责任。

            请关注微信公众号
            微信二维码
            不容错过
            Powered By Z-BlogPHP