lambda不是python的保留字_Python3 基础

编码

默认情况下，Python 3源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。

当然你也可以为源码文件指定不同的编码：

# -*- coding:

cp-1252 -*-

标识符

第一个字符必须是字母表中字母或下划线'_'。

标识符的其他的部分有字母、数字和下划线组成。

标识符对大小写敏感。

在Python 3中，非-ASCII 标识符也是允许的了。

python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python的标准库提供了一个keyword

module，可以输出当前版本的所有关键字：

>>> import keyword

>>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert',

'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',

'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',

'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

Python中单行注释以#开头，多行注释用三个单引号（'''）或者三个双引号（"""）将注释括起来。

行与缩进

python最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在Python中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

Python 3中有六个标准的数据类型：

Numbers（数字）

String（字符串）

List（列表）

Tuple（元组）

Sets（集合）

Dictionaries（字典）

Numbers（数字）

Python 3支持int、float、bool、complex（复数）。

数值类型的赋值和计算都是很直观的，就像大多数语言一样。内置的type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j

>>> print(type(a), type(b), type(c), type(d)) <class 'int'>

float'> bool'> complex'>

数值运算：

>>> 5 + 4 # 加法 9

>>> 4.3 - 2 # 减法 2.3

>>> 3 * 7 # 乘法 21

>>> 2 / 4 # 除法，得到一个浮点数 0.5

>>> 2 // 4 # 除法，得到一个整数

0

>>> 17 % 3 # 取余 2

>>> 2 ** 5 # 乘方 32

Python 可以使用**操作来进行幂运算：

>>> 5 ** 2 # 5 的平方

25

>>> 2 ** 7 # 2的7次方

128

在交互模式中，最后被输出的表达式结果被赋值给变量 _

。这能使您在把Python作为一个桌面计算器使用时使后续计算更方便，例如：

>>> tax = 12.5 / 100

>>> price = 100.50

>>> price * tax

12.5625

>>> price + _

113.0625

>>> round(_, 2)

113.06

此处， _

变量应被用户视为只读变量。不要显式地给它赋值——这样您将会创建一个具有相同名称的独立的本地变量，并且屏蔽了这个内置变量的功能。

注意：

1、Python可以同时为多个变量赋值，如a, b = 1, 2。

2、一个变量可以通过赋值指向不同类型的对象。

3、数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。

4、在混合计算时，Python会把整型转换成为浮点数。

String（字符串）

python中单引号和双引号使用完全相同。

