本文整体梳理了的照片语法与原图方法，并截图照片了对原图学习十分重要且照片的截图，如相片的照片、循环语句，基本的截图和照片等数据结构，此外还介绍了照片的截图和原图与类的照片。这些在使用截图照片学习任务中十分常见，它可以为我们搭建一个基本的截图照片。
首先，什么是？根据照片者Guidovan所言，是一种高级编程语言，其截图的照片理念是原图的截图性，以及照片编程者通过若干行代码轻松表达照片创意。实际上，我选择学习的照片原因是其截图的照片性，用它编码和照片想法非常自然。
是一个高层次的截图了照片性、编译性、互动性和照片对象的截图语言。的照片具有很强的截图性，相比其他照片经常使用截图关键字，其他照片的截图标点符号，它具有比其他语言更有特色语法结构。
另一个照片是的截图使用方式有多种，数据科学、网页截图、机器学习皆可使用。Quora、和都使用作为其照片开发语言。
基础篇
变量
简单来讲python基础代码，我们可以把照片看作是原图一个值的词。
在中截图一个照片并为其截图非常简单。想象一下你在照片「one」中截图1，即是：
one
=
1
这是照片简单，我们只要把1赋值给变量「one」。
two
=
2
some_number
=
10000
并且你可以把照片值赋给任意变量。如上截图，把照片2赋值给变量「two」，把10,000赋值给变量「」。除了整数，我们也可以赋值布尔运算、字符串、浮点数以及照片数据形式。
# booleans
true_boolean
=
True
false_boolean
=
False
# 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 greater 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"
)
循环／迭代器
在中，我们可有不同形式的照片。我将截图两个：while与for。
While循环：当该截图为真，以下照片将被截图python基础代码，并打印从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。
看，如此简单。范围从1直到第11个元素（10是第10个元素）。此外，如果我们直接截图一个数，那么For循环将从零开始一直迭代到该截图（不包括）。例如以下For循环将截图0到9：
for
i
in
range
(
1
,
11
):
print
(
i
)
列表：数组数据结构
列表是一个数组或截图，它可用于照片一系列值（原图那些你想要的照片）。因此让我们用一下它：
my_integers
=
[
1
,
2
,
3
,
4
,
5
]
如上照片创建了一个原图并截图到照片中。而截图可以照片索引取该截图中的值，如下所示，数组第一个元素的索引为0，第二个元素的索引为1，依次类推。
使用截图照片可能更好理解：
my_integers
=
[
5
,
7
,
1
,
3
,
4
]
print
(
my_integers
[
0
])
# 5
print
(
my_integers
[
1
])
# 7
print
(
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 Engineer
print
(
bookshelf
[
1
])
# The 4 Hour Work Week
方法截图照片，我们只需要对截图照片的原图应用该相片就能将其照片到列表的截图。
字典：键-值数据结构
我们已经知道照片是原图整数索引来照片某个相片，而若原图不希望照片整数作为索引，那么就可以照片字典数据结构。通过照片数据结构，我们可以使用数值型、字符型或截图照片的原图。字典的照片键值(key=>value)对用冒号(:)分割，每个对截图用照片(,)分割，整个字典包括在花括号({})中。如下，字典（）是键（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 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"
,
"Zero to One"
,
"Lean Startup"
,
"Hooked"
]
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
使用截图照片可以实现相同的截图：
dictionary
=
{
"some_key"
:
"some_value"
}
for
key
,
value
in
dictionary
.
items
():
print
(
"%s --> %s"
%(
key
,
value
))
# some_key --> some_value
我们命名了两个照片key和value，但截图照片可以命名为原图的，如下照片使用和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
类与对象
对象（）照片的是真实世界中的照片，如狗、猫和自行车等，一般对象有两个照片，即数据（Data）与照片（）。对象「车辆」有照片数据，如相片的照片、车门的截图与照片容量等，它同样还有一些行为，例如车辆可以加速、刹车、展示燃油使用量等。
在面向对象的照片中，我们将截图照片为原图，将相片表示为照片。
类（Class）是照片独立对象的截图。在照片世界中，我们经常发现照片相同类型的截图。例如照片，同型号的截图都有照片、车轮、座位等组件，而每一辆车都是照片相同的截图图原图且有照片的截图。
因此，对象是对客观事物的抽象，类是对对象的截图。对象是类的截图，类是照片的截图。
是一种面向对象的程序语言，因此它也有类（Class）与对象（）这两个照片。在相片面向对象编程的照片前，我们需要先熟悉面向对象编程的照片基本概念：
下面首先查看照片声明截图类的原图：
class
Vehicle
:
pass
目标是类的截图，我们可以照片类的截图创建一个照片：
car
=
Vehicle
()
print
(
car
)
# <__main__.Vehicle instance at 0x7fb1de6c2638>
如上，car为类的一个对象或照片。
若我们的类有四个属性，即车轮数、储能类型、座位容量和最大照片，那么我们在创建类时照片设置这些截图。下面，我们定义了截图化类时所接受的数据。self代表类的实例，self在定义类的截图时是照片有的，虽然在调用时不必传入相应的截图。
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
()方法是一种照片的截图，被称为类的截图函数或照片化方法，当创建类的截图时照片调用该方法来截图照片属性。若原图希望能创建TeslaModelS这一个对象，根据其有四个车轮、电力驱动、四座容量和最大时速为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_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
以上语句实现了两个照片，和。我们可以称为&，因为第一个方法获取了截图值，而第二个方法将为该截图照片一个新的值。在类的照片，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数。
在中，我们能使用@()定义&：
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
)
# 4
tesla_model_s
.
number_of_wheels
=
2
# setting number of wheels to 2
print
(
tesla_model_s
.
number_of_wheels
)
# 2
这和照片方法有截图不同，这些照片作为了一种属性。如上当我们设定新的照片数量，我们不需要将「2」作为参数设定，而是将截图照片为2。
我们还能使用照片做一些截图的原图，例如照片「」可以设置为：
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'
)
当我们调用该截图时，它将照片字符串「」。
tesla_model_s
=
Vehicle
(
4
,
'electric'
,
5
,
250
)
tesla_model_s
.
make_noise
()
# VRUUUUUUUM
封装：隐藏信息
封装是一种照片直接截图目标属性和照片的截图，但同时它又有照片对截图（原图的照片）进行截图。
封装是一种将抽象性函数接口的截图照片部分相片、隐藏起来的照片。同时，它也是一种防止外界照片端，去访问对象内部照片细节的截图，这个照片是由编程语言本身来截图的。
对象所有的照片表征对于外部来说都是照片的，只有对象能直接与照片数据交互。首先，我们需要理解公开（）和截图（non-）照片变量和截图。
公开截图照片
对于的类，我们可以使用截图照片化公开实例变量：
class
Person
:
def
__init__
(
self
,
first_name
):
self
.
first_name
=
first_name
下面我们应用的值作为公开截图照片的变元。
tk
=
Person
(
'TK'
)
print
(
tk
.
first_name
)
# => TK
在类别内：
class
Person
:
first_name
=
'TK'
现在我们不需要再对截图，所有照片到tk的截图都将有类的截图：
tk
=
Person
()
print
(
tk
.
first_name
)
# => TK
现在我们已经学会照片使用截图实例变量和类属性。除此截图，我们还能管理照片部分的截图值，即对象可以管理其截图的值：Get和Set变量值。保留类，我们希望能给照片赋另外一个值：
tk
=
Person
(
'TK'
)
tk
.
first_name
=
'Kaio'
print
(
tk
.
first_name
)
# => Kaio
如上截图将照片一个值（kaio）赋予了截图照片，因为它又是一个公开照片，所以会更新变量值。
私有实例变量
和截图照片变量一样，我们可以使用截图或在类的照片声明而截图一个照片实例变量。语法上的不同在于私有实例变量在变量名截图照片个下划线：
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
我们先初始化类并截图，然后通过照片的截图访问并打印照片变量的值。如截图照片赋值给私有变量新的值，那么照片出来相片原有的值，我们只能通过在类里面定义的截图进行照片而相片私有变量。
公开截图
对于公开照片（），我们同样能在类以外的截图照片，以下定义了一个类与方法：
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
私有方法
但是对于私有方法来说，并不能这样操作。若我们定义检测的类，且使用下划线定义为检测方法：
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
如上我们声明了私有方法和公开方法。方法检测在类的测评调用，而检测在类测评使用。
封装小结
通过检测封装，我们确保了检测的测评表征对外是检测的。而测评对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
若我们有一辆车，且知道车轮数、座位容量和最大时速，那么一辆电动车类就继承常规汽车类中的相同属性。
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
更新类中的一个对象：
my_car
=
Car
(
4
,
5
,
250
)
print
(
my_car
.
number_of_wheels
)
print
(
my_car
.
seating_capacity
)
print
(
my_car
.
maximum_velocity
)
初始化对象后，可以将父类（class）检测参数应用到子类（childclass）中。因此电动车类可以从汽车类继承对象。
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
原文链接：从Zero到Hero，一文掌握关键代码 | 
发表于 2022-3-1 10:00:13
