Python基础教程

最新推荐文章于 2024-02-03 10:27:02 发布

齐佰垩

最新推荐文章于 2024-02-03 10:27:02 发布

阅读量378

点赞数 1

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_63780608/article/details/130330861

版权

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.编码

1.1 gbk 和 gb2312

GB -2312，国家信息委员会制作（1980）。
GBK，GB-2312的扩展包含中日韩等文字。（1995）。

1.2 Unicode 万国码

ucs2，用固定的两个字节表示二进制和文字的对应关系。2 ** 16 = 65632 缺点表示不了特殊文字
ucs4，用固定的四个字节表示二进制和文字的对应关系。缺点就是浪费空间

1.3 utf-8 编码

对unicode 进行压缩，用尽可能少来表示自己数据

注意时项：

- 以后开发时,一定要用utf-8编码
- UTF-8编码,1个中文用3个字节表示。

1.4 python

name = "齐佰垩"     #字符串类型 unicode来储存（ucs4)
data =  neme.encode('utf-8') # 字节类型 utf-8编码来储存
print(data) #b'\xe9\xbd\x90\ xe4\xbd\xb0  \xe5\x9e\xa9' 十六进制

在python开发中，以后再去做文件储存或网络传输时，不能直接用字符串，而是需要压缩成utf-8编码的字节，然后来传输和存储。

# 在文件中写入一个字符串
name = "齐佰垩"

# 打开文件
file_object = open("vip.txt", mode='ab')

# 写入内容
file_object.weite(name.encode('utf-8'))

# 关闭文件
file_object.close()

文件编码
- 写文件，写了很多文本的内容 -> 按照某种编码去储存文件
- 读文件，真正的内容读取出来，用同样的编码才能读取到文本信息
python 解释器将代码读取到内存之后，是需要进行;
- 语法分析 & 词法分析

	name = '齐佰垩'  - > 字符串处理， 在unicode中找对应关系 103131
	age  = b"xxoo" - > 字节，在utf - 8 中找对应关系 00012310

2. 数据类型

布尔类型（bool)：True, False
整形（int)： 1 6 1 5 6
字符串（str）："中国联动"
列表（list）: [11, 22 ,33]  ["伺机待发"， 11， True]
元组(tuple) :(11, 22, 33)
字典(diet)：{"k1"} : 123 , "k2" : sf d}

2.1字符串（str)

定义

name = "齐佰垩"
email = "xjlsjfld"

注意：字符串是一个不可变的类型。

独有功能

datat = root 
res = data.功能名（）

大写小写

name = "root"
res = name.upper()  # name.lower() 小写
print(res) #"ROOT"
print(name) # "root"

isdecimal，判断字符串中是不是整数

data = "12"
v1 = data.isdecimal()
print(v1) # True 如果不是就是非数字

关于作用域

	if 1 == 1:
		text = "jslj"
		print(text)
	print(text) # 毛线
	# 不报错

if 1 > 2
	text = "jslj"
	print(text)
print(text) # 毛线
	# 报错

startswith 和 endswith ,判断字符串是以XX开头或XX结尾。

name = "中华人民共和国"
vi = name.startswith("中华") # True
v2 = name.endwith("中华") # False

strip/lstrip/rstrip,去除空白

name = "fsf "

v1 = name.strip()  #两边都去
v2 = name.lstrip() #去左边
v1 = name.rstrip()  #去除右边

name = input("输入姓名：") # "  "
data = name.strip() # data = ""
if data:
	#用户输入姓名不能为空
else:
	#用户输入为空

replace，替换

text = "广西梁伟"
data =  text.replace("梁伟"， "齐佰垩")

print(text) # 广西梁伟
print(data) # 广西齐佰垩

切割

file_name = "day01 python.mp4"

# data_list = {"day01 python", "mp4"}

data_list = file_name.split(".")
data_list[0] #day01 python
data_list[1] #mp4

字符串的拼接

1. 字符串相加
	v1 = "李阳金"
	v2 = "大神"
	text = v1 + "是" + v2

2.字符串格式化
	v1 = "李阳金"
	v2 = "大神"
	text = "{}是{}".format(v1,v2)

3.列表，里面有很多字符串，你想要让他们按照某个连接符号拼接起来。
	data_list = {"李阳金"， "大神" }
	res = "__".join(data_list)
	print(res) # "李阳金——大神"

注意事项：要想用join里面必须全部是字符串

字符串转化成字节类型

字符串 unicode
字节 文件存储网络传输

长度补足

name = "齐佰垩"
text = name.center(13,"**")
print(text) # *****齐佰垩****

name = "齐佰垩"
text = name.ljust(13,"**")
print(text) # 齐佰垩*******

python
name = "齐佰垩"
text = name.rjust(13,"**")
print(text) # ********齐佰垩

长度补足，只能在左边补零（二进制字符串前面补零）

name = "齐白垩"
v1 = name.zfill(10)
print(v1) # "0000000齐白垩"

name = "10101"
v1 = name.zfill(10)
print(v1) #“00000100101

公共功能

长度

name = "齐佰垩"
res = len(name)
print(res) # 4

索引

text = "我要学习"
text[0] # 我

切片

	0 1 2 3
	-4 -3 -2 -1
text = "我要学习"
text[0:2] # 我要
# 前取后不取

