1.4.5. Python中的序列
列表
list 是处理一组有序项目的数据结构， 即你可以在一个列表中存储一个序列的项目。 假想你有一个购物列表， 上面记载着你要买的东西，你就容易理解列表了。 只不过在你的购物表上， 可能每样东西都独自占有一行， 而在Python中， 你在每个项目之间用逗号分割。
列表中的项目应该包括在方括号中， 这样Python就知道你是在指明一个列表。 一旦你创建了一个列表， 你可以添加、删除或是搜索列表中的项目。 由于你可以增加或删除项目， 我们说列表是 可变的 数据类型， 即这种类型是可以被改变的。
注意， 列表与数组不同（尽管都是在方括号中）。 Python的列表中可以存储不同的数据类型：
>>> list_val = [1, '3', 5 ,'4']
python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val = range(5,0, -1) >>> print(list_val) range(5, 0, -1)
list() 函数是对象迭代器，把对象转为一个列表。返回的变量类型为列表。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val = list(range(5,0, -1)) >>> print(list_val) [5, 4, 3, 2, 1]
append() 方法用于在列表末尾添加新的对象。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val.append(6) >>> print(list_val) [1, '3', 5, '4', 6] >>> list_val = [1, '3', 5 ,'4'] >>> list_val = list_val + [7,8] >>> print(list_val) [1, '3', 5, '4', 7, 8]
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
>>> list_val = [1, '3', 5 ,'4'] >>> list_val.extend([9, 10]) >>> list_val [1, '3', 5, '4', 9, 10]
insert() 函数用于将指定对象插入列表的指定位置。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val.insert(7, 6) >>> print(list_val) [1, '3', 5, '4', 6]
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
>>> list_val = [1, '3', 5 ,'4'] >>> tep_a = list_val.pop() >>> print(list_val) >>> print(tep_a) [1, '3', 5] 4 >>> list_val = [1, '3', 5 ,'4'] >>> tep_a = list_val.pop(3) >>> print(list_val) >>> print(tep_a) [1, '3', 5] 4
Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
>>> list_val = [1, '3', 5 ,'4','3'] >>> val_index = list_val.index('4') >>> print(list_val) >>> print(val_index) [1, '3', 5, '4', '3'] 3
remove() 函数用于移除列表中某个值的第一个匹配项。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val.remove('3') >>> print(list_val) [1, 5, '4'] >>> list_val = [1, '3', 5 ,'4'] >>> for val in list_val: >>> print(val) 1 3 5 4 >>> list_val = [1, '3', 5 ,'4'] >>> print(len(list_val)) 4
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
>>> list_val = ['1', '3', '5' ,'4'] >>> list_val.sort() >>> print(list_val) ['1', '3', '4', '5']
reverse() 函数用于反向列表中元素。
>>> list_val = [1, '3', 5 ,'4'] >>> list_val.reverse() >>> print(list_val) ['4', 5, '3', 1]
元组
元组和列表十分类似， 只不过元组和字符串一样是 不可变的 即你不能修改元组。 元组通过圆括号中用逗号分割的项目定义。 元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候， 即被使用的元组的值不会改变。
元组和列表可以进行转换：
>>> a = range(8) >>> print(a) >>> b = tuple(a) >>> print(b) >>> c = list(b) >>> print(c) range(0, 8) (0, 1, 2, 3, 4, 5, 6, 7) [0, 1, 2, 3, 4, 5, 6, 7]
序列
列表、元组和字符串都是序列， 但是序列是什么， 它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。 索引操作符让我们可以从序列中抓取一个特定项目。 切片操作符让我们能够获取序列的一个切片， 即一部分序列。
下面例子以列表为例， 但对于元组、字符串也都是适用的。
>>> list_val = range(8,0, -1) >>> print(list_val) >>> index_list = range(8) >>> for index in index_list: >>> print(' Index: %d'%(index)) >>> print(list_val[index]) >>> print(list_val[-1]) >>> print(list_val[-2]) >>> print(list_val[2:]) >>> print(list_val[:-2]) >>> print(list_val[2:-2]) >>> print(list_val[:]) range(8, 0, -1) Index: 0 8 Index: 1 7 Index: 2 6 Index: 3 5 Index: 4 4 Index: 5 3 Index: 6 2 Index: 7 1 1 2 range(6, 0, -1) range(8, 2, -1) range(6, 2, -1) range(8, 0, -1)
字符串处理
字符串的基本操作
Python字符串：一个有序的字符集合， 用来存储和表现基于文本的信息。 用于表示和存储文本， 是单个字符的序列, 符合序列操作。 python中字符串是不可变的， 一旦声明， 不能改变。 通常由单引号(’ )， 双引号(“ )， 三引号(”’ ”“”)包围,其中单引号和双引号可互换,三引号可以由多行组成。 三引号， 多行字符串块， 编写多行文本的快捷语法， 常用语文档字符串， 在文件的特定地点， 被当做注释。
字符是非常常用的类型。 下面是基本的用法。 还有更多的关于字符串的类库， 如string， 以及正则表达式。
>>> path = r'e:\book' >>> >>> print(path) e:book >>> print('** \n\t"\r **') ** ** 转义符 >>> >>> len(path) 7 长度 >>> str_val = 's ' + 'pam' >>> print(str_val) >>> str_val = 's ' 'pam' >>> print(str_val) s pam s pam
连接’s ’ + ‘pam’ 或 ‘s’‘pam’ 建议使用前者，可读性
>>> print('=' * 10) ========== 重复输出 >>> print('abc'+str(9)) abc9
Python不允许在+表达式中出现其他类型，需要手工转换：
>>> val = int('42') >>> print(val) >>> val =str(42) >>> print(val) >>> val = float('42.0') >>> print(val) 42 42 42.0
字符串转换
>>> print(ord('s')) #转ASCII >>> print(type(ord('s'))) #转ASCII >>> print(chr(115)) #转字符 >>> print(type(chr(115))) 115 <class 'int'> s <class 'str'>
转换ASCII与字符
>>> s='spam' >>> k = '|'.join(s) >>> print(k) >>> s='spam' >>> l = list(s) >>> print(l) >>> k = '|'.join(l) >>> print(k) s|p|a|m ['s', 'p', 'a', 'm'] s|p|a|m
合并与分割
>>> s = s+'a' >>> s = s[3:] + 'b' >>> s = s.replace('pl','pa')
字符串无法进行修改，但可以通过重新赋值的方法变通
>>> s = 'abcdefg' >>> print(s[1:]) >>> print(s[1:-1]) bcdefg bcdef
字符串的索引和切片，前面刚讲过
>>> >>> str_val = 'abcd' >>> str_val = str_val.capitalize() >>> print(str_val) Abcd
字符串第一个字符大写
>>> str_val = str_val.lower() >>> print(str_val) abcd
全变小写
>>> print(str_val.isalpha()) >>> print(str_val.isdigit()) True False
isxxx 函数。更多请找参考手册
>>> >>> str_val = ' abcdfgxabcdyzcdba ' >>> str_val = str_val.strip() >>> print(str_val) >>> str_val = str_val.strip('a') >>> print(str_val) abcdfgxabcdyzcdba bcdfgxabcdyzcdb
去掉字符
>>> >>> tepstr = str_val >>> str_val = str_val.strip('bc') >>> print(str_val) >>> str_val = tepstr.strip('cb') >>> print(str_val) dfgxabcdyzcd dfgxabcdyzcd >>> >>> str_val = list(str_val) >>> str_val.sort() >>> str_val = ''.join(str_val) >>> print(str_val) abccdddfgxyz
字符串排序
>>> >>> str_val = str_val.upper() >>> print(str_val) ABCCDDDFGXYZ
全部大写
>>> >>> ind_list = range(5, 15) >>> ind_list = [str(x) for x in ind_list] >>> print(ind_list) >>> str_list = [ind.zfill(3) for ind in ind_list] >>> print(str_list) >>> ''' 格式化输出 ： >>> %c 单个字符 >>> %d 十进制整数 >>> %o 八进制整数 >>> %s 字符串 >>> %x 十六进制整数， >>> 其中字母小写 >>> %X 十六进制整数， >>> 其中字母大写 >>> ''' >>> str_val = 'The are %d %s in the team.' % (2, 'girls') >>> print(str_val) ['5', '6', '7', '8', '9', '10', '11', '12', '13', '14'] ['005', '006', '007', '008', '009', '010', '011', '012', '013', '014'] The are 2 girls in the team.
返回长度width的字符串，原字符串右对齐，前面填充0
像元组一样看待字符串
字符串具备很多元组的特征。 字符串与元组不同的是， 字符串内部的各个成员都是字符。
>>> str_val = 'Hello, Python!' >>> print(len(str_val)) 14 print(len(str_val)) 输出字符串长度。 >>> print(str_val.index('P')) 7
输出字符P的位置
>>> for x in str_val: >>> print(x) H e l l o , P y t h o n !
循环输出字符串的内容。
字典
字典数据结构可以理解为自然语言中的“字典”， 这种数据结构可以通过检索的文字， 来查找相关的内容。 也可以理解为通过联系人名字查找地址和联系人详细情况的地址簿， 即， 我们把键（名字）和值（详细情况）联系在一起。
注意， 键必须是唯一的， 就像如果有两个人恰巧同名的话， 你无法找到正确的信息。 当然可以再通过其它方法来变通。
更专业一点讲， 字典就是一个关联数组(或称为哈希表)。 它是一个通过关键字索引的对象的集合。 使用大括号来创建一个字典。
注意它们的键/值对用冒号分割， 而各个对用逗号分割， 所有这些都包括在花括号中。
尽管字符串是最常见的 关键字(key)类型， 你还是可以使用很多其它的 python对象做为字典的关键字， 比如 数字 和tuple， 只要是不可修改对象， 都可以用来做字典的key。
有些对象， 例如列表和字典， 不可以用来做字典的关键词， 因为他们的内容是允许更改的。
字典中的键/值对是没有顺序的。 如果你想要一个特定的顺序， 那么你应该在使用前自己对它们排序。
>>> dict_demo = {'GIS': 'Geographic Information System', >>> 'RS': 'Remote Sencing', >>> 'GPS': 'Global Positioning System', >>> 'DEM': 'Dynamic Effect Model'} >>> print(dict_demo['GPS']) >>> print(dict_demo['DEM']) >>> print(dict_demo.items()) >>> dict_demo['DEM'] = 'Digital Elevation Model' >>> print(dict_demo['DEM']) Global Positioning System Dynamic Effect Model dict_items([('GIS', 'Geographic Information System'), ('RS', 'Remote Sencing'), ('GPS', 'Global Positioning System'), ('DEM', 'Dynamic Effect Model')]) Digital Elevation Model
上面定义了字典， 并且说明了怎样引用。
下面我们继续来看一下字典的一些常用方法：
>>> print( 'RS' in dict_demo) >>> print( 'rs' in dict_demo) >>> dict_demo['rs'] = 'Remote Sencing' >>> print(dict_demo.keys()) >>> del(dict_demo['rs']) >>> dict_demo.keys() >>> for short_name, long_name in dict_demo.items(): >>> print(('Short Name: %4s -> Long Name: %s') % (short_name, long_name)) True False dict_keys(['GIS', 'RS', 'GPS', 'DEM', 'rs']) Short Name: GIS -> Long Name: Geographic Information System Short Name: RS -> Long Name: Remote Sencing Short Name: GPS -> Long Name: Global Positioning System Short Name: DEM -> Long Name: Digital Elevation Model
1.4.6. 函数
函数概述
函数是重要的程序段。 它允许你给一块语句一个名称， 然后你可以在你的程序的任何地方使用这个名称任意多次地运行这个语句块。 这被称为调用函数。
函数通过 def 关键字定义。 def 关键字后跟一个函数的标识符名称， 然后跟一对圆括号。 圆括号之中可以包括一些变量名， 该行以冒号结尾。 接下来是一块语句， 它们是函数体。
>>> def sayHello(): >>> print('Hello World!') >>> sayHello() Hello World!
def sayHello() 通过def关键字定义sayHello函数。并且带有语句。
上面的函数打印了一些字符；但有时， 函数若有返回值会更有用。 如给定了半径， 得到圆的面积， 可以在以后使用。
>>> import math >>> def get_circle_area(r): >>> area = math.pi * r * r >>> return(area) >>> val_r = 3 >>> the_area = get_circle_area(val_r) >>> print(the_area) 28.274333882308138
return(area) 返回area的值。
注意， 所有的 Python函数都有返回值。 没有显式声明 return 语句的函数等价于 return None。 None 是Python中表示没有任何东西的特殊类型，如果一个变量的值为 None ， 表示它没有值。 除非你提供你自己的return语句， 每个函数都在结尾暗含有return None语句。
函数取得的参数是你提供给函数的值， 这样函数就可以利用这些值做一些事情。 这些参数就像变量一样， 只不过它们的值是在我们调用函数的时候定义的， 而非在函数本身内赋值。
参数在函数定义的圆括号对内指定， 用逗号分割。 当我们调用函数的时候， 我们以同样的方式提供值。 注意我们使用过的术语——函数中的参数名称为形参， 而你提供给函数调用的值称为实参 。
变量作用域
当你在函数定义内声明变量的时候， 它们与函数外具有相同名称的其他变量没有任何关系， 即变量名称对于函数来说是 局部 的。 这称为变量的 作用域 。 所有变量的作用域是它们被定义的块， 从它们的名称被定义的那点开始。
>>> def func(x): >>> print ('x is', x) >>> x = 2 >>> print ('Changed local x to', x) >>> x = 50 >>> func(x) >>> print ('x is still', x) x is 50 Changed local x to 2 x is still 50
函数func(x) 中的x对于func（）是局部的。
如果你想要为一个定义在函数外的变量赋值， 那么你就得告诉Python这个变量名不是局部的， 而是 全局 的。 我们使用global语句完成这一功能。 没有global语句， 是不可能为定义在函数外的变量赋值的。
因为全局变量会带来很多问题，所有在写代码的过程中， 一定避免使用这一功能。
使用参数的默认值
对于一些函数， 你可能希望它的一些参数是 可选 的， 如果用户不想要为这些参数提供值的话， 这些参数就使用默认值。 这个功能借助于默认参数值完成。 你可以在函数定义的形参名后加上赋值运算符（=）和默认值， 从而给形参指定默认参数值。
注意， 默认参数值应该是一个参数。 更加准确的说， 默认参数值应该是不可变的。
>>> def say(message, times = 1): >>> print (message * times) >>> say('Hello') >>> say('World', 5) Hello WorldWorldWorldWorldWorld
注意:若函数定义处 times参数没有默认值， 则say(’Hello’)会出错。
关键字参数
如果你的某个函数有许多参数， 而你只想指定其中的一部分， 那么你可以通过命名来为这些参数赋值——这被称作 关键参数字 ——我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。
这样做有两个优势，一、我们不必担心参数的顺序， 使用函数变得更加简单了。 二、假设其他参数都有默认值， 我们可以只给我们想要的那些参数赋值。
>>> def func(a, b=5, c=10): >>> print ('a is', a, 'and b is', b, 'and c is', c) >>> func(3, 7) >>> func(25, c=24) >>> func(c=50, a=100) a is 3 and b is 7 and c is 10 a is 25 and b is 5 and c is 24 a is 100 and b is 5 and c is 50
当非关键字可变长参数和关键字可变长参数出现在同一个函数中时，他们应当遵守如下的顺序约定：
>>> def newfoo(normal_arg1, normal_arg2, *argv, ** keywords): >>> pass
当然，你也可以直接向函数中传入元组和字典对象，如：
>>> newfoo(2, 4, *(6, 8), **{'foo': 10, 'bar': 12})
也可以来个“混搭”，孤立的可变长参数将会被放入对应的tuple或dict中，如：
>>> aTuple = [3,4] >>> aDict = {'m': 1, 'n':2} >>> newfoo(2, 4, 3, x=4, y=5, *aTuple, **aDict)
在这个例子中，参数3会被放入aTuple，参数x=4和y=5会被放入aDict
