python学习笔记——字符串、列表、元组、字典

字符串

字符串可以用""也可以用’’，甚至可以用’’’’’’
其中前两个只能在一行内完成，而最后一个可以写成多行。
前两个表示的字符串中，若要包含引号的话，必须转义，第三个不需要。

字符串的截取和访问

python对于字符串，可以看成一个元组（后面会说）来处理，也就说，我们可以用下标去访问它的某一个字符，但是不能对其中一个字符直接用下标去修改，比如：

v="hello world"
#v[0]="w"   这是非法的
print(v[0])

我们的输出结果是h。
但是注意我们第二行注释掉的代码是非法的，也就是说我们并不能像数组那样去修改这个字符（所以我说它像元组，而没说是数组或list）。
因此我们也就有如下的访问方式：

v="hello world"
print(v[1:3])
print(v[:3])
print(v[1:])
print(v[-1])

这些访问方法的含义可以参考下面list的讲解。

字符串的拼接和重复

我们说的字符串的拼接和重复，表面上看上去就像对字符串进行加法和乘法。
加法为连接两个字符串。
乘法是指把某个字符串重复多少遍。
例如：

cgg="cgg"
xhy="xhy"
print(cgg+xhy)
print(cgg*10)

但是注意我们不能让两个字符串相乘：

cgg="cgg"
xhy="xhy"
print(cgg*xhy)

这种写法是非法的。

转义字符

我们在开头的介绍就提到了转义字符。
相信如果学过编程，对转义字符应当不陌生。
方便起见，我们还是再把转义字符表列一遍，大家可以比较一下和自己熟悉的语言有什么不同：

字符串的运算符

我们之前介绍过的重复、拼接、截取（访问）的运算符都是字符串的运算符。
这里我们再介绍一些特殊的。
首先是，in和not in也可以用于字符串，比如：

v="hello world"
print("h" in v)
print("a" in v)

运行结果就比较显然了，第一个是true，第二个是false

接下来是r或者是R，二者效果一致。
他们的作用是显示原始字符。
什么意思？
举个例子：

print(r"hello world\n")

然后输出的结果是：hello world\n
也就是说，如果加上r（R），机器就会按照最原始的方法去理解字符串，不会采用什么转义之类的字符。或者开个玩笑：所见即所得。

格式化字符串

我们知道，在C语言中，我们可以用%加上一些约定的字符从而实现一些对于输出格式的控制。
方便起见，我们还是把表给出：

相信大家应该比较熟悉了，我们下面给出辅助的控制：

我们下面举个例子：

cgg="I have %s pens."
num=10
print(cgg%num)

当然我们也可以嵌入多个值。
例如：

cgg="I love %s ans %s"
pe1="my father"
pe2="my mother"
print(cgg%(pe1,pe2))

扩展

python2.6以后，新加了str.format()函数，使得格式化的功能更加强大。我们下面来简单介绍一下。
基本的语法是用{}和:来代替原来的%，我们举个例子：

"{} {} {}".format("hello","world","!")
"{0} {1} {0}".format("hello","world","!")

第一个例子就是会依次将三个参量填入三个花括号。
第二个例子则会根据给的数字，把这个数字作为下标，从给的参数列表中选取对应的数据填入。
我们也可以用字典、元组或列表（参考后文）来实现一些更高级的功能：

print("大家好，我是{name}，我的网站是：{url}".format(name="cggwz",url="https://blog.csdn.net/cggwz"))

site={"name":"cggwz","url":"https://blog.csdn.net/cggwz"}
print("大家好，我是{name}，我的网站是：{url}".format(**site))

site=["cggwz","https://blog.csdn.net/cggwz"]
print("大家好，我是{name}，我的网站是：{url}".format(name=site[0],url=site[1]))

site={"00":"cggwz","11":"https://blog.csdn.net/cggwz"}   #非法
print("大家好，我是{00}，我的网站是：{11}".format(**site))

这里前三个都是合法正常的，第四个是非法的，也就说无论我们的字典里的下标是什么，我们格式化字符串中{}中出现的数字会被优先解释为参数列表的下标。

当然了，我们也可以向format里传入自己写的对象，举个例子：

class cgg(object):
    def __init__(self,a):
        self.a=a
my=cgg(10)
print("{.a}".format(my))

输出的结果是10。

下面我们再讲讲format对数字的格式化。
主要就是下面这张图了，它详细地说了对于数字的各种格式化。

、

转化为unicode

和之前的r类似，这里我们用的是u，
举个例子：

print(u"hello\u0020world!")

这里的输出结果就是一个很简单的hello world！
这里用u指定为unicode字符集，然后\u0020就会被解释为Unicode编码中0020的对应字符，也就是空格符。

一些有用的函数

我们知道在其他语言中有很多对字符串操作的函数，在python中也不例外，python也含有很多操作字符串的函数，这里我们跳出比较常用的一部分来讲解一下：

capitalize()

这个函数的作用就是，如果字符串的第一个字符是字母，则把它变成大写，如果是其他字符，则不予理睬，不做处理。如：

cgg="wowowo"
print(cgg.capitalize())