循环

while 循环
for 循环

v1 = range(5) #[0,1,2,3,4]
v2 = range(5,10) #[5,6,7,8,9]
v3 =range(5,10, 2) # [5, 7, 2]
## 前取后不取

for itrm in range(0,100)
	print(itrm)

# 实现获取字符串中的每个袁术并输出

data = "我要学习python编程"

# 方式1
index = 0
while index < len(data):
	char = data[index]
	print(char)

# 方式2
for item in data:
	print(item)

# 方式3
for idx in range(len(data):
	char = data[idx]
	print(char)

查询你自己电脑上的某个文件

import os

data_list = os.listdir(r"c:\dsf\sdf")
for file_name in data_list:
	print(file_name) # 字符串

2.2列表（list)

列表，是一个有序且可变的容器，元素可以有多种不同的数据类型，是一个可变类型

定义

data_list = {11, 22, "中国联通"， True}
data = {}
data.append(11)
data.append(999)

独有功能

追加

data_list = {11, 22, "中国联通"， True}
data = {}
data.append(11)
data.append(999)

插入,把数字插入到那个位置

user_list =["陈清"， "齐佰垩"， "马启坤"]
user_list.insert(1, "懵懂绝")
print(user_list) # ["陈清"，"懵懂绝" ，"齐佰垩"， "马启坤"]

3.删除（指删除）

user_list =["陈清"，"懵懂绝" ，"齐佰垩"， "马启坤"]
user_list.remove("陈清")
print(user_list) # [懵懂绝" ，"齐佰垩"， "马启坤"]

注意：利用remove 去删除列表元素时，如果元素不存在就会报错

user_list =["陈清"，"懵懂绝" ，"齐佰垩"， "马启坤"]
if "陈清" in user_list
	user_list.remove("陈清")

删除（索引位置）

user_list =["陈清"，"懵懂绝" ，"齐佰垩"， "马启坤"]
user_list.pop(1)
print(user_list)  # ["陈清" ，"齐佰垩"， "马启坤"]

user_list =["陈清"，"懵懂绝" ，"齐佰垩"， "马启坤"]
# 1.原列表中删除指定索引位置
# 2.将刚删除的数据获取并赋值到前面的变量

data = user_list.pop()
print(data) #"马启坤"
print(user_list)  # ["陈清"，"懵懂绝" ，"齐佰垩"]

5. 列表元素排序

num_list = [11 ,22,2,11]

num_list.sort()

print(num_list) # [2, 11, 11, 22]

num_list.sort(reverse=True)

print(num_list) # [ 22, 11 ,11,  2]

中文排序的规则：unicode(了解)

user_list = ["叶子"， "q器", "韦神" ]

user_list.sort()

print(user_list) # [“青青”， “韦神”， “叶子]

公共功能

长度
索引删除 del user_list $[1]$
切片
嵌套

2.3 元组(tuple)

是一个有序可变的容器，元素可以时多种不同的数据类型

元组，时一个有序且不可变的容器，元素可以是多种不同的数据类型

定义

v1 = (11, 12 , 13)
v2 = (11, "齐佰垩"，True, (55,66))

元组的个数不能修改；元组的1数据不能替换成其他值

# 元组中的易错点
v1 = (11,22) #正确
v2 =(11,22,) #正确
v3 = (666) # 错误 他表示去除括号的那个置并不是元组
v4 = (666, ) #正确

独有功能

无

公共功能

长度
索引（只能读取）
切片
循环
嵌套

2.4 字典（dict）

字典是一个无序，键不重复且元素只能是键值对的可变的容器。

info = {"k1" : 123, "k2":999}

键值对
键不能重复，重复时数据会被覆盖

info = { "k1" : 123 , "k2" : 999}
print(info) # {"k1" : 999}

键必须是可以哈希类型

可哈希：int， bool, str，tuple
不可哈希类型： 列表，字典

v1 = 123
v2 = "吴佩琦"
v3 = (11, 22, 33)
v4 = [11, 22] # 不可哈希
v5 = {"k1" : 123} # 不可哈希
res  = hash(v5)
print(res)

容器
无序（3.6之前）有序（3python.6之后）

定义

user_list =[
			["root","123","18","xx@live.com"],
			["admin","123",18, "xx@live.com"]
]

user_list =[
			{"name":"root","pwd":"123","age":"18","emall""xx@live.com"},
]

独有功能

获取值

info ={
	 "name":"root",
	 "age":"18",
	 "status":True,
	 "hobbby":["篮球","足球"]  
}

# 在字典中根据键，获取对应值
v1 = info.get("name")
print(v1) # root

v2 = info.get("email")
print(v2) # None / null

v3 = info.get("emall", "xxx") #当键不存在时，v3 = "xxxx"
print(v3) # xxx 如果键存在自动忽略后面

 info ={
	 "name":"root",
	 "age":"18",
	 "status":True,
	 "hobbby":["篮球","足球"]  
}
v1 = info.keys() # 高仿列表
print(v1) # dicti_keys({'name','age', 'status','hobby'}) #高仿列表

 info ={
	 "name":"root",
	 "age":"18",
	 "status":True,
	 "hobbby":["篮球","足球"]  
}
v1 = info.keys() # 高仿列表
res = list(v1)  # 将高仿列表转换成python中的列表
print(res)

 info ={
	 "name":"root",
	 "age":"18",
	 "status":True,
	 "hobbby":["篮球","足球"]  
}
v1 = info.values() # 高仿列表
print(v1) # dicti_keys({"root","18", True,["篮球","足球"]  }) #高仿列表

