python自动化编程-第二天
python自动化编程-第二天
目录
一、Python模块
模块是别人写好的一些功能，打包成一个模块，我们可以直接调用；模块在python中也叫做库;python中的库分为两种，一种叫标准库，一种叫第三方库；
标准库：不需要安装，可以直接导入的库，比如getpass，shell的命令，或者编写stocket等等；
第三方库：必须要安装才能使用，比如 Django，
一般在导入模块时，首先要到python脚本所在目录下查找模块，然后到全局的环境变量中查找；
Python的全局环境变量：是存放模块和python自己文件调用的地方，使用print(sys.path)命令查看；
sys模块是python自带的，使用C语言编写的一个内置模块；
/lib/python3.6 是标准库存放位置；
lib/python3.6/site-packages 是第三方库存放目录。
>>> import sys
>>> print(sys.path)
['', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages']
>>>
另外还有一个方法，用来取向脚本传递的参数
~$ grep -v "^\s*#\|^\s*$" sys_mod.py
import sys
print(sys.argv)
print(sys.argv[2]) #可以取出对本脚本传递的参数，以列表的形式显示，0是脚本名称，
~$
~$ python3 sys_mod.py 1 2 3
['sys_mod.py', '1', '2', '3']
2
系统模块的相关方法
import os
os.system("ls")
#cmd_res = os.system("ls") #执行命令，不保存结果，保存的是命令执行状态返回值，0表示命令执行成功
cmd_res = os.popen("ls").read() #不加read()方法，则返回一段内存地址空间，如果要返回命令执行结果，则需要添加read()方法；
print("--->",cmd_res)
#os.mkdir("new_dir") #创建目录
#执行结果
>>> import os
>>> os.system("ls")
Applications Dropbox Music-local learning 虚拟机
Desktop Library OneDrive private 装机软件
Documents Movies Pictures working
Downloads Music Public 铃声
0
>>> cmd_res = os.system("ls")
Applications Dropbox Music-local learning 虚拟机
Desktop Library OneDrive private 装机软件
Documents Movies Pictures working
Downloads Music Public 铃声
>>> print(cmd_res)
0
>>>
>>> cmd_res = os.popen("ls")
>>>
>>> print(cmd_res)
<os._wrap_close object at 0x1030ab6d8>
>>>
>>> print(cmd_res.read())
Applications
Desktop
Documents
Downloads
Dropbox
Library
Movies
Music
Music-local
OneDrive
Pictures
Public
learning
private
working
铃声
虚拟机
装机软件
二、.pyc是什么
.pyc是python代码预编译后的字节码文件。
python程序运行的过程:
首先当python代码第一次运行时，会将编译的结果保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当下一次在运行python代码时，首先会检测是否存在pyc文件，如果存在，则检测pyc的更新时间与源代码的更新时间，如果源代码更新时间较新，则重新编译为.pyc文件
三、数据类型
1、数字
整型：
python2中根据操作系统分为整型和长整型；python3中统一都叫整型；
浮点数：
带有小数的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10**4
复数：
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
2、布尔型
真或假
1或0
3、字符串
字符串是不可变的
字符串常用功能：
移除空白
分割
长度
索引
切片
四、数据运算
1.算术运算：
2.比较运算
3.赋值运算
4.逻辑运算
5.成员运算
6.身份运算
7.位运算
>>> a = 31
>>> ~a
-32
>>> 224 -256
-32
>>> 64>>2
16
>>> 64/4 # 2**2 = 4
16.0
>>> 64>>4
4
>>> 64/16 # 2**4 = 16
4.0
8.运算符优先级
五、三元运算
>>> a,b,c = 1,3,5
>>> d = a if a> b else c
>>> d
5
如果if的条件为真，则d = a
如果if的条件为假，则d = c
六、bytes类型
python2中，bytes类型与字符串类型是不分的，都是字符串类型，但是在python3中字符串与bytes是分开的；例如在编写socket程序时，用python2时远程的过程调用使用的数据类型是字符串类型，而在python3中就要使用bytes类型；
http://www.ituring.com.cn/article/1116
test = "我住在合肥"
print(test.encode()) #默认为utf-8的编码格式
print(test.encode().decode()) #默认为utf-8的编码格式
执行结果
b'\xe6\x88\x91\xe4\xbd\x8f\xe5\x9c\xa8\xe5\x90\x88\xe8\x82\xa5'
我住在合肥
如果是使用b“aaa”这种设置bytes类型，则字符串必须是ascii里面支持的格式，不能写中文的
七、列表、元组操作
1.列表操作
创建列表：
names = ["ZhangYang","GuYun","XiangPeng"]
or
names = list(["ZhangYang","GuYun","XiangPeng"])
切片
列表是一个有序的数据类型，因此列表中的每个元素都有其位置，相当于索引、指针、下标，从左往右看，顺序从0开始；从右往左看，顺序是从-1开始；
>>> names = ["ZhangYang","GuYun","XiangPeng",["alex","jock"],"XuLiangChen"]
>>>
>>>
>>> names[0] #取出第一个元素；
'ZhangYang'
>>> names[1:3] #取出从第二个元素到第三个元素，不包括第四个元素，俗称"顾头不顾尾"
['GuYun', 'XiangPeng']
>>> names[1:-1] #取出第二个元素，到最后一个元素，但是不包括最后一个元素；
['GuYun', 'XiangPeng', ['alex', 'jock']]
>>> names[0:3] #取出第一个元素，到第三个元素；
['ZhangYang', 'GuYun', 'XiangPeng']
>>> names[-1] #取出最后一个元素
'XuLiangChen'
>>> names[:3] #相当于[0:3]，因此在列表中切片时，0和-1都是可以省略的；
['ZhangYang', 'GuYun', 'XiangPeng']
>>> names[-2:] #取出最后两个元素；
[['alex', 'jock'], 'XuLiangChen']
>>> names[::2] # 2表示步长，就是每隔一个元素，取一个；
>>> ['ZhangYang', 'XiangPeng', 'XuLiangChen']
>>> names[0::2]
['ZhangYang', 'XiangPeng', 'XuLiangChen']
>>> names[:-1:2]
['ZhangYang', 'XiangPeng']
追加
>>> names = ["anqing","liuan","hefei","wuhu"]
>>> names.append("suzhou") #追加只能添加在列表的最后一个位置；
>>> print(names)
['anqing', 'liuan', 'hefei', 'wuhu', 'suzhou']
>>>
插入
>>> print(names)
['anqing', 'liuan', 'hefei', 'wuhu', 'suzhou']
>>> names.insert(1,"huangshan") #1表示要插入的数据在列表中的位置，第二个参数表示要插入的数据
>>> print(names)
['anqing', 'huangshan', 'liuan', 'hefei', 'wuhu', 'suzhou']
修改
>>> print(names)
['anqing', 'huangshan', 'liuan', 'hefei', 'wuhu', 'suzhou']
>>> names[3] = "chuzhou"
>>> print(names)
['anqing', 'huangshan', 'liuan', 'chuzhou', 'wuhu', 'suzhou']
删除
>>> print(names)
['anqing', 'huangshan', 'liuan', 'chuzhou', 'wuhu', 'suzhou']
>>> del names[2] #根据索引来删除指定的元素
>>> print(names)
['anqing', 'huangshan', 'chuzhou', 'wuhu', 'suzhou']
>>> names.remove("wuhu") #删除指定的元素
>>> print(names)
['anqing', 'huangshan', 'chuzhou', 'suzhou']
>>> names.pop() #默认弹出最后一个元素
'suzhou'
>>> names.pop(0) #可以指定索引，删除元素；
'anqing'
>>> print(names)
['huangshan', 'chuzhou']
获取下标
>>> print(names)
['huangshan', 'chuzhou', 'luan', 'chuzhou ', 'chuzhou']
>>> print(names.index("chuzhou"))
1 #只返回从左到右找到的第一个下标
统计
>>> print(names)
['huangshan', 'chuzhou', 'luan', 'chuzhou ', 'chuzhou']
>>> print(names.count("chuzhou"))
2
清空列表
>>> print(names)
['huangshan', 'chuzhou', 'luan', 'chuzhou ', 'chuzhou']
>>> names.clear()
>>> print(names)
[]
翻转和排序
>>> names
['bozhou', 'hefei', '!suzhou', 'HuangShan', '1']
>>> names.sort()
>>> names
['!suzhou', '1', 'HuangShan', 'bozhou', 'hefei']
#排序的顺序为：特殊字符，数字，大写字母，小写字母；
>>> names.reverse() #翻转，将列表中的所有元素的位置进行头尾调换
>>> names
['hefei', 'bozhou', 'HuangShan', '1', '!suzhou']
合并
>>> names2 = [2,3,4,5]
>>> names.extend(names2) #合并
>>> names
['hefei', 'bozhou', 'HuangShan', '1', '!suzhou', 2, 3, 4, 5]
>>> names2 #合并以后，变量不会被删除
[2, 3, 4, 5]
>>> del names2 #删除变量
>>> names2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'names2' is not defined
浅拷贝和深拷贝
拷贝有两种：浅拷贝和深拷贝；
浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象；也就是说第二个列表里面的每个元素，只是第一个列表中的每一个元素的引用；
深拷贝： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
浅拷贝的三种方式：
person = ["name",["saving",100]]
import copy
p1 = copy.copy(person) #相当于 p1 = pserson.copy()
p2 = person[:]
p3 = list(person)
>>> print(p1,p2,p3)
['name', ['saving', 100]] ['name', ['saving', 100]] ['name', ['saving', 100]]
>>> p1[0] = 'alex'
>>> p2[0] = 'fengjie' #同时修改了p1和P2的name元素；
>>>
>>> p1[1][1] = 50 #只修改了p1子列表的元素属性，但是p2的子列表中的元素属性也会改变
>>>
>>> print(p1,p2)
['alex', ['saving', 50]] ['fengjie', ['saving', 50]]
深拷贝：
name2 = copy.deepcopy(names) # 深拷贝，直接拷贝到另一块内存空间中，大部分时候不要两份内存空间
浅拷贝与深拷贝的区别：
1、b = a: 赋值引用，a 和 b 都指向同一个对象。
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向同一对象（是引用）。
3、b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
参考文档：
http://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
http://python.jobbole.com/82294/
在循环中，取出下标的方法
list1 = [1,2,3,4,6]
for index,item in enumerate(list1):
print(index,item)
#执行结果
0 1
1 2
2 3
3 4
4 6
2.元组操作
元组其实和列表差不多，也是存一组数据，只不过它一旦被创建，就不能再修改，所以又叫只读列表；
创建元组：
ages = (12,13,56,34,67)
or
ages = typle((12,13,56,34,67))
元组只有两种方法，count和index。
一个是统计，一个是获取下标
八、字符串操作
特性：不可修改
>>> name = "my name \t is czla"
>>> print(name.capitalize()) #第一个字母大写
My name is czla
>>> print(name.count("a")) #统计字符串的字符个数
2
>>> print(name.center(50,"-")) #把name放中间，然后打印50个"-"
----------------my name is czla-----------------
>>> print(name.endswith("la")) #判断字符串是否以指定字符串结尾
True
>>> print(name.startswith("my")) #判断字符串是否以指定字符串开头
True
>>> print(name.expandtabs(tabsize=30)) #将一个tab键转换为30个空格
my name is czla
>>>
>>>>>> print(name.find("name")) #取出字符串下标，只会从左到右返回第一个查找到的下标
3
>>> print(name.find("n"))
3
>>> print(name.find("a"))
4
>>> print(name.rfind("a")) #从右往左找，第一个，然后显示下标
18
format：
>>> name = "my name is {name} and i am {year} old"
>>> print(name.format(name='alex',year=23))
my name is alex and i am 23 old
formatmap：
>>> print(name.format_map({'name':'alex','year':12}))
my name is alex and i am 12 old
>>> print("alg325".isalnum()) #判断是不是由所有英文字符和数字组成的字符串
True
>>> print("AdDfGeE".isalpha()) #判断是不是由所有英文字符组成的字符串
True
>>> print("fa35_5".isidentifier()) #判断是不是一个合法的标识符(合法的变量名)
True
>>> print("asdgas".islower()) #判断是不是小写字母组成的字符串
True
>>> print("I'M IN CHINA".isupper()) #判断是不是全大写
True
>>> print("356674".isnumeric()) #判断是不是纯数字,不能带有小数
True
>>> print("35667.4".isnumeric())
False
>>> print("1215266".isdecimal()) #判断是不是十进制数字
True
>>> print("1256".isdigit()) #判断是不是整数
True
>>> print("12.56".isdigit())
False
>>> print(" ".isspace()) #判断是不是空格
True
>>> print("My Name Is Czlan".istitle()) #判断是不是一个title字符
True
>>> print(name.isprintable()) #一般都是tty的文件或者drive的文件为False，判断文件是否可以打印。
False
join:
>>> print(",".join(["1","2","3","4"]))
1,2,3,4
>>> print("+".join(["1","2","3","4"]))
1+2+3+4
>>>
>>> print(name.ljust(50,"*")) #保证长度为50，不够用*补上
my name is {name} and i am {year} old*************
>>>
>>> print(name.rjust(50,"*"))
*************my name is {name} and i am {year} old
>>>
大小写转换：
>>> print(name.lower()) #把大写变成小写
my name is {name} and i am {year} old
>>> print(name.upper())
MY NAME IS {NAME} AND I AM {YEAR} OLD
>>>
去掉空格和回车:
>>> name
'\n my guess you a man.\n '
>>> print(name.lstrip())
my guess you a man.
>>> print(name.rstrip())
my guess you a man.
>>> print(name.strip())
my guess you a man.
>>>
>>> p = str.maketrans("abcdef","123456") #适用于密码处理
>>> print("i'm in china".translate(p))
i'm in 3hin1
>>>
>>> print(name.replace("a","A",1)) # 替换，可以指定个数,虽然是替换，但是是指向了不同的内存空间
my guess you A man.
>>> print(name.replace("a","A"))
my guess you A mAn.
>>>
>>> print(name.split()) #将字符串拆分为列表，默认分隔符为空格，
['my', 'guess', 'you', 'a', 'man.']
>>>
>>> print(name.splitlines()) #将字符串按照换行符来拆分为列表；默认分隔符为换行符
['', ' my guess you a man.', ' ']
>>> name = "Czlan"
>>> print(name.swapcase()) #大小写转换
cZLAN
>>> name = "my name \t is czla"
>>> print(name.title()) #转换为title格式，title就是首字母大写
My Name Is Czla
>>> print(name.zfill(50))
000000000000000000000000000000000my name is czla
>>>
九、字典操作
字典是一种key - value的数据类型，字典是无序的；字典的下标就是key；并且key必须唯一；
创建字典：
person = {"name":"mr.wu","age":"18"}
or
person = dict({"name":"mr.wu","age":"18"})
增加
>>> info = {
... 'stu1101':'DaJun',
... 'stu1102':'XiaoTeng',
... 'stu1103':'GuiZi'
... }
>>> info["stu1105"] = "LanZi"
>>> info
{'stu1101': 'DaJun', 'stu1102': 'XiaoTeng', 'stu1103': 'GuiZi', 'stu1105': 'LanZi'}
修改
>>> info["stu1102"] = "YangYang"
>>> info
{'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi'}
删除
>>> info.pop("stu1101") #使用pop方法删除元素
'DaJun'
>>> info
{'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi'}
>>>
>>> del info["stu1103"] #使用python内置方法删除
>>> info
{'stu1102': 'YangYang', 'stu1105': 'LanZi'}
>>> info = {'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi'}
>>>
>>> info.popitem() #随机删除 ('stu1105', 'LanZi')
>>> info
{'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi'}
查找
>>> "stu1102" in info #判断key是否在字典中,info.has_key('stu1103') only on python2
True
>>> info.get("stu1102") #在获取KEY的值，如果存在则返回值，不存在则返回None
'YangYang'
>>> info.get("stu1104")
>>>
>>> info["stu1105"] #存在就会返回值，不存在就会报错，因此不建议是用；
'LanZi'
>>> info["stu1104"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'stu1104'
多级字典嵌套及操作
>>> av_catalog = {
... "欧美":{
... "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
... "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
... "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
... "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
... },
... "日韩":{
... "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
... },
... "大陆":{
... "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
... }
... }
>>> av_catalog["欧美"]["www.youporn.com"][1] = "。。。。。"
>>> print(av_catalog["欧美"]["www.youporn.com"][1])
。。。。。
其他方法
#values:
>>> info.values()
dict_values(['DaJun', 'YangYang', 'GuiZi', 'LanZi'])
>>>
#keys:
>>> info.keys()
dict_keys(['stu1101', 'stu1102', 'stu1103', 'stu1105'])
#setdefault:
>>> info.setdefault("stu1106","czlan") # 设定默认值，如果key已经有值，则覆盖default的值；
'czlan'
>>> info
{'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi', 'stu1106': 'czlan'}
>>> info.setdefault("stu1102","JunZai")
'YangYang'
>>> info
{'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi', 'stu1106': 'czlan'}
#update:
>>> info = {'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'GuiZi', 'stu1105': 'LanZi', 'stu1106': 'czlan'}
>>>
>>> b = {1:2,3:4,"stu1103":"boduoyejieyi"}
>>> info.update(b) #存在KEY的，将替换其值，不存在的KEY，则直接添加 >>> info {'stu1101': 'DaJun', 'stu1102': 'YangYang', 'stu1103': 'boduoyejieyi', 'stu1105': 'LanZi', 'stu1106': 'czlan', 1: 2, 3: 4}
>>>
#items:
>>> info.items() #将key - value的值作为一个元组存在在一个列表中；
dict_items([('stu1101', 'DaJun'), ('stu1102', 'YangYang'), ('stu1103', 'boduoyejieyi'), ('stu1105', 'LanZi'), ('stu1106', 'czlan'), (1, 2), (3, 4)])
>>>
#fromkeys:
>>> dict.fromkeys([1,2,3],["testd",["aaa","g"],1])
{1: ['testd', ['aaa', 'g'], 1], 2: ['testd', ['aaa', 'g'], 1], 3: ['testd', ['aaa', 'g'], 1]}
#但是所有的value中的子列表都是同一个内存地址空间；相当于浅拷贝
>>> a[1][1][1]="ggg"
>>> a
{1: ['testd', ['aaa', 'ggg'], 1], 2: ['testd', ['aaa', 'ggg'], 1], 3: ['testd', ['aaa', 'ggg'], 1]}
>>>
循环dict
for i in info:
print(i,info[i])
for k,v in info.items():
print(k,v)
第一个比第二个高效很多，因为第一个是通过索引（下标）的方式直接取出数据，第二个要先将字典转换成列表后，再取出key和value，如果列表非常大的话，会很消耗系统资源，因此建议使用第一中方法；
注意：所有数据类型的方法中，带有“__”开头的都是内置方法，一般不用。
十、python中的字符串颜色
格式：\033[显示方式;前景色;背景色m
说明：
前景色 背景色 颜色
---------------------------------------
30 40 黑色
31 41 红色
32 42 绿色
33 43 黄色
34 44 蓝色
35 45 紫红色
36 46 青蓝色
37 47 白色
显示方式 意义
-------------------------
0 终端默认设置
1 高亮显示
4 使用下划线
5 闪烁
7 反白显示
8 不可见
例子：
\033[1;31;40m <!--1-高亮显示 31-前景色红色 40-背景色黑色-->
\033[0m <!--采用终端默认设置，即取消颜色设置-->
十一、作业
1、购物车程序：
- 1、启动程序后，输入用户名密码后，如果是第一次登录，让用户输入工资，然后打印商品列表
- 2、允许用户根据商品编号购买商品
- 3、用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
- 4、可随时退出，退出时，打印已购买商品和余额
- 5、在用户使用过程中， 关键输出，如余额，商品已加入购物车等消息，需高亮显示
- 6、用户下一次登录后，输入用户名密码，直接回到上次的状态，即上次消费的余额什么的还是那些，再次登录可继续购买
- 7、允许查询之前的消费记录
浙公网安备 33010602011771号