使用三引号('''或""")可以指定一个多行字符串。

转义符 '\'

自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n"

则\n会显示，并不是换行。

python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode

string"。

字符串是不可变的。

按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

Python中的字符串str用单引号(' ')或双引号(" ")括起来，同时使用反斜杠(\)转义特殊字符。

>>> s

= 'Yes,he doesn\'t'

>>> print(s, type(s), len(s)) Yes,he doesn't str'> 14

如果你不想让反斜杠发生转义，可以在字符串前面添加一个r，表示原始字符串：

>>> print('C:\some\name') C:\some ame

>>> print(r'C:\some\name') C:\some\name

另外，反斜杠可以作为续行符，表示下一行是上一行的延续。还可以使用"""..."""或者'''...'''跨越多行。

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复：

>>> print('str'+'ing', 'my'*3) string mymymy

Python中的字符串有两种索引方式，

第一种是从左往右，从0开始依次增加；

第二种是从右往左，从-1开始依次减少。

注意，没有单独的字符类型，一个字符就是长度为1的字符串。

>>>word='Python'>>>print(word[0],word[5])P n>>>print(word[-1],word[-6])n P

还可以对字符串进行切片，获取一段子串。用冒号分隔两个索引，形式为变量[头下标:尾下标]。

截取的范围是前闭后开的，并且两个索引都可以省略：

>>> word = 'ilovepython'

>>> word[1:5] 'love'

>>> word[:] 'ilovepython'

>>> word[5:] 'python'

>>> word[-10:-6] 'love'

与C字符串不同的是，Python字符串不能被改变。向一个索引位置赋值，比如word[0] =

'm'会导致错误。

>>> 'spam eggs'

'spam eggs'

>>> 'doesn\'t'

"doesn't"

>>> "doesn't"

"doesn't"

>>> '"Yes," he said.'

'"Yes," he

said.'

>>> "\"Yes,\" he said."

'"Yes," he

said.'

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

Python中使用反斜杠转义引号和其它特殊字符来准确地表示。

如果字符串包含有单引号但不含双引号，则字符串会用双引号括起来，否则用单引号括起来。对于这样的输入字符串，print()

函数会产生更易读的输出。

跨行的字面字符串可用以下几种方法表示。使用续行符，即在每行最后一个字符后使用反斜线来说明下一行是上一行逻辑上的延续：

以下使用 \n 来添加新行：

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

>>> print('"Isn\'t," she said.')

"Isn't," she said.

>>> s

= 'First line.\nSecond line.'

# \n

意味着新行

>>> s

# 不使用 print(), \n

包含在输出中

'First

line.\nSecond line.'

>>> print(s)

# 使用 print(), \n

输出一个新行

First line.

Second line.

以下使用 反斜线（\） 来续行：

hello = "This is a rather long string

containing\n\

several lines of text just as

you would do in C.\n\

Note that whitespace at the beginning of the line

is\

significant."

print(hello)

注意，其中的换行符仍然要使用 \n 表示——反斜杠后的换行符被丢弃了。以上例子将如下输出：

This is a rather long string containing

several lines of text just as you would do in C.

Note that whitespace at the beginning of the line is significant.

或者，字符串可以被 """ （三个双引号）或者 '''

（三个单引号）括起来。使用三引号时，换行符不需要转义，它们会包含在字符串中。以下的例子使用了一个转义符，避免在最开始产生一个不需要的空行。

print("""\

Usage: thingy

[OPTIONS]

-h Display this usage message

-H hostname Hostname

to connect to

""")

结果：

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

如果我们使用"原始"字符串，那么 \n

不会被转换成换行，行末的的反斜杠，以及源码中的换行符，都将作为数据包含在字符串内。例如：

hello = r"This is a rather long string

containing\n\

several lines of text much as

you would do in C."

print(hello)

结果：

This is a rather long string containing\n\

several lines of text much as you would do in C.

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复：

>>> word = 'Help' + 'A'

>>> word

'HelpA'

>>> '<' + word*5 + '>'

''

两个紧邻的字面字符串将自动被串连；上例的第一行也可以写成 word = 'Help' 'A'

；这样的操作只在两个字面值间有效，不能随意用于字符串表达式中：

>>> 'str' 'ing' #

<- 这样操作正确

'string'

>>> 'str'.strip() + 'ing' #

<- 这样操作正确

'string'

>>> 'str'.strip() 'ing' #

<- 这样操作错误

File

"", line 1, in ?

'str'.strip() 'ing'

^

SyntaxError: invalid syntax

对于有偏差的分切索引的处理方式也很优雅：一个过大的索引将被字符串的大小取代，上限值小于下限值将返回一个空字符串。

>>> word[1:100]

'elpA'

>>> word[10:]

>>> word[2:1]

超出范围的负数索引会被截去多余部分，但不要尝试在一个单元素索引（非分切索引）里使用：

注意：

1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。

2、字符串可以用+运算符连接在一起，用*运算符重复。

3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

4、Python中的字符串不能改变。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同：

>>> a = ['him', 25, 100, 'her']

>>> print(a) ['him', 25, 100, 'her']

和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。详细的在这里就不赘述了。

列表还支持串联操作，使用+操作符：

>>> a = [1, 2, 3, 4, 5]

>>> a + [6, 7, 8]

[1, 2, 3, 4, 5, 6, 7, 8]

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]

>>> a[0] = 9

>>> a[2:5] = [13, 14, 15]

>>> a [9, 2, 13, 14, 15, 6]

>>> a[2:5] = []

#

删除

>>> a [9, 2, 6]

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

1、List写在方括号之间，元素用逗号隔开。

2、和字符串一样，list可以被索引和切片。

3、List可以使用+操作符进行拼接。

4、List中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

>>> a = (1991, 2014, 'physics', 'math')

>>> print(a, type(a), len(a))

(1991, 2014, 'physics', 'math') <class 'tuple'>

4

元组与字符串类似，可以被索引且下标索引从0开始，也可以进行截取/切片（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

>>> tup = (1, 2, 3, 4, 5, 6)

>>> print(tup[0], tup[1:5])

1 (2, 3, 4, 5)

>>> tup[0] = 11

#

修改元组元素的操作是非法的

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含0个或1个元素的tuple是个特殊的问题，所以有一些额外的语法规则：

tup1=()# 空元组tup2=(20,)# 一个元素，需要在元素后添加逗号

另外，元组也支持用+操作符：

>>> tup1, tup2 = (1, 2, 3), (4, 5, 6)

>>> print(tup1+tup2) (1, 2, 3, 4, 5, 6)

string、list和tuple都属于sequence（序列）。

注意：

1、与字符串一样，元组的元素不能修改。

2、元组也可以被索引和切片，方法一样。

3、注意构造包含0或1个元素的元组的特殊语法规则。

4、元组也可以使用+操作符进行拼接。

Sets（集合）

集合（set）是一个无序不重复元素的集。

基本功能是进行成员关系测试和消除重复元素。

可以使用大括号 或者 set()函数创建set集合，注意：创建一个空集合必须用 set() 而不是 {

}，因为{ }是用来创建一个空字典。

>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

>>> print(student)

#

重复的元素被自动去掉 {'Jim', 'Jack', 'Mary', 'Tom', 'Rose'}

>>> 'Rose' in student

#

membership testing（成员测试） True

>>> # set可以进行集合运算

...

>>> a = set('abracadabra')

>>> b

= set('alacazam')

>>> a {'a', 'b', 'c', 'd', 'r'}

>>> a - b # a和b的差集 {'b',

'd', 'r'}

>>> a | b # a和b的并集 {'l',

'm', 'a', 'b', 'c', 'd', 'z', 'r'}