for item in info.values():
	print(item)

键值

 info ={
	 "name":"root",
	 "age":"18",
	 "status":True,
	 "hobbby":["篮球","足球"]  
}
v1 = info.item() # 高仿列表
print(v1) # dicti_keys({ "name":"root","age":"18","status":True,"hobbby":["篮球","足球"]   }) #高仿列表

for key, value in info.item():
	print(key,value)

公共功能

长度
索引增删改查
循环
实例

goods = [  
    {"name": "电脑", "price": 123},  
    {"name": "鼠标", "price": 21},  
    {"name": "游艇", "price": 12},  
    {"name": "美女", "price": 2}  
]  
cnt = 0  
  
for item in range(len(goods)):  
    print(item, goods[item]['name'], goods[item]['price'])  
  
for i2 in range(len(goods)):  
    print(i2 + 1, goods[i2]['name'], goods[i2]['price'])

goods = [11, 23, 1, 31, 5]  
  
result = {  
    "k1": [],  
    "k2": []  
}  
  
for item in goods:  
    if item < 20:  
        result["k1"].append(item)  
    else:  
        result["k2"].append(item)  
  
print(result)

goods = [11, 23, 1, 31, 5]  
  
result = {  }  
  
for item in goods:  
    if item < 20:  
	    if k1 in result
		    result["k1"].append(item)  
		else:
			result["k1"] = [item]
    else:  
        pass
  
print(result)

2.5集合（set)

集合是一个无序，可变，元素必须可哈希且元素不重复的容器

定义

v1 = {11, 22, 33, 44,}

无序的，没有索引操作
可变

v1 = {11, 22}
v1.add(33)
print(v1) # 11 , 22 , 33

元素不可重复

v1 = {11, 22}
v1.add(11)
print(v1) # 11 , 22

元素不可哈希

一般什么时候会用到集合

不希望重复的一个数据集合，例如:通过网络爬虫的技术去网上下载各种图片，每个图片都有一个URL，维护一个集合，集合里面存放所有已下载国的图片的URL

注意事项: 定义空值的情况。

# 定义空列表
v1 = []
v2 = list()

# 定义空元组
v3 = ()
v4 =tuple()

# 定义空字典
v5 = {}
v6 = dict{}

# 定义空集合
v7 = set()

独有功能

添加元素

v7 = set()
v1.add(11)
v1.add("jls")
print(v1) # (11, jls)

删除元素

v1 ={11, 22}
v1.discard(11)
print(v1) # 22

交集

v1 ={11, 22}
v2 = {11, 44}

# 方式1
res = v1.intersection(v2)
print(res) # 11

# 方式2
res = v1 & v2
print(res) # 11

并集

v1 ={11, 22}
v2 = {11, 44}

# 方式1
res = v1.union(v2)
print(res) # 11 22 44

# 方式2
res = v1 | v2
print(res) # 11 22 44

差集

v1 ={11, 22}
v2 = {11, 44}

# 方式1
res = v1.difference(v2) # v1中有 v2中没有
print(res) #  22 

# 方式2
res = v1 - v2
print(res) #  22

公共功能

长度
循环
in是否包含（效率高，速度快 - > 和字典查询键的速度一样快）

2.6 容器之间的转换

list

v1 =[11, 221 ,33]

tuple

v1 =(11, 221 ,33)

v1 ={11, 221 ,33}

转换原则：想转换成谁就用谁的英文名字包裹一哈

v1 =[11, 22, 33, 44]
res = tuple(v1)
# 列表或元组转换成集合时，会自动去重

2.7 None 类型

None 表示空值相当于其它语言的null

# v1 设置成空值
v1 = None # None 在内存中有一个固定空间
# 再在内重新创建一个字符串，让 v1 指向字符串
v1 = "齐佰垩"

# v2 设置成空字符串
v2 = "" # 这个在内存中每次都重新开空间
v2 = "齐佰垩"

2.8 布尔类型

真假 True/False

0,"", [], (), {} , set() - > False
其余均为True

2.9浮点数类型 (float)

就是小数

v1 = 1.21

由于计算机对浮点数的存储原理导致换算有误差

# 特别精确计算

import decimal

v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")

v3 = v1 + v2
print(v3) # 0.3

2.10 字节类型（bytes）

name = "齐佰垩" # str 字符串，底层是unicode编码
data = name.encode("utf-8") # bytes字节 底层是utf-8编码
print(data) # b'\xx\xx\xx\...

如果以后有取到一个字节，字节decode转换成字符串

name = "齐佰垩" # str 字符串，底层是unicode编码
data = name.encode("utf-8") # bytes字节 底层是utf-8编码

old = data.decode("utf-8")
print(old) # 齐佰垩

普通的文本文件。

3. 文件操作

三个基本步骤：

# 1. 打开文件

# 2. 操作文件

# 3. 关闭文件

3.1 快速读写

写文件

