4.1 字符串
字符串str是在Python编写程序过程中，最常见的一种基本数据类型。字符串是许多单个子串组成的序列，其主要是用来表示文本。字符串是不可变数据类型，也就是说你要改变原字符串内的元素，只能是新建另一个字符串。
1、创建python字符串
1）单引号' ' 双引号" "创建字符串
要创建字符串，首先可以把字符串元素放在单引号、双引号中，如下图所示：
>>> str1='hello world'
>>> str1
'hello world'
>>> type(str1)
<class 'str'>
>>> str2="hello world"
>>> type(str2)
<class 'str'>
2）python字符串str( )方法
可以把str()作为一种方法来创建一个新的字符串，如下图所示：
>>> a=123
>>> b=str(a)
>>> type(b)
<class 'str'>字符串str( )方法，就是把一个原本不是字符串类型的数据，变成字符串类型。
2、查找python字符串的值（子串\字符）
1）什么是字符串的索引（下标）
生活中的下标
超市储物柜
高铁二等座
绿皮车
字符串是许多单个子串组成的序列，序列中的子串按照从左到右的顺序，分别对应一个下标，下标值从0开始。
还有一种下标是反向取值，从右向左取值时会用到。这种下标从最右位开始向左计数，下标值从-1开始！如图所示：
2）python字符串的索引（下标）取值的操作方法
切片：x[开始,结束,步长]
>>> x = 'abcdefj'
>>> x[2]
'c'
>>> x[2:]
'cdefj'
>>> x[2:5]
'cde'
>>> x[-1:-4:-1]
'jfe'
>>> x[::-1]
'jfedcba'
3、修改和删除python字符串
字符串和数字一样都是不可变数据类型，不能进行修改操作。要想修改或是删除原有字符串数据，最好的方法是重新创建一个字符串。
4、Python转义字符
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
|
转义字符 |
描述 |
|
\(在行尾时) |
续行符 |
|
\\ |
反斜杠符号 |
|
\' |
单引号 |
|
\" |
双引号 |
|
\a |
响铃 |
|
\b |
退格(Backspace) |
|
\e |
转义 |
|
\000 |
空 |
|
\n |
换行 |
|
\v |
纵向制表符 |
|
\t |
横向制表符 |
|
\r |
回车 |
|
\f |
换页 |
|
\oyy |
八进制数yy代表的字符，例如：\o12代表换行 |
|
\xyy |
十进制数yy代表的字符，例如：\x0a代表换行 |
|
\other |
其它的字符以普通格式输出 |
>>> print('xi\'an')
xi'an
5、Python字符串运算符
下表实例变量a值为字符串"Hello"，b变量值为"Python"：
|
操作符 |
描述 |
实例 |
|
+ |
字符串连接 |
a + b 输出结果： HelloPython |
|
* |
重复输出字符串 |
a*2 输出结果：HelloHello |
|
[] |
通过索引获取字符串中字符 |
a[1] 输出结果 e |
|
[ : ] |
截取字符串中的一部分 |
a[1:4] 输出结果 ell |
|
in |
成员运算符 - 如果字符串中包含给定的字符返回 True |
H in a 输出结果 1 |
|
not in |
成员运算符 - 如果字符串中不包含给定的字符返回 True |
M not in a 输出结果 1 |
|
r/R |
原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
print r'\n' prints \n 和 print R'\n' prints \n |
|
% |
格式字符串 |
请看一下章节 |
6、Python字符串格式化
python字符串格式化符号:
|
符 号 |
描述 |
|
%c |
格式化字符及其ASCII码 |
|
%s |
格式化字符串 |
|
%d |
格式化整数 |
|
%u |
格式化无符号整型 |
|
%o |
格式化无符号八进制数 |
|
%x |
格式化无符号十六进制数 |
|
%X |
格式化无符号十六进制数（大写） |
|
%f |
格式化浮点数字，可指定小数点后的精度 |
|
%e |
用科学计数法格式化浮点数 |
|
%E |
作用同%e，用科学计数法格式化浮点数 |
|
%g |
根据值的大小决定使用%f活%e |
|
%G |
作用同%g，根据值的大小决定使用%f活%e |
|
%p |
用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
|
符号 |
功能 |
|
* |
定义宽度或者小数点精度 |
|
- |
用做左对齐 |
|
+ |
在正数前面显示加号( + ) |
|
<sp> |
在正数前面显示空格 |
|
# |
在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
|
0 |
显示的数字前面填充'0'而不是默认的空格 |
|
% |
'%%'输出一个单一的'%' |
|
(var) |
映射变量(字典参数) |
|
m.n. |
m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
示例：
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出'xx.x%'，只保留小数点后1位：
[root@localhost 03-day]# vim 3-1.py
#!/usr/bin/env python
s1 = 72
s2 = 85
r = s2/s1*100
print('%.1f%%'%r)
[root@localhost 03-day]# python 3-1.py
118.1%
7、Python字符串常用操作
当前字符串mystr = ‘hello world how are you’
1)find
string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
>>> mystr = 'hello world how are you'
>>> mystr.find("how")
12
>>> mystr.find("how",20,30)
-12)index
string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
>>> mystr.index("how")
12
>>> mystr.index("how",20,30)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not foundpython的字符串内建函数
|
方法 |
描述 |
|
string.capitalize() |
把字符串的第一个字符大写 |
|
string.center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
|
string.count(str, beg=0, end=len(string)) |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
|
string.decode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' |
|
string.encode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
|
string.endswith(obj, beg=0, end=len(string)) |
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
|
string.expandtabs(tabsize=8) |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
|
string.find(str, beg=0, end=len(string)) |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
|
string.index(str, beg=0, end=len(string)) |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
|
string.isalnum() |
如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
|
string.isalpha() |
如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
|
string.isdecimal() |
如果 string 只包含十进制数字则返回 True 否则返回 False. |
|
string.isdigit() |
如果 string 只包含数字则返回 True 否则返回 False. |
|
string.islower() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
|
string.isnumeric() |
如果 string 中只包含数字字符，则返回 True，否则返回 False |
|
string.isspace() |
如果 string 中只包含空格，则返回 True，否则返回 False. |
|
string.istitle() |
如果 string 是化的(见 title())则返回 True，否则返回 False |
|
string.isupper() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
|
string.join(seq) |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
|
string.ljust(width) |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
|
string.lower() |
转换 string 中所有大写字符为小写. |
|
string.lstrip() |
截掉 string 左边的空格 |
|
string.maketrans(intab, outtab]) |
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
|
max(str) |
返回字符串 str 中最大的字母。 |
|
min(str) |
返回字符串 str 中最小的字母。 |
|
string.partition(str) |
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
|
string.replace(str1, str2, num=string.count(str1)) |
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
|
string.rfind(str, beg=0,end=len(string) ) |
类似于 find()函数，不过是从右边开始查找. |
|
string.rindex( str, beg=0,end=len(string)) |
类似于 index()，不过是从右边开始. |
|
string.rjust(width) |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
|
string.rpartition(str) |
类似于 partition()函数,不过是从右边开始查找. |
|
string.rstrip() |
删除 string 字符串末尾的空格. |
|
string.split(str="", num=string.count(str)) |
以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
|
string.splitlines([keepends]) |
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
|
string.startswith(obj, beg=0,end=len(string)) |
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
|
string.strip([obj]) |
在 string 上执行 lstrip()和 rstrip() |
|
string.swapcase() |
翻转 string 中的大小写 |
|
string.title() |
返回"化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
|
string.translate(str, del="") |
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
|
string.upper() |
转换 string 中的小写字母为大写 |
|
string.zfill(width) |
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
|
string.isdecimal() |
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
4.2 列表
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型。
1.创建列表
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
>>> list1 = ['physics','chemistry',1997,2000]
>>> list2 = [1,2,3,4,5]
2.访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符
>>> print("list1[0]:",list1[0])
list1[0]: physics
>>> print("list2[1:5]:",list2[1:5])
list2[1:5]: [2, 3, 4, 5]
列表应用：显示文件名的后缀
# 需求文档：显示所有文件的后缀
# 1. 先列举一些常用的文件后缀
fileNames = ['01.py','02.txt','03.rar','04.c','05.cpp','06.php','07.java','index.html','finally.doc']
# 2. 思路
# 2.1 先把01.py文件后缀显示出来，如果这个成功，那么使用循环就完成了整个需求
tempName = fileNames[0] -------->"01.py"
position = tempName.rfind(".")------------->
从右边开始出现的第一次的位置，例如1
print(tempName[position:])
# 2.2 把上一步整体放在循环中，即可完成
for tempName in fileNames:
position = tempName.rfind(".")
print(tempName[position:])
[root@localhost 03-day]# vim 3-2.py
#/usr/bin/env python
fileNames = ['01.py','02.txt','03.rar','04.c','05.cpp','06.php','07.java','index.html','finally.doc']
for tempName in fileNames:
position = tempName.rfind(".")
print(tempName[position:]
[root@localhost 03-day]# python 3-2.py
.py
.txt
.rar
.c
.cpp
.php
.java
.html
.doc
3.列表的相关操作
1）添加元素（append、extend、insert）
append：在列表末尾添加新的对象
>>> names = ['zhangsan','lisi','wangwu']
>>> names.append('baoqiang')
>>> names
['zhangsan', 'lisi', 'wangwu', 'baoqiang']
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
>>> a = [1,2]
>>> b = [3,4]
>>> a.extend(b)
>>> a
[1, 2, 3, 4]
list.insert(index, obj)
将对象插入列表
>>> names.insert(1,'marong')
>>> names
['zhangsan', 'marong', 'lisi', 'wangwu', 'baoqiang']
2）修改元素
['zhangsan', 'marong', 'lisi', 'wangwu', 'baoqiang']
>>> names[2]='songzhe'
>>> names
['zhangsan', 'marong', 'songzhe', 'wangwu', 'baoqiang']
3）查找元素
in（存在）、not in（不存在）
>>> names
['zhangsan', 'marong', 'songzhe', 'wangwu', 'baoqiang']
>>> findName = input("请输入你要找的名字：")
请输入你要找的名字：wangwu
>>> if findName in names:
... print("找到了")
... else:
... print("没有找到")
...
找到了
list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
['zhangsan', 'marong', 'songzhe', 'wangwu', 'baoqiang']
>>> names.index("marong")
1
>>> names.index("qianqi")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'qianqi' is not in list
list.count(obj)
统计某个元素在列表中出现的次数
>>> names.count("marong")
1
>>> names.count("qianqi")
0
4）删除元素
del 根据下表删除
>>> names
['zhangsan', 'marong', 'songzhe', 'wangwu', 'baoqiang']
>>> del names[3]
>>> names
['zhangsan', 'marong', 'songzhe', 'baoqiang']
list.pop([index])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
>>> names
['zhangsan', 'marong', 'songzhe', 'baoqiang']
>>> names.pop()
'baoqiang'
>>> names
['zhangsan', 'marong', 'songzhe']
list.remove(obj)
移除列表中某个值的第一个匹配项
>>> names
['zhangsan', 'marong', 'songzhe']
>>> names.remove('zhangsan')
>>> names
['marong', 'songzhe']
4.Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
|
Python 表达式 |
结果 |
描述 |
|
len([1, 2, 3]) |
3 |
长度 |
|
[1, 2, 3] + [4, 5, 6] |
[1, 2, 3, 4, 5, 6] |
组合 |
|
['Hi!'] * 4 |
['Hi!', 'Hi!', 'Hi!', 'Hi!'] |
重复 |
|
3 in [1, 2, 3] |
True |
元素是否存在于列表中 |
|
for x in [1, 2, 3]: print x, |
1 2 3 |
迭代 |
>>> [1,2,3]+['a','b','c']
[1, 2, 3, 'a', 'b', 'c']
>>> [1,2,3]*2
[1, 2, 3, 1, 2, 3]
>>> len([1,2,3])
3
5.列表的嵌套
>>> schoolNames = [['北京大学','清华大学'],
... ['中山大学','华南师大'],
... ['西安交大','西安电子科大','长安大学']]
>>> schoolNames
[['北京大学', '清华大学'], ['中山大学', '华南师大'], ['西安交大', '西安电子科大', '长安大学']]
遍历列表
>>> for temp1 in schoolNames:
... for temp2 in temp1:
... print(temp2)
... print("-----------")
...
北京大学
清华大学
-----------
中山大学
华南师大
-----------
西安交大
西安电子科大
长安大学
-----------
列表应用：
一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机分配
#!/usr/bin/env python
import random
#1. 定义一个列表，用来存储8位老师的名字
tearchers = ['xiaoming','xiaowang','laozhang','xiaoliu','laoli','xiaozhao','jenry','smith']
#2. 定义一个列表，这里有3个办公室，用来等待老师分配
offices = [[],[],[]]
#3.通过循环的方式把8位老师随机分配到3个办公室
#注意：所谓的随机分配，即获取一个随机的办公室号，然后把这个老师添加到里面
for name in tearchers:
index = random.randint(0,2)
offices[index].append(name)
#print(offices)
#4.输出每个办公室里面的老师的信息
[root@localhost 03-day]# python 3-3.py
办公室1
xiaoming
xiaowang
xiaoliu
smith
--------------------
办公室2
--------------------
办公室3
laozhang
laoli
xiaozhao
jenry
--------------------
[root@localhost 03-day]# python 3-3.py
办公室1
xiaoliu
laoli
xiaozhao
smith
--------------------
办公室2
xiaoming
xiaowang
jenry
--------------------
办公室3
laozhang
--------------------
4.3 元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
>>> tup1 = ('physics', 'chemistry', 1997, 2000)
>>> tup2 = (1,2,3,4,5)
>>> tup3 = 'a','b','b','d'
创建空元组
>>> tup4 = ()
>>> tup3[0]='A'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
基本操作
>>> tup1[0]
'physics'
>>> tup2[1:3]
(2, 3)
>>> tup1 + tup2
('physics', 'chemistry', 1997, 2000, 1, 2, 3, 4, 5)
>>> del tup3
>>> tup3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'tup3' is not defined
>>> len(tup2)
5
>>> tuple('123')
('1', '2', '3')
4.4 字典
字典是另一种可变容器模型，且可存储任意类型对象，如其他容器模型。
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下：
>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
访问字典
>>> newNames = {'name1':'aaaa','name2':'bbbb','name3':'cccc'}
>>> newNames
{'name1': 'aaaa', 'name2': 'bbbb', 'name3': 'cccc'}
>>> newNames['name2']
'bbbb'
修改字典
>>> newNames['name3']='CCCC'
>>> newNames
{'name1': 'aaaa', 'name2': 'bbbb', 'name3': 'CCCC'}
radiansdict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
>>> newNames.get('name2')
'bbbb'
>>> newNames.get('name4','dddd')
'dddd'
>>> newNames
{'name1': 'aaaa', 'name2': 'bbbb'}
删除字典
>>> del newNames['name3']
>>> newNames
{'name1': 'aaaa', 'name2': 'bbbb'}
>>>
#删除整个字典
>>> del newNames
>>> newNames
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'newNames' is not defined
#清空字典
>>> dict
{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> dict.clear()
>>> dict
{}
len 长度
>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> len(dict)
3
>>> len(dict['Beth'])
4
keys 返回key
>>> dict.keys()
dict_keys(['Alice', 'Beth', 'Cecil'])
values 返回value
>>> dict.values()
dict_values(['2341', '9102', '3258'])
items 以列表返回可遍历的(键, 值) 元组数组
>>> dict.items()
dict_items([('Alice', '2341'), ('Beth', '9102'), ('Cecil', '3258')])
遍历字典
>>> dict
{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> for key,values in dict.items():
... print(key,values)
...
Alice 2341
Beth 9102
Cecil 3258
>>> for key,values in dict.items():
... print("key=%s,values=%s"%(key,values))
...
key=Alice,values=2341
key=Beth,values=9102
key=Cecil,values=3258
遍历字典元素
>>> for item in dict.items():
... print(item)
...
('Alice', '2341')
('Beth', '9102')
('Cecil', '3258')
遍历key
>>> for key in dict.keys():
... print(key)
...
Alice
Beth
Cecil
遍历value
>>> for value in dict.values():
... print(value)
...
2341
9102
3258
遍历
通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。
注意python语法的缩进
字符串遍历
>>> a_str = "hello itcast"
>>> for char in a_str:
... print(char,end=' ')
...
hello itcast
列表遍历
>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
... print(num,end=' ')
...
1 2 3 4 5
元组遍历
>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
... print(num,end=" ")
1 2 3 4 5
字典遍历
<1> 遍历字典的key（键）
<2> 遍历字典的value（值）
<3> 遍历字典的项（元素）
<4> 遍历字典的key-value（键值对）
想一想，如何实现带下标索引的遍历
>>> chars = ['a', 'b', 'c', 'd']
>>> i = 0
>>> for chr in chars:
... print("%d %s"%(i, chr))
... i += 1
...
0 a
1 b
2 c
3 d
enumerate()
>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
... print i, chr
...
0 a
1 b
2 c
3 d
1）生活中的字典
2）软件开发中的字典
公共方法
运算符
|
运算符 |
Python 表达式 |
结果 |
描述 |
支持的数据类型 |
|
+ |
[1, 2] + [3, 4] |
[1, 2, 3, 4] |
合并 |
字符串、列表、元组 |
|
* |
'Hi!' * 4 |
['Hi!', 'Hi!', 'Hi!', 'Hi!'] |
复制 |
字符串、列表、元组 |
|
in |
3 in (1, 2, 3) |
True |
元素是否存在 |
字符串、列表、元组、字典 |
|
not in |
4 not in (1, 2, 3) |
True |
元素是否不存在 |
字符串、列表、元组、字典 |
>>> "hello " + "itcast"
'hello itcast'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')
*
>>> 'ab'*4
'ababab'
>>> [1, 2]*4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b')*4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
in
>>> 'itc' in 'hello itcast'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True>>> "name" in {"name":"Delron", "age":24}
True
注意，in在对字典操作时，判断的是字典的键
python内置函数
Python包含了以下内置函数
|
序号 |
方法 |
描述 |
|
1 |
cmp(item1, item2) |
比较两个值 |
|
2 |
len(item) |
计算容器中元素个数 |
|
3 |
max(item) |
返回容器中元素最大值 |
|
4 |
min(item) |
返回容器中元素最小值 |
|
5 |
del(item) |
删除变量 |
cmp
>>> cmp("hello", "itcast")
-1
>>> cmp("itcast", "hello")
1
>>> cmp("itcast", "itcast")
0
>>> cmp([1, 2], [3, 4])
-1
>>> cmp([1, 2], [1, 1])
1
>>> cmp([1, 2], [1, 2, 3])
-1
>>> cmp({"a":1}, {"b":1})
-1
>>> cmp({"a":2}, {"a":1})
1
>>> cmp({"a":2}, {"a":2, "b":1})
-1
注意：cmp在比较字典数据时，先比较键，再比较值。
len
>>> len("hello itcast")
12
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({"a":1, "b":2})
2
注意：len在操作字典数据时，返回的是键值对个数。
max
>>> max("hello itcast")
't'
>>> max([1,4,522,3,4])
522
>>> max({"a":1, "b":2})
'b'
>>> max({"a":10, "b":2})
'b
'>>> max({"c":10, "b":2})
'c'
del
del有两种用法，一种是del加空格，另一种是del()
>>> a = 1
>>> a
1
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a = ['a', 'b']
>>> del a[0]
>>> a
['b']
>>> del(a)
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
多维列表/元祖访问的示例
>>> tuple1 = [(2,3),(4,5)]
>>> tuple1[0]
(2, 3)
>>> tuple1[0][0]
2
>>> tuple1[0][2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> tuple1[0][1]
3
>>> tuple1[2][2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range>>> tuple2 = tuple1+[(3)]>>> tuple2
[(2, 3), (4, 5), 3]>>> tuple2[2]3>>> tuple2[2][0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable
引用
想一想
>>> a = 1
>>> b = a
>>> b
1
>>> a = 2
>>> a
2
请问此时b的值为多少？
>>> a = [1, 2]
>>> b = a
>>> b
[1, 2]
>>> a.append(3)
>>> a
[1, 2, 3]
请问此时b的值又是多少？
引用
在python中，值是靠引用来传递来的。
我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。
>>> a = 1
>>> b = a
>>> id(a)
13033816
>>> id(b)
# 注意两个变量的id值相同13033816
>>> a = 2>>> id(a)
# 注意a的id值已经变了13033792
>>> id(b)
# b的id值依旧13033816
>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)
# 注意a与b始终指向同一个地址139935018544808
139935018544808
可变类型与不可变类型
可变类型，值可以改变：
-
- 列表 list
- 字典 dict
不可变类型，值不可以改变：
-
- 数值类型 int, long, bool, float
- 字符串 str
- 元组 tuple
怎样交换两个变量的值？
4.4 集合
set （集合）。集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合），intersection（交），difference（差）和 sysmmetric difference（对称差集）等数学运算。
1、创建集合
创建空集合
>>> s=set()
>>> s
set()
>>> s1=set([]) ＃列表
>>> s1
set()
>>> s2=set(()) ＃元组
>>> s2
set()
>>> s3=set({}) ＃字典
>>> s3
set()注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典，我们在后面介绍的一种数据结构。
创建非空集合
>>> s1=set([1,2,3,4])
>>> s1
{1, 2, 3, 4}
>>> s3=set({'a':2,'b':3,'c':4})
>>> s3
{'c', 'a', 'b'}注意：字典转set集合，需要注意的是，只取了字典的key，相当于将字典中的dict.keys()列表转成set集合。
2、集合操作
1）集合添加
集合的添加有两种方式，分别是add和update。但是它们在添加元素时是由区别的：
-
- add()方法
把要传入的元素作为一个整体添加到集合中，如：
- add()方法
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.add('two')
>>> s
{'e', 'two', 'o', 'n'}-
- update()方法
是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的字符。可以一次添加多个值，如：
- update()方法
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.update('two')
>>> s
{'e', 'n', 't', 'w', 'o'} 2）集合删除
集合的删除操作使用的方法跟列表是一样的，使用的也是remove方法。如：
-
-
setVar.remove(element)
setVar :为一个set类型的变量
element :表示要查找并删除的元素
函数作用：
在集合setVar中查找element元素，如果存在则删除；如果没找到，则报错。
-
setVar.remove(element)
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.remove('e')
>>> s
{'n', 'o'}-
-
setVar.discard(element)
setVar :为一个set类型的变量
element :表示要查找并删除的元素
函数作用：
在集合setVar中查找element元素，如果存在则删除；如果没找到，则什么也不做。
-
setVar.discard(element)
>>> sList
set([1, 2, 3, 4, 5])
>>> sList.discard(1)
>>> sList
set([2, 3, 4, 5])-
-
s.pop()
s：为set类型的变量
函数作用：
删除并返回set类型的s中的一个不确定的元素，如果为空引发KeyError错误。
-
s.pop()
>>> sList
set([2, 3, 4, 5])
>>> sList.pop()
2-
-
s.clear()
s：set类型的变量
函数作用：
清空s集合中的所有元素
-
s.clear()
>>> sList
set([3, 4, 5])
>>> sList.clear()
>>> sList
set([]) 3）集合的遍历
集合的遍历跟序列的遍历方法完全一样。
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for i in s:
print(i)
... ...
e
o
n
>>>
另一种遍历方式：
>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for idex,i in enumerate(s):
print (idex,i)
... ...
0 e
1 o
2 n
>>> 变量idex表示集合中元素i的索引。
3）集合其他方法
4）集合的操作方法
交集
Python中求集合的交集使用的符号是“&”，返回连个集合的共同元素的集合，即集合的交集。
>>> st1 = set('python')
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st2 = set('htc')
>>> st2
set(['h', 'c', 't'])
>>> st1 & st2
set(['h', 't'])或者：
>>> st1.intersection(st2)
{'t', 'h'}
并集（合集）
Python中求集合的并集用的是符号“|”，返回的是两个集合所有的并去掉重复的元素的集合。
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st3 = set('two')
>>> st3
set(['o', 't', 'w'])
>>> st1 | st3
set(['p', 't', 'w', 'y', 'h', 'o', 'n'])或者：
>>> st1.union(st2)
{'n', 't', 'y', 'p', 'o', 'c', 'h'}
差集
Python中差集使用的符号是减号“-”。
>>> st1
set(['1', '3', '2', '5', '4', '7', '6'])
>>> st2 = set('4589')
>>> st2
set(['9', '8', '5', '4'])
>>> st1 - st2
set(['1', '3', '2', '7', '6'])或者：
>>> st1.difference(st2)
{'6', '3', '2', '1', '7'}
返回的结果是在集合st1中但不在集合st2中的元素的集合。
集合的不同
查看两个集合的不同之处，使用的difference函数，等价于差集。如：
s1.difference(s3)
这种不同指的是集合s3相对于集合s1，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素组成的新集合。
>>> s1
set([1, 2, 3, 4, 5])
>>> s2
set([1, 2, 3, 4])
>>> s1.difference(s2)
set([5])
>>> s3
set(['1', '8', '9', '5'])
>>> s1.difference(s3)
set([1, 2, 3, 4, 5])
集合的范围判断
集合可以使用大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（！=）来判断某个集合是否完全包含于另一个集合，也可以使用子父集判断函数。
定义三个集合s1，s2，s3：
>>> s1＝set([1, 2, 3, 4, 5])
>>> s2＝set([1, 2, 3, 4])
>>> s3＝set(['1', '8', '9', '5'])
大于（>）或大于等于（>=）
>>> s1 > s2
True
>>> s1 > s3
False
>>> s1 >= s2
True
表示左边集合是否完全包含右边集合，如集合s1是否完全包含集合s2。
小于（<）或 小于等于（<=）
>>> s2 < s1
True
>>> s1 < s3
False
>>> s3 < s1
False
表示左边的集合是否完全包含于右边的集合，如集合s1是否完全包含于集合s2。
等于（==）、不等于（！=）
>>> s1 == s2
False
>>> s2 == s3
False
>>> s1 != s2
True
判断两个集合是否完全相同。
不可变集合frozenset
Python中还有一种不可改变的集合，那就是frozenset，不像set集合，可以增加删除集合中的元素，该集合中的内容是不可改变的，类似于字符串、元组。
>>> f = frozenset()
>>> f
frozenset([])
>>> f = frozenset('asdf')
>>> f
frozenset(['a', 's', 'd', 'f'])
>>> f = frozenset([1,2,3,4])
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset((1,2,3,4))
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset({1:2, 'a':2, 'c':3})
>>> f
frozenset(['a', 1, 'c'])
如果试图改变不可变集合中的元素，就会报AttributeError错误。
不可变集合，除了内容不能更改外，其他功能及操作跟可变集合set一样。
作业
1. 编程实现对一个元素全为数字的列表，求最大值、最小值
2. 编写程序，完成以下要求：
-
- 统计字符串中，各个字符的个数
- 比如："hello world" 字符串统计的结果为： h:1 e:1 l:3 o:2 d:1 r:1 w:1
3. 编写程序，完成以下要求：
-
- 完成一个路径的组装
- 先提示用户多次输入路径，最后显示一个完成的路径，比如/home/python/ftp/share
4. 编写程序，完成“名片管理器”项目
-
- 需要完成的基本功能：
- 添加名片
- 删除名片
- 修改名片
- 查询名片
- 退出系统
-
- 程序运行后，除非选择退出系统，否则重复执行功能
