一、Python 变量类型&运算符

Python语言支持以下类型的运算符:

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级

Python算术运算符

以下假设：a=10;b=20

实例：

>>> a=30
>>> b=20
>>> c=0
>>>
>>> c=a+b
>>> print("a+b=",c)
a+b= 50
>>>
>>> c=a-b
>>> print("a-b=",c)
a-b= 10
>>>
>>> c=a*b
>>> print("axb=",c)
axb= 600
>>>
>>> c=a/b
>>> print("a/b=",c)
a/b= 1.5
>>>
>>> c=a%b
>>> print("a%b=",c)
a%b= 10
>>>
>>>
>>> a=20
>>> b=30
>>> c=a**b
>>> print("a**b=",c)
a**b= 1073741824000000000000000000000000000000
>>>
>>> a=10
>>> b=5
>>> c=a//b
>>> print("a//b=",c)
a//b= 2
>>>

Python比较运算符

以下假设：a=10;b=20

实例：

>>> a=21
>>> b=10
>>> c=0
>>>
>>> if(a==b):
...     print("a等于b")
... else:
...     print("a不等于b")
...
a不等于b
>>>
>>> if(a != b):
...     print("a不等于b")
... else:
...     print("a等于b")
...
a不等于b
>>> 
>>> if (a <> b):（python3会报错）
...     print("a不等于b")
... else:
...     print("a等于b")
... 
a不等于b
>>>
>>> if (a < b):
...     print("a小于b")
... else:
...     print("a大于b")
...
a大于b
>>>
>>> if (a > b):
...     print("a大于b")
... else:
...     print("a小于b")
...
a大于b
>>>
>>>#数值被修改，后继续
>>> a=5
>>> b=20
>>>
>>> if (a <= b):
...     print("a 小于等于b")
... else:
...     print("a 大于b")
...
a 小于等于b
>>>
>>> if(b >= a):
...     print("b大于等于a")
... else:
...     print("b小于a")
...
b大于等于a
>>>

Python赋值运算符

以下假设：a=10;b=20

实例：

>>> a=21
>>> b=10
>>> c=0
>>>
>>> c=a+b
>>> print("a+b=",c)
a+b= 31
>>>
>>> c+=a
>>> print("c+=a=",c)
c+=a= 52
>>>
>>> c*=a
>>> print("c*=a=",c)
c*=a= 1092
>>>
>>> c/=a
>>> print("c/=a=",c)
c/=a= 52.0
>>>
>>> c=2
>>> c%=a
>>> print("c%=a=",c)
c%=a= 2
>>>
>>> c**=a
>>> print("c**=a=",c)
c**=a= 2097152
>>>
>>> c//=a
>>> print("c//=a=",c)
c//=a= 99864
>>>

Python位运算符

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

以下假设变量a=60（0011 1100）;b=13（0000 1101）

实例：

>>> 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
>>>

Python逻辑运算符

以下假设变量a=1;b=1;c=0

实例：

>>> a=1
>>> b=1
>>> c=0
>>>
>>> a and b                     #and只要一处为假则表达式就为假
1
>>> a and c
0
>>>
>>> a or b                     #or只要有一处为真咋表达式为真
1
>>> a or c
1
>>>

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下假设变量：a = 10; b = 20; list = [1, 2, 3, 4, 5 ];

实例：

>>> a=10
>>> b=20
>>> list =[1,2,3,4,5]
>>>
>>> if ( a in list):
...     print("a在list列表中")
... else:
...     print("a不在list列表中")
...
a不在list列表中
>>>
>>> if ( b not in list):
...     print("b不在list列表中")
... else:
...     print("b在list列表中")
...
b不在list列表中
>>>

Python身份运算符

身份运算符用于比较两个对象的存储单元是否一致,id() 函数用于获取对象内存地址。

实例：

>>>
>>> a=20
>>> b=20
>>>
>>> a is b
True
>>>
>>> a is not b
False
>>>
>>> b=30
>>>
>>> a is b
False
>>>
>>> a is not b
True
>>>

Python运算符优先级

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

二、Python 数据类型

Python中的常用数据类型

数字：int, float, complex, bool
字符：str, unicode
列表：list
字典：dict
元组：tuple
集合：set(可变集合),frozenset(不可变集合)
文件：file,open
补充：copy,deepcopy,enumrate,range

