python创建元组并输出_Python基础入门第五章列表元组和字符串

第五章 列表、元组和字符串

5.1 列表 (由于Python的变量没有数据类型，python是没有数组的，加入更强大的list)

5.1.1 创建列表

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

>>>mix = [1, "小甲鱼", 3.14 ,

[1, 2, 3] ]

empty = [

]

5.1.2 向列表中添加元素

>>>number = [1, 2,

3, 4, 5]

>>>number.

append(6)

可以看到参数6以经被添加到列表number的末尾了

>>>number.

extend([7,8])可以使用extend()方法使用一个列表扩展另一个列表

>>>number.

insert(0 ,

0)insert在任意位置插入元素，第一个参数表示位置，第二个参数元素

5.1.3 从列表中获取元素

>>>number[0] #列表元素位置互换

5.1.4 从列表中删除元素

三种方法：remove() ，del 和

pop()

用法：number.

remove(1) 删除元素不需要知道元素具体位置，只要存在就可以，删除1

del number[1]

del是一个语句不是列表的方法，不必加小括号。删除第一个元素

del number删除

整个列表

name.

pop()弹出列表最后一个元素 name.pop(2)弹出第三个元素

5.1.5 列表分片

>>>number[ 0:

2]结束位置上的元素不包含，原来列表不变化

>>>number[ : 2 ] >>>>number[

0 : ] number[ : ]

>>>list = [1,2,3,4,5,6,7,8,9]

>>>list[0:9:2] [1,3,5,7,9] #选取0到第九个元素，步数间隔2

>>>list[: : -1] [9,8,7,6,5,4,3,2,1]

补充：

>>>list1 =

[1,3,2]

>>>list2 = list1[ :

]

>>>list3 =

list1

>>>list1.sort()

>>>list1 [1,2,3]

>>>list2 [1,3,2] #使用分片方式得到的列表相当于复制

>>>list3 [1,2,3] #为一个列表指定另一个名字，只是向同一个列表增加一个新的标签而已

5.1.6 一些常用字符串

字符串可以用加号(+)也叫连接操作符 来进行连接，用乘号(*)也叫重复操作符来

复制自身若干次。它们在列表身上也是可以实现的 #列表可以相加

>>>list1 = [123,456]

>>>list2 = [234,123]

>>>list = list1 + list2

>>>list [123,456,234,123]

一般建议使用extend()语句，连接操作符+不能实现列表添加元素

>>>list1 = [123]

>>>list1 * 3 [123 , 123,

123]

>>>list1 *= 4 [123,123,123,123]

另一个成员操作符 in

和 not in！

>>>list1 =

["小猪"，"小猫"，["小甲鱼","小护士"],"小狗"]

>>>“小甲鱼” in list1[2] True

>>>“小护士" not in list1[2] False

in 和 not in

只能判断一个层次成员关系

>>>list1[2][0] 小甲鱼

5.1.8 列表的小伙伴

>>>dir(list) 查看列表 #dir()函数可以查询到该模块定义了哪些变量、函数和类。

count()计算参数在列表中出现次数

>>>list1 =

[1,2,1,3]

>>>list1.count(1) 2

index()这个方法返回参数在列表中位置

>>>list1.index(1) 0 可以看到这里返回的是第一个目标在list1中位置

>>>start =

list1.index(1) + 1

>>>stop =

len(list1)

>>>list1.index(1,start,stop) 1 返回第二个目标在list1中位置

reverse()将整个列表原地翻转

>>>list1 =

[1,2,3]

>>>list1.reverse()

>>>list1 [3,2,1]

sort()对列表成员进行排序，默认不需要参数

从小到大排序

>>>list1 =

[8,9,3,5,2,6,10,1,0]

>>>list1.sort()

>>>list1 [0,1,2,3,5,8,9,10]

>>>list1.sotr(reverse =

True)

>>>list1 [10,9,8,5,3,2,1,0]

5.2 元组：戴上枷锁的列表

5.2.1 创建和访问一个元组

>>>tuple1 =

(1,2,3,4,5,6) #用小括号

>>>tuple1[1] 2 #访问元组和列表无异

>>>tuple2 = tuple1[

: ] # 分片方式复制一个元组

易混淆点：

>>>temp = (1)

>>>type(temp)

>>>temp =

1,2,3 #

元组类型，，号是关键。列表类型[ ]是关键

>>>type(temp)