# 1. 打开文件时 由于是wb模式文件不存在就创建文件，文件存在就清空文件
#  - "unicom.txt" 文件路径
#  - mode = "wb" 写文件的模式打开
file_object = open("unicom.txt", mode = "wb")

# 2. 写内容
name = "吴佩琦" # unicode
file_object.write( name.encode("utf-8") )

# 3. 关闭文件
file_object.close()

练习题：实现用户注册，每注册一个用户就在文件中写入一行，（循环操作指导用户q停止）

file_object = open("user.txt", mode = "wb")  
  
while True:  
   user = input("用户名：")  
  
   if user.upper() == 'Q':  
      break  
  
   pwd = input("密码： ")  
   line = "{},{}\n".format(user, pwd)  
   file_object.write(line.encode("utf-8"))  
  
file_object.close()

# 1. 打开文件

file_object = open('user.txt', mode='rb')

# 2. 读取文件所有内容
data = file_object.read()
data_string = data.decode('utf-8')
print(data_string)

# 将读取到的字符串切割并获取每一行的数据
row_list = data_string.strip().split("\n")
print(row_list)

# 3. 关闭文件
file_object.close()

如果文件很大就不要用上述方法读取

# 读取大文件

# 1. 打开文件
file_object = open("user.txt", mode ='rb')

# 2.读取大文件时，可以逐行读取
for line in file_object:
	line_string = line.decode('utf-8')
	line_string = line_string.strip()
	print(line_string)
# 3.关闭文件
file_object.close()

练习题：读取以下文件中的企业名称

# 读取大文件

# 1. 打开文件
file_object = open("user.txt", mode ='rb')

# 2.读取大文件时，可以逐行读取
for line in file_object:
	line_string = line.decode('utf-8')
	line_string = line_string.strip()
	if line_string:
		name = line_string.split(",")[1]
		print(line_string)
# 3.关闭文件
file_object.close()

1.用户注册和用户登录功能
注册部分：用户名和密码写入文件中。

wupeiqi,123
root,123
admin,666

登录部分：输入一次用户名和密码，去文件中比对用户名和密码是否正确。

# 输入部分
file_object = open("user.txt", mode = "wb")  
  
while True:  
   user = input("用户名：")  
  
   if user.upper() == 'Q':  
      break  
  
   pwd = input("密码： ")  
   line = "{},{}\n".format(user, pwd)  
   file_object.write(line.encode("utf-8"))  
  file_object.close()

# 读取部分
# 1. 打开文件
file_object = open("user.txt", mode ='rb')
name = input("用户名：")
pwd = input("密码：")
is_success = False
# 2.读取大文件时，可以逐行读取
for line in file_object:
	line_string = line.decode('utf-8')
	line_string = line_string.strip()
	if line_string:
		if line_string.split(",")[0] == name and line_string.split(",")[1] == pwd: 
						is_success = True
# 3.关闭文件
if is_success == True:
	print("登录成功")
else:
	print("登录失败")
file_object.close()

3.2 with 上下文

你以后编写文件操作的代码时。一定会有时候忘记关闭文件。

print("开始")

# 在离开缩进时自动关闭文件
with open("xxx.txt", mode ='rb') as file_object
	data = file_object.read()
	print(data)

print("结束")

3.4 打开文件的模式

wb 写

file_object = open("ubicom.txt", mode ="wb", )

file_object.write("齐佰垩"， encode("utf - 8"))

file_object.close()

w ，写

file_object = open("ubicom.txt", mode ="w", encoding = "utf-8")

file_object.write("齐佰垩")

file_object.close()

ab 追加

file_object = open("ubicom.txt", mode ="wb", )

file_object.write("齐佰垩"， encode("utf - 8"))

file_object.close()

file_object = open("ubicom.txt", mode ="a", encoding = "utf-8")

file_object.write("齐佰垩")

file_object.close()

rb 对

file_object = open("ubicom.txt", mode ="rb" )

data = file_object.read()

to_string = data.decode('utf-8')
print(to_string)
file_object.close()

r，读

file_object = open("ubicom.txt", mode ="r", encoding = "utf-8" )

# 直接读取到的是字符串
data = file_object.read()

print(data)
file_object.close()

函数

案例：

def image():
""" 图片专区 """
	image_dict = {
		"1":("美女地图"，"image/jlsf")
		"2":("地图"，"image/jlsf")
		"3":("美女"，"image/jlsf")
		"4":("美女地"，"image/jlsf")
		"4":("女地图"，"image/jlsf")
	}
	msg_list = []
	for k, v in image_dict.items():
		ele = "{}.{}".format(k, v[0])
		msg_list.append(ele)
	msg_string = ":".join(msg_list)
	print(msg_string)
	
	pass
def nba():
"""NBA专区"""
	pass
def vdeo():
""""视频专区"""
	pass
def run():
""" 实现程序的主要逻辑"""
	func_dict = {
		"1": image,
		"2": nba,
		"3": vdeo
	}
	while True:
		print(------ 专区------)
		print("1.图片专区; 2.NBA专区；3. 视屏专区")
		choice =input("请输入专区选项（q/Q）:")
		if choice.upper() == "Q":
			return 
		func = func_dict(choice)
		if not func:
			print("\n序号输入错误请重新输入：")
			continue
		func()
			

run()

安装第三方模块
基于第三方的模块来实现下载