Python数值类型

Python 支持四种不同的数值类型

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

float（浮点型）

　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

数值类型的互相转换：

int(x [,base ])                  将x转换为一个整数  
long(x [,base ])                 将x转换为一个长整数  
float(x )                        将x转换到一个浮点数  
complex(real [,imag ])           创建一个复数  
str(x )                          将对象 x 转换为字符串  
repr(x )                         将对象 x 转换为表达式字符串  
eval(str )                       用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )                        将序列 s 转换为一个元组  
list(s )                         将序列 s 转换为一个列表  
chr(x )                          将一个整数转换为一个字符  
unichr(x )                       将一个整数转换为Unicode字符  
ord(x )                          将一个字符转换为它的整数值  
hex(x )                          将一个整数转换为一个十六进制字符串  
oct(x )                          将一个整数转换为一个八进制字符串

Python字符串类型

创建字符串：

>>> str1="hello lyshark"
>>> str1
'hello lyshark'

适用于字符串的常用方法：

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()      找出以什么为结尾的字符元素

Python列表类型

创建列表：

name_list = ['lyshark', 'admin', 'root']
或
name_list ＝ list(['lyshark', 'admin', 'root'])

适用于列表的常用方法：

list.insert() 　　在列表中指定索引位置前插入元素
list.append() 　　在列表尾部插入
list.remove() 　　删除指定的元素
list.pop() 　　　 没有指定索引，则弹出最后一个元素，返回的结果是弹出的索引对应的元素
list.copy() 　　　浅复制,只会复制第一层,如果有嵌套序列则不会复制,如果需要复制则要导入copy模块
list.extend() 　　把另外一个列表合并，并不是追加
list.index() 　　 列表中元素出现的索引位置
list.count() 　　 统计列表中元素的次数
list.reverse() 　进行逆序
list.sort() 　　 进行排序,python3无法把数字和字符串一起排序
l1 + l2 :  　　  合并两个列表，返回一个新的列表，不会修改原列表
l1 * N :   　　  把l1重复N次，返回一个新列表

实例：

#列表切片操作（用来取出多个元素）

>>> list=[1,2,3,4,5,6,7,8,9,0]
>>>
>>>
>>> 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]
>>>

#通过内置函数删除数据

>>> list
[1, 2, 3, 4, 5]
>>>
>>> del(list[0])
>>> list
[2, 3, 4, 5]
>>>

#通过索引来修改元素

>>> list=[1,2,3,4,5]
>>>
>>> print(list)
[1, 2, 3, 4, 5]
>>>
>>> list[1]=99
>>> print(list)
[1, 99, 3, 4, 5]
>>>
>>> list[3]=88
>>> print(list)
[1, 99, 3, 88, 5]
>>>
>>> list[1:]=["a","b","c"]
>>>
>>> print(list)
[1, 'a', 'b', 'c']
>>>

#通过列表类中的方法进行增删改

>>> list=[1,2,3,4,5,6,7,8,9]
>>> list
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list.append(10)
>>>
>>> list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>
>>> list1=["a","b"]
>>>
>>> list.append(list1)
>>>
>>> list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ['a', 'b']]
>>>

#嵌套列表

>>> list1,list2=[[1,"a","b"],[2,"a","b"]]
>>>
>>> print(list1)
[1, 'a', 'b']
>>>
>>> print(list2)
[2, 'a', 'b']

#查找列表中的元素并修改

root@localhost:# cat test.py 
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]

#查找列表中的元素并批量修改

root@localhost:# cat test.py 
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 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

字典的特性：

dict是无序的
key必须是唯一的,so 天生去重

创建字典：

person = {"name": "lyshark", "age": 22}
或
person = dict({"name": "lyshark", "age": 22})

info = {
    'stu1': "加藤鹰",
    'stu2': "波多野结衣",
    'stu3': "小泽玛利亚",
}

适用于字典的常用方法：

dict.get(key)      取得某个key的value
dict.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迭代器

实例：

#两种遍历字典方法

第一种：
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":33,"y":99}
>>>
>>> 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元组类型

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

创建元组：

ages = (1,2,3,4,5)
或
ages = tuple((1,2,3,4,5))

适用于字典的常用方法：

