python -白白入门篇

第一章、计算机的基础

组成

硬件

• 输入设备

   接收数据，指令。
   键盘，鼠标，扫描仪
  

• 输出设备

   显示数据。
   显示器，音箱
  

• CPU

   控制器：分析中转指令
   运算器：运算
  

存储设备

• 内存

   瞬时存储，断电，程序退出，数据消失。
   传输速度非常快。
  

• 外存

   永久存储。
   传输速度相对慢。
   存储单位：
   位bit：1位存储1个0或者1--b
    字节byte:--B 1B=8b
   KB -- K 1KB=1024B
   MB --M 1MB=1024KB
   GB--G
   TB
  

完成一个功能，各个组成部分协同工作的结果。输入设备—存储设备（内存）–CPU–(运算器)—
存储设备（内存）–输出设备、外存

• 软件

   系统软件
   	操作系统
   	驱动程序
   应用软件
   	单机软件：记事本，计算器
   	网络软件：QQ、微信、王者荣耀
  

程序

生活中的程序：完成一个任务而进行一系列有序的动作集
计算机中的程序：让计算机完成一个功能而编写的有序指令集
编程语言：
机器语言：010100001111
速度快，可读性不好，维护性，扩展性
汇编语言：助记符 add a,b
可读性有改善，比较贴近硬件，速度相对快
程序冗长。对计算机的硬件组成要求高。
高级语言：贴近人类语言
可读性，维护性，扩展性都非常好。
速度相对慢。
C\C#\Java\Python
解释型语言：源代码–解释器–边解释边执行 Python ，JavaScript—【即时编译】
编译型语言：源代码–编译器–可执行文件 C,Java —【文献翻译】

第二章、Python简介

为啥学Python?

很受欢迎，简单，应用领域广（办公自动化，web，数据采集，数据分析，人工智能，科学计
算），
三大方向的基础课。
Python发展历程：
Python之父：Guido 吉多
推荐使用3.x版本

特点：

简单，优雅
跨平台，跨语言
强大的库
免费开源
解释型
应用广
交互型
支持面向对象：C#，Java,Python,JavaScript
面向过程：C

搭建环境

：
安装Python解释器
IDE:PyCharm

第三章、Python基础语法

3.1print输出函数

print('hello,python') #print()往控制台打印xxx
#打印各种数据
print(123)
print(3.5)
print(True)
print("人生苦短，我用python")
#控制是否换行 end=''
print("hello",end=' ')
print('world')
#转义字符
# 当我们输入一些控制键如回车，Tab等无法显示的字符，可以使用字符
# \n 回车换行
# \t Tab键 ，相当于4个空格
print('a',end='\n')
print('b')
print('hello\npython')
print('hellopython')
print('hell\tpython')
#\,',"，就想不要转义,需要前面再添加\
print('\\') #输出\
print('\'') #输出‘
#以原字符的方式输出，前面r或R
print(r'\nbc')
print(r'E:\BaiduNetdiskDownload\hello beda音频')
#双引号中使用单引号，单引号中间使用双引号
print("小明对妈妈说：'我饿了'")
#python支持各种特殊符号
print('웃')
#以，号分隔，后面会讲其实是可变的位置参数，输出内容间会以空格分开
print('hello','python','java','c')

3.2注释