pip3 install requests

import requests  
	  
	# 1.下载图片（网络）
def download(url, file_name):
	response = requests.get(url="https://www.runoob.com/wp-content/uploads/2016/04/py-dict-3.png",  
	                        headers={  
	                            'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.75 Safari/537.36',  
	                        }  
	                        )  
	file_object = open(file——name, mode="wb")  
	file_object.write(response.content)  
	file_object.close()

匿名函数 lambda

将已经安装的包写入名称为requirement.txt文件
pip freeze > a1.txt

批量安装
pip install -r requirements.txt

5. 模块和包

什么是模块，什么是包？

模块，就是指py 文件，我们可以将一些功能按照某个中维度划分。

自定义
内置
第三方

包，就是指文件夹，我们可以将一些功能按照某个中维度划分

里面有多个py文件

一般情况下，大家平时讨论和沟通，一般都是统称为：模块

5.1 自定义模块和包

5.1.1 关于模块和包的导入路径

注意：千万不要让自己的模块名称和python内置的模块名称同名（此时就调用自己的）

5.1.2 关于模块和包的导入方式

5.1.2.1 import 导入

导入一个 py 文件

#  utils 就是一个文件
import utils
utils.u_f1()

# commons 是同级目录的文件夹， pager 是文件夹中的一个文件
import commoms.pager
commons.pager.p_1()

5.1.2.2 from 导入

可以导入 py 文件中的函数，也可以导入一个文件

from utils import u_f1
u_f1()

from commons.pager import p_1
p_1()

from commons import pager
pager.p_1()

# 全部导入
from commons.pager import *
p_1()

# 如果本文件中和包中文件冲突那么可以写个别名
from commons.pager import p_1 as p2
p_1()
p2()

sys.path

import os
sys.path.append("......")

import xx

5.2 常见的内置模块

python 内部提供好的功能

5.2.1 hashlib

是对一个数据进行加密的模块

5.2.1.1密文匹配

import hashlib

data = "admin"
obj = hashlib.md5() # md5    加密是不可反解
object.update(data.encode('utf-8'))
res = obj.hexdigest()
print(res)

在以后咱门开发项目是密码不要用明文处理
为防止数据库泄露，用户名和密码全都泄露

案例：

# 密文匹配
user = input("用户名：") # 吴佩琦
pwd = input("密码：") #admin

db_pwd = user_dict.get(user) 

data = pwd
obj = hashlib.md5() # md5    加密是不可反解
obj.update(data.encode('utf-8'))
res = obj.hexdigest()
print(res)

5.2.1.2 撞库

有些网站可以破解你

5.2.1.3 加盐

def md5(data):  
    salt = "fdsf"  
    obj = hashlib.md5(salt.encode('utf-8'))  # md5    加密是不可反解  
    obj.update(data.encode('utf-8'))  
    res = obj.hexdigest()  
    return res

用户注册案例：

DB_FILE_PATH = 'db.txt'
SALT = 'NKKJHKSFL'
def md5(data):
	
	obj = hashlib.md5(SALT.encode('utf-8')) # md5    加密是不可反解
	obj.update(data.encode('utf-8'))
	res = obj.hexdigest()
	return res

def login():
	"""用户登录"""
	print("""用户登录""")
	user = input("用户名：")
	pwd = input("密码：")
	is_success = False
	with open('DB_FILE_PATH ', mode='r', encoding='utf-8') as file_object:
		for line in file_object:
			data_list = line.strip().split(',')
				if data_list[0] == user and data_list[1] == encrypt_pwd:
					is_success = True
					break
	if is_success
		print("登录成功")
	else
		print("登录失败")
def register():
	"""注册"""
	print(”用户注册)
	user = input("用户名：")
	pwd = input("密码：")
	encrypt_pwd = md5(pwd)
	line = "{},{}\n".format(user, encrypt_pwd)
	with open('DB_FILE_PATH ', mode='a', encoding='utf-8') as file_object:
		file_object.write(line)
def run():
pass
run()

5.2.2 random

import random

#  大于等于一小于等于二十的随机值
v1 = random.randint(1,20)

# 随机得到一个小数
 v2 = random.uniform(1,10)

# 随机抽取一个值
data_list = [11,22,333,55,44,2]
v3 = random.choice(data_list)

# 随机抽取多个
data_list =[11,33,56,66,8]
v4 = random.sample(data_list,3)

# 打乱顺序
num_list =[i for i in rang[100]]
random.shuffle(num_list)
print(num_list)
print(v1)

5.2.3 json

本质上：是一种数据格式，字符串类型
用处：让不同语言之间实现通信

python - > json 序列化
json - > python 反序列化

json格式：

外部整体打的字符串
json 字符串内部如果有字符串，要用双引号
json格式中没有元组元组会变成列表

info = {456, fs,fs}
#转化成json
res = json.dumps(info)
# json转化成 python
res = json.loads(info)

5.2.3.1 关于中文

import json
info = {"name": "就发生了就"， "age"：12}

v1 = json.dumps(info, ensure_ascii = False)
print(v1)

5.2.4 datetime

时间戳

import time
# 从1970年开始经过了多少时间
v1 =time.time()
print(v1)

while True:
	print(1)
	time.sleep(5) # 停五秒在运行

datetime

