我们人类可以很容易的分清数字与字符的区别,但是计算机并不能,计算机虽然很强大,但从某种角度上看又很傻,除非你明确的告诉它:1 是数字、Python 是字符,否则它是分不清 1Python 的区别的。因此,在每个编程语言里都会有一个叫数据类型的东西,其实就是对常用的各种数据类型进行了明确的划分,你想让计算机进行数值运算,你就传数字给它,你想让它处理字符,就传字符串类型给它。

运算符

运算符用于将各种类型的数据进行运算,Python 语言支持以下类型的运算符:

算术运算符

序号 运算符 描述
1 + 加 -- 两个对象相加
2 - 减 -- 两个对象相减
3 * 乘 -- 两个数相乘或是返回一个被重复若干次的字符串
4 / 除 -- x 除以 y
5 % 取模 -- 返回除法的余数
6 ** 幂 -- 返回 x 的 y 次幂
7 // 取整除 -- 返回商的整数部分(向下取整)
>>> a = 10
>>> b = 3 

>>> print("a + b =", a + b)
a + b = 13

>>> print("a - b =", a - b)
a - b = 7

>>> print("a * b =", a * b)
a * b = 30

>>> print("a / b =", a / b)
a / b = 3.3333333333333335

>>> print("a % b =", a % b)
a % b = 1

>>> print("a ** b =", a ** b)
a ** b = 1000

