Python

pyautogui用法

import time
import pyautogui
​
 while True:
     #获取鼠标位置
    currentMouseX, currentMouseY = pyautogui.position() # 鼠标当前位置
    print(currentMouseX, currentMouseY)
    time.sleep(3)
    
 while True:
     time.sleep(1)
     pyautogui.moveTo(1770, 22, duration=0.25)  #鼠标移动到指定位置，duration为持续时间
     time.sleep(1)
     pyautogui.click()                  #点击鼠标
     time.sleep(1)
     pyautogui.moveTo(948, 1051, duration=0.25)
     time.sleep(1)
     pyautogui.click() 
    
    time.sleep(1)
    pyautogui.click(1770, 22, duration=0.25)   #与上面的代码块作用相似
    time.sleep(1)
    pyautogui.click(948, 1051, duration=0.25)

for i in range(2):
  pyautogui.moveRel(50, 0, duration=0.25) # 从当前位置右移100像素
  pyautogui.moveRel(0, 50, duration=0.25) # 向下
  pyautogui.moveRel(-50, 0, duration=0.25) # 向左
  pyautogui.moveRel(0, -50, duration=0.25) # 向上
​
# 按住鼠标左键，把鼠标拖拽到(100, 200)位置
pyautogui.dragTo(100, 200, button='left')
# 按住鼠标左键，用2秒钟把鼠标拖拽到(300, 400)位置
pyautogui.dragTo(300, 400, 2, button='left')
# 按住鼠标左键，用0.2秒钟把鼠标向上拖拽
pyautogui.dragRel(0, -60, duration=0.2)
​
# pyautogui.click(x=moveToX, y=moveToY, clicks=num_of_clicks, interval=secs_between_clicks, button='left')
# 其中，button属性可以设置成left，middle和right。
pyautogui.click(10, 20, 2, 0.25, button='left')
pyautogui.click(x=100, y=200, duration=2) # 先移动到(100, 200)再单击
pyautogui.click() # 鼠标当前位置点击一下
pyautogui.doubleClick() # 鼠标当前位置左击两下
pyautogui.doubleClick(x=100, y=150, button="left") # 鼠标在（100，150）位置左击两下
pyautogui.tripleClick() # 鼠标当前位置左击三下
​
pyautogui.mouseDown() # 鼠标左键按下再松开
pyautogui.mouseUp()
pyautogui.mouseDown(button='right') # 按下鼠标右键
pyautogui.mouseUp(button='right', x=100, y=200) # 移动到(100, 200)位置，然后松开鼠标右键
​
# scroll函数控制鼠标滚轮的滚动，amount_to_scroll参数表示滚动的格数。正数则页面向上滚动，负数则向下滚动
# pyautogui.scroll(clicks=amount_to_scroll, x=moveToX, y=moveToY)
pyautogui.scroll(5, 20, 2)
pyautogui.scroll(10) # 向上滚动10格
pyautogui.scroll(-10) # 向下滚动10格
pyautogui.scroll(10, x=100, y=100) # 移动到(100, 100)位置再向上滚动10格
​
# 缓动/渐变函数可以改变光标移动过程的速度和方向。通常鼠标是匀速直线运动，这就是线性缓动/渐变函数。
# PyAutoGUI有30种缓动/渐变函数，可以通过pyautogui.ease*?查看。
# 开始很慢，不断加速
pyautogui.moveTo(100, 100, 2, pyautogui.easeInQuad)
# 开始很快，不断减速
pyautogui.moveTo(100, 100, 2, pyautogui.easeOutQuad)
# 开始和结束都快，中间比较慢
pyautogui.moveTo(100, 100, 2, pyautogui.easeInOutQuad)
# 一步一徘徊前进
pyautogui.moveTo(100, 100, 2, pyautogui.easeInBounce)
# 徘徊幅度更大，甚至超过起点和终点
pyautogui.moveTo(100, 100, 2, pyautogui.easeInElastic)

 

print('''请根据对应的号码选择一个路由协议:
    1.RIP
    2.IGRP
    3.EIGRP
    4.OSPF
    5.ISIS
    6.BGP''')
option = input('请输入选项（1-6）:')
if option.isdigit() and 1 <= int(option) <=6:     #isdigit函数用于判断内容是否为整数
    if option =='1' or option =='2' or option=='3':    #此处嵌套了一个if语句，注意语句格式
        print('该路由协议属于距离矢量路由协议')
    elif option =='4' or option=='5':
        print('该路由协议属于链路状态路由协议')
    else :
        print('该路由协议属于路径矢量路由协议')
else :
    print('选项效，请输入数字 1-6！')

 

1.数据类型

1.1字符串

与字符串相关的方法与函数

upper()：将字符串中的小写英文转换为大写；

lower()：将字符串中的大写英文转换为小写；

strip()：用于移除字符串开头或者结尾的指定字符，如果没有指定任何参数，则默认移除字符串开头和结尾处的所有空格和换行符；

rstrip():用法与strip()相同；

count()：用于判断一个字符串中具体字母或数字的个数，返回值是整数；

len()：用于判断字符串内容的长度，返回值是整数；

split()：将字符串转换成列表；（split函数的括号中加入的元素为切片依据，会根据括号中的元素对字符串进行分片，每个分片是一个元素）

ip = input('请输入要查询的IP地址：')
ip_list = ip.split('.')            #表示根据“.”进行分片
print(ip_list)
​
----------输出结果----------
请输入要查询的IP地址：132.185.21.132
['132', '185', '21', '132']         #看到此处，根据“.”分片后，ip地址的每一段分成了一个元素
​

列表(list)：一种有序的集合，用“[]“表示，该集合中的数据又被称为元素(Python中列表概念与C/JAVA中的数组概念相似，但实际用法有出入，在C/JAVA中数组中的数据类型是固定的，在Python中，列表中的数据类型不唯一)；

join()：将列表转换成字符串；

type()：用于确定变量的数据类型；

input()：提示用户输入数据，返回值是字符串；

print('请输入你的年龄：')
age = input()                      #input函数默认都是str数据类型
birthyear = 2022-int(age)          #在此将age转换为int类型，才能够进行运算
print('你是'+str(birthyear)+'年生人')  #在使用“+”进行拼接时，只能够拼接字字符串类型，不能拼接int类型，所以将birthyear转换为str类型   

返回值为布尔值（true和false）的函数和方法：

startwith()：用于判断字符串的内容是否是给定的字符串开头；

endwith()：用于判断字符串的内容是否是给定的字符串结尾；

isdigit()：用于判断字符串内容是否为整数；

isalpha()：用于判断字符串内容是否为英文字母；

格式化输出

name = input("name:")
age = int(input("age:"))
job = input("job:")
salary = int(input("salary:"))
​
#方法一
info1 = """
-----info of %s-----
name:%s
age:%d          
job:%s
salary:%d
    """%(name,name,age,job,salary)      #每个关键字的位置与输出内容中转义字符（占位符）的位置一一对应
#%d表示用户输入必须是整型，用于检测用户输入格式是否正确,因此在输入时，要在input()方法前，调用int()方法
​
print(info1)
​
#方法二，常用方法
info2 = """
-----info of {_name}-----
name:{_name}
age:{_age}     
job:{_job}
salary:{_salary}
    """.format(_name=name,_age=age,_job=job,_salary=salary)     #使用format()方法
​
print(info2)
​
#方法三
info3 = """
-----info of {0}-----
name:{0}
age:{1}     
job:{2}
salary:{3}
    """.format(name,age,job,salary)     #使用下标位置表示format方法中关键字的位置
​
print(info3)
——————————————————————————————————
name:xuekang
age:24
job:it
salary:30000
​
-----info of xuekang-----
name:xuekang
age:24          
job:it
salary:30000
    
​
-----info of xuekang-----
name:xuekang
age:24     
job:it
salary:30000
    
​
-----info of xuekang-----
name:xuekang
age:24     
job:it
salary:30000

 

1.2列表

与列表相关的方法与函数

range()：在Python2与Python3中，range有区别，在2 中range创建的整数列表的返回值为列表（使用type函数查看，返回值为list），而在3中，返回值为range（新的返回值类型，变为可迭代的对象，类似数组表示的是地址，这样做可节省内存空间）；

可以在range()指定起始数和尾数，如range(1,15)将返回包含整数1~14的列表；

range()还可通过指定步长来得到我们想要的整数，如只想取1~19中所有的单数，那么就可以使用range(1,20,2)来实现（这里的2即为步长）；

append()：用于向列表中添加元素（将新的元素添加到列表的最后）；

insert()：列表为有序的集合，append()是将新的元素添加到列表的最后，如果要控制元素添加到列表中的指定位置，则要使用insert()方法；

ospf_config=['router ospf 100\n','network 0.0.0.0 255.255.255.255 area 0\n']
print(ospf_config)
ospf_config.insert(0,'system')       #insert插入位置为列表的0号为，即列表的第一位
print(ospf_config)
—————————————————————————————————————— #输出结果
['router ospf 100\n', 'network 0.0.0.0 255.255.255.255 area 0\n']
['system', 'router ospf 100\n', 'network 0.0.0.0 255.255.255.255 area 0\n']

pop()：用于移除（弹出）列表中的元素，可以将值继续使用，如果不指定索引号，则默认移除列表末尾的元素；如果加了索引号，则可以精确的移除元素；

roomates_name = ['WenXiang Yao','YuLong Tang','PengFei Zi','YuanQing He','Jing Wang']
print(roomates_name[0])
print(roomates_name[1])
print(roomates_name[2])
print(roomates_name[3])
print(roomates_name[4])
print("hello,"+roomates_name[0]+",have a good day!")
pop_roommates=roomates_name.pop()         #将弹出的最后一位赋值给pop_roommates
print(pop_roommates)       
————————————————————————————————————————————————
WenXiang Yao
YuLong Tang
PengFei Zi
YuanQing He
Jing Wang
hello,WenXiang Yao,have a good day!
Jing Wang

 

ospf_config=['router ospf 100\n','network 0.0.0.0 255.255.255.255 area 0\n']
print(ospf_config)
ospf_config.insert(0,'system')
print(ospf_config)
ospf_config.pop()
print(ospf_config)
ospf_config.pop(1)     #拿掉索引号为1的第二位
print(ospf_config)
——————————————————————————————
['router ospf 100\n', 'network 0.0.0.0 255.255.255.255 area 0\n']
['system', 'router ospf 100\n', 'network 0.0.0.0 255.255.255.255 area 0\n']
['system', 'router ospf 100\n']
['system']

index()：用于查找列表中元素的索引号（括号中写列表中的具体元素）；

remove()：删除列表中的指定元素，括号中加上指定要删除的元素；

sort()：对列表进行永久性的排序；

cars = ['bmw','audi','toyota']
cars.sort()
print(cars)
cars.sort(reverse=True)    #反序输出
print(cars)
——————————————————————————————————
['audi', 'bmw', 'toyota']
['toyota', 'bmw', 'audi']

sorted()：列表临时性排序

cars = ['bmw','audi','toyota']
print("原始的排序为:")
print(cars)
print("经过sorted排序后为:")
print(sorted(cars))
print("原始的排序依然为:")
print(cars)          #临时排序后，原顺序未改变
——————————————————————————————
原始的排序为:
['bmw', 'audi', 'toyota']
经过sorted排序后为:
['audi', 'bmw', 'toyota']
原始的排序依然为:
['bmw', 'audi', 'toyota']

reverse()：反转列表顺序，永久性的改变，可再次调用reverse()还原排序

len()：确定列表长度（列表中元素的个数），括号中要写上列表名；

 

1.3字典

在Python中，字典（dictionary）是若干组无序键值对（key-value pair）的集合，用{}表示，每一组键值对用逗号隔开；键值对里的键（key）和值（value）以冒号：隔开，左边为键，右边为值；与列表不同，字典是无序的；

dict1={'vendor':'HuaWei','ports':48,'version':'ipv4'}
print(dict1)
print(dict1['version'])          #键的值查找
dict1['number']=100            #添加键值
print(dict1)
dict1['ports']=24             #更改键的值
print(dict1)
del dict1['number']        #删除键与值
print(dict1)
————————————————————————————————————
{'vendor': 'HuaWei', 'ports': 48, 'version': 'ipv4'}
ipv4
{'vendor': 'HuaWei', 'ports': 48, 'version': 'ipv4', 'number': 100}
{'vendor': 'HuaWei', 'ports': 24, 'version': 'ipv4', 'number': 100}
{'vendor': 'HuaWei', 'ports': 24, 'version': 'ipv4'}

aline_0 = {'x_position':0,'y_position':'25','speed':'medium'}
print("Original x_position:"+str(aline_0['x_position']))

#向右移动外星人
#根据外星人的速度决定将其移动多远
if aline_0['speed'] == 'slow':
    x_increment = 1
elif aline_0['speed'] == 'medium':
    x_increment = 2
else:
    x_increment = 3

#新的位置等于老位置加上增量
aline_0['x_position'] = aline_0['x_position'] + x_increment
print("New position:"+str(aline_0['x_position']))
————————————————————————————————————————————
Original x_position:0
New position:2

 

与字典相关的方法与函数

len()：统计字典中有多少组键值对，返回值为整数；

keys()：用于返回字典中所有的键（在Python2中返回值为list，在3中返回值为range，因此在输出时，要使用list()将其转换为列表）

values()：与keys()同理，返回所有的值；

pop()：删除某组键值不只可使用del，用pop也可，但字典中没有索引号，因此pop中要跟键名，且pop的返回值为键对应的值；

get()：values()能得到字典中所有的值，get()中跟具体键名，可以返回对应键名的值；

a=dict1.get('version')
print(a)
————————————————————————————
ipv4

1.3.2遍历字典

user = {
    'name1':'admin',
    'name2':'user1',
    'name3':'user2'
    }
​
for key,values in user.items():     #方法items()用于返回一个键值对列表，前一个关键字key对应键，后一个关键字values对应值
    print('\nkey:'+key)
    print('valuse:'+values)
————————————————————————————————————————————————————
key:name1
values:admin
​
key:name2
values:user1
​
key:name3
values:user2

 

1.4布尔量

布尔值只有两种：True和False（首字母要大写）；

1.4.1比较运算符

• 比较运算符的作用和书写方式同C/JAVA相同；

1.4.2逻辑运算符

• 与（and）、或（or）、非（not）；

 

1.5集合、元组、空值

1.5.1集合（Set）

• 集合为一种特殊的列表，里面没有重复的元素，因此集合没有count()方法；

• 集合可以通过{}方式创建（与字典类似，但是集合中没有键值对），或者通过set()函数创建；

interfaces={'F0/0/1','F0/0/2','F0/0/3'}          #集合的第一种定义方式
print(type(interfaces))                        #使用type()函数查看interfaces的数据类型，命令模式可以直接使用type()函数
print(interfaces)                              #脚本模式下，type()函数要结合print方法使用
interfaces1=set(['Cisco','HuaWei','Juniper','H3C'])  #集合的第二种定义方式
print(type(interfaces1))
print(interfaces1)
————————————————————————————————————
<class 'set'>
{'F0/0/1', 'F0/0/3', 'F0/0/2'}
<class 'set'>
{'Cisco', 'HuaWei', 'H3C', 'Juniper'}

• 若将有重复元素的列表转换为集合，那么重复元素会被去掉，只保留一个；

• 集合也是无序的，因此也不能像列表一样使用index()函数；

1.5.1.1与集合相关的方法与函数

• add()：向集合中添加新元素，返回值依然为集合；

• remove()：删除集合中已经存在的元素，返回值依然为集合；

 

1.5.2元组（Tuple）

• 元组也是一种特殊的列表，但元组与列表最大的区别是：列表可以随意的对其中的元素进行增、删、改，而元组不可以，一旦元组被建立，将无法对其进行修改，因此不能对元组使用append()、insert()、pop()、add()、和remove()等函数与方法，只保留了index()与count()方法；

• 元组可通过()创建，也可以使用tuple()函数创建；

• 元组是有序的；

foods =("宫保鸡丁","糖醋排骨","红烧肉","酸辣土豆丝","番茄西红柿")
for food in foods:
    print(food)
print("**************")
foods = ("宫保鸡丁","红烧鱼","红烧肉","京酱肉丝","番茄西红柿")    #元组不可修改值，但可以整体重新赋值
for food in foods:
    print(food)
——————————————————————————————————————————
宫保鸡丁
糖醋排骨
红烧肉
酸辣土豆丝
番茄西红柿
**************
宫保鸡丁
红烧鱼
红烧肉
京酱肉丝
番茄西红柿

1.5.2.1与元组相关的方法与函数

index()：查询索引号，返回值为整数；

count()：查询指定元素在元组中的数量，返回值为整数；

 

1.5.3空值（None）

• 空值是一个特殊的数据类型，没有自带函数与方法，也无任何算术与逻辑运算，但空值可以赋值给一个变量；

 

2.循环

2.1for循环

name1=['小明','小李','小黄']
for name in name1:          #在执行for循环中，会将列表name1中的每个值顺序的赋值给name变量
    print(name)             #Python中，for循环后的每行不间断的缩进代码都是for循环的一部分

 

2.2创建数字列表

for value in range(1,6):          #使用for循环输出1~5的数字
    print(value)

number=list(range(1,6))           #创建数字列表，list数据类型转换
print(number)

even_number = list(range(2,11,2))     #从2开始，以2为步长，不断加2，直到数字大于11
print(even_number)

S = []                              #创建一个空列表
for values in range(1,11):          #循环1~10
    S1 = values**2                  #临时变量S1，用于储存每个循环数的平方，Python中"**"表示平方
    S.append(S1)                    #将临时变量的值添加到列表S中
print(S)

N = []                           #跟上面代码效果一样，但更简洁
for values1 in range(1,11):
    N.append(values1**2)         #舍弃临时变量，直接将values1平方后添加到列表中
print(N)
——————————————————————————————————————————————————
1
2
3
4
5
[1, 2, 3, 4, 5]
[2, 4, 6, 8, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

2.3使用列表的一部分

2.3.1切片

players = ['小明','小黑','小白','小绿']      #冒号前是起始元素的索引号，冒号后是终止位的索引号加一（实际就是第多少位）
print(players[0:3])      #输出列表中的前三位，中间用冒号隔开
print(players[2:4])
print(players[:3])      #冒号前不加起始位，默认从第一位开始，及索引号0
print(players[2:])      #同样，冒号后不加终止位，默认到列表结尾
print(players[-3:])     #负数的索引号表示离列表结尾距离的元素，输出列表的最后三个元素
————————————————————————————————————————————————————————
['小明', '小黑', '小白']
['小白', '小绿']
['小明', '小黑', '小白']
['小白', '小绿']
['小黑', '小白', '小绿']

2.3.2遍历切片

players = ['小明','小黑','小白','小绿']   
print("前三名信息：")
for player in players[:3]:      #利用for循环遍历
    print(player)
___________________________________
前三名信息：
小明
小黑
小白

2.3.3复制列表

my_like = ['馒头','牛肉','羊肉','菠菜']
friend1_like = my_like[:]        #先在my_like中提取切片，然后再将切片的内容赋值给friend1_like
friend2_like = my_like          #直接将my_like的值赋给friend2_like，通过下面的输出可知，这种列表的复制共享地址空间
print("我最喜欢的食物有：")
print(my_like)
print("朋友1喜欢的食物有：")
print(friend1_like)
print("朋友2喜欢的食物有：")
print(friend2_like)
my_like.append("土豆")      #在my_like中添加新的元素
friend1_like.append("洋葱")      #在friend1_like中添加新的元素
friend2_like.append("豆芽")     #在friend2_like中添加新的元素
print("我最喜欢的食物有：")
print(my_like)
print("朋友1喜欢的食物有：")
print(friend1_like)
print("朋友2喜欢的食物有：")
print(friend2_like)
————————————————————————————————————————————
我最喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜']
朋友1喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜']
朋友2喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜']
我最喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜', '土豆', '豆芽']        #在friend2_like中添加的元素，在my_like中也会体现
朋友1喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜', '洋葱']
朋友2喜欢的食物有：
['馒头', '牛肉', '羊肉', '菠菜', '土豆', '豆芽']        #同样在my_like中新增的元素，在friend2_like中也有所体现

 

3.if语句

cars = ['audi','bmw','toyota']

for car in cars:
    if car == 'bmw':        #判断，将bmw全部改为大写
        print(car.upper())
    else:                   #其余的全部是首部大写
        print(car.title())
 ————————————————————————————————————
Audi
BMW
Toyota

在if语句中将列表名用在条件表达式中时，Python将在列表中至少包含一个元素时返回True；

4.while语句

4.1在列表之间移动元素

#创建一个待验证的用户列表和一个用于存储已验证用户的空列表
unconfirmed_users = ['xiaoming','xiaohua','xiaoxiao']
confirmed_users = []
​
#验证用户，直到没有未验证的用户
#将每个经过验证的用户移到已验证用户列表中
while unconfirmed_users:                      #while后跟列表，表示判断列表是否为空
    current_user = unconfirmed_users.pop()
​
    print("Verifying user:" + current_user.title())
    confirmed_users.append(current_user.title())
​
print("\nThe following user have been confirmed:")
for confirmed_user in confirmed_users:
    print(confirmed_user)
————————————————————————————————
Verifying user:Xiaoxiao
Verifying user:Xiaohua
Verifying user:Xiaoming
​
The following user have been confirmed:
Xiaoxiao
Xiaohua
Xiaoming
​

4.2删除包含特定值的所有列表元素

pets = ['dog','cat','dog','goldfish','cat','rabbit','cat']
print(pets)
​
while 'cat' in pets:
    pets.remove('cat')
print(pets)
——————————————————————————————
['dog', 'cat', 'dog', 'goldfish', 'cat', 'rabbit', 'cat']
['dog', 'dog', 'goldfish', 'rabbit']
​

4.3使用用户输入来填充字典

#创建一个空字典用于存放用户姓名和回答
responses = {}
​
#设置一个标志，判断调查是否结束
polling_active = True
​
while polling_active:
    name = input("What`s your name?\n")
    response = input("How are you?\n")
    #将回答存储在字典中!!!!!
    responses[name] = response
​
    repeat = input("Would you like to let another person respond?(yes/no)\n")
    if repeat == 'no':
        polling_active = False
​
print("---Poll Results---")
for name,response in responses.items():
    print(name + "`s response:" + response + ".")
——————————————————————————————
What`s your name?
lili
How are you?
i am ok
Would you like to let another person respond?(yes/no)
yes
What`s your name?
xiaohei
How are you?
enen,i am fine
Would you like to let another person respond?(yes/no)
yes
What`s your name?
xiaohua
How are you?
no good
Would you like to let another person respond?(yes/no)
no
---Poll Results---
lili`s response:i am ok.
xiaohei`s response:enen,i am fine.
xiaohua`s response:no good.

4.4while循环中的else语句

true_age = 24
​
count = 0
while count < 3:
    guess_age = int(input("guess_age:"))
    if guess_age == true_age:
        print("Yes,you got it.")
        break
    elif guess_age > true_age:
        print("You should think it smaller...")
    else:
        print("You should think it bigger...")
    count +=1
​
# if count == 3:
#     print("You have tried too many times...")
else:       #while循环结束，执行语句，与if count==3含义相同
    print("You have tried too many times...")

 

5.函数

5.1传递实参

5.1.1位置实参

def describe_pet(animal_type,pet_name):
    """显示宠物信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
​
describe_pet('dog','xiaohei')      
describe_pet('cat','66')        #函数的重复调用
describe_pet('heihei','birds')      #在使用位置实参时，要注意传递实参的位置，搞错参数位置，将会很尴尬
————————————————————————————————————
I have a dog.
My dog's name is Xiaohei.
​
I have a cat.
My cat's name is 66.
​
I have a heihei.
My heihei's name is Birds.

5.1.2关键字实参

def describe_pet(animal_type,pet_name):
    """显示宠物信息"""
    print("\nI have a " + animal_type + ".")
    print("My " + animal_type + "'s name is " + pet_name.title() + ".")
​
# describe_pet('dog','xiaohei')
# describe_pet('cat','66')
# describe_pet('heihei','birds')
describe_pet(pet_name='heihei',animal_type='birds')     #即使实参的位置错误，但由于有关键字，在传递时，参数并不会错位
——————————————————————————————
I have a birds.
My birds's name is Heihei.
​

5.1.3默认值

编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，python将使用指定的实参；否则，将使用形参的默认值；

5.1.4可选实参

def get_formatted_name(first_name,last_name,middle_name = ''):      #给middle_name默认值设为空值
    if middle_name:         #判断middle_name是否为空
        full_name = first_name + ' ' + middle_name + ' ' + last_name
    else:
        full_name = first_name + ' ' + last_name
    return full_name.title()
test = get_formatted_name('jimi' , 'hendrix')
print(test)
test = get_formatted_name('jimi' , 'hooker' , 'lee')
print(test)
——————————————————————————————————————————
Jimi Hendrix
Jimi Lee Hooker

5.1.5返回字典

def build_person(first_name,last_name,age=''):
    person = {'first':first_name,'last':last_name}
    if age:     #判断年龄是否为空
        person['age'] = age     #不为空，则新增键age，值为实参
    return person
test = build_person('jimi','hendix',age=18)
print(test)
————————————————————————————————————
{'first': 'jimi', 'last': 'hendix', 'age': 18}

5.1.6函数结合while判断

def get_formatted_name(first_name,last_name):
    full_name = first_name + " " + last_name
    return full_name
​
while True:
    print("\nPleasr enter your name,enter 'q' to quit")
    f_name = input('First_name:')
    if f_name == 'q':
        break
    else:
        l_name = input('Last_name:')
    formatted_name = get_formatted_name(f_name,l_name)
    print('\nHello, '+formatted_name.title() + '!')
——————————————————————————————————————————————
Pleasr enter your name,enter 'q' to quit
First_name:xue
Last_name:kang
​
Hello, Xue Kang!
​
Pleasr enter your name,enter 'q' to quit
First_name:q
  

5.2传递列表

5.2.1在函数中修改列表

在函数中对于列表的修改是永久性的；

unprinted_designs = ['iphone case','robot pendant','dodecahedron']
completed_modles = []

# while unprinted_designs:
#     current_designs = unprinted_designs.pop()
#     print("Printing model:"+current_designs)
#     completed_modles.append(current_designs)
#
# print("\nThe following modles have been printed:")
# for completed_modle in completed_modles:
#     print(completed_modle)
# 设置两个函数，根据功能划分为打印模型函数和已完成模型函数
def print_models(unprinted_design,completed_model):
    while unprinted_designs:
        current_design = unprinted_design.pop()
        print("Printing model:"+current_design)
        completed_model.append(current_design)

def show_completed_models(completed_model):
    print("\nThe following models have been printed:")
    for c_m in completed_model:
        print(c_m)

print_models(unprinted_designs,completed_modles)
show_completed_models(completed_modles)
————————————————————————————————————————————
Printing model:dodecahedron
Printing model:robot pendant
Printing model:iphone case

The following models have been printed:
dodecahedron
robot pendant
iphone case

 

5.3传递任意数量的实参

在不确定函数需要接受多少实参时，python可以在调用函数时，接受任意数量的实参

def make_pizza(*toppings):  #形参名*toppings中的星号会让python创建一个名为toppings的空元组，所有值都会封装进去
    # print(toppings)
    print('\nMaking a pizza with the following toopings:')
    for tooping in toppings:
        print('- '+tooping)
        
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')
——————————————————————————————————————————
Making a pizza with the following toopings:
- pepperoni

Making a pizza with the following toopings:
- mushrooms
- green peppers
- extra cheese

5.3.1结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在定义函数中将接纳任意数量的实参的形参放在最后，python先匹配位置实参和关键字实参，再将剩余的实参都收集到最后一个形参中；

def make_pizza(size,*toppings):  
    # print(toppings)
    print('\nMaking a '+str(size)+'-inch pizza with the following toopings:')
    for tooping in toppings:
        print('- '+tooping)

make_pizza(16,'pepperoni')
make_pizza(15,'mushrooms','green peppers','extra cheese')
————————————————————————————————————————————————
Making a 16-inch pizza with the following toopings:
- pepperoni

Making a 15-inch pizza with the following toopings:
- mushrooms
- green peppers
- extra cheese

5.3.2使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道会传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键-值对——调用语句提供多少就接受多少；

def build_profile(first,last,**user_info):#形参**user_info让python创建一个空的字典，
    #因此在调用函数的时候，user_info的实参应该是键-对值
    """创建一个字典，其中包括我们知道的有关用户的一切"""
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key,value in user_info.items():
        profile[key] = value
    return profile

user_profile = build_profile('alber','einstein',
                             location='princeton',
                             field='physics')
print(user_profile)
————————————————————————————————————————————————
{'first_name': 'alber', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

5.4将函数存储在模块中

函数的优点之一是，使用函数可以将代码块与主程序分离。

5.4.1导入整个模块

要让函数是可导入的，首先要创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。

#modular_pizza.py
def make_pizza(size,*toppings):
    print('\nMaking a '+str(size)+'-inch pizza with the following toopings:')
    for tooping in toppings:
        print('- '+tooping)

#making_pizza.py
import modular_pizza		#导入modular_pizza.py模块

modular_pizza.make_pizza(16,'pepperoni')
——————————————————————————
Making a 16-inch pizza with the following toopings:
- pepperoni

5.4.2导入特定和函数

语法：from module_name import function_name

from modular_pizza import make_pizza

make_pizza(16,'pepperoni')
——————————————————————————————————、
Making a 16-inch pizza with the following toopings:
- pepperoni

5.4.3使用as给函数指定别名

from modular_pizza import make_pizza as mp
​
mp(16,'pepperoni')
——————————————————————————————————
Making a 16-inch pizza with the following toopings:
- pepperoni

5.4.4使用as给模块指定别名

import modular_pizza as mpi
​
mpi.make_pizza(16,'pepperoni')
————————————————————————————————————
Making a 16-inch pizza with the following toopings:
- pepperoni

 

6.类

6.1类的创建

class Dog():
    def __init__(self, name, age):  #self在__init__方法形参中的第一位，在实例化对象的时候，不需要传递实参，用于类的属性初始化
        """初始化属性name和age"""
        self.name = name
        self.age = age
​
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title() + " is now sitting.")
​
    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title() + " rolled over!")
​
my_dog = Dog('wangwang',6)      #类的实例化以及实参的传递
​
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
my_dog.sit()        #实例化对象调用类方法
my_dog.roll_over()
————————————————————————————————————————
My dog's name is Wangwang.
My dog is 6 years old.
Wangwang is now sitting.
Wangwang rolled over!

6.2使用类和实例

class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make		#类中每个属性都必须初始化，哪怕这个值是0或空值
        self.model = model
        self.year = year
        self.odometer_reading = 0  #给定属性默认值

    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " +str(self.odometer_reading) + " miles on it.")


my_new_car = Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
——————————————————————————————————————————————————
2016 audi a4
This car has 0 miles on it.

6.3修改属性的值

• 直接通过实例进行修改

class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0       #给定属性默认值

    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " +str(self.odometer_reading) + " miles on it.")


my_new_car = Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23        #直接访问属性并给属性赋值
my_new_car.read_odometer()
——————————————————————————————————————————————
2016 audi a4
This car has 23 miles on it.

• 通过方法进行设置

class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0       #给定属性默认值

    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " +str(self.odometer_reading) + " miles on it.")

    def update_odometer(self,mileage):
        """设置里程表的值
           禁止将里程表读数回调
        """
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

my_new_car = Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)      #通过方法调用修改属性的值
my_new_car.read_odometer()
——————————————————————————————————————————————————————
2016 audi a4
This car has 23 miles on it.

• 通过方法递增（增加特定的值）

class Car():
    """一次模拟汽车的简单尝试"""
​
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0       #给定属性默认值
​
    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name
​
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " +str(self.odometer_reading) + " miles on it.")
​
    def update_odometer(self,mileage):
        """设置里程表的值
           禁止将里程表读数回调
        """
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
​
    def increment_odometer(self,miles):
        """将里程表读数增加指定的量
           禁止将里程表读数回调
        """
        if miles >=0 :
            self.odometer_reading += miles
        else:
            print("You can't roll back an odometer!")
​
my_used_car = Car('subaru','outback',2013)      
print(my_used_car.get_descriptive_name())
​
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
​
my_used_car.increment_odometer(100)         #增加100里程
my_used_car.read_odometer()
——————————————————————————————————————————————————————
2013 subaru outback
This car has 23500 miles on it.
This car has 23600 miles on it.

6.4继承

一个类继承另一个类时，将自动获得另一个类的所有属性和

6.4.1子类的方法 _ _init _ _()

#创建子类时，父类必须包含在当前文件中，且位于子类的前面
class Car():
    """一次模拟汽车的简单尝试"""

    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name

class ElectricCar(Car):     #定义子类时，必须在括号中指定父类名
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)       #super()是一个特殊函数，帮助python将父类和子类关联起来，这行代码调用父												   类的__init__()方法
                                                #让ElectricCar实例包含父类的所有属性

my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
——————————————————————————————————————————————————————
2016 tesla model s

6.4.2给子类定义属性和方法

class Car():
    """一次模拟汽车的简单尝试"""
​
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
​
    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name
​
class ElectricCar(Car):     
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        """初始化电动汽车的特有属性"""
        self.battery_size = 70
​
    def describe_battery(self):
        """打印一条描述电瓶容量的信息"""
        print("This car has a " + str(self.battery_size) + "-kwh battery.")
​
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
——————————————————————————————
2016 tesla model s
This car has a 70-kwh battery.

6.4.3重写父类方法

class Car():
    """一次模拟汽车的简单尝试"""
​
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
​
    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name
​
    def fill_gas_tank(self):
        print("This car is out of gas!")
​
class ElectricCar(Car):     
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)       
        #"""初始化电动汽车的特有属性"""            
        self.battery_size = 70
​
    def describe_battery(self):
        """打印一条描述电瓶容量的信息"""
        print("This car has a " + str(self.battery_size) + "-kwh battery.")
​
    def fill_gas_tank(self):        #对父类方法的重写
        print("This car doesn't need a gas tank!")
​
my_tesla = ElectricCar('tesla','model s',2016)
my_car = Car('bmw','z4',2018)
my_car.fill_gas_tank()
my_tesla.fill_gas_tank()
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
——————————————————————————————————————
This car is out of gas!
This car doesn't need a gas tank!

6.4.4将实例用作属性

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name

class Battery():
    """一次模拟电动汽车电瓶的尝试"""
    def __init__(self,battery_size=70):
        """初始化电瓶属性"""
        self.battery = battery_size

    def describe_battery(self):
        """打印电瓶信息"""
        print("This car has a " + str(self.battery) + "-kwh battery.")

class ElectricCar(Car):     #定义子类时，必须在括号中指定父类名
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)
        self.batter = Battery()     #通过Battery()类实例化对象self.battery，作为ElectricCar()类的属性

electric_car = ElectricCar('tesla','model s',2016)
print(electric_car.get_descriptive_name())
electric_car.batter.describe_battery()      #electric_car对象调用ElectricCar()类的battery属性，battery对象调用											  Battery()类的describe_battery()方法
                                            #electric_car对象间接调用Battery()类的describe_battery()方法
——————————————————————————————————————————
2016 tesla model s
This car has a 70-kwh battery.

6.5导入类

6.5.1导入单个类

#restaurant模块,文件名restaurant.py
"""一个可用于表示餐厅的类"""
class Restaurant():
​
    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = 0
​
    def describe_restaurant(self):
        print("The restaurant's name is " + self.restaurant_name.title() +
              " and the cuisine type is " +self.cuisine_type + ".\n")
​
    def open_restaurant(self):
        print("The restaurant is open!")
​
    def set_number_served(self,poeple):
        self.number_served = poeple
​
    def increment_number_served(self,add_people):
        self.number_served += add_people

from restaurant import Restaurant   #导入模块内的类
​
class IceCreamStand(Restaurant):
    def __init__(self,flavors):
        self.flavors = flavors
​
    def discribe_flavors(self):
        for i in self.flavors:
            print("This ice-cream is made of " + i + '.')
​
flavors = ['fruit','yogurt','ice']
ice_cream1 = IceCreamStand(flavors)
ice_cream1.discribe_flavors()
————————————————————————————————————————
This ice-cream is made of fruit.
This ice-cream is made of yogurt.
This ice-cream is made of ice.

6.5.2在一个模块中存储多个类

#car模块
class Car():
    """一次模拟汽车的简单尝试"""
​
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
​
    def get_descriptive_name(self):
        """返回整洁的描述信息"""
        long_name = str(self.year) + " " + self.make + ' ' + self.model
        return long_name
​
class Battery():
    """一次模拟电动汽车电瓶的尝试"""
    def __init__(self,battery_size=70):
        """初始化电瓶属性"""
        self.battery_size = battery_size
​
    def discribe_battery(self):
        """打印一条描述电瓶容量的信息"""
        print("This car has a " + str(self.battery_size) + "-kwh battery.")
​
    def get_range(self):
        """打印一条描述电瓶续航里程的信息"""
        if self.battery_size == 70:
            range = 240
        elif self.battery_size ==85:
            range = 270
​
        massage = "This car can go approximately " + str(range)
        massage += " miles on a full charge."
        print(massage)
​
class ElectricCar(Car):
    """模拟点电动汽车的独到之处"""
    def __init__(self,make,model,year):
        super().__init__(make,model,year)     #初始化父类属性
        self.battery = Battery()
​

from car import ElectricCar

my_tesla = ElectricCar('tesla','model y',2019)

print(my_tesla.get_descriptive_name())
my_tesla.battery.discribe_battery()
my_tesla.battery.get_range()
————————————————————————————————————————
2019 tesla model y
This car has a 70-kwh battery.
This car can go approximately 240 miles on a full charge.

6.5.3从一个模块中导入多个类

from car import Car,ElectricCar
​
my_beetle = Car('audi','a6',2015)
print(my_beetle.get_descriptive_name())
​
my_tesla = ElectricCar('tesla','model3',2020)
print(my_tesla.get_descriptive_name())
————————————————————————————
2015 audi a6
2020 tesla model3

6.5.4其他导入类的方式

导入整个模块:

import model_name

导入模块中的所有类:

from model_name import *

在一个模块中导入另一个模块

7.文件和异常

7.1从文件中读取数据

7.1.1读取整个文件

with open('pi_digits.txt') as file_object:      #open()函数接受一个参数：要打开文件的名称
    contents = file_object.read()
    print(contents)
​
"""关键字with表示在不再需要访问文件后将其关闭。在这个程序中，只调用了open()函数，而没有调用close()函数；
    也可以使用open和close函数来打开和关闭文件，但这样做时，如果程序存在bug，导致close函数没有执行，文件
    将不会关闭。要注意close函数的使用，因此可以使用with关键字，让python判断什么时候关闭文件；
"""
"""相比于原始文件，使用read函数读取的数据，在输出时，会在末尾多一行空行，因为read函数到达文件末尾时返回一个
    空字符串，而将这个空字符串显示出来就是空行，解决方式就是使用rstrip()函数：删除字符串末尾的空白；
"""

7.1.2文件路径

使用open函数打开文件，其中文件路径有两种书写方式：

一、相对路径：

在Linux中——with open(‘text_files/filename.txt’) as file_object:

在windows中——with open(‘text_files\filename.txt’) as file_object:（反斜杠“\”）

二、绝对路径：

一般绝对路径相对较长，可以定义一个变量，将绝对路径的字符串赋值给变量；

 

7.1.3逐行读文件

filename = 'pi_digits.txt'
​
with open(filename) as file_object:
    for line in file_object:        #使用for循环逐行读取文件内容
        print(line.rstrip())        #调用rstrip方法，去除行末尾换行符
——————————————————————————————————————
3.1415926535
  8979846934
  4811849154

7.1.4创建一个包含文件各行内容的列表

filename = 'pi_digits.txt'
​
with open(filename) as file_object:
    """使用with关键字时，open()返回的文件对象只能在with代码块内使用。如果要在with代码块外访问文件内容，
        可在with内将文件逐行存储在一个列表中，在with代码块外访问列表就可以了；
    """
    # for line in file_object:        #使用for循环逐行读取文件内容
    #     print(line.rstrip())        #调用rstrip方法，去除行末尾换行符
    lines = file_object.readlines()     #readlines()表示逐行读取目标文件，，读取的文件数据类型为列表，将读取的文件内容存储在lines列表中
    print(lines)
​
for line in lines:
    print(line.rstrip())
————————————————————————————————————————————————————
['3.1415926535\n', '  8979846934\n', '  4811849154']
3.1415926535
  8979846934
  4811849154

replace方法

将字符串中的特定单词都替换为另一个单词

message = "I really like dogs."
print(message)
print(message.replace('dog','cat'))     #replace(‘修改前’，‘修改后’)
————————————————————————————————
I really like dogs.
I really like cats.

*其他

import getpass      #导入getpass模块，用于密码输入时不明文显示
​
username = input("username:")
password = getpass.getpass("password:")     #编辑器中无法有效运行，需在终端中运行
​
print(username,password)
————————————————————————————————
PS D:\app_install_locate\pycharm\source_code\B站> .\密文密码.py
username:langxiaobai
password:
langxiaobai 123456