第2章自动化系列二之Python基础

Python自动化
笔者QQ:572891887、552408925
Linux架构交流群:471443208、524721466

1.1Python模块

sys模块

  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  3. import sys #导入sys模块
  4. print (sys.path) #打印python环境变量
  5. print(sys.argv) #打印脚本相对路径,执行的时候可以传入参数
  6. print (sys.argv[2]) #取出传入的参数

os模块

  1. import os
  2. print(os.system("df -h")) #调用系统命令
  3. #disk = os.system("ls -l") #执行命令,不保存结果
  4. disk = os.popen("ls -l").read() #结果存入变量
  5. print ("-->",disk)
  6. os.mkdir("new_dir") #创建新目录

第三方库,默认找当前目录,然后找Python环境变量是否存在该模块名。

1.2Python PYC

预编译后的字节码
1.Python是一门解释型语言?
初学Python一直听别人说,Python是一门解释性语言,直到发现了.pyc文件的存在。如果是解释型语言,那么生成的.pyc文件是什么呢?c应该是compiled的缩写才对啊!
为了防止其他学习Python的人也被这句话误解,那么我们就在文中来澄清下这个问题,并且把一些基础概念给理清。
2. 解释型语言和编译型语言
计算机是不能够识别高级语言的,所以当我们运行一个高级语言程序的时候,就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类,第一种是编译,第二种是解释。
编译型语言在程序执行之前,先会通过编译器对程序执行一个编译的过程,把程序转变成机器语言。运行时就不需要翻译,而直接执行就可以了。最典型的例子就是C语言。
解释型语言就没有这个编译的过程,而是在程序运行的时候,通过解释器对程序逐行作出解释,然后直接运行,最典型的例子是Ruby。

通过以上的例子,我们可以来总结一下解释型语言和编译型语言的优缺点,因为编译型语言在程序运行之前就已经对程序做出了“翻译”,所以在运行时就少掉了“翻译”的过程,所以效率比较高。但是我们也不能一概而论,一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化,从而在效率上超过编译型语言。

此外,随着Java等基于虚拟机的语言的兴起,我们又不能把语言纯粹地分成解释型和编译型这两种。
用Java来举例,Java首先是通过编译器编译成字节码文件,然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

3. Python到底是什么

Python也是一门基于虚拟机的语言,我们先来从表面上简单地了解一下Python程序的运行过程吧。

当我们在命令行中输入python hello.py时,其实是激活了Python的“解释器”,告诉“解释器”:你要开始工作了。可是在“解释”之前,其实执行的第一项工作和Java一样,是编译。
Python是一门先编译后解释的语言。

4. 简述Python的运行过程

在说这个问题之前,我们先来说两个概念,PyCodeObject和pyc文件。
我们在硬盘上看到的pyc自然不必多说,而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了,继续向下看。

当python程序运行时,编译的结果则是保存在位于内存中的PyCodeObject中,当Python程序运行结束时,Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时,首先程序会在硬盘中寻找pyc文件,如果找到则直接载入,否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件,我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

1.3Python数据类型

1.3.1 int(整数)

  1. 1.32位机器上,整数的位数为32位,取值范围为-2**312**31-1,即-21474836482147483647
  2. 2.64位系统上,整数的位数为64位,取值范围为-2**632**63-1,即-92233720368547758089223372036854775807

1.3.2 long(长整型)

python3不存在长整型,变为整型,需要注意。

  1. 1.C语言不同,Python的长整数没有指定位宽,
  2. 2.即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
  3. 3.注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。

1.3.3 float(浮点型)

  1. 1.浮点数用来处理实数,即带有小数的数字。
  2. 2.浮点表示的形式是小数,但小数不一定都是浮点型,2352.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4

1.3.4 complex(复数)

  1. 复数由实数部分和虚数部分组成,一般形式为xyj,其中的x是复数的实数部分,y是复数的虚数部分,这里的xy都是实数。
  2. 注:Python中存在小数字池:-5 257

1.3.5 布尔值

真或假
1或0

  1. xuliangwei:~ xuliangwei$ python3
  2. Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
  3. [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. >>> a = 0
  6. >>> if a :print("a")
  7. ...
  8. >>> a =1
  9. >>> if a :print("a")
  10. ...
  11. a

1.3.6 查看数据类型

  1. xuliangwei:~ xuliangwei$ Python3
  2. Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
  3. [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. >>> print (type("xuliangwei.com"))
  6. <class 'str'> #字符串
  7. >>> print (type(1.22))
  8. <class 'float'> #浮点
  9. >>> print (type(1))
  10. <class 'int'> #整数

1.4数据运算

1.4.1算术运算

操作符 描述符 示例
+ 加法 - 对操作符的两侧增加值 a + b = 30
- 减法 - 减去从左侧操作数右侧操作数 a - b = -10
* 乘法 - 相乘的运算符两侧的值 a * b = 200
/ 除 - 由右侧操作数除以左侧操作数 b / a = 2
% 模 - 由右侧操作数和余返回除以左侧操作数 b % a = 0
** 指数- 执行对操作指数(幂)的计算 a**b = 10 的幂 20
// 取整除 - 操作数的除法,其中结果是将小数点后的位数被除去的商。 9//2 = 4 而 9.0//2.0 = 4.0

1.4.21比较运算

运算符 描述符 示例
== 检查,两个操作数的值是否相等,如果是则条件变为真。 (a == b) 不为 true.
!= 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 (a != b) 为 true.
<> 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 (a <> b) 为 true。这个类似于 != 运算符
> 检查左操作数的值是否大于右操作数的值,如果是,则条件成立。 (a > b) 不为 true.
< 检查左操作数的值是否小于右操作数的值,如果是,则条件成立。 (a < b) 为 true.
>= 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立。 (a >= b) 不为 true.
<= 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立。 (a <= b) 为 true.

1.4.3赋值运算

运算符 描述符 示例
= 简单的赋值运算符,赋值从右侧操作数左侧操作数 c = a + b将指定的值 a + b 到 c
+= 加法AND赋值操作符,它增加了右操作数左操作数和结果赋给左操作数 c += a 相当于 c = c + a
-= 减AND赋值操作符,它减去右边的操作数从左边操作数,并将结果赋给左操作数 c -= a 相当于 c = c - a
*= 乘法AND赋值操作符,它乘以右边的操作数与左操作数,并将结果赋给左操作数 c *= a 相当于 c = c * a
/= 除法AND赋值操作符,它把左操作数与正确的操作数,并将结果赋给左操作数 c /= a 相当于= c / a
%= 模量AND赋值操作符,它需要使用两个操作数的模量和分配结果左操作数 c %= a is equivalent to c = c % a
**= 指数AND赋值运算符,执行指数(功率)计算操作符和赋值给左操作数 c **= a 相当于 c = c ** a
//= 地板除,并分配一个值,执行地板除对操作和赋值给左操作数 c //= a 相当于 c = c // a

1.4.4位运算

操作符 描述符 示例
& 二进制和复制操作了一下,结果,如果它存在于两个操作数。 (a & b) = 12 即 0000 1100
| 二进制或复制操作了一个比特,如果它存在一个操作数中。 (a | b) = 61 即 0011 1101
^ 二进制异或运算符的副本,如果它被设置在一个操作数而不是两个比特。 (a ^ b) = 49 即 0011 0001
~ 二进制的补运算符是一元的,并有“翻转”位的效果。 (~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数。
<< 二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。 a << 2 = 240 即 1111 0000
>> 二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。 a >> 2 = 15 即 0000 1111

1.4.5逻辑运算

运算符 描述 示例
and 所谓逻辑与运算符。如果两个操作数都是真的,那么则条件成立。 (a and b) 为 true.
or 所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。 (a or b) 为 true.
not 所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真,则逻辑非运算符将返回false。 not(a and b) 为 false.

1.4.6三元运算

result = 值1 if 条件 else 值2

  1. xuliangwei:~ xuliangwei$ python3
  2. Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 26 2016, 10:47:25)
  3. [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
  4. Type "help", "copyright", "credits" or "license" for more information.
  5. #a,b,c = 1,3,5
  6. if a > b:
  7. a = d
  8. else:
  9. c = d
  10. #简写为如下:
  11. >>> a,b,c = 1,3,5 #定义值
  12. >>> d = a if a>b else c
  13. >>> d
  14. 5
  15. >>> d = a if a <b else c
  16. >>> d
  17. 1

1.4.7进制类型

1.4.8bytes类型

Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。这是件好事。

不管怎样,字符串和字节包之间的界线是必然的,下面的图解非常重要,务请牢记于心:
bytes

  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  3. #encode 编码
  4. #decode 解码
  5. msg = "徐亮伟架构师之路"
  6. print (msg)
  7. print (msg.encode(encoding="utf-8")) #转换为bytes
  8. print (msg.encode("utf-8").decode(encoding="utf-8")) #转为字符串

执行结果:

  1. 徐亮伟架构师之路
  2. b'\xe5\xbe\x90\xe4\xba\xae\xe4\xbc\x9f\xe6\x9e\xb6\xe6\x9e\x84\xe5\xb8\x88\xe4\xb9\x8b\xe8\xb7\xaf '
  3. 徐亮伟架构师之路

1.5Python元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表,用于数据库等信息的连接。

  1. names = ("mysqldb","username","password")
  2. 1.count 统计
  3. 2.index#获取下

1.6Python字符串基本操作

  1. name = "My name is xuliangwei"
  2. print(name.capitalize()) #首字母大写
  3. print(name.count("a")) #查看有几个相同的字符串
  4. print(name.center(50,"-")) #打印50个字符不够的话用‘-’补全
  5. print(name.endswith("xp")) #以什么结尾
  6. print(name.expandtabs(tabsize=30)) #转成多少个"这里是30个"空格
  7. print(name.find(name)) #找字符串的索引
  8. print('Xuliangwei'.lower()) #大写转换成小写
  9. print('Xuliangwei'.upper()) #小写转换成大写
  10. print(name.format(name='Xuliangwei',year=20))
  11. #print(name.format_map( {'name';'Xuliangwei','year';19} ))
  12. print('ab23'.isalnum())
  13. print('abA'.isalpha())
  14. print('1.23'.is_integer())
  15. print('a 1A'.isidentifier()) #判断是不是一个合法的标识符

1.7Python列表基本操作

列表是我们最常用的数据类型,通过列表可以对数据实现最方便的存储、修改等操作(顾头不顾尾)

  1. 列表定义:
  2. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print (names[0],names[2]) #0代表下标,从左到右第一个位置
  3. 执行结果:
  4. Zhangyang Xiangpeng
  5. print (names[1:3]) #切片
  6. 执行结果:
  7. ['lisi', 'wangwu']
  8. print (names[-1:]) #取最后一个值
  9. 执行结果:
  10. ['zhaoliu']
  11. print (names[-2:]) #取最后两个值
  12. 执行结果:
  13. ['wangwu', 'zhaoliu']
  14. print (names[:2]) #从下标0至下标2
  15. 执行结果:
  16. ['zhangsan', 'lisi']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. names.append("xiaoqi")
  3. print("append-->",names)
  4. 执行结果:
  5. append--> ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'xiaoqi']
  6. 追加wangba至于lisi前面
  7. names.insert(1,"wangba")
  8. print("insert-->",names)
  9. 执行结果:
  10. insert--> ['zhangsan', 'wangba', 'lisi', 'wangwu', 'zhaoliu', 'xiaoqi']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. names.insert(0,"xiaosan")
  3. print("insert-->",names)
  4. 执行结果:
  5. insert--> ['xiaosan', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print("获取下标识-->",names.index("wangwu"))
  3. print("获取下标内容-->",names[names.index("wangwu")])
  4. 执行结果:
  5. 获取下标识--> 2
  6. 获取下标内容--> wangwu
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print(names)
  3. names.sort()
  4. print("sort-->",names)
  5. 执行结果:
  6. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  7. sort--> ['lisi', 'wangwu', 'zhangsan', 'zhaoliu']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. names.insert(2,"zhangsan")
  3. print("count-->",names.count("zhangsan"))
  4. 执行结果:
  5. count--> 2
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print(names)
  3. names.reverse()
  4. print("reverse-->",names)
  5. 执行结果:
  6. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  7. reverse--> ['zhaoliu', 'wangwu', 'lisi', 'zhangsan']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print(names)
  3. names2 = [1,2,3,4]
  4. names.extend(names2)
  5. print("extend-->",names)
  6. 执行结果:
  7. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  8. extend--> ['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 1, 2, 3, 4]
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. names2 = names.copy()
  3. print(names)
  4. names[3] = "赵⑥"
  5. print("copy-->",names)
  6. 执行结果:
  7. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  8. copy--> ['zhangsan', 'lisi', 'wangwu', '赵⑥']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. for i in names:
  3. print(i)
  4. 执行结果:
  5. zhangsan
  6. lisi
  7. wangwu
  8. zhaoliu
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. print(names)
  3. del names[2]
  4. print(names)
  5. 执行结果:
  6. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  7. ['zhangsan', 'lisi', 'zhaoliu']
  8. #remove方法
  9. print(names)
  10. names.remove("lisi")
  11. print(names)
  12. 执行结果:
  13. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  14. ['zhangsan', 'wangwu', 'zhaoliu']
  15. #pop
  16. print(names)
  17. names.pop(1) #不指定下标,随机删除
  18. print(names)
  19. 执行结果:
  20. ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
  21. ['zhangsan', 'wangwu', 'zhaoliu']
  1. names = ["zhangsan","lisi","wangwu","zhaoliu"]
  2. names.clear()
  3. print(names)
  4. 执行结果:
  5. []

1.8Python字典

字典书写格式:

  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  3. #key-value
  4. info = {
  5. 'stu1101': "zhangsan",
  6. 'stu1102': "lizi",
  7. 'stu1103': "wangwu",
  8. }
  1. print(info)
  2. print("select-->",info["stu1101"])
  3. #names = info["stu1101"]
  4. #print(names)
  5. print("get-->",info.get("stu1102")) #get方法
  6. 执行结果:
  7. {'stu1103': 'wangwu', 'stu1101': 'zhangsan', 'stu1102': 'lizi'}
  8. select--> zhangsan
  9. get--> lizi
  1. info["stu1101"] = "add 1101"
  2. print(info)
  3. info["stu1104"] = "xiaosan" #不存在则增加
  4. print(info)
  5. 执行结果:
  6. {'stu1103': 'wangwu', 'stu1101': 'add 1101', 'stu1102': 'lizi'}
  7. {'stu1103': 'wangwu', 'stu1104': 'xiaosan', 'stu1101': 'add 1101', 'stu1102': 'lizi'}
  1. del info["stu1103"]
  2. print(info)
  3. 执行结果:
  4. {'stu1102': 'lizi', 'stu1101': 'zhangsan'}
  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  3. www = {
  4. "个人博客":{
  5. 'name':["xuliangwei"],
  6. 'address':["xuliangwei.com"],
  7. },
  8. "运维社区": {
  9. 'name': ["bjstack"],
  10. 'address': ["bjstack.com"],
  11. },
  12. }
  13. www["个人博客"]["address"][0] += ",非常不错的个人博客,多多关注!"
  14. www["运维社区"]["address"][0] += ",社区活跃度非常高,期待你的加入!"
  15. print("猛击有惊喜-->",www["个人博客"]["address"])
  16. print("猛击有惊喜-->",www["运维社区"]["address"])
  17. 执行结果:
  18. 猛击有惊喜--> ['xuliangwei.com,非常不错的个人博客,多多关注!']
  19. 猛击有惊喜--> ['bjstack.com,社区活跃度非常高,期待你的加入!']

1.9购物程序练习

购物车程序
需求:
1.启动程序后,让用户输入工资,然后打印商品列表
2.允许用户根据商品编号购买商品
3.用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒
4.可随时退出,退出时,打印已购买商品和余额

  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  3. product_list = [
  4. ('Iphone', 5800),
  5. ('Mac Pro', 12000),
  6. ('Bike', 800),
  7. ('watch', 31),
  8. ('Python', 120),
  9. ]
  10. shpping_list = []
  11. salary = input("请输入工资:")
  12. if salary.isdigit(): #他是一个数字,强行转换会报错
  13. salary = int(salary)
  14. while True:
  15. for index,item in enumerate (product_list):
  16. #print(product_list.index(item),item) #列表单号
  17. print(index,item)
  18. user_choice = input("选择要买嘛!>>>:")
  19. if user_choice.isdigit():
  20. user_choice = int(user_choice)
  21. if user_choice < len(product_list) and user_choice >=0: #小于列表长度
  22. p_item = product_list[user_choice]
  23. if p_item[1] <= salary: ##买得起
  24. shpping_list.append(p_item)
  25. salary -= p_item[1]
  26. print("添加商品%s成功,你的余额还剩%s" %(p_item,salary))
  27. else:
  28. print("你的余额只剩[%s]啦,还买个毛线" %(salary))
  29. else:
  30. print("你选择商品%s没有,傻x"%user_choice)
  31. elif user_choice == 'q':
  32. print("-------shoping--------- ")
  33. for p in shpping_list:
  34. print(p)
  35. print("你的余额还剩%s"%(salary))
  36. exit()
  37. else:
  38. print("错误的选项!")