>>> print("a // b =", a // b)
a // b = 3

比较运算符

所有比较运算符返回 1 表示真,返回 0 表示假。这分别与特殊的变量 TrueFalse 等价。

序号 运算符 描述
1 == 等于 -- 比较对象是否相等
2 != 不等于 -- 比较两个对象是否不相等
3 > 大于 -- 返回 x 是否大于 y
4 < 小于 -- 返回 x 是否小于 y
5 >= 大于等于 -- 返回 x 是否大于等于 y
6 <= 小于等于 -- 返回 x 是否小于等于 y
>>> a = 23
>>> b = 17

>>> if (a == b):
...     print("a == b")
... elif (a != b):
...     print("a != b")
... elif (a > b):
...     print("a > b")
... elif (a < b):
...     print("a < b")
... elif (a >= b):
...     print("a >= b")
... elif (a <= b):
...     print("a <= b")
... 
a != b

赋值运算符

序号 运算符 描述
= == 简单赋值运算符
2 += 加法赋值运算符
3 -= 减法赋值运算符
4 *= 乘法赋值运算符
5 /= 除法赋值运算符
6 %= 取模赋值运算符
7 **= 幂赋值运算符
8 //= 取整除赋值运算符
>>> a = 10
>>> b = 3
>>> c = 0

>>> c += a
>>> print("c =", c)
c = 10

>>> c *= b
>>> print("c =", c)
c = 30

>>> c /= b
>>> print("c =", c)
c = 10.0

>>> c **= b
>>> print("c =", c)
c = 1000.0

>>> c //= b
>>> print("c =", c)
c = 333.0

逻辑运算符

序号 运算符 逻辑表达式 描述
1 and x and y 布尔"与" -- 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值
2 or x or y 布尔"或" -- 如果 x 为 True,它返回 x 的值,否则它返回 y 的计算值
3 not not x 布尔"非" -- 如果 x 为 True,返回 False;如果 x 为 False,它返回 True
# a 和 b 都为 True
>>> a = 20
>>> b = 10

>>> print("a and b =", a and b)
a and b = 10

>>> print("a or b =", a or b)
a or b = 20


# a 为 True, b 为 False
>>> a = 20
>>> b = 0

>>> print("a and b =", a and b)
a and b = 0

>>> print("a or b =", a or b)
a or b = 20


# a 为 False,b 为 True
>>> a = 0
>>> b = 10

>>> print("a and b =", a and b)
a and b = 0

>>> print("a or b =", a or b)
a or b = 10

位运算符

按位运算符是把数字看作二进制来进行计算的。

序号 运算符 描述
1 & 按位与运算符:参与运算的两个值,如果两个相应位都为 1,则该位的结果为 1,否则为 0
2 | 按位或运算符:只要对应的二个二进位有一个为 1 时,结果位就为 1
3 ^ 按位异或运算符:当两对应的二进位相异时,结果为 1
4 ~ 按位取反运算符:对数据的每个二进制位取反,即把 1 变为 0,把 0 变为 1
5 << 左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补 0
6 >> 右移动运算符:把 >> 左边的运算数的各二进位全部右移若干位,>> 右边的数字指定了移动的位数
>>> a = 60          # 60 = 0011 1100 
>>> b = 13          # 13 = 0000 1101 

>>> print("a & b =", a & b)
a & b = 12               # 0000 1100 = 12

>>> print("a | b =", a | b)
a | b = 61               # 0011 1101 = 61

>>> print("a ^ b =", a ^ b)
a ^ b = 49               # 0011 0001 = 49

>>> print("~a =", ~a)
~a = -61                 # 1100 0011 = -61

>>> print("a << 2 =", a << 2)
a << 2 = 240             # 1111 0000 = 240

>>> print("a >> 2 =", a >> 2)
a >> 2 = 15              # 0000 1111 = 15

成员运算符

序号 运算符 描述
1 in 如果在指定的序列中找到值则返回 True,否则返回 False
2 not in 如果在指定的序列中没有找到值则返回 True,否则返回 False
>>> a = 7
>>> b = 15
>>> lists = [1, 3, 5, 7, 9]

>>> if (a in lists):
...     print("a 在列表 lists 中")
... else:
...     print("a 不在列表 lists 中。")
... 
a 在列表 lists 

>>> if (b not in lists):
...     print("b 不在列表 lists 中")
... else:
...     print("b 在列表 lists 中")
... 
b 不在列表 lists 

身份运算符

身份运算符用于比较两个对象的存储单元。

序号 运算符 描述
1 is is 是判断两个标识符是不是引用自一个对象,如果引用的是同一个对象则返回 True,否则返回 False
2 is not is not 是判断两个标识符是不是引用自不同对象,如果引用的不是同一个对象则返回结果 True,否则返回 False

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符。

序号 运算符 描述
1 ** 幂运算
2 ~ + - 按位翻转, 一元加号和减号
3 * / % // 乘,除,取模和取整除
4 + - 加法减法
5 << >> 右移,左移运算符
6 & 位 'AND'
7 ^ | 位运算符
8 > >= < <= 比较运算符
9 == != 等于运算符
10 = %= /= //= -= += *= **= 赋值运算符
11 is is not 身份运算符
12 in not in 成员运算符
13 and or not 逻辑运算符
>>> a = 20
>>> b = 10
>>> c = 15
>>> d = 5

>>> print("(a + b) * c / d =", (a + b) * c / d)
(a + b) * c / d = 90.0

>>> print("((a + b) * c) / d =", ((a + b) * c) / d)
((a + b) * c) / d = 90.0

>>> print("(a + b) * (c / d) =", (a + b) * (c / d))
(a + b) * (c / d) = 90.0

>>> print("a + (b * c) / d =", a + (b * c) / d)
a + (b * c) / d = 50.0

基本数据类型

Python3 中有六个标准的数据类型:

Python3 的六个标准数据类型中:

  • 不可变数据类型: NUMBER、STRING、TUPLE
  • 可变数据类型: LIST、SET、DICT

NUMBER

Python 支持三种不同的数字类型:

  • 整型 int
  • 浮点型 float
  • 复数 complex

数字类型转换:

  • int(x) 将 x 转换为一个整数
  • float(x) 将 x 转换为一个浮点数
  • complex(x) 将 x 转换为一个复数,实数部分为 x,虚数部分为 0
  • complex(x, y) 将 x 和 y 转换为一个复数,实数部分为 x,虚数部分为 y,x 和 y 是数字表达式

内置函数与方法:

序号 函数 描述
1 abs(n) 返回数字 n 的绝对值
2 ceil(n) 返回数字 n 的上入整数
3 floor(n) 返回数字 n 的下舍整数
4 exp(n) 返回数字 n 的指数
5 max(n1, n2, ...) 返回给定参数的最大值,参数可以为序列幂
6 min(n1, n2, ...) 返回给定参数的最小值,参数可以为序列
7 modf(n) 返回数字 n 的小数部分与整数部分,两部分的数值符号与数字 n 相同,整数部分以浮点型表示值
8 round(n [,p]) 返回浮点数 n 的四舍五入值,如给出 p 值,则代表舍入到小数点后的位数
9 sqrt(n) 返回数字 n 的平方根
10 pow(n1, n2) 数字 n1 ** n2 运算后的值
11 choice(seq) 从序列的元素中随机挑选一个元素
12 random() 随机生成一个实数,它在 [0, 1) 范围内
13 sin(n) 返回弧度 n 的正弦值
  • abs(n)

返回数字 n 的绝对值:

>>> print ("abs(-40) =", abs(-40))
abs(-40) = 40
  • ceil(n)

返回一个大于或等于数字 n 的最小整数:

>>> import math

>>> print ("math.ceil(-45.17) =", math.ceil(-45.17))
math.ceil(-45.17) = -45

>>> print ("math.ceil(99.15) =", math.ceil(99.15))
math.ceil(99.15) = 100
  • floor(n)

返回一个小于或等于数字 n 的最小整数:

>>> import math

>>> print ("math.floor(-45.17) =", math.floor(-45.17))
math.floor(-45.17) = -46

>>> print ("math.floor(99.15) =", math.floor(99.15))
math.floor(99.15) = 99
  • exp(n)

返回 n 的指数:

>>> import math 

>>> print ("math.exp(math.pi) =", math.exp(math.pi))
math.exp(math.pi) = 23.140692632779267
  • max(n1, n2, ...)

返回给定参数的最大值,参数可以为序列:

>>> print ("max(-80, -20, -10) =", max(-80, -20, -10))
max(-80, -20, -10) = -10
  • min(n1, n2, ...)

返回给定参数的最小值,参数可以为序列:

>>> print ("min(-80, -20, -10) =", min(-80, -20, -10))
min(-80, -20, -10) = -80
  • modf(n)

返回数字 n 的小数部分与整数部分,两部分的数值符号与 n 相同,整数部分以浮点型表示:

>>> import math 

>>> print ("math.modf(math.pi) =", math.modf(math.pi))
math.modf(math.pi) = (0.14159265358979312, 3.0)
  • round(n [,p])

返回浮点数 n 的四舍五入值:

>>> import math

>>> print ("round(math.pi, 2) =", round(math.pi, 2))
round(math.pi, 2) = 3.14
  • sqrt(n)

返回数字 n 的平方根:

>>> import math

>>> print ("math.sqrt(9) =", math.sqrt(9))
math.sqrt(9) = 3.0
  • pow(n1, n2)

返回数字 n1 的 n2 次方的值:

>>> import math

>>> print ("math.pow(100, 2) =", math.pow(100, 2))
math.pow(100, 2) = 10000.0
  • choice(seq)

返回一个列表、元组或字符串的随机项:

>>> import random

>>> print ("从 range(100) 返回一个随机数 =",random.choice(range(100)))
 range(100) 返回一个随机数 = 29

>>> print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 =", random.choice([1, 2, 3, 5, 9]))
从列表中 [1, 2, 3, 5, 9] 返回一个随机元素 = 1
  • random()

返回随机生成的一个实数,它在 [0,1) 范围内:

>>> import random

>>> print ("random() =", random.random())
random() = 0.5426028101355577
  • sin(n)

返回 n 弧度的正弦值:

>>> import math 

>>> print ("math.sin(math.pi) =",  math.sin(math.pi))
math.sin(math.pi) = 1.2246467991473532e-16

>>> print ("math.sin(90) =", math.sin(90))
math.sin(90) = 0.8939966636005579

STRING

Python中的字符串用单引号 ' 或双引号 " 括起来,同时使用反斜杠 \ 转义特殊字符。

序号 目录
1 字符串内置方法
2 字符串格式化
3 字符串切片
4 字符串拆分
5 字符串连接及拼接
6 字符串编码

字符串内置函数与方法

序号 函数与方法 描述
1 capitalize() 将字符串的第一个字符转换为大写
2 count() 统计字符串里某个字符出现的次数
3 join(seq) 将序列中的元素以指定的字符连接生成一个新的字符串
4 len(s) 返回字符串长度
5 replace(old, new [, max]) 将字符串中的 old 替换成 new
6 split(s, n)) 以 s 为分隔符截取字符串 n 次
7 find() 检测 str 是否包含在字符串中,如果包含则返回开始的索引值,否则返回 -1
8 rfind() 返回字符串最后一次出现的位置,如果没有匹配项则返回 -1
9 index() 跟 find() 方法一样,不过如果子字符串 s 不在字符串中会报一个异常
10 rindex() 返回子字符串 s 在字符串中最后出现的位置,如果没有匹配的字符串会报异常
11 rstrip() 删除字符串末尾的空格或指定字符
12 lstrip() 删除字符串左边的空格或指定字符
13 strip() 移除字符串头尾指定的字符(默认为空格)或字符序列
14 upper() 转换字符串中的小写字符为大写
15 lower() 转换字符串中所有大写字符为小写
16 max(s) 返回字符串中最大的字符
17 min(s) 返回字符串中最小的字符
18 isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
19 isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
20 isdigit() 如果字符串只包含数字则返回 True,否则返回 False
21 islower() 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
22 isupper() 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
23 endswith(suffix, beg=0, end=len(string)) endswith(suffix, beg=0, end=len(string))
24 encode(encoding='UTF-8', errors='strict') 以指定的编码格式编码字符串
25 bytes.decode(encoding="utf-8", errors="strict") 以指定的编码格式解码 bytes 对象,默认编码为 'utf-8'
  • capitalize()

