python3.0编程总结一:基础语法、标准数据类型(数字/字符串/列表/元组/集合/字典)、类型转换、迭代器与生成器、函数

基础语法

默认情况下,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'}"

Python 运算符

// 取整除 - 返回商的整数部分(向下取整)
算术运算符、比较运算符、赋值运算符(幂赋值运算符 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 语句可以跳出 forwhile 的循环体。如果你从 forwhile 循环中终止,任何对应的循环 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

你可能感兴趣的:(Python程序设计)