tuple.count()       统计元组中元素的个数
tuple.index()       找出元组中元素的索引位置

实例：

#在没有嵌套的情况，元组是不可变对象，但是元祖内的列表是可变的

>>> 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')
>>>
>>>

Python集合类型

集合是一个无序的，不重复的数据组合，它的主要作用如下：

去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系
不支持：索引、元素获取、切片
没有特定语法格式，只能通过工厂函数创建set，像字符串则直接创建即可
set集合必须中的元素必须是可迭代对象,所有元素不会重复,不像list列表是可以重复

创建集合：

s = {"tom","cat","name","error"}
或
s = set({"tom","cat","name","error"})

集合运算符：

s = set([3,5,9,10])      #创建一个数值集合
  
t = ("Hello")            #创建一个唯一字符的集合


a = t | s                # t 和 s的并集
  
b = t & s                # t 和 s的交集
  
c = t – s                # 求差集（项在t中，但不在s中）
  
d = t ^ s                # 对称差集（项在t或s中，但不会同时出现在二者中）

len(s)                   #集合中项数

max(s)                   #最大值

min(s)                   #最小值

适用于集合的常用方法：

s.add(item)               将item添加到s中。如果item已经在s中，则无任何效果
s.remove(item)            从s中删除item。如果item不是s的成员，则引发KeyError异常
s.discard(item)           从s中删除item.如果item不是s的成员，则无任何效果
s.pop()                   随机删除一个任意集合元素，并将其从s删除,如果有变量接收则会接收到删除到的那个元素
s.clear()                 删除s中的所有元素
s.copy()                  浅复制
s.update(t)               将t中的所有元素添加到s中。t可以是另一个集合、一个序列或者支持迭代的任意对象

s.union(t)                求并集。返回所有在s和t中的元素
s.intersection(t)         求交集。返回所有同时在s和t中的都有的元素
s.intersection_update(t)  计算s与t的交集，并将结果放入s
s.difference(t)           求差集。返回所有在set中，但不在t中的元素
s.difference_update(t)    从s中删除同时也在t中的所有元素
s.symmetric_difference(t) 求对称差集。返回所有s中没有t中的元素和t中没有s中的元素组成的集合
s.sysmmetric_difference_update(t) 计算s与t的对称差集，并将结果放入s

s.isdisjoint(t)           如果s和t没有相同项，则返回True
s.issubset(t)             如果s是t的一个子集，则返回True
s.issuperset(t)           如果s是t的一个超集，则返回True

实例：

#在多条数据中寻找差异

# 数据库中原有
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)

# 数据库中原有
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文件操作

Python-补充

深浅Copy

拷贝意味着对数据重新复制一份，对于拷贝有两种深拷贝，浅拷贝两种拷贝，不同的拷贝有不同的效果。

浅copy：只拷贝第一层数据
深copy：完全拷贝

实例：

#一个浅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 copy
n1 = {"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=["苍井空","小泽玛利亚","吉泽明步"]
>>> for (x,y) in enumerate(list,1):
    print(x,y)

    
1 苍井空
2 小泽玛利亚
3 吉泽明步
>>>

range

range用来指定范围，生成指定的数字。

实例：

#输出1-9

>>> for i in range(1,10):
    print(i)

#输出1-9中所有基数 2代表每次跳一格

>>> for i in range(1,10,2):
    print(i)

《Python运维开发之路》运算符与数据类型(二)

一、Python 变量类型&运算符

Python算术运算符

Python比较运算符

Python赋值运算符

Python位运算符

Python逻辑运算符

Python成员运算符

Python身份运算符

Python运算符优先级

二、Python 数据类型

Python数值类型

Python字符串类型

Python列表类型

Python字典类型

Python元组类型

Python集合类型

Python文件操作

Python-补充

猜你喜欢

《Python运维开发之路》 运算符与数据类型(二)

一、Python 变量类型&运算符

Python算术运算符

Python比较运算符

Python赋值运算符

Python位运算符

Python逻辑运算符

Python成员运算符

Python身份运算符

Python运算符优先级

二、Python 数据类型

Python数值类型

Python字符串类型

Python列表类型

Python字典类型

Python元组类型

Python集合类型

Python文件操作

Python-补充

猜你喜欢

《Python运维开发之路》运算符与数据类型(二)