将字符串的第一个字母变成大写,其他字母变小写,首字符如果是非字母,则其不会转换成大写,但其它所有字符都会转换成小写:

>>> s = "hello PYTHON"
>>> s.capitalize()
'Hello python'

>>> s = "123 Hello Python"
>>> s.capitalize()
'123 hello python'
  • count()

统计字符串里某个字符出现的次数,可选参数为在字符串搜索的开始与结束位置:

>>> s = "https://www.python.org"
>>> sub = "o"

>>> s.count(sub)
2

>>> sub = "t"
>>> s.count(sub, 10, 20)
1
  • join(seq)

将序列中的元素以指定的字符连接生成一个新的字符串:

>>> s = "-"                                # 连接串
>>> seq = ('P', 'Y', 'T', 'H', 'O', 'N')   # 字符串序列

>>> s.join(seq)
'P-Y-T-H-O-N'
  • len(s)
>>> s = "I Love it."
>>> len(s)
10

replace()

将字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数 max,则替换不超过 max 次:

>>> s = "www.baidu.com"
>>> s.replace('baidu.com', 'python.org')
'www.python.org'

>>> s = "this is string example....wow!!!"
>>> s.replace('is', 'was', 2)
'thwas was string example....wow!!!'
  • split(s, n))

通过指定分隔符 s 对字符串进行切片,如果参数 n 有指定值,则表示分隔次数为 n(分割次数 n 默认为 -1, 即分隔所有):

s = "this is string example....wow!!!"


# 以空格为分隔符
>>> s.split()
['this', 'is', 'string', 'example....wow!!!']


# 以 w 为分隔符
>>> s.split('w')
['this is string example....', 'o', '!!!']


# 以 i 为分隔符,且分隔次数为 1 
>>> s.split('i', 1)
['th', 's is string example....wow!!!']
  • find()

检测字符串中是否包含子字符串 s ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置,如果不包含索引值,返回 -1:

>>> s = 'abca'


# 从下标 0 开始,查找在字符串里第一个出现的子串
>>> s.find('a')
0


# 从下标 1 开始,查找在字符串里第一个出现的子串
>>> s.find('a', 1) 
3


# 查找不到返回 -1
>>> s.find('3')  
-1
  • rfind()

返回字符串最后一次出现的位置,如果没有匹配项则返回 -1:

>>> s1 = "this is really a string example....wow!!!"
>>> s2 = "is"

>>> s1.rfind(s2)
5

>>> s1.find(s2)
2
  • index()

检测字符串中是否包含子字符串 s ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,该方法与 python find()方法一样,只不过如果 s 不在 string 中会抛出一个异常:

>>> s1 = "Runoob example....wow!!!"
>>> s2 = "exam"

>>> s1.index(s2)
7

>>> s1.index(s2, 5)
7

