Python 运算符
运算符用于执行程序代码运算,会针对一个以上操作数项目来进行运算,在Python中运算符大致可以分为7种类型:算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算等,下面的例子将依次介绍这几种运算符的使用技巧.
◆算数运算符◆
算术运算(arithmetic operators)符号,就是用来处理四则运算的符号,这是最简单,也最常用的符号,尤其是数字的处理,几乎都会使用到算术运算符号,Python支持以下运算符:
运算符
描述信息
例子
+
加号:两个数相加
a=10,b=20 a+b结果30
-
减号:两个数相减
a=20,b=10 a-b结果10
*
乘号:两个数相乘
a=10,b=20 a*b结果200
/
除号:两个数相除
a=10,b=20 b/a结果2
%
取模:返回除法的余数
a=10,b=20 b%a结果0
**
幂符:返回x的y次幂
a**b,a的b次方,返回
//
取整:返回商的整数部分
a=9,b=2 a//b结果4
加法运算(+):
>>> a=30>>> b=20
>>> c=0
>>>
>>> c=a+b
>>> print("a+b=",c)
a+b= 50
减法运算(-):
>>> a=30>>> b=20
>>> c=0
>>>
>>> c=a-b
>>> print("a-b=",c)
a-b= 10
乘法运算(x):
>>> a=30>>> b=20
>>> c=0
>>>
>>> c=a*b
>>> print("a*b=",c)
a*b= 600
除法运算(/):
>>> a=30>>> b=20
>>> c=0
>>>
>>> c=a/b
>>> print("a/b=",c)
a/b= 1.5
取余运算(%):
>>> a=30>>> b=20
>>> c=0
>>>
>>> c=a%b
>>> print("a%b=",c)
a%b= 10
求幂运算(xx):
>>> a=20>>> b=30
>>> c=0
>>>
>>> c=a**b
>>> print("a**b=",c)
a**b= 1073741824000000000000000000000000000000
取整运算(//):
>>> a=10>>> b=5
>>> c=0
>>>
>>> c=a//b
>>> print("a//b=",c)
a//b= 2
◆比较运算符◆
比较运算符是指可以使用如下运算符比较两个值,当用运算符比较两个值时,结果是一个逻辑值,不是 TRUE(成立)就是FALSE(不成立)的运算符号,Python支持以下运算符:
运算符
描述信息
例子
==
等于:比较两个对象是否相等
(a==b)返回false
!=
不等于:比较两个对象是否不相等
(a!=b)返回true
<>
不等于:比较两个对象是否不相等
(a<>b)返回true
>
大于:返回x是否大于y
(a>b)返回false
<
小于:返回x是否小于y
(a<b)返回true
>=
大于等于:返回x是否大于等于y
(a>=b)返回false
<=
小于等于:返回x是否小于等于y
(a<=b)返回true
等于(==):
>>> a=21>>> b=10
>>> c=0
>>> if(a==b):
... print("a等于b")
... else:
... print("a不等于b")
...
a不等于b
不等于(!=):
>>> a=21>>> b=10
>>> c=0
>>> if(a != b):
... print("a不等于b")
... else:
... print("a等于b")
...
a不等于b
大于(>):
>>> a=21>>> b=10
>>> c=0
>>> if (a > b):
... print("a大于b")
... else:
... print("a小于b")
...
a大于b
小于等于(<=):
>>> a=5>>> b=20
>>> c=0
>>> if(b >= a):
... print("b大于等于a")
... else:
... print("b小于a")
...
b大于等于a
◆赋值运算符◆
基本的赋值运算符是"=",这里不是等号,他的优先级别低于其他的运算符,所以对该运算符往往最后读取,Python支持以下运算符:
运算符
描述信息
例子
=
简单的赋值运算符
c=a+b,将a+b结果给c
+=
加法赋值运算符
c+a等效于c=c+a
-=
减法赋值运算符
c-=a等效于c=c-a
x=
乘法赋值运算符
c=a等效于c=ca
/=
除法赋值运算符
c/=a等效于c=c/a
%=
取模赋值运算符
c%=a等效于c=c%a
**=
幂赋值运算符
c**=a等效于c=c**a
//=
取整除赋值运算符
c//=a等效于c=c//a
普通的赋值(=):
>>> a=21>>> b=10
>>> c=0
>>> c=a+b
>>> print("a+b=",c)
a+b=31
加等于(+=):
>>> a=21>>> c=10
>>> c+=a
>>> print("c+=a(c=c+a)=",c)
c+=a(c=c+a)= 31
◆位运算符号◆
程序中的所有数在计算机内存中都是以二进制的形式储存的,位运算就是直接对整数在内存中的二进制位进行操作,按位运算符是把数字看作二进制来进行计算,以下实例默认假设变量a=60(0011 1100);b=13(0000 1101),Python支持以下运算符:
运算符
描述信息
例子
&
按位与运算
(a&b)输出结果为12
竖线
按位或运算
(a竖线b)输出结果为61
^
按位异或运算
(a^b)输出结果为49
~
按位取反运算
(~a)输出结果为-61
<<
按位左移
(a<<2)输出结果为240
>>
按位右移
(a>>2)输出结果为15
与运算(&):
>>> a=60 # 60 = 0011 1100>>> b=13 # 13 = 0000 1101
>>> c=0
>>>
>>> c= a & b # 12 = 0000 1100
>>> print("a与b: ",c)
a与b: 12
或运算(|):
>>> c= a | b # 61 = 0011 1101>>> print("a或b: ",c)
a或b: 61
异或运算(^):
>>> c=a^b # 49 = 0011 0001>>> print("a异或b:",c)
a异或b: 49
非运算(~):
>>> c=~a # -61 = 1100 0011>>> print("非a:",c)
非a: -61
左移运算(<<):
>>> c=a << 2 # 240 = 1111 0000>>> print("a左移2",c)
a左移2 240
右移运算(>>):
>>> c=a >>2 # 15 = 0000 1111>>> print("a右移2",c)
a右移2 15
◆逻辑运算符◆
在形式逻辑中,逻辑运算符或逻辑联结词把语句连接成更复杂的复杂语句,逻辑运算符通常用于Boolean型(逻辑)值,这种情况,它们返回一个布尔型值,以下假设变量a=1;b=1;c=0,Python支持以下运算符:
运算符
描述信息
说明
and
x and y
逻辑比较,只要有一处为0则返回0
or
x or y
逻辑比较,两边都为0则返回0
not
not x
逻辑比较,两边都不为0则返回false
and逻辑与: and只要一处为假则表达式就为假
>>> a=1>>> b=1
>>> c=0
>>> a and b
1
>>> a and c
0
or逻辑或: or只要有一处为真咋表达式为真
>>> a=1>>> b=1
>>> c=0
>>> a or b
1
>>> a or c
1
>>> c or c
0
◆成员运算符◆
Python里有成员运算符,可以判断一个元素是否在某一个序列中,比如可以判断一个字符是否属于这个字符串,可以判断某个对象是否在这个列表中等,Python支持以下运算符:
运算符
描述信息
说明
in
a in list
如果在指定序列中找到值返回true,否则返回false
not in
a not in
如果在指定序列中没找到值返回true,否则返回false
in运算符:
>>> a=10>>> b=20
>>> list =[1,2,3,4,5]
>>>
>>> if ( a in list):
... print("a在list列表中")
... else:
... print("a不在list列表中")
...
a不在list列表中
not in运算符:
>>> a=10>>> b=20
>>> list =[1,2,3,4,5]
>>>
>>> if ( b not in list):
... print("b不在list列表中")
... else:
... print("b在list列表中")
...
b不在list列表中
◆身份运算符◆
身份运算符用于比较两个对象的存储单元是否一致,id()函数用于获取对象内存地址,Python支持以下运算符:
运算符
描述信息
说明
is
a is b
判断两个标识符是不是引用自一个对象
is not
a is not
判断两个标识符是不是引用自不同对象
is运算符:
>>> a=20>>> b=20
>>> c=30
>>>
>>> a is b
True
>>> a is c
False
is not运算符:
>>> a=20>>> b=20
>>> c=30
>>>
>>> a is not b
False
>>> a is not c
True
## Python 数据类型
数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作,在Python当中数据类型包括数值类型、字符类型组、列表、字典、元组、等类型,下面的例子将依次介绍这几种运算符的使用技巧.
◆数值的类型◆
Python支持int、float、bool、complex(复数),在Python中只有一种整数类型int表示为长整型,像大多数语言一样,数值类型的赋值和计算都是很直观的,数值间的数据互换可以参考如下列表:
int(x) #将x转换为一个整数long(x) #将x转换为一个长整数
float(x) #将x转换到一个浮点数
complex() #创建一个复数
str(x) #将对象x转换为字符串
repr(x) #将对象x转换为表达式字符串
eval(str) #用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(x) #将序列s转换为一个元组
list(x) #将序列s转换为一个列表
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) #将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串
整数转其他数值: 使用转换命令将一个整数转换为其他数值.
>>> temp=100>>>
>>> float(temp)
100.0
>>> complex(temp)
(100+0j)
>>> str(temp)
'100'
整数转换字符: 使用转换命令将一个整数转换为字符.
>>> temp=100>>>
>>> chr(temp)
'd'
>>> ord(chr(temp))
100
进制转换: 使用转换命令实现进制转换.
>>> temp=100>>>
>>> hex(temp)
'0x64'
>>> oct(temp)
'0o144'
◆字符串类型◆
所谓字符串就是字符的集合,Python支持字符串这种数据类型,且提供了一些丰富的字符串处理函数,以下列表中就是Python所支持的字符串操作函数,接下来我们将找出几个比较常用的字符串函数来进行演示.
str.capitalize() #将字符串的首字母变大写str.title() #将字符串中的每个单词的首字母大写
str.upper() #将字符串变成大写
str.lower() #将字符串变成小写
str.index() #找出索引对应的字符串
str.find() #找出索引对应的字符串
str.count() #找出字符串中元素出现的次数
str.format() #也是格式化的一种
str.center() #以什么字符从字符串两边填充
str.join() #以str为分隔符连接字符串
str.split() #以什么为分隔符分隔字符串
str.strip() #将字符串两边中的空格去掉
str.replace() #查找替换
str.isupper() #判断是否为大写
str.islower() #判断是否为小写
str.isalnum() #判断是否是字母数字
str.isalpha() #判断是否是字母下划线
str.isdigit() #判断是否是数字
str.isspace() #判断是否为空
str.startswith() #找出以什么为开头的字符元素
str.endswith() #找出以什么为结尾的字符元素
首字母大写: 使用capitalize()函数,将一个指定字符串首字母变成大写.
>>> str="hello lyshark">>>
>>> str.capitalize()
'Hello lyshark'
全部首字母大写: 使用title()函数,将字符串中的每一个单词的首字母大写.
>>> str="hello lyshark">>>
>>> str.title()
'Hello Lyshark'
查找字符串: 使用index()函数,找出指定字符串的索引编号,不存在则报错.
>>> str="hello lyshark">>>
>>> str.index("hello")
0
>>> str.index("lyshark")
6
>>> str.index("mk")
ValueError: substring not found
查找字符串: 使用find()函数,找出指定字符串的索引编号,不存在则返回-1.
>>> str="hello lyshark">>>
>>> str.find("hello")
0
>>> str.find("lyshark")
6
>>> str.find("mk")
-1
统计字符串出现次数: 使用count()函数,统计指定字符串的出现次数.
>>> str="hello lyshark">>>
>>> str.count("h")
2
>>> str.count("l")
3
>>> str.count("hello")
1
>>> str.count("mk")
0
格式化输出(1): 使用format()函数,格式化输出指定的一段内容.
>>> "{} {}".format("hello","lyshark") #不设置指定位置,按默认顺序'hello lyshark'
>>>
>>> "{0} {1}".format("hello","lyshark") #设置指定位置
'hello lyshark'
>>>
>>> "{1} {0} {1}".format("hello","lyshark") #设置指定位置
'lyshark hello lyshark'
格式化输出(2): 使用format()函数,格式化输出指定的一段内容.
>>> print("网站名称:{name},地址:{url}".format(name="myblog",url="www.mkdirs.com"))网站名称:myblog,地址:www.mkdirs.com
>>>
>>> site={"name":"myblog","url":"www.mkdirs.com"}
>>> print("网站名称:{name} 地址:{url}".format(**site))
网站名称:myblog 地址:www.mkdirs.com
>>>
>>> my_list = ['myblog','www.mkdirs.com']
>>> print("网站名称:{0[0]},地址:{0[1]}".format(my_list))
网站名称:myblog,地址:www.mkdirs.com
字符串填充: 使用center()函数,填充指定字符串两边的内容.
>>> str="hello lyshark">>>
>>> str.center(20,'*')
'***hello lyshark****'
>>>
>>> print(str.center(50,'-'))
------------------hello lyshark-------------------
字符串连接: 使用join()函数,将序列中以指定的字符连接生成一个新字符串
>>> str="-">>> seq=("hello","lyshark","welcome")
>>>
>>> print(str.join(seq))
hello-lyshark-welcome
>>> list =['1','2','3','4','5']
>>> print(''.join(list))
12345
>>> 'kill %s' % ' '.join(['1024','2234'])
切割字符串: 使用split()函数,指定分割一个字符串,并保存成列表.
>>> str="hello-lyshark-welcome">>>
>>> str.split("-")
['hello', 'lyshark', 'welcome']
去除字符串两边空格: 使用trip()函数,去除指定字符串两边空格.
>>> str=" hello lyshark ">>> str
' hello lyshark '
>>>
>>> str.strip()
'hello lyshark'
字符串查找替换: 使用replace()函数,查找并替换指定字符串.
>>> str="hello lyshark">>> str
'hello lyshark'
>>>
>>> str.replace("lyshark","mkdirs")
'hello mkdirs'
判断是否为大写: 使用isupper()函数,判断指定字符串是否为大写.
>>> str="LYSHARK">>> str1="lyshark"
>>>
>>> str.isupper()
True
>>> str1.isupper()
False
查找开头结尾: 使用startswith()函数,找出指定字母开头的字符元素.
>>> str="hello lyshark welcome">>>
>>> str.startswith("hello")
True
>>> str.startswith("lyshark")
False
>>>
>>> str.startswith("lyshark") or str.endswith("welcome")
True
>>> str.startswith("lyshark") and str.endswith("welcome")
False
◆列表的类型◆
列表是Python中最基本的数据结构,同时也是最常用的,列表中的每个元素都分配一个数字-它的位置或索引,第一个索引是0,第二个索引是1,依此类推,,接下来我们将找出几个比较常用的列表操作函数来进行演示.
list.insert() #在列表中指定索引位置前插入元素list.append() #在列表尾部插入
list.remove() #删除指定的元素
list.pop() #没有指定索引,则弹出最后一个元素,返回的结果是弹出的索引对应的元素
list.copy() #浅复制,只复制第一层,如果有嵌套序列则不会复制,需要复制要导入copy模块
list.extend() #把另外一个列表合并,并不是追加
list.index() #列表中元素出现的索引位置
list.count() #统计列表中元素的次数
list.reverse() #进行逆序
list.sort() #进行排序,无法把数字和字符串一起排序
list1 + list2 #合并两个列表,返回一个新的列表,不会修改原列表
list * N #把list重复N次,返回一个新列表
向列表追加数据: 使用append()函数,追加写入几个数据到指定的列表里.
>>> list = [1,2,3]>>> list
[1, 2, 3]
>>>
>>> list.append(4)
>>> list.append(5)
>>> list.append(6)
>>>
>>> list
[1, 2, 3, 4, 5, 6]
向列表插入数据: 使用insert()函数,向指定的列表插入几个数据到指定的位置.
>>> list = ["admin","lyshark"]>>> list
['admin', 'lyshark']
>>>
>>> list.insert(1,"python")
>>> list
['admin', 'python', 'lyshark']
>>>
>>> list.insert(2,"ruby")
>>> list.insert(2,"ruby")
>>> list
['admin', 'python', 'ruby', 'ruby', 'lyshark']
修改指定数据: 使用names[]变量赋值的方式,修改指定元素的字段值.
>>> list['admin', 'python', 'ruby', 'ruby', 'lyshark']
>>> list[0]="mkdirs"
>>> list
['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']
>>>
>>> list[3]="pip"
>>> list
['mkdirs', 'python', 'ruby', 'pip', 'lyshark']
删除指定数据: 使用remove()函数,删除指定数据,或使用del()函数来删除.
>>> list['mkdirs', 'python', 'ruby', 'pip', 'lyshark']
>>>
>>> del list[2] #通过下标删除元素
>>> list
['mkdirs', 'python', 'pip', 'lyshark']
>>>
>>> list.remove("python") #删除指定的元素
>>> list
['mkdirs', 'pip', 'lyshark']
>>>
>>> list.pop() #删除列表的最后一个元素
'lyshark'
>>> list.pop()
'pip'
>>> list
['mkdirs']
扩展一个列表: 使用extend()函数,将一个列表追加到另一个列表的后面.
>>> list1 = ["admin","guest","lyshark"]>>> list2 = [1,2,3]
>>>
>>> list1.extend(list2)
>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]
浅COPY列表: 使用copy()函数,实现列表的浅Copy.
>>> list1['admin', 'guest', 'lyshark', 1, 2, 3]
>>>
>>> list1_copy = list1.copy()
>>> list1_copy
['admin', 'guest', 'lyshark', 1, 2, 3]
统计元素次数: 使用count()函数,统计列表中元素出现的次数.
>>> list = ["admin","admin","lyshark","mkdirs"]>>>
>>> list.count("admin")
2
>>> list.count("mkdirs")
1
正反向排序: 使用sort(),reverse()函数,给指定列表元素排序.
>>> list = ["admin","python","ruby","1","3","6","9"]>>> list
['admin', 'python', 'ruby', '1', '3', '6', '9']
>>>
>>> list.sort() #正向排序,必须元素类型一致
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>>
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>> list.reverse() #反向排序,必须元素类型一致
>>> list
['ruby', 'python', 'admin', '9', '6', '3', '1']
获取元素下标: 使用index()函数,来获取元素的下标.
>>> list['ruby', 'python', 'admin', '9', '6', '3', '1']
>>>
>>> list.index("admin")
2
>>> list.index("1")
6
列表的切片: 使用[]实现列表的各种切片操作.
>>> list=[1,2,3,4,5,6,7,8,9,0]>>>
>>> list[1:4] #取出下标1-4的元素,不包括4
[2, 3, 4]
>>>
>>> list[1:-1] #取出下标1至-1,不包括-1
[2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[1:] #取出下标从1到最后的数据
[2, 3, 4, 5, 6, 7, 8, 9, 0]
>>>
>>> list[:] #取出所有元素
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[0::2] #取元素时每次格2格
[1, 3, 5, 7, 9]
通过分片删除数据: 通过使用分片来清除指定列表中的数据.
>>> list[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list[0:3]
[123, 111, 111]
>>>
>>> list[0:3]=[] #将下标0-3替换成空,不包括3
>>> print(list)
[111, 8, 7, 6, 5, 4, 3, 2, 1]
>>>
嵌套列表的实现: 一次性声明两个列表,并于数据名称相关联.
>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]>>>
>>> print(list1)
[1, 'a', 'b']
>>> print(list2)
[2, 'a', 'b']
查找元素并修改(1): 查找列表中的指定元素,并修改,只修改第一次发现的.
[root@localhost]# cat test.py#!/usr/bin/python
name = [1,2,3,4,5,1,5,6]
if 1 in name:
num_of_ele = name.count(1)
position_of_ele = name.index(1)
name[position_of_ele] = 888
print(name)
[root@localhost]# python test.py
[888, 2, 3, 4, 5, 1, 5, 6]
查找元素并修改(2): 查找列表中的指定元素,并批量修改,修改所有的.
[root@localhost]# cat test.py#!/usr/bin/python
name = [1,2,3,4,5,1,5,6]
for i in range(name.count(1)):
ele_index = name.index(1)
name[ele_index] = 8888888
print(name)
[root@localhost]# python test.py
[8888888, 2, 3, 4, 5, 8888888, 5, 6]
◆字典的类型◆
Python 中的字典是另一种可变容器模型,且可存储任意类型对象,字典一种key-value 的数据类型,字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号{}中,且字典还有两个特性,第一个就是字典是无序的,第二个是key必须是唯一的,所以天生去重,字典的两种格式如下所示:
person = {"name": "lyshark", "age": 22}person = dict({"name": "lyshark", "age": 22})info = {
'stu1': "***",
'stu2': "*****",
'stu3': "***",
}
接下开继续看字典的常用函数方法,以及后续的小例子,方法如下:
dict.get(key) #取得某个key的valuedict.has_key(key) #判断字典是否有这个key,在python3中已经废除,使用in判断
dict.keys() #返回所有的key为一个列表
dict.values() #返回所有的value为一个列表
dict.items() #将字典的键值拆成元组,全部元组组成一个列表
dict.pop(key) #弹出某个key-value
dict.popitem() #随机弹出key-value
dict.clear() #清除字典中所有元素
dict.copy() #字典复制,d2=d1.copy()是浅复制,如果深复制需要copy模块
dict.fromkeys(s) #生成一个新字典
dict.update(key) #将一个字典合并到当前字典中
dict.iteritems() #生成key-value迭代器,可以用next()取下个key-value
dict.iterkeys() #生成key迭代器
dict.itervalues() #生成values迭代器
增加字典: 在info字典的基础上,增加一个字段info["stu4"] = "苍老师".
>>> info{'stu1': '***', 'stu2': 'xxxx', 'stu3': 'xxxx'}
>>> info["stu4"] = "xxx"
>>>
>>> info
{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx', 'stu4': 'xxx'}
修改字典: 在info字典的基础上,修改将stu1:xxx修改为stu1:金手指.
>>> info{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': xxxxx', 'stu4': 'xxx'}
>>>
>>> info["stu1"] = "xxx"
>>> info
{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx', 'stu4': 'xxx'}
删除字典: 在info字典的基础上,删除几个字典,以下提供多种删除方法.
>>> info{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx', 'stu4': 'xxx'}
>>>
>>> info.pop("stu1") #通过pop函数删除
'xxx'
>>> info
{'stu2': 'xxxxx', 'stu3': 'xxxxx', 'stu4': 'xxx'}
>>>
>>> del info["stu4"] #通过del命令删除
>>> info
{'stu2': 'xxxxx', 'stu3': 'xxxxx'}
>>>
>>> info.popitem() #随机删除元素
('stu3', 'xxxxx')
查找字典: 在info字典基础上,完成几个查询任务,这里提供几种方法.
>>> info{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx'}
>>>
>>> "stu1" in info #标准的查询方式
True
>>>
>>> info.get("stu1") #使用get函数查询
'xxx'
>>>
>>> info["stu2"]
'xxxxx'
更新字典: 在info字典的基础上,更新字典内容,将temp字典与info字典合并.
>>> info{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx'}
>>>
>>> temp = {1:2,"stu4":"xxx"}
>>>
>>> info.update(temp)
>>> info
{'stu1': 'xxx', 'stu2': 'xxxxx', 'stu3': 'xxxxx', 1: 2, 'stu4': 'xxx'}
字典遍历(拓展): 这里提供两种字典遍历方法,建议使用第二种,因为其遍历速度最快.
for keys,values in dict.items():print(keys,values)
for keys in dict:
print(keys,dict[keys])
字典索引(拓展): 字典也支持索引的方式获取,只不过key是他的索引了.
>>> dic={"x":100,"y":[1,2,3]}>>>
>>> dic["x"]
100
>>> dic["y"]
[1, 2, 3]
>>>
>>> dic["y"][2:]
[3]
>>>
>>> len(dic)
2
变量解包(拓展1): 分别分解字典变成元组后赋值给t1,t2.
>>> dic{'x': 100, 'y': [1, 2, 3]}
>>>
>>> dic.items()
dict_items([('x', 100), ('y', [1, 2, 3])])
>>>
>>> t1,t2=dic.items()
>>>
>>> print(t1)
('x', 100)
>>> print(t2)
('y', [1, 2, 3])
变量解包(拓展2): 取出所有key复制给k1,k2.
>>> k1,k2 = {"x":10,"y":20}>>>
>>> print(k1)
x
>>> print(k2)
y
列表合并(拓展): 将两个列表合成一个字典,其中list1是key,list2是values.
>>> list1=[1,2,3,4]>>> list2=["a","b","c","d"]
>>> dic={}
>>>
>>> for (x,y) in zip(list1,list2):
... dic[x]=y
...
>>> dic
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
>>>
字典合并(拓展): 合并字典,但是在有相同的key时会覆盖原有的key的值.
>>> dic1={"x":1,"y":2}>>> dic2={"a":3,"b":4}
>>>
>>> dic1.update(dic2)
>>>
>>> print(dic1)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>>
◆元组的类型◆
元组是Python中常用的一种数据结构,元组由不同的元素组成,每个元素可以存储不同类型的数据,如字符串、数字甚至元组,元组是"写保护"的,即元组创建后不能再做任何修改操作,元组通常代表一行数据,而元组中的元素代表不同的数据项,元组一旦创建,便不能再修改,所以又叫只读列表,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可.
创建元组: 同个几个实例看一下元组是如何被创建的.
>>> tup1 = ("google","baidu",1997,1998)>>> tup2 = (1,2,3,4,5,6,7)
>>> tup3 = "a","b","c","d"
>>>
>>> tup1
('google', 'baidu', 1997, 1998)
>>> tup2
(1, 2, 3, 4, 5, 6, 7)
>>> tup3
('a', 'b', 'c', 'd')
>>>
>>> type(tup1)
<class 'tuple'>
访问元组: 元组可以使用下标索引来访问元组中的值.
>>> tup1('google', 'baidu', 1997, 1998)
>>>
>>> print("tup1[0:]",tup1[0])
tup1[0:] google
>>> print("tup1[1:2]",tup1[1:2])
tup1[1:2] ('baidu',)
连接元组: 元组中的元素值是不允许修改的,但我们可以对元组进行连接组合.
>>> tup1 = (1,2,3,4)>>> tup2 = ("abc","xyz")
>>>
>>> tup3 = tup1+tup2
>>> print(tup3)
(1, 2, 3, 4, 'abc', 'xyz')
删除元组: 元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组.
>>> tup = ("admin","lyshark", 1997, 2000)>>>
>>> print(tup)
('admin', 'lyshark', 1997, 2000)
>>> del tup;
>>> print(tup)
列表转元组: 将一个列表,强制转换成元祖.
>>> list = ["admin","lyshark","guest"]>>>
>>> tuple = tuple(list)
>>>
>>> tuple
('admin', 'lyshark', 'guest')
数据统计: 通过使用count(),index()函数统计元组中的其他数据.
>>> tuple('admin', 'lyshark', 'guest')
>>>
>>> tuple.count("lyshark") #统计lyshark出现次数
1
>>> tuple.index("lyshark") #统计lyshark索引位置
1
元素修改(拓展): 在没有嵌套的情况,元组是不可变对象,但是元组内的列表是可变的.
>>> tup=("lyshark",[1,2,3,4,5])>>> tup
('lyshark', [1, 2, 3, 4, 5])
>>>
>>> tup[1].pop()
5
>>> tup
('lyshark', [1, 2, 3, 4])
元组解包(拓展): 将两个元组,查分开,分别存储在两个变量中.
>>> tup1,tup2=((1,2,3),("a","b","c"))>>> print(tup1)
(1, 2, 3)
>>>
>>> print(tup2)
('a', 'b', 'c')
◆集合的类型◆
集合是一个无序的,不重复的数据组合,集合天生去重,把一个列表变成集合,就自动去重了,集合不支持：索引、元素获取、切片,且没有特定语法格式,只能通过工厂函数创建set,像字符串则直接创建即可,set集合中的元素必须是可迭代对象,所有元素不会重复,不像list列表是可以重复.
set.add(item) #将item添加到set中,如果item已经在set中,则无任何效果set.remove(item) #从set中删除item,如果item不是set的成员,则引发KeyError异常
set.discard(item) #从set中删除item.如果item不是set的成员,则无任何效果
set.pop() #随机删除一个集合元素,并从set删除,有变量接收则会接收删除到的元素
set.clear() #删除set中的所有元素
set.copy() #浅复制
set.update(t) #将t中的所有元素添加到set中,t可以是另一个集合、一个序列
set.union(t) #求并集,返回所有在set和t中的元素
set.intersection(t) #求交集,返回所有同时在set和t中的都有的元素
set.intersection_update(t) #计算set与t的交集,并将结果放入set
set.difference(t) #求差集,返回所有在set中,但不在t中的元素
set.difference_update(t) #从set中删除同时也在t中的所有元素
set.symmetric_difference(t) #求对称差集,返回所有set中没有t中的元素和t中没有set中的元素组成的集合
set.sysmmetric_difference_update(t) #计算set与t的对称差集,并将结果放入set
set.isdisjoint(t) #如果set和t没有相同项,则返回True
set.issubset(t) #如果s是t的一个子集,则返回True
set.issuperset(t) #如果s是t的一个超集,则返回True
创建集合: 使用两种方式分别创建一个集合元素.
>>> s = {"tom","cat","name","lyshark"}>>> s = set({"tom","cat","name","lyshark"})
>>>
>>> s
{'tom', 'cat', 'name', 'lyshark'}
>>> type(s)
<class 'set'>
定义可变集合: 定义一个可变集合,集合中的元素不可重复,都是不同的.
>>> set_test = set("hello")>>> set_test
{'o', 'e', 'l', 'h'}
定义不可变集合: 定义一个不可变集合,集合中的元素不可重复,都是不同的.
>>> set_test = set("hello")>>> set_test
{'o', 'e', 'l', 'h'}
>>>
>>> no_set_test = frozenset(set_test)
>>> no_set_test
frozenset({'o', 'e', 'l', 'h'})
求子集: 子集为某个集合中一部分的集合,故亦称部分集合.
>>> A = set('abcd')>>> B = set("cdef")
>>> C = set("ab")
>>>
>>> C<A #C是A的子集
True
>>> C.issubset(A) #C是A的子集
True
>>> C<B #C不是B的子集
False
求并集: 一组集合的并集是这些集合的所有元素构成的集合,而不包含其他元素.
>>> A{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A | B
{'f', 'b', 'c', 'a', 'e', 'd'}
>>> A.union(B)
{'f', 'b', 'c', 'a', 'e', 'd'}
求交集: 两个集合A和B的交集是含有所有既属于A又属于B的元素,而没有其他元素的集合.
>>> A{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A & B
{'c', 'd'}
>>> A.intersection(B)
{'c', 'd'}
求差集: A与B的差集是,所有属于A且不属于B的元素构成的集合.
>>> A{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A - B
{'a', 'b'}
>>> A.difference(B)
{'a', 'b'}
对称差: 两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合.
>>> A{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A ^ B
{'f', 'b', 'a', 'e'}
>>> A.symmetric_difference(B)
{'f', 'b', 'a', 'e'}
添加元素: 使用add()函数,向一个现有的集合添加一个元素.
>>> s = {1,2,3,4,5,6}>>> s
{1, 2, 3, 4, 5, 6}
>>> s.add("s")
>>> s.add("e")
>>> s.add("t")
>>>
>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
清空集合: 使用clear()函数,清空一个集合中的所有元素.
>>> s{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
>>>
>>> s.clear()
>>>
>>> s
set()
删除指定元素: 使用remove,discard函数,删除集合中的指定元素.
>>> s = {1,2,3,4,5}>>> s
{1, 2, 3, 4, 5}
>>>
>>> s.remove(3)
>>> s
{1, 2, 4, 5}
批量更新元素: 使用update()函数,用自己和另一个的并集来更新这个集合.
>>> s ={"p","y"}>>> s
{'p', 'y'}
>>>
>>> s.update(["H","e"],{"1","2","3"})
>>> s
{'H', '1', 'y', 'p', '2', 'e', '3'}
拓展知识(1): 在多条数据中寻找差异.
# 数据库中原有old_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
}
# cmdb 新汇报的数据
new_dict = {
"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}
old_set=set(old_dict)
new_set=set(new_dict)
del_set=old_set.difference(new_set)
add_set=new_set.difference(old_set)
flush_set=old_set.intersection(new_set)
for i in del_set:
old_dict.pop(i)
for i in add_set:
old_dict[i]=new_dict[i]
for i in flush_set:
old_dict[i] = new_dict[i]
print(old_dict)
拓展知识(2): 在多条数据中寻找差异.
# 数据库中原有old_dict = {
"#1":8,
"#2":4,
"#3":2,
}
# cmdb 新汇报的数据
new_dict = {
"#1":4,
"#3":4,
"#4":2,
}
old_set = set(old_dict.keys())
print(old_set)
new_set = set(new_dict.keys())
print(new_set)
remove_set = old_set.difference(new_set)
print(remove_set)
add_set = new_set.difference(old_set)
print(add_set)
update_set = old_set.intersection(new_set)
print(update_set)
◆序列的补充◆
序列类型表示索引为非负整数的有序对象集合,包括字符串、列表、元组、字符串是字符的,列表和元组是任意python对象的序列,字符和元组属于不可变序列,而列表则支持插入、删除和替换元素等.所有序列都支持迭代,当然元组是不可变对象,对元素的操作是不支持的,当然了有嵌套列表字典是可以操作的,以下是几个常用的序列操作函数:
s + r #连接字符串,与数据s * n #重复s的n次复制
v1,v2...vn = s #变量解包(unpack)
s[i] #索引
s[i:j] #切片
s[i:j:stride] #扩展切片
x in s,x not in s #成员关系
for x in s: #迭代
all(s) #如果s中的所有项都为True,则返回True
any(s) #如果s中的任意项为True,则返回True
len(s) #长度,元素个数
min(s) #s中的最小项
max(s) #s中的最大项
sum(s [,initial]) #具有可选初始值的项的和
all判断: 如果temp中的所有项都为True,则返回True.
>>> temp = [1,1,1,1,1,1]>>> temp1 = [1,1,1,1,0,1]
>>>
>>> all(temp)
True
>>> all(temp1)
False
any判断: 如果temp中的任意项为True,则返回True.
>>> temp = [1,1,1,1,1,1]>>> temp1 = [1,1,1,1,0,1]
>>>
>>> any(temp)
True
>>> any(temp1)
True
len计算元素个数: 计算列表或字典等相关的元素个数.
>>> temp = [1,1,1,1,1,1]>>> len(temp)
6
min返回最小: 返回列表中最小的数值.
>>> temp = [1,2,3,4,5,6,7,8,9]>>>
>>> min(temp)
1
max返回最大: 返回列表中最大的数值.
>>> temp = [1,2,3,4,5,6,7,8,9]>>>
>>> max(temp)
9
## Python 拓展知识
◆文件操作◆
open: open函数用来打开一个文件,并返回一个句柄.
>>> f=open("./test.txt","r")>>>
popen: 使用popen存储命令执行结果,并打印执行结果.
>>> temp=os.popen("ifconfig").readlines()>>> temp
['eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500\n']
read: 此函数一次性读取文件所有内容.
>>> f=open("./test.txt","r")>>> f.read()
readline: 此函数每次读取一行数据,直到全部读取完毕.
>>> f=open("./test.txt","r")>>> f.readline()
'root:x:0:0:root:/root:/bin/bash\n'
>>> f.readline()
'bin:x:1:1:bin:/bin:/sbin/nologin\n'
>>> f.readline()
'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
readlines: 使用readlines一次性读取全部内容,相当于全部加载.
>>> f=open("./test.txt","r")>>> f.readlines()
seek: 使用seek移动光标位置,tell获取当前光标位置.
>>> f=open("./test.txt","r")>>> f.tell() #查询当前光标所在位置
0
>>> f.readline() #读取一行后
'root:x:0:0:root:/root:/bin/bash\n'
>>>
>>> f.tell() #再次查询光标所在位置
32
>>>
>>> f.read() #完全读取后，光标此时在文件最后面..
'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
>>>
>>> f.seek(32) #移动光标到32
>>>
>>> f.read() #重新读取数据
'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'
flush: 强制刷新内存中的数据,将其写入磁盘.
>>> import sys>>> import time
>>>
>>> for i in range(40):
... sys.stdout.write("#")
... sys.stdout.flush() #强制将内存中的数据写入硬盘
... time.sleep(0.1)
close: 使用close关闭文件句柄,每次打开文件用完后记得关闭.
>>> f=open("./test.txt","r")>>> f.readlines()
>>> f.close()
next: 每次读取一行数据,可以使用next函数加载下一行.
>>> f = open("./test.txt", "r")>>> print ("文件名为: ", f.name)
>>> for index in range(5):
... line = next(f)
... print ("第 %d 行 - %s" % (index,line))
>>> f.close()
truncate: 截取数据,可指定每次截取的字节数.
>>> f = open("./test.txt", "r+")>>> print ("文件名为: ", f.name)
>>> f.truncate(10) #截取10个字节
>>> str = f.read()
>>> print ("读取数据: %s" % (str))
>>> f.close()
with: 自动打开文件,并在执行完后自动的释放文件句柄.
>>> with open('test.txt') as f:... print(f.read())
◆其他拓展◆
浅COPY: 浅拷贝值拷贝数据的第一层.
>>> import copy>>> a=[1001,["a","b"]]
>>> print(a)
[1001, ['a', 'b']]
>>>
>>> b=copy.copy(a)
>>> b
[1001, ['a', 'b']]
>>>
>>> a[1][0]="lyshark"
>>> b
[1001, ['lyshark', 'b']] #看,只拷贝了第一层(此时,a第二层发生变化后b也变了)
>>>
深COPY: 深度拷贝,会将所有数据复制一份.
>>> import copy>>>
>>> a=[1001,["a","b"]]
>>>
>>> print(a)
[1001, ['a', 'b']]
>>>
>>> b=copy.deepcopy(a)
>>>
>>> print(b)
[1001, ['a', 'b']]
>>>
>>> a[1][0]="lyshark"
>>>
>>> print(a)
[1001, ['lyshark', 'b']]
>>> print(b)
[1001, ['a', 'b']] #对于深copy由于是完全拷贝所以,对b没有影响
>>>
Copy与deepcopy对比: 以下小例子来对比一下其中的变化.
import copyn1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n2=copy.copy(n1) # 浅拷贝
n3=copy.deepcopy(n1) # 深拷贝
print(n1,id(n1),id(n1['k1']),id(n1['k3']))
print(n2,id(n2),id(n2['k1']),id(n2['k3']))
print(n3,id(n3),id(n3['k1']),id(n3['k3']))
# 从下面打印的值结合上面的图就可以很好的理解
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713748822024 2713753080528 2713755115656
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713755121416 2713753080528 2713755115656
# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713753267656 2713753080528 2713754905800
enumrate: 给一个可迭代的对象添加序号,默认是编号是从0开始,可以设置从1开始.
>>> list=["xxx","xxxxx","xxxx"]>>> for (x,y) in enumerate(list,1):
print(x,y)
1 xxx
2 xxxxx
3 xxxx
range: range用来指定范围,生成指定的数字.
>>> for i in range(1,10):print(i)
>>> for i in range(1,10,2):
print(i)
版权声明：本博客文章与代码均为学习时整理的笔记，文章 [均为原创] 作品，转载请 [添加出处] ，您添加出处是我创作的动力！