1、变量和常量
1. 变量是计算机内存中的一块区域，变量可以存储任何值，而且值可以改变。
2. 变量的命名 ：由字母、数字或下划线组成，第1个字符不能是数字
3. 变量的赋值 ：Python中变量不需要声明，赋值操作即是变量声明和定义的过程，例如 x=1
4. Python的变量是一个对象，对变量的回收彩的是垃圾回收机制
5. 常量是一块只读的内存区域，常量一旦初始化就不能修改
变量作用域
Python的作用域一共有4种，分别是：
- L （Local） 局部作用域
- E （Enclosing） 闭包函数外的函数中
- G （Global） 全局作用域
- B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：
>>> if True:
... msg = 'I am from Runoob'
...
>>> msg
'I am from Runoob'
>>>
实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。
如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：
>>> def test():
... msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "", line 1, in
NameError: name 'msg_inner' is not defined
>>>
# 从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。
全局变量和局部变量
| 类型 | 描述 |
|---|---|
| 局部变量 | 局部变量只能在函数或代码段内使用的变量，函数一旦结束，局部变量的生命周期也就结束。 |
| 全局变量 | 1. 全局变量是能够被不同的函数、类或文件共享的变量，在函数之外定义的变量都可稳为全局变量。 2. 使用global关键字引用全局变量 3. 可以把全局变量放一个专门的文件中，统一管理 |
案例：
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
# 函数内是局部变量 : 30
# 函数外是全局变量 : 0
global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
# 1
# 123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
# 100
# 100
另外有一种特殊情况，假设下面这段代码被运行
a = 10
def test():
a = a + 1
print(a)
test()
# UnboundLocalError: local variable 'a' referenced before assignment
# 错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改
2、数据类型
Python有五个标准的数据类型：
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典
2.1、Number类型
| 整型 | 长整型 | 布尔型 | 双精度浮点数 | 复数 |
|---|---|---|---|---|
| Interger | Long integer | Boolean | Double-precision floating | Complex number |
2.1.1 数值操作符
- 算术操作符：加、减、乘、除
- 二进制比特操作符：取反、异或等
| 操作符 | 含义 |
|---|---|
| A+B | 加号;也可单独置于数字前,用于表示正数 |
| A-B | 减号;也可单独置于数字前,用于表示负数 |
| A*B | 乘号 |
| A/B | 除号;B不能为零,整数相除仍为整数 |
| A%B | 取余;结果为A除以B后取余 |
| A**B | 幂操作符;结果为A的B次方 |
| A∥B | 整除符;结果为A除以B后的结果的整数部分 |
| not A | 取反操作;只用于 Boolean类型 |
| A>B | 判断A是否大于B,结果为True或者 False |
A| 判断A是否小于B,结果为True或者 False |
|
| A==B | 判断A与B是否相等,结果为True或者 False |
| A>= B | 判断A是否大于等于B,结果为True或者 False |
| A<=B | 判断A是否小于等于B,结果为Tue或者 False |
| 操作符 | 含义 | |
|---|---|---|
| ~A | 按二进制取反;按照补码规则,结果数字是-(A+1) | |
| a & B | 并操作;只有两个比特位都为1时结果中的对应比特位才设1,否则 | 设零 |
| A|B | 或操作;只要两个比特位有一个为1,结果中的对应位则设1,否则设零 | |
| A^B | 异或操作;如果两个比特位相同,则结果中的对应位设零,否则设1 | |
| A>>B | 按比特位右移 | |
A<| 按比特位左移 |
|
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
2.1.2、数值类型的内置函数：
1. 通用函数：不仅适用数值类型变量，还适用于其它类型的变量。
2. 特定函数：仅适用于数值类型变量的相关操作
| 函数 | 含义 |
|---|---|
| cmp(A, B) | 比较二者的大小,如果前者小则返回-1,前者大则返回1,相等则返回0 python3已废除 |
| str(A) | 将参数转换为可显示的字符串 |
| type(A) | 返回参数的类型对象 |
| bool(A) | 将参数转换为布尔类型 |
| int(A) | 将参数转换为整数类型,以十进制表达 |
| long(A) | 将参数转换为长整型,以十进制表达 |
| float(A) | 将参数转换为浮点类型 |
| complex(A) | 将参数转换为复数类型 |
| 函数 | 含义 |
|---|---|
| abs(A) | 取绝对值 |
| coerce(A, B) | 将A和B转换成一个类型,并生成一个元组 |
| divmod(A, B) | 除模操作;生成一个元组,形式为(A/B,A%B) |
| pow(A, B) | 幂操作符;结果为“A的B次方” |
| round(A) | 返回参数的四舍五入结果 |
| hex(A) | 将A转换为用十六进制表示的字符串 |
| oct(A) | 将A转换为用八进制表示的字符串 |
| chr(A) | 将A转换为ASCI字符,要求0≤A≤255 |
| ord(A) | chr(A)的反函数 |
2.2、 Sequence(序列)类型簇
Python中字符串(String)、元组(Tuple)、列表(List)都属于序列类型簇
1. 字符串可看作是由字符组成的序列类型
2. 元组是==做生意==对象组成的不可修改序列类型
3. 列表==做生意==对象组成的可修改序列
| 操作符 | 含义 |
|---|---|
| A[index] | 获取序列中的第 index个元素; index的取值从0开始 |
| A[index1 : index2] | 切片操作,获取序列中从第 index1到第 index2-1的子序列 |
| A in B | 判断序列B中是否有A,如果有则返回True,否则返回 False |
| A not in B | 判断序列B中是否有A,如果没有则返回True,否则返回 False |
| A+B | 链接A和B,生成新的序列并返回 |
| A * number | 将A重复 number次,生成新的序列并返回 |
| A>B | 判断A是否大于B,结果为True或者Fase |
A| 判断A是否小于B,结果为True或者 False |
|
| A==B | 判断A与B是否相等,结果为True或者 False |
| A>= B | 判断A是否大于等于B,结果为True或者 False |
| A<=B | 判断A是否小于等于B,结果为True或者 False |
| 函数 | 含义 |
|---|---|
| enumerate(A) | 对序列A生成一个可枚举对象,对象中的每个元素是一个二位元组,元组内容为(indeiem),即(索引号,序列元素) |
| len(A) | 返回序列A的长度 |
| list(A) | 转换为List类型 |
| max(A) | A是一个序列,返回A中的最大元素 |
| max(a,b,…,) | 返回所有参数中的最大元素 |
| min(A) | A是一个序列,返回A中的最小元素 |
| min(a, b,...) | 返回所有参数中的最小元素 |
| reversed(A) | 生成A的反向序列 |
| sorted(A, func=None,key=None, reverse=False) | 对A排序,排序规则按照参数func、key、 reverse指定的规则进行 |
| sum(A, init=0) | 对A中的元素求和 |
| tuple(A) | 转换为 Tuple类型 |
列表推导式
列表推导式提供了从序列创建列表的简单途径,每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
[生成公式 for x in 序列]
# 将列表中每个数值乘三
vec = [2, 4, 6]
[3*x for x in vec]
[6, 12, 18]
# 对序列里每一个元素逐个调用某方法
freshfruit = [' banana', ' loganberry ', 'passion fruit ']
[weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
# 用 if 子句作为过滤器
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
# 循环
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
[x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
[x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
[vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
# 使用复杂表达式或嵌套函数
[str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
2.2.1 String 类型
1. 字符串是由0个或多个字符组成的有限序列，是Sequence(序列)类型簇的一员，字符串以用引号包含标识,有3种表示字符串的方式：单引号、双引号、三引号
2. Python中字符串分两种 ：普通字符串、Unicode字符串。分别是引号声明，引号之前加上字母u
3. 技巧：若字符串中包含汉字，则应将其声明为Unicode字符串
4. 技巧：因为String是Sequence类型簇成员，所以Sequence中所有操作符和函数都适用于String
5. 常用方法：合并、截取、比较、反转、查找和替换、与日期的转换
字符串格式化：
#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
| 格式化符号 | 解释 |
|---|---|
| %c | 转为单个字符 |
| %r | 转为用repr()函数表达的字符串 |
| %s | 转为用str()函数表达的字符串 |
| %d or %i | 转为有符号的十进制整数 |
| %r | 转为无符号的十进制整数 |
| %o | 转为无符号的八进制整数 |
| %x | 转为无符号的十六进制整数,十六进制字母用小写表示 |
| %X | 转为无符号的十六进制整数,十六进制字母用大写表示 |
| %e | 转为科学计数法表达的浮点数,其中的e用小写显示 |
| % E | 转为科学计数法表达的浮点数,其中的E用大写显示 |
| %f or %F | 转为浮点数 |
| %g | 由 Python根据数字的大小自动判断转换为%e或者%f |
| % G | 由 Python根据数字的大小自动判断转换为%E或者%F |
| %% | 输出“%” |
| 辅助格式化符号 | 解释 |
|---|---|
| * | 定义宽度或小数点的精度 |
| - | 左对齐 |
| + | 对正数输出正值符号“+” |
| 数字的大小不足mn的要求时,用空格补位 | |
| # | 在八进制数前面显示零(0),在十六进制前面显示“0x”或者“0X”(取决于用的是“x”还是“X) |
| 0 | 数字的大小不满足mn的要求时,用0补位 |
| m.n | 是显示的最小总宽度,n是小数点后的位数(如果可用的话) |
模式化字符串的固定内容除了字母、数字、标点符号等可显示的字符，还可以包含不可显示字符，如回车、缩进等
以下为转义字符表：
| 转义字符 | 解释 | ASCII值 |
|---|---|---|
| \a | 响铃(BEL) | 7 |
| \b | 退格(BS),将当前位置移到前一列 | 8 |
| \f | 换页(FF),将当前位置移到下页开头 | 12 |
| \n | 换行(LF),将当前位置移到下一行开头 | 10 |
| \r | 回车(CR),将当前位置移到本行开头 | 13 |
| \t | 水平制表(HT) (跳到下一个TAB位置) | 9 |
| \v | 垂直制表(VT) | 11 |
| \\ | 代表一个反斜线字符'' | 92 |
| \* | 代表一个单引号（撇号）字符 | 39 |
| " | 代表一个双引号字符 | 34 |
| ? | 代表一个问号 | 63 |
| \0 | 空字符（NULL） | 0 |
字符串作为最重要的常用类型之一,有一系列特有的内置函数,常用的如下:
| 函数 | 解释 |
|---|---|
| capitalize() | 将字符串中的第1个字符大写 |
| center( width) | 返回一个长度至少为 width的字符串,并使原字符串的内容居中。 |
| count( str,beg=0,end=len( string) | 返回str在 string里面出现的次数,可以用开始索引(beg)和结束索引(end)指定搜索的范围 |
| decode(encoding='UTF-8',errors='strict') | 以 encoding指定的编码格式解码 string |
| encode(encoding=UTF-8, errors= 'strict's) | 以 encoding指定的编码格式编码 string |
| endswith(obj,beg=0,end= len(string)）b,e | 检查字符串是否以obj结束,如果是,则返回True,否则返回 False可以用开始索引(beg)和结束索引(end)指定搜索的范围 |
| expandtabs( absite-=8) | 把字符串 string中的Tab符号转为空格,默认的空格数 tabsize是8 |
| find(str,beg=0,end=len( string) | 检测str是否包含在 string中;可以用开始索引(beg)和结束索引(end)指定搜索的范围,找到则返回索引值,找不到则返回-1 |
| index(str,beg=0,end=len( string) | 跟 findo类似,但是如果str不在 string中,则报一个异常 |
| isalnumo() | 如果发现有一个字符并且所有字符都是字母或数字,则返回True,否则返回 |
| igalpha() | 如果发现有一个字符并且所有字符都是字母,则返回True,否则返回 False |
| isdecimalo() | 如果可解释为十进制数字,则返回True,否则返回 False |
| isdigito | 如果可解释为数字,则返回True,否则返回 False |
| islower(: | 如果字符串中的字符都是小写,则返回True,否则返回 False |
| isnumerico: | 如果只包含数字字符,则返回True,否则返回 False. |
| isospace: | 如果字符串是空格,则返回True,否则返回 False |
| isto: | 如果字符串是标题化的,则返回True,否则返回 False |
| supper | 如果字符串中的字符都是大写的,则返回True,否则返回 False。 |
| ljust( width): | 返回一个原字符串左对齐,并使用空格填充至长度 width的新字符串 |
| lower: | 转换所有大写字符为小写。 |
| Stripe: | 截掉 string左边的空格 |
| replace(stri,str2,num= count(strl): | 把 string中的strl替换成str2,num指定替换的最大次数。 |
| fnd(str,beg=0, end=len( string): | 类似于 findo,但是从右边开始查找。 |
| index(str,beg=0,end=len( string): | 类似于index,但是从右边开始查找 |
| rust( width): | 返回一个原字符串右对齐,并使用空格填充至长度 width的新字符串 |
| rpartition(str)e: | 类似于 partition函数,不过是从右边开始查找 |
| stripe: | 删除 string字符串末尾的空格 |
| split(str="",num= count(str): | 以str为分隔符切片 string,如果num有指定的值,则仅分隔num个子字符串。 |
| splitlinest(num= count(n): | 按照行分隔,返回一个包含各行作为元素的列表,如果num已指定,则仅切片num个行 |
| startswith(obj,beg=0,end=len( string): | 检查字符串是否以ob开头,如果是则返回True,否则返回 False。可以用开始索引(beg)和结束索引(end)指定搜索的范围 |
| srip(obj]): | 在 string上执行 Istrip(和 stripe。 |
| swapcaseo: | 翻转 string中的大小写。 |
| titled: | 将字符串标题化,即所有单词都以大写开始,其余字母均为小写。 |
| ranslate(str,del="): | 根据str给出的表转换 string的字符,将要过滤掉的字符放到del参数中。 |
| upper: | 转换 string中的小写字母为大写 |
| fill( width): | 返回长度为 width的字符串,原字符串 string右对齐,前面填充0 |
# capitalize()
str = "this is string example from runoob....wow!!!"
print ("str.capitalize() : ", str.capitalize())
# count()
str="www.runoob.com"
sub='o'
print ("str.count('o') : ", str.count(sub))
sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
2.2.2 List 类型
- List即列表,是一种常用的Sequence(序列)类型。List用中括号“[ ]”表示,不同的元素之间以逗号隔开。
- 在Python语言中,List的大小和其中的元素在初始化后可以被再次修改,这是List与Tuple的主要区别。如果开发者定义了一组值,并且在之后需要不断对其进行增、删、改等操作,则应该使用List类型
- 关键字：任意对象的可变可重复有序序列
| 特点 | 描述 |
|---|---|
| 特点 | 查找和插入时间随着元素的增加而增加，占用内存小 |
| 任意对象 | 列表中可以存储任意类型的对象 |
| 可变 | 可以对任何索引上的对象进行修改、替换 |
| 有序 | 其中的元素可以用位置索引 |
| 可重复 | 不同索引位置上的元素是可以相同的 |
List的创建
list=[元素1,元素2,...]
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
List的访问
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# 同时遍历两个或更多的序列，可以使用 zip() 组合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
# 反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数
>>> for i in reversed(range(1, 10, 2)):
... print(i)
# 要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
List的操作
#添加元素
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
print list
#删除元素
list1 = ['physics', 'chemistry', 1997, 2000]
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
#插入元素
aList = [123, 'xyz', 'zara', 'abc']
aList.insert( 3, 2009)
print "Final List : ", aList
#追加列表
aList = [123, 'xyz', 'zara', 'abc', 123];
bList = [2009, 'manni'];
aList.extend(bList)
print "Extended List : ", aList ;
#反向
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();
print "List : ", aList;
#排序
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.sort();
print "List : ", aList;
除了Squence（序列）类型公用的操作，List类型还有一组自己的函数，常有的如下：
| 方法 | 描述 | |
|---|---|---|
| list.append(x) | 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 | |
| list.extend(L) | 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。 | |
| list.insert(i, x) | 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引， 例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) |
相当于 a.append(x) 。 |
| list.remove(x) | 删除列表中值为x的第一个元素。如果没有这样的元素，就会返回一个错误。 | |
| list.pop([i]) | 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。 元素随即从列表中被移除。 |
|
| list.clear() | 移除列表中的所有项，等于del a[:]。 | |
| list.index(x) | 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。 | |
| list.count(x) | 返回 x 在列表中出现的次数。 | |
| list.sort() | 对列表中的元素进行排序。 | |
| list.reverse() | 倒排列表中的元素。 | |
| list.copy() | 返回列表的浅复制，等于a[:]。 |
2.2.3 Tuple 类型
- 关键词：任意对象的不可变可重复有序序列
- Tuple即元组,是一种特殊的Sequence(序列)类型。Tuple用圆括号表示,在不同的元素之间以逗号隔开
- 在Python语言中,tuple的大小和其中的元素在初始化后不能修,Tuple比可修改List的操作速度快。如果开发者定义了一个值的常量集,并且唯一要用它做的是不断地读取，则这正是Tuple的长处。
- Tuple可以通过Sequence类型的通用方法进行操作
Tuple的创建
tuple=() #空元組
tuple=(1,) #单个元素的元组，需要有，号结尾
tuple=(元素1,元素2,.....)
tuple=(('元素1','元素2'),('元素3','元素4'))#二元元组
Tuple的访问
tuple[n]
tuple[m][n] #访问二元元组
tuple[m:n] #切片
tuple[0]="a"
TypeError: 'tuple' object does not support item assignment
# tuple创建后不能修改
tuple[11]
IndexError: tuple index out of range
# tuple索引访问越界
Tuple的连接组合
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;
Tuple的“打包”和“解包”
任意无符号的对象，以逗号隔开，默认为元组
# 打包
tuple1=("apple","banana","grape","orange")
# 解包
a,b,c,d = tuple1
print(a,b,c,d)
Tuple的遍历
tuple=(("apple","banana"),("grape","orange"))
for i in tuple:
for j in i:
print(j)
#利用range()函數和len()函數
tuple=(("apple","banana"),("grape","orange"),("watermolon",)("grapefruit",))
for i in range(len(tuple)):
print("tuple [%d] : " %i , " " ,)
for j in range(len(tuple[i])):
print(tuple[i][j]," " ,)
print()
元组和列表的区别
类型 | 支持负索引 | 支持分片| 支持 添加、删除、修改| 支持排序、查找| 数据的含义
---|---|---|---|---|---|---
元组| 是| 是| 否| 否| 一组不同含义的数据组成
列表 |是| 是| 是| 是| 一组相同含义的数据组成
3、 Set类型
Set的创建
set={} #空集合
set={元素1,元素2...}
x=set([元素1,元素2...])
x=forzenset([元素1,元素2...]) #固定集合
# 集合也支持推导式
a = {x for x in 'abracadabra' if x not in 'abc'}
- 关键词：任意对象的无序可变集合
- Set类型即集合，用于表示相互之间无序的一组对象，集合在算术上的去处包括并集、交集、补集等
- Python中通过关键字set和frozenset定义普通集合和不可变集合，普通集合在初始化后支持并集、交集、补集等运算，而不可变集合初始化后就不能改变
- 初始化集合内容的方法是向其传入Sequence类型簇的变量
| 操作符 | 解释 |
|---|---|
| in | 判断包含关系 |
| not in | 判断不包含关系 |
| == | 判断等于 |
| != | 判断不等于 |
| < | 判断绝对子集关系 |
| <= | 判断非绝对子集关系 |
| > | 判断绝对超集关系 |
| >= | 判断非绝对超集关系 |
| & | 交运算 |
| 并运算 | |
| - | 差运算 |
| ^ | 对称差运算 |
| = | 执行并运算并赋值 |
| &= | 执行交运算并赋值 |
| -= | 执行差运算并赋值 |
| ^= | 执行对称差运算并赋值 |
Set类型有一组自己的内置函数，用于集合的增、删、改等操作
| 函數 | 解釋 |
|---|---|
| add() | 增加新元素 |
| update(seq) | 用序列更新集合，序列的每个元素都被添加到集合中 |
| remove(element) | 删除元素 |
4、 Dictionary类型
Dictionary即字典，代表一个键/值存储库，工作方式像映射表
- 关键词：任意对象的无序不重复键值对集合
- 字典是通过key值获取相应的value值
- 字典的值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
| 特点 | 描述 |
|---|---|
| 特点 | 查找快，需占用大量内存，内存浪费多 |
| 无序 | 不可索引 |
| 任意对象 | 必需是不可变数据类型，值可以是任意对象 |
| 不重复 | 键不可重复，值随意，出现重复时，后面的键值会覆盖前面的键值 |
字典的创建
dictionary={ }
dictionary={key1:value1 , key2:value2 , ...}
字典的访问
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
# key值严格区分大小写
print "dict['Alice']: ", dict['Alice'];
# KeyError: 'Alice'，字典中沒有對應的鍵
字典的修改
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
# dict['Age']: 8
# dict['School']: DPS School
字典的方法
dict.keys()
dict.values()
# 字典的遍历,返回若干元组
dict={"a":"apple","b":"banana","c":"grape"}
for i in dict.items():
print(i)
# 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
D.update(E) # 合并字典
# 字典的排序-按键排序
print(sorted(dict.items(),key=lambda d:d[0]))
# 按值排序
print(sorted(dict.items(),key=lambda d:d[1]))
字典的键值特性
- 同一个key不允许出现两次，创建时如果同一个key被赋值两次，仅后一个值会被记住
- key必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
- value可以是元组、列表、字典
代码演示：
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
print "dict['Name']: ", dict['Name'];
# dict['Name']: Manni
dict = {['Name']: 'Zara', 'Age': 7};
print "dict['Name']: ", dict['Name'];
# TypeError: list objects are unhashable
dict={"key1":(tuple),"key2":[list],"key3":[dictionary]}
全局字典sys.modules模块
| 函數 | 解釋 |
|---|---|
| clear() | 清除字典中所有（键，值）对 |
| copy() | 复制字典的一个副本 |
| fromkeys(seq,val=None) | 用seq中的元素作为创建字典，所有键的值 都设为val,val的默认为None |
| get(key,default=None) | 读取字典中的键Key，返回该键的值； 如果找不到该键则返回default的值 |
| has key(key) | 判断键key在字典中是否存在,如果存在则返回True,否则返回False |
| items | 返回一个包含字典中(键,值)对元组的列表。 |
| keys | 返回一个字典中所有键的列表。 |
| Iteritems() | 返回对字典中所有(键,值)对的迭代器。 Python 3.x 已废除,在3.x 里用 items()替换iteritems() |
| pop(key[, default]) | 读取某键的值,并且从字典中删除该键的值。如果键key不存在且没有设置 default,则引发 Keyerror异常。 |
| setdefault(key, default=None) | 创建新的元素并默认值 |
| update(dict) | 合并字典 |
| values() | 返回一个包含字典中所有值的列表。 |
# clear()函数
dict = {'Name': 'Zara', 'Age': 7}
print ("字典长度 : %d" % len(dict))
dict.clear()
print ("字典删除后长度 : %d" % len(dict))
#tart Len : 2
#End Len : 0
# copy()函数
dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)
# New Dictinary : {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}
# fromkeys()函数
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" % str(dict))
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" % str(dict))
# New Dictionary : {'age': None, 'name': None, 'sex': None}
# get()函数
dict = {'Name': 'Runoob', 'Age': 27}
print ("Age 值为 : %s" % dict.get('Age'))
print ("Sex 值为 : %s" % dict.get('Sex', "NA"))
# Value : 27
# Value : NA
# has_key()函数
dict = {'Name': 'Zara', 'Age': 7}
print "Value : %s" % dict.has_key('Age')
print "Value : %s" % dict.has_key('Sex')
# Value : True
# Value : False
# in 操作符
dict = {'Name': 'Runoob', 'Age': 7}
if 'Age' in dict:
print("键 Age 存在")
else :
print("键 Age 不存在")
if 'Sex' in dict:
print("键 Sex 存在")
else :
print("键 Sex 不存在")
# 键 Age 存在
# 键 Sex 不存在
# items() 方法
dict = {'Name': 'Runoob', 'Age': 7}
print ("Value : %s" % dict.items())
#keys() 方法
dict = {'Name': 'Runoob', 'Age': 7}
print ("字典所有的键为 : %s" % dict.keys())
# dict_keys(['Age', 'Name'])
# setdefault() 方法
dict = {'Name': 'Runoob', 'Age': 7}
print ("Age 键的值为 : %s" % dict.setdefault('Age', None))
print ("Sex 键的值为 : %s" % dict.setdefault('Sex', None))
print ("新字典为：", dict)
# Age 键的值为 : 7
# Sex 键的值为 : None
# 新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}
#update()函数
dict = {'Name': 'Runoob', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print ("更新字典 dict : ", dict)
# {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}