>>> s1.index(s2, 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
  • rindex()

返回子字符串 s 在字符串中最后出现的位置,如果没有匹配的字符串会报异常,你可以指定可选参数 [beg:end] 设置查找的区间:

>>> s1 = "this is really a string example....wow!!!"
>>> s2 = "is"

>>> s1.rindex(s2)
5

>>> s1.rindex(s2, 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
  • rstrip()

删除字符串末尾的空格或指定字符(默认为空格):

>>> s = "     this is string example....wow!!!     "

>>> s.rstrip()
'     this is string example....wow!!!'


>>> s = "*****this is string example....wow!!!*****"

>>> s.rstrip('*')
'*****this is string example....wow!!!'
  • lstrip()

删除字符串左边的空格或指定字符(默认为空格):

>>> s = "     this is string example....wow!!!     "

>>> s.lstrip()
'this is string example....wow!!!     '


>>> s = "88888888this is string example....wow!!!8888888"

>>> s.lstrip('8')
'this is string example....wow!!!8888888'
  • strip()

删除字符串头尾指定的字符(默认为空格)或字符序列,该方法只能删除开头或是结尾的字符,不能删除中间部分的字符:

# 删除指定字符串 '*'

>>> s = "*****this is **string** example....wow!!!*****"

>>> s.strip( '*' )
'this is **string** example....wow!!!'


# 删除字符序列 '12'

>>> s = "123abcrunoob321"

>>> s.strip('12')
'3abcrunoob3'
  • upper()
>>> s = "www.baidu.com"

>>> s.upper()
'WWW.BAIDU.COM'
  • lower()
>>> s = "ORACLE ACE"

>>> s.lower()
'oracle ace'
  • max(s)
>>> s = "www.baidu.com"

>>> max(s)
'w'
  • min(s)
>>> s = "www.baidu.com"

>>> min(s)
'.'
  • isalnum()
>>> s = "www.baidu.com"

>>> s.isalnum()
False
  • isalpha()
>>> s = "www.baidu.com"

>>> s.isalpha()
False


>>> s = "baidu"

>>> s.isalpha()
True
  • isdigit()
>>> s = "1 3 5 7 9"

>>> s.isdigit()
False


>>> s = "123"

>>> s.isdigit()
True
  • islower()
>>> s = "www.baidu.com"

>>> s.islower()
True
  • isupper()
>>> s = "WWW.BAIDU.COM"

>>> s.islower()
True
  • endswith(suffix, beg=0, end=len(string))

判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回 True,否则返回 False,可选参数 start 与 end 为检索字符串的开始与结束位置:

>>> s = 'Runoob example....wow!!!'
>>> suffix='!!'

>>> s.endswith(suffix)
True

>>> s.endswith(suffix, 30, 100)
False


>>> s = 'Runoob example....wow!!!'
>>> suffix='run'

>>> s.endswith(suffix)
False
  • encode(encoding='UTF-8', errors='strict')
>>> s = "字符串"
>>> s_utf8 = s.encode('UTF-8')
>>> s_gbk = s.encode('GBK')

>>> print ("UTF-8 编码:", s_utf8)
UTF-8 编码: b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'

>>> print ("GBK 编码:", s_gbk)
GBK 编码: b'\xd7\xd6\xb7\xfb\xb4\xae'
  • bytes.decode(encoding="utf-8", errors="strict")

Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 s.encode() 来编码返回:

>>> s = "字符串"
>>> s_utf8 = s.encode('UTF-8')
>>> s_gbk = s.encode('GBK')

>>> print (s)
字符串

>>> print ("UTF-8 编码:", s_utf8)
UTF-8 编码: b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'

>>> print ("GBK 编码:", s_gbk)
GBK 编码: b'\xd7\xd6\xb7\xfb\xb4\xae'

>>> print("UTF-8 解码:", s_utf8.decode('UTF-8', 'strict'))
UTF-8 解码: 字符串

>>> print("GBK 解码:", s_gbk.decode('GBK', 'strict'))
GBK 解码: 字符串

字符串格式化

  • %s 形式
>>> print('hello %s and %s' %('Python', 'Oracle'))
hello Python and Oracle
  • %s + 字典 形式
>>> print('hello %(first)s and %(second)s' %{'first':'Python', 'second':'Oracle'})
hello Python and Oracle
  • .format 形式
>>> print('hello {0} and {1}'.format('Python', 'Oracle'))
hello Python and Oracle

>>> print('hello {first} and {second}'.format(first='Python', second='Oracle'))
hello Python and Oracle

字符串切片
字符串切片操作(slice),可以从一个字符串中获取子字符串,我们使用一对方括号 、起始偏移量 start 、终止偏移量 end 以及可选的步长 step 来定义一个分片。

序号 方法 描述
1 [:] 提取从开头(默认位置0)位置到结尾(默认位置-1)位置的整个字符串
2 [start:] 从 start 位置提取到结尾位置
3 [:end] 从开头位置提取到 end - 1 位置
4 [start:end] 从 start 位置提取到 end - 1 位置
5 [start:end:step] 从 start 位置提取到 end - 1 位置,每 step 个字符提取一个
  • 基础用法:
>>> letter = 'abcd'

>>> letter[0]
'a'

>>> letter[-1]
'd'
  • 提取最后 N 个字符:
>>> letter = 'abcdefghijklmnopqrstuvwxyz'

>>> letter[-3:]
'xyz'
  • 从开头到结尾,step 为 N:
>>> letter[::5]
'afkpuz'
  • 将字符串倒转(reverse), 通过设置步长为负数:
>>> letter[::-1]
'zyxwvutsrqponmlkjihgfedcba'

字符串拆分

  • 无参数字符串拆分:

如果不指定任何分隔符,split() 会使用空格作为分割符,并返回 list 类型数据:

>>> s = "this is my string"

>>> s.split()
['this', 'is', 'my', 'string']

>>> type(s.split())
<class 'list'>
>>> 
  • 指定分隔符:

当指定分隔符后, split() 会使用指定的分隔符,对字符串进行分隔:

>>> s = '<a href="www.baidu.com">baidu</a>'

>>> s.split('"')[1].split('.')
['www', 'baidu', 'com']
  • 使用 Maxsplit 对拆分进行限定:

split() 有一个名为 maxsplit 的可选参数,默认情况下,split() 将在调用时进行所有可能的拆分,但是,如果对 maxsplit 赋值后,就只会生成指定数量的拆分:

>>> s = "this is my string"

>>> s.split(maxsplit=1)
['this', 'is my string']

练习: 使用 split 对 CSV 文件进行分隔

CSV 文件:

Name,Phone,Address
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Guido van Rossum,315558730,Science Park 123, 1980 XG Amsterdam, NL


希望得到的数据:

[
    ['Mike Smith', '15554218841', '123 Nice St, Roy, NM, USA'],
    ['Anita Hernandez', '15557789941', '425 Sunny St, New York, NY, USA'],
    ['Guido van Rossum', '315558730', 'Science Park 123, 1980 XG Amsterdam, NL']
]


Python 代码:

>>> s = """Name,Phone,Address
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Guido van Rossum,315558730,Science Park 123, 1980 XG Amsterdam, NL"""

>>> def str_split(unsplit):
...     results = []
...     for line in unsplit.split('\n')[1:]:
...         results.append(line.split(',', maxsplit=2))
...     return results
...

>>> print(str_split(s))
[['Mike Smith', '15554218841', '123 Nice St, Roy, NM, USA'], ['Anita Hernandez', '15557789941', '425 Sunny St, New York, NY, USA'], ['Guido van Rossum', '315558730', 'Science Park 123, 1980 XG Amsterdam, NL']]

字符串连接及拼接

  • 使用运算符 + 将多个字符串连接在一起:
>>> s1 = "hello"
>>> s2 = "world"

>>> s = s1 + ' ' +  s2

>>> s
'hello world'
  • 使用 join() 方法用于将字符串素以指定的字符(分隔符)连接生成一个新的字符串:
>>> s = "python"

>>> ','.join(s)
'p,y,t,h,o,n'
>>> li = ['hello', 'python']

>>> ','.join(li)
'hello,python'

字符串编码
通过以下代码查看 Python 3 的字符串默认编码:

>>> import sys

>>> sys.getdefaultencoding()
'utf-8'

使用 Python 解释器进行如下编码解码操作,在 bytesstr 之间转换:

>>> '字符串'.encode()
b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'

>>> b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'.decode('utf-8')
'字符串'

LIST

序列是 Python中 最基本的数据结构,序列中的每个元素都会分配一个数字 代表它的位置或索引:第一个索引是 0、第二个索引是 1,依此类推。

序号 目录
1 访问列表中的值
2 更新列表
3 删除列表元素
4 列表截取与拼接
5 嵌套列表
6 列表函数
7 列表方法

访问列表中的值
使用下标索引来访问列表中的值,同样也可以使用方括号的形式截取字符,如下所示:

>>> l1 = ['Google', 'Baidu', 1997, 2000]
>>> l2 = [1, 3, 5, 6, 7 ]

>>> print ("l1[0] =", l1[0])
l1[0] = Google

>>> print ("l2[1:3] =", l2[1:3])
l2[1:3] = [3, 5]

更新列表
对列表的数据项进行修改或更新,也可以使用 append() 方法来添加列表项,如下所示:

>>> l = ['Google', 'Baidu', 1997, 2000]

>>> print ("第三个元素为 =", l[2])
第三个元素为 = 1997

>>> l[2] = 2001

>>> print ("更新后的第三个元素为 : ", l[2])
更新后的第三个元素为 :  2001

删除列表元素
可以使用 del 方法来删除列表的的元素,如下所示:

>>> l = ['Google', 'Baidu', 1997, 2000]

>>> print ("原始列表 =", l)
原始列表 = ['Google', 'Baidu', 1997, 2000]

>>> del l[2]

>>> print ("删除第三个元素 =", l)
删除第三个元素 = ['Google', 'Baidu', 2000]

列表截取与拼接

>>> l = ['Google', 'Baidu', 'Safari']

>>> l[2]
'Safari'

>>> l[-2]
'Baidu'

>>> l[1:]
['Baidu', 'Safari']

>>> l += ['firefox']

>>> l
['Google', 'Baidu', 'Safari', 'firefox']

嵌套列表
使用嵌套列表即在列表里创建其它列表,如下所示:

>>> l1 = ['a', 'b', 'c']

>>> l2 = [1, 2, 3]

>>> l3 = [l1, l2]

>>> l3 
[['a', 'b', 'c'], [1, 2, 3]]

列表函数

序号 函数 描述
1 len(list) 返回列表元素个数
2 max(list) 返回列表元素最大值
3 min(list) 返回列表元素最小值
4 list(seq) 将元组或字符串转换为列表
  • len(list)
>>> l1 = ['Google', 'Baidu', 'Safari']

>>> print("len(l1) =", len(l1))
len(l1) = 3


>>> l2 = list(range(10))

>>> print("len(l2) =", len(l2))
len(l2) = 10
  • max(list)
>>> l1, l2 = ['Google', 'Baidu', 'Safari'], [3, 7, 9]

>>> print ("l1 最大元素值 =", max(l1))
l1 最大元素值 = Safari

>>> print ("l2 最大元素值 =", max(l2))
l2 最大元素值 = 9
  • min(list)
>>> l1, l2 = ['Google', 'Baidu', 'Safari'], [3, 7, 9]

>>> print ("l1 最小元素值 =", min(l1))
l1 最小元素值 = Baidu

>>> print ("l2 最小元素值 =", min(l2))
l2 最小元素值 = 3
  • list(seq)
>>> t = (123, 'Google', 'Baidu', 'Safari')

>>> l1 = list(t)

>>> print ("列表元素 =", l1)
列表元素 = [123, 'Google', 'Baidu', 'Safari']


>>> s = "Hello World"

>>> l2 = list(s)

>>> print ("列表元素 =", l2)
列表元素 = ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

列表方法

序号 方法 描述
1 list.append() 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反转列表中元素
9 list.sort() 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表
  • list.append()

用于在列表末尾添加新的对象:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.append('firefox')

>>> print ("更新后的列表 =", l)
更新后的列表 = ['Google', 'Baidu', 'Safari', 'firefox']
  • list.count(obj)

用于统计某个元素在列表中出现的次数:

>>> l = [123, 'Google', 'Baidu', 'Safari', 123];

>>> print ("123 元素个数 =", l.count(123))
123 元素的个数 = 2

>>> print ("'Safari' 元素个数 =", l.count('Safari'))
'Safari' 元素的个数 = 1
  • list.extend(seq)

用于在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表):

>>> language = ['French', 'English', 'German']

>>> language_tuple = ('Spanish', 'Portuguese')

>>> language_set = {'Chinese', 'Japanese'}

>>> language.extend(language_tuple)

>>> print('新列表 =', language)
新列表 = ['French', 'English', 'German', 'Spanish', 'Portuguese']

>>> language.extend(language_set)

>>> print('新列表 =', language)
新列表 = ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Japanese', 'Chinese']
  • list.index(obj)

用于从列表中找出某个值第一个匹配项的索引位置,如果没有找到对象则抛出异常:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.index('Safari')
2

>>> l.index('Firefox')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'Firefox' is not in list
  • list.insert(index, obj)

用于将指定对象插入列表的指定下标位置:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.insert(1, 'Firefox')

>>> l
['Google', 'Firefox', 'Baidu', 'Safari']
  • list.pop([index=-1])

用于移除列表中的一个元素(默认最后一个元素),也可以指定元素的下标来进行移除,并且返回该元素的值:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.pop()
'Safari'

>>> l
['Google', 'Baidu']

>>> l.pop(1)
'Baidu'

>>> l
['Google']
  • list.remove(obj)

用于移除列表中某个值的第一个匹配项:

>>> l = ['Google', 'Baidu', 'Safari', 'Google']

>>> l.remove('Google')

>>> l
['Baidu', 'Safari', 'Google']

>>> l.remove('Baidu')

>>> l
['Safari', 'Google']
  • list.reverse()

用于反转列表中元素:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.reverse()

>>> l  
['Safari', 'Baidu', 'Google']
  • list.sort()

用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数进行排序:

# 默认升序

>>> l = [1, 5, 23, 19, 7]

>>> l.sort()

>>> l
[1, 5, 7, 19, 23]


# 降序
>>> l = [1, 5, 23, 19, 7]

>>> l.sort(reverse=True)

>>> l
[23, 19, 7, 5, 1]
  • list.clear()

用于清空列表:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l.clear()

>>> l 
[]
  • list.copy()

用于复制列表:

>>> l = ['Google', 'Baidu', 'Safari']

>>> l2 = l.copy()

>>> l2 
['Google', 'Baidu', 'Safari']

TUPLE

Python 的元组与列表类似,不同之处在于元组的元素不能修改且元组使用小括号,而列表使用方括号。

序号 目录
1 创建元祖
2 访问元组
3 修改元组
4 删除元组
5 元组索引、截取
6 元组内置函数

创建元祖
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

# 创建空元祖

tup1 = ();


# 创建只有一个元素的元祖

tup2 = (50,)


# 创建多个元素的元祖

tup3 = ('Google', 'Baidu', 'Safari')

访问元组
可以使用下标索引来访问元组中的值,如下所示:

>>> tup1 = ('Google', 'Baidu', 'Safari')

>>> tup2 = (1, 3, 5, 6)

>>> tup1[0]
'Google'

>>> tup2[1:3]
(3, 5)

修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下所示:

>>> tup1 = (12, 34.56)

>>> tup2 = ('abc', 'xyz')


# 创建一个新的元组

>>> tup3 = tup1 + tup2

>>> tup3
(12, 34.56, 'abc', 'xyz')


# 以下修改元组元素操作是非法的

>>> tup1[0] = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

删除元组
元组中的元素值是不允许删除的,但我们可以使用 del 语句来删除整个元组,如下所示:

>>> tup = ('Google', 'Baidu', 'Safari')

>>> del(tup)

>>> tup 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tup' is not defined

元组索引、截取
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:

>>> tup = ('Google', 'Baidu', 'Safari')

>>> tup[2]
'Safari'

>>> tup[-2]
'Baidu'

>>> tup[1:]
('Baidu', 'Safari')

元组内置函数

序号 函数 描述
1 len(tuple) 计算元组元素个数
2 max(tuple) 返回元组中元素最大值
3 min(tuple) 返回元组中元素最小值
4 tuple(seq) 将列表或字符串转换为元组
  • len(tuple)

计算元组元素个数:

>>> tup = ('Google', 'Baidu', 'Safari')

>>> len(tup)
3
  • max(tuple)

返回元组中元素最大值:

>>> tup = ('Google', 'Baidu', 'Safari')

>>> max(tup)
'Safari'
  • min(tuple)

返回元组中元素最小值:

>>> tup = ('Google', 'Baidu', 'Safari')

>>> min(tup)
'Baidu'
  • tuple(seq)

将列表或字符串转换为元组:

>>> l = ['Google', 'Baidu', 'Safari', 'Firefox']

>>> tup = tuple(l)

>>> tup 
('Google', 'Baidu', 'Safari', 'Firefox')

SET

集合是一个无序的不重复元素序列。

序号 目录
1 创建集合
2 添加元素
3 移除元素
4 计算集合元素个数
5 清空集合
6 判断元素是否在集合中存在
7 集合内置方法

创建集合
可以使用大括号 { } 或者 set() 函数来创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典的。

# 创建空集合

>>> set01 = {}

>>> set02 = set()

>>> print(type(set01))
<class 'dict'>

>>> print(type(set02))
<class 'set'>


# 创建多个元素的集合

basket = {'orange', 'banana', 'pear', 'apple'}

添加元素
将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作:

>>> netset = set(('Google', 'Baidu', 'Safari'))

>>> netset.add('Firefox')

>>> print(netset)
{'Firefox', 'Baidu', 'Google', 'Safari'}

移除元素
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误:

>>> netset = set(('Google', 'Baidu', 'Safari'))

>>> netset.remove('Safari')

>>> print(netset)
{'Baidu', 'Google'}

>>> netset.remove('Firefox')   
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Firefox'

计算集合元素个数

>>> netset = set(('Google', 'Baidu', 'Safari'))

>>> len(netset)
3

清空集合

>>> netset = set(('Google', 'Baidu', 'Safari'))

>>> netset.clear()

>>> netset
set()

判断元素是否在集合中存在
判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False:

>>> netset = set(('Google', 'Baidu', 'Safari'))

>>> 'Google' in netset

>>> 'Firefox' in netset
False

集合内置方法

序号 方法 描述
1 add() 为集合添加元素
2 clear() 移除集合中的所有元素
3 copy() 拷贝一个集合
4 difference() 返回多个集合的差集
5 difference_update() 移除两个集合中都存在的元素
6 discard() 移除集合中的元素,该元素在指定的集合也存在
7 intersection() 返回集合的交集
8 intersection_update() 移除集合中的元素,该元素在指定的集合中不存在
9 isdisjoint() 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False
10 issubset() 判断指定集合是否为该方法参数集合的子集
11 issuperset() 判断该方法的参数集合是否为指定集合的子集
12 pop() 随机移除元素
13 remove() 移除指定元素
14 symmetric_difference() 返回两个集合中不重复的元素集合
15 symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中
16 union() 返回两个集合的并集
17 update() 为集合添加元素
  • add()

用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.add('orange') 

>>> fruits
{'banana', 'apple', 'cherry', 'orange'}


# 元素在集合中已存在

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.add('apple')

>>> fruits
{'banana', 'apple', 'cherry'}
  • clear()

用于移除集合中的所有元素:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.clear()

>>> fruits
set()
  • copy()

用于拷贝一个集合:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> x = fruits.copy()

>>> x
{'banana', 'apple', 'cherry'}
  • difference()

返回集合的差集,即返回的集合元素包含在第一个集合中,但不包含在第二个集合中:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> z = x.difference(y) 

>>> z
{'banana', 'cherry'}
  • difference_update()

用于移除两个集合中都存在的元素:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.difference_update(y)

>>> x 
{'banana', 'cherry'}
  • discard()

用于移除指定的集合元素,该方法不同于 remove() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.discard('apple')

>>> fruits
{'banana', 'cherry'}


# 移除一个不存在的元素

>>> fruits.discard('orange')
  • intersection()

用于返回两个或更多集合中都包含的元素,即交集:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.intersection(y)
{'apple'}
  • intersection_update()

用于移除两个或更多集合中都不重叠的元素,即计算交集:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.intersection_update(y)

>>> x
{'apple'}
  • isdisjoint()

用于判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.isdisjoint(y)
False
  • issubset()

用于判断集合的所有元素是否都包含在指定集合中,如果是则返回 True,否则返回 False:

# 判断集合 x 的所有元素是否都包含在集合 y 中

>>> x = {'a', 'b', 'c'}

>>> y = {'a', 'f', 'd', 'c', 'b'}

>>> x.issubset(y)
True
  • issuperset()

用于判断指定集合的所有元素是否都包含在原始的集合中,如果是则返回 True,否则返回 False:

# 判断集合 y 的所有元素是否都包含在集合 x 中

>>> x = {'a', 'f', 'd', 'c', 'b'}

>>> y = {'a', 'b', 'c'}

>>> x.issuperset(y)
True
  • pop()

用于随机移除一个元素:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.pop()
'banana'
  • remove()

用于移除集合中的指定元素,该方法不同于 discard() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会:

>>> fruits = {'apple', 'banana', 'cherry'}

>>> fruits.remove('apple')

>>> fruits
{'banana', 'cherry'}


# 移除一个不存在的元素

>>> fruits.remove('orange')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'orange'
  • symmetric_difference()

返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.symmetric_difference(y)
{'banana', 'microsoft', 'cherry', 'google'}
  • symmetric_difference_update()

移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中:

# 在原始集合 x 中移除与 y 集合中的重复元素,并将不重复的元素插入到集合 x 中

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.symmetric_difference_update(y)

>>> x 
{'banana', 'microsoft', 'cherry', 'google'}
  • union()

返回两个集合的并集,即包含了所有集合的元素,重复的元素只会出现一次:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.union(y)
{'banana', 'microsoft', 'cherry', 'google', 'apple'}
  • update()

用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略:

>>> x = {'apple', 'banana', 'cherry'}

>>> y = {'google', 'microsoft', 'apple'}

>>> x.update(y)

>>> x 
{'banana', 'microsoft', 'cherry', 'google', 'apple'}

DICT

字典是另一种可变容器模型,且可存储任意类型对象。

序号 目录
1 创建字典
2 访问字典里的值
3 修改字典
4 删除字典元素
5 字典键的特性
6 字典内置函数
7 字典内置方法

创建字典
字典的每个键 key 和 值 value 用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包含在花括号 {} 中。

# 创建空字典

>>> dict1 = {}

>>> print(type(dict1))
<class 'dict'>


# 创建多个元素的字典

dict2 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

访问字典里的值
把相应的键放入到方括号中,进行访问,如下所示:

>>> print("dict2['NAME'] =", dict2['NAME'])
dict2['NAME'] = Smith

如果用字典里没有的键访问数据,会输出错误,如下所示:

>>> print("dict2['NO'] =", dict2['NO'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'NO'

修改字典
向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对,如下所示:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

# 更新字典

>>> dict1['JOB'] = 'Salesman'

>>> dict1
{'NAME': 'Smith', 'JOB': 'Salesman', 'SALARY': '1000'}


# 添加信息

>>> dict1['LOC'] = 'China'

>>> dict1 
{'NAME': 'Smith', 'JOB': 'Salesman', 'SALARY': '1000', 'LOC': 'China'}
>>> 

删除字典元素
能删除单个元素也能清空字典:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}


# 删除单个元素
>>> del dict1['SALARY']

>>> dict1
{'NAME': 'Smith', 'JOB': 'Cleak'}


# 清空字典

>>> dict1.clear()

>>> dict1
{}

字典键的特性
字典值可以是任何的 Python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。

  • 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会覆盖前一个,如下所示:
>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'NAME': 'Blake'}

>>> dict1
{'NAME': 'Blake', 'JOB': 'Cleak'}
  • 键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下所示:
>>> dict1 = {['NAME']: 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

字典内置函数

序号 函数 描述
1 len(dict) 计算字典元素个数,即键的总数
2 type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型
  • len(dict)
>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> len(dict1)
3
  • type(variable)
>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> type(dict1)
<class 'dict'>

字典内置方法

序号 方法 描述
1 clear() 删除字典内所有元素
2 copy() 返回一个字典的浅复制
3 fromkeys(seq[, value]) 创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值
4 get(key, default=None) 返回指定键的值,如果值不在字典中返回 default 值
5 key in dict 如果键在字典里则返回 True,否则返回 False
6 items() 以列表形式返回可遍历的(键、值)元组数组
7 keys() 返回一个迭代器,可以使用 list() 来转换为列表
8 setdefault(key, default=None) 和 get() 类似, 但如果键不存在于字典中,将会添加键并将值设为 default
9 update() 把字典 dict2 的键/值对更新到字典 dict1 中
10 values() 返回一个迭代器,可以使用 list() 来转换为列表
11 pop() 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回 default 值
12 popitem() 随机返回并删除字典中的一对键和值(一般删除末尾键值对)
13 sorted() 对字典进行排序
  • clear()

用于删除字典内所有元素:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict1.clear()

>>> dict1
{}
  • copy()

返回一个字典的浅复制:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict2 = dict1.copy()

>>> dict2 
{'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}
  • fromkeys(seq[, value])

用于创建一个新字典,以序列 seq 中元素做字典的键(默认为 None),value 为字典所有键对应的初始值:

>>> seq = ('name', 'age', 'sex')

>>> dict1 = dict.fromkeys(seq)

>>> dict1
{'name': None, 'age': None, 'sex': None}


>>> dict2 = dict.fromkeys(seq, 10)

>>> dict2
{'name': 10, 'age': 10, 'sex': 10}
  • get(key, default=None)

返回指定键的值,指定的键不在字典中则返回默认值:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict1.get('NAME')
'Smith'


# 指定的键不在字典中,返回默认值 "None"

>>> dict1.get('LOC')


# 指定的键不在字典中,自定义默认值

>>> dict1.get('LOC', "China")
'China'
  • key in dict

in 操作符用于判断键是否存在于字典中,如果键在字典里返回 True,否则返回 False,而 not in 操作符刚好相反,如果键在字典里返回 False,否则返回 True:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> 'NAME' in dict1
True

>>> 'LOC' in dict1
False

>>> 'NAME' not in dict1
False
  • items()

以列表形式返回可遍历的(key、value)元组数组:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict1.items()
dict_items([('NAME', 'Smith'), ('JOB', 'Cleak'), ('SALARY', '1000')])


# 将字典的 key 和 value 变成列表

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> lk = []
>>> lv = []

>>> for k, v in dict1.items():
...     lk.append(k)
...     lv.append(v)
... 

>>> print(lk)
['NAME', 'JOB', 'SALARY']

>>> print(lv)
['Smith', 'Cleak', '1000']
  • keys()

返回一个可迭代对象,可以使用 list() 来转换为列表:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict1.keys()
dict_keys(['NAME', 'JOB', 'SALARY'])


# 转换为列表

>>> list(dict1.keys())
['NAME', 'JOB', 'SALARY']
  • setdefault(key, default=None)

setdefault() 方法和 get() 方法类似,如果 key 在字典中,返回对应的值。如果不在字典中,则插入 key 及设置的默认值 default,并返回 defaultdefault 默认值为 None

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}


# key 在字典中,返回对应的值

>>> dict1.setdefault('NAME')
'Smith'


# key 不在字典中,则插入 key 及默认值 None

>>> dict1.setdefault('LOC')

>>> dict1
{'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000', 'LOC': None}


# key 不在字典中,则插入 key 及设置的默认值 SALES

>>> dict1.setdefault('DEPT', 'SALES')
'SALES'

>>> dict1
{'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000', 'LOC': None, 'DEPT': 'SALES'}
  • update()

update() 函数把字典 dict2key:value 更新到字典 dict1 中:

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict2 = {'LOC': 'China'}

>>> dict1.update(dict2)

>>> dict1
{'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000', 'LOC': 'China'}


# 如果键值有重复,则 dict2 的内容会更新替换到 dict1 中

>>> dict1 = {'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '1000'}

>>> dict2 = {'LOC': 'China', 'SALARY': '2000'}

>>> dict1.update(dict2)

>>> dict1
{'NAME': 'Smith', 'JOB': 'Cleak', 'SALARY': '2000', 'LOC': 'China'}
  • values()

values() 方法返回一个迭代器,可以使用 list() 来转换为列表,列表为字典中的所有值 value

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> list(fruit.values())
['Orange', 'Lemon', 'Banana', 'Apple']
  • pop()

pop() 方法删除字典给定键 key 所对应的值,返回值为被删除的值。key 必须给出,否则,返回 default 值:

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> fruit.pop(20)
'Lemon'

>>> fruit
{70: 'Orange', 50: 'Banana', 30: 'Apple'}


# 如果要删除的 key 不存在,则需要添加默认值,否则会报错

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> fruit.pop(100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 100

>>> fruit.pop(100, 'Grape')
'Grape'
  • popitem()

popitem() 方法随机删除并返回字典中的一对 key:value (一般删除末尾 key:value),如果字典已经为空,却调用了此方法,就报出 KeyError 异常:

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> fruit.popitem()
(30, 'Apple')

>>> fruit
{70: 'Orange', 20: 'Lemon', 50: 'Banana'}


>>> fruit.clear()

>>> fruit
{}

>>> fruit.popitem()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
  • sorted()

对字典进行排序:

# key=operator.itemgetter(0) 表示按照 item 中的第一个字符进行排序,即按照 key 排序

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> import operator

>>> sorted_key = sorted(fruit.items(), key=operator.itemgetter(0))

>>> sorted_key
[(20, 'Lemon'), (30, 'Apple'), (50, 'Banana'), (70, 'Orange')]


# key=operator.itemgetter(1) 表示按照 item 中的第二个字符进行排序,即按照 value 排序

>>> fruit = {70: 'Orange', 20: 'Lemon', 50: 'Banana', 30: 'Apple'}

>>> import operator

>>> sorted_value = sorted(fruit.items(), key=operator.itemgetter(1))

>>> sorted_value
[(30, 'Apple'), (50, 'Banana'), (20, 'Lemon'), (70, 'Orange')]

参考资料

http://www.runoob.com/python3/python3-tutorial.html

原创文章,转载请注明出处:http://www.opcoder.cn/article/23/