文章目录
- Python详细入门教程
-
- 第一章：
-
- 1.常见输出：
- 2.转义字符
- 第二章：
-
- 1.注释
- 2.标识符
- 3.变量
- 4.数据类型
- 5.字符编码
- 第三章
-
- 1.基础运算符
- 2.比较运算符
- 3.赋值运算符
- 4.布尔运算符
- 5.位运算符
- 6.输入函数
- 第四章
-
- 1.顺序结构
- 2.选择结构-单分支
- 3.选择结构-双分支
- 4.选择结构-多分支
- 5.选择结构-嵌套循环
- 6.循环结构
- 7.break语句
- 8.continue语句
- 9.pass语句
- 10.range函数
- 11.对象的布尔值
- 第五章
-
- 1.集合
- 2.列表
- 3.元组
- 4.字典
- 5.生成式
- 6.总结
- 第六章
-
- 1.字符串常用操作
- 2.字符串比较操作
- 3.字符串切片操作
- 4.字符串编码解码
- 5.字符串驻留机制
- 6.格式化字符串
- 第七章
-
- 1.函数
- 2.函数返回值
- 3.函数默认值
- 4.位置参数和关键字参数
- 5.参数总结
- 6.变量的作用域
- 7.递归函数
- 8.斐波那契
- 第八章
-
- 1.bug
- 2.Python常见的异常类型
- 3.异常处理机制
- 4.TraceBack模块的使用
- 第九章
-
- 1.两大编程思想
- 2.类和对象的理解
- 3.类和对象的创建
- 4.类属性-类方法-静态方法
- 5.动态绑定属性和方法
- 第十章
-
- 1.继承
- 2.封装
- 3.多态
- 4.方法重写
- 5.特殊属性
- 6.特殊方法
- 7.Object
- 8.类的浅拷贝和深拷贝
- 第十一章
-
- 1.主程序
- 2.包
- 3.模块
- 4.Python内置模块
- 5.第三方模块的安装和使用
- 6.导入注意事项
- 第十二章
-
- 1.文件的读写原理
- 2.文件对象的常用方法
- 3.常见文件打开方法
- 4.OS
- 5.with语句
- 6.编码格式
- Python十四案例
-
- 1.ASCII码
- 2.enumerate函数
- 3.wordcount
- 4.修改字体输出颜色
- 5.列表倒叙输出
- 6.十进制转二八十六
- 7.向文件输入语句
- 8.字符串分割
- 9.异常抛出
- 10.格式化字符串输出
- 11.格式化时间类型
- 12.登录支付功能
- 13.遍历两个列表输出
- 14.列表
Python详细入门教程
第一章：
1.常见输出：
# Author : zxy
# Date : 2022/5/2 11:50
# 1.输出数字
print(520)
# 2.输出字符串1
print('hello world')
# 2.输出字符串2
print("hello world")
# 3.输出结果到文件
# 不存在即创建 存在即追加
fp = open('F:/text.txt','a+')
print('hello world',file=fp)
fp.close()
# 4.不换行输出
print('hello','world','python')
2.转义字符
# Author : zxy
# Date : 2022/5/2 12:12
# 转义字符-换行
print('hello\nworld')
# 转义字符-table键
print('hello\tpython')
# 转义字符-backspace
print('hello\bzxy')
# 转移字符-return
print('hello\rworld')
# 转义字符-\" \'
print("\"hello\"","\'world\'")
# 转义字符-\\
print("http:\\\\www.baidu.com")
# 原字符-不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前加上r或者R
print(r"http:\\www.baidu.com")
# 原字符使用-末尾不能使用一个反斜杠结尾会报错，需要的话，使用两个
# print(r"http:\\www.baidu.com\")
print(r"http:\\www.baidu.com","\b\\")
第二章：
1.注释
# coding:utf-8
# Author : zxy
# Date : 2022/5/2 19:09
# Python代码中的注释
# 注释：
# 提高代码可读性
# 注释内容会被Python解释器忽略
# 三种注释类型：
# 单行注释：以#开头
"""
多行注释：将一对三引号之间代码称为多行注释
"""
# 中文编码声明注释：文件开头加上中文声明注释，用以指定源码文件的编码格式
2.标识符
# Author : zxy
# Date : 2022/5/2 15:07
import keyword
# 查看所有保留字
print(keyword.kwlist)
# 标识符规则
# 变量、函数、类、模块和其他对象起的名字就叫标识符
# 规则：
# 1.字母、数字、下划线
# 2.不能以数字开头
# 3.不能是保留字
# 4.严格区分大小写
3.变量
# Author : zxy
# Date : 2022/5/2 15:13
name = 'zxy'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
# 再次赋值后，会开辟新的内存空间
name = 'python'
print(name)
4.数据类型
# Author : zxy
# Date : 2022/5/2 18:22
from decimal import Decimal
# 数据类型
# 1.整数类型 int
# 1.1 可以表示正数、负数、0
n1 = 100
n2 = -100
n3 = 0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
# 1.2 整数可以表示 为二进制 十进制 八进制 十六进制
# 1.2.1 二进制取值[0,1]，逢2进一
print('二进制',0b10101111)
# 1.2.2 十进制取值[0,1,2,3,4,5,6,7,8,9] 逢10进一
print('十进制',118)
# 1.2.3 八进制取值[0,1,2,3,4,5,6,7] 逢8进一
print('八进制',0o176)
# 1.2.4 十六进制取值[0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] 逢16进一
print('十六进制',0x1EAF)
# 2.浮点数类型 float
f1 = 1.1
f2 = 2.2
# 输出结果3.3000000000000003，因为是通过二进制计算，存在浮点数小数点不准确性
print(f1,type(f1))
print(f1 + f2)
print(Decimal('1.1') + Decimal('2.2'))
# 3.布尔类型 bool
# 3.1 布尔判断
b1 = False
b2 = True
print(b1,type(b1))
if(b1) :
print('true')
else :
print('false')
# 3.2布尔相加
print(b1 + 1) # b1为false相当于0
print(b2 + 0) # b2为true相当于1
# 4.字符串类型 str
# 4.1 单引号，必须在一行
print('hello world',type('hello world'))
# 4.2 双引号，必须在一行
print("hello world",type("hello world"))
# 4.3 三引号，可以不在一行
print("""
hello
world
python
""")
# 4.不同数据类型连接,使用str将int类型转成string类型
print('------------------------str()转换类型--------------------------')
name = '张三'
age = 28
print('我是'+name+',我今年'+str(age)+'岁了')
print('------------------------int()转换类型--------------------------')
s1 = '128'
s2 = True
s3 = 98.8
s4 = '98.8'
s5 = 'hello'
print(s1,type(s1),int(s1),type(int(s1)))
print(s2,type(s2),int(s2),type(int(s2)))
# float转成int，会将小数截取掉
# 将s4转成Int类型会报错，因为字符串为小数串
# 将s5转成int类型也会报错，因为字符串转成整数，该字符串必须为整数数字串
print(s3,type(s3),int(s3),type(int(s3)))
print('------------------------float()转换类型--------------------------')
s1 = '98.8'
s2 = '98'
s3 = True
s4 = 98
s5 = 'hello'
# 将s5转成float类型会失败，只允许为数字串(整数，浮点数)
print(s1,type(s1),float(s1),type(float(s1)))
print(s2,type(s2),float(s2),type(float(s2)))
print(s3,type(s3),float(s3),type(float(s3)))
print(s4,type(s4),float(s4),type(float(s4)))
5.字符编码
# Author : zxy
# Date : 2022/5/2 14:26
# 十进制
print(ord('乘'))
# 二进制
print(chr(0b100111001011000))
第三章
1.基础运算符
# Author : zxy
# Date : 2022/5/2 19:51
# 算术运算符 -> 位运算符 -> 比较运算符 -> 布尔运算符 -> 赋值运算符
# ** -> [*,/,//,%] -> [<<,>>] -> [&] -> [|] -> [>,<,<=,>=,==,!=] -> and -> or -> =
# 基础运算符
print(1+1) # 加法运算
print(1-1) # 减法运算
print(1*2) # 乘法运算
print(1/2) # 除法运算
print(11//2) # 整除运算符
print(11%2) # 取余运算符
print(2**2) # 2的2次方
print(9//4) # 2
print(-9//-4) # 2
# 一正一负取整
print(9//-4) # -3 向下取整
print(-9//4) # -3 向下取整
# 一正一负，取余
print(9%-4) # 商-3 公式：余数 = 被除数 - 除数 * 商 9 - (-4) * (-3) = 9 - 12 = -3
print(-9%4) # 商-3 公式：余数 = 被除数 - 除数 * 商 -9 - 4 * (-3) = -9 + 12 = 3
2.比较运算符
# Author : zxy
# Date : 2022/5/2 20:25
# 比较运算符
a,b = 10,20
print('a>b？',a>b)
print('a<b?',a<b)
print('a>=b？',a>=b)
print('a<=b?',a<=b)
print('a==b？',a==b)
print('a!=b？',a!=b)
"""
赋值运算符 =
比较运算符 ==
一个变量由三个部分组成，标识，类型，值
== 比较的是值
is 比较的是标识
"""
print('----------整数对比----------')
a = 10
b = 10
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)
print('---------数组对比,值相同，id标识不同-----------')
a = [1,2,3,4]
b = [1,2,3,4]
print('值比较',a == b)
print('id标识比较',a is b)
print('id标识比较',a is not b)
3.赋值运算符
# Author : zxy
# Date : 2022/5/2 20:10
# 赋值运算符
# 执行顺序 ： 从右至左
a = 1 + 2
print('从右至左，先执行加法再赋值',a)
# 支持链式赋值,执行同一空间 ：a = b = c = 10
a = b = c = 10
print(a,id(a))
print(b,id(b))
print(c,id(c))
# 支持参数赋值 ：+= =+ *= /= //= %=
a = 20
a += 30
print('-------------a+=30 类似于 a = a + 30------------------')
print(a)
# 支持系列解包赋值 ： a,b,c = 20,30,40
print('-------------解包赋值------------')
a,b = 20,30
print(a,id(a))
print(b,id(b))
print('----------交换----------------')
a,b = b,a
print(a,id(a))
print(b,id(b))
4.布尔运算符
# Author : zxy
# Date : 2022/5/2 21:12
# 布尔运算符 and or not in not in
a,b = 10,20
# and 全真为真 一假为假
print(a==10 and b == 10)
# or 全假为假 一真为真
print(a==10 or b==10)
# not 取反
b1 = True
print(not b1)
# in
s1 = 'helloworld'
print('w' in s1)
print('z' in s1)
# not in
s1 = 'helloworld'
print('w' not in s1)
print('z' not in s1)
5.位运算符
# Author : zxy
# Date : 2022/5/2 21:44
# 位运算符 & | << >>
# 与运算符 & 同1为1 否则为0
# 0100
# 1000
# &
# 0000
print(4&8)
# 或运算符 | 同0为0 否则为1
# 0100
# 1000
# |
# 1100
print(4|8)
# 逻辑右移 >>
# 0100 => 4
# >> 1
# 0010 => 2
print(4>>1)
# 逻辑左移
# 0100 => 4
# << 1
# 1000 => 8
print(4<<1)
6.输入函数
# Author : zxy
# Date : 2022/5/2 19:42
# input输入函数
name = input('请输入你的名字：')
print(name,type(name))
# 转成int类型方式一
age = input('请输入你的年龄：')
print(age,type(age),int(age),type(int(age)))
# 转成int类型方式二
age = int(input('请输入你的年龄：'))
print(age,type(age))
第四章
1.顺序结构
# Author : zxy
# Date : 2022/5/2 22:21
# 顺序结构，把大象装冰箱
print('---------------程序开始--------------')
print('---------------1.打开冰箱--------------')
print('---------------2.大象放冰箱--------------')
print('---------------3.关冰箱门--------------')
print('---------------程序结束--------------')
2.选择结构-单分支
# Author : zxy
# Date : 2022/5/2 22:21
# 1.选择结构-单分支结构 银行取款
money = 1000
s = int(input('请输入取款金额：'))
if(money >= s):
money -= s
print('取款成功，剩余金额为：',money)
3.选择结构-双分支
# Author : zxy
# Date : 2022/5/3 10:31
# 2.选择结构-双分支结构 奇偶判断
i = int(input('请输入一个数字:'))
if i % 2 == 0:
print('你输入一个偶数！')
else:
print('你输入一个奇数！')
4.选择结构-多分支
# Author : zxy
# Date : 2022/5/3 10:31
# 3.选择结构-多分支结构 成绩等级划分
score = int(input('请输入一个成绩:'))
# if score >= 90 and score <= 100:
if 90 <= score <= 100:
print('A级')
elif score >= 80 and score < 90:
print('B级')
elif score >= 70 and score < 80:
print('C级')
elif score >= 60 and score < 70:
print('D级')
else:
print('不及格')
5.选择结构-嵌套循环
# Author : zxy
# Date : 2022/5/3 10:31
# 4.选择结构-嵌套结构 商场购物
money = int(input('请输入你需要支付金额！'))
vip = bool(input('请输入你是否是会员？True/False'))
if vip:
if money >= 200:
print('你需要支付：',money * 0.8)
elif money >= 100:
print('你需要支付：',money * 0.9)
else:
print('你需要支付：',money)
else:
if money >= 200:
print('你需要支付：',money * 0.95)
else:
print('你需要支付：',money)
6.循环结构
# Author : zxy
# Date : 2022/5/2 22:21
"""
循环结构
while
for - in
"""
def test1():
a = 1
while a < 10:
print(a)
a += 1
# 计算0到10的累加
def sum():
'''初始化变量'''
sum = 0
a = 0
'''条件判断'''
while a <= 10:
'''条件执行体'''
sum += a
a += 1
print(sum)
# 1到100偶数和
def number():
sum = 0
i = 0
while i <= 100:
if i % 2 == 0:
sum += i
i+=1
print('while计算求和',sum)
def number2():
sum = 0
for item in range(1,101):
if item % 2 == 0:
sum += item
print('for-in计算求和:',sum)
# 100 到 1000 的水仙花
def water():
for item in range(100,1001):
ge = item % 10
shi = item // 10 % 10
bai = item // 100
if ge**3+shi**3+bai**3 == item:
print(item)
if __name__ == '__main__':
number()
number2()
water()
'''for-in'''
for item in 'python':
print(item)
for i in range(10):
print(i)
for _ in range(1,3):
print('hello python')
7.break语句
# Author : zxy
# Date : 2022/5/3 13:30
# 通过break退出循环
'''密码三次输入不成功退出，密码正确退出'''
for item in range(3):
pwd = input('请输入密码：')
if pwd == '8888':
print('密码正确')
break
else :
print('密码不正确')
else:
print('三次密码均失败！')
8.continue语句
# Author : zxy
# Date : 2022/5/3 13:34
'''break是退出循环'''
'''continue是退出当前循环，继续下一个循环'''
'''1到50之间，5的倍数'''
for item in range(1,51):
'''如果item不是5的倍数，就跳出当前循环，继续下一个循环'''
if item % 5 != 0:
continue
print(item)
9.pass语句
# Author : zxy
# Date : 2022/5/3 10:44
# pass语句，什么都不做，只是一个占位符，用到需要写语句的地方
money = int(input('请输入你需要支付金额！'))
if money >= 200:
pass
# 当没想好怎么写的时候，可以先使用pass占位，继续写后面的操作
# print('你需要支付：', money * 0.8)
elif money >= 100:
print('你需要支付：', money * 0.9)
else:
print('你需要支付：', money)
10.range函数
# Author : zxy
# Date : 2022/5/3 10:50
# range函数
'''一个参数，表示从0到10'''
n1 = range(10)
print(list(n1))
'''两个参数，从1开始到19'''
n2 = range(1,19)
print(list(n2))
'''三个参数，从1开始到19，步长为2'''
n3 = range(1,19,2)
print(list(n3))
'''判断指定的整数 在序列中是否存在 in，not in '''
print(10 in n3)
print(10 not in n3)
11.对象的布尔值
# Author : zxy
# Date : 2022/5/2 22:36
"""
Python所有对象都有一个布尔值
获取对象的布尔值，使用内置函数bool()
以下对象的布尔值为False
False
数值0
None
空字符串
空列表
空元组
空字典
空集合
"""
print(bool(False)) # False
print(bool(0.0)) # 数值0
print(bool(None)) # None
print(bool('')) # 空字符串
print(bool("")) # 空字符串
print(bool([])) # 空列表
print(bool(list())) # 空列表
print(bool(())) # 空元组
print(bool(tuple())) # 空元组
print(bool({})) # 空字典
print(bool(dict())) # 空字典
print(bool(set())) # 空集合
第五章
1.集合
# Author : zxy
# Date : 2022/5/3 22:41
# 集合
"""
集合：
Python语言提供的内置数据结构
与列表、字典一样都属于可变类型的序列
集合是没有value的字典
"""
# 1.集合的创建
"""
集合的创建方式：
直接{}
s = {'python','java'}
使用内置函数set()
s = set(range(6))
s = set([1,2,3,4])
s = set((1,2,3,4))
s = set('python')
s = set({1,2,3,4})
s = set()
"""
def create_tuple():
s = {'python', 'java','java'} # 集合中元素不能重复，会把重复的元素自动去掉
print(s,type(s))
s = set(range(6))
print(s, type(s))
s = set([5, 2, 3, 4]) # 集合中元素是无序的
print(s, type(s))
s = set((1, 6, 3, 4))
print(s, type(s))
s = set('python')
print(s, type(s))
s = set({1, 2, -1, 4})
print(s, type(s))
s = set() # 空集合
print(s, type(s))
s = {} # 空字典
print(s, type(s)) # 不能使用空的大括号创建集合，因为这默认是字典
# 2. 集合相关操作
"""
集合元素的判断
in
not in
集合元素的新增：
add() ,一次添加一个元素
update()至少添加一个元素
集合元素的删除：
remove() ,一次删除一个指定元素，如果指定元素不存在抛出异常KeyError
discord(),一次删除指定元素，如果指定元素不存在不抛出异常
调用pop(),一次只删除一个任意元素
调用clear() ，情况集合
"""
def opter_set():
s = {'hello','my','python','time'}
print('python是否在集合中？','python' in s)
print('python是否不在集合中？', 'python' not in s)
s.add('java')
print('add添加元素Java：',s)
s.update('a','b','c')
print('update添加元素a,b,c:',s)
s.remove('java')
print('指定删除Java元素：',s)
# s.remove('zxy') remove删除一个不存在的元素，会抛出异常
s.discard('zxy')
print('discard删除不存在的元素，不会报错:',s)
s.pop()
print('pop删除任意一个元素：',s)
s.clear()
print('clear清空所有集合元素：',s)
# 3.集合的关系
"""
两个集合是否相等
可以使用运算符==或!=判断
一个集合是否是另一个集合的子集
可以调用方法issubset进行判断
B是A的子集
一个集合是否另一个集合的超集
可以调用方法issuperset进行判断
A是B的超集
两个集合是否没有交集
可以调用方法isdisjoint进行判断
"""
def relation_set():
s1 = {10,20,30,40}
s2 = {40,10,20,30}
s3 = {10,20}
s4 = {60,70}
print('s1和s2相同？',s1==s2)
print('s1和s2不相同',s1!=s2)
print('s3是s1的子集？',s3.issubset(s1))
print('s1是s3的超集',s1.issuperset(s3))
print('s1和s4没有交集？',s1.isdisjoint(s4)) # 没有交集为True，有交集为False
# 4.集合的数据操作
"""
交集
并集
差级
"""
def data_opetate():
s1 = {10, 20, 'hello'}
s2 = {40, 10, 20, 30}
print('方式一：s1和s2交集：',s1.intersection(s2)) # 交集
print('方式二：s1和s2交集：',s1 & s2)
print('方式一：s1和s2并集：',s1.union(s2)) # 并集
print('方式二：s1和s2并集：',s1 | s2)
print('方式一：s1减去[s1和s2的交集]：',s1.difference(s2)) # 差集
print('方式一：s2减去[s1和s2的交集]：',s2.difference(s1))
print('方式二：s1减去[s1和s2的交集]：', s1 - s2)
print('方式二：s2减去[s1和s2的交集]：', s2 - s1)
print('s1和s2的并集减去s1和s2的交集：',s1.symmetric_difference(s2)) # 对称差集
# 5. 集合生成式
def create_set():
s = { i for i in range(6)}
print(s,type(s))
if __name__ == '__main__':
create_set()
2.列表
# Author : zxy
# Date : 2022/5/3 14:04
"""
列表：
变量 可以存储一个元素，
而列表是一个”大容器“可以存储N多个元素，
程序可以方便的对这些数据进行整体操作
列表相当于其他语言中的数组
特点：
列表元素按顺序有序排序
索引映射唯一一个数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
"""
def test():
lst = [98,98.8,'hello']
print(lst,id(lst))
print(lst,type(lst))
print(lst)
lst2 = list(lst)
print(lst2,type(lst2))
print(lst[0])
print(lst2[0])
'''
元素位置索引
索引：
正向 0 到 N
逆向 -N 到 -1
'''
def index_test():
lst = [98, 98.8, 'hello']
print(lst.index(98))
print(lst.index('hello',1,3))
"""
切片：
获取列表中多个元素
切片的结果->原列表片段的拷贝
切片的范围->
"""
def split_test():
lst = [10,20,30,40,50,60,70]
print('原列表：',lst)
print('起始位2，结束为6，步长为1：',lst[2:6:1])
print('不设起始，结束为6，步长为2：',lst[:6:2])
print('起始为2，不设结束，步长为1：',lst[2::1])
print('不设起始，不设结束，步长为1',lst[::1])
print('不设起始，不设结束，步长为-1,类似反转',lst[::-1])
"""
判断元素在列表中是否存在：
in
not in
"""
def exists_test():
lst = ['yyds','python','java']
print('yyds' in lst)
print('zxy' not in lst)
"""
列表元素的遍历
"""
def list_test():
lst = ['yyds', 'python', 'java']
for ls in lst:
print(ls)
"""
列表元素的增加操作
"""
def append_test():
lst = ['yyds', 'python', 'java']
lst2 = ['a','b','c']
lst3 = [1,2,3]
print('原数据',lst)
lst.append('zxy')
print('append追加后：',lst)
lst.extend(lst2)
print('extend追加多个元素：',lst)
lst.insert(0,666)
print('insert在索引为0的位置添加666：',lst)
lst[1:]=lst3
print('切片替换，从下标1开始的所有元素替换为lst3',lst)
def remove_test():
lst = ['yyds', 'python', 'java','scala','html']
print('原数据：',lst)
lst.remove("yyds") # 从列表中移除一个元素，如果有重复元素，只移除第一个元素
print('删除lst中指定元素',lst)
lst.pop(0) # 通过指定索引，删除元素,如果不指定索引，则删除最后一个元素
print('删除索引为0的数据：',lst)
new_list = lst[1:3]
print('切片删除，只留下索引1到3的数据，会产生新的列表对象：',new_list)
lst[0:1] = []
print('将列表中索引0到1的位置置空，相当于删除：',lst)
"""
修改列表元素
"""
def modify_test():
lst = ['yyds', 'python', 'java', 'scala', 'html']
print('原数据：', lst)
lst[0] = 'bigdata'
print('指定下标修改：',lst)
lst[2:4] = [100,200,300,400]
print('切片修改：',lst)
"""
排序查询
"""
def sort_test():
lst = [40,10,30,90,100]
print('原数据：',lst)
lst.sort()
print('不指定排序方式，默认升序排序：',lst)
lst.sort(reverse=False)
print('指定升序排序:', lst)
lst.sort(reverse=True)
print('指定降序排序：',lst)
print('-------------------sorted()跟sort()的区别是，sort()是在原有list基础上排序，sorted()是生成新的列表-------------')
lst = [40, 10, 30, 90, 100]
print('原数据：', lst)
new_list = sorted(lst)
print('默认升序排序：',new_list)
desc_list = sorted(lst,reverse=True)
print('指定降序排序：',desc_list)
"""
列表生成式
"""
def create_test():
lst = [i for i in range(1,10)]
print(lst)
if __name__ == '__main__':
create_test()
3.元组
# Author : zxy
# Date : 2022/5/3 21:52
# 元组
"""
什么是元组？
Python 内置的数据结构之以，是一个不可变序列
不可变序列与可变序列
不可变序列：字符串、元组
不可变序列没有增、删、改的操作
可变序列：列表、字典
可变序列：可以对序列执行增、删、改操作，对象地址不发生改变
"""
# 1.元组的创建
"""
1.1 直接小括号
t = ('python','java')
1.2 使用内置函数tuple()
t = tuple(('python','java'))
1.3 只包含一个元组的元素需要使用逗号和小括号
t = (10,)
"""
def create_tuple():
# 空列表创建
lst = []
lst = list()
# 空字典创建
dic = {}
dic = dict()
# 空元组创建
tup = ()
tup = tuple()
t = ('python','java')
print(t,type(t))
t = tuple(('python', 'java'))
print(t, type(t))
t = (10,)
print(t, type(t))
# 如果不加逗号，会被识别为int类型
t = (10)
print(t, type(t))
# 2.为什么要将元组设计成不可变序列
"""
为什么要将元组设计成不可变序列
在多任务环境下，同时操作对象时不需要加锁
因此，在程序中尽量使用不可变序列
注意事项：
元组中存储的是对象的引用
a) 如果元组中对象本身是不可变对象，则不能再引用其他对象
b) 如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
"""
def test():
tup = (10,['a','b','c'],20)
print(tup,'类型',type(tup)) # 元组类型
print(tup[0],'类型',type(tup[0])) # 元组类型中的不可变对象
print(tup[1],'类型',type(tup[1])) # 元组类型中的可变对象
# tup[1]是list类型，可以增、删、改数据。但是不能将其改为tup[1]=100这种
# 3.元组的遍历
def list_tuple():
print('--------------方式一：索引获取--------------------')
tup = (10, ['a', 'b', 'c'], 20)
print(tup[0])
print(tup[1])
# 但是这样的缺陷是，你要知道总共有多少数据
print('--------------方式二：遍历查询----------------------')
for item in tup:
print(item)
# 主函数
if __name__ == '__main__':
list_tuple()
4.字典
# Author : zxy
# Date : 2022/5/3 16:47
"""
字典：
1.什么是字典
2.字典得原理
3.字典的创建与删除
4.字典的查询操作
5.字典的增删改
6.字典推导式
"""
# 1.什么是字典
"""
以Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列
eg: scores = {'张三':100,'李四':99}
字典名：scores
花括号：{}
键：'张三'
值：100
冒号：:
逗号：,
"""
# 2.字典原理
"""
字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python中的字典是根据Key查找Value所在位置
字典元素的位置，不是按照输入的位置，是按照hash函数计算key的得到的
key:不可变的序列
"""
# 3.字典的创建
def create_dict():
list1 = ['张三','李四']
list2 = [100,99]
scores = {'张三':100,'李四':99}
print('字典创建方式一：',scores)
scores = dict(name='张三',age=18)
print('字典创建方式二：',scores)
scores = {list1:list2 for list1,list2 in zip(list1,list2)}
print('字典创建方式三：',scores)
# 4.字典的查询
def get_dict():
scores = {'张三': 100, '李四': 99}
print('-----------------方式一和二的区别主要在于：方式一查找不存在的键会报错，方式二会返回一个None值')
print('查找方式一',scores['张三'])
print('查找方式二',scores.get('张三'))
print('查找方式二,不存在的键：',scores.get('zxy'))
print('查找方式二,不存在的键，修改默认返回值None：',scores.get('zxy',100))
# 5.字典的常用操作
"""
key的判断：in 或者 not in
字典的删除：del scores['张三']
字典的元素新增：scores['zxy']=100
"""
def operate_test():
# 判断是否存在
scores = {'张三': 100, '李四': 99}
print('判断张三是否存在：','张三' in scores)
print('判断张三是否存在：', 'zxy' in scores)
# 删除元素
del scores['张三']
print("删除key='张三':",scores)
# 清空字典
scores.clear()
print('清空数据元素：',scores)
# 新增元素
scores['zxy'] = 100
print("增加key='zxy',value='100",scores)
# 修改元素
scores['zxy'] = 99
print('key是唯一的，如果重复新增，会覆盖原有值：',scores)
# 6.获取字典试图的三种方法
"""
keys() 获取字典中所有key
values() 获取字典中所有value
items() 获取字典中所有key，value
"""
def view_test():
scores = {'张三': 100, '李四': 99}
keys = scores.keys()
print('获取字典的所有key:',keys)
values = scores.values()
print('获取字典的所有value:',values)
print('-----------------将key集合和list集合转成列表-----------------')
print(list(keys),list(values))
items = scores.items()
print('获取字典中的所有key,value',items)
print('--------------------将items转成元组tuple集合--------------')
print(tuple(items))
# 7.循环字典元素
def list_dict():
scores = {'张三': 100, '李四': 99}
for item in scores:
print('key=',item,'value=',scores[item])
print('key=',item,'value=',scores.get(item))
# 8.字典的特点
"""
字典的特点：
字典中所有元素都是一个key-value键值对，key不允许重复，value可以重复
字典中的元素是无序的
字典中的key必须是不可变对象
字典也可以根据需要动态的伸缩
字典会浪费较大的内存，是一种使用空间换时间的数据结构 *********************
"""
# 9.字典生成式
"""
内置函数zip()
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，
然后返回由这些元组组成的列表
"""
def zip_dict():
lst1 = ['张三','李四','王五']
lst2 = [100,20,50]
# 使用zip将两个列表，压缩成一个元组组成的列表
dic1 = zip(lst1,lst2)
print(list(dic1),type(dic1))
# 使用zip元素，将两个元组，组成一个字典
dic2 = {lst1:lst2 for lst1,lst2 in zip(lst1,lst2) }
print(dic2,type(dic2))
# 主函数
if __name__ == '__main__':
zip_dict()
5.生成式
# Author : zxy
# Date : 2022/5/4 10:27
# 列表生成式
list1 = [ i for i in range(6)]
print(list1,type(list1))
# 集合生成式
set1 = { i for i in range(6)}
print(set1,type(set1))
# 字典生成式
k = ['张三','李四']
v = [100,90]
dict1 = {k:v for k,v in zip(k,v)}
print(dict1,type(dict1))
6.总结
# Author : zxy
# Date : 2022/5/4 10:30
# 总结
"""
共有列表、字典、元组、集合
列表 []
字典 {key:value}
元组 ()
集合 {}
其中：
列表、字典、集合都是可变的，元组不可变
列表、元组可以有重复，集合不可以重复，字典的key不可以重复，value可以重复
列表、元组是有序的，字典、集合是无序的
"""
# 1.元组
"""
创建元组：
使用小括号()创建
使用内置函数tuple()创建
元组遍历：
for ... in
不可变序列
"""
# 2.集合
"""
创建集合
使用花括号{}
内置函数set()
集合生成式
集合遍历
for ... in
新增
add()
update()
删除
remove()
discard()
pop()
clear()
可变序列
"""
第六章
1.字符串常用操作
# Author : zxy
# Date : 2022/5/4 13:45
# 查询操作
"""
index() 查找字符第一次出现的位置，不存在抛出异常ValueError
rindex() 查找字符最后一次出现的位置，不存在抛出异常ValueError
find() 查找字符第一次出现的位置，不存在返回-1
rfind() 查找字符最后一次出现的位置，不存在返回-1
"""
def find_str():
s = 'password'
i = s.index('s')
print('index查找字符第一次出现的位置，不存在抛出ValueError',i)
i = s.find('s')
print('index查找字符第一次出现的位置，不存在返回-1',i)
i = s.find('z')
print('index查找字符第一次出现的位置，不存在返回-1', i)
j = s.rindex('s')
print('index查找字符最后一次出现的位置，不存在抛出ValueError', j)
j = s.rfind('s')
print('index查找字符最后一次出现的位置，不存在返回-1', j)
j = s.rfind('z')
print('index查找字符最后一次出现的位置，不存在返回-1', j)
# 2. 字符串带小写转换
"""
upper() 把字符中的所有字符串都转成大写字母
lower() 把字符中的所有字符串都转成小写字母
swapcase() 把字符串中所有大写字母都转成小写字母，把所有小写字母转成大写字母
capitalize() 把第一个字符转成大写，其他转成小写
title() 把每个单词第一个字符转成大写，其余转成小写
"""
def trans_str():
s = 'hEllo wOrd'
print('原数据',s)
print('upper():',s.upper())
print('lower()',s.lower())
print('swapcase()',s.swapcase())
print('captitalize()',s.capitalize())
print('title()',s.title())
# 3.字符串对齐方式
def align_str():
s = 'hello word'
print('居中对齐:',s.center(20,'-'))
print('左对齐:',s.ljust(20,'_'))
print('右对齐:',s.rjust(20,'_'))
print('右对齐，只传一个参数，默认0填充',s.zfill(20))
# 4.字符串拆分
def split_str():
s1 = 'hello world python'
s2 = 'hello-world-python'
print('从左往右分'.center(100,'*'))
print('split默认按空格拆分',s1.split())
print('split,设置sep选择分隔符，设置maxsplit设置最大分割次数', s2.split(sep='-',maxsplit=1))
print('\n')
print('从右往左分'.center(100, '*'))
print('rsplit默认按空格拆分',s1.rsplit())
print('rsplit,设置sep选择分隔符，设置maxsplit设置最大分割次数', s2.rsplit(sep='-', maxsplit=1))
"""从左往右和从右往左分的最主要的区别在与设置maxsplit后，会得到不同的结果"""
# 5. 字符串判断操作
"""
isidentifier() 是不是合法的标识符
isspace() 是否全部由空白字符串组成(回车、换行、水平制表符)
isalpha() 是否全部由字母组成
isdecimal() 是否全部由二进制数字组成
isnumeric() 是否全部由数字组成
isalnum() 是否全部由字母和数字组成
"""
def judge_str():
s1 = 'hello_123'
s2 = s1.join('@')
s3 = ' \t'
s4 = 'abcd'
s5 = '1234'
s6 = '123四'
print('合法标识符'.center(70,'*'))
print(s1,'是不是由合法标识符组成',s1.isidentifier())
print(s1,'是不是由合法标识符组成',s2.isidentifier())
print('\n','空白字符串'.center(70, '*'))
print(s1, '是不是空白字符串组成', s1.isspace())
print(s3,'是不是空白字符串组成',s3.isspace())
print('\n', '字母'.center(70, '*'))
print(s1,'是不是全部由字母组成',s1.isalpha())
print(s4, '是不是全部由字母组成', s4.isalpha())
print('\n', '十进制数字'.center(70, '*'))
print(s5,'是不是由十进制数字组成',s5.isdecimal())
print(s6, '是不是由十进制数字组成', s6.isdecimal())
print('\n', '数字'.center(70, '*'))
print(s5, '是不是由数字组成', s5.isnumeric())
print(s6, '是不是由数字组成', s6.isnumeric())
print('\n', '字母和数字'.center(70, '*'))
print(s1, '是不是全由字母和数字组成', s1.isalnum())
print(s4,'是不是全由字母和数字组成',s4.isalnum())
# 6.字符串替换和 合并
def replace_join_str():
s1 = 'hello java java'
lst = ['hello','java','python']
tup = ('hello','java','python')
print('replace替换',s1.replace('java','python'))
print('replace只替换1个目标',s1.replace('java','python',1))
print('join合并','*'.join(s1))
print('列表合并','*'.join(lst))
print('元组合并','*'.join(tup))
if __name__ == '__main__':
replace_join_str()
2.字符串比较操作
# Author : zxy
# Date : 2022/5/4 15:31
# 字符比较操作
"""
字符串的比较操作：
运算符：> >= < <= == !=
比较规则：
首先是比较两个字符串中第一个字符，如果相等则继续比较下一个字符，
依次比较下去，直到两个字符串中的字符不相等时，其比较结果就说两个字符串的比较结果
两个字符串中的所有后续字符将不再被比较
比较原理：
两个字符进行比较时，比较是其ordinal value（原始值），调用内置函数ord可以 得到指定字符的Ordinal value。
与内置函数ord对应的内置函数是chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
"""
def compare_str():
print('python' > 'java')
print('p',ord('p'))
print('j',ord('j'))
print('112',chr(112))
print('106',chr(106))
## == 比较的值
## is 比较的id
if __name__ == '__main__':
compare_str()
3.字符串切片操作
# Author : zxy
# Date : 2022/5/4 16:05
# 字符串切片操作
"""
字符串是不可变类型
不具备增、删、改等操作
切片操作将产生新的对象
"""
s = 'abcdefg'
print('指定切片区间',s[0:2])
print('不指定起始：',s[:2])
print('不指定结束：',s[2:])
print('指定区间、指定步长',s[0:3:2])
4.字符串编码解码
# Author : zxy
# Date : 2022/5/4 16:49
# 字符串的编码解码
"""
为什么需要字符串的编码转换：
计算机之间的传输是通过byte字节，在计算机展示的时候是字符
编码和解码的方式：
编码：将字符串转换为二进制数据bytes
解码：将bytes类型的数据转换成字符串类型
"""
s = '大河向东流'
# 编码
print(s.encode(encoding='GBK')) # 一个中文字符，两个字节
print(s.encode(encoding='UTF-8')) # 一个中文字符，三个字节
# 解码
byte = b'\xb4\xf3\xba\xd3\xcf\xf2\xb6\xab\xc1\xf7'
print(byte.decode(encoding='GBK'))
byte = b'\xe5\xa4\xa7\xe6\xb2\xb3\xe5\x90\x91\xe4\xb8\x9c\xe6\xb5\x81'
print(byte.decode(encoding='UTF-8'))
5.字符串驻留机制
# Author : zxy
# Date : 2022/5/4 10:41
# 字符串的驻留机制
"""
字符串：
在Python中字符串是基本数据类型，是一个不可变的字符序列
什么叫字符串驻留机制？
仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，
Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串时，
不会开辟新的空间，而是把该字符串 的地址赋给新创建的变量
"""
a = 'python'
b = "python"
c = """python"""
print('----------相同字符串，相同地址------------')
print(a,id(a))
print(b,id(b))
print(c,id(c))
print(a is b , b is c , c is a)
"""
驻留机制的几种情况：
字符串长度为0或1时
符合标识符的字符串
字符串只在编译时进行驻留，而非运行时
[-5,256]之间的整数数字
sys中intern方法强制2个字符串指向同一对象
pycharm对字符串进行了优化处理
"""
"""
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> s1 = 'abc'
>>> s2 = 'abc'
>>> s1 is s2
True
>>> s1 = 'abc%'
>>> s2 = 'abc%'
>>> s1 is s2
False
>>> s1 == s2
True
>>>
"""
# 字符串驻留的优缺点
"""
字符串驻留的优缺点：
当需要值相同的字符串时，可以直接从字符串池中拿来使用，
避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是比较影响性能的
在需要进行字符串拼接的时候建议使用str类型的join方法，而非+，
因为join()方法是先计算出所有字符中的长度，然后拷贝，只new一次对象，效率比+更高
"""
# >>> c = ''.join(['ab','c'])
# >>> c
# 'abc'
# >>> c = 'a'.join(['b','c'])
# >>> c
# 'bac'
# >>>
6.格式化字符串
# Author : zxy
# Date : 2022/5/4 16:21
# 格式化字符串
"""
格式化字符串的两种方式
%作为占位符: '我的名字叫：%s,今年%d岁了' % (name,age)
字符串：%s
整数：%l 或 %d
浮点数：%f
{}作为占位符: '我的名字叫：{0},今年{1}岁了，我真的叫{0} format(name,age)
"""
name = 'zxy'
age = 18
print('我叫%s,我今年%d岁了' % (name,age))
print('我叫{0},我今年{1}岁了，我真的叫{0}'.format(name,age))
# 长度为10，保留小数点后三位
print('%10.3f' % 3.1415926)
print('{}'.format(3.1415926)) # 只有一个元素，不指定位置也可
print('{0:.3}'.format(3.1415926)) # 总共保留三位数
print('{0:.3f}'.format(3.1415926)) # 保留三位小数
print('{0:10.3f}'.format(3.1415926)) # 设置宽度和精度，一共十位，保留小数点后三位
第七章
1.函数
# Author : zxy
# Date : 2022/5/4 17:22
# 函数
"""
什么是函数：
函数是执行特定任务和完成特定功能的一段代码
为什么需要函数：
提高代码可复用性
隐藏实现细节
提高可维护性
提高可读性
函数的创建：
def 函数名([输入参数]):
函数体
[return xxxx]
"""
"""
在函数调度过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体的修改会影响到实参的值
"""
def cale(a,b): # a,b为形参
return a + b
if __name__ == '__main__':
a = cale(10,20) # 10,20 是实参
print(a)
b = cale(b=100,a=10) # 指定参数赋值
print(b)
2.函数返回值
# Author : zxy
# Date : 2022/5/4 18:55
# 函数返回值
"""
函数返回值：
如果函数没有返回值 return可以不写
函数的返回值，如果是一个，直接返回类型
函数返回值，如果是多个，返回结果为元组
"""
# 函数返回多个值，结果为元组
def fun(num):
odd = []
even = []
for i in num:
if i % 2 == 0 :
odd.append(i)
else:
even.append(i)
return odd,even
if __name__ == '__main__':
lists = [10,23,45,23,85,12]
print('元组：',fun(lists))
# 函数返回多个值，可以使用下标取值
print('列表1',fun(lists)[0])
print('列表2',fun(lists)[1])
# for i,j in fun(10):
# print(i)
# print(j)
3.函数默认值
# Author : zxy
# Date : 2022/5/4 19:49
def fun(a,b=20):
# 这里的为end='\t'也是给end指定传参，这样就不会使用默认值end='\n'
# def print(self, *args, sep=' ', end='\n', file=None):
print('begin1',end='\t')
print('beigin2')
return a+b
if __name__ == '__main__':
a = fun(10)
print('未给b传参，则b使用默认值',a)
b = fun(10,30)
print('给a,b指定传参，则默认值失效',b)
4.位置参数和关键字参数
# Author : zxy
# Date : 2022/5/4 20:01
# 函数得参数定义
"""
个数可变得位置参数：
定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组
个数可变的关键字形参：
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典
"""
def fun1(*args):
print(args,type(args))
def fun2(**args):
print(args,type(args))
if __name__ == '__main__':
fun1(10,20,30)
fun2(a=10,b=20,c=30)
5.参数总结
# Author : zxy
# Date : 2022/5/4 21:07
# 参数总结
def fun(a,b,c):
print('a={0},b={1},c={2}'.format(a,b,c))
def fun2(a,b,c,d):
print('a={0},b={1},c={2},d={3}'.format(a, b, c,d))
if __name__ == '__main__':
fun(10,20,30) # 位置传参
fun(a=10,b=20,c=30) # 关键字传参
lst = [10,20,30]
fun(*lst) # 使用lst传参的时候，需要使用*，将列表中的元素依次传给函数fun()
dic = {'a':10,'b':20,'c':30}
fun(**dic)
6.变量的作用域
# Author : zxy
# Date : 2022/5/4 21:31
# 变量的作用域
"""
变量的作用域：
程序代码能访问该变量的区域
根据变量的有效范围可分为：
局部变量：
在函数内定义并使用的变量，只有在函数内部有效，
局部变量使用global声明，这个变量就会变成全局变量
全局变量：
函数体外定义的变量，可作用于函数内外
"""
b = 'hello python'
def fun():
a = 'hello word'
global c
c = 'hello java'
print('局部变量',a)
print('global局部变量转全局变量',c)
if __name__ == '__main__':
print('全局变量', b)
fun()
# global将局部变量转为全局变量，定义在fun()函数中，需要先调用fun()函数，才能使用全局变量c
print('global局部变量转全局变量',c)
7.递归函数
# Author : zxy
# Date : 2022/5/4 21:48
#递归函数
"""
什么是递归函数？
如果在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数
递归的组成部分？
递归调用与递归终止条件
递归的调用过程？
每递归调用一次函数，都会在栈内存分配一个栈帧
每执行完一次函数，都会释放相应的空间
递归的优缺点？
缺点：占用内存多，效率底下
优点：思路和代码简单
"""
def fun(n):
if n == 1:
return 1
else:
return n * fun(n-1)
if __name__ == '__main__':
print(fun(6))
8.斐波那契
# Author : zxy
# Date : 2022/5/4 22:09
# 斐波那契
"""
fun(6)
fun(5) fun(4)
fun(4) fun(3) fun(3) fun(2)
fun(3) fun(2) fun(2) fun(1) fun(2) fun(1) .
fun(2) fun(1) . . . . . .
. . . . . . . .
. . . . . . . .
1 1 1 1 1 1 1 1
"""
def fun(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fun(n-1) + fun(n-2)
if __name__ == '__main__':
print(fun(6))
第八章
1.bug
# Author : zxy
# Date : 2022/5/4 22:35
# 1.规范操作
"""
1.漏末尾的冒号
2.缩进错误
3.英文字符写成中文
4.字符串连接，把字符串和数字拼接到一起
5.没有定义变量
6.比较运算符==和赋值运算符=的混用
"""
# 2.知识点不熟练导致错误
"""
1.索引越界：indexError
lst = [11,22,33,44]
print(lst[4])
2.append()方法使用不熟练
lst=[]
lst=append('A','B','C')
print(lst)
"""
# 3.思路不清导致的问题
"""
基础知识不牢固，练
"""
'''列表套字典，字典里的value值有列表'''
lst = [{'rating':[9.7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['蒂姆.罗宾斯','摩根.弗里曼']},
{'rating':[9.6,1528760],'id':'1291546','type':['剧情','爱情','同性'],'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']},
{'rating':[9.5,1559181],'id':'1292720','type':['剧情','爱情'],'title':'阿甘正传','actors':['汤姆.汉克斯','罗宾.怀特']}]
name = input('请输入你要查询演员的名字:')
for movie in lst:
actor = movie['actors']
for act in actor:
if(name in act):
print(name + '出演了' + movie['title'])
2.Python常见的异常类型
# Author : zxy
# Date : 2022/5/20 14:55
# Python常见的异常类型
ZeroDivisionError #除或取模零的类型
IndexError #序列中没有此索引
KeyError #映射中没有这个键
NameError #未声明/初始化对象(没有属性)
SyntaxError #Python语法错误
ValueError #传入无效的参数
3.异常处理机制
# Author : zxy
# Date : 2022/5/20 14:05
# 1.try: ... except Error:...
"""
1.问题
程序代码逻辑没有错，只是因为用户错误操作或者一些例外情况而导致的程序崩溃
例如：除数不可以为0
没有按照输入类型输入指定类型数据
2.解决
针对这种问题，Python提供了异常处理机制，可以在异常的时候出现0时即捕捉，然后内部"消化"，让程序继续运行
try ... except Error:
捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException
"""
try:
n1 = int(input('请输入一个整数：'))
n2 = int(input('请输入另一个整数:'))
result = n1 / n2
print('结果为：',result)
except ZeroDivisionError:
print('除数不可以为0')
except ValueError:
print('值异常')
except BaseException as e:
print(e)
# 2.try...except...else结构
"""
如果try块中没有抛出异常，则执行else,如果抛出异常，则执行except
"""
try:
n1 = int(input('请输入一个整数：'))
n2 = int(input('请输入另一个整数:'))
result = n1 / n2
except ZeroDivisionError:
print('除数不可以为0')
else:
print('结果为：',result)
# 3.try...except...else...finally
"""
finally块无论如何是否发生异常都会被执行，能常用来释放try块中申请的资源
"""
try:
n1 = int(input('请输入一个整数：'))
n2 = int(input('请输入另一个整数:'))
result = n1 / n2
except ZeroDivisionError:
print('除数不可以为0')
else:
print('结果为：',result)
finally:
print('无论是否抛出异常，都会执行finally，输出这一句')
# 4.try...except...else...finally
4.TraceBack模块的使用
# Author : zxy
# Date : 2022/5/20 22:03
"""
使用traceback模块打印异常信息
"""
import traceback
try:
print('测试'.center(10,'*'))
print(1/0)
except:
traceback.print_exc()
第九章
1.两大编程思想
# Author : zxy
# Date : 2022/5/20 22:14
"""
面向过程：
事物比较简单，可以线性的思维去解决
面向对象:
事务比较复杂，使用简单的线性思维无法解决
共同点：
面向过程和面向对象都是解决实际问题的一种思维方式
联系：
二者相辅相成，并不是对立的
解决复杂问题，通过面向对象方式便于我们从宏观把握事务之间复杂的关系，
方便分析整个系统；具体到微观操作，仍然使用面向过程来处理
"""
2.类和对象的理解
# Author : zxy
# Date : 2022/5/20 22:14
# 1.类和对象
"""
类：
类是多个类似事物组成的群体的统称。能够帮助我们快速的理解和判断事物的性质
数据类型：
不同数据类型属于不同的类
使用内置函数type()查看数据类型
例如：
print(type(10))
print(type(20))
对象：
10,20都是Int类之下包含相似的不同个例，这个个例的专业术语称为实例或对象
"""
3.类和对象的创建
# Author : zxy
# Date : 2022/5/20 22:46
# 1.类的创建
"""Student为类的名称，由一个或多个单词组成，每个单词首字母大写，其余小写"""
class Student:
# 直接写在类里的变量，称为类属性
address = '上海'
# name,age为实例属性
def __init__(self,name,age):
self.name = name
self.age = age
# 实例方法
"""在类之外定义的称为函数，在类之内定义的称为方法"""
def info(self):
print('name:',self.name,'age:',self.age)
# 类方法
@classmethod
def cm(cls):
print('类方法')
# 静态方法
@staticmethod
def sm():
print('静态方法')
# 2.对象的创建
"""
对象的创建又称为类的实例化
语法：
实例名=类面()
"""
stu = Student('zxy','01')
print(stu.name)
print(stu.age)
stu.info() # 方法一：对象名.方法名()
Student.info(stu) # 方法二：类名.方法名(类的对象) -》 实际上就算定义处的self
4.类属性-类方法-静态方法
# Author : zxy
# Date : 2022/5/20 23:23
# 类属性、类方法、静态方法
"""
类属性：类中方法外的变量称为类属性，被该类所有对象共享
类方法：使用@classmethod修饰的主法，使用类名点直接访问的方法
静态方法：使用 @staticmethod修饰的主法，使用类名点直接访问的方法
"""
class Student:
# 直接写在类里的变量，称为类属性
address = '上海'
# name,age为实例属性
def __init__(self,name,age):
self.name = name
self.age = age
# 实例方法
"""在类之外定义的称为函数，在类之内定义的称为方法"""
def info(self):
print('name:',self.name,'age:',self.age)
# 类方法
@classmethod
def cm(cls):
print('类方法')
# 静态方法
@staticmethod
def sm():
print('静态方法')
# 类属性调用
print(Student.address)
Student.address = '杭州'
print(Student.address)
# 类方法调用
Student.cm()
# 静态方法的调用
Student.sm()
5.动态绑定属性和方法
# Author : zxy
# Date : 2022/5/20 23:39
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print('my name is ',self.name,', i am', self.age,' years old')
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print('-----------------属性----------------------------')
print('为stu1动态绑定性别属性')
stu1.gender = '女'
print(stu1.name,stu1.age,stu1.gender)
print('为stu2动态绑定ID属性')
stu2.id = 100
print(stu2.name,stu2.age,stu2.id)
print('-----------------方法----------------------------')
def show():
print('测试动态绑定方法')
stu1.show = show
stu1.show()
第十章
1.继承
# Author : zxy
# Date : 2022/5/21 10:01
# 继承
"""
父类：动物
子类：猫 、 狗 、 鸟继承动物的属性
如果一个类没有继承任何类，则默认继承Object
Python支持多继承
定义子类的时候，必须在其构造参数中调用父类的构造函数
"""
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print('姓名：{0},年龄：{1}'.format(self.name,self.age))
# 定义子类
class Student(Person):
def __init__(self,name,age,score):
super().__init__(name,age)
self.score = score
# 定义子类
class Teacher(Person):
def __init__(self,name,age,subject):
super().__init__(name,age)
self.subject = subject
# 测试
stu = Student('zxy',1,100)
stu.info()
2.封装
# Author : zxy
# Date : 2022/5/20 23:57
# 面向对象的三大特征：
"""
封装：提高程序的安全性
将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法
这样就无需关系内部的具体实现细节，从而降低复杂度
在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"_"
继承：提高代码的复用性
多态：提高程序的可扩展性和可维护性
"""
# 封装
class Student:
def __init__(self,name,age):
self.name = name
## age前加两个下划线，表示不希望被类外使用
self.__age = age
def show(self):
print('name is ', self.name,'age is ',self.__age)
# 使用封装方法
try:
stu = Student('张三',20)
stu.show()
print(stu.name)
print(stu.age)
except AttributeError:
print("Error : 'Student' object has no attribute 'age'")
finally:
"""
尽管在类中，age属性被添加两个下划线来表示不可被外部调用
但是可以通过dir查看对象，发现_Student__age的属性
"""
print(dir(stu))
print(stu._Student__age)
3.多态
# Author : zxy
# Date : 2022/5/21 10:01
# 多态
"""
简单的说，多态就算“具有多种形态”，它指的是：
即使不知道一个变量所引用对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，
动态决定调用哪个对象中的方法
"""
# 静态语言和动态语言
# 静态语言如Java
# 动态语言如Python
"""
静态语言实现多态的三个必要条件：
1。继承
2.方法重写
3.父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”，当看到一只鸟走路像鸭子，游泳像鸭子，收起来像鸭子，那么这只鸟就可以被称为鸭子。
在鸭子的类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为
"""
4.方法重写
# Author : zxy
# Date : 2022/5/21 10:01
# 方法重写
"""
如果子类对继承的父类的某个属性或方法不满意，可以在子类中对其进行重写编写
子类重写后的方法中可以通过super().方法名()调用父类中被重写的方法
"""
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print('姓名：{0},年龄：{1}'.format(self.name,self.age))
# 定义子类
class Student(Person):
def __init__(self,name,age,score):
super().__init__(name,age)
self.score = score
def info(self):
super().info()
print('成绩：{0}'.format(self.score))
# 定义子类
class Teacher(Person):
def __init__(self,name,age,subject):
super().__init__(name,age)
self.subject = subject
def info(self):
super().info()
print('学科：{0}'.format(self.subject))
# 测试
stu = Student('zxy',1,100)
stu.info()
tea = Teacher('Mr.zxy',2,'数学')
tea.info()
5.特殊属性
# Author : zxy
# Date : 2022/5/21 10:02
# 特殊方法和特殊属性
"""
特殊属性:
__dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法：
__len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
__new__() : 用于创建对象
__init__() : 对创建的对象进行初始化
"""
class A(object):
pass
class B(object):
pass
class C(A,B):
def __init__(self,name,age):
self.name = name
self.age = age
c = C('zxy',1)
print(c.__dict__) # 实例对象c所有属性的字典
print(C.__dict__) # 类
print(c.__class__) # 输出对象所属类
print(C.__bases__) # 输出C类的父类元素
print(C.__base__) # 输出C类的第一个父类元素
print(C.__mro__) # 查看类的层次结构
print(A.__subclasses__()) # 查看A的子类
6.特殊方法
# Author : zxy
# Date : 2022/5/21 12:12
# 特殊方法和特殊属性
"""
特殊属性:
__dict__ : 获得对象或实例对象所绑定的所有属性和方法的字典
特殊方法：
__len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
__new__() : 用于创建对象
__init__() : 对创建的对象进行初始化
"""
# 测试__add__()
a = 20
b = 30
c = a + b
d = a.__add__(b) ## 调用a的对象__add__()方法
print(c)
print(d)
# __len__() : 通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
# __add__() : 通过重写__add__()方法，可以使用自定义对象具有'+'功能
class Student():
def __init__(self,name):
self.name = name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1 = Student('zzzz')
stu2 = Student('xx')
print('----------------------------__add__()------------------------')
stu3 = stu1 + stu2 # 重写__add__()方法
print(stu3)
print('----------------------------__len__()------------------------')
print(len(stu3))
# __new__() : 用于创建对象
# __init__() : 对创建的对象进行初始化
print('----------------------------__new__()-----__init__()-----------------------------------')
class Person():
def __new__(cls, *args, **kwargs):
print('cls的id为{0}',id(cls))
obj = super().__new__(cls)
print('创建对象ID为{0}'.format(id(obj)))
return obj
def __init__(self,name,age):
print('调用__init__()，self的ID值为{0}'.format(id(self)))
self.name = name
self.age = age
print('object类对象的ID为{0}'.format(id(object)))
print('Person类对象的ID为{0}'.format(id(Person)))
# 创建Person的实例对象
per = Person('zxy',1)
print('per这个实例对象的ID为{0}'.format(id(per)))
7.Object
# Author : zxy
# Date : 2022/5/21 10:01
# Object类
"""
1.Object类 是所有类的父类，因此所有类都有Object类的属性和方法
2.有内置函数dir()可以查看指定对象所有属性
3.Object有一个__str__()方法，用于返回一个对于“对象的描述”，
对于内置函数str()经常用于print()方法，帮我们查看对象的信息，
所以我们经常对__str__()进行重写
"""
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print('姓名：{0}，年龄：{1}'.format(self.name,self.age))
def __str__(self):
return '姓名：{0}，年龄：{1}'.format(self.name,self.age)
obj = object()
print(dir(obj))
per = Person('zxy',1)
print(dir(per))
print(per) # 重写str方法，用于返回对象的描述
8.类的浅拷贝和深拷贝
# Author : zxy
# Date : 2022/5/21 15:22
# 类的浅拷贝和深拷贝
"""
变量的赋值操作
只是形成两个变量，实际上还算指向同一个对象
浅拷贝：
Python拷贝一般是浅拷贝，拷贝时，对象包含的子对象内容不拷贝。
因此，源对象与拷贝对象会引用捅一个子对象。
深拷贝：
使用Copy模块的deepcopy函数，递归拷贝对象中包含的子对象，
源对象和拷贝对象所有的子对象也不相同
"""
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu = cpu
self.disk = disk
# 1.变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
# 2.浅拷贝
import copy
disk = Disk()
com = Computer(cpu1,disk)
com2 = copy.copy(com)
# 浅拷贝，由com复制到com2，发生变化，而子对象disk和cpu不发生变化
print(com,com.cpu,com.disk)
print(com2,com2.cpu,com2.disk)
# 3.深拷贝
com3 = copy.deepcopy(com)
# 深拷贝，由com复制到com3，源对象和子对象都被拷贝，从而发生变化
print(com,com.cpu,com.disk)
print(com3,com3.cpu,com3.disk)
第十一章
1.主程序
# Author : zxy
# Date : 2022/5/21 16:35
# 以主程序运行
"""
在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以
检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其他程序
中执行，那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量值为__main__
"""
def add(a,b):
return a + b
def div(a,b):
try:
return a/b
except ZeroDivisionError:
return 0
if __name__ == '__main__':
print(div(1, 2))
2.包
# Author : zxy
# Date : 2022/5/21 16:42
# Python中的包
"""
包是一个分层次的目录结构，将一组功能相近的模块组织在一个目录下
作用：
代码规范
避免模块名称冲突
包与目录的区别：
包含__init__.py文件的目录称为包,如chapter11/package
目录里统称不包含__init__.py文件,如chapter11/dictory
包的导入：
import 包名.模块名
"""
# 导入package包下的modeA模块
import package.modeA as pac
# 调用包下的modeA模块中的变量a
print(pac.a)
# 调用包下的modeA模块中的方法add()
print(pac.add(1, 2))
3.模块
模块的使用
# Author : zxy
# Date : 2022/5/21 16:26
# 自定义模块
"""
创建模块
新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入模块
import 模块名称 [as 别名]
from 模块名称 import 函数/变量/类
"""
from math import pow
print(pow(2, 3))
# print(math.pi) 这里因为没有导入math模块中的pi,所以会报错
import math
print(math.pi)
print(dir(math))
自定义模块
# Author : zxy
# Date : 2022/5/21 16:12
# 自定义模块
"""
创建模块
新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入模块
import 模块名称 [as 别名]
from 模块名称 import 函数/变量/类
"""
# 指定函数导入
from calc import add
print(add(1,2))
# 导入自定义模块calc的所有函数
import calc
print(calc.add(1,2))
print(calc.div(1,2))
print(calc.div(1,0))
calc
# Author : zxy
# Date : 2022/5/21 16:30
def add(a,b):
return a + b
def div(a,b):
try:
return a/b
except ZeroDivisionError:
return 0
4.Python内置模块
# Author : zxy
# Date : 2022/5/21 17:15
#Python常用的内置模块
"""
sys 与Python解释器及其操作相关的标准库
time 提供与时间相关的各种函数的标准库
os 提供访问操作系统服务功能的标准库
calendar 提供与日期相关的各种函数的标准库
urllib 用于读取来自网上(服务器)的数据标准库
json 用于使用JSON序列化和反序列化对象
re 用于在字符串中执行正则表达式匹配和替换
math 提供标准算术运算函数的标准库
decimal 用于进行精度控制运算精度，有效数位和四舍五入操作的十进制运算
logging 提供了灵活的记录事件、错误、警告和调试信息等日志的功能
"""
import sys
import time
import urllib.request #爬虫常用
import logging
print(sys.getsizeof(20))
print('秒',time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
5.第三方模块的安装和使用
# Author : zxy
# Date : 2022/5/21 17:41
# 安装 pip install 模块名
# pip install schedule
# 使用 import 模块名
import schedule
import time
def run():
print('python')
# 定时调度任务，每三秒执行一次
schedule.every(3).seconds.do(run)
while True:
# 启动调度
schedule.run_pending()
# 每次执行后休息1秒
time.sleep(1)
6.导入注意事项
# Author : zxy
# Date : 2022/5/21 17:08
# 导入模块和包的时候注意事项
# 使用import导入的时候，只能跟包名或模块名
import package
import 主程序
# 使用from ... import导入的时候，可以跟包、模块、函数、变量
from package import modeA
from package.modeA import a
from package.modeA import add
第十二章
1.文件的读写原理
# Author : zxy
# Date : 2022/5/21 18:10
#文件的读写原理
"""
文件的读写俗称IO操作
文件读写操作流程
操作原理
Python操作文件-》打开或新建文件-》读写文件-》关闭资源
通过IO流将磁盘文件中的内容与程序中的对象中的内容进行同步
file = open( filename [,mode,encoding])
file: 被创建的文件对象
open: 创建文件对象的函数
filename: 要创建或打开文件名称
mode: 打开默认只读模式
encoding: 默认文本中字符编写格式为GBK
"""
file = open('file','r')
words = file.readlines()
print(words) # readlines读取到的是列表
file.close()
2.文件对象的常用方法
# Author : zxy
# Date : 2022/5/21 21:22
# 文件对象的常用方法
"""
read((size)) : 从文件读取size个字节或字符内容返回，若省略size，则一次性读完
readline() : 从文本文件中读取一行内容
readlines() : 把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str) : 将字符串str内容写入文件
writelines(list) : 将字符串列表list写入文本文件，不添加换行
seek(offset,[whence]) : 把文件指针移动到新的位置，offset表示相对于whence的位置
offset:为正往结束放心移动
whence不同的值代表不同含义：
0 ： 从文件头开始计算（默认值）
1 ： 从当前位置开始计算
2 ： 从文件尾开始计算
tell()
返回文件指针的当前位置
flush()
把缓冲区的内容写入文件，但不关闭文件
close()
把缓冲区内容写入文件，同时关闭文件，释放文件对象相关资源
"""
3.常见文件打开方法
# Author : zxy
# Date : 2022/5/21 21:01
# 文件的类型
"""
按照文件中数据的组织形式，文件分为以下两大类：
文本文件：通常以Unicode字符集存储，可以使用记事本程序打开，存储的是普通的字符文本
二进制文件：把数据内容用字节存储，无法用记事本打开，必须使用专用的软件，比如mp3,jpg,doc等
打开模式：
r : 只读模式，指针在文件开头
w ： 只写模式，存在则覆盖内容，不存在则创建，指针在文件开头
a : 追加模式，存在则追加，指针在文件末尾、不存在则创建，指针在文件开头
b : 以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb 或者 wb
+ : 以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+
"""
# 只读
file = open('file','r')
words = file.readlines()
print(words)
file.close()
# 只写
file = open('file','w')
lst = ['床前明月光\n','疑似地上霜']
words = file.writelines(lst)
file.close()
# 追加
file = open('file','a')
lst = ['\n举头望明月']
words = file.writelines(lst)
file.close()
# 二进制文件边读边写
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()
4.OS
OS模块常用方法
# Author : zxy
# Date : 2022/5/21 21:51
# os模块
"""
os模块是Python内置的与操作系统功能和文件系统相关的模块，
该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上
运行，得到的结果可能不一样
os模块与os.path模块用于对目录或文件进行操作
getcwd() 返回当前的工作目录
listdir(path) 返回指定路径下的文件和目录信息
mkdir(path,[mode]) 创建目录
makedirs(path1/path2...) 创建多级目录
rmdir(path) 删除目录
removedirs(path1/path2...) 删除多级目录
chdir(path) 设置path为当前工作目录
"""
import os
# 1.调用命令
# os.system('notepad.exe')
# os.system('calc.exe')
# 2.直接调用可执行文件
# os.startfile('D:\\WeChat\\WeChat.exe')
# 3.打开
print(os.getcwd())
# 4.查看指定目录下的文件
print(os.listdir('E:\\BigData\\date\\PyCharm\\May2\\chapter1'))
print(os.listdir('../chapter1'))
# 5.当前目录下创建\删除文件
os.mkdir('test1')
os.rmdir('test1')
# 6.多级目录创建\删除
os.makedirs('test1\\test2')
os.removedirs('test1\\test2')
# 7.修改当前工作目录
os.chdir('E:\\BigData\\date\\PyCharm\\May2\\chapter11')
os.path模块操作目录相关函数
# Author : zxy
# Date : 2022/5/21 22:10
# os.path 模块操作目录相关函数
"""
abspath(path) 用于获取文件或目录的绝对路径
exists(path) 用于判断文件或目录是否存在，如果存在返回True，否则返回False
join(path,name) 将目录与目录或文件名拼接起来
splitext() 分离文件名和扩展名
basename(path) 从一个目录中提取文件名
dirname(path) 从一个路径中提取文件路径，不报错文件名
isdir(path) 用于判断是否为路径
"""
import os.path as path
# 1.绝对路径
print(path.abspath('..'))
# 2.是否存在
print(path.exists('/chapter12'))
# 3.分割
# 3.1 分割目录和文件
print(path.split('/chapter12'))
# 3.2 分割文件名和扩展名
print(path.splitext('chapter12.py'))
# 4.分离文件名
filename = path.basename('/chapter12')
print(filename)
# 5.分离目录
dirname = path.dirname('/chapter12')
print(dirname)
# 6.将目录和文件名连接
print(path.join(dirname, filename))
# 7.是否为路径
print(path.isdir('/chapter12'))
print(path.isdir('chapter12'))
案例_列出指定目录下所有py文件
# Author : zxy
# Date : 2022/5/21 22:38
import os
path = os.getcwd()
lst = os.listdir('E:/BigData/date/PyCharm/May2/chapter12')
lst_files = os.walk('E:/BigData/date/PyCharm/May2/chapter12')
for filename in lst:
# 方法一：os.path模块实现
"""
fileSplit = os.path.splitext(filename)
if fileSplit[1] == '.py':
print(filename)
"""
# 方法二：
if filename.endswith('.py'):
print(filename)
# 2.递归遍历
print('递归遍历'.center(100,'*'))
for dirpath,dirname,filename in lst_files:
# filename 是递归目录下的文件列表
for file in filename:
if file.endswith('.py'):
print(file)
"""
代码：
print(dirpath)
print(dirname)
print(filename)
print('------------')
输出结果：
E:/BigData/date/PyCharm/May2/chapter12
['os']
['Copy.png', 'copy2.png', 'CSDN.png', 'file', 'with语句.py', '常见文件打开模式.py', '文件对象的常用方法.py', '文件的读写原理.py', '编码格式.py']
------------
E:/BigData/date/PyCharm/May2/chapter12\os
[]
['ospath模块操作目录相关函数.py', 'os模块常用函数.py', '案例_列出指定目录下所有py文件.py']
------------
"""
5.with语句
# Author : zxy
# Date : 2022/5/21 21:39
# With语句
"""
with语句可以自动管理上下文资源，不论什么原因跳出with块，
都能确保文件正确的关闭，以此来达到释放资源的目的
"""
# 离开了with，就自动关闭文件
# 遵循上下文管理协议
with open('file','r') as read_file:
print(read_file.read())
# 使用with语句重写，二进制文件边读边写
with open('copy.png','rb') as read_png:
with open('copy2.png','wb') as write_png:
write_png.write(read_png.read())
"""
readPng = open('CSDN.png','rb')
writePng = open('Copy.png','wb')
writePng.write(readPng.read())
readPng.close()
writePng.close()
"""
6.编码格式
# Author : zxy
# Date : 2022/5/21 17:54
# 编码格式
"""
Python的解释器使用的Unicode（内存）
.py文件在磁盘上使用UTF-8存储（外存）,如果需要修改存储类型，在.py文件开头第一行写：#encoding=gbk
"""
# GBK和UTF-8
"""
GBK英文一个字节，汉字两个字节
UTF-8英文一个字节，汉字三个字节
"""
Python十四案例
1.ASCII码
# Author : zxy
# Date : 2022/5/24 23:10
a = 97
for i in range(0,26):
print(chr(a+i),'----->',a+i)
2.enumerate函数
# Author : zxy
# Date : 2022/5/24 23:27
# Desc : enumerate函数，用于获取列表索引和数据
# 1.列表
year = [82,89,88,86,85,00,99]
print('原列表:',year)
for index,value in enumerate(year):
if str(value) != '0':
year[index] = int('19'+str(value))
else:
year[index] = int('200'+str(value))
print('调整后:',year)
# 2.元组
coffice_name = ('蓝山','卡布奇诺','拿铁','皇家咖啡')
print('您好，欢迎光临')
print('本店经营的咖啡有：')
for index,item in enumerate(coffice_name):
print(index+1,'.',item,end=' ')
buy = int(input('\n请输入你想购买的品类:'))
print('你购买的[',coffice_name[buy-1],']咖啡已到货!')
3.wordcount
# Author : zxy
# Date : 2022/5/26 14:24
def wordcount(words,word):
count = 0
for item in words:
if word.upper() == item or word.lower() == item:
count += 1
return count
if __name__ == '__main__':
words = 'helloworldhellopythonhelloJava'
word = 'h'
count = wordcount(words,word)
print(count)
4.修改字体输出颜色
# Author : zxy
# Date : 2022/5/23 23:14
# Desc : 控制输出颜色
# 格式：
# 设置颜色开始 ：\033[显示方式;前景色;背景色m
# 说明：
# 前景色 背景色 颜色
# ---------------------------------------
# 30 40 黑色
# 31 41 红色
# 32 42 绿色
# 33 43 黃色
# 34 44 蓝色
# 35 45 紫红色
# 36 46 青蓝色
# 37 47 白色
# 显示方式 意义
# -------------------------
# 0 终端默认设置
# 1 高亮显示
# 4 使用下划线
# 5 闪烁
# 7 反白显示
# 8 不可见
print('\033[0:35m\t\tPython切换颜色打印\033[m')
print('\033[0:32m\t\tPython切换颜色打印\033[m')
5.列表倒叙输出
# Author : zxy
# Date : 2022/5/26 12:45
# Desc : 列表倒序输出
card = ['1001','1002','1003','1004']
print('正序输出...')
for i in card:
print(i)
print('倒叙输出...')
# 从len(card)-1 到 -1依次输出，步长为-1
for i in range(len(card)-1,-1,-1):
print(card[i])
6.十进制转二八十六
# Author : zxy
# Date : 2022/5/23 23:48
# Desc : 十进制转二进制、八进制、十六进制
def cale():
number = int(input('请输入一个十进制数字:'))
print('你输出的十进制数字为:{}'.format(number))
print('你输出的二进制数字为:{}'.format(bin(number)))
print('你输出的八进制数字为:{}'.format(oct(number)))
print('你输出的十六进制数字为:{}'.format(hex(number)))
if __name__ == '__main__':
while True:
try:
cale()
break
except:
print('你输入有误！！！请重写输入')
7.向文件输入语句
# Author : zxy
# Date : 2022/5/23 21:15
# Desc : 向文件中输入语句
# 方式一：使用print方式输出文字，目的地是文件
fp = open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test1.txt','w')
print('Good Good Study，Day Day Up',file=fp)
fp.close()
# 方式二：是哦那个with上下文管理器
with open('E:\\BigData\\date\\PyCharm\\PythonStudy\\action\\test2.txt','w') as file:
file.write('好好学习，天天向上')
8.字符串分割
# Author : zxy
# Date : 2022/5/28 0:42
class Student(object):
def __init__(self,stu_name,stu_age,stu_gender,stu_score):
self.stu_name = stu_name
self.stu_age = stu_age
self.stu_gender = stu_gender
self.stu_score = stu_score
def show(self):
print(self.stu_name,self.stu_age,self.stu_gender,self.stu_score)
# 列表中存储对象，然后通过对象调用类中函数
if __name__ == '__main__':
print('请输入五位学生信息，(姓名-年龄-性别-成绩)')
lst = []
for i in range(0,2):
s = input(f'请输入入第{i+1}位学生的信息和成绩:')
s_lst = s.split('-')
stu = Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
lst.append(stu)
for item in lst:
item.show()
9.异常抛出
# Author : zxy
# Date : 2022/5/26 14:52
# 手动抛出异常: raise Exception('')
# 自动抛出异常: try...except...
score = int(input('请输入一个分数:'))
try:
if 0 <= score <= 100:
print('分数为:',score)
else:
raise Exception('分数超出范围!!!')
except Exception as e:
print(e)
10.格式化字符串输出
# Author : zxy
# Date : 2022/5/23 23:28
# 格式化字符串输出
height = 170
weight = 50.5
bmi = weight / (height + weight)
# 6种格式化方式
print('身高',height,'的你体重',weight)
print('身高'+str(height)+'的你体重'+str(weight))
print('身高{0}的你体重{1}'.format(height,weight))
print(f'身高{height}的你体重{weight}')
print('身高%s的你体重%s' % (height,weight))
print('你的BMI指标是:' + '{:0.7f}'.format(bmi))
11.格式化时间类型
# Author : zxy
# Date : 2022/5/28 11:00
import time
if __name__ == '__main__':
print(time.time())
print(time.localtime(time.time()))
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
12.登录支付功能
# Author : zxy
# Date : 2022/5/24 0:07
# Desc : 验证登录用户名，密码;设置限制支付密码只允许是数字
def login(username,password):
if username == 'admin' and password == '123456':
print('登录成功！！')
return True
if __name__ == '__main__':
while True:
username = input('请输入用户名:')
password = input('请输入密码:')
if login(username,password):
pay = input('请输入支付密码:')
"""
if条件成立，则将开头的字符串输出，否则输出else后的字符
"""
print('支付密码合法' if pay.isdigit() else '支付密码不合法，只能由数字组成！！')
break
else:
print('账号密码错误，请重新登录！！！')
13.遍历两个列表输出
# Author : zxy
# Date : 2022/5/23 21:22
# Desc : 循环遍历两个列表中数据
# 1.列表输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']
for i in range(len(lst_type)):
print(lst_type[i],':',lst_data[i])
# 2.字典输出
dic_data = {'id':'001','name':'zxy','age':'5'}
for i in dic_data:
# print(i, ':', dic_data[i])
print(i,':',dic_data.get(i))
# 3.列表转元组输出
lst_type = ['id','name','age']
lst_data = ['001','zxy','5']
for i,j in zip(lst_type,lst_data):
print(i,':',j)
# 4.列表转字典输出
dict_list = dict(zip(lst_type, lst_data))
for i in dict_list:
print(i,dict_list[i])
14.列表
# Author : zxy
# Date : 2022/5/26 14:10
phones = set()
for i in range(5):
info = input(f'请输入第{i+1}个朋友的姓名和手机号:')
phones.add(info)
for item in phones:
print(item)
🤝 期待与你共同进步
🌱 亲爱的读者，非常感谢你每一次的停留和阅读！你的支持是我们前行的最大动力！🙏
🌐 在这茫茫网海中，有你的关注，我们深感荣幸。你的每一次点赞👍、收藏🌟、评论💬和关注💖，都像是明灯一样照亮我们前行的道路，给予我们无比的鼓舞和力量。🌟
📚 我们会继续努力，为你呈现更多精彩和有深度的内容。同时，我们非常欢迎你在评论区留下你的宝贵意见和建议，让我们共同进步，共同成长！💬
💪 无论你在编程的道路上遇到什么困难，都希望你能坚持下去，因为每一次的挫折都是通往成功的必经之路。我们期待与你一起书写编程的精彩篇章！ 🎉
🌈 最后，再次感谢你的厚爱与支持！愿你在编程的道路上越走越远，收获满满的成就和喜悦！
关于Python学习指南
如果想要系统学习Python、Python问题咨询，或者考虑做一些工作以外的副业，都可以扫描二维码添加微信，围观朋友圈一起交流学习。
我们还为大家准备了Python资料和副业项目合集，感兴趣的小伙伴快来找我领取一起交流学习哦！
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
包括：Python激活码+安装包、Python web开发，Python爬虫，Python数据分析，人工智能、自动化办公等学习教程。带你从零基础系统性的学好Python！
👉Python所有方向的学习路线👈
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取）
👉Python学习视频600合集👈
观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
温馨提示：篇幅有限，已打包文件夹，获取方式在：文末
👉Python70个实战练手案例&源码👈
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
👉Python大厂面试资料👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
👉Python副业兼职路线&方法👈
学好 Python 不论是就业还是做副业赚钱都不错，但要学会兼职接单还是要有一个学习规划。
👉 这份完整版的Python全套学习资料已经上传，朋友们如果需要可以扫描下方CSDN官方认证二维码或者点击链接免费领取【保证100%免费】
扫一扫
70万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