import datetime
# 时间戳
import time
v1 =time.time()

v1 = datetime.datetime.now()
print(v1) # datetime数据类型

# 转换成字符串数据类型
string_data = v1.strftime("%Y-%m-%d %H:%M:%S") # 年月日时分秒
print(string_data)

案例：

用户注册
- while循环，输入：用户名和密码
- 密码->md5加密->密文
- 当前时间，用户注册时间
- 写入到db.txt文档中

import hashlib  
import datetime  
  
  
def md5(data):  
    salt = "fdsf"  
    obj = hashlib.md5(salt.encode('utf-8'))  # md5    加密是不可反解  
    obj.update(data.encode('utf-8'))  
    res = obj.hexdigest()  
    return res  
  
  
while True:  
    user = input("用户名：")  
    if user.upper() == 'Q':  
        break  
    pwd = input("密码：")  
    pwd_md5 = md5(pwd)  
    time1 = datetime.datetime.now()  
    string_time = time1.strftime("%Y-%m-%d %H:%M:%S")  
    string_line = "{},{},{}\n".format(user, pwd, string_time)  
    with open('db.txt ', mode='a', encoding='utf-8') as file_object:  
        file_object.write(string_line)

日志记录器，按分钟的维度来创建文件，并将内容写入到文件中。
- 写一个函数，在函数中实现这个功能
- 在函数里面循环用户输入文本
- 需要将文本写入到文件中

import datetime
ctime_string = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
file_object = "{}.{}".format(ctime_string,"txt")
with open(file_object, mode='a', encoding='utf-8') as file_object1:  
        file_object1.write(ctime_string)

5.2.4.1 时间转换

datetime->字符串

from datetime import datetime

dt = datetime.now()
res = dt.strftime("%Y-%m-%d-%H-%M")
print(res)

时间戳-> datetime类型

import time
from datetime import datetime

ctime = time.time()

dt = datetime.fromtimestamp(ctime) 
print(dt, type(dt))

datetime类型 ->时间戳

from datetime import datetime

v1 = datetime.now()
res = v1.timestamp()
print(res)

datetime 类型的意义

from datetime import datetime, timedelta

v1 = datetime.now()
res = v1 + timedelta(days = 10, hours =20, minutes = 10, seconds = 100)

res = datetime.strftime(res, "%Y-%m-%d-%H-%M")
print(res)

很方便处理时间的加减

5.2.5os

路径的拼接

window: c:\xx\xx
Mac /xx/xx
Linux /xx/xx

import os
path = os.path.join("x1","x2",'log.txt')
print(path)

import os
file_path = \xx\xx
v1 = os.path.dirname(file_path)
print(va)

绝对路径

import os
res = os.path.abspath('xx')
print(res)

判断路径是否存在

res = os.path.exists(xx) True/False

import os

path = os.path.join('bd','2021','11月份')
print(path) # db/2021/11
if not os.path.exists(path)
	os.makedirs(path)

删除文件，文件夹

import os
path = os.path.join('bd','2021','11月份')
print(path)
# 删除文件
os.remove(path)

import os
import shutil
path = os.path.join('bd','2021','11月份')
print(path)
# 删除文件夹
shutil.rmtree(path)

判断是否是文件夹

import os
prth =os.path.join('db', 'a1.txt')
res = os.path.isdir(path)
print(res)

# 用户注册放在指定的文件夹中
import os

while True:
	user = input(">>>")
	line'{}\n'.format(user)
	# 确保文件所在目录已经存在
	folder_path = os.path.join('db','files')
	if not os.path.exists(folder_path)
		os.makedirs(folder_path)
	# 所在文件夹必须已经存在
	file_path = os.path.join(folder_path, 'account.txt')
	file_object = open(file_path, mode = 'a', encoding ='utf-8')
	file_object.write(line)
	file_object.close()

5.2.6 shutil

删除文件夹

import shutil
shutil.rmtree("xx/xx/xx")

拷贝文件夹

shutil.copytree("原文件夹"， "目标文件夹路径")

拷贝文件

shutil.copy("原文件夹"， "目标文件夹路径/")

重命名

shutil.move('x10','x10.txt')

压缩和解压缩

import shutil

# base_name 压缩包的名称
# format ,后缀名
# root_dir ，压缩文件路径
 shutil.make_archive(bash_name'1666', format ='zip', root_dir ='ppp')

# filename 压缩包的文件名
# extract_dir，要解压的目录
# format 后缀名
shutil.unpack_archive(filename = "1116.zip", extract_dir = "1333", format = ' zip')

5.2.7 re

正则表达式【和语言无关】
python中的re模块

- >特征 表达一些东西的特征

import re
txt = 1456453
# 必须是一开头， 第二位可以是3589 在加后面九位
data_list = re.findall("1[3|5|8|9]\d{9}"， txt)

print(data_list)

5.2.7.1 字符相关

固定文本

import re
txt = 1456453sdf131sdf4654
# 必须是一开头， 第二位可以是3589 在加后面九位
data_list = re.findall("sdf"， txt)

print(data_list) # [sdf,sdf]

匹配字符

# 找 a, b, c

data_list = re.findall("[abc]"， txt)

# 找 qa, qb, qc

data_list = re.findall("q[abc]"， txt)

字符范围

# 找q +  a 到 z

