[Toc]

Python学习

input输入

==python对缩进有着严格的要求，这里的print和input都是顶格写==

1
2
3
4
5
6
7
8
9
10
11
12
#input()内的作用和print（）一样，都是打印，但是如果这样操作，输入不会换行
name=input("What is your name ?")
num=input("What is your number ?")
print(type(num))
#input输入数据都是字符串类型
int(num)
print(num)

#练习 欢迎登录小程序
user_name=input()
user_type=input()
print("您好：%s,您是尊贵的：%s用户，欢迎您的光临。"%(user_name,user_type))
1
2
3
4
5
6
7
What is your name ?123	#他会让你输入一些数据，123是我输入的数据
What is your number ?123
<class 'str'>
123
123
123
您好：123,您是尊贵的：123用户，欢迎您的光临。

算术运算符

1
2
3
4
5
6
7
print("1+1=",1+1)
print("1-1=",1-1)
print("1*1=",1*1)
print("8/3=",8/3)
print("7//2=",7//2)
print("5%3=",5%3)
print("2**3=",2**3)
1
2
3
4
5
6
7
1+1= 2
1-1= 0
1*1= 1
8/3= 2.6666666666666665
7//2= 3
5%3= 2
2**2= 8

精确度和字符串拼接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
name="YYSSH"
num=1
print("My name is",name,"My number is",num)

#   %s表示占位符，后面%括号里面表示替代前面%s
message="My name is %s,My number is %s"%(name,num)

#    %s表示str占位符，%d表示int的占位符，%f表示float的占位符


num3=11
num4=15.557879798
#     首先是%d表示int占位符，然后%后的辅助符号第一个表示宽度
print("宽度限制5 结果是%5d"%num3)

#     若限制宽度小于数字本身宽度，则不生效
print("宽度限制1 结果是%1d"%num3)

################若控制精度则数值会四舍五入###################

#      首先是%f表示float占位符，%后的第一位表示宽度，第二位表示保留小数
print("宽度限制7，保留两位小数 结果是%7.2f"%num4)

#      若%后没有第一位只有小数点后位，则表示宽度没有限制
print("没有宽度限制，保留两位小数 结果是%.2f"%num4)

##########快速格式化########
Name="YYSSH"
set_num=1.01123
set_num2=12312

#进行所有括号内部格式化(将变量进行数据输出)，但是不能控制精度
print(f"My name is {Name},My num1 is{set_num},My num2 is{set_num2}")
nb=f"My name is {Name},My num1 is{set_num},My num2 is{set_num2}"
print(nb)
1
2
3
4
5
6
7
My name is YYSSH My number is 1
宽度限制5 结果是   11
宽度限制1 结果是11
宽度限制7，保留两位小数 结果是  15.56
没有宽度限制，保留两位小数 结果是15.56
My name is YYSSH,My num1 is1.01123,My num2 is12312
My name is YYSSH,My num1 is1.01123,My num2 is12312

while循环\for循环

1
2
3
4
5
6
7
8
9
num = 1
sum = 0
while num <=100 :
    sum += num
    num += 1

print(sum)

while Ture:	#死循环
1
5050
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
name="itheima is a brand of itcast"
count=0
for x in name :
    if x=='a' :
        count+=1

print(count)

count=0
num =3
for x in range(1,num+1):	#没有取num+1
    print(x)
    if x%2==0 :
        count+=1

print(count)
1
2
3
4
5
4
1
2
3
1

函数

==def定义带有名称的函数==

1
2
3
4
5
def 函数名：
	直接用
    返回值(可以有多个) e.g. retrun 1,"yanyuan",{123}
    
    x,y,z=函数名()

==lambda定义匿名函数==

只能被调用一次（因为没有名字），但可以多次写

1
lambda x,y:x+y	#只能有一行函数体，冒号后面的即是return返回值也是函数体

传参

1
2
3
def user_info(name,age,gender):
	print(f"{name},{age},{gender}")
user_info("yanyuan",age=20,gender="男")	#乱序也可以，但是要指定键
1
2
3
def user_info(name,age,gender="男"):	#只能在后面设置默认值，也就是默认值后面不允许不是默认值的
	print(f"{name},{age},{gender}")
user_info("yanyuan",age=20)	#若不传值，则为设定的默认值男
1
2
3
4
5
6
7
def user_info(*args):	#规定叫args，不用也可以*a,*b
	print(f"{type(args)}")	#传进来之后都变成了元组
user_info("yanyuan",age=20,gender="男")

def user_info(**kwargs):	#规定叫kwargs，不用也可以*a,*b
	print(f"{type(kwargs)}")	#传进来之后都变成了字典
user_info(name="yanyuan",age=20,gender="男")	#所以只能键值对传参

序列(列表、元组、字符串)

列表

增删改查
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
##增加
#######在指定下标前面插入一个元素###########

mylist=[1,2,3,4,5]
mylist.insert(1,"y")
print(mylist)

#######在列表末尾插入一个元素###########

mylist=[0,1,2,3,4,5]
mylist.append(9)
print(mylist)

#######在列表末尾插入一个列表###########

mylist=[0,2,4,5,6,8]
mylist2=[11111,222222,33333]
mylist.extend(mylist2)
print(mylist)
1
2
3
[1, 'y', 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 9]
[0, 2, 4, 5, 6, 8, 11111, 222222, 33333]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
##删除
#######在指定下标删除一个元素###########

##Example(1)
mylist=[1,2,3,4,56,6,7]
del mylist[2]
print(mylist)

##Example(2)
mylist=[1,2,3,4,56,67,7,7,8]
pop=mylist.pop(4)
print(mylist)
print(pop)

##Example(3)  #只会删除第一个匹配项目
mylist=[1,2,3,4,56,67,7,7,8]
mylist.remove(7)
print(mylist)
1
2
3
4
[1, 2, 4, 56, 6, 7]
[1, 2, 3, 4, 67, 7, 7, 8]
56
[1, 2, 3, 4, 56, 67, 7, 8]
1
2
3
4
5
6
##修改
#######在指定位置修改一个元素###########

mylist=[1,2,3,4,56,7,8,1]
mylist[5]=999999
print(mylist)
1
[1, 2, 3, 4, 56, 999999, 8, 1]
1
2
3
4
5
6
##查询
#######查找一个元素,并返回他的下标###########

mylist=[1,23,4,54,645,7,54,1]
index=mylist.index(645)
print(index)
1
4
1
2
3
4
5
6
##统计
#######统计一个元素在列表中出现的次数###########

mylist=[1,23,4,54,645,7,54,1]
count=mylist.count(1)
print(count)
1
2
1
2
3
4
5
6
##清空
#######清空列表###########

mylist=[213125435423,541542354235]
mylist.clear()
print(mylist)
1
[]
1
2
3
4
5
6
##求列表大小
#######求列表大小(返回数组有多少个元素)###########

mylist=[123123455435,456453,67345,67,546,543,6543]
len=len(mylist)
print(len)
1
7

字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
my_str=("YYSSH")
y=my_str[0]
h=my_str[-1]
print(f"{y},{h}")

######### 查找
index=my_str.index("S")
print(f"{index}")

############ 替换
replace=my_str.replace("YY","yy")
print(f"{replace}")

############ 用split切割字符串，并且用一个列表进行存储
split=my_str.split()
print(f"{split},{type(split)}")

#############  strip 若括号里面不添加内容，则默认去除行首和行尾的空格和换行符
my_str=("   YYSSH    ")
strip=my_str.strip()
print(f"{strip}")

my_str=("78 YYSSH 87")
strip=my_str.strip("78")
print(f"{strip}")

#字符串也有count和len函数
1
2
3
4
5
6
Y,H
2
yySSH
['YYSSH'],<class 'list'>
YYSSH
 YYSSH

元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
###########定义元组  :元组不可以被修改 tuple
from itertools import count

t =(1,1,1,1,1,1,23,577,"jianjian")
print(f"{t}")

################ 跟list一样 都可以使用 index count len
index = t.index(577)
print(f"{index}")
tc= t.count(1)
print(f"{tc}")
len =len(t)
print(f"{len}")

############# 元组元素不可以被修改（自我猜测应该是记录了元素的首地址），但是元素的元素可以被修改 e.g.（元组里面有个列表）

t2=(1,2,3,4,5,6,[1,2,3])
t2[6][0]=0
print(f"{t2}")
1
2
3
4
5
(1, 1, 1, 1, 1, 1, 23, 577, 'jianjian')
7
6
9
(1, 2, 3, 4, 5, 6, [0, 2, 3])

==序列 连续、有序、支持下标索引 e.g.(列表、元组、字符串)==

1
2
3
4
5
6
7
8
9
10
11
12
my_list=[1,2,3,4,5,6,7]
result1=my_list[::]      ######### 三个空格默认分别为 行首、行尾、步长为1
print(f"{result1}")

my_tuple=("YYSSH","yyssh","YYssh","yuya","ioio")
result2=my_tuple[1:4:1]    #####如果不使用默认的空格表示，则不会表示步长最后一个数
result3=my_tuple[::-1]     #####若表明步长为-1，则默认从行尾到行首
print(f"{result2},{result3}")

my_str=("YySsH")
result4=my_str[::2]
print(f"{result4}")
1
2
3
[1, 2, 3, 4, 5, 6, 7]
('yyssh', 'YYssh', 'yuya'),('ioio', 'yuya', 'YYssh', 'yyssh', 'YYSSH')
YSH
1
2
3
4
5
6
7
8
9
10
#练习案例：序列的切片实践
my_str1=("学python,来黑马程序员,月薪过万")
my_str=my_str1[::-1]
print(f"{type(my_str)}")
split=my_str.split(",")
print(f"{split}")
split2=split[1]
strip=split2.strip("来")
print(f"{strip}")
print(f"{strip[::-1]}")
1
2
3
4
<class 'str'>
['万过薪月', '员序程马黑来', 'nohtyp学']
员序程马黑
黑马程序员

集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
###############  集合 无序、所以不支持下标索引和while循环遍历 去重、集合里面不允许有重复的数据存在

## 定义一个空集合
SET=set()
print(f"{SET}")

my_set={1,3,34,5,5,6,7}
print(f"{my_set}")

## 添加一个集合元素
my_set.add("yan")
print(f"{my_set}")

## 移除一个集合元素
my_set.remove("yan")
print(f"{my_set}")

## 取出第一个元素
pop=my_set.pop()
print(f"{my_set}")

## 清空集合
my_set.clear()
print(f"{my_set}")

## 取集合1相比集合2的差集，集合1、2都不变，生成一个新的集合
my_set={1,2,3,4}
my_set2={2,3,4,5}
different=my_set.difference(my_set2)
print(f"{different},{my_set},{my_set2}")

## 去除集合1与集合2相同的部分，保留不同的部分
my_set.difference_update(my_set2)
print(f"{my_set},{my_set2}")

## 合并两个集合
my_set3=my_set.union(my_set2)
print(f"{my_set3},{my_set},{my_set2}")

## 集合也有len函数
1
2
3
4
5
6
7
8
9
set()
{1, 34, 3, 5, 6, 7}
{1, 34, 3, 5, 6, 7, 'yan'}
{1, 34, 3, 5, 6, 7}
{34, 3, 5, 6, 7}
set()
{1},{1, 2, 3, 4},{2, 3, 4, 5}
{1},{2, 3, 4, 5}
{1, 2, 3, 4, 5},{1},{2, 3, 4, 5}

字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 定义字典
# {key:value,key:value,.....,key:value}

# 定义字典变量
# my_dict={key:value,key:value}

# 定义空字典
# my_dict={}
# my_dict=dict()

# 定义重复key值的话，新的key值会把老的key值给覆盖，
# 嵌套字典的话key值不可以为字典，但是value可以为字典

# 新增元素
# my_dict["新增的元素"]=你要赋的value值

# 删除元素
# my_dict.pop("删除的元素")

# 清空元素
# my_dict.clear()

# 获取全部的key
my_dict={1:1,23:2,4:2,4:2}
keys=my_dict.keys()

# 遍历字典
for key in keys:
    print(f"{key}")
    print(f"{my_dict[key]}")
for key in my_dict:
    print(f"{key}")
    print(f"{my_dict[key]}")

容器的不同

==都支持len\max\min\sorted(序列,[reverse=True])==

==使用sorted函数之后容器会变成列表==

==字典转序列除了字符串，其他都会丢失值==

image-20241113202258253

字符串的比较

1
通过ascii码表一位一位比较，只要前面有一位比后面大，整体就大

文件读取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
open(name,mode,encoding)
#name是要打开文件名（可以包含文件所在的具体路径）
#mode设置文件打开的模式（访问模式）：只读、写入、追加等
#encoding编码格式（大多用UTF-8）

with open(name,mode,encoding) as f:	#会自动帮我们关闭文件

f=open(python.md,'r',encoding=UTF-8)
#r:read读取文件，文件指针放在文件开头
#w:write写入文件，默认删除原本文件内容，没有文件则新建文件
#a:add追加文件内容，没有文件新建文件
f.read(读取文件字节数)	#默认不写则为num，即是所有字节
f.read(10)	#会从本次代码中上一次read读取末尾进行读取，也就是文件读取指针发生了偏移

#在本次代码中文件读取指针对整个文件有影响，也就是不论函数，指针已经发生了偏移

f.readlines()	#读取文件一行内容，并以列表的模式返回，
f.close()

循环读取文件数据

1
2
3
for line in open("python.txt","r"):
    print(line)
#line是临时数据，记录文件一行数据，line的类型是字符串

文件写入

1
2
3
4
f=open(python.md,'w',encoding=UTF-8)
f.write(111)	#这行代码执行完之后还没有把内容写入硬盘文件中，而是写入到了内存中，防止重复调用硬盘
f.flush()	#把内容写入硬盘中
f.close()	#这个函数自带了flush功能

异常

1
2
3
4
5
6
7
8
9
10
11
12
try:
	可能发生错误的代码
	f=open("NULL.txt","r",encoding="UTF-8")	//因为没有这个文件所以无法读取发生报错
except：
	发生错误之后的处理
	f=open("NULL.txt","w",encoding="UTF-8")	//所以改成写入文件即创建这个文件
except (NameError,ZeroDivisionError) as e(用e这个变量接收):	//捕获指定的异常、
	print(e)	//打印这个异常的具体信息
else:	//如果没有异常
finally:	//最终执行代码，不论上述代码执行成不成功

except Exception as e:	//等于except接收所有异常

异常可以传递

Python模块

1
2
3
4
5
6
7
8
9
10
11
[]:表示可选
[from 模块名] import [模块|类|变量|函数|*][as 别名]

如果调用模块的函数名一样的话，会使用后面那个函数

不进行调用模块的测试代码
if __name__='__main__' :
	测试代码
	
from 模块名 import *	//可以手动导入没有被all的函数
	如果模块里面定义了__all__==['执行函数']，则只能引入执行函数	//因为*===__all__

pip国内网站源安装包

1
pip intall -i https://pypi.tuna.tsinghua.edu.cn/simple 安装包名

python服务请求

requests.post/requests.get
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
requests.post(url, data=None, json=None, headers=None, cookies=None, files=None, auth=None, timeout=None, allow_redirects=True, proxies=None, stream=None, verify=None, cert=None, hooks=None)

data: (可选)
发送到服务器的表单数据。可以是字典、字节串、文件对象，或者一个文件描述符。
示例：
data = {'key': 'value'}
response = requests.post(url, data=data)

json: (可选)
这是一个将数据以 JSON 格式发送的快捷方式。如果提供了这个参数，requests 会自动将数据编码为 JSON 格式，并设置请求头 Content-Type 为 application/json。
示例：
json_data = {'name': 'Alice', 'age': 25}
response = requests.post(url, json=json_data)

headers: (可选)
字典类型的 HTTP 请求头。你可以在请求中添加自定义的 HTTP 头，例如设置 Content-Type，Authorization 等。
示例：
headers = {'User-Agent': 'my-app'}
response = requests.post(url, headers=headers)

cookies: (可选)
一个字典，包含要随请求发送的 Cookie 数据。可以指定浏览器会话的 Cookie 或者其他类型的 Cookie。
示例：
cookies = {'session_id': 'abc123'}
response = requests.post(url, cookies=cookies)

files: (可选)
用于上传文件。可以使用字典形式，键是表单字段名，值是文件对象（使用 open() 打开的文件）。
示例：
files = {'file': open('report.pdf', 'rb')}
response = requests.post(url, files=files)

auth: (可选)
用于 HTTP 基本认证的元组（username, password）。如果服务器要求身份验证，这个参数会帮助自动处理认证。
示例：
auth = ('username', 'password')
response = requests.post(url, auth=auth)

timeout: (可选)
请求的超时时间（单位是秒）。这个参数定义了请求等待服务器响应的最长时间。
示例：
response = requests.post(url, timeout=5)  # 5秒超时

allow_redirects: (可选)
默认为 True。如果设置为 False，请求将不会自动跟随 HTTP 重定向（3xx 状态码）。
示例：
response = requests.post(url, allow_redirects=False)

proxies: (可选)
用于指定代理服务器的字典。
proxies = {'http': 'http://10.10.1.10:3128', 'https': 'http://10.10.1.10:1080'}
response = requests.post(url, proxies=proxies)

stream: (可选)
默认为 False。如果设置为 True，响应的内容不会立即下载，直到你开始读取它。这对于大文件下载时非常有用。
示例：
response = requests.post(url, stream=True)

verify: (可选)
默认为 True，表示验证 SSL 证书。如果设置为 False，将不验证 SSL 证书，适用于不受信任的自签名证书。
示例：
response = requests.post(url, verify=False)

cert: (可选)
用于指定 SSL 证书文件。如果你需要进行客户端证书验证，可以使用该参数。
示例：
response = requests.post(url, cert=('cert.pem', 'key.pem'))

hooks: (可选)
钩子函数，通常用于在请求完成后执行一些自定义操作。例如，可以指定请求的 response 钩子以对响应做后处理。



requests.get 参数详解
requests.get(url, params=None, headers=None, cookies=None, auth=None, timeout=None, allow_redirects=True, proxies=None, stream=None, verify=None, cert=None, hooks=None)

params: (可选)
URL 查询参数，可以是字典、元组或字节序列。requests 会自动将其编码为查询字符串并附加到 URL 上。
示例：
params = {'q': 'python', 'page': 2}
response = requests.get(url, params=params)

python脚本速写小技巧

format{}占位符
1
2
3
4
soure_number='$(({}))'
add_number='$(())'
payload=soure_number.format(add_number*37)	#这里format函数将会使add_number*37与{}进行替换
print(payload)