>>> a & b # a和b的交集 {'a',

'c'}

>>> a ^ b # a和b中不同时存在的元素

{'l', 'm', 'b', 'd', 'z', 'r'}

Dictionaries（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

字典是一种映射类型（mapping type），它是一个无序的键 : 值对集合。

关键字必须使用不可变类型，也就是说list和包含可变类型的tuple不能做关键字。

在同一个字典中，关键字还必须互不相同。

>>> dic = {} #

创建空字典

>>> tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}

>>> tel {'Tom': 1320, 'Jack': 1557, 'Rose': 1886}

>>> tel['Jack'] # 主要的操作：通过key查询

1557

>>> del tel['Rose']#

删除一个键值对

>>> tel['Mary'] = 4127#

添加一个键值对

>>> tel {'Tom': 1320, 'Jack': 1557, 'Mary': 4127}

>>> list(tel.keys()) # 返回所有key组成的list

['Tom', 'Jack', 'Mary']

>>> sorted(tel.keys())

#

按key排序 ['Jack', 'Mary', 'Tom']

>>> 'Tom' in tel # 成员测试

True

>>> 'Mary' not in tel # 成员测试

False

构造函数 dict() 直接从键值对sequence中构建字典，当然也可以进行推导，如下：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

{'jack': 4098, 'sape': 4139, 'guido': 4127}

>>> {x: x**2 for x in (2, 4, 6)}#推导

{2: 4, 4: 16, 6: 36}

>>> dict(sape=4139, guido=4127, jack=4098)

{'jack': 4098, 'sape': 4139, 'guido': 4127}

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

1、字典是一种映射类型，它的元素是键值对。

2、字典的关键字必须为不可变类型，且不能重复。

3、创建空字典使用{ }。

Python 条件控制

if

if-else

if – elif – else。

没有switch – case语句

Python 循环

while 循环

for语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:

<statements>

else:

<statements>

Python loop循环实例：

>>> languages = ["C", "C++", "Perl", "Python"]

>>> for x in languages:

... print x

...

C

C++

Perl

Python

>>>

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>> for i in range(5):

... print(i)

...

0

1

2

3

4

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数;有时这也叫'步长'):

>>> for i in range(0, 10, 3) :

print(i)

0

3

6

9

>>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

>>> for i in range(len(a)):

... print(i, a[i])

...

0 Mary

1 had

2 a

3 little

4 lamb

还可以使用range()函数来创建一个列表：

>>> list(range(5))

[0, 1, 2, 3, 4]

>>>

循环语句可以有else子句;它在穷尽列表(以for循环)或条件变为假(以while循环)循环终止时被执行,但循环被break终止时不执行.如下查寻质数的循环例子:

>>> for n in range(2, 10):

... for

x in range(2, n):

... if n % x == 0:

... print(n, 'equals', x, '*', n//x)

... break

... else:

... #

循环中没有找到元素

... print(n, 'is a prime number')

...

2 is a prime number

3 is a prime number

4 equals 2 * 2

5 is a prime number

6 equals 2 * 3

7 is a prime number

8 equals 2 * 4

9 equals 3 * 3

pass语句

pass语句什么都不做。它只在语法上需要一条语句但程序不需要任何操作时使用.例如:

>>> while True:

... pass

# 等待键盘中断

(Ctrl+C)

Python 函数

def

函数名（参数列表）：

函数体

函数变量作用域

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

关键字参数

函数也可以使用 kwarg=value 的关键字参数形式被调用

parrot(1000) # 1 positional

argument

parrot(voltage=1000) # 1 keyword

argument

parrot(voltage=1000000, action='VOOOOOM') # 2 keyword

arguments

parrot(action='VOOOOOM', voltage=1000000) # 2 keyword

arguments

parrot('a million', 'bereft of life', 'jump') # 3

positional arguments

parrot('a thousand', state='pushing up the daisies')

# 1 positional, 1

keyword

以下为错误调用方法：

parrot()

# required

argument missing

parrot(voltage=5.0, 'dead')

# non-keyword

argument after a keyword argument

parrot(110, voltage=220) # duplicate value

for the same argument

parrot(actor='John Cleese')

# unknown keyword

argument

可变参数列表

最后,一个最不常用的选择是可以让函数调用可变个数的参数.这些参数被包装进一个元组(查看元组和序列).在这些可变个数的参数之前,可以有零到多个普通的参数:

def arithmetic_mean(*args):

sum = 0

for x in args:

sum

+= x

return sum

print(arithmetic_mean(45,32,89,78))

print(arithmetic_mean(8989.8,78787.78,3453,78778.73))

print(arithmetic_mean(45,32))

print(arithmetic_mean(45))

print(arithmetic_mean())

以上实例输出结果为：

244

170009.31

77

45

0

按值传递参数和按引用传递参数

所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:表达式

#!/usr/bin/python

# -*-

coding: UTF-8 -*-

#

可写函数说明

sum = lambda arg1, arg2: arg1 + arg2;

#

调用sum函数

print "相加后的值为 : ", sum( 10, 20 )

print "相加后的值为 : ", sum( 20, 20 )