# 注释是来解释代码的，给程序员看的
# 解释器不处理，不会影响程序的效率
# 多多益善
# 分类：单行注释和多行注释
# 单行注释 ：#+文字
print('hello') #控制台输出内容
# 多行注释 三个单引号或者三个双引号
'''
多行注释1
多行注释2
多行注释3
'''
"""
多行注释1
多行注释2
多行
""

3.3变量

我有20元钱，花了12元，问还剩多少钱？
变量的本质：就是内存中的一块存储空间
变量的作用：存储数据
变量简单的理解为程序中其值可以发生可变的量
变量三要素：
变量名：存储空间的名字，快速地找到其中的数据
数据类型：存储数据的类型，分配空间
变量值：存储数据
数据类型：
基本数据类型
数值型
整型：int
浮点型:小数 float
布尔型
bool—boolean
真True 假False
字符串型
str:0~多个字符组成的串 ，放在单引号或双引号或者三引号之间
选择数据类型：是否有运算需求，有的话选数值类型，没就是字符型
举例：余额：1000,000,000—float 身份证号，电话号码，密码–str

#数据类型
#整型 int
age = 16
print(age,type(age),id(age))
# 其它进制表示
i = 0b100 # 二进制0b开头
i2 =0o10 # 八进制0o开头
i3 =0x10 # 十六进制0x开头
print(i3,type(i3))
# float
price = 3.5
print(price,type(price))
price = 2
print(price,type(price))
#bool
flag = True
print(flag,type(flag))
#str
s1='hello'
s2=""
#三引号支持换行
s3='''h
e
l
l
o'''
s4="""
python,
java,
c
"""
print(s1,type(s1))
#个人信息
name = '张飞'
age = 45
print("我的名字是"+name)
print("我的年龄是"+str(age)) #字符串和数值不能直接拼接，需要使用str()将数值类型转换成str类
型
print('年龄是',age）

复合数据类型/引用数据类型（后面讲到）
数据类型之间的转换
str() 把其它类型的数据转换成str

i = 12
f = 2.5
b = True
print('int转换后'+str(i),type(str(i)))
print('float转换后'+str(f),type(str(f)))
print('bool转换后'+str(b),type(str(b)))

int() 把其它类型的数据转换成int 结论：小数串和非数值串不能转换成int

f = 3.1
b = True
s1 = '12'
s2 = '12.5'
s3 = 'hello'
print(int(f),type(int(f))) #3 float类型转换成int，小数部分直接截断
print(int(b),type(int(b))) #False=0 True=1
print(int(s1),type(int(s1))) #12 整数串可以正常转换
#ValueError: invalid literal for int() with base 10: '12.5'
# print(int(s2),type(int(s2))) #小数串 转换成int，会报错
#ValueError: invalid literal for int() with base 10: 'hello'
# print(int(s3),type(int(s3))) #非数值串，不能转换成int

float() 把其它类型的数据转换成float 非数值串不能转换成float

i = 12
b = True
s1 = '12'
s2 = '12.5'
s3 = 'hello'
print(float(i),type(float(i))) #12.0
print(float(b),type(float(b))) #True=1.0
print(float(s1),type(float(s1))) #12.0
print(float(s2),type(float(s2))) #12.5
#ValueError: could not convert string to float: 'hello'
# print(float(s3),type(float(s3))) #非数值串，不能转换成float

bool() 把其它类型的数据转换成bool

i = 10
f = -1
s = ''
print(bool(i),type(bool(i))) # 0=False 其它都是True
print(bool(f),type(bool(f))) # 0=False 其它都是True
print(bool(s),type(bool(s))) # 空串是False ,其它都是true

总结：字符串拼接的时候，需要把其它类型转换成字符串，使用str()
数值计算的时候，需要把其它类型转换成数值，使用int()或float()
逻辑判断的时候，需要把其它类型转换成布尔，使用bool() —使用较少，后面会直接使用变量
来判断 变量名：
命名规范：
1、可以使用字母、数字 和下划线（_），不能以数字开头
2、不能使用关键字或保留字（创建python语言时，已占用了某些单词，已具有特殊的含义）
3、区分大小写 name Name
4、见名知意 name brand age price i
5、多个单词用_分隔 stu_name phone_price book_author
bookAuthor
输入输出
格式化输出
1、使用个数可变的位置参数
2、使用+连接符，+的左右均为str类型
3、%占位符：’’%()
4、{0}占位符：’’.format()
5、f’{变量名}’
输入
变量 = input(‘提示语：’)

第四章 运算符

4.1算术运算符

a = 3
b = 2
print(a+b)
print(a-b)
print(a*b)
print(a/b) #1.5 /数学中的除法
print(a//b) # 1 //整除(结果是整数)
print(a%b) # 1 % 模/求余
# 幂 2*2*2
print(2**3)
# ++ -- python中没有

# 今天周日，12天之后是周几？
weekday = int(input('今天周几？'))
weekday2 = (weekday +12) % 7
print('12天之后是周',weekday2)

print('-------------练习：分解整数--')
# %求余 可以拿到低位上的数字 //整除 可以拿到高位上的数字
# 分解两位数 34 十位是3，各位是4
num = 34
ge = num % 10
shi = num // 10
print(f'{num}的个位数字是{ge}，十位数字是{shi}')
print()
## 分解三位数 456
num1=456
ge = num1 % 10
bai = num1 // 100
# shi = num1 // 10 % 10 # 45 6 -- 4 5
shi = num1 % 100 // 10 # 456-- 4 56--5 6
print(f'{num1}的个位数字是{ge}，十位数字是{shi}，百位数字是{bai}')

4.2赋值运算符

从右往左进行
支持链式赋值
解包赋值，左右两边个数要一致
复合赋值运算符:赋值+算术 += -= *= /= //= %=

# 从右往左进行
num = 12
num = num + 1
# num = input('请输入：')
print(num)
# 支持链式赋值
# a = 1
# b = 1
# c = 1
a = b = c = 1
print(a,b,c)
print(id(a),id(b),id(c))
# 解包赋值 左右两边个数要一致
# 交换两个数 m=5 n=3 ----》m=3 n=5
# 交换算法 temp
print('-------------')
m = 5
n = 3
temp = m
m = n
n = temp
print(m,n)
print('------------')
m = 5
n = 3
sum = m + n
m = sum - m
n = sum - n
print(m,n)
print('--------只在python中有效--------')
m = 5
n = 3
m,n=n,m
print(m,n)
# 复合赋值运算符 赋值+算术 += -= *= /= //= %=
print('-----------')
x = 2
x += 1 # x = x +1
print(x)

4.3关系运算符

表示两个变量之间的大小关系的

< >= <= == !=

# 关系运算符 关系表达式的结果是bool
a = 23
b = 12
print(a>=b) #True
print(a<=b) #False
print(a!=b)
print(a==b) # ==表示等于
# 通常不比较float数据，因为小数在内存存储不精确
print(1.1+2.2)
print(1.1+2.2==3.3) #False
# == 比较值
# in / not in 在/不在
print()
s = 'hello'
print('k' in s)
print('k' not in s)

4.4逻辑运算符

主要是连接多个条件（布尔表达式–关系表达式、布尔变量）
and 逻辑与：同真则真，遇假则假
or 有真则真，同假则假
not 取反

# and 同真则真，遇假则假
a = 8
b = 4
print( a >1 and b >2) # True and True
# or 有真则真，同假则假
print(a >10 or b >20)
# not 取反
print(not(a>1))
print(True or True and False)
#结果是True，所以and比or的优先级高

4.5位运算

按位与 &
按位或 |
异或 ^
左移
右移

# 位运算
m = 5
n = 12
print(m&n)
print(m|n)
print(m^n)
#结论：对一个数异或两次，就可以获取原数字本身
#交换两个数
print('------------')
a = 23
b = 12
temp = a ^ b #a^b==b^a
a = temp ^ a
b = temp ^ b
print(a, b)
print('-----------')
#>> 右移 相当于整除，右移1位相当于除以2 ，右移n位相当于除以2的n次方
print(5>>1)
print(5>>2)
#<< 左移 相当于乘法 左移1位相当于乘以2，左移n位相遇乘以2的n方
print(5<<1) # 10
print(5<<2) # 20

4.6运算符的优先级

小括号>算术运算>位运算>关系运算>逻辑运算>赋值运算
先运算 ，再比较 ，再链接，最后赋值
建议大家，把优先高的放在小括号中，这样的代码可读性好

f = not (35 > (3 << (1 + 1)))
print(f) #False

第五章 程序流程结构

5.1 算法

算法就是解决问题的步骤。
算法不唯一，但是有优劣。评价维度：时间复杂度，空间复杂度。
表示算法的方式有很多，最主要的一种就是流程图。
符号：圆角矩形 —程序的开始/结束
平行四边形–输入或输出
直角矩形–处理步骤（运算，赋值）
菱形—判断（布尔表达式）
流程线
计算机专家发现，不管多么简单或多么复杂的算法都可以由顺序结构，选择结构，循环结构组合而
成。

5.1 顺序结构

从左往右，从上往下依次执行
写出来的代码都会执行

5.2 选择结构 /条件结构

场景：需要做出选择/做出判断，才知道如何执行
1、单分支结构

if 条件:
代码块

语法：
1）条件：结果只要是布尔值就行，所以也叫布尔表达式。可以是变量，关系表达式，逻辑表达式
bool(变量)–0,0.0,空字符串、空字典，空集合，空列表等返回false，其它都返回true
2）代码块：可以是赋值，运算，流程结构等
3）python靠缩进表达代码的层次关系，缩进一般使用tab键
执行顺序： 先判断条件，如果条件为true，则执行代码块。否则不执行代码块
案例：

aply = input("笔试通过了吗？")
if aply == 'y':
print('明天参加面试')

# 输入三个数，求最大值
# a b c
# max=a
a = int(input('请输入一个数:'))
b = int(input('请输入一个数:'))
c = int(input('请输入一个数:'))
max = a
if max<b:
max=b
if max<c:
max=c
print('最大值是',max)

2、双分支结构
语法：

if 条件：
代码块1
else:
代码块2

执行顺序：先判断条件，条件为true，则执行代码块1，否则执行代码块2
案例：

# 模拟以下QQ登录
# 正确的账号：QQ :123456 密码：123
account = input("请输入QQ号:")
pwd = input('请输入密码:')
if account == '123456' and pwd == '123':
print('登录成功')
else:
print('账号密码不匹配')

简化写法:条件表达式

表达式1 if 条件 else 表达式2

执行顺序：条件为true，表达式的结果就是表达式1，否则整个表达式的结果就是表达式2

# 输入一个数，判断奇偶性
num = int(input('请输入一个整数'))
s = '奇数' if num%2==1 else '偶数'
print(s)
print('奇数' if num%2==1 else '偶数')

## 输入一个数，判断奇偶性
## 模拟取款，输入取款金额，如果余额够，显示余额；否则提示余额不足。

3、多分支结构
3.1 多重if结构
语法：

if 条件1：
代码块1
elif 条件2：
代码块2
elif 条件3：
代码块3
else:
代码块4

执行顺序：先判断条件1，如果条件1为true，则执行代码块1
否则判断条件2，如果条件2为true,则执行代码块2
否则判断条件3，如果条件3为true,则执行代码块3
场景：一个维度连续区间的多路分支
案例：

# 给成绩评级 60以下差，60-80中 80-90良，90以上优
# 一个维度（成绩），连续区间
score = int(input('请输入成绩'))
if 0<score < 60: # 0-60
print('差')
elif score<=80: #60-80
print('中')
elif score<=90: #80-90
print('良')
else:
print('优')
# 或者
if 100>=score > 90:
print('优')
elif score>=80:
print('良')
elif score>=60:
print('中')
else:
print('差')

注：python中关系表达式允许连写0 练习

## 猜数游戏 输出结果：大了，小了，对了
## 根据年龄判断年龄段（0-6婴幼儿，6-12少年，12-18青年，18以上成年）

3.2 嵌套if结构
语法：

if 条件1：
if 条件2：
代码块1
else:
代码块3
else:
代码块2

执行顺序：
场景：多个维度的多路分支
案例：

# 超市活动 如果不是会员，消费满100打9折；如果是会员，消费满200打7折，不满200打8折。
# 根据会员及消费金额输出应付金额
# pass 什么都不做，只是一个占位符，代替需要写的语句
# 进行代码建构的时候，还不想写代码，可以使用pass先代替
isVip = input('是否是会员?')
sumMoney = int(input('请输入消费金额：'))
discount=1
if isVip=='y':
if sumMoney>=200:
discount=0.7
else:
discount=0.8
else:
#不是会员
if sumMoney>=100:
discount=0.9
print(f'应该支付{sumMoney*discount}')

3.3 switch在python没有

5.3 循环结构

场景：有重复做的事情（可以是一样的事情，也可以是有规律的事情）
循环的特点：
循环操作：重复在做的事情
循环条件：循环继续的条件，循环结束的条件
如果循环永不结束，就叫死循环。初学程序的时候，要避免死循环。
编码时，循环条件会借助循环变量来表达。
如，计数器count=0(循环变量的初始化) count+=1（循环变量的更新） count<=10（循环条
件）
5.3.1 while循环
语法：
循环变量的初始化
while 循环条件:
循环操作
循环变量的更新
特点：先判断，再执行
如果循环条件一开始就不成立，循环操作可能一次都不执行
适合循环次数不固定的情况
案例

# 输出10个*
# 循环操作：输出1个*
# 循环条件：count=1 count<=10
count = 11
while count<=10:
print('*')
count+=1
# 输出1-100之间的整数
# 循环操作：输出一个数 print(i)
# 循环条件：i=[1,100]
i = 1
while i<=100:
print(i)
i+=1
# 输出1-100之间的偶数
# 输出100-1之间整数
# 求和1-100
# 循环操作：1+2 +3 +4 +。。。+100 ---> sum+=num --累加求和
# 循环变量 num=[1,100] sum=0 就是存储每一次计算的和
print('--------------')
num = 1
sum = 0
while num<=100:
sum+=num
num+=1
print(f'1-100之间的整数和为{sum}')
# 求1-100之间的奇数和
# 扩展计算： 1-2+3-4+5-6...-100
# 求1*2*3*4*5*6---累乘求积
print('-----------')
num = 1
sum = 0
while num<=100:
if num%2==0:
sum-=num
else:
sum+=num
num+=1
print(f'1-2+3-4+5-6...-100和为{sum}')
# 计数器
# 输入5个学生的成绩，统计80分以上的比例
# count 存储80分以上的成绩数
print('------------')
i = 1
count = 0
while i<=5:
score = int(input(f'请输入第{i}个学生的成绩:'))
if score>=80:
count+=1
i+=1
print(f'80以上的学生有{count}个，占比{count/5*100}%')

while适合循环次数不固定的情况

'''
*****欢迎拨打中国移动服务热线******
1、电话业务
2、宽带业务
3、人工服务
********************************
请选择：2
宽带业务
请问还有其它需要吗？（y是，n否）
'''
choice = 'y'
while choice=='y':
print('*****欢迎拨打中国移动服务热线******')
print(' 1、电话业务')
print(' 2、宽带业务')
print(' 3、人工服务')
print('********************************')
num = int(input('请选择：'))
if num==1:
print('电话业务')
elif num==2:
print('宽带业务')
else:
print('人工服')
print()
choice=input('请问还有其它需要吗？（y是，n否）')
print('谢谢，再见')

5.3.2 for in循环
语法

for 变量名 in 可迭代对象:
循环操作

特点：循环次数固定，优先for;常用来遍历容器对象
可迭代对象:字符串、range对象
range()函数 可以生成整数序列
range(stop) 生成[0，stop)之间的整数序列，步长是1
range()函数只存储这start,stop,step个变量，节省内存

# 生成[0,10)之间的整数
r = range(10)
print(list(r))
# range(start,stop)---[start,stop) 步长为1
r2 = range(1,10)
print(list(r2))
# range(start,stop,step) ---[start,stop) 步长为step
r3 = range(1,10,2)
print(list(r3))

#
for i in range(1,11):
print(i)
# 猜数字 num 结果是对了，大了，小了
print('--------------')
num = 35
for _ in range(1,4):
n = int(input('请猜：'))
if n==num:
print('猜对了')
#退出for，结束
break
elif n>num:
print('猜大了')
else:
print('猜小了')
# 输入5个学生的年龄，求平均值
# 求两个值的最大公约数

5.3.3 循环中的break、continue、else
break:中断指令，也使用在循环中，结束当前所在层的循环

#break:中断指令，当前所在层的循环
#跑10圈 7圈跑不动了，要求退出--break
for i in range(1,11):# [1,2,3,4,5,6,7,8,9,10]
if i==7:
print(f'跑到第{i}圈，实在跑不动了，要求退出')
break
print(f'跑了{i}圈')
#也可以使用在while中
i= 1
while i<=10:
if i==7:
print(f'跑到第{i}圈，实在跑不动了，要求退出')
break
print(f'跑了{i}圈')
i+=1
#练习：QQ登录(2890993,8888) ，有3次机会，如果某一次登录成功了，可以直接退出

continue:中断指令，也使用在循环中，结束本轮循环

#continue 结束本轮循环，之后的代码不再执行，继续下一轮的循环
#跑10圈 7圈跑不动了，休息一圈，下一圈跟着跑---continue
for i in range(1,11):
if i==7:
print('实在跑不动了，下一圈再跟着跑')
continue
print(f'跑了{i}圈')
# 统计5个学生成绩80分以上的人数
count=0
for i in range(1,6):
score = int(input(f'请输入第{i}个学生成绩:'))
# if score>=80:
# count+=1
if score<80:
continue
count+=1
print(f'{count}个学生成绩大于80')

else：和while/for-in搭配使用，不碰到break退出时才会执行到的代码

# else 和while/for-in搭配使用，不碰到break退出时才会执行到的代码
i= 1
while i<=10:
# if i==7:
# print(f'跑到第{i}圈，实在跑不动了，要求退出')
# break
print(f'跑了{i}圈')
i+=1
else:
print('正常完成')
# 输入一个数（2-100），判断是否是质数
num = int(input('输入一个数（2-100）:'))
# [2,num) 看是否有能被num整除的，如果有，则不是质数。如果一个都没有，则是质数
# for i in range(2,num):
# if num%i==0:
# print('不是质数')
# break
# else:
# print('是质数')
print('-------其它语言中借助布尔值来实现-----')
flag = True # True 是质数 False 不是质数
for i in range(2,num/2):
if num % i == 0:
flag = False
break
if flag:
print('是质数')
else:
print('不是质数')

5.3.4 双重循环：
一个循环嵌套在另一个循环中
外层循环执行一轮，内层循环执行一遍 —>双重循环要执行的次数

# 计算3个班5个学生的平均成绩
# 外层循环控制班数
# 内层循环控制一个班有多少学生
# 外层循环执行一轮，内层循环执行一遍 --->双重循环要执行的次数
j = 1
while j<=3:
print(f'第{j}个班：')
i = 1
sum = 0
while i <= 5:
score = int(input(f'请输入第{i}个学生的成绩:'))
sum += score
i += 1
avg = sum / 5
print(f'平均成绩为{avg}')
j+=1
print()
# 输出2-100之间的质数
# break、continue、else都一样

打印图形练习

'''
*****
*****
*****
'''
# 外层循环控制行数
# 内层循环控制列数
row = 7
col = 4
for j in range(1,row+1):
for i in range(1, col+1):
print('*', end='')
print()
'''
11111
22222
33333
'''
print()
row = 3
col = 5
for j in range(1,row+1):
for i in range(1, col+1):
print(j, end='')
print()
'''
123456
123456
123456
'''
'''
*
**
***
****
*****
'''
'''
分析
# 外层 i [1,5]
# 内层 j [1,i]
i j
1 [1,1]
2 [1,2]
3 [1,3]
'''
print()
for i in range(1,6):
for j in range(1,i+1):
print('*',end='')
print()
'''
*****
****
***
**
*
'''
'''
外层 i [1,5]
内层 j [1,6-i]
i j
1 [1,5]
2 [1,4]
3 [1,3]
'''
'''
外层 i [5,1]
内层 j [1,i]
i j
5 [1,5]
4 [1,4]
3 [1,3]
'''
'''
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=20
...
'''
'''
*
***
*****
*******
*********
'''
'''
外层：i [1,5]
内层：空格j [1,5-i] * k[1,2*i-1]
i j k
1 [1,4] [1,1]
2 [1,3] [1,3]
3 [1,2] [1,5]
4 [1,1] [1,7]
5 [1,0]
'''
for i in range(1,6):
for j in range(1,5-i+1):
print(' ',end='')
for k in range(1,2*i):
print('*',end='')
print()

5.3.4 循环作业
1、求两个数最大公约数
参考链接：https://www.cnblogs.com/schips/p/10658253.html

# 最大公约数就是能被两个数整除的最大数
# 穷举法
m = 24
n = 36
# 1、先求两个数的最小数
min = m
if min<n:
min=n
num=1
# for i in range(1,min+1):
# if m%i==0 and n%i==0:
# num=i
for i in range(min,0,-1):
if m % i == 0 and n % i == 0:
num=i
break
print(f'最大公约数就是{num}')
#辗转相除法 求最大公约数
a = 48
b = 24
if a<b:
a,b=b,a
while True:
c=a%b
if c==0:
print(f'最大公约数是{b}')
break
else:
a=b
b=c

2、整数反转

#整数反转：如123，输出543
'''
123 ---321
123%10--- 3 =0*10+3
123//10--12
12%10 -- 2--32=3*10+2
12//10 --1
1%10 -- 1---321=32*10+1
1//10 -- 0
'''
num = 12321
temp = num
num2=0
while True:
yu=num%10
# print(yu,end='')
num2=num2*10+yu
num=num//10
if num==0:
break
print(num2)
if num2==temp:
print(f'{temp}是回文数')
else:
print(f'{temp}不是回文数')
#判断一个整数是否是回文数 121--121 12321--12321 abcba

3、1~10之间的整数相加，得到累加值大于20的当前数 1+2+3+4…加到几和超过20

sum = 0
for i in range(1,11):
sum+=i
if sum>20:
print(f'加到{i}就超过20了')
break

#5、输出10000以下的完全数。如果一个正整数等于除它本身之外其它所有除数之和，就称之为完全数。
#如6就是第一个完全数，因为6=1+2+3
for i in range(1,10000):
sum = 0
for j in range(1,i):
if i%j==0:
sum+=j
if sum==i:
print(i)

第六章 容器

变量-单一数据
容器-存储多个数据，提供了一些操作数据的方法

6.1 列表list

特点：
元素的数据类型是不受限制的，可变长，有索引，有序，可重复
参考动态数组
创建:

# 创建
# 1、用[]
# 可以存储各种类型的数据，一般建议大家存同种类型的数据
lst = [1,2,3,'hello']
print(lst)
print(type(lst))
lst2 =[] #空列表
print(lst2,bool(lst2))
# 2、list() 内置函数--把其它类型转换成列表
lst3 = list([10,20,30])
print(lst3,type(lst3))
lst4 = list()
print(lst4)
# 3、列表生成式
lst5=[i*i for i in range(1,11)]
print(lst5)

获取元素：

# 获取列表中的数据
# 列表是有索引 ：正向索引：[0,len-1] 负向索引 [-len,-1]
#获取单个元素 :列表名[索引]
# list index out of range 索引越界
lst = [10,20,30,40,50,60]
# print(lst[6])
# 获取多个元素：切片 列表名[start:end[:step]]
# start 起始索引，默认值0
# end 结束索引，默认值len
# 切片的范围：[start,end)
# 切片的结果是原列表片段的复制，不影响原列表
# step 步长，可以省略，默认值是1
# step为正值：start默认值0，end默认值len
# step为负值：start默认值末尾 end默认值开头
lst2=lst[::-1]
print(lst2)
# 遍历 for-in不能做修改
print('-------for in----------')
for i in lst:
i=0
for i in lst:
print(i)
print('--------while---')
# index =0
# while index
# lst[index]=0
# index+=1
index =0
while index<len(lst):
print(lst[index])
index+=1
print('--------enumerate()可以遍历出索引和值')
for index,value in enumerate(lst):
# lst[index]=12
print(index,value)
# 根据元素，查找索引位置
# 列表名.index(查找的元素) 返回第一个找到的元素位置 如果找不到，报错：10 is not in list
lst = [1,2,3,4,5,1,1,1]
print(lst.index(1))
# in/not in 判断某个元素是否存在列表中
print(1 in lst)
print(10 not in lst)

添加

# 添加
# 添加单个元素
# append() 在末尾追加1个元素
lst = [1,2,3,4,5]
print(lst,id(lst))
lst.append(0)
print(lst,id(lst))
# str='hello'
# print(str,id(str))
# str = str+'world'
# print(str,id(str))
# insert(index,ele) 指定索引插入，索引太大，直接加在末尾
lst.insert(1,0)
print(lst)
# 添加多个元素
# 列表的合并
lst2 = [55,44,33,22,11]
# print(lst*2)
# lst =lst+lst2
print(lst)
# extend 扩展，合并
lst.extend(lst2)
print(lst)
# 切片
lst[0:2]=[11,22,33]
print(lst)

修改

# 修改单个元素
lst = [1,2,3,4,5]
lst[1]=90
print(lst)
#修改多个值：切片
lst[4:]=[8,23,15]
print(lst)

删除

# 删除
# 删除单个元素
# remove(ele) 按对象删除,如果找不到，则报错list.remove(x): x not in list
lst = [11,22,33,44,55]
lst.remove(22)
print(lst)
#pop(index) 按索引删除,不写index，删除最后一个元素
lst.pop()
print(lst)
# del 列表名[index]
del lst[0]
print(lst)
#清空 clear()
lst.clear()
print(lst)
# del 列表名 ，删除之后，不能再使用此对象,
del lst
print(lst)#name 'lst' is not defined

其它

# 统计
# len(列表) 统计元素个数
lst = [1,2,3,4,5,1,2,1]
print(len(lst))
# 列表名.count(元素) 统计列表中某个元素出现的次数
print(lst.count(1))
# max()求最大值
# min() 求最小值
print(max(lst))
#排序 列表名.sort() 默认升序，如果想降序,reverse=True ----在原列表上排序
# lst.sort(reverse=True)
print(lst)
# sorted() 会开辟新的空间，产生新的列表
lst=sorted(lst,reverse=True)
print(lst)
#反转 reverse()

综合案例

'''
*******学生管理系统*********
1、添加学生
2、查询学生
3、修改学生信息
4、删除学生
5、查询所有学生信息
6、查询学生人数
7、退出
**************************
'''
names=[]
while True:
print('*******学生管理系统*********')
print(' 1、添加学生')
print(' 2、查询学生')
print(' 3、修改学生信息')
print(' 4、删除学生')
print(' 5、查询所有学生信息')
print(' 6、查询学生人数')
print(' 7、退出')
print('**************************')
choice= int(input('请选择'))
if choice==1:
name=input('请输入要添加的学生姓名')
names.append(name)
print('添加成功')
elif choice==2:
name = input('请输入要查询的学生姓名')
if name in names:
print('有这个学生')
else:
print('查无此人')
elif choice==3:
name = input('请输入要修改的学生姓名')
try:
index = names.index(name)
newName = input('请输入要修改后的学生姓名')
names[index]=newName
print('修改成功')
except:
print('没有找到这个学生')
elif choice==4:
name = input('请输入要删除的学生姓名')
try:
names.remove(name)
print('删除成功')
except:
print('没有找到这个学生')
elif choice==5:
print('所有的学生信息如下：')
names.sort()
for n in names:
print(n,end=' ')
elif choice==6:
length = len(names)
print(f'学生总人数为{length}')
elif choice==7:
print('谢谢使用，再见')
break
print()

6.2 元祖tuple

特点：
1 不可变的序列 特点：不可增删改，修改后，地址会发生改变
2 参考定长数组,
3 有索引
4 有序
5 元素不限制类型
创建

s ='hello'
print(s,id(s))
s =s +'world'
print(s,id(s))
# 可变序列来说，可以增删改查，地址不会发生改变
lst = [1,2,3,4]
print(lst,id(lst))
lst.append(0)
print(lst,id(lst))
#创建
# 1、使用() ，小括号可以省略,只有一个元素时，末尾加上逗号
print('-------------------')
t = (1,2,3,'hello',[1,2,3])
print(t,type(t))
t = ()
print(t,type(t))
t2 = 'hello',
print(t2,type(t2))
# 2、使用内置函数 tuple()
t3 = tuple()
print(t3,type(t3))
t3 = tuple((11,22,33,'hello'))
print(t3,type(t3))
lst = [5,4,3,2,1]
t4 = tuple(lst)
print(t4,type(t4))
lst2 = list(t3)
print(lst2,type(lst2))
t5 = tuple(range(6))
print(t5,type(t5))
# 2、元组没有生成式
# t6 = (i for i in range(6))
# print(t6,type(t6))

获取元素

# 获取单个元素：索引,不存在，则报错
t =(1,2,3,4,5)
print(t[2])
# 获取多个元素：切片 对象名[start:end:step]
print(t[1:4])
# 遍历
for i in t:
print(i)
print('-------------')
for index,value in enumerate(t):
print(index,value)
# in/not in
print(1 not in t)
# index()
print(t.index(5))
# len()
print(len(t))

不能做的事情

# 不能增删改
# 改
# 元组中的元素地址是不能改的
# 元组中的元素如果是可变对象，通过可变对象的增删改查，是可以改变可变对象中的元素的
t = (1,2,[3,4])
# t[0]=0
print(t[2],type(t[2]))
# t[2][1]=3
lst=t[2]
lst[1]=3
print(t[2],type(t[2]))
print(t)
# 增
# 删
# 排序 'tuple' object has no attribute 'sort'
t2=(23,1,4,56)
# t2.sort()
# print(t2)
t2=sorted(t2)
print(t2) #[1, 4, 23, 56] 返回了列表

6.3 集合set

特点：
1 不重复，无序
2 参考数学上的集合：不重复，无序
3 底层实现：哈希表
4 集合存储的对象都是不可变对象
5 没有索引
6 集合是没有value的字典

# 创建
# 1、使用{}
s = {1,2,3,1,1,1,1,64,'hello',(2,3)}
print(s,type(s))
#unhashable type: 'list'
# 集合存储的对象都是不可变对象
# s = {} #{}  不能创建空集合
# print(s,type(s))
#2、使用内置函数 set()
s2 = set({2,3,4,5})
print(s2,type(s2))
s2 =set([1,5,23,2,5])
print(s2,type(s2))
s2 = set((1,2,3))
print(s2,type(s2))
s2=set(range(6))
print(s2,type(s2))
s2=set('hello')
print(s2,type(s2))
s2 =set()
print(s2,type(s2),bool(s2))
# 3、使用生成器
s3 = {i*i for i in range(3)}
print(s3,type(s3))

获取元素

# 集合 获取元素
# 没有索引，不能索引操作
# 不能使用切片
# 遍历
s = {23,1,2,34,56}
for i in s:
print(i)
# in/not in 判断是否存在
print(23 in s)

增删改

# 集合 可变序列
# 增删改
# 增
s = { 10,20,30,40}
# 增加一个元素 add()
s.add(68)
print(s)
# 增加多个元素 update(容器对象)
s.update([1,2,3])
print(s)
s.update((11,22,33))
print(s)
s.update({111,222,333})
print(s)
# 删除
print('-----------')
# remove(ele) 如果对象不存在，会报错KeyError: 100
s.remove(10)
print(s)
# discard(ele) 如果对象不存在,无效果，不报错
s.discard(30)
print(s)
# clear() 清空
# s.clear()
# 修改==先删再添
s.remove(222)
s.add(888)
print(s)

其它操作

# 集合 其它操作
# 获取长度
s ={ 68,2,3,4,5}
l = len(s)
print(l)
# max() min
m = max(s)
print(m)
# sort
print(s,id(s))
s=sorted(s)# 排序后是列表
print(s,id(s),type(s))

集合在数学方面的操作

# 集合数学方面的操作
a = {1,2,3}
b = {1,2,4}
#交集 intersection()
print(a.intersection(b))
#并集 union()
print(a.union(b))
#差集difference()
print(a.difference(b))#{3}
print(b.difference(a))#{4}
#对称差集 symmetric_difference()
print(a.symmetric_difference(b))#{3, 4}
# 集合间的关系
a = {1,2}
b = {1,2,4}
# 是否是子集 issubset()
print(a.issubset(b))#True
# 是否是超集 issuperset
print(b.issuperset(a))#True
# 是不是没有交集 isdisjoint()
print(a.isdisjoint(b))

6.4 字典dict

特点：
1、字典中的所有元素都是一个键值对，key不允许重复，value可以重复
2、无序
3、key必须是不可变对象
4、字典也可以根据需要动态地伸缩
5、字典会浪费较大的内存，是一种使用空间换时间的数据结构

创建：

#创建
# 使用{key:value,key:value}
# 键不可变，必须唯一
# 值类型不受限制，可重复
# 键--值 1-1或多对1
d = {'name':'zhangsan','age':20}
print(d,type(d))
d ={}
print(d,type(d))
d={10001:'zhangsan',10001:'lisi'}
print(d)
d={'name':'zhangsan','nickname':'zhangsan'}
print(d)
# 2、使用内置函数 dict()
d2 = dict()
print(d2,type(d2))
d2 = dict({'name':'zhangsan','nickname':'zhangsan'})
print(d2,type(d2))
# 3、字典推导式
names = ['zhangsan','lisi']
ages = [16,18]
# zip() 可以将两个列表打包，生成元组
print('-----------------')
z = zip(names,ages)
for item in z:
print(item)
print('-----------------')
d3 = { name:age for name,age in zip(names,ages)}
print(d3,type(d3))

获取元素

# 字典 ：获取元素
# 根据key获取值
d = {'name':'Jack','age':23}
#1、d[key] ,key不存在，就报错 KeyError: 'name2'
print(d['name'])
#字典名.get(key) key不存在的话，就返回None ,可以给出默认值
print(d.get('name')
print(d.get('name2','游客'))
#遍历
dk = d.keys()
print(dk,type(dk))
dv = d.values()
print(dv,type(dv))
di = d.items()
print(di,type(di))
print('-------遍历key-----推荐----')
for i in d:
print(i,d[i])
print('-------遍历key2---------')
for i in d.keys():
print(i)
print('-----------遍历值')
for value in d.values():
print(value)
print('-----------遍历键值对')
for item in d.items():
print(item[0],item[1])
for key,value in d.items():
print(key,value)
# print('-----------遍历键值对3')
# for key,value in enumerate(d):
# print(key,value)
# in / not in 判断key是否存在
print('name2' not in d) #True

增删改

# 字典 增删改
# 增
d ={'name':'Tom'}
d['age']=24
print(d)
#改
d['name']='Mary'
print('d')
d = {'10001':['Jack',18,'1889990990']}
d['10002']=['MeiMei',16,'1660009878']
print(d)
#删除
del d['10002']
print(d)
d.clear()
print(d)

6.5 总结

列表：有序，可重复，可变长，有索引，任意类型数据 []
元组：有序，可重复，不可变，有索引，任意类型数据 ()
集合：无序，不重复，可变长，无索引，不可变数据， {}
字典：无序，key不重复，value可重复，可变长，无索引，有键，键值对（key不可变数据）{}

第七章 字符串

# 字符串
s = 'python,python'
#index 从左往右，第一个出现该字符/串的位置 ,如果不存在，则报错ValueError: substring not
found
print(s.index('py'))
#rindex() 从右往左，第一个出现该字符/串的位置 ,如果不存在，则报错ValueError: substring
not found
print(s.rindex('py'))
#find 从左往右，第一个出现该字符/串的位置 ,如果不存在，返回-1
print(s.find('py3'))
#rfind 从右往左，第一个出现该字符/串的位置 ,如果不存在，返回-1
print(s.rfind('py3'))
# 判断
print('-------------')
s2 = 'sss'
#isalpha() 判断字符串是否全是字母
print(s2.isalpha())
#isdecimal() 是否全是十进制的数字
print(s2.isdecimal())
#isnumeric() 包含中文数字，罗马数字等等
print(s2.isnumeric())
#isalnum() 是否全是字母或数字
print(s2.isalnum())
print('中文'.isidentifier())#True
#大小写转
s3 = 'Python'
print(s3.upper())
print(s3.lower())
#比较
# == 比较内容
s4 ='Python'
print(s3==s4)
# is 比较地址，也就是比较id
print(s3 is s4) #True
print(id(s3),id(s4))
'''
驻留机制的几种情况
1字符串长度为0/1
2、符合标识符的规则
3、[-5,256]
'''
# 字符串的拆分 split(分隔符)--返回拆分后的列表
s='hello,python'
s2=s.split(',')
print(s2,type(s2))
#字符串的合并 分隔串.join(可迭代对象) ---返回合并后的字符串
s3 = '/'.join(s2)
print(s3,type(s3))
#字符串的替换
s4='hello,python'
s5=s4.replace('python','Java')
print(s5)
s6='http://www.baidu.com'
# startswith() 是否以xxx开头
print(s6.startswith('http:'))
print(s6.endswith('com'))

第八章 函数

8.1 函数入门

什么是函数？函数就是完成特定功能的一段代码
为什么需要函数？复用代码、隐藏实现细节、提高可维护性、提高可读性
创建函数

def 函数名([参数列表])：
函数体
[return返回值]

函数调用：本质上就是在执行函数体

def show():
print('大家好')
print('我叫Monkey')
print('今年6岁啦')
print('请大家多多关照')
show()
print('程序结束')

8.2 函数的返回值

1）可选项，
2）需要给调用者返回数据，使用return+数据
3）可返回多个数据，以元组返回—python独有的
4）如果不需要返回数据，可以return 语句。
5）函数体中可以根据条件判断，通过return提前结束函数

#有1个返回值
def show():
return '我叫Monkey,今年6岁'
s=show()
print(s)
print(show())
#返回两个值
def show():
return 6,'hello'
s=show()
print(s) # 输出 (6,'hello')
s,t=show()
print(s,t) # 输出6,'hello'

8.3 函数的参数

当完成特定功能，需要调用者提供数据的时候，可以给函数定义参数
函数定义的时候，参数叫形式参数，简称形参列表：
函数调用的时候，参数叫实际参数，简称实参列表, 实参个数需和形参个数一致

# 计算两个数的和
def getSum(num1,num2): #num1,num2 形参列表
return num1+num2
s=getSum(13,5) #13,5 实参列表
print(s)

参数传递

在函数体中，形参重新赋值，不会影响到实参

在函数体中，修改可变对象中的元素，会影响到实参

# 在函数体中，形参重新赋值，不会影响到实参
def f1(num):
num=13
a=10
f1(a)
print(a) #10
print('-----------')
def swap(m,n):
temp=m
m=n
n=temp
x=14
y=45
swap(x,y)
print(x,y) # 14,45
print('-----------')
s='hello'
s.replace('h','H')
print(s) #hello
print('-----------')
def f2(lst):
lst=[1,2,3]
lst2=[4,5,6]
f2(lst2)
print(lst2) #[4,5,6]
print('-----------')
s = {-3,89,23,-1}
for i in s:
if i<0:
i=0
print(s)
print('------参数是可变对象,在函数体中，修改可变对象，会影响到实参------')
def f2(lst):
lst[0]=99
lst2=[4,5,6]
f2(lst2)
print(lst2)
print('-----------')
d = {'a':12,'b':20}
for key,value in d.items():
if value<18:
# value=18
d[key]=18
print(d)

参数的类型
位置实参：实参按照顺序依次传递给形参

def f1(name,age):
print(name,age)
a='Mike'
b=12
f1(a,b)
# 使用可变容器统一传递参数,需要使用*，依次取出可变序列中的元素按照位置实参传递
lst =['Tom',16]
f1(*lst)

关键字实参：按照形参名传递，与顺序无关
可以与位置参数混用，但位置实参在前，关键字实参在后

def f1(name,age):
print(name,age)
f1(name='Jack',age=18)
f1(age=18,name='Jack')
#使用**，可以依次将字典中的元素按照关键字实参传递
d = {'name':'Monkey','age':6}
f1(**d)

默认值形参

#默认值形参,可以不传递,如果传递，以实参优先
#默认参数必须要指向不可变对象
def f1(a,b=0):
print(a,b)
f1(12)#因为b有默认值，可以不传递
f1(12,6)
print('',end='')# print()函数的end参数也是有默认值的，默认为\n

可变个数的形参

#可变个数的位置形参,前面加*,形参会以元组的方式接收
print('--------------')
print('hello','world','')
def f2(*nums):
print(nums)
f2(1,2,3,4)
f2()
#可变个数的关键字形参,前面加**,形参会以字典的方式接收
print('----------')
def f3(**kwargs):
print(kwargs)
f3(name='Monkey',age=6,phone='9999999998')
d={'name':'Monkey','age':6,'phone':'9999999998'}
f3(**d)
# 参数的顺序：位置参数--默认值参数--关键字参数
# 一般一个函数中，可变个数的位置形参只有一个，可变个数的关键字形参也只有1个

8.4 递归

递归是一种算法思想，就是函数自己调用自己
把一个大的复杂的问题，化简成一个跟他相似但规模更小的问题
递归的好处：想起来简单，编码也简单
递归的缺点：内存占用大,效率低
递归的编码：
1、递归公式-- f(n)=f(n-1)+n
2、临界条件 f(1)=1

# 1+2+3+4+5
# f(num)---功能计算1+。。。+num和
'''
f(5) = f(4) +5 return 1+2+3+4+5
f(4) = f(3) +4 return 1+2+3+4
f(3) = f(2) +3 return 1+2+3
f(2) = f(1) +2 return 1+2
f(1) = 1 return 1
分递和归两个过程。
'''
def fsum(num):
if num==1:
return 1
else:
sum=fsum(num-1)+num
return sum
print(fsum(5))

斐波那契数列、兔子数列
从第三项开始，每一项都是前面两项数字的和，如 1,1,2,3,5,8,13…

#输出前100项的斐波那契数列项
#第n项的数字是多少 --fibo(n)
'''
fibo(1)=1
fibo(2)=1
fibo(n)=fibo(n-1)+fibo(n-2)
'''
def fibo(n):
if n==1 or n==2:
return 1
else:
return fibo(n-1)+fibo(n-2)
for i in range(1,50):
print(fibo(i))
'''
使用循环来解决，效率明显提高
num1=1
num2=1
num3=num1+num2
num1=num2
num2=num3
num3=num1+num2
'''
def fibo2(n):
num1 = 1
num2 = 1
num3 = num1 + num2
print(num1)
print(num2)
print(num3)
i=4
while i <= n:
num1 = num2
num2 = num3
num3 = num1 + num2
print(num3)
i+=1
fibo2(50)

汉诺塔

'''
汉诺塔
有三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。
需求：把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
'''
def havo(start,middle,end,n):
if n==1:
print(start+'--》'+end)
else:
# 1、前n-1个 从start，经end，移动到middle
havo(start,end,middle,n-1)
# 2、把第n个盘子，从start，移动end
print(start + '--》' + end)
# 3、前n-1个，从middle，经start，移动end
havo(middle, start, end, n-1)
havo('a','b','c',64)

8.5 全局变量和局部变量

# 全局变量 定义在函数外部的变量
a=1
# 局部变量:定义在某些代码块中的变量
def f():
m=12
# 在函数内部，只能读，不能改全局变量。
def f2():
# global a #使用global修饰，则可以修改全局变量，但是不提倡
# a+=1 #函数体内不能修改全局变量
a='hello' # 局部变量可以和全局变量重名,但是局部变量的优先级更高
print(a)

8.6 lambda表达式

参考链接：
https://zhuanlan.zhihu.com/p/80960485
https://zhuanlan.zhihu.com/p/65485925
https://zhuanlan.zhihu.com/p/257851876

第九章 异常处理

try…except…else…finally

try:
# 可能出现异常的代码
num1 = int(input('请输入一个整数')) # ValueError: invalid literal for int()
with base 10: 's'
num2 = int(input('请输入一个整数'))
result = num1 / num2 # ZeroDivisionError: division by zero
print(result)
except ValueError:
# 出现异常的处理方法
print('应该输入数字')
except ZeroDivisionError:
# 出现异常的处理方法
print('除数不能为0')
else:
# try块中正常执行结束，就执行else,如果有异常，则不执行
print('else子------')
finally:
# 不管是否出现异常，都会执行的代码--释放资源，收场
print('finally---------')
print('程序结束')
# return语句也不能阻挡finally块代码的执行
def f():
try:
print('try')
a=1/0
return 1
except:
print('execpt---')
return -1
finally:
print('finally---'）

第十章 面向对象

10.1 面向过程与面向对象
面向过程：算法，1,2,3–围观上操作细节
面向对象：宏观上把控
面对过程和面向对象不是相互对立的，而是相辅相成的。
支持面向过程的语言：C、C++
支持面向对象的编程语言：C++,c#,Java,Python,Javascript

10.2 面向对象入门
面向对象：
模拟现实世界
对象：
万事万物皆对象。
对象就是一个真实的存在。
例如：张三
静态的特征：姓名，年龄，性别，身份证号，电话号码

类：

现实世界，我们会自然而然地对事物进行归类。
具有相同静态特征和动态特征的对象，统称为类

类和对象的关系：

类是抽象的，对象是具体的。
类是集合，对象是个体。
类和对象不是整体和局部的关系。牛-牛头
类可当作一种数据类型。由类创建出来的对象，叫实例。
面向对象编程的思路：
1、抽象出类
2、抽象出跟业务相关的静态特征（属性）：name,age,phone
抽象出跟业务相关的动态特征（方法）：gotoClass() ，run()
3、创建对象–实例化对象
对象.属性
对象名.方法（）

Python中的面向对象：

class Student:
#self 当前对象 ，类似java中的this
def __init__(self,name,age):
self.stu_name=name #实例属性
self.stu_age=age
#实例方法
def show(self):
print(self.stu_name+"\t"+str(self.stu_age))
# 类对象
print(id(Student)) #2054725717664
# 实例化对象 对象名=类名(name,age)
stu = Student('张三',21)
# 通过.操作符操作属性
print(stu.stu_name)
stu.stu_name='张伟'
print(stu.stu_name)
# 通过.操作符操作方法
stu.show()
#不同的对象拥有各自的属性空间
stu = Student('张三',21)
stu2 = Student('高飞',18)
stu.show()
stu2.show()

python 支持动态属性和方法

class Student:
def __init__(self,name,age):
self.stu_name=name #实例属性
self.stu_age=age
#实例方法
def show(self):
print(self.stu_name+"\t"+str(self.stu_age))
stu = Student('张三',21)
stu2 = Student('高飞',18)
stu.phone='13500000000'
print(stu.phone)
# print(stu2.phone) #'Student' object has no attribute 'phone'
def run():
print('跑。。。。')
stu.stu_run=run
stu.stu_run()
stu2.stu_run()

类属性和类方法

class Student:
grade='计科2班'
@classmethod
def showGrade(cls):
print(f'我们是{cls.grade}')
# 类属性和类方法是属于类的，建议通过类名来调用
# 类属性和类方法被该类的所有实例对象共有，通过对象名来操作的也是共有的那一份

案例：

# 定义一个MP3类 属性：品牌 方法：下载音乐，播放下载的音乐,充电
class Cell:
def charge(self):
print('电池在充电。。。。')
class MP3:
def __init__(self,brand):
self.brand=brand
def download(self):
return '小苹果'
def play(self):
print(self.brand+'的MP3正在播放'+self.download())
def charge(self):
# 利用电池充电
c = Cell()
c.charge()
mp3 = MP3('索尼')
mp3.download();
mp3.play()
mp3.charge()
# 自定义对象容器
class Student:
def __init__(self,name,age):
self.stu_name=name #实例属性
self.stu_age=age
#实例方法
def show(self):
print(self.stu_name+"\t"+str(self.stu_age))
#集合
lst = [
Student('张三',21),
Student('李四',31),
Student('王五',18)
]
stu = Student('赵六',16)
lst.append(stu)
for i in lst:
i.show()
# 排序
lst.sort(key = lambda x:x.age)
for i in lst:
i.show()

10.3 面向对象之封装

封装的目的：保护数据的安全性
封装的含义：
1）广义：类把属性和方法封装在了一起，方法把过程进行了封装
2）狭义：属性私有化，在方法内部操作属性，在类外部调用方法
我们一般强调的是狭义的封装
封装的实现：
1）属性的私有化（加__），
2）添加get、set方法
3）在方法中添加逻辑判断
注：在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面
使用两个__。

class Student:
def __init__(self,name,age):
self.stu_name=name
self.__stu_age=age #其实此属性转换成了：_类名__属性名
def show(self):
print(self.stu_name+"\t"+str(self.__stu_age))
# 读
def get_age(self):
return self.__stu_age
# 写
def set_age(self,age):
if age<0:
# self.__stu_age=0
raise ValueError('年龄不能为负')
else:
self.__stu_age = age
stu = Student('张三',16)
stu.show()
# stu.__stu_age=-7 #
# print(stu.__stu_age)
try:
stu.set_age(-7)
except:
print('好像哪里不对')
print(stu.get_age())

也可以通过property简化封装

class Student:
def __init__(self,age):
self.__age=age
@property #--相当于get方法
def age(self):
print('get---')
return self.__age
@age.setter #--相当于set方法
def age(self,age):
print('set------')
self.__age=age
stu=Student(21)
stu.age=16
print(stu.age)

10.4 面向对象之继承

# 继承--重用代码
# 父类/基类/超类 （公共的属性和方法） 子类/派生类（特定的属性和方法）
# 子类 is a 父类 ---表达的是类的本质
#子类拥有和父类同样的方法，叫重写override
#青出于蓝而胜于蓝
#重载 overload 方法名相同，参数列表不同
#python没有重载
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(f'姓名：{self.name}')
print(f'年龄：{self.age}')
class Student(Person):
def __init__(self,name,age,stu_no):
super().__init__(name,age) # 调用父类的初始化方法
# super(Student, self).__init__(name,age)
# Person.__init__(self,name,age)
self.stu_no=stu_no
def show(self):
super(Student, self).show()
print(f'学号:{self.stu_no}')
class Teacher(Person):
pass
stu =Student('张三',21,'jk1001')
stu.show()
lst =[
Student('Jack',21,'jk1001'),
Student('Apple',16,'jk1002'),
Student('Tom',11,'jk1003')
]
lst.sort(key=lambda x:x.age)
for i in lst:
print('-------')
i.show()
tea =Teacher('张老师',24)
tea.show()

python没有重载

##重载 overload 方法名相同，参数列表不同
#python没有重载
# 因为python是解释性语言，后面定义的方法会覆盖前面的
def f():
return "abc"
def f(a,b):
return a+b
print(f(2,3))

练习

'''
宠物：
属性：昵称，健康值（int）
方法：显示信息，输出各属性值
吃
狗：继承宠物
增加属性：品种strain
重写方法:吃
增加方法：玩飞盘，健康值增加
生病，健康值减少
猫：继承宠物
重写方法：吃
实例化对象进行测试
'''
class Pet:
def __init__(self,name,health):
self.name=name
self.health=health
def show(self):
print(f'昵称:{self.name}')
print(f'健康值:{self.health}')
def eat(self):
print('吃东西。。。')
class Dog(Pet):
def __init__(self,name,health,strain):
super().__init__(name,health)
self.strain=strain
def eat(self):
print('狗吃骨头')
def play(self):
self.health+=10
def get_ill(self):
self.health-=5
class Cat(Pet):
def eat(self):
print('猫吃鱼')
pet =Pet('匿名宠物',0)
pet.show()
pet.eat()
print('--------')
dog =Dog('毛毛',99,'拉布拉多')
dog.show()
dog.eat()
print('-----')
cat = Cat('咪咪',90)
cat.show()
cat.eat()

python支持多继承

# python支持多继承-1个子类可以有多个父类
# 当多继承时，多个父类都有同样的方法，会按照继承列表依次查询（广度优先）
class A:
def f1(self):
print('A f1----')
class B:
def f1(self):
print('B f1----')
def f2(self):
print('B f2--------')
class C(B,A):
pass
c = C()
c.f1()
c.f2()

所有类都是object类的子类

# 如果显式地写出继承谁，此类就是谁的子类，
# 如果没有写出继承谁，此类默认会去继承object
# 所有的类都是object的子类
# 继承具有传递性，所有自定义的类都从object类中继承了一些方法
class Student(object):
pass
class SubStudent(Student):
def __init__(self,name):
self.name=name
print('init-----')
# def __new__(cls, *args, **kwargs):
# print('new----------')
# obj=super().__new__(SubStudent)
# return obj
def __str__(self):
return f'姓名：{self.name}'
ss= SubStudent('Jack')
print(ss)
print(dir(ss))#dir(ss) 查看ss所有的属性和方法
'''
'__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__',
'__subclasshook__', '__weakref__'
'''
#__init__() 初始化属性
#__new__() 创建对象，开辟内存空间
#__str__() 一般自定义类都会重写此方法，利用print直接输出
#__repr__() 列表及字典等容器总是会使用此方法，故也建议重写
#如果你没有添加 __str__ 方法，Python 在需要该方法但找不到的时候，它会去调用 __repr__ 方法。
因此，推荐在自定义类时至少添加一个 __repr__ 方法，这能保证类到字符串始终有一个有效的自定义转换
方式。

10.5 面向对象之多态

# 多态--多种形态
# 在继承的基础上，重写，父类的引用指向子类的对象，----多态
# python动态语言，不在乎数据类型，在乎有没有这样的行为，所以不一定要继承，不一定要重写，只要有
方法就行
class Pet:
def eat(self):
print('吃东西')
class Dog(Pet):
def eat(self):
print('狗吃骨头')
class Cat(Pet):
def eat(self):
print('猫吃鱼')
class Bird(Pet):
def eat(self):
print('鸟吃虫子')
class Manager:
# def feedDog(self,dog):
# dog.eat()
#
# def feedCat(self,cat):
# cat.eat()
#
# def feedBird(self,bird):
# bird.eat()
def feed(self,pet):
pet.eat()
dog = Dog()
cat = Cat()
manager = Manager()
manager.feed(cat)
print('----------------')
class Baby:
def eat(self):
print('宝宝吃奶')
baby = Baby()
manager.feed(baby)
'''
练习
模拟员工回家
员工类：goHome(vechile)
交通工具：
Vechile:run()
Bike
Bus
'''

10.6 对象的拷贝

class Grade:
def __init__(self,name):
self.name=name
class Student:
def __init__(self,name,grade):
self.name=name
self.grade=grade
def __str__(self):
return f'{self.name}属于{self.grade}'
# = 赋值运算符
# 拷贝的是对象的地址，拷贝后的对象和原对象指向同样的内存空间
# 影响：通过拷贝后的对象的修改，都会影响回原对象
grade =Grade('计科二班')
stu = Student('Jack',grade)
stu2=stu
print(stu,id(stu))
print(stu2,id(stu2))
stu2.grade.name='计科3班'
print(stu.grade.name)
stu2.grade=Grade('计科4班')
print(stu.grade.name)
# 浅拷贝--对象空间中的数据，不管是可变对象还是不可变对象都把其地址拷贝，也就是不新开空间
# 影响：拷贝后的对象，如果修改可变对象的属性，会影响回原对象；如果修改不可变对象，不会影响原对象
print('---------')
import copy
stu3 = copy.copy(stu)
stu3.grade.name='5班'
print(stu.grade.name)
stu3.name='Tom'
print(stu.name)
print('-------------')
#深拷贝-对象空间中的数据，如果是可变对象，会对其指向的空间中的数据进一步拷贝
#影响：拷贝后的对象，对其修改，不会影响原对象
stu4 = copy.deepcopy(stu)
stu4.grade.name='6班'
print(stu.grade.name)
stu4.name='Mary'
print(stu.name)
stu4.grade=Grade('0班')
print(stu.grade.name)

10.7 作业讲解

'''
银行卡： 卡号、密码、姓名、余额 Card
方法：取款
本行卡： LocalCard
方法：取款、转账
其它行卡： OtherCard
方法：取款（加收2元手续费）
实例化对象进行测试
'''
class Card:
def __init__(self,no,pwd,name,blance):
self.no=no
self.pwd=pwd
self.name=name
self.blance=blance
def withdraw(self,money):
if self.blance>=money:
self.blance-=money
else:
return -1
#本行卡
class LocalCard(Card):
def transfer(self,money,to_card):
if self.blance >= money:
self.blance-=money
to_card.blance+=money
else:
return -1
#其它行卡
class OtherCard(Card):
def withdraw(self, money):
if self.blance+2 >= money:
self.blance-=money+2
else:
return -1
#实例化对象 no,pwd,name,blance
lc = LocalCard('62221008','111111','Mary',3000)
# r = lc.withdraw(10000)
# if r==-1:
# print('余额不足')
# else:
# print(f'取款成功，当前余额是{lc.blance}')
#转账
# lc2 = LocalCard('622210008','111111','Tom',1000)
# lc2 = OtherCard('622210000','111111','Jackey',200)
# r=lc.transfer(1000,lc2)
# if r==-1:
# print('余额不足')
# else:
# print(f'转账成功，当前余额是{lc.blance}')
# print(f'转入账号的当前余额：{lc2.blance}')
# 其它行卡
lc2 = OtherCard('622210000','111111','Jackey',200)
r = lc2.withdraw(100)
if r==-1:
print('余额不足')
else:
print(f'取款成功，当前余额是{lc2.blance}')

第十一章 模块和包

11.1 模块
模块：1个py文件就是一个模块
包含的内容：类，函数，变量和语句
好处：避免类、函数、变量的重名
提高代码的可维护性
提高代码的可重用性
模块分类：1、系统内置模块 2、第三方模块 3、自定义模块
创建模块：新建.py文件
导入模块 ：import
1)import 模块名 [as 别名]
使用时，模块名.类 模块名.函数 模块名.变量
2)from 模块 import 类/函数/变量
代码中直接使用类、函数、变量

# demo1.py中
def add(a,b):
return a+b
#demo2.py中
import demo1 as d
print(d.add(2, 3))
from demo1 import add
print(add(3, 5))

以主程序形式运行

在每个模块的定义中都包括一个记录模块名称的变量__name__,程序可以核查该变量，以确定他们在哪个模块
中执行。
如果一个模块不是被导入到其它程序中执行，那么他可能在解释器的顶级模块中执行。
也就是说，
当一个模块被导入到其它模块使用时，__name__输出的是自己模块名
如果在自己的模块中调用，输出的是__main__，顶级模块的名字
所以，如果有些代码只想在直接运行本模块时才执行，请添加如下判断：
if __name__ == '__main__':#以主程序形式运行
pass
#demo1.py
def add(a,b):
print('运行在'+__name__)
return a+b
if __name__ == '__main__':#直接运行当前模块
print(add(3,4)) # 以主程序形式运行
#demo2.py
import demo1 as d
print(d.add(2, 3))

11.2 包

类似目录 、管理一些功能的相似的模块
包和目录的区别:包中包含init.py文件
好处：避免模块的重名
导入其它包中的模块，需要：import 包.模块名

# 创建python package
# 在包pack中的test.py中
a=12
#在pack包外的py文件中使用
import pack.test as pt
print(pt.a)

11.3 random模块

学习内置模块的方法：
1）dir(模块名) 查看模块中的成员
2）help(模块名/方法名/类名) 查看对象的帮助文档
3）通过pycharm中的提示功能
4）点击查看源码注释

import random
print(dir(random)) #查看random模块中的成员
'''
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST',
'SystemRandom',
'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__',
'__file__',
'__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos',
'_bisect', '_ceil',
'_cos', '_e', '_exp', '_inst', '_log', '_os', '_pi', '_random', '_repeat',
'_sha512', '_sin',
'_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate',
'choice', 'choices',
'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate',
'lognormvariate',
'normalvariate', 'paretovariate', 'randint', 'random', 'randrange', 'sample',
'seed',
'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate',
'weibullvariate']
'''
help(random.choice) #查看帮助文档
# randint(a,b) 返回[a, b]之间的随机整数
for i in range(10):
print(random.randint(1, 3))
#randrange(start,end,step) 返回[start, end)之间的随机整数,可以自定义步长
for i in range(10):
print(random.randrange(100, 300,100))
random() 返回[0, 1) --产生[1,3]==[1,4)--[0, 1)*3+1
for i in range(10):
print(random.random())
#choice(seq)--本质使用索引--所以参数不能是集合或者字典
s ='1234567890'
lst = [12,34,56,67,78]
t =(12,34,56,67,78)
s ={12,34,56,67,78}
for i in range(10):
print(random.choice(s))

随机产生一个唯一的标识，还可以使用uuid模块

# 随机产生一个不重复的值
import uuid
help(uuid)
'''
If all you want is a unique ID, you should probably call uuid1() or uuid4().
'''
u = uuid.uuid4()
print(u.hex) #68a785fb123242df92cb6f00deb3c123
print(u.int)#216436124549608148511458979176232828659

11.4 math模块

math:提供标准算术运算函数的标准库

import math
print(dir(math))
'''
['__doc__', '__loader__', '__name__', '__package__', '__spec__',
'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb',
'copysign',
'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs',
'factorial',
'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose',
'isfinite',
'isinf', 'isnan', 'isqrt', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2',
'modf',
'nan', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh',
'sqrt', 'tan',
'tanh', 'tau', 'trunc']
'''
# 向上取整 ceil(x) This is the smallest integer >= x.
help(math.floor)
# print(math.ceil(-3.8))
#向下取整 floor(x) the largest integer <= x
print(math.floor(-3.8))
# 四舍五入 ---全局函数round(x)
print(round(-3.5))
# 判断一个数是不是质数 [1，n的平方根]
print(math.sqrt(2))

11.5 time模块

time 时间相关的模块

import time
#获取系统当前时间 （单位 是s）
print(time.time())
#获取当前时间的时间类型 yyyy年mm月dd日
print(time.localtime().tm_year)
# 时间---》字符串
'''
%Y Year with century as a decimal number.
%m Month as a decimal number [01,12].
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%M Minute as a decimal number [00,59].
%S Second as a decimal number [00,61].
'''
s = time.strftime('%Y年%m月%d日 %H:%M',time.localtime())
print(s,type(s))
# 字符串--->时间
t = time.strptime(s,'%Y年%m月%d日 %H:%M')
print(t)
# help(time.sleep)
# sleep
for i in range(5):
print(i)
time.sleep(1)

11.6 目录相关模块

os模块

import os
print(dir(os))
# getcwd()
print(os.getcwd()) #E:\PycharmProjects\day1204
#mkdir() 创建一级目录
os.mkdir('a/b/c/d')
#makedirs() 创建多级目录
os.makedirs('c/d')
#删除一级目录 要求目录必须是空的
os.rmdir('a')
#删除多级目录
os.removedirs('c/d')
#删除文件
os.remove('a/test.py')
#重命名文件或文件夹---移动
os.rename('a/test.py','a/tt.py')
os.rename('a','abc')
os.rename('keqian.py','abc/keqian.py')
#获取目录下的文件或子目录
d = os.getcwd()
lst=os.listdir(d)
print(lst)
import os.path
#遍历指定目录下所有的文件---递归
def get_file(dir):
lst = os.listdir(dir)
for item in lst:
#判断item是文件还是目录
if os.path.isdir(item):
get_file(dir+'/'+item)
else:
if item.endswith('.py'):
print(item)
get_file(d)
print('-----walk--------')
dd=os.walk(d)
for dirpath,dirnames,filenames in dd:
for file in filenames:
if file.endswith('.py'):
print(file)

os.path模块

# os.path 模块 文件或目录相关的操作
import os.path
#isdir() 判断是否是目录
print(os.path.isdir('abc'))
print(os.path.isfile('abc/tt.py'))
#exists(path) 判断目录或文件是否存在
print(os.path.exists('abc/tt.py'))
#把目录和文件名拼接 join(dir,filename)
print(os.path.join('abc', 'tt.py'))
#分离目录和文件名
print(os.path.split('abc/tt.py'))#('abc', 'tt.py')
print(os.path.basename('abc/tt.py'))
print(os.path.dirname('abc/tt.py'))
#分离文件名和后缀
print(os.path.splitext('demo1.py'))

11.7 文件IO操作

文件内容的操作需要通过流来实现
流是有方向的。从内存->外存,叫输出Output，称写操作；从外存到内存，叫输入Input，称读操
作。
按每次读取的数据单元，也可将流分为字符流和字节流。一般文本文件建议以字符方式读写，二进
制文件采用字节方式读写。
文件IO操作步骤：
1、创建流对象
2、读或者写
3、关闭流

'''
注意：1、读取的文件必须存在，不存在则报错
2、mode
'r' open for reading (default) 只读
'w' open for writing, truncating the file first 只写
'a' open for writing, appending to the end of the file if it exists 追
加
'b' binary mode 字节
't' text mode (default)
'+' open a disk file for updating (reading and writing)
rt -读取字符 rb -读取字节 wt-写字符 wb-写字节 a+...
'''
f=open('b/test.txt','rt')
print(dir(f))
#'read', 'readline', 'readlines'
# help(f.read)
# content=f.read() #读取所有
# content= f.readline() #读取一行
content=f.readlines() #读取所有行
print(content)
f.close()

文件的写

# 写模式，文件不存在，可以创建 w,a
f=open('test.txt','w')
f.write('python\n')
f.write('java')
lst = ['1','2','3']
f.writelines(lst)
f.close()

乱码问题：编码格式

# python 中默认的编码是utf-8
# 不同的编码格式，占的内存空间不一样
f=open('test.txt','rt',encoding='gbk')
content=f.read()
print(content)
f.close()

with 语句

'''
with open(file,mode,encoding) as f:
pass
'''
# 复制图片 hetao.jpg
with open('hetao.jpg','rb') as src_file:
with open('hetao2.jpg','wb') as dest_file:
dest_file.write(src_file.read())
#复制视频 1.mp3--2.mp3
with open('1.mp3','rb') as f1:
with open('2.mp3','wb') as f2:
while True:
n = 1024*1024
content = f1.read(n)
if content:
f2.write(content)
f2.flush()
else:
break

对象的序列化和反序列化

 #序列化:对象--->字节序列
# 反序列化 ：字节序列--->对象
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __repr__(self):
return f'{self.name}:{self.age}'
import pickle
help(pickle.load)
# dump(obj,file) -序列化
stu = Student('Mary',16)
pickle.dump(stu,open('stu.dat','wb'))
# 学生管理系统 lst[stu,stu2,stu3]---stulist.dat
lst =[
Student('Mary',16),
Student('Tom',18),
Student('Jack',12)
]
pickle.dump(lst,open('stu.dat','wb'))
# load(file) -反序列化
obj=pickle.load(open('stu.txt','rb'))
print(obj)

11.8 爬虫

爬虫：用程序模拟用户/浏览器，按照一定的规则，批量发送网络请求，批量获取数据
爬虫的价值：
1、流量
2、数据分析，提出解决方案
3、排行榜，百度指数
爬虫能获取所有的数据？
不能。普通用户获取普通的数据。vip访问特有数据
爬虫分类：
通用的爬虫：搜索引擎
聚焦爬虫：代码--精准定位
python 的爬虫
Get:参数都拼接在url后面，显示在地址栏，不太安全，速度快
Post:参数不显示地址栏，相对安全，数据量没限制，速度稍慢
405错误码，请求方法不支持 200 正常返回
User-Agent：客户端的身份
Cookie：存储网站用户的信息
Referer: 从哪个页面跳转过来的
步骤：
1、确定url
2、request 头 +params
1）User-Agent 2）IP代理 3）time.sleep()
3、response 数据：1、html 2、json类型
4、数据解析：1、beautifulSoup (选择器) 2、re正则表达式
5、数据持久化：文件、数据库
6、数据可视化

爬取一个网页/图片/视频

import urllib.request as req
#爬取一个网页
url='http://www.baidu.com/'
response=req.urlopen(url)
with open('baidu.html','wb') as f:
f.write(response.read())
#爬取一个视频
url='https://vd4.bdstatic.com/mda-km7annyxnxam9d8k/sc/mda-km7annyxnxam9d8k.mp4?
v_from_s=hkapp-haokan-suzhou&auth_key=1638606623-0-0-
975934ee23ee8c6a83aa3a939c63bead&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest=
17376_2-3000201_6&klogid=0023449082'
response=req.urlopen(url)
with open('heshang.jpg','wb') as f:
f.write(response.read())

Cookie:携带用户登录的信息

# cookie
import urllib.request as req
headers={
'Cookie': 'PSTM=1636848234; BAIDUID=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BIDUPSID=583693E58AE227377AD2C0255BE81A7C;
__yjs_duid=1_fcbf43df8ca883073f54c3e2668c9a101636899752284;
BAIDUID_BFESS=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BDRCVFR[J6KCWSEUjPm]=jzbQNU_zIP3uA-duhN8uz4WU6; BD_HOME=1; delPer=0; BD_CK_SAM=1;
PSINO=3; BDRCVFR[dG2JNJb_ajR]=mk3SLVN4HKm; BDRCVFR[-pGxjrCMryR]=mk3SLVN4HKm;
BDRCVFR[tox4WRQ4-Km]=mk3SLVN4HKm; BDRCVFR[CLK3Lyfkr9D]=mk3SLVN4HKm;
bdindexid=m7ca82kaivggoqndii4stvi5s7;
__yjs_st=2_YzNjNzVhNjY1YTg2Yzk3ZjcxNzNhZGE2ZGFmMzc3YzgxZjdkZGQ2NTUwZmQ3MjdjNmJmO
TdlMmJhNjA4MjRiYWJlMzQxM2JmYjBlZTMwOTc1MDkxMGI5N2FkZGVlMWY3MDQ2Yzc2NGE3YWJkNjMzN
DVkYzIxYWFlNzljYTBiMmQ1NGEwNDFlMTMzMzUyMWVhZTRiOWNhOWE5ZTI5ZWU3NDViMTg4NGQ3ZmRlM
2NhNzgwN2ZmMzMzMjk5MzEwMDcwMDgxZDQ1MmI1YmQwYjM5MDc5MmI0MjA2ZmRmYTEzOTUyMzk3NDBlY
2ZkMjQ1YWE5MzFkM2U2ZmJiZTRiZTA1ZF83XzBlNmI2ZGYz;
RT="z=1&dm=baidu.com&si=2nnngmj776t&ss=kwrgxahn&sl=f&tt=14xv&bcn=https://fclog.b
aidu.com/log/weirwood?type=perf&ld=1xsk&ul=30lc&hd=30oc";
BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; BD_UPN=12314753;
H_PS_645EC=6389g6iIpVnBbgosEw1V+z2mtlcSRayNkSY60Ndr3HbTT+V1wEj3+h2YN3k;
channel=baidusearch; baikeVisitId=4202b3c7-82fa-4957-ae0d-e3b8bfc09f71;
COOKIE_SESSION=2210_0_6_7_3_12_1_0_3_6_6_3_50012_0_0_0_1638601729_0_1638603935|8
#0_0_1638603935|1; userFrom=ala;
ab_sr=1.0.1_YTM2NTY3OTEyMmJkYTE2ZjI4MGYwOGFmYWM0MDZjMWY3ZGZiNDFkMDE5MDlmNWU2NDA2
M2NmZGFiYTdiZDE0Zjc4ZjBiMjdlYWRmNTZhNjYxY2Y5MGNhNjRiN2ZjMjhjMzZiMmNiYWQyN2JmM2U1
MmJhMTAzMTY3YjI4ZjNlM2ZhODI0NGRlZGYzZjQ5MTBhN2Y5ZjczOTcwYzZlYjM4ZQ==;
H_PS_PSSID=31660_26350; BDUSS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BDUSS_BFESS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BA_HECTOR=0la00l0ha02kal8g6r1gqm8hq0r'
}
url='http://www.baidu.com/'
request=req.Request(url,headers=headers)
response=req.urlopen(request)
with open('baidu2.html','wb') as f:
f.write(response.read())

User-Agent：客户端的身份

# User-Agent
import urllib.request as req
from fake_useragent import UserAgent
url='https://movie.douban.com/'
headers={
'User-Agent':UserAgent().random
# 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36'
}
request=req.Request(url,headers=headers)
response=req.urlopen(request)
with open('douban.html','wb') as f:
f.write(response.read())
#HTTP Error 418: 服务器识别出对方是个程序

请求参数

# params
import urllib.request as req
import urllib.parse as par
from fake_useragent import UserAgent
#单个参数
# kw='风景图片'
# kw=par.quote(kw)
# print(kw)
# url='https://image.baidu.com/search/index?tn=baiduimage&word='+kw
url='https://image.baidu.com/search/index?'
headers={
'User-Agent':UserAgent().random,
'Cookie': 'PSTM=1636848234; BAIDUID=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BIDUPSID=583693E58AE227377AD2C0255BE81A7C;
__yjs_duid=1_fcbf43df8ca883073f54c3e2668c9a101636899752284;
BAIDUID_BFESS=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BDRCVFR[J6KCWSEUjPm]=jzbQNU_zIP3uA-duhN8uz4WU6; BD_HOME=1; delPer=0; BD_CK_SAM=1;
PSINO=3; BDRCVFR[dG2JNJb_ajR]=mk3SLVN4HKm; BDRCVFR[-pGxjrCMryR]=mk3SLVN4HKm;
BDRCVFR[tox4WRQ4-Km]=mk3SLVN4HKm; BDRCVFR[CLK3Lyfkr9D]=mk3SLVN4HKm;
bdindexid=m7ca82kaivggoqndii4stvi5s7;
__yjs_st=2_YzNjNzVhNjY1YTg2Yzk3ZjcxNzNhZGE2ZGFmMzc3YzgxZjdkZGQ2NTUwZmQ3MjdjNmJmO
TdlMmJhNjA4MjRiYWJlMzQxM2JmYjBlZTMwOTc1MDkxMGI5N2FkZGVlMWY3MDQ2Yzc2NGE3YWJkNjMzN
DVkYzIxYWFlNzljYTBiMmQ1NGEwNDFlMTMzMzUyMWVhZTRiOWNhOWE5ZTI5ZWU3NDViMTg4NGQ3ZmRlM
2NhNzgwN2ZmMzMzMjk5MzEwMDcwMDgxZDQ1MmI1YmQwYjM5MDc5MmI0MjA2ZmRmYTEzOTUyMzk3NDBlY
2ZkMjQ1YWE5MzFkM2U2ZmJiZTRiZTA1ZF83XzBlNmI2ZGYz;
RT="z=1&dm=baidu.com&si=2nnngmj776t&ss=kwrgxahn&sl=f&tt=14xv&bcn=https://fclog.b
aidu.com/log/weirwood?type=perf&ld=1xsk&ul=30lc&hd=30oc";
BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; BD_UPN=12314753;
H_PS_645EC=6389g6iIpVnBbgosEw1V+z2mtlcSRayNkSY60Ndr3HbTT+V1wEj3+h2YN3k;
channel=baidusearch; baikeVisitId=4202b3c7-82fa-4957-ae0d-e3b8bfc09f71;
COOKIE_SESSION=2210_0_6_7_3_12_1_0_3_6_6_3_50012_0_0_0_1638601729_0_1638603935|8
#0_0_1638603935|1; userFrom=ala;
ab_sr=1.0.1_YTM2NTY3OTEyMmJkYTE2ZjI4MGYwOGFmYWM0MDZjMWY3ZGZiNDFkMDE5MDlmNWU2NDA2
M2NmZGFiYTdiZDE0Zjc4ZjBiMjdlYWRmNTZhNjYxY2Y5MGNhNjRiN2ZjMjhjMzZiMmNiYWQyN2JmM2U1
MmJhMTAzMTY3YjI4ZjNlM2ZhODI0NGRlZGYzZjQ5MTBhN2Y5ZjczOTcwYzZlYjM4ZQ==;
H_PS_PSSID=31660_26350; BDUSS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BDUSS_BFESS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BA_HECTOR=0la00l0ha02kal8g6r1gqm8hq0r'
# 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36'
}
#多个参数
params={
'tn':'baiduimage',
'word':'风景图片'
}
params=par.urlencode(params)
print(params)
url=url+params
request=req.Request(url,headers=headers)
response=req.urlopen(request)
with open('tupian.html','wb') as f:
f.write(response.read())

post方式请求

# post
import urllib.request as req
import urllib.parse as par
from fake_useragent import UserAgent
url='http://httpbin.org/post'
headers={
'User-Agent':UserAgent().random,
# 'Cookie': 'PSTM=1636848234; BAIDUID=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BIDUPSID=583693E58AE227377AD2C0255BE81A7C;
__yjs_duid=1_fcbf43df8ca883073f54c3e2668c9a101636899752284;
BAIDUID_BFESS=EDC2CC01873CB8FC8AD1E6A671A724C3:FG=1;
BDRCVFR[J6KCWSEUjPm]=jzbQNU_zIP3uA-duhN8uz4WU6; BD_HOME=1; delPer=0; BD_CK_SAM=1;
PSINO=3; BDRCVFR[dG2JNJb_ajR]=mk3SLVN4HKm; BDRCVFR[-pGxjrCMryR]=mk3SLVN4HKm;
BDRCVFR[tox4WRQ4-Km]=mk3SLVN4HKm; BDRCVFR[CLK3Lyfkr9D]=mk3SLVN4HKm;
bdindexid=m7ca82kaivggoqndii4stvi5s7;
__yjs_st=2_YzNjNzVhNjY1YTg2Yzk3ZjcxNzNhZGE2ZGFmMzc3YzgxZjdkZGQ2NTUwZmQ3MjdjNmJmO
TdlMmJhNjA4MjRiYWJlMzQxM2JmYjBlZTMwOTc1MDkxMGI5N2FkZGVlMWY3MDQ2Yzc2NGE3YWJkNjMzN
DVkYzIxYWFlNzljYTBiMmQ1NGEwNDFlMTMzMzUyMWVhZTRiOWNhOWE5ZTI5ZWU3NDViMTg4NGQ3ZmRlM
2NhNzgwN2ZmMzMzMjk5MzEwMDcwMDgxZDQ1MmI1YmQwYjM5MDc5MmI0MjA2ZmRmYTEzOTUyMzk3NDBlY
2ZkMjQ1YWE5MzFkM2U2ZmJiZTRiZTA1ZF83XzBlNmI2ZGYz;
RT="z=1&dm=baidu.com&si=2nnngmj776t&ss=kwrgxahn&sl=f&tt=14xv&bcn=https://fclog.b
aidu.com/log/weirwood?type=perf&ld=1xsk&ul=30lc&hd=30oc";
BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; BD_UPN=12314753;
H_PS_645EC=6389g6iIpVnBbgosEw1V+z2mtlcSRayNkSY60Ndr3HbTT+V1wEj3+h2YN3k;
channel=baidusearch; baikeVisitId=4202b3c7-82fa-4957-ae0d-e3b8bfc09f71;
COOKIE_SESSION=2210_0_6_7_3_12_1_0_3_6_6_3_50012_0_0_0_1638601729_0_1638603935|8
#0_0_1638603935|1; userFrom=ala;
ab_sr=1.0.1_YTM2NTY3OTEyMmJkYTE2ZjI4MGYwOGFmYWM0MDZjMWY3ZGZiNDFkMDE5MDlmNWU2NDA2
M2NmZGFiYTdiZDE0Zjc4ZjBiMjdlYWRmNTZhNjYxY2Y5MGNhNjRiN2ZjMjhjMzZiMmNiYWQyN2JmM2U1
MmJhMTAzMTY3YjI4ZjNlM2ZhODI0NGRlZGYzZjQ5MTBhN2Y5ZjczOTcwYzZlYjM4ZQ==;
H_PS_PSSID=31660_26350; BDUSS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BDUSS_BFESS=DhQeU9tOGpFUElnUWdXSHJzZGd0QzYtckpoYzRNVWJeWxQV2Q5dThaWTFyOUpoRVFBQUFBJCQAAAAAAAAAAAEAAADyx5wF0KG~p7fItrm2-
QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiq2E1I
qthd; BA_HECTOR=0la00l0ha02kal8g6r1gqm8hq0r'
# 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36'
}
params={
'tn':'baiduimage',
'word':'风景图片'
}
params=bytes(par.urlencode(params),encoding='utf-8')
print(params)
request=req.Request(url,headers=headers,method='POST',data=params)
response=req.urlopen(request)
print(response.status)
with open('post.html','wb') as f:
f.write(response.read())