零基础入门Python小甲鱼-笔记7

第5章 列表、元组和字符串-下

原文再续，书接上一回

5.2 元组:戴上了枷锁的列表

5.2.1 关于元组的一些常用的操作

元组和列表最大的区别:

列表	元组
你可以任意修改列表的中的元素,可以任意插入或者删除一个元素,也就是可以增删查改。	元组是不可改变的
创建列表使用中括号[]	创建元组大部分的时候使用小括号()

可以对元组作一些操作

下面是代码展示,是直接一步一步往下去的,要亲自一个一个在IDLE上输入。

操作	代码展示
创建元组	tuple1 = (1,2,3,4,5,6,7,8)
访问元组	tuple1[1]
分片元组	tuple1[5:],tuple1[:5],
复制整个元组	tuple2 = tuple1[:]

试图修改元组的一个元素,Python会很不开心

>>> tuple1 = (1,2,3,4,5,6,7,8)
>>> tuple1[1] = 1
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    tuple1[1] = 1
TypeError: 'tuple' object does not support item assignment

元组的标志性符号是小括号?当然不是,我一开始也是这样想得,但是结果往往出乎意料。

通过type()这个BIF返回参数的类型,下面的执行返回的是int整数类型

>>> temp = (1)
>>> type(temp)
<class 'int'>

没有小括号,temp还是元组类型,所以逗号(,)才是元组的关键,通过下面的例子可以得出:

>>> temp = 1,2,3
>>> type(temp)
<class 'tuple'>
>>> temp2 = (1,)
>>> type(temp2)
<class 'tuple'>

所以创建元组的方法总结如下,tuple1是变量名,自己可以改的:

创建元组的方法
tuple1 = ()
tuple1 = (1,2,3,4,5,6,7,8)
tuple1 = 1,2,3
tuple1 = (1,)

逗号(,)起到了决定性作用

>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)

5.2.2 更新和删除元组

直接在同一个元组上更新是不可行的,所以我们采取相对含蓄的方法:

向元组里面加入一些元素,可以通过分片的方法拆分两部分,然后再使用连接操作符(+)合并成一个新的元组

下面展示一下我的错误的做法,逗号不能放在前面:

>>> temp = ("小鸡","小鸭","小猪")
>>> temp = temp[:2] +(,"小甲鱼") + temp[2:]
SyntaxError: invalid syntax

间接删除一个/多个元素

>>> temp = temp[:2] + temp[3:]
>>> temp
('小鸡', '小鸭', '小猪')

删除整个元组,使用del语句,但是在日常使用中,很少使用del去删除整个元组,因为Python的回收机制会在这个元组不再使用到的时候自动删除:

>>> del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    temp
NameError: name 'temp' is not defined

关系操作符,逻辑操作符,成员关系操作符也可以应用到元组里面

5.3 字符串

操作	代码提示
创建字符串	str1 = “I love fishC .com”
访问字符串的一个字符	str1[5]
修改字符串(含蓄间接的修改)	str2 = str1[:6] + “我是一个字符串” +str1[6:]

这种通过拼接旧的字符串的各个部分得到新的字符串的方式并不是真的意义上的改变原始的字符串,原来的那个”家伙”还在,知识将变量指向了新的字符串(就饿得字符串一旦失去变量的引用,就会被Python的垃圾回收机制释放掉)

关系操作符,逻辑操作符,成员关系操作符也可以应用到字符串里面

5.3.1 各种内置的方法

常用的内置方法:

casefold()作用:将字符串的所有字符变为小写

>>> str1 = "FishC"
>>> str1.casefold()
'fishc'

count(sub[,start[,end]]):查找sub字符串出现的次数,可选参数(注:在Python文档中,用方括号[]括起来表示为可选)

>>> str1 = "abcabcabcabcabc"
>>> str1.count("ab",0,15)
5

find(sub[,start[,end]]):检测 str (子字符串)是否包含在 mystr(该字符串)中，如果是返回开始的索引值，否则返回-1

>>> str1 =  "I love fishC .com">>> str1 =  "I love fishC .com"
>>> str1.find('fishC')
7
>>> str1.find('d')
-1
>>> str1.find('fishC')
7

index(sub[,start[,end]]):跟find()方法一样，只不过如果str(子字符串)不在 mystr(该字符串)中会报一个异常.

>>> str1.index('fishC')
7
>>> str1.index('good')
Traceback (most recent call last):
  File "<pyshell#35>", line 1, in <module>
    str1.index('good')