>>>temp = ()

>>>type(temp)

>>>8 *

(8) 64

>>>8 *

(8,) (8,8,8,8,8,8,8,8)

5.2.2 更新和删除元组

>>>temp = ("小鸡","

小鸭"," 小猪" )

>>>temp =temp [ :

2]+("小甲鱼",) + temp [2: ] #只是将变量temp指向新的元组

>>>temp ("小鸡","

小鸭","小甲鱼"," 小猪" )

>>>temp =temp [ :

2]+temp [3: ]

>>>temp ("小鸡","

小鸭"," 小猪" )

5.3 字符串

在python并没有字符这个类型，所谓字符就是长度为1的字符串，字符串和元组一样，

都是属于”一言既出驷马难追“的家伙，一旦定下来就不能直接对他们修改，只能将变量

指向新的字符串

5.3.1 各种内置方法

1、去空格及特殊符号

s.strip().lstrip().rstrip(',')

2、复制字符串

#strcpy(sStr1,sStr2)

sStr1 = 'strcpy'

sStr2 = sStr1

sStr1 = 'strcpy2'

print sStr2

3、连接字符串

#strcat(sStr1,sStr2)

sStr1 = 'strcat'

sStr2 = 'append'

sStr1 += sStr2

print sStr1

4、查找字符

#strchr(sStr1,sStr2)

# < 0 为未找到

sStr1 = 'strchr'

sStr2 = 's'

nPos = sStr1.index(sStr2)

print nPos

5、比较字符串

#strcmp(sStr1,sStr2)

sStr1 = 'strchr'

sStr2 = 'strch'

print cmp(sStr1,sStr2)

6、扫描字符串是否包含指定的字符

#strspn(sStr1,sStr2)

sStr1 = '12345678'

sStr2 = '456'

#sStr1 and chars both in sStr1 and sStr2

print len(sStr1 and sStr2)

7、字符串长度

#strlen(sStr1)

sStr1 = 'strlen'

print len(sStr1)

8、将字符串中的大小写转换

S.lower() #小写 S.upper() #大写 S.swapcase() #大小写互换 S.capitalize() #首字母大写 String.capwords(S)

#这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起 #实例：

#strlwr(sStr1)

sStr1 = 'JCstrlwr'

sStr1 = sStr1.upper()

#sStr1 = sStr1.lower()

print sStr1

9、追加指定长度的字符串

#strncat(sStr1,sStr2,n)

sStr1 = '12345'

sStr2 = 'abcdef'

n = 3

sStr1 += sStr2[0:n]

print sStr1

10、字符串指定长度比较

#strncmp(sStr1,sStr2,n)

sStr1 = '12345'

sStr2 = '123bc'

n = 3

print cmp(sStr1[0:n],sStr2[0:n])

11、复制指定长度的字符

#strncpy(sStr1,sStr2,n)

sStr1 = ''

sStr2 = '12345'

n = 3

sStr1 = sStr2[0:n]

print sStr1

12、将字符串前n个字符替换为指定的字符

#strnset(sStr1,ch,n)

sStr1 = '12345'

ch = 'r'

n = 3

sStr1 = n * ch + sStr1[3:]

print sStr1

13、扫描字符串

#strpbrk(sStr1,sStr2)

sStr1 = 'cekjgdklab'

sStr2 = 'gka'

nPos = -1

for c in sStr1:

if c in

sStr2:

nPos = sStr1.index(c)

break

print nPos

14、翻转字符串

#strrev(sStr1)

sStr1 = 'abcdefg'

sStr1 = sStr1[::-1]

print sStr1

15、查找字符串

#strstr(sStr1,sStr2)

sStr1 = 'abcdefg'

sStr2 = 'cde'

print sStr1.find(sStr2)

16、分割字符串

#strtok(sStr1,sStr2)

sStr1 = 'ab,cde,fgh,ijk'

sStr2 = ','

sStr1 = sStr1[sStr1.find(sStr2) + 1:]

print sStr1

#或者

s = 'ab,cde,fgh,ijk'

print(s.split(','))

17、连接字符串

delimiter = ','

mylist = ['Brazil', 'Russia', 'India', 'China']

print delimiter.join(mylist)

18、PHP 中 addslashes 的实现

def addslashes(s):

d =

{'"':'\"', "'":"\\'", "\0":"\\\0", "\":"\\\"}

return

''.join(d.get(c, c) for c in s)

s = "John 'Johny' Doe (a.k.a. "Super Joe")\\\0"

print s

print addslashes(s)

19、只显示字母与数字

def OnlyCharNum(s,oth=''):

s2 =

s.lower();

fomart =

'abcdefghijklmnopqrstuvwxyz0123456789'

for c in

s2:

if not c in fomart:

s = s.replace(c,'');

return

s;

print(OnlyStr("a000 aa-b"))

20、截取字符串

str = '0123456789′

print str[0:3] #截取第一位到第三位的字符

print str[:] #截取字符串的全部字符

print str[6:] #截取第七个字符到结尾

print str[:-3] #截取从头开始到倒数第三个字符之前

print str[2] #截取第三个字符

print str[-1] #截取倒数第一个字符

print str[::-1] #创造一个与原字符串顺序相反的字符串

print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符

print str[-3:] #截取倒数第三位到结尾

print str[:-5:-3] #逆序截取，具体啥意思没搞明白？

21、字符串在输出时的对齐

S.ljust(width,[fillchar]) #输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。 S.rjust(width,[fillchar]) #右对齐 S.center(width, [fillchar]) #中间对齐 S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足

22、字符串中的搜索和替换

S.find(substr, [start, [end]]) #返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索 S.index(substr, [start, [end]]) #与find()相同，只是在S中没有substr时，会返回一个运行时错误 S.rfind(substr, [start, [end]]) #返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号 S.rindex(substr, [start, [end]]) S.count(substr, [start, [end]])

#计算substr在S中出现的次数 S.replace(oldstr, newstr, [count]) #把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换 S.strip([chars]) #把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None S.lstrip([chars]) S.rstrip([chars]) S.expandtabs([tabsize]) #把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个

23、字符串的分割和组合

S.split([sep, [maxsplit]]) #以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 S.rsplit([sep, [maxsplit]]) S.splitlines([keepends]) #把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。 S.join(seq) #把seq代表的序列──字符串序列，用S连接起来

24、字符串的mapping，这一功能包含两个函数

String.maketrans(from, to) #返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。 S.translate(table[,deletechars]) #

使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持

deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

25、字符串还有一对编码和解码的函数

S.encode([encoding,[errors]]) # 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5

bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore',

'replace', 'xmlcharrefreplace', 'backslashreplace'

和所有的通过codecs.register_error注册的值。这一部分内容涉及codecs模块，不是特明白 S.decode([encoding,[errors]])

26、字符串的测试、判断函数，这一类函数在string模块中没有，这些函数返回的都是bool值

S.startswith(prefix[,start[,end]]) #是否以prefix开头 S.endswith(suffix[,start[,end]]) #以suffix结尾 S.isalnum() #是否全是字母和数字，并至少有一个字符 S.isalpha() #是否全是字母，并至少有一个字符 S.isdigit() #是否全是数字，并至少有一个字符 S.isspace() #是否全是空白字符，并至少有一个字符 S.islower() #S中的字母是否全是小写 S.isupper() #S中的字母是否便是大写 S.istitle() #S是否是首字母大写的

27、字符串类型转换函数，这几个函数只在string模块中有

string.atoi(s[,base]) #base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串 string.atol(s[,base]) #转成long

string.atof(s[,base])

#转成float

5.3.2 格式化

格式化字符串就是按照统一的规格去输出一个字符串。

1.

format()

format()方法接受位置参数和关键字参数，二者均传递到由大括号({})表示的replacement字段

例如：

>>>"{0} love {1} .

{2}" . format ("I", "FishC", "com")

' I love FishC . com'

字符串{0}、{2}

{3}应该跟位置有关，依次被format()的三个参数替换，那么format()的三个参数

就叫位置参数

>>>"{a} love {b} .

{c}" .format(a ="I", b = "FishC", c = "com ")

'I love FishC .com'

{a}{b}{c}相当于三个标签，format()将参数中等值的字符串替换进去，这就是关键字参数

>>>"{0} love {b} .

{c}" .format("I", b = "FishC", c

= "com ") #综合使用

>>>"{0} : {1: .2f}"

.format("圆周率",3.14159)

'圆周率：3.14' #位置参数多了冒号，替换中冒号表示格式化符号的开始，“.2”的意思

四舍五入 保留两位小数点，而f的意思是浮点数。

2. 格式化操作符%

符 号

说 明

%c

格式化字符及其ASCII码

%s

格式化字符串

%d

格式化整数

%o

格式化无符号八进制数

%x

格式化无符号十六进制数

%X

格式化无符号十六进制数(大写)

%f

格式化定点数，可指定小数点后的精度

%e

用科学计数法格式化定点数

%E

作用同%e，用科学计数法格式化定点数

%g

根据值的大小决定使用%f活%e

%G

作用同%g，根据值的大小决定使用%f或者%E

使用方法：

%.2f四舍五入保留两位有效数字

仅有一个空时： print

('xxxx%c')

多个空时：print ('%c %c %c'%(97,

98, 99)) 需要使用元组

格式化操作符辅助指令

符 号

说 明

m.n

m是显示的最小总宽度，n是小数点后的位数

-

用于左对齐

+

在正数前面显示加号(+)

#

在八进制数前面显示

'0o'，在十六进制数前面显示 '0x' 或 '0X'

0

显示的数字前面填充

'0' 取代空格

使用方法：

m.n:

print('%5.5f'

% 27.55),此时要求，小数点后要有5位数，若不足会自动补全，得到 ：'27.55000'

m应该控制占据总长度，不足前面补空格，输出时数据美观

- ：

print( '%-010d'

'.55),此时若无 '-' 号时，将得到：'0000000027'，若有'-'号，则得到：'27

'# ：print('%#o' ),简单易懂，转为8 or

16进制输出

3. python的转义字符及含义

符 号

说 明

\'

单引号

"

双引号

\a

发出系统响铃声

\b

退格符

\n

换行符

\t

横向制表符(TAB)

\v

纵向制表符

\r

回车符

\f

换页符

\o

八进制数代表的字符

\x

十六进制数代表的字符

\0

表示一个空字符

\\

反斜杠

5.4 序列

关于序列的常用BIF

1. list([iterable]) ### 索引 -1

表示最后一个元素

>>>将元组中的每个元素迭代(迭代就是for循环)存放到列表中

>>>c =

list((1,1,2,3,5,8,13))

>>>c [1,1,2,3,5,8,13]

注意：如果之前有定义list这个变量，那么list模块将不可以调用了

要del list才可以

2. tuple([iterable])

将一个可迭代对象转换为元组，具体用法同list

3. str(obj)

用于把obj对象转换为字符串 #obj必须预先定义

4. len(sub)

返回参数的长度

>>>tuple1 = “这”，“是”

>>>len(tuple1) 2

5. max(....)返回序列或者参数集合中的最大值

6. min(...)

返回序列或者参数集合中的最小值

max()和

min()都要保证序列或参数的数据类型一致

7. sum(iterable[,

start])

返回序列iterable总和，如设置可选参数，表示从该数值开始加起，默认是0

>>>tuple1 =

1,2,3

>>>sum(tuple1) 6

>>>sum(tuple1,10) 16

8. sorted(iterable, key=none,

reverse = false)

sort()实现列表原地排序

sorted()是返回一个排序后的新列表

>>>list1 = [1,18,13,0,-98]

>>>list2 = [ : ]

>>>list1.sort() #改变了原来的列表

>>>list1 [-98,0,1,13,18]

>>>sorted(list2)[-98,0,1,13,18] #原列表不改变，只是返回一个排好序的新列表

>>>list2[1,18,13,0,-98]

9. reversed(sequence)

列表的内建方法reverse()是原地翻转，而reversed()是返回一个翻转后的迭代器对象

不是返回列表，是返回一个迭代器对象

>>>list1 = [1,2,3,4]

>>>reversed(list1)

>>>for each in

reversed(list1):

print(each,end='')

4,3,2,1

10. enumerate(iterable)

生成由二元组(元素数量为二的元组)构成的一个迭代对象，每个二元组可由迭代

参数的索引号及其对应的元素组成。

>>>str1 = "FishC"

>>>for each in

enumerate(str1):

print(each)

(0,

'F')

(1,

'i')

(2, 's')

(3, 'h')

(4, 'C')

11. zip(iter1

[.iter2[...]])

返回由各个可迭代参数共同组成的元组

>>>list1 =

[1,3,5,7,9]

>>>str1 =

"FishC"

>>>for each in

zip(list1,str1) :

print(each)

(1, 'F')

(3, 'i')

(5, 's')

(7, 'h')

(9, 'C')