data_list = re.findall("q[a-z]"， txt)

$KaTeX parse error: Undefined control sequence: \d at position 1: \̲d̲$ 代表1个数字

# 表示q 后面加一个数字
data_list = re.findall("q\d"， txt)

- 代表一个或n个

# 表示 q 后米加 一个或 n个数字
data_list = re.findall("q \d+"， txt)

- 表示 0 个到 n 个

# 表示 q 后面加 0个或 n个数字
data_list = re.findall("q \d*"， txt)

？表示 0个到一个‘

# 表示 q 后面加 0个或 1个数字
data_list = re.findall("q \d？"， txt)

{} 固定n个

# 表示 q 后米加 2个数字
data_list = re.findall("q \d{2}"， txt)
# 表示 q 后米加 2到 4 个数字
data_list = re.findall("q \d{2，4}"， txt)

$KaTeX parse error: Undefined control sequence: \w at position 1: \̲w̲$ 字母，数字，下滑线

# 表示 q 后面加 一个或 n个字母 到 x
data_list = re.findall("q \w+ x"， txt) 贪婪匹配
data_list = re.findall("q \w+? x") 非贪婪匹配

. 除了下划线后的所有

# 表示 q 后面加个任意的在加o
data_list = re.findall("q.o"， txt)

$KaTeX parse error: Undefined control sequence: \s at position 1: \̲s̲$ 任意空白字符

# 表示 q 后面加 一个空白字符
data_list = re.findall("q \s"， txt)

5.2.7.2数量

- 0 到 n
- 1 到 n
？0 到 1
{n} 固定 n个
{m,} n + 个
{n,m} n~m 个

5.2.7.3 分组

提取数据区域

# 先匹配了 在提取括号中的部分[(),()]
data_list = re.findall("(1\d{2})31(2\d{5})"， txt)

提取数据区域 + 或

# 可以按 （1\d{2})31 , (2\d{5})31 匹配
data_list = re.findall("（1\d{2}|2\d{5})31"， txt)

注意：. 用 $KaTeX parse error: Expected group as argument to '\.' at end of input: \.$

5.2.7.4 re模块

re.findall, 获取匹配成功的所有结果
re.match 从开始进行匹配，开头没有匹配成功就不用往下面看了, 返回一个对象
re.search 浏览之后匹配，返回第一个对象

5.3 第三方模块

5.3.1 requests 模块

requests 模块，让我们可以通过代码向某些地址发送网络请求然后可以获取到结果

pip install requests

import requests
requests.功能

5.3.1.1 抓包

查看它的网络请求

地址
请求方式
请求地址

import requests


# 返回所有数据 （响应头，响应题）
# 代码去豆瓣获取数据会被以为是去窃取数据
# - 防范 你是浏览器给你返回， 不是浏览器就不返回
# - ip限制： 1天只能看一千次 (代理 ip)
# - 底层算法： js写算法（逆向）

res = requests.get(
	# 访问地址
				   url =""
				   # 伪造自己是浏览器
				   headers ={
				   }
)

print(res.txt)

例子：

import requests  
headers = {  # 模拟浏览器头部信息，向浏览器发送消息  
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0"  
}  
res = requests.get(url="HTTP://www.chinaunicom.com.cn/api/article/NewsByIndex/2/2022/01/dfdt", headers=headers)  
date_list = res.json()  
print(date_list)  
return HttpResponse("hahah")

案例：
窃取别人的网页

import requests
# 所有
res = requests.get(url= "https://www.autohome.com.cn/news/")
# res.encoding = 'gbk'
# print(res.text)

data = res.content.decode('gbk')
 print(data)

# 根据特征获取元素

"""
如果你想处理 html中的 数据 要加一个模块
	pip install BeautifulSoup4
"""
soup_object =  BeautifulSoup(data, "html.parser")

# 找一个
new_area_object =soup_object.find(name = 'div', attrs = {"id": "auto-channel-lazyload-article"})
# 找所有
new_area_object_li = new_area_object.find_all(name = 'li')

# 获取到某个标签的值
 # prints(v4.attrs("src"))

for li_ob in new_area_object_li 
	p_object = li_object.find(name ="p")
	print(p_object.txt)
	print("........")

5.3.2 Excel 操作

pip install openpyxl

5.3.2.1 读取

import os
from openpyxl import load_worbook

# 1.获取 work book 对象
file_path = os.path.join('file', 'p1.xlsx')
work_book_object = load_workbook(file_path)

# 2.读取所有sheet的名字
v1 = work_book_object.sheetnames
print(v1)

# 3.读取所有sheet 对象（内部含有很多数据）
v2 = work_book_object.worksheets
print(v2)

# 4.获取某一个sheet对象
sheet_object = v2[0]
sheet_object = work_book_object["seet名称"]

####### 方式一 ######
# 5.读取sheet中的单元格cell对象
cell_object =sheet_object.cell(1,1)
#  读取cell对象中的文本
print(cell_object.value)

####### 方式二 ######
cell_object2 = sheet_object["E3"]
print(cell_object2.value)

# 6.读取一行
row_list = sheet_object[1]
print(row_list)
for cell_list in row_list
	print(cell_list)
# 7. 读取所有行
for row in sheet_object.rows:
	row_text_list = []
	for cell_object in row:
		row_text_list.append(cell_object.value)
	print(row_text_list)