ValueError: substring not found

join():是以字符串作为哦分隔符,插入到sub字符串中所有的字符之间:

>>> 'x'.join("Test")
'Txexsxt'

通常我们都是建议使用join()来连接字符串,因为当使用连接符号(+)去拼接大量的字符串时是非常低效率的,加号连接会引起内存复制以及垃圾回收机制操作。使用join()方法的效率更好。

replace(old,new[,count]):替换指定的字符串

>>> str1 = "I love you"
>>> str1.replace('you','fishC.com')
'I love fishC.com'

split(sep=None,maxsplit =-1):拆分字符串

>>> str1 = ' '.join(['I','love','fishc.com'])
>>> str1
'I love fishc.com'
>>> str1.split()
['I', 'love', 'fishc.com']

5.3.2格式化

还没写好,我后面还没有搞懂,所以先在上传,明天一定补充完整

1.format():

format()方法接受位置参数和关键字参数,二者均传递到一个叫做replacement字段。而这个replacement字段在字符串内有大括号({})表示。’

下面有个例子:

>>> '{0} love {1}.{2}'.format('I','FishC','com')
'I love FishC.com'

上面这个字符串中的{0},{1}和{2}应该跟位置有关,依次被format()的三个参数替换,那么format()的三个参数叫叫做位置参数。

关键字参数,通过下面的例子解析:

>>> '{a} love {b}.{c}'.format(a = 'I',b = 'FishC',c = 'com')
'I love FishC.com'

上面这个字符串中的{a},{b}和{c}相当于是三个标签,被format()的三个参数替换,简单来说,这个字符串上面有三个坑,format()的三个参数把那些坑填上去。

PS.如果将位置参数和关键字参数综合在一起使用,那么位置参数必须在关键字参数之前,否则就会报错,所以位置参数一定放在关键字之前。

>>> '{a} love {b}.{0}'.format(a = 'I',b = 'FishC', 'com')
SyntaxError: positional argument follows keyword argument

把大括号打印出来,只需要用多一层大括号包起来即可,因为{0}的特殊功能被外层的大括号({})剥夺,因此没有字段输出,这并不是一个错误啊。

>>> '{{0}}'.format('不打印')
'{0}'

最后一个例子:

>>> '{0} : {1:.2f}'.format('圆周率',3.14159)
'圆周率 : 3.14'

位置参数{1}跟平常有些不同,后边多了个冒号。在替换域中,冒号表示格式化的开始,”.2”的意思是四舍五入到保留两位小数点,而f的意思是定点数,所以结果是打印出3.14。

2.格式化操作符:%

当%的左右均为数字的时候,那么它表示求余数的操作;但当它出现在字符串中的时候,它表示的是格式化操作符。

Python格式化符号及含义

符号	含义
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数(大写)
%f	格式化浮点数字,可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e,用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g,根据值的大小决定使用%f或%e

下面举几个例子:

>>> '%c %c %c'%(97,98,99)
'a b c'
>>> '%d转换为八进制是:%o'%(123,123)
'123转换为八进制是:173'
>>> '%f用科学计数法表示为:%e'%(149500000,149500000)
'149500000.000000用科学计数法表示为:1.495000e+08'

其实把一些常用的记住就好笑脸.jpg

Python还提供了格式化操作的辅助指令:

符号	含义
m.n	m是显示的最小总宽度,n是小数点后的位数
-	结果左对齐
+	在正数前面显示加号(+)
#	在八进制前面显示’0o’,在十六进制数前面显示’0x64’或’0X64’
0	显示的数字掐面填充的’0’代替空格

下面举几个例子仅供参考:

>>> '%5.1f'%27.658
' 27.7'
>>> str1 = ' 27.7'
>>> len(str1)
5
>>> '%.2e'%27.658
'2.77e+01'
>>> '%10d' %5
'         5'
>>> '%010d'%5
'0000000005'
>>> '%#X'%100
'0X64'

你会发现上面如果不够宽度的话,会使用空格代替它。

3.Python的转义字符及含义

符号	说明
\'	单引号
\"	双引号
\a	发出系统响铃声
\b	退格符
\n	换行符
\t	横向制表符(Tab)
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制代表的字符
\x	十六进制代表的字符
\0	表示一个空字符
\\	反斜杠

5.4 序列

列表、元组、字符串统称为序列。它们之间有很多共同点:

• 都可以通过索引值得到每一个元素
• 默认索引值总是从0开始(灵活的Python还支持负数索引)
• 可以通过分片的方法得到一个范围内的元素的集合
• 有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)

常用BIF(内置方法)	说明
list([iterable])	把一个可迭代的对象转换成列表(要么不带参数,要么带一个可迭代对象作为参数)
tuple([iterable])	把一个可迭代的对象转换成元组
str(obj)	把一个obj对象转换为一个字符串
len(sub)	返回sub参数的长度
max(…)	返回序列或参数集合中最大值
min(…)	返回序列或参数集合中最小值
sum(iterable[,start])	返回序列的iterable的总和
sorted(iterable,key=None,reverse = Flase)	返回一个排序的新列表而列表的sort()是实现列表原地排序
reversed(sequence)	返回逆向迭代序列的值,返回一个返回后的迭代器对象,列表的内建犯法是原地翻转
enumerate(iterable)	生成二元组(二元组就是元素数量为二的元组)构成的一个迭代对象
zip(iter1[,iter2[…])	返回由各个可迭代的参数共同组成的元组

迭代的解释:

迭代是重复反馈过程的活动,其目的通常是为了接近到达所需的目标和结果。每一个对过程的重复被称为一次”迭代”,而每一个迭代得到的结果会被用来下一次迭代的初始值。

1.list([iterable]):

把一个可迭代的对象转换成列表(要么不带参数,要么带一个可迭代对象作为参数)

>>> a = list()
>>> a
[]
>>> #将字符串的每个字符迭代存放到列表中
>>> b = list('FishC')
>>> b
['F', 'i', 's', 'h', 'C']
>>> c = list((1,2,3,4,5))
>>> c
[1, 2, 3, 4, 5]

2.len(sub):

返回sub参数的长度,sub可以是字符串、列表、元组,列表页类似。

>>> str1 = "I love FishC.com"
>>> len(str1)
16
>>> tuple1 = '这','是','一','个','元','组'
>>> len(tuple1)
6

3.max(…):

max()的参数可以是一个序列,返回值是该序列中的最大值,也可以是多个参数

>>> list1 = [1,2,3,4,5,62,147,82,748,213,189,3482]
>>> max(list1)
3482
>>> str1 = "I love FishC.com"
>>> max(str1)
'v'

PS.使用max()方法和min()方法都要保证序列或参数的数据类型统一,否则会出错。

>>> list1 = [1,2,3,4,5,62,147,82,748,213,189,3482]
>>> list1.append('x')
>>> max(list1)
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    max(list1)
TypeError: unorderable types: str() > int()

错误是说不能拿字符串和整型进行比较。max()和min()方法都是通过索引得到每一个元素,然后将各个元组进行对比。

4.sum(iterable[,start]):

sum()方法有一个可选的参数(start),如果设置改参数,表示从改值开始加起,默认值是0

>>> tuple1 = 1,2,3,4,5
>>> sum(tuple1)
15
>>> sum(tuple1,10)
25

5.sorted(iterable,key=None,reverse = Flase):

列表的内建方法sort()是实现列表原地排序,而sorted()是返回一个排序的新列表。

>>> list1 = [1,6,8,24,15,45,2,0]
>>> list2 = list1[:]
>>> list1.sort()
>>> list1
[0, 1, 2, 6, 8, 15, 24, 45]
>>> sorted(list2)
[0, 1, 2, 6, 8, 15, 24, 45]
>>> list2
[1, 6, 8, 24, 15, 45, 2, 0]

6.reversed(sequence):

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

>>> list1 = [1,6,8,24,15,45,2,0]
>>> reversed(list1)
<list_reverseiterator object at 0x05E645D0>
>>> for each in reversed(list1):
    print(each,end = ',')

0,2,45,15,24,8,6,1,

7.enumerate(iterable):

每个二元组是由可迭代参数的索引号及其对应的元素组成的。通过栗子,你应该可以弄懂的。

>>> str1 = 'FishC'
>>> for each in enumerate(str1):
    print(each)

(0, 'F')
(1, 'i')
(2, 's')
(3, 'h')
(4, 'C')

8.zip(iter1[,iter2[…]):

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

>>> list1 = [1,3,5,7,9]
>>> str1 = 'FishC'
>>> tuple1 = (2,4,6,8,10)
>>> for each in zip(list1,str1,tuple1):
    print(each)

(1, 'F', 2)
(3, 'i', 4)
(5, 's', 6)
(7, 'h', 8)
(9, 'C', 10)