默认情况下,Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。
标识符:第一个字符必须是字母或下划线,其他的部分由字母、数字和下划线组成,对大小写敏感。
注释:Python中单行注释以 # 开头,多行注释可以用多个 # 号,还有 ‘’’ 和 “”"。
python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {} ,语句末尾不需要分号;。同一行显示多条语句之间使用分号(;)分割。
可以使用反斜杠()来实现多行语句。在 [], {}, 或 () 中的多行语句,不需要使用反斜杠()。
total = item_one + \
item_two + \
item_three
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']
数字(Number)类型有四种类型:整数、布尔型、浮点数和复数。
int (整数), 如 1, 只有一种整数类型 int,表示为长整型
bool (布尔), 如 True。
float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j
字符串(String):单引号和双引号使用完全相同。
使用三引号(’’'或""")可以指定一个多行字符串。
转义符 ‘’
反斜杠可以用来转义,使用r可以让反斜杠不发生转义( raw string)。 如 r"this is a line with \n" 则\n会显示,并不是换行。
按字面意义级联字符串,如"this " "is " "string"会被自动转换为this is string。
字符串可以用 + 运算符连接在一起,用 * 运算符重复。
Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
Python中的字符串不能改变。
Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始的后的所有字符
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一个 r,表示原始字符串,不会发生转义
空行与代码缩进不同,空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
像if、while、def和class这样的复合语句,首行以关键字开始,以**冒号( : )**结束
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end="":
# 不换行输出
print( x, end=" " )
用 import 或者 from…import 来导入相应的模块
将整个模块(somemodule)导入,格式为: import somemodule
从某个模块中导入某个函数,格式为: from somemodule import somefunction
从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入,格式为: from somemodule import *
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
变量就是变量,没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
#!/usr/bin/python3
# 变量不需要声明,直接赋值
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
print (counter)
print (miles)
print (name)
标准数据类型有六个:Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)。
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。
Number(数字):支持 int、float、bool、complex(复数)。只有一种整数类型 int,表示为长整型。内置的 type() 函数可以用来查询变量所指的对象类型。也可以用 isinstance 来判断。
通过使用del语句删除单个或多个对象
del var
del var_a, var_b
Python可以同时为多个变量赋值,如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符:/ 返回一个浮点数,// 返回一个整数。
4、在混合计算时,Python会把整型转换成为浮点数。
字符串用单引号 ’ 或双引号 " 括起来,用反斜杠 \ 转义特殊字符,两种索引方式,从左往右以0开始,从右往左以-1开始。
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm’会导致错误。
List(列表)列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
列表被截取后返回一个包含所需元素的新列表。加号 + 是列表连接运算符,星号 * 是重复操作。
和字符串一样,list可以被索引和切片;List可以使用+操作符进行拼接;List中的元素是可以改变的。
列表截取可以接收第三个参数,参数作用是截取的步长,如果第三个参数为负数表示逆向读取,用于翻转字符串。
def reverseWords(input):
# 通过空格将字符串分隔符,把各个单词分隔为列表
inputWords = input.split(" ")
# 翻转字符串
# 假设列表 list = [1,2,3,4],
# list[0]=1, list[1]=2 ,而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空,表示移动到列表末尾
# 第三个参数为步长,-1 表示逆向
inputWords=inputWords[-1::-1]
# 重新组合字符串
output = ' '.join(inputWords)
return output
if __name__ == "__main__":
input = 'I like runoob'
rw = reverseWords(input)
print(rw)
Tuple(元组):元组的元素不能修改,元组写在小括号 () 里,元素之间用逗号隔开。元组中的元素类型也可以不相同。元组也可以被索引和切片,方法一样。元组也可以使用+操作符进行拼接。
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
>>> tup[0] = 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):
File "" , line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
Set(集合):基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合。创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合,重复的元素被自动去掉
# 成员测试
if 'Rose' in student :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
输出结果:
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
Dictionary(字典)列表是有序的对象集合,字典是无序的对象集合。区别在于:字典当中的元素是通过键来存取的。**字典用 { } 标识,**它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型(数学/字符串/元组),在同一个字典中,键(key)必须是唯一的。
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 教程"
dict[2] = "2 - 工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
输出结果:
1 - 教程
2 - 工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site']) //
dict_values(['runoob', 1, 'www.runoob.com']) //列表
#构造函数 dict() 可以直接从键值对序列中构建字典
>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
数据类型的转换,只需要将数据类型作为函数名即可。函数返回一个新的对象,表示转换的值。
long(x, base=10) #将数字或字符串转换为一个长整型,base进制数默认十进制
>>> long(1)
1L
>>> long('123')
123L
int(x, base=10) #将一个字符串或数字转换为整型。
>>>complex(1, 2) #创建一个复数
(1 + 2j)
float(x) #将x转换到一个浮点数
str(x) #将对象 x 转换为字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
>>>x = 7
>>> eval( '3 * x' )
21
tuple(s) #将序列 s 转换为一个元组
list(s) # 将序列 s 转换为一个列表
set(s) #转换为可变集合
dict(d) #创建一个字典。d 必须是一个序列 (key,value)元组。
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串
repr(x) #将对象 x 转换为表达式字符串
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
// 取整除 - 返回商的整数部分(向下取整)
算术运算符、比较运算符、赋值运算符(幂赋值运算符 c = c ** a)、位运算符、逻辑运算符(and、or、not)、成员运算符(in、not in)、身份运算符(is 、is not)。
数学常量:pi 数学常量 pi(圆周率,一般以π来表示);e 数学常量 e,e即自然常数(自然常数)。
[ : ]截取字符串中的一部分,遵循左闭右开原则,str[0,2] 是不包含第 3 个字符的。
Python字符串格式化,格式符 %s 。
%c 格式化字符及其ASCII码
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g %f和%e的简写
%p 用十六进制数格式化变量的地址
使用 del 语句来删除列表的的元素、列表**+ 号用于组合列表,* 号用于重复列表**。len([1, 2, 3]) 长度
列表截取与拼接、嵌套列表、
#列表函数&方法
len(list) #列表元素个数
max(list) #返回列表元素最大值
list(seq) #将元组转换为列表
min(list) #返回列表元素最小值
list.append(obj) #在列表末尾添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) #从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj) #将对象插入列表
list.pop([index=-1]) #移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj) #移除列表中某个值的第一个匹配项
list.reverse() #反向列表中元素
list.sort( key=None, reverse=False) #对原列表进行排序
list.clear() #清空列表
list.copy() #复制列表
元组创建
>>> tup3 = "a", "b", "c", "d"; # 不需要括号也可以
tup1 = (); #创建空元组
>>>tup1 = (50)
>>> type(tup1) # 不加逗号,类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号,类型为元组
<class 'tuple'>
#元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
del tup
#元组索引,截取
tuple(seq) #将列表转换为元组。
min(tuple) #返回元组中元素最小值。
max(tuple) #返回元组中元素最大值。
len(tuple) #计算元组元素个数。
字典是另一种可变容器模型,且可存储任意类型对象。
#向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新 Age
dict['School'] = "菜鸟教程" # 添加信息
#能删单一的元素也能清空字典,清空只需一项操作
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
#不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
str(dict) #输出字典,以可打印的字符串表示。
type(variable) #返回输入的变量类型,如果变量是字典就返回字典类型。
集合(set)是一个无序的不重复元素序列。创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
s.add( x ) #集合的基本操作:添加元素
s.update( x ) #也可以添加元素,且参数可以是列表,元组,字典等
s.remove( x ) #移除元素
s.discard( x ) #也是移除集合中的元素,且如果元素不存在,不会发生错误
s.pop() #随机删除集合中的一个元素
len(s) #计算集合元素个数
s.clear() #清空集合
x in s #判断元素是否在集合中存在
end 关键字关键字end可以用于将结果输出到同一行,或者在输出的末尾添加不同的字符。
if 语句if 嵌套
Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else。
1.每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句
循环语句:循环语句有 for 和 while。
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
无限循环
var = 1
while var == 1 : # 表达式永远为 true,通过设置条件表达式永远不为 false 来实现无限循环
num = int(input("输入一个数字 :"))
print ("你输入的数字是: ", num)
print ("Good bye!")
CTRL+C 来退出当前的无限循环
#while 循环使用 else 语句
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
简单语句组
flag = 1
while (flag): print ('欢迎!')
print ("Good bye!")
for循环可以遍历任何序列的项目,如一个列表或者一个字符串
for <variable> in <sequence>:
<statements>
else:
<statements>
使用了 break 语句,break 语句用于跳出当前循环体
range()函数遍历数字序列
>>>for i in range(5):
... print(i) #print()函数内置默认转行,可以用end来....
...
0
1
2
3
4
使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做'步长'):
结合range()和len()函数以遍历一个序列的索引
>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>
使用range()函数来创建一个列表
>>>list(range(5))
[0, 1, 2, 3, 4]
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止,任何对应的循环 else 块将不执行。
continue语句被用来告诉Python跳过当前循环块中的剩余语句,然后继续进行下一轮循环。
循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
pass 语句是空语句,为了保持程序结构的完整性
迭代是Python最强大的功能之一,是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法:iter() 和 next()。
字符串,列表或元组对象都可用于创建迭代器
>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1
>>> print (next(it))
2
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")
创建一个迭代器
把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
面向对象编程中类都有一个构造函数,Python 的构造函数为 init(), 它会在对象初始化的时候执行。
iter() 方法返回一个特殊的迭代器对象, 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 方法会返回下一个迭代器对象。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
StopIteration 异常用于标识迭代的完成,防止出现无限循环的情况,在 __next__() 方法可以设置**在完成指定循环次数**后**触发 StopIteration 异常**来结束迭代。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
使用了 yield 的函数被称为生成器(generator)
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器,由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
执行以上程序,输出结果如下:
0 1 1 2 3 5 8 13 21 34 55
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def 函数名(参数列表):
函数体
strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 中一切都是对象
调用函数时可使用的正式参数类型:
必需参数:以正确的顺序传入函数,调用时的数量必须和声明时的一样
关键字参数:允许函数调用时参数的顺序与声明时不一致
默认参数:如果没有传递参数,则会使用默认参数
不定长参数:可能需要一个函数能处理比当初声明时更多的参数
def functionname([formal_args,] *var_args_tuple )://加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数
"函数_文档字符串"
function_suite
return [expression]
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
//如果在函数调用时没有指定参数,它就是一个空元组。也可以不向函数传递未命名的变量
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
#参数带两个星号 **基本语法,加了两个星号 ** 的参数会以字典的形式导入。
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)
输出:
1
{'a': 2, 'b': 3}
声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入。
匿名函数: lambda 来创建匿名函数,lambda 只是一个表达式,函数体比 def 简单很多,lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda [arg1 [,arg2,.....argn]]:expression
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
return语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
变量作用域决定了在哪一部分程序可以访问哪个特定的变量名称。
L (Local) 局部作用域
E (Enclosing) 闭包函数外的函数中
G (Global) 全局作用域
B (Built-in) 内置作用域(内置函数所在模块的范围)
在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内置中找。
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
内置作用域是通过一个名为 builtin 的标准模块来实现的,但是这个变量名自身并没有放入内置作用域内,所以必须导入这个文件才能够使用它。
Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域。
如果将 msg 定义在函数中,则它就是局部变量,外部不能访问
>>> def test():
... msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "" , line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>
说明了 msg_inner 未定义,无法使用,因为它是局部变量,只有在函数内可以使用。
全局变量和局部变量
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)#改为sum( 10, 20 )
输出结果:
函数内是局部变量 : 30
函数外是全局变量 : 0
global 和 nonlocal关键字:内部作用域想修改外部作用域的变量;修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
输出结果:
1
123
123
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
输出结果:
100
100
a = 10
def test():
a = a + 1
print(a)
test()
以上程序执行,报错信息如下:
Traceback (most recent call last):
File "test.py", line 7, in <module>
test()
File "test.py", line 5, in test
a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment
因为 test 函数中的 a 使用的是局部,未定义,无法修改
a = 10
def test(a):
a = a + 1
print(a)
test(a)
执行输出结果为:
11
将列表当做堆栈使用,堆栈作为特定的数据结构,最先进入的元素最后一个被释放(后进先出)。
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
将列表当作队列使用在队列里第一加入的元素,第一个取出来;但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
列表推导式
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
嵌套列表解析
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
del 语句
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
>>> del a
字典推导
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
构造函数 dict() 直接从键值对元组列表中构建字典
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
遍历技巧
在字典中遍历时,关键字和对应的值可以使用 items() 方法同时解读出来
在序列中遍历时,索引位置和对应值可以使用 enumerate() 函数同时得到
同时遍历两个或更多的序列,可以使用 zip() 组合
要反向遍历一个序列,首先指定这个序列,然后调用 reversed() 函数
要按顺序遍历一个序列,使用 sorted() 函数返回一个已排序的序列,并不修改原值
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear