*args # 表示的是输出的内容，输出内容可以是一个也可以是多个 每个内容之间使用逗号隔开
sep=' ' # 多个内容之间的分隔符 默认是空格
end='\n' # 输出语句的结束语  \n 换行 \t 制表符 
file=None # 将输出的内容指定的文件中
# 扩展知识：文件写入
# 指定打开文件 open('文件路径','打开的模式')
# 打开的模式  r 读取内容 w 写入内容

#  if   如果.. 就...
age = int(input("请输入您年龄:"))
# 判断
if age >= 18:
    print("小伙子 可以谈恋爱了")

age = int(input("请输入您年龄:"))
# 判断
if age >= 18:
    print("小伙子 可以谈恋爱了")
else: #  如果.. 就... 否则....
    print("小朋友 你还小 回家做作业去")

# range 方法
"""
range  生成一个顺序的序列
[stop] 接受结束值  从0开始到多少结束  [0,stop)
"""
res = range(100)
print(res) # (0, 100)  序列

# 把结果转换list 列表
list0 = list(res)
print(list0)

"""
range()
start 起始值
stop  结束值
[, step]  步长 默认1

"""
res = range(1,10,2)
print(list(res)) #  [1, 3, 5, 7, 9]

res = range(10,1,-1)
print(list(res)) (10.。。。2)

# 提供用户输入一个字符 输出十进制的值  # 97 a  65 A
s =  input("请输入一个字符:")
# 转换为 ASCII
value = ord(s)

# 97 + 26 = 123
if value in range(97,124):  # 只判断a-z  范围 a-z
    print(s)

str = "if123456789"
#把字符串的第一个字符大写
str.capitalize()

#返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 (填充的字符)
str.center()

#返回 str 在 string 里面出现的次数，如果 beg或者 end 指定则返回指定范围内 str 出现的次数
str.count("f", beg=0, end=len(str)) # 1

#检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
str.endswith(obj, beg=0, end=len(str))

#把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
str.expandtabs(tabsize=8)

#检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.find(str, beg=0, end=len(string))

#格式化字符串
string.format()

#跟find()方法一样，只不过如果str不在 str中会报一个异常.
string.index(str, beg=0, end=len(string))

#如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalnum()

#如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isalpha()

#如果 string 只包含数字则返回 True 否则返回 False.
string.isdigit()

#如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isnumeric()

#如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.istitle()

#以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.join(seq)   

#以空格拼接字符串
" ".join(string)

#返回一个原字符串左对齐,并使用空格填充至长度width 的新字符串
 string.ljust(width)
    
#转换 string 中所有大写字符为小写.  
string.lower()

#返回字符串 str 中最大的字母。
max(str)

#返回字符串 str 中最小的字母。
min(str)

#把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.replace(str1, str2,  num=string.count(str1))

#类似于 index()，不过是从右边开始.
string.rindex( str, beg=0,end=len(string))

#以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.split(str=" ", num=string.count(str))

#按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 
#False，不包含换行符，如果为 True，则保留换行符。
string.splitlines([keepends])

#检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，
#则在指定范围内检查.
string.startswith(obj, beg=0,end=len(string))

#删除字符串最后的字符
string.strip([obj])

#转换 string 中的小写字母为大写
string.upper()

# 列表类型
list0 = ["开群","老谢","嘉豪",10,True,[12,34],(56,78)]

# 列表中元素的个数  len
res = len(list0)
print(res) # 7

# 访问列表中元素
# [0,len(list0)-1]    [-len(list0),-1]
res = list0[1] # 7IndexError: list index out of range
print(res)

# 修改元素
list0[0] = "老杨"
print(list0)

# 向列表中添加元素
list0.append("思思")
print(list0)

list0.append(10)
print(list0)

# 在指定位置插入元素  下标0
list0.insert(0,"head")
print(list0)

list0.insert(1,"body")
print(list0)

# 将一个列表合并到当前列表中
list1 = [99,88,77,55,66,10,20,10,22,10]
list0.extend(list1)
print(list0)
# list0.append(list1) # 追加 和 合并是有区别的
# print(list0)

# 删除元素
# 直接删除最后一个元素
list0.pop()
print(list0)

# 删除指定索引位置的元素
list0.pop(0)
print(list0)

# 删除指定的元素
list0.remove(10) # 如果有重复元素 只会删除第一个次出现的元素
print(list0)

# 统计某个元素出现的次数  传入一元素
res = list0.count(10)
print(res)

"""
list0 = [10,22,44,66,22,10,99,66]
要求;列表中元素顺序不变  使每个一个元素只有一个
最后的结果：[10,22,44,66,99]
提示思路： 
1.可以借助其他列表辅助完成存储
2.使用到成员运算符  in 或 not in
"""
# list0 = [10,22,44,66,22,10,99,66]
# list1 = []
# for item in list0:
#     if item not in list1:
#         list1.append(item)
# print(list1)

"""
set 用于排重的  是一个无序的集合【插入顺序和显示顺序不一致】
"""
# res = set(list0)
# print(list(res))  # [66, 99, 10, 44, 22]

# 列表 可以切片吗？  [start:stop:step]
print(list0)
# 从头到尾提取数据
sub_list = list0[::]
print(sub_list)

sub_list = list0[1::]
print(sub_list)
# 倒序
sub_list = list0[::-1]
print(sub_list)

# 方法 倒序
list0.reverse()
print(list0)

# 排序:同类型的数据 才会有排序的情况出现
list0 = [12,22,55,35,19,66,48,88]
"""
sort(key=None, reverse=False)
key: 接受的一个函数
     函数可以当做值进行传递
     key的作用：将列表中的元素依次作用于对应的函数 返回排序的元素状态 默认数据大小进行排序的
reverse： 接受的是布尔值
        控制排序完之后是升序还是降序
        默认升序 值False
"""
list0.sort(reverse=True)
print(list0)

# 获取列表中最大值
list0 = [12,22,55,35,19,66,48,88]
max_value = max(list0)
print(max_value)

list0 = [12,22,55,35,19,66,48,88]
min_value = min(list0)
print(min_value)

# 自己去写方法
max_value = list0[0]
for item in list0:
    if item > max_value:
        max_value = item
print(max_value)

# 另外的方式去找最大值
max_index = 0
for i in range(1,len(list0)):
    if list0[i] > list0[max_index]:
        max_index = i
print(list0[max_index])


# 二维列表
list_two = [[89,77,62],[44,23],[55,66,88,22]]
res = list_two[0]
print(res[0])

res = list_two[2][1]
print(res)
# 获取所有一维列表
for list1 in list_two:
    for item in list1:
        print(item)
# 返回值与下标
list_two = [89,77,62,44,23,55,66,88,22]
for k,v in  enumerate(list_two):
    print(k,v) 
      0 89
      1 77 
   	。。。。
    

# 元组类型 ()  tuple
tuple0 = (23,56,99,True,"abc")
# 获取元组中的数据 通过索引获取
value = tuple0[-1]
print(value)

# 获取元组的元素个数
num =  len(tuple0)
print(num)

# 修改元组元素  TypeError: 'tuple' object does not support item assignment 不可以修改
# tuple0[0] = 32
# print(tuple0)

# 获取的操作
tuple1 = ([12,56],"abc",88)
# 获取12
print(tuple1[0][0])
tuple1[0][0] = 22
print(tuple1)
# 元组中的列表 列表是可以修改的
print(id(tuple1[0]))
print(id(tuple1[1]))
print(id(tuple1[2]))

tuple1[0][0] = 22
print(id(tuple1[0]))
print(id(tuple1[1]))
print(id(tuple1[2]))

# 遍历
for item in tuple1:
    print(item)

for i in range(len(tuple1)):
    print(tuple1[i])

# 小括号 还有另外一层意思 就是提高运算的优先级
print(type((10,)))

# 字典操作
dict0 = {"语文":100,"数学":150,"英语":60}
res = "语文" in dict0
print(res)

# 1.在字典中添加键值对
dict0["政治"] = 77
print(dict0)

# 获取值   根据键获取值
value = dict0["语文"]
print(value)

# KeyError: '历史'  报错  不建议
# value = dict0["历史"]
# print(value)

# 2. 建议使用 get方式去获取值
value  = dict0.get("历史")
print(value) # None

# 3. 修改 值
dict0["语文"] = 88
print(dict0)

# 4. 删除
dict0.pop("政治")
print(dict0)

# 5.对于字典进行遍历
# 5.1 只遍历key 键
for key in dict0:
    print(key)
# 5.2 只遍历value 值
for value in dict0.values():
    print(value)
# 5.3 获取所有的键值对元素
# items = dict0.items()
# print(items) # [('语文', 88), ('数学', 150), ('英语', 60)]
# for item in items:
#     print("key=",item[0],"value=",item[1])

# a,b = (11,12)
# print(a,b)
# 同时获取键和值
for k,v in dict0.items():
    print("key=",k,"value=",v)

"""
练习1：
统计一个英文字符串中 每个字母出现的次数
要求使用字典存储：
key:value
字母:个数
例子：aaabbbccca
{'a':4,'b':3,'c':3}
"""
# # 提示用户输入字符串
# src_str = input("请输入一个英文字符串:")
# # 定义容器存储数据 字典
# dict_str = {}
# # 遍历所有输入的字符串
# for s in src_str:
#     if s not in dict_str:
#         dict_str[s] = 1
#     else:
#         # 获取value
#         value = dict_str[s]
#         value += 1
#         dict_str[s] = value
# print(dict_str)


"""
练习2：
键盘录入一句英文语句 单词和单词之间用空格隔开 统计每个单词出现的次数
要求使用字典存储：
key:value
字母:个数

abc abc ddd hello hello
"""

# 提示用户输入英文语句
words = input("请录入一句英文语句，单词和单词之间用空格隔开:")
w_dict = {}
# 根据空格切割字符串
w_list = words.split(" ")
# 遍历列表
for word in w_list:
    if word not in w_dict:
        w_dict[word] = 1
    else:
        w_dict[word] += 1
print(w_dict)

# 集合 setdict0 = {"语文":100,"数学":150,"英语":60,"英语":60}set0 = set([1,2,3,1,2,3])print(set0)# 交集 & 和 并集 |set1 = {1,2,3}set2 = {2,3,4}print(set1&set2) # 2 3print(set1|set2) # 1 2 3 4

def 函数名(变量1,变量2...变量n):	函数功能的实现	return 功能的结果def --- 声明函数的关键字函数名 --- 功能名字  方便之后通过名字进行调用		  命名规范：符合标识符规范 函数名英文字母都是小写 每个单词之间使用下划线隔开  circle_area (起名 最好做到见名知意)小括号 --- 形参列表		  形参： 作用于存储函数功能中未知项的值            实参： 为形参赋值的数据  return --- 作用：结束函数 并将功能的结果返回给调用者  		   如果该功能的实现不必须要返回结果 return可以省略 或者写成 return None    

# 封装一个修改名字的功能name = "开群" # 全局变量def change_name():    """    在函数内部可以直接获取外部变量的数据    如果要进行修改    变量名 = 值    变量作用域的问题：如果直接在函数内部内容写为  变量名 = 值 解释器会默认为函数内部的变量 与外部变量无关    如果想修改外部变量的值 在函数内部标注该变量的作用域范围 global 使用全局变量    """    global name    name = "小杨" # 局部变量    print("函数内部",name)change_name()print("外部",name)

print(self, *args, sep=' ', end='\n', file=None)

import randomprint(random.random())  # (0,1) float  大于0且小于1之间的小数print(random.randint(1,3)) #[1,3]  大于等于1小于等于3之间的整数print(random.randrange(1,3)) # [1,3) 大于等于1 小于3之间的整数print(random.choice([1,"23",[4,5]])) # 在序列中随机产生一个内容print(random.sample([1,"23",[4,5]],2)) # 列表中任意组合两个print(random.uniform(1,3)) # 大于1 小于3的小数item = [1,3,5,7,9]random.shuffle(item) # 打乱item的顺序 相当于 洗牌print(item)

import time# 获取当前的时间   -- 时间元组res = time.localtime()print(res)# 可以通过字段的方式获取 (推荐)year = res.tm_yearprint(year)# 通过索引获取# year = res[5]# print(year)# 2.获取当前时间对应时间戳seconeds =  time.time()print(seconeds)# 将时间戳转换时间元组time1 = time.localtime(seconeds)print(time1)# 休眠time.sleep(2)print("睡醒了")# 时间格式 2021年4月1日 9:54:22'''表示年的占位符   %Y  2021  %y 21表示月的占位符   %m    日           %d  -- 表示是1-31号的日期                 %H  -- 24小时制                 %I  -- 12小时制                 %p  -- am/pm 的标识    分           %M    秒           %S    一年中的第几天     %j'''t1 = time.localtime()# 将其进行格式化res = time.strftime("%Y/%m/%d %H:%M:%S %j %A",t1)print(res)# 将格式化的时间转换为时间元组 2021/04/01 10:00:01time_str = "2021-04-01 10:00:01"res = time.strptime(time_str,"%Y-%m-%d %H:%M:%S")print(res)# 获取指定时间的秒数seconds = time.mktime(res)print(seconeds)'''要求：获取指定时间的三天后的时间思路：指定一个时间  2020-01-01  --- 2020-01-04转成程序认识的时间 获取秒数+3天的秒数 ---时间戳'''# 获取指定时间 的n天后/前的时间戳def get_time(time_str,days,format_str):    # 1.将时间转换为程序认识的时间元组    time_tuple = time.strptime(time_str,format_str)    # 2.获取指定时间的秒数    seconds = time.mktime(time_tuple)    # 3.获取days前/后时间戳    times = seconds + (days) * 24 * 3600    tiems_tuple = time.localtime(times)    res_times = time.strftime(format_str,tiems_tuple)    return res_timesres = get_time("2020-1-1",-3,"%Y-%m-%d")print(res)

import datetime# 获取当前时间res = datetime.datetime.now()print(res)# 获取当前日期day = datetime.date.today()print(day)print(day.weekday()) # 星期# 获取指定时间 的n天后/前的时间res = datetime.date.today() - datetime.timedelta(days=-2) # 正数代表 过去  负数代表 未来   天数print(res)# 时间格式res = datetime.datetime.now().strftime("%Y-%m-%d %j")print(res)# 在转回去res = datetime.datetime.strptime(res,"%Y-%m-%d %j")print(res)# 将时间转化为时间元组time_tuple = datetime.datetime.now().timetuple()print(time_tuple)

import calendar# 显示指定年的日期res = calendar.calendar(2021)#print(res)res = calendar.month(2021,4)print(res)# 判断闰年和平年res = calendar.isleap(2021)print(res)res = calendar.monthcalendar(2021,1)print(res)day = res[2][2]print(day)res = calendar.weekday(2021,4,1)print(res) #[0,6] [星期1 星期天]# hashlib  加密模块

import hashlibhash = hashlib.md5() # md5  不可逆的 不可反解 但是加密是固定的 关系是一一对应 缺陷 可以被撞出来hash.update(bytes('admin',encoding="utf-8")) # 要对那个字符串进行加密# 输出加密的字符串print(hash.hexdigest()) # 拿到加密的字符串  21232f297a57a5a743894a0e4a801fc3hash2 =  hashlib.sha3_384() # 不同算法  hashlib很多加密的算法hash2.update(bytes('admin',encoding="utf-8"))print(hash2.hexdigest())hash3 = hashlib.md5(bytes('abd',encoding="utf-8"))"""如果没有参数 md5遵循一个规则 生成同一个对应关系 如果加了参数 就是在原来的基础上在一层加密  这样的话参数只有自己知道 防止被撞库因为别人永远那不不到这个参数"""hash3.update(bytes('admin',encoding='utf-8'))print(hash3.hexdigest())"""模拟登陆和注册 要求：利用md5进行用户登陆网站进行注册之后密码加密的基本事例扩展：数据放入文本中  open('文件路径','打开模式')******* 模拟网站界面*****1.登录2.注册"""# 封装加密功能def md5_jiami(arg):    hash = hashlib.md5(bytes('abcd',encoding='utf-8')) # 如果加了参数 就是在原来的基础上在一层加密  这样的话参数只有自己知道 防止被撞库    hash.update(bytes(arg,encoding='utf-8')) # 要对那个字符串进行加密    return hash.hexdigest()# 封装注册功能def register(user,pwd):    with open("db.txt","a",encoding="utf-8") as f:        #数据 用户名+密码（加密？）        temp = user + "|" + md5_jiami(pwd) + "\n"        f.write(temp)# 封装登录功能def log(user,pwd):    with open('db.txt','r',encoding="utf-8") as f:        for line in f:           u,p = line.strip().split("|") # admin  da3177cbd9f064004b6a0d59a3a484bb           if u == user and p == md5_jiami(pwd):               return Trueprint("******* 模拟网站界面*****")print("1.表示登录 \n2.表示注册")i = input("请选择操作功能：")if i == "2":    user = input("用户名:")    pwd = input("密码:")    register(user,pwd)elif i == "1":    user = input("用户名:")    pwd = input("密码:")    res = log(user,pwd)    if res:        print("登录成功")    else:        print("登录失败")

# from collections import Iterable # 判断是否是迭代对象  -- 是迭代对象# # isinstance()判断是否是迭代对象的方法# print(isinstance("abc",Iterable)) # True# print(isinstance([1,2,3],Iterable)) # True# print(isinstance(123,Iterable))list1 = list("一二三四五六七八九十")# 获取索引 和  值for i,v in enumerate(list1):    print("index:",i,"values",v)

list0 = [1,2,3,4,5,6,7,8,9,10]# 从上面数据中快速生成[2,4,6,8,10]# 不使用列表生成式# list1 = []# for item in list0:#     if item % 2 == 0:#         list1.append(item)# print(list1)# 列表生成式list2 = [item for item in list0 if item%2==0]print(list2)# 在上面的基础上 利用列表生成式 生成[4,16,36,64,100]list3 = [item**2 for item in list2]print(list3)# 判断某个数据是否指定的类型res = isinstance(123,str)print(res)list4 = ["good","nice",12,"day","up",88]# 只要字符串 不要数字res = [item for item in list4 if isinstance(item,str)]print(res)## 只要字符串 不要数字 字符串的字母变大写形态res = [item.upper() for item in list4 if isinstance(item,str)]print(res)

# 字典生成式dict0= {"语文":88,"政治":76,"历史":57,"英语":55}# 大于60分的科目dict1 = {k:v for k,v in dict0.items() if v>=60}print(dict1)# 将原字典的键和值颠倒dict1 = {v:k for k,v in dict0.items() if v>=60}print(dict1)

# 可变参数# 求n个数累计的和def add(*nums):    #print(type(nums)) # 元组    # 在函数中nums是一个元组；用于接受传递过来的所有实参的值    sum = 0    for item in nums:        sum+=item    return sum# res = add(1,2,33,55,10)# print(res)# 直接传递一个元组tuple0 = (34,56,88)# 调用函数res = add(*tuple0) # 在其赋值给函数的可变参数nums 不加* 报错print(res) # TypeError: unsupported operand type(s) for +=: 'int' and 'tuple'list0 = [1,2,3]res = add(*list0)print(res)

# 关键字参数# 选填项就要用关键字参数  字段名=数据def accept_data(username,password,**argus):    print(username,password,argus)# 调用函数accept_data("开群","5201314",email="860152299@qq.com",sex="女")dict0 = {'email': '860152299@qq.com', 'sex': '女'}# 通过字典传值accept_data("小群群","1314520",**dict0)

# 闭包# def func_a():#     def func_b():#         print("内部函数B")#     def func_c():#         print("内部函数C")#     return func_b# res = func_a()# res()#func_a()()# func_b()  在函数内部声明的内容 函数外部获取不到的# 作用域# 变量作用域：全局变量 和 局部变量a = 50 # 全局变量def func_a():    # global a    # a = 500 # 局部变量    num = 10    def func_b():        print("内部函数B")        nonlocal num        num = 100        print("内部函数B",num)    def func_c():        print("内部函数C")    func_b()    print("外部函数：",num)    return func_bres = func_a()print(res)# print(a)

# 打印九九乘法表def table():    for i in range(1,10):        for j in range(1,i+1):            print(j,"*",i,"=",i*j,end=" \t")        print("")import time# start = time.time()# table()# end = time.time()# print(end-start)# 想计算每个功能执行的时间def get_time(func):    start = time.time()    func()    end = time.time()    print("耗时",end-start)def nums():    for s in range(1,1000000):        print(s)get_time(nums)

def outter_name(func):    def inner_name(*value,**argus):        # 增加的功能        res = func(*value,**argus)        return res    return inner_name

# 偏函数"""int(x, base=10)--- 常用的状态十进制为基础"""res= int("10",base=2)print(res) # 0000 0000 # 2def int1(value):    return int(value,base=2)res = int1("0010")print(res)# 系统也提供了设置偏函数的功能import  functoolsint2 = functools.partial(int,base=2)res = int2("1001")print(res)

# def add(a,b):#     return a+bf = lambda a,b:a+bprint(f)res = f(12,34)print(res)# def add(a,b,c):#     return a+b+cadd = lambda a,b,c:a+b+cprint(add(1,2,3))# res = add(1,2)# print(res) # 第二个会把第一个覆盖掉

import os# 1.获取当前的操作系统的名称name = os.nameprint(name) # nt -- windows posix--Liunx/Mac# 获取系统的信息# res = os.uname()  # windows 下是不支持 Mac/Liunx下才有结果# print(res)# 获取环境变量env =  os.environprint(env)# 获取某一个的环境变量对应的值res = os.environ.get("Path")print(res)"""绝对路径:从盘符开始 到目的的文件结束D:\Anaconda3\demo.txt相对路径：参照物    C:        test            a.txt            m.py            subtest                b.txt        test1            c.txt参照物是m.py文件需求：    想在m.py中获取a.txt这个路径（平级的直接就写文件名称即可） a.txt    想在m.py中获取b.txt这个路径 (subtest\b.txt)    想在m.py中获取c.txt这个路径 (..\test1\c.txt). --- 当前路径.. --- 上一级路径"""# 获得当前文件所在的当前路径path = os.curdir # 当前路径print(path) # .# 获得当前文件所在的目录path = os.getcwd()print(path)# D:\pythonobj\ch14\os_pack# 获得指定目录下的所有子目录或者子文件的名字path = r"D:\pythonobj"path_list = os.listdir(path)print(path_list)# 创建目录"""make directory 创建文件夹"""#os.mkdir("test_dir") # 相对路径# 多级目录 mkdir不行 创建一级#os.mkdir(r"D:\pythonobj\ch14\os_pack\test")# 想多级目录#os.makedirs(r"D:\pythonobj\ch14\os_pack\test1\test2\test3")# 删除目录#os.rmdir("test_dir")# 删除只能删除空目录（删除只会删除最后一级目录）#os.rmdir(r"D:\pythonobj\ch14\os_pack\test1\test2\test3")# 创建文件  -- 注：后面文件的输入输出详细讲解# 打开一个文件 执行的写的操作  打开这个文件的时候 如果文件不存在 则创建#open("test.txt","w")# 删除文件#os.remove("test.txt")# 获取文件的信息#res = os.stat("os_demo.py")  # 存在问题   传入文件名  路径地址#print(res)# 重命名#os.rename("修改目录","原目录")# 重命名目录#os.rename(r"D:\pythonobj\ch14\os_pack\test1",r"D:\pythonobj\ch14\os_pack\test3")# 有些对文件的操作是存在os.path下# 文件的绝对路径ab_path = os.path.abspath(".")print(ab_path) # D:\pythonobj\ch14\os_pack# 拼接路径join_path = os.path.join("路径","文件名)print(join_path) # D:\pythonobj\ch14\os_pack\os_demo.py# 拆分路径 最后的返回结果1个元组 (“前半部分路径”，“最后一级的路径名”)res = os.path.split(ab_path)print(res)# 获取指定路径的扩展名分为两个路径(前半部分路径，文件的扩展名)# 注：如果指定的路径是一个目录的话 扩展名的部分就是空字符res = os.path.splitext(join_path)print(res)# 获取指定路径的 最后一级的名字file_name = os.path.basename(ab_path)print(file_name)# 获取指定路径的 最后一级前的所有路径dir_name = os.path.dirname(ab_path)print(dir_name)# 获取文件的大小file_size = os.path.getsize(join_path)print(file_size) # 字节 B -- KB -- MB -- GB -- TB -- PB -- EB -- ZB -- YB -- BB -- NB -- DB -- CB -- XB# 判断操作# 1.判断指定目录是否绝对路径res = os.path.isabs(join_path)print(res) # True# 2.判断指定路径是不是目录/文件夹res = os.path.isdir(ab_path)print(res)# 3.判断是否是文件res= os.path.isfile(join_path)print(res)# 判断指定路径在计算机中是否存在res = os.path.exists("w:\s")print(res)"""练习：获取指定目录下 后缀为.wmv的文件路径      扩展：想获取指定目录下所有的文件"""path = r"C:\Users\Administrator\Desktop\数据分析5班\2021-4-6\video"dir_list = os.listdir(path)for file_name in dir_list:    if file_name.endswith(".wmv"):        print(os.path.join(path,file_name))# 想获取指定目录下所有的文件"""test    a.txt    b.txt    subtest        1.txt        2.txt        sub_tets            l.txt            m.txt"""# 目录中 所有的文件def get_file(path):    # 判断路径是否存在    if not os.path.exists(path):        return    if os.path.isfile(path):        print("只接受目录")        return    file_list = os.listdir(path)    for file_name in file_list:        # 判断路径下是否文件路径        join_path = os.path.join(path,file_name)        # 判断整个路径        if os.path.isfile(join_path):            print(join_path)        else:            get_file(join_path) # 在去找# get_file(r"d:\\")"""删除指定目录"""def delete_file(path):    # 判断路径是否存在    if not os.path.exists(path):        return    if os.path.isfile(path):        print("只接受目录")        return    file_list = os.listdir(path)    for file_name in file_list:        # 判断路径下是否文件路径        join_path = os.path.join(path, file_name)        # 判断整个路径        if os.path.isfile(join_path):            os.remove(join_path)            print(join_path,"已删除")        else:            delete_file(join_path)  # 在去找    # 遍历删除完成后 该目录成了空目录    os.rmdir(path)delete_file(r"E:\pythonobj")

打开模式：r  (read)   ---- 只读操作  要求文件必须存在w  (write)  ---- 只写模式  如果文件不存在 会创建文件  存在将文件原来的内容清空x  			---- 写入模式  要求文件是存在的a  (append) ---- 只写模式  如果文件不存在 会创建文件 如果文件存在会在原来的基础上进行拼接r+  w+ x+  a+ ----- 可以进行读和写带有b的模式    --- 以二进制的形式对文件进行读写操作   读出/写入的是数据的字节格式rb  wb  xb abrb+ wb+ xb+ ab+程序本身无法处理程序外部的垃圾【读和写的过程中产生垃圾 程序无法处理】当文件处理完毕后 记得关闭处理通道 防止产出通道垃圾（程序无法处理）handle.close()

read([size]) 不写参数的话 一次性将文件中的内容全部读取出来传入size大小   一次性读取<=size个字符的数据readline()将数据一行一行的进行读取readlines()读取所有的行  将每一行当做一个元素存放在列表中

# 1.打开文件获取文件的操作手柄# r 读取的是字符数据  记住可能存在编码问题  设置编辑集  utf-8handle = open("hello.txt","r",encoding="gbk")# 调用读取的函数 read# res = handle.read()# print(res)# 获取文件指针位置pos = handle.tell()print(pos)# 按字节读取"""r 按照字符个数读取rb  按照字节数读取"""res = handle.read(5)print(res) # 5个字# 获取文件指针位置pos = handle.tell()print(pos) # gbk 2字节 utf-8 3个字节# 如果还想在读取前面的数据 需要移动文件指针到指定的位置handle.seek(0)# res = handle.read(1)# print(res)# readline 一行一行的读取 读取的时候换行读取出来\n# line = handle.readline()# print(line)# line = handle.readline()# print(line)# # 循环遍历# readlines 读取多行 将每一行当做元素存储在列表中lines = handle.readlines()print(lines)# 关闭通道handle.close()

write(str/字节数据)将字符串写入到文件中 根据写入的模式来判定写入的内容 a/w  --字符串 ab/wb 写入就是字节数据writelines(序列)将序列中的内容写入到文件中

# 写的操作handle = open("hello.txt","a")handle.write("\n这首诗叫做静夜思")# 按序列写入内容list0 = ["小乔流水人家\n","古道西风瘦马\n","夕阳西下\n","断肠人在天涯"]# handle.writelines(list0)for item in list0:    handle.write(item)handle.close()

# 二进制写入handle = open("hello.txt","wb")# 写进去的就是字节数据 如果是带b模式只能写入字节数据handle.write("\n离离原上草".encode('gbk'))# 如果遇到写入不成功 可以执行刷新handle.flush()handle.close()

例子：#系统界面while 1:    print("**********************学员管理系统**********************")    print("**********************1.添加学员**********************")    print("**********************2.修改学员**********************")    print("**********************3.查询学员**********************")    print("**********************4.删除学员**********************")    print("**********************0.退出程序**********************")    num = int(input("请选择你的操作："))    if num == 1:        pass    elif num==2:        pass    elif num==3:        pass    elif num==4:        pass    else:        print("退出程序")        break

#深拷贝，包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变import copyalist=`[``1``,``2``,``3``,[``"a"``,``"b"``]]`d=copy.deepcopy(alist)#copy浅拷贝，没有拷贝子对象，所以原始数据改变，子对象会改变\>> b=alist\>>> print b[1, 2, 3, ['a', 'b']]\>>> alist.append(5)\>>> print alist;print b[1, 2, 3, ['a', 'b'], 5][1, 2, 3, ['a', 'b'], 5]

import pandas as pa# data = pa.DataFrame(dict(item))# data.to_csv('医药.csv',mode='a',header=False,index=False,sep='|')

# 列表方式写入csvimport csv# 当前上下文操作 with  自动关闭通道with open("data.csv","a+",encoding="utf-8",newline='') as csvfile:    # csv 写入操作对象    writer = csv.writer(csvfile)    # 写入一行    writer.writerow(['1','2','3','4','5'])    # 写入多行    writer.writerows([[0,1,3],[1,2,3],[2,3,4]]) # 以二维列表方式进行写入    

# 字典方式的写入csvimport csvwith open("data2.csv","a+",encoding="gbk",newline="") as csvfile:    # 字典 name:张三 sex:男    filename = {'name','sex'}    # 写入标题    writer = csv.DictWriter(csvfile,fieldnames=filename)    writer.writeheader()    # 写入内容    writer.writerow({'name':'开群','sex':'男'})    writer.writerow({'name': '嘉豪', 'sex': '男'})    writer.writerow({'name': '小东', 'sex': '男'})   

# 列表方式的读取import csvwith open('data.csv','r',encoding='utf-8') as csvfile:    # 读取的对象    reader = csv.reader(csvfile)    for row in reader:        print(row,row[0]) # 读取出来的内容是列表格式的  0

# 字典方式的读取import csvwith open('data2.csv','r',encoding='gbk') as csvfile:    reader = csv.DictReader(csvfile)    for row in reader:        print(row['sex']) # 可以直接通过键的名称取值

# 异常机制num = 0try:    num = int(input("请输入一个数字:"))except ValueError as ve:    print("输入的格式不正确",ve)else:    print("else")

class Student:	# 描述所有个体的特征	name = ""	score = 0

声明一个类的关键字  class对象的描述：	特征描述：名字			年龄	行为描述：			正在吃饭...			正在跑步...	这些描述映射到程序中：			特征描述  --- 变量（属性）			行为描述  --- 功能（方法）class 自定义类的名字：	 def __init__(self,形参列表)：	 	self.特征描述的变量 = 创建对象传值的初始化数据	 def 行为名字(self,参与行为的未知项):	 	行为的实现

变量 = 自定义的类名称(描述该对象的数据值)

class Student:    """    def __init__(self,name,age,sex,address):    初始化方法：来为新建的对象进行初始化特征值的    self  --- 表示你当前创建的对象         初始化方法需要明确为那个对象来进行初始化 -- 用self来接受的对象         这个self不需要手动进行赋值的 自动将你创建的对象赋予给self    动态为对象添加字段（属性） ：对象有哪些特征 直接通过self.特征名字 动态添加    注：self.name 和 init方法中的形参名name不是一个内容    self.name --- 表示是该对象的特征    形参name --- 接受初始化数据 为特征赋值的    """    def __init__(self,name,age,sex,address):        self.name = name        self.age = age        self.sex = sex        self.address =address        print("嘿嘿")    # 行为    def sleep(self):        print(self.name,"在睡觉")    # 析构方法    def __del__(self):        print(self.name,"在内存中消失了..")

父类的格式：	class 父类的类名:		def __init__(self,形参列表)			子类共同的特征(属性)		子类中共同行为子类	class 子类类名(父类类名):		def __init__(self,共性属性列表,个性属性的列表)			# 调用父类的共性属性进行初始化			# 在为个性属性进行赋值		个性方式

//div

/a

a/text()

a/@href

'//div[1]/a/@hrfe' #获取第一个div标签下是a标签hrfe属性

'//div[last()]/a/@hrfe' 

'//div[last()-2]/a/@hrfe' 

//div[postion()<n]

'//div[@class="shu"]/a/@hrfe' '//div[@id="shu"]/a/@hrfe' 

xpath模块 解析网页#模块导入from lxml import etree#首先要初始化网页后才能通过xpath#初始化html = etree.HTML（(req.text) 或 (req.content)传入请求对象）html.xpath(传入选取的节点)/	从根节点选取。//	从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。.	选取当前节点。..	选取当前节点的父节点。@	选取属性。|   或者元素child::book	选取所有属于当前节点的子元素的 book 节点。attribute::lang	选取当前节点的 lang 属性。child::*	选取当前节点的所有子元素。attribute::*	选取当前节点的所有属性。child::text()	选取当前节点的所有文本子节点。child::node()	选取当前节点的所有子节点。descendant::book	选取当前节点的所有 book 后代。ancestor::book	选择当前节点的所有 book 先辈。ancestor-or-self::book	选取当前节点的所有 book 先辈以及当前节点（如果此节点是 book 节点）child::*/child::price	选取当前节点的所有 price 孙节点案列html.xpath(r'//[@id="id选择器名字"]/div/tr/a@herf')#返回的是a标签里的路径 返回是列表案列2html.xpath(r'//[@id="id选择器名字"]/div/tr/a/text()')#返回的是a标签里的文本 返回是列表html.xpath(r'//[@id="id选择器名字"]/div/tr/a/text() | //[@id="id选择器名字"]/div/tr/a/text()') 可以这种表示法

from bs4 import BeautifulSoup #包import requests req = requests.get()req.encoding ="utf-8"# 生成BeautifulSoup对象soup = BeautifulSoup('req.text 或 text.content ','lxml(固定模式)')print(soup.prettify())  # 输出格式化print("hade标签内容",soup.head) # 获取hade标签print(soup.body.a.img)  # 获取到body的第一个a标签print("获取所有的img标签",soup.find_all('img')) # 获取所有的img标签 find_all()print("获取的第一个img的属性",url + soup.img['src']) # 获取src的属性print("a标签name",soup.a.name) # 获取a标签名name   a元素# 修改a标签为b标签tag = soup.a# 修改btag.name = 'b' # 赋值print("a标签修改后的tag内容",tag)# 获取全部属性print("tag对象的全部属性",tag.attrs)# 获取属性的值  classprint("class的值",tag['class'])# 修改class的值tag['class'] = "Logo"# 输出修改后的内容print(tag.attrs)# 新增属性  idtag['id'] = "logo"print(tag.attrs)# 输出标签print("tag标签",tag)# 删除属性del tag['href']print("tag标签",tag)# 针对内容操作# 获取title的内容tag = soup.titleprint(tag)# 获取标签中的字符串print("tag标签中的字符串",tag.string)# 替换标题内容tag.string.replace_with("重庆华信智原")print(tag)# 获取注释的内容# <!-- 学科建设 -->markup = "<b><!-- 学科建设 --></c>" # <b></c>没有任何意义soup_comment = BeautifulSoup(markup,'lxml')# 获取文本comment = soup_comment.b.stringprint(comment)# 获取某个元素的全部节点  titleprint("名为title的全部节点",soup.find_all('title'))# 获取title的文本数据  string get_text()print(soup.title.string) (一)print(soup.title.get_text()) （二）# 查找ul元素标签 参数  属性  class  idtag = soup.find_all('ul',class_='menu') # 按照css类名进行完全匹配print("匹配ulclass名menu节点",tag)# 通过id匹配tag = soup.find_all(id='menu')print("通过id匹配节点",tag)# 通过ul名称下a标签的内容taga = soup.ul.find_all('a')print("ul下所有的a标签",taga)# 输出a标签的所有hreffor tag in  taga:    print(tag.get('href'))# 获取整个页面的url地址 进行下载在本地tagimgs = soup.find_all('img')print(tagimgs)# 循环输出图片的地址for imgsrc in tagimgs:    print(url + imgsrc.get('src'))      #ul的class属性pli 下的li 的标签  tu = soup.select(''ul.pli > li > div > a > img'') #返回为一个可迭代的#获取img里的所有src路径sq = [i["src"] for i in tu] #列表生成式

官方文档:https://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.common.action_chainschromedriver下载：http://chromedriver.storage.googleapis.com/index.htmlchromedriver与chrome的对应关系表：https://www.jb51.net/article/151629.htm    基本使用#安装: pip install selenium#导入模块from selenium import webdriverfrom selenium.webdriver.common.action_chains import ActionChains  # 鼠标操作模块#创建浏览器对象browser = webdriver.Chrome(executable_path='chromedriver.exe'可不用填写)   # 声明一个浏览器对象   指定使用chromedriver.exe路径browser.get("https://www.baidu.com")  # 打开Chrome并导入路径input = browser.find_element_by_id("kw")  # 通过id定位到input框input.send_keys("python")   # 在输入框内输入pythonbrowser.implicitly_wait(2) # 设定等待时间browser.save_screenshot('传入保存的名字')#对当前页面进行截屏#得到需要鼠标移动位置的节点weizhi = find_elements_by_name("q")#把鼠标移上去#perform()立即执行鼠标事件ActionChains('浏览器对象').move_to_element(wenzhi).perform()#鼠标点击事件#鼠标点击长按指定的标签ActionChains('浏览器对象').click_and_hold('q 定位节点 ')for i in range(5)：	#这一步显示为鼠标长按一个节点，并水平方向移动12个像素	ActionChains('浏览器对象').move_to_element(12，x轴，y轴).perform()#释放动作ActionChains('浏览器对象').release() browser.maximize_window() #窗口最大化     browser.minimize_window() #窗口最小化browser.execute_script("window.scrollTo(0,document.body.scrollHeight)") # 将进度条下拉到最底部（第一种）browser.execute_script(scroll(0,屏幕的高度))#（第二种）find_elements_by_id("q").get_attribute("src")  #获取标签里的src 属性#处理弹框页面，accept()确定  dismiss()取消browser.swith_to_alert().accept()#返回上一级页面browser.back()#返回下一级页面browser.forward()find_elements_by_id("q".text #获取文本send_keys()  #输入文字用clear()  #清空文字用click()  #点击按钮用browser.current_url  # 打印url路径browser.get_cookies()  # 打印Cookiesbrowser.page_source    # 打印整个网页源代码browser.close()        # 关闭浏览器                      #无头浏览器,也可称为不可视化  #导入模块 from selenium.webdriver.chrome.options import Options #实力化options = Options()options.add_argument('--headless')options.add_argument('--disable-gpu') #实力化浏览器时传入一个参数  webdriver.Chrome(url,chrome_options=options)                                            #不显示检测弹框#导入模块from selenium.webdriver import ChromeOptionsoption = ChromeOptions()   option.add_experimental_option('excludeSwitches',['enable-automation'])  #实力化浏览器时传入一个参数                     webdriver.Chrome(options=option)                                         #嵌套iframe#如果定位的标签是存在于iframe标签中，则必须通过如下方法进行定位：div=  broeser.switch_to.frame('定位于iframe节点')div.find——element_by_....('需要定位的节点')#获取单节点# 通过属性查找单个节点，当在element后面增添一个“s”时就是查找多个browser.find_elements_by_css_selector(".service-bd li")  # 注意是elements多个s，输出为列表find_elements_by_id("q")find_elements_by_name("q")find_elements_by_css_selector("#q")find_elements_by_xpath('//*[@id="q"]')find_elements_by_link_textfind_elements_by_partial_link_textfind_elements_by_tag_namefind_elements_by_class_name browser.find_element_by_id("id的名字")  # 通过id找     browser.find_element_by_name("name的名字")  # 通过name属性值找 web.find_element_by_class_name() #通过class查找     browser.find_element_by_css_selector(" .classmingzi > 下一级 > ....") # 根据css选择器找#s_position_list > ul > li.con_list_item.first_row.default_list > div.list_item_top > div.position > div.p_top > a     # 根据css选择器找 注意 > 两端要有一个空格  browser.find_element_by_xpath('//*[@id="q"]') # 根据xpath找#//*[@id="s_position_list"]/ul/li[1]/div[1]/div[1]/div[1]/a 根据xpath找#关闭浏览器 browser.close()# 其他获取单个节点方法find_element_by_link_textfind_element_by_partial_link_textfind_element_by_tag_namefind_element_by_class_name#案列获取输入框并输入关键字，点击搜索按钮import timefrom selenium import webdriverbrowser = webdriver.Chrome()browser.get("https://www.taobao.com")input = browser.find_element_by_id("q")input.send_keys("iPhone")   #在搜索框输入iPhoneinput.clear()  # 清空搜索框的文字time.sleep(2)input.send_keys("iPad")  # 在搜索框输入iPadbutton = browser.find_element_by_class_name("btn-search")  # 获取点击按钮button.click()  # 点击搜索#当需要进入二级页面时，所用方法#获取当前所有句柄（窗口） url = browser.window_handles #这回把所有路径都存在一个列表里，而且是  一级网页存放在前面，二级页面放在后面                #切换到二级网页里面，切换到新的页面  browser.switch_to_window(url[1])                   #案列from selenium import webdriverfrom selenium.webdriver import ActionChains   # 引入动作链browser = webdriver.Chrome()url = "https://www.runoob.com/try/try.php?filename=jqueryui-api-droppable"browser.get(url)browser.switch_to.frame("iframeResult")  # 切换到元素所在的frame[框架]"""可以传入id、name、index以及selenium的WebElement对象,index从0开始"""source = browser.find_element_by_css_selector("#draggable") # 找到被拖拽对象target = browser.find_element_by_css_selector("#droppable") # 找到目标actions = ActionChains(browser)       # 声明actions对象actions.drag_and_drop(source,target)  # 拖拽元素的起点和终点actions.perform()  # 执行动作action.click_and_hold()    # 点击且长按，更多方法查看官方文档#案列，下拉滚动条到最底部执 selenium import webdriverbrowser = webdriver.Chrome()url = "https://www.zhihu.com/explore"browser.get(url)browser.execute_script("window.scrollTo(0,document.body.scrollHeight)") # 将进度条下拉到最底部（第一种）browser.execute_script(scroll(0,屏幕的高度))#（第二种）browser.execute_script("alert('hello word')")  # 弹出alert提示窗#案列from selenium import webdriverbrowser = webdriver.Chrome()url = "https://www.zhihu.com/explore"browser.get(url)"""WebElement常用属性:    get_attribute 获取属性值    text          获取文本值    id            获取节点id    location      获取节点在页面中的相对位置    tag_name      获取标签名称    size          获取节点大小(宽和高)"""# 获取属性logo = browser.find_element_by_id("zh-top-link-logo")  # 获取logo节点print(logo)  # 返回值为WebElement对象logo_class = logo.get_attribute("class")   # 获取zh-top-link-logo节点的class属性值print(logo_class)# 获取文本值text_Ele = browser.find_element_by_css_selector(".question_link") # 通过css选择器获取文本内容所在的标签text = text_Ele.text  # 取出标签内的文本内容print(text)# 获取ID 位置 标签名和大小test = browser.find_element_by_class_name("zu-top-add-question")print(test.id)       # 0bfe7ae6-ebd9-499a-8f4e-35ae34776687print(test.location) # {'x': 759, 'y': 7}print(test.tag_name) # buttonprint(test.size)     # {'height': 32, 'width': 66}#案列获取子页面from selenium import webdriverbrowser = webdriver.Chrome()url = "https://www.runoob.com/try/try.php?filename=jqueryui-api-droppable"browser.get(url)"""网页中有一种节点叫做iframe，也就是子Frame，相当于页面的子页面，他的结构和外部网页的结构完全一致。selenium打开页面后,他默认是在父级Frame里面操作,而此时如果页面中还有子Frame，他是不能获取到子Frame里面的节点的，这时候就需要使用switch_to.frame()方法来切换Frame。"""browser.switch_to.frame("iframeResult")logo = browser.find_elements_by_class_name("logo")print(logo)# [<selenium.webdriver.remote.webelement.WebElement (session="1ccb11403013c749ce9fceda50a00975", element="88e5924e-d655-44c3-a905-8af1947b9d86")>]# 报错信息""" raise exception_class(message, screen, stacktrace)selenium.common.exceptions.NoSuchElementException: Message: no such element: Unable to locate element: {"method":"css selector","selector":".aaa"}  (Session info: chrome=75.0.3770.142)#如果selenium没有在DOM中找到节点，将继续等待，超出设定事件后，则抛出找不到节点的异常。当查找节点而节点并没有立即出现的时候，隐式等待将等待一段时间在查找DOM，默认时间是0"""--------------------------显式等待------------------------# 显示等待from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWaitfrom selenium.webdriver.support import expected_conditions as ECbrowser = webdriver.Chrome()browser.get("https://www.taobao.com/")wait = WebDriverWait(browser,2)input = wait.until(EC.presence_of_element_located((By.ID,"q")))button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR,".btn-search")))print(input,button)# 等待条件# EC.presence_of_element_located   节点出现# EC.element_to_be_clickable       可点击# 更多等待条件查看260页"""引入WebDriverWait对象指定最长等待时间,调用它的until方法,传入要等待的条件expected_conditions,比如这里传入例如presence_of_element_located这个条件,代表节点出现的意思,其参数是节点的定位元组,也就是ID为q的搜索框。这样可以做到的效果就是,在10秒内如果ID为q的节点(即搜索框)成功加载出来,就返回该节点,如果10秒还没有加载出来,就抛出异常。""""""异常:TimeoutException""""""指定要查找的节点,然后指定一个最长等待时间,如果在规定时间内加载出来了这个节点,就返回查找的节点,如果到了规定时间依然没有加载出该节点,则抛出【超时】异常"""#案例import timefrom selenium import webdriverbrowser = webdriver.Chrome()browser.get("https://www.baidu.com")browser.get("https://www.taobao.com")browser.get("https://www.jd.com")browser.back()  # 后退time.sleep(2)browser.forward() # 前进browser.close()  # 关闭浏览器# 连续访问三个页面from selenium import webdriverbrowser = webdriver.Chrome()browser.get("https://www.zhihu.com/explore")cookies = browser.get_cookies()  # 获取cookiesprint(cookies)browser.add_cookie({"name":"name","domain":"www.zhihu.com","vlue":"germey"})browser.delete_all_cookies()  # 删除所有cookies#案例import timefrom selenium import webdriverbrowser = webdriver.Chrome()browser.get("https://www.baidu.com")browser.execute_script("window.open()")print(browser.window_handles)# ['CDwindow-7106D94FF002752ADF198B986343E31D', 'CDwindow-B669BA9559DBB78D8D6EC9C5AA699C40']browser.switch_to.window(browser.window_handles[1])browser.get("https://www.taobao.com")time.sleep(1)browser.switch_to.window(browser.window_handles[0])browser.get("https://jd.com")"""1、打开百度网页2、新开一个选项卡,调用execute_script()方法传入JavaScript语法window.open()3、切换到新打开的选项卡,调用window_handles属性获取当前开启的所有选项卡,返回的是选项卡的代号列表,要想切换选项卡只需要调用switch_to.window()方法,这里我们将第二个选项卡代号传入,即跳转到第二个选项卡,在第二个选项卡里打开新页面https://www.taobao.com,然后切换回第一个选项卡打开jd页面"""复制代码异常处理#复制代码from selenium import webdriverbrowser = webdriver.Chrome()browser.get("https://www.baidu.com")try:    browser.find_element_by_id("hello")except Exception as e:    print(e)   # 打印错误信息 Exception捕获所有错误信息赋给efinally:    browser.close()"""在使用selenium的过程中,难免遇到一些异常,例如超时、节点未找到错误，一旦出现此类错误,程序便不会在继续运行了,这里我们使用try except语句来捕获各种异常"""#案列import timefrom selenium import webdriverfrom selenium.webdriver import ChromeOptionsoption = ChromeOptions()browser = webdriver.Chrome(executable_path='D:\chromedriver.exe',options=option)   # 声明一个浏览器对象   option.add_experimental_option('excludeSwitches', ['enable-automation'])browser.get("https://www.baidu.com")  # 打开Chromeinput = browser.find_element_by_id("kw")  # 通过id定位到input框input.send_keys("爱奇艺")   # 在输入框内输入pythonbrowser.find_element_by_id("su").click()time.sleep(3)browser.find_element_by_xpath('//*[@id="1"]/h3').click()time.sleep(10)browser.switch_to_window(browser.window_handles[1])  # 切换到新打开的选项卡定位爱奇艺的搜索框search = browser.find_element_by_xpath("//input[@class='search-box-input']").send_keys("青春有你")browser.close()               # 关闭浏览器#案列from selenium import webdriverfrom selenium.webdriver.chrome.options import Options# 创建chrome参数对象opt = Options()# 把chrome设置成无界面模式，不论windows还是linux都可以，自动适配对应参数opt.add_argument('--headless')# 创建chrome无界面对象driver = webdriver.Chrome(options=opt)driver.get("http://www.baidu.com")print(driver.page_source)

class （BossSpiderlscrapy.Spider) :    name = ' boss'    #allowed_ domains = [ " www. xxx. com ' ]    start urls = ['https:/ /www. zhipin. com/ job_ detail/ ?que ry=python&c ity=101010100&indus                                 def parse(self, response) :    li_ list = response . xpath( ' //* [@id="main"]/div/div[3]/ul/li' )    for li in li_ list:    item = BossproItem( )    #一级页面需要的内容    item['job_ name'] = li. xpath( './/div [@class="info-prima ry"]/h3/a/div[1]/text()') .extract()     #item['job_ name' ] = job_ name    # print( job_ name )      #二级页面路径                 detail_ url = ' https:/ /www. zhipin. com '+li. xpath( ' .//div [@class=" info-prima ry#对详情页发请求		获取详情页的页面源码数据    #手动请求的发送    #进请求传参i meta=ften 可以将meta字典传递给请求对应的回调函数    yield scrapy.Reauest(detail_url,callback = self.parse_detail,meta= {'item' : item})                                                               #回调函数接受itemdef parse_detail(self, response) :    item = response.meta['item']     #二级页面所需要的东西                                                          item['job_ desc'] ="".join(response.xpath('//[@id="main"]/div[3]/div/div[2]/div[2]/div[1]/div/)).extract()     #job_ desc =''.join(job_ desc)	# print(job_ desc)	#item['job_ desc'] = job_ desc     yield item	  

class QiubaiproPipe Line (object):    fp = None    并重写父类的一个方法:该方法只在开始爬虫的时候被调用一次    defm apen spider(selfaspiderli    #print( '开始爬虫....... )    self.fp = open(' ./giubai. txt'。'w' zencoding='utf-8' )    #专门用来处理item类型对象    #该方法可以接收爬虫文件提交过来的item对象进该方法没接收到-个item就会被调用一次    def process_ item(self, item, spider) :    authar = item [ ' author' ]    content= item[ ' content']    self. fp. write( author+' : '+content+'\n' )    return item    def close_ spider(self,spider) :        #关闭文件       self.fp.close()#另一种import pandas as pd #模块class DiannaoPipeline:    def process_item(self, item, spider):        data = pd.DataFrame(dict(item))        data.to_csv('电脑.csv',mode='a',index=False,header=False,sep=',')

# Define here the models for your scraped items## See documentation in:# https://docs.scrapy.org/en/latest/topics/items.htmlimport scrapyclass DemoItem(scrapy.Item):    # define the fields for your item here like:    # name = scrapy.Field()    # 标题    title = scrapy.Field()    # 时间    date = scrapy.Field()    # 作者    author = scrapy.Field()    # 浏览次数    view_count = scrapy.Field()

user_agent_list = [    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.163 Safari/535.1",    "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:6.0) Gecko/20100101 Firefox/6.0",    "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50",    "Opera/9.80 (Windows NT 6.1; U; zh-cn) Presto/2.9.168 Version/11.50",    "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.41 Safari/535.1 QQBrowser/6.9.11079.201",    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; InfoPath.3; .NET4.0C; .NET4.0E)"]

{'ip_port': '111.8.60.9:8123', 'user_passwd': 'user1:pass1'},{'ip_port': '101.71.27.120:80', 'user_passwd': 'user2   :pass2'},{'ip_port': '122.96.59.104:80', 'user_passwd': 'user3:pass3'},{'ip_port': '122.224.249.122:8088', 'user_passwd': 'user4:pass4'}

# 导入库import pytesseractfrom PIL import Imageimage = Image.open('code.jpg')# res = pytesseract.image_to_string(image)# print(res)# 对图片进行灰度处理image = image.convert('L')# 加载图片data = image.load()w,h = image.size # ndarryfor i in range(w):    for j in range(h):        if data[i,j] > 40:            data[i,j] = 255        else:            data[i,j] = 0image.show()res = pytesseract.image_to_string(image)print(res)

# 目标地址：https://fanyi.youdao.com/# https://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule# e：输入翻译内容# ts:当前时间戳字符串# bv：将user-agent经过md5加密后的字符串# salt：时间戳字符串拼接随机数# sign：将"fanyideskweb" + e + i+ "Tbh5E8=q6U3EXe+&L[4c@"import randomimport timeimport hashlibimport requestsclass Youdao(object):    def __init__(self, word):        # 初始化        self.url = "https://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule"        # 请求头信息        self.headers = {            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36",            "Cookie": "OUTFOX_SEARCH_USER_ID=-1132106333@10.169.0.83; OUTFOX_SEARCH_USER_ID_NCOO=1946771786.421294; JSESSIONID=aaacAtoZRHi0Ud08zLvNx; ___rl__test__cookies=1622786844607",            "Referer": "https://fanyi.youdao.com /"        }        # 翻译内容        self.word = word        # 定义字典存储表单数据        self.post_boyd = {}    def genrator_post(self):        # 得到ts 拿到时间戳        ts = str(int(time.time()*1000))        # 得到salt 时间戳 + 一个随机的值        salt = ts + str(random.randint(0,10))        # 得到sign  字符串 + 陪翻译的值 + 盐值        sign_str = "fanyideskweb" + self.word + salt + 					                      "Tbh5E8=q6U3EXe+&L[4c@"        # 将sign_str md5进行加密        md5 = hashlib.md5()        md5.update(sign_str.encode())        sign = md5.hexdigest()        # 生成数据信息        self.post_boyd = {            "i": self.word,            "from": "AUTO",            "to": "AUTO",            "smartresult": "dict",            "client": "fanyideskweb",            "salt": salt,            "sign": sign,            "lts": ts,            "bv": "960780974768cef6d5005081d3d340f0",            "doctype": "json",            "version": "2.1",            "keyfrom": "fanyi.web",            "action": "FY_BY_REALTlME"        }    # 请求方法    def send_request(self):        # 发送请求        response =requests.post(self.url,headers=self.headers,data=self.post_boyd)        return response.json()    # 解析方法    def parser_response(self,ret_dict):        ret  = ret_dict["translateResult"][0][0]["tgt"]        print("翻译的文本:{} 翻译后的结果:{}".format(self.word,ret))    # 操作方法    def run(self):        self.genrator_post()        ret_dict = self.send_request()        self.parser_response(ret_dict)if __name__ == '__main__':    word = input("请输入要翻译的文本：")    yd = Youdao(word)    yd.run()

set key value: #设置key-valueget key: #获取key所对应的valuegetrange key start end: #字符串的提取，字符串从0开始，包含start和endgetset key value :#设置key的值，返回的是旧值，新值会设置成功setex key seconds value: #设置key的值 过期时间为seconds  如果存在  则替换之，时间为s为单位setnx key value:#该key不存在的时候才设置，存在不设置strlen key :#得到该key对应的值的长度mset key value[key value]:#同时设置多个键值对mget :#一次获取多个键的值incr key：#为key对应的值增加1 如果key不存在那么先创建key，值为0，然后再设置为1decr key:#为key对应的值减1incrby key number ：#在指定的key对应的值加number

import redisres = redis.StrictRedis('localhost', 6379)# sq = res.hkeys('books')## for i in sq:#     print(i.decode('utf-8'))# print(res.hlen('books'))# sq = (res.hmget('books','僵尸管家2006','劫匪与僵尸'))# for i in sq:#     print(i.decode('utf-8'))# sq = res.hgetall('books')# # print((sq.d).decode('utf-8'))# print(res.hset('books','劫匪与僵尸').decode('utf-8'))# sq = res.hvals('books')# for i in sq:#     print(i.decode('utf-8'))# print(res.llen('book'))# print(res.lindex('book',5).decode('utf-8'))# sq = res.lrange('book',3,10)# for i in sq:#     print(i.decode('utf-8'))#存：    red = redis.StrictRedis('localhost', 6379)    #哈希    red.hset('安康', str(item['name']), str(item))    #列表    red.lpush('安康',str(item))

增：1、hmset key（名字） field1（键） value1（值） [field2 value2 ]  #同时将多个 field-value (域-值)对设置到哈希表 key 中。2、hsetnx key field value  #只有在字段 field 不存在时，设置哈希表字段的值。3、hincrby key field increment #为哈希表 key 中的指定字段的整数值加上增量 increment删：1、hdel key field1 [field2] #删除一个或多个哈希表字段查：1、hexists key field #查看哈希表 key 中，指定的字段是否存在 存在返回TRUE 否则返回false。2、hget key field  #获取存储在哈希表中指定字段的值。3、hgetall key #获取在哈希表中指定key的所有字段和值，返回值为字典4、hkeys key  #获取所有哈希表中的 key字段， 所有键的值5、hlen key  #获取哈希表中字段的数量 键的数量6、hmget key field1 [field2]  #获取多个给定字段的值7、hset key field value   #将哈希表key中的字段field的值设为value 。8、hvals key   #获取哈希表中所有值。 返回值为列表9、hscan key cursor [MATCH pattern] [COUNT count] #迭代哈希表中的键值对。

增：1、lpush key value1 [value2]  #将一个或多个值插入到列表头部2、rpush key value1 [value2]  #在列表中添加一个或多个值3、rpushx key value  #为已存在的列表添加值4、lpushx key value  #将一个值插入到已存在的列表头部5、linsert key before|after pivot value  #在列表的元素前或者后插入元素删：1、blpop key1 [key2 ] timeout  #移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。2、brpop key1 [key2 ] timeout  #移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。3、rpop key  #移除列表的最后一个元素，返回值为移除的元素。4、rpoplpush source destination  #移除列表的最后一个元素，并将该元素添加到另一个列表并返回5、lpop key  #移出并获取列表的第一个元素6、lrem key count value  #移除列表元素7、ltrim key start stop  #对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。查：1、lindex key index  #通过索引获取列表中的元素2、llen key  #获取列表长度3、lrange key start stop  #获取列表指定范围内的元素4、lset key index value  #通过索引设置列表元素的值5、brpoplpush source destination timeout  #从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

sadd key member1 [member2]  #向集合添加一个或多个成员scard key  #获取集合的成员数sdiff key1 [key2]  #返回第一个集合与其他集合之间的差异。sdiffstore destination key1 [key2]  #返回给定所有集合的差集并存储在 destination 中sinter key1 [key2]  #返回给定所有集合的交集sinterstore destination key1 [key2]  #返回给定所有集合的交集并存储在 destination 中 sismember key member  #判断 member 元素是否是集合 key 的成员smembers key  #返回集合中的所有成员smove source destination member  #将 member 元素从 source 集合移动到 destination 集合spop key  # 移除并返回集合中的一个随机元素srandmember key [count]  #返回集合中一个或多个随机数srem key member1 [member2]   #移除集合中一个或多个成员sunion key1 [key2]   #返回所有给定集合的并集sunionstore destination key1 [key2]  #所有给定集合的并集存储在 destination 集合中sscan key cursor [MATCH pattern] [COUNT count]  #迭代集合中的元素

zadd key score1 member1 [score2 member2]  
#向有序集合添加一个或多个成员，或者更新已存在成员的分数zcard key  #获取有序集合的成员数zcount key min max  #计算在有序集合中指定区间分数的成员数zincrby  key increment member  #有序集合中对指定成员的分数加上增量 incrementzinterstore destination numkeys key [key ...]  #计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 destination 中zlexcount key min max  #在有序集合中计算指定字典区间内成员数量zrange key start stop [WITHSCORES]  #通过索引区间返回有序集合指定区间内的成员zrangebylex key min max [LIMIT offset count]  #通过字典区间返回有序集合的成员zrangebyscore key min max [WITHSCORES] [LIMIT] #通过分数返回有序集合指定区间内的成员zrank key member  #返回有序集合中指定成员的索引zrem key member [member ...]  #移除有序集合中的一个或多个成员zremrangebylex key min max  #移除有序集合中给定的字典区间的所有成员zremrangebyrank key start stop  #移除有序集合中给定的排名区间的所有成员zremrangebyscore key min max  #移除有序集合中给定的分数区间的所有成员zrevrange key start stop [WITHSCORES]  #返回有序集中指定区间内的成员，通过索引，分数从高到低zrevrangebyscore key max min [WITHSCORES]  #返回有序集中指定分数区间内的成员，分数从高到低排序zrevrank key member  #返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序zscore key member  #返回有序集中，成员的分数值zunionstore destination numkeys key [key ...]  #计算给定的一个或多个有序集的并集，并存储在新的 key 中zscan key cursor [MATCH pattern] [COUNT count]  #迭代有序集合中的元素（包括元素成员和元素分值）