# 8. 读取某一列
for row in sheet_object.rows:
	cell_object_0 = row[0]
	print(cell_object_0.value)

# 9. 从第2行开始读取

for row in sheet_object.iter_row(min_row = 2):
	print(row[0].value)

5.3.2.2 合并单元格

# 1.获取 work book 对象
file_path = os.path.join('file', 'p1.xlsx')
work_book_object = load_workbook(file_path)

# 2.读取所有sheet的名字
sheet_object_list = work_book_object.worksheets

# 获取一个sheet 对象
sheet_object = sheet_object_list[2]

# 获取合并的单元格
call_1_object = sheet_object.cell(1,1) # cell对象
print(cell_1_object)
									# 合并了的单元格顶一个还是cell对象
									# 后面的都是 Mergedcell对象
									# 被合并的单元格就是
call_2_object = sheet_object.cell(1,2) # MergedCell对象
print(cell_2_object)

for row in sheet_object.rows:
	text_list = []
	for cell in row:
		if type(cell) == MergedCell:
			text_list.append("-")
		elif type(cell) == Cell:
			text_list.append(cell.value)
		else:
			text_list.append("不认识")
	print(text_list)

# 1.获取 work book 对象
file_path = os.path.join('file', 'p1.xlsx')
work_book_object = load_workbook(file_path)

# 2.读取所有sheet的名字
sheet_object_list = work_book_object.worksheets

# 获取一个sheet 对象
sheet_object = sheet_object_list[2]

# 获取所有被合并的单元格   
def get_merged_txt(coordinate, sheet_obj):
	for item in sheet_object.merged_cells:
		print(item, type(item))
			return item.start_cell.value

for row in sheet_object.rows:
	text_list = []
	for cell in row:
		if type(cell) == MergedCell:
		get_merged_txt(cell.coordinate, sheet_object)
		elif type(cell) == Cell:
			text_list.append(cell.value)
		else:
			text_list.append("不认识")
	print(text_list)

# 共有几行几列
print(sheet_object.max_row)
print(sheet_object.max_column)

5.3.2.3写

修改

- 读取，将所有内容都读取到内存
- 都是在内存中修改
- 保存

# 1.获取 work book 对象
file_path = os.path.join('file', 'p1.xlsx')
work_book_object = load_workbook(file_path)

# 2.读取所有sheet的名字
sheet_object_list = work_book_object.worksheets

# 获取一个sheet 对象
sheet_object = sheet_object_list[2]

# 修改内容 
cell_object = sheet_object.cell(1, 1)

cell_object.value = "序号"

# 将内存中的数据写入文件

work_book_object.save(file_path)

兴建

- 读取，空内容
- 在内存中修改操作
- 保存

from openpyxl.workbook import Workbook

# 1.获取 work book 对象
work_book_object = Workbook()
sheet_object = work_book_object.worksheets[0]
# sheet名称

sheet_object.title = "数据集"
sheet1 = work_book_object.create_sheet("上海"，1)

# 拷贝
new_sheet = work_book_object.copy_worksheet(sheet_object)
new_sheet.title = "备份"

# 2.写入内容
cell_object = sheet_object.cell(1,1)
cell_object.value = "你好呀"

# 3. 保存
work_book_object.save('files/p2.xlsx')

# 4.
wb = load_workbook(file_path)
del wb["用户列表"]

在单元中写文本

# 1.获取 work book 对象
work_book_object = Workbook()
sheet0 = work_book_object.worksheets[0]
cell_object = sheet0.cell(1,1)
# 写入
cell_object.value = "123123"

设置对齐方式

from openpyxl.styles import Alignment
	call.对齐方式 = 剧中
	# 居中 和 换行
call.alignment = Alignment(horizontal="center", vertical="ccenter", wrap_text=True)

设置边框

from openpyxl.styles import Border,Side
# 设置了边框样式才会显示颜色
cell.border = Border(top =Side(style = "thin",color="rbg颜色"), right="", left="", bottom="")

字体颜色

from openpyxl.styles import font
# 大小 颜色 样式
cell.font = Font(color ="",size ="", name="" )

设置行高和宽高

sheet.row_dimensions[1].heigth = 50
sheet.column_dimensions['A'].height = 520

框框填充颜色

PatternFill
cell.fill = PatternFill("solid", fgColor="F4A460")

6. 面向对象编程

主文件

def run()
	print(123)
# 当你在运行当前脚本时，__name__时python内部会创建一个变量 __name__ = "__main__"
# 如果时别人导入运行的化python内部会在这个脚本内创建__name__ = "app"

if __name__ == '__main__'
	run()

齐佰垩

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python基础教程

name = "齐佰垩"注意：字符串是一个不可变的类型。11 , 22 , "中国联通" ， True } data = {v1 =(11 , 12 , 13) v2 =(11 , "齐佰垩" ， True ,(55 , 66))元组的个数不能修改；元组的1数据不能替换成其他值# 元组中的易错点 v1 =(11 , 22) #正确 v2 =(11 , 22 ,) #正确 v3 =(666) # 错误他表示去除括号的那个置并不是元组 v4 =(666 ,) #正确无序的，没有索引操作可变。
复制链接

扫一扫