在上一篇教程,我们学习了Python的语法——意味着它的标识符、关键字、注释、语句、字面量和数据类型。我们还了解到Python是面向对象的,这些对象可以是可变的或不可变的. 指向一组值的Python对象是可迭代的在这种情况下,被称为迭代器.
前面教程中介绍的所有数据类型(整数、浮点数、复数、字符串、原始字符串)都是字面值(分配给变量或属性的实际值)的数据类型。Python还有指向一组有序或无序值(项)的引用的数据类型。
此外,Python具有以下数据类型:
元组-对象的序列。序列是指一组有序的项(对象),其中的索引可以访问这些项。元组的项可以是可变或不可变的任意对象。
但是,元组是不可变的,这意味着元组的项一旦定义就不能更新或更改。这就是为什么很少建议在元组中使用可变项,除非它们永远不会更改或需要更新。元组可以看作是一组常量值或对象,可以用来定义一个或多个常量。
元组定义为一组由空格或逗号分隔的值或对象。该组可以选择用括号(“”)括起来。逗号也是可选的,但建议使用逗号分隔元组项,特别是在函数需要元组时。
或者,元组的最后一项也可以有一个尾随逗号。空元组由一对空括号定义。内置函数,元组(),也可用于定义元组。任何由空格或逗号分隔的项组默认为元组。如果单个字符串(或任何可迭代对象)被定义为元组,则其字符(或项)可以用作元组项。
下面是一些元组的有效示例:
tup1 = ' Id ' ' Name ' '地址'
tup1 = ' Id ', ' Name ', ' Address '
tup1 = (' Id ', ' Name ', ' Address ')
tup1=('Id','Name','Address',)
tup1 =() #空元组
tup1 = (' Id ', 123, 0b1111_1110, 2.5j5.4, True)
tup1 = (' Id ', 123, 0b1111_1110, 2.5j5.4, True,)
tup1 = tuple(' Id ', ' Name ', ' Address ')
tup1 = tuple(' Id ' ' Name ' ' Address ')
tup1 = tuple(' ABC ') #等价于tup = (' A ', ' B ', ' C ')
列表,作为一组可变项排序的序列。这意味着可以更改或修改列表中的项目。本质上,列表是一组可修改的值或对象,可以在其中替换、删除或添加组中的项目。列表中的项目可以包括任何可变或不可变的任意对象。
列表被定义为一组值和/或对象,这些值和/或对象之间用逗号("[")分隔。列表的最后一项可以有一个逗号作为结尾。内置的函数,列表,也可用于定义列表。
空列表由一对空括号或列表()函数没有参数。如果iterable用作列表的唯一项,则其项可以用作列表的项。
以下是一些有效的列表示例:
list1 = [` Id `, ` Name `, ` Address `]
list1 = [' Id ', '姓名','地址']
list1 =[] #空列表
list1=list()#空列表
列表1=['Id',123,0b1111_1110,2.5j5.4,True]
list1 = [' Id ', 123, 0b1111_1110, 2.5j5.4, True,]
list1 = list(' Id ', ' Name ', ' Address ')
list1 = list(' Id ' ' Name ' ' Address ')
list1 = list(' ABC ') #等价于list1 = [' A ', ' B ', ' C ']
集- - - - - -唯一项的一个可变的、无序的集合。集合的项应该是不可变的和“可散列的”,这意味着它的值(散列值)永远不应该改变。不可变意味着它的数据类型也必须永远不变。这是因为集合只能包含不可变和可散列的项,其中没有任何其他集合。
集合由一组值和/或(不可变和可哈希的)对象定义,这些对象由大括号内的逗号("{")分隔。可选地,集合的最后一项可以在末尾加上逗号。内置的函数,集,也可用于定义集合。空集由一对空大括号或集函数没有参数。
下面是集合的有效例子:
set1={'Id','Name','Address'}
set1 = {' Id ', ' Name ', ' Address ',}
set1 ={} #空集合
set1 = set() #空的集合
set1 = {' Id ', 123, 0b1111_1110, 2.5j5.4, True}
set1 = {' Id ', 123, 0b1111_1110, 2.5j5.4, True,}
set1=set('Id','Name','Address')
set1 = set(' Id ' ' Name ' '地址')
Frozensets -集合的不可变版本。它们由frozenset()函数。的定义为空冻结集冻结函数没有参数。
以下是一些有效的例子:
frset1=frozenset('Id','Name','Address'))
frset1 = frozenset(' Id ' ' Name ' '地址')
frset1=冻结集()#空冻结集
字典,与任意键配对的值的一个可变的、无序的集合。这些键是任意的,但它们应该是可散列的。这些值可以包括任意的可变或不可变对象。
字典类似于其他编程语言中的无序映射或哈希表。它被定义为一组逗号、分隔的键对和用大括号括起来的值或作为内置参数使用的值dict类型()函数。
键值对中的key和value由冒号(":")分隔。在dict类型()成对的函数、键和值可以用等号(“=”)分隔,也可以放在元组中。或者,字典的最后一项(键值对)可以有一个尾随逗号。
空字典由一对空的大括号或dict类型()没有参数的函数。字典中的任何项都应该是键值对,即使该值是iterable。
以下是字典的有效例子:
dict1={x:25,y:57,z:64}
Dict1 = {x:25, y:57, z:64,}
dict1={'x':25,'y':57,'z':64,}
Dict1 = {' x ':25, 57: ' y ', z:8.9j6.5}
Dict1 = dict(x=25, y=57, z=64)
Dict1 = dict(x, 25), (y, 57), (z, 64))
dict1 = dict() #空字典
dict1 ={} #空字典
无-Python中的空对象,相当于“no object”,没有属性或方法。一个函数返回没有一个如果没有return语句。
字节,不可变序列(有序集合),其中只有项可以是字节(0到255的整数)。a的项目字节可以是字符串的字符、整数、,没有一个或iterable。
字节可以通过在字符串或整数之前预先固定“b”或使用内置字节()函数。Byte()函数还允许指定编码。
以下是几个有效的例子:
Val = b 'Python '
Val = b‘123’
Val=字节('Python')
Val = bytes(' Python ', utd-8)
Val = bytes ([1, 2, 3, 4, 5])
字节数组-可变序列(有序集合),仅包含项(0到255范围内的整数)。字节数组的项可以是字符串、整数、,没有一个或iterable。
唯一的区别字节和字节数组类型是一个字节是不可变的,而字节数组是可变的。字节数组可以使用内置的bytearray()函数。
以下是几个有效的例子:
Val = bytearray(" Python ", ' utf-8 ')
Val = bytearray([1, 2, 3, 4, 5,])
Val = bytearray() #空bytearray
范围- - - - - -两个整数值之间的整数序列(有序集合),使得每个整数值(项)通过步长值与相邻项不同。默认情况下,相邻值之间的差值为“1”
使用内置的range ()函数。range()函数具有以下语法:
范围(启动、停止、步骤)
- 如果range()中只有一个值作为参数提供,则它提供从0到给定参数的整数序列。
- 如果两个值作为参数提供,它将给出两个值之间的整数序列,其中包括它们。
- 如果提供了三个值作为参数,则第三个值作为相邻项之间的差值。
以下是该范围的有效例子:
Range (9) # 0,1, 2, 3, 4, 5, 6, 7, 8, 9
范围(5,10)# 5,6,7,8,9,10
Range (2, 10, 2) # 2,4,6,8, 10
布尔-该类型只能有两个值:True或False。任何非零值或非空容器都被认为是True。任何零值,没有一个或空容器被认为是False。True和False值也可以分别用“1”和“0”表示。
Python中还有其他几种数据类型可以具有内置类(如datetime)或用户定义类。例如,任何按目的定义数据类型或表示数据结构的类都可以视为数据类型类。
Python中有六种类型的序列(有序集合):
- 串
- 字节
- 字节数组
- 范围
- 元组
- 列表
序列的索引必须从“0”开始(即任何序列的第一项的索引/键为“0”)。集合、冻结集合和字典在Python中是无序的集合。
为清楚起见,请参阅此表:
藏品名称 | 集合的性质 | 物品的性质 |
字符串 | ASCII或UTF(或其他编码)字符的不可变序列(有序集合) | ASCII或UTF字符或与应用的编码方案相对应的字符 |
字节 | 不可变的字节序列(0到255) | 范围从0到255的字节值,可以是整数、字符或可数 |
字节数组 | 可变字节序列 | 范围从0到255的字节值,可以是整数、字符或可数 |
范围 | 不可变的整数序列 | 定义范围之间的整数 |
元组 | 不可变的对象序列 | 任意可变或不可变对象 |
列表 | 可变对象序列 | 任意可变或不可变对象 |
集 | 对象的可变无序集合 | 任意不可变对象,不允许重复对象 |
冷冻组 | 不可变的无序对象集合 | 任意不可变对象,不允许重复对象 |
词典 | 可变的无序键值对集合 | 任意不可变键和任意可变或不可变值 |
变量、属性和项
在Python中——所有东西都是对象——数据值也是对象。数据值存储在内存中。这意味着每当一个新的数据值出现在Python代码中(无论是在代码中定义的还是在运行时定义的),它都被存储在某个内存位置中。
代码通过引用访问这些数据值。这些引用可以是对象的变量、属性、方法或项。这些变量是对数据值的引用,可以在代码中的任何地方使用。
这些属性是对与对象关联的不可调用数据值的引用。方法是对与对象关联的“可调用”数据值的引用。可调用意味着这些数据值在出现时执行一组语句。在Python中,类的实例称为items。因此,项是对类或对象实例的引用。
每当将数据值赋给变量、属性、方法或对象时,这个过程就称为绑定。数据值保持独立于它的绑定。如果将不同的数据值分配给一个引用,该数据值将存储在不同的内存位置。因此,前面的数据值(如果没有绑定到任何其他引用)将成为未绑定的。清除未绑定的数据值或对象称为垃圾收集。
Python中没有声明。引用会动态显示,并且没有声明的数据类型。如何处理(对数据值/对象的)引用取决于它出现的表达式以及如何/如果使用它重新绑定另一个引用。
数据值可以通过赋值或扩充赋值语句绑定到引用。在赋值语句中,RHS表达式绑定到LHS目标,并用赋值符号(“=”)分隔。目标可以是任何引用,例如变量、属性或项。
简单的赋值语句是这样的:
var =表达式
这是一个简单赋值的例子:
a=1
可以将一个数据值(或表达式的结果)同时赋给多个目标:
var1=var2=var3=表达式
这是这样一个作业的例子:
a=b=c=1
如果RHS表达式是一个iterable或导致一个iterable,则应将其分配给另一个iterable(大小相同)或多个变量(数量等于iterable的大小),如下所示:
var1, var2, var3 = Iterable/生成Iterable的表达式
下面是这种说法的一个例子:
A, b, c, = [1.1, 1.9, abc]
如果目标引用前面有星号(“*”),则它接受所有未指定的数据值/对象的列表,如下所示:
var1,*var2,var3=Iterable/导致Iterable的表达式
下面是这样一个作业的例子:
a * b c = 1.1, 1.9, abc, 43岁,2.5阁下# b = 1.9, abc, 43岁
在增广赋值中,增广运算符,如+=、-=、*=、**=,用于赋值。在这样的语句中使用目标引用之前,应该创建目标引用。在扩展赋值中只能有一个目标引用。
在扩展赋值中,将修改先前分配给引用的数据值并将其重新绑定到该引用。然后,先前分配的数据值将变成未绑定的(来自那个特定的引用)。
下面是一个扩充赋值的示例:
a+=b#a=a+b
属性可以将数据值与引用解除绑定▽语句。这称为解除绑定。可以在一个语句中解除多个引用的绑定▽语句,使用逗号分隔目标引用。然而,一个▽语句仅解除数据值/对象与引用的绑定,而不删除数据值或对象。如果数据值未绑定到任何其他引用,则将其留给垃圾收集。
下面是一些有效的例子▽声明:
德尔一
德尔a、b、c
Python运营商
操作符用于操作数据值和使用构成逻辑表达式的引用。在一个逻辑语句中可以有一个或多个表达式。Python支持许多操作符。
这些是最常见的:
算术运算符,包括加(+)、减(-)、乘(*)、除(/)、模(%)、求幂(**)和底除(//)。加法操作符(*)也可以作为字符串和其他可迭代对象的连接操作符。类似地,乘法运算符(*)可用于按照使用乘数指定的时间复制字符串或可迭代对象。
赋值运算符-包括assign (=), add和assign(“+=”),subtract和assign (-=), multiply和assign (*=), divide和assign (/=), modulus和assign (%=), exponation和assign (**=), floor division和assign(//==)。
比较运算符,包括equal (==), not equal (!= or <>),大于(>),小于(<),大于(>=),小于(<=)。
也可以将比较链如下所示:
A < b >=c #
逻辑运算符,包括逻辑与(和)、逻辑或(或)和逻辑非(NOT)。
按位运算符,包括二进制和(&)、二进制或(|)、二进制异或(^)、二进制一补(~)、二进制左移(<<)和二进制右移(>>)。
成员操作符-包括in(在)和not in(不在)。这些操作符用于计算项是否属于序列或集合。如果LHS项是RHS序列/集合的成员,则in (in)操作符返回true。如果LHS项不是RHS序列/集合的成员,则not in (not in)操作符返回true。
身份操作员-包括is (is)和not (is not)。这些操作符用于计算两个引用是否相同。如果这两个引用指向相同的数据值,那么它们可以具有相同的标识,这些数据值可能存储在相同的内存位置(取决于操作系统和平台)。的是(is)操作符如果两个引用具有相同的标识符则返回true。的不是(is not)运算符在两个引用不具有相同标识时返回true。
索引运算符-索引操作符([])与序列一起使用,用于访问序列中的特定项。所有序列的索引都以“0”开头,因此任何序列的第一项的索引(或键)都是0。其后项指数增加“1”。因此,x[2]允许您访问序列“x”的第三项。如果使用负数作为索引,则访问该项时将从序列的最后一项开始计数,而不是从第一个开始计数。
切片操作符-切片运算符([:])用于以列表的形式访问序列中的多个项。例如,x[1:3]允许您以列表的形式访问序列“x”的第二项和第三项。请记住,Python有六种类型的序列:字符串、字节、字节数组、范围、元组和列表。
Python中的操作符优先级
下表总结了Python中从最低优先级到最高优先级的操作符优先级:
控制流语句
Python支持以下控制流语句:
If-elif-else -一个条件语句,如果条件表达式返回true,则允许执行语句。它有这样的语法:
如果conditional_expression1:
语句(年代)
elif conditional_expression2:
语句(年代)
elif conditional_expression3:
语句(年代)
其他conditional_expression:
语句(年代)
在如果声明中elif和其他的是可选的。当条件表达式的计算结果为True时,将执行其前面的语句,并执行如果声明到此结束。但是,条件表达式不必显式返回True或False。在Python中,任何表达式或对象都隐式地作为条件表达式计算True或False。
因此,建议使用以下表达式:
如果x:
如果不是x:
而不是下面的表达:
如果x == True:
如果x == 1:
如果x为真:
如果布尔(x):
如果x==False:
如果x==0:
如果x为False:
需要注意的是,Python确实如此不支持switch语句。
虽然声明——如果条件表达式的计算结果为True,则重复语句或语句块。它将继续重复,直到条件表达式的计算结果为False。这意味着语句应包含最终使条件表达式为False的代码。
while语句的语法如下:
而条件表达式:
语句(年代)
类中重复执行的语句虽然语句,称为循环体。如果虽然是在函数内部使用的,并且循环体包含一个return语句,循环在那里结束——就像return语句结束函数的执行一样。类似地,打破和持续语句也会影响虽然声明。
对于报表中的-允许在迭代可迭代对象的项时执行语句或语句块。目标引用访问可迭代对象的项。可迭代对象的项可以被语句使用,也可以不使用。但是iterable不应该在工党声明如虽然遍历列表、集或字典时,不应该从列表中添加或删除项。
for in语句具有以下语法:
对于iterable中的目标_引用:
语句(年代)
如果iterable是一个字典或其他数据结构,其中每个项包含多个数据值,则可以有多个目标引用以逗号分隔为语句在字典中迭代:
对于d.items()中的键值:
Print (key + ': ' + value + ' /n ')
如果必须对iterable的每个项执行一条语句以获得新的iterable,则为语句可以与赋值语句组合,如下所示:
Y = x+3 for x in range(5)
在这种语句中,表达式的执行也可以是有条件的,如下所示:
如果x%2==0,则范围(5)内x的y=x+3
类似的语句也可以用于列表、集合和字典。
Break语句,在循环体中用于终止循环。它通常与如果声明。当找到break语句时,循环结束。
以下是break语句的一些有效示例:
当x: #执行循环,如果x不为零或none
如果x < 10:
打印(x)
x + = 1
其他:
打破
当x: #执行循环,如果x不为零或none
如果x > 10:
打破
其他:
打印(x)
x + = 1
继续声明-在循环体中使用,将语句的执行留在循环的当前迭代之后。它经常和the连用如果声明。
下面是一个有效的例子:
当x≤10时:
如果x%2 == 0:继续
打印(x)
Else语句,使用一个如果,为和虽然语句。当与为或虽然,它在循环自然结束后执行语句或语句块(即在为语句的条件表达式虽然语句的值为False)。
通过声明-用于如果语句,如果对条件表达式不做任何操作。它有这样的语法:
如果conditional_expression:
语句(年代)
elif conditional_expression:
语句(年代)
elif conditional_expression:
如果满足此条件,则无需执行任何操作
其他:
语句(年代)
异常处理-Python支持尝试,除了,最后,其他的和与异常处理语句。类可以在代码中显式引发异常提升声明。当隐式或显式引发异常时,代码的正常执行会偏离,直到该异常被解决为止。
功能
函数是可调用的语句块。在Python中,函数也是对象。他们可以是:
- 赋值给引用(变量、属性和其他对象)
- 作为一项包含在可迭代对象中
- 在其他函数中用作参数
一个函数也可以返回另一个函数def语句的语法如下:
def function_name(参数):
语句(年代)
函数名是一个标识符,可用于进行函数调用。形参是在调用函数时必须提供给函数的引用。形参(或实参)是可选的,如果函数不需要提供引用,则没有理由在函数定义中包含它们。
如果有多个参数,在函数定义中应该用括号内的逗号分隔。可以有一个或多个语句在调用函数时执行。这些语句称为函数体。
在函数中可以有可选参数,这些参数在调用函数时可能提供,也可能不提供。这些可选参数由赋值表达式指定,其中可选参数被赋给默认值。
具有可选参数的函数具有以下语法:
Def function_name(parameter, optional_parameter = expression):
语句(年代)
此外,这也是具有可选参数的函数的有效示例:
def makeList (x, y = []):
y、 附加(x)
返回y
属性可以返回任何数据值或对象回来语句,该语句只能在函数体中使用。如果函数在return关键字后没有return语句、表达式、数据值或对象,则函数不返回任何对象。
非可选的参数称为位置参数。可以为函数提供任意数量的位置参数,在参数前使用前缀星号(*)或双星号(**)。
将星号(*)预固定到参数时,它接受任意数量的位置参数并将其收集到元组中。将双星号(*)预固定到参数时,它接受任意数量的位置参数并将其收集到字典中。
下面是一个在函数中接受任意数量位置参数的有效示例:
定义添加(*num)
返回和(num)
S = add(15, 20, 15) # = 50
在调用函数时提供给函数的引用称为参数。参数可以作为位置参数或命名参数提供。如果数据值/对象用作实参而不给形参引用赋值,则在函数调用中根据其在函数签名中的出现位置接受它们。(注意:函数签名是绑定到函数的参数集合)。
这些被称为位置参数。如果数据值/对象通过显式地将它们赋给参数引用而作为对象使用,那么它们在函数调用中的出现位置并不重要。这些参数称为命名参数或关键字参数。
下面是位置参数的一个有效示例:
def f(a、b、c):
返回a=b=c
F(12,17,21) #返回50
这是一个有效的(关键字)参数示例:
def f(a、b、c):
返回a=b=c
F (b = 12, a = 17, c = 21) #返回50
在Python中,可以在另一个函数中定义一个函数,这称为。在另一个函数中定义的函数称为嵌套函数,在其中定义另一个函数的函数称为外部函数。嵌套函数可以使用外部函数的参数和引用。这种嵌套函数称为闭包。
函数也可以在不同的时间返回值/对象。例如,它可以有yield或yield from语句。这样的函数称为生成器。当调用生成器时,它在第一个yield语句中返回表达式的值/对象或结果,并将所有本地引用保存在其内存中。
当再次调用该函数时,它从第一个yield语句之后的语句开始执行,并在另一个yield语句之后返回值/对象或表达式的结果。如果语句的表达式是迭代器,则可以使用yield语句。
下面是一个生成器函数的有效示例:
def f(a、b、c):
产生
收益a + b
收益a + b + c
对于f(2,5,7)中的x: print(x) #返回2,7,14
生成器使用yield from语句:
def f(a、b、c):
产量从范围(一)
范围(b)的收益率
产量从范围(c)
对于f(1, 2, 3)中的x: print(x) #返回0,1,0,1,2,0,1,2,3
Python还支持递归函数,即那些在自身内部调用自身的函数。
这是Python中一个有效的递归函数示例:
def阶乘(n):
如果n==1:返回1
否则返回n*阶乘(n-1)
参考范围
在Python中,引用可以有局部或全局作用域。这称为它们的名称空间。绑定到函数或其他对象的引用是该函数或对象的局部引用。这些引用只能在它们所绑定的函数或对象中使用。
出现在函数或其他对象之外的引用具有全局作用域。这些引用可以在代码中的任何地方使用。一个引用可以通过前缀A来实现全局引用全球的关键字。
这是一个有效的例子:
a=1
def f (b):
全球b
返回a + b
在下一个教程,我们将了解有关字节数组、列表、集合和字典的更多信息。尽管字符串、字节、范围和元组是不可变序列,但在Python中字节数组和列表只是可变序列。集合和集合最常用于无序集合。
了下:188app彩票