这个例子的输出结果就是：Wowowo
但是如果我们这样写：

cgg="23wowowo"
print(cgg.capitalize())

则什么也不会发生，程序会将字符串原样输出。

center(width)

这个函数是使字符串居中。那么怎么个居中法？我们可以看到它需要一个参数width，这个参数就是指定字符串将处于一个多长的空间的中心，比如：

cgg="cgg"
print(cgg.center(5))
print(cgg.center(1))
print(cgg.center())    #非法

第一个是正常情况下，输出为 cgg ，注意前后各有一个空格。
第二个语句，给出的长度小于字符串的长度，这个时候，会直接返回原字符串。
第三个是非法的，这个函数不能缺省参数。

这个函数还有一个更加高级的功能，他还有一个参数，可以用于指定填充的字符，比如：

cgg="cgg"
print(cgg.center(5,'*'))

这里指定了*作为填充字符，所以输出结果就是：*cgg*两边用星号进行了填充。
所以当这个参数缺省时，默认用空格进行填充。

count()

这个从名字就能看出来了，计数用的。
它一共有三个参数：
第一个参数时指定的要搜索的子字符串，
第二个是开始搜索的位置，默认是0，也就是从头开始
第三个是搜索结束的位置，默认是len(string)，也就是尾
虽然很好理解还是举个例子：

cgg="cgggcggcgcgcgcgcg"
print(cgg.count("c"))
print(cgg.count("c",1,9))

答案分别是7和2.
这个自己数一下就明白了。
着重强调一下第二个语句，为什么选择9，自己数一下就能明白我的意思了。
这个语句和结果说明，这里的9并不包括下标为9的这个位置，而是搜索到下标为8的位置，这个是很值得注意的。（其实python中很多都不包括上界）

find()

这个名字貌似也很好理解，也是在一个字符串中找另一个字符串。
它有三个参数，含义分别如下：
第一个是我们要搜索字符串
第二个是我们搜索的开始位置，默认为开头
第三个是我们搜索的结束位置，默认为字符串结束。
它的返回值是搜索到的第一个字符串的首字母下标，如果没有搜到则返回-1，我们看一个例子：

cgg="cgggcgcgcgcgcccggggcggcggc"
print(cgg.find("cgg"))
print(cgg.find("cgg",15))
print(cgg.find("cgg",15,25))
print(cgg.find("cgg",15,16))
print(cgg.find("cgg",15,21))

结果分别为：0 19 19 -1 -1
我们着重讲一下第五个例子，这个例子返回-1，说明，我们指定的下标，是指把这一段的字符串截取出来进行搜索，而不是字符串首字母下标所处的区间，这一点值得注意。

isalnum()、isalpha()

这个恐怕不太能看出其含义是什么，就算你说你能看出来，那你也多半会看错。
is all number?
no
它的作用是，如果字符串至少有一个字符，且所有字符为数字或者字母才返回true，其他情况都返回false。举个例子：

cgg="cggg123"
print(cgg.isalnum())
cgg="cggg 123"
print(cgg.isalnum())

第一个是true，第二个是false，因为第二个多了一个空格。
同理，isalpha()应该也就很好理解了，至少有一个字符且全部是字母才返回true，具体的例子我就不举了。
与这两个类似的函数还有很多，我列一个表，就不一一讲解了（以后有机会再说）：

我们就先说这么多，其实还有很多函数，以后有时间再说（博主要期末考试了）

列表

python中是没有数组的概念的，而和数组概念最接近的应该就是列表（list）。
定义用方括号，元素用逗号隔开。
例如：

shoplist=["ball","apples","bananas"]

当然了，元素是可以不同类型的，也就是说可以混着放，比如如下的定义是合法的：

cgg=[1,2,'cgg',3.4,3+9j]

python也提供了更多样的访问方法，如对上述shoplist打印：

print(shoplist)        #输出整个列表
print(shoplist[0])     #输出第0个元素
print(shoplist[0:2])   #输出第0到1个元素
print(shoplist[:2])    #输出第0到1个元素
print(shoplist[1:])    #输出第1到2个元素
print(shoplist[-1])    #输出倒数第二个数

从这里负数的含义，相比你也就知道了，python的list下标是有范围限制的，不能越界

更改值和数组一样
当然了，列表里也可以放列表。
我们还可以追加元素：

shoplist.append("books")

这样就在末端加上了书。
当然了，既然可以加，就可以删除。

del shoplist[0]

这里就是删除了第一个元素，并将剩下的元素向左移动。
和字符串一样，列表也可以加和乘，含义相同，不再赘述

列表的函数和方法

函数

这些方法中我们重点说一下cmp函数。
这个函数根据比较结果返回0或者1、-1，来反映二者的大小关系。
我们之前说了，list是一个混血儿，不一定是纯种的数字或者纯种的字符串，那怎么比较二者的大小？
和字典序的比较类似，从前往后比较，如果有出现不一样的地方，则遵循如下比较原则：

空<小数字<大数字<其他类型（其他类型按照类型名字的字典序排）

我说的空就是指，某一个list提前结束，也就是比另一个短，那么它会小一点。（当然它和另一个list的前半部分肯定是相等的）
也就说，在所有的类型中，数字是最小的。
按照这个顺序，就可以实现list这个混血儿的比较大小了。
其他的函数，我就不多嘴了，大家应该一看到就会用。

方法

这里我们重点讲解一下sort的参数。
第一个cmp，是可以自己写排序函数，然后传进去，系统就会按我们写函数去排序。
第二个参数可以用来指定排序依据的元素。我这么说你可能觉得不理解什么意思，我们举个例子：

abc=[(5,2),(3,1),(6,5)]
def sec(a):
    return a[1]
abc.sort(key=sec)
print(abc)

这是一个把元组（下面就会介绍）作为元素的list。
我们的key传入的依然是一个自己写的函数。
这里写key=这个函数，表示把这个函数的返回值作为排序的依据，这样我们就可以实现自定义的一些排序，比如我们可以以两个数的和来排序：

abc=[(5,2),(3,1),(6,5)]
def sec(a):
    return a[1]+a[0]
abc.sort(key=sec)
print(abc)

只要改一下我们的函数就好了。
第三个参数，则是指定是升序还是降序。
默认是升序，也就是reverse=false
我们如果指定reverse=true，则会按降序排列。
其他的方法用法比较明显，我就不再赘述了。

元组

元组的特点就是，不能修改，就如常数组一般，值不能修改删除或增添。

定义

元组用圆括号来定义，如：

fibs=(1,1,2,3,5,8)
cgg=()
cgg=(30,)

第一个是正常的例子。
第二个是定义了一个空元组
第三个是只含一个元素的元组，这里值得注意，当元组中只有一个元素时，我们需要在这个元素的后面加上逗号。

访问

元组的访问和列表类似，我们就不再赘述了。

修改

元组的值一旦创立，是不被允许更改的。
但是我们可以对元组进行拼接和重复。
我们同样使用加号和乘号来处理的。
如：

cgg=(1,2,3)
ggc=(4,5,6)
print(cgg+ggc)
print(cgg*3)

第一个输出1,2,3,4,5,6，第二个输出1,2,3,1,2,3,1,2,3

删除

开头就说了，元组的元素是不允许改变的，所以这里也不能删除单个元组的元素，但是我们可以删除整个元组。
举个例子：

cgg=(1,2,3)
del(cgg)

如果删除后，你试图访问这个元组，会报错。

无关闭分隔符的元组

在python中任意无符号的对象，如果用逗号隔开，则默认视为元组。
比如：

print("cgg",3,3)
x,y=1,2
print(x,y)

输出结果就比较朴素了。

元组的内置函数

元组的函数如下表：

都很易懂，其中第一个cmp的比较方法和list一致，这里不再赘述。

字典

定义

字典的每一个元素都是由键和值组成的，如：

games={"cgg":"cod",
"whz":"lol"
}

此处用花括号定义。
其中，值可以是任何类型的数据，但是键必须是不能变的量，比如数字常量、字符串常量、元组（元组也可以）

调用和修改

调用和修改也很简单：

print(games["cgg"])
games["cgg"]="mole"

和数组使用类似。
有两点提示：

1. 如果一个键对应多个值，只取最后一个
2. 定义时，键用的是双引号，在取用时，可以用单引号的字符串引用

删除

我们可以删除一对元素，或者整个删除，比如：

cgg={"1":"cgg","2":"ggc"}
del(cgg['1'])
cgg.clear()
del(cgg)

第一个del是删除某一对元素。
第二个是清空字典，也就是删除所有元素
第三个是删除字典
注意我加粗的字。
后面这两个语句是有区别的。
第二个只是清空元素，使得cgg变成了一个空字典，我们后期还可以向里面加入元素。
但是第三个语句是删除字典，调用后，这个字典就不再存在了，如果再对它进行操作会报错。

函数和方法

首先是一些函数：

首先关于其cmp的比较是如何实现的，大家可以参考：字典的cmp原理
我就不再赘述了。

第三个方法，是将字典转换成一个字符串，便于人类阅读。
我们举个例子：

cgg={"zx":"cgg","cd":"ggc"}
print(str(cgg))

输出就是：{“zx”:“cgg”,“cd”:“ggc”}

第四个就是返回这个变量的值，这不是字典专属的函数。

下面是字典的一些内置的函数：

首先我们说一下第二个函数，什么是浅赋值，我们举个例子：

cgg={"zx":"cgg","cd":[1,2,3]}

dict1=cgg             
dict2=cgg.copy()      

cgg['zx']="gcc"
cgg['cd'].remove(1)

print(cgg)
print(dict1)
print(dict2)

我们这里把直接赋值和浅复制进行了对比。
如果我们直接赋值，那么实际上我们实现了一个引用，dict1的内容会和cgg一起改变。
而对于浅复制的dict2，它是只复制一级目录，不复制二级目录，二级目录仍是引用，我们可以看到dict2的值中的list是随着cgg变化的，而前一个字符串是不变的。

其他的如果有必要，我以后再详细解释。
写数学去了！