入门教程"/>
《Python系列》Python详细入门教程
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")# 原字符-不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前加上r或者R
print(r"http:\\www.baidu")
# 原字符使用-末尾不能使用一个反斜杠结尾会报错，需要的话，使用两个
# print(r"http:\\www.baidu\")
print(r"http:\\www.baidu","\b\\")
第二章：
1.注释
# coding:utf-8
# Author : zxy
# Date : 2022/5/2 19:09# Python代码中的注释
# 注释：
# 提高代码可读性
# 注释内容会被Python解释器忽略
# 三种注释类型：
# 单行注释：以#开头
"""
多行注释：将一对三引号之间代码称为多行注释
"""
# 中文编码声明注释：文件开头加上中文声明注释，用以指定源码文件的编码格式2.标识符
# Author : zxy
# Date : 2022/5/2 15:07import keyword# 查看所有保留字
print(keyword.kwlist)# 标识符规则
# 变量、函数、类、模块和其他对象起的名字就叫标识符
# 规则：
# 1.字母、数字、下划线
# 2.不能以数字开头
# 3.不能是保留字
# 4.严格区分大小写3.变量
# Author : zxy
# Date : 2022/5/2 15:13name = '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 worldpython""")
# 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 = 1000s = int(input('请输入取款金额：'))if(money >= s):money -= sprint('取款成功，剩余金额为：',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"""循环结构whilefor - in
"""
def test1():a = 1while a < 10:print(a)a += 1
# 计算0到10的累加
def sum():'''初始化变量'''sum = 0a = 0'''条件判断'''while a <= 10:'''条件执行体'''sum += aa += 1print(sum)
# 1到100偶数和
def number():sum = 0i = 0while i <= 100:if i % 2 == 0:sum += ii+=1print('while计算求和',sum)
def number2():sum = 0for item in range(1,101):if item % 2 == 0:sum += itemprint('for-in计算求和:',sum)# 100 到 1000 的水仙花
def water():for item in range(100,1001):ge = item % 10shi = item // 10 % 10bai = item // 100if 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('密码正确')breakelse :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:continueprint(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()以下对象的布尔值为FalseFalse数值0None空字符串空列表空元组空字典空集合
"""
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() ,一次删除一个指定元素，如果指定元素不存在抛出异常KeyErrordiscord(),一次删除指定元素，如果指定元素不存在不抛出异常调用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:]=lst3print('切片替换，从下标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'] = 100print("增加key='zxy',value='100",scores)# 修改元素scores['zxy'] = 99print('key是唯一的，如果重复新增，会覆盖原有值：',scores)# 6.获取字典试图的三种方法
"""keys() 获取字典中所有keyvalues() 获取字典中所有valueitems() 获取字典中所有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 = 18print('我叫%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 + bif __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,evenif __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:49def 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+bif __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 cc = 'hello java'print('局部变量',a)print('global局部变量转全局变量',c)
if __name__ == '__main__':print('全局变量', b)fun()# global将局部变量转为全局变量，定义在fun()函数中，需要先调用fun()函数，才能使用全局变量cprint('global局部变量转全局变量',c)
7.递归函数
# Author : zxy
# Date : 2022/5/4 21:48#递归函数
"""
什么是递归函数？如果在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数
递归的组成部分？递归调用与递归终止条件
递归的调用过程？每递归调用一次函数，都会在栈内存分配一个栈帧每执行完一次函数，都会释放相应的空间
递归的优缺点？缺点：占用内存多，效率底下优点：思路和代码简单
"""def fun(n):if n == 1:return 1else: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 1elif n == 2:return 1else: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.索引越界：indexErrorlst = [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 / n2print('结果为：',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 tracebacktry: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 = nameself.age = age# 实例方法"""在类之外定义的称为函数，在类之内定义的称为方法"""def info(self):print('name:',self.name,'age:',self.age)# 类方法@classmethoddef cm(cls):print('类方法')# 静态方法@staticmethoddef 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 = nameself.age = age# 实例方法"""在类之外定义的称为函数，在类之内定义的称为方法"""def info(self):print('name:',self.name,'age:',self.age)# 类方法@classmethoddef cm(cls):print('类方法')# 静态方法@staticmethoddef sm():print('静态方法')# 类属性调用
print(Student.address)
Student.address = '杭州'
print(Student.address)# 类方法调用
Student.cm()# 静态方法的调用
Student.sm()
5.动态绑定属性和方法
# Author : zxy
# Date : 2022/5/20 23:39class Student:def __init__(self,name,age):self.name = nameself.age = agedef 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 = nameself.age = agedef 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 = agedef 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 = nameself.age = agedef 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 = scoredef info(self):super().info()print('成绩：{0}'.format(self.score))# 定义子类
class Teacher(Person):def __init__(self,name,age,subject):super().__init__(name,age)self.subject = subjectdef 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 = nameself.age = agec = 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 = namedef __add__(self, other):return self.name + other.namedef __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 objdef __init__(self,name,age):print('调用__init__()，self的ID值为{0}'.format(id(self)))self.name = nameself.age = ageprint('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 = nameself.age = agedef 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 = cpuself.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 + bdef div(a,b):try:return a/bexcept ZeroDivisionError:return 0if __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 powprint(pow(2, 3))
# print(math.pi) 这里因为没有导入math模块中的pi,所以会报错import mathprint(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:30def add(a,b):return a + bdef div(a,b):try:return a/bexcept 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('').read())5.第三方模块的安装和使用
# Author : zxy
# Date : 2022/5/21 17:41# 安装 pip install 模块名
# pip install schedule
# 使用 import 模块名import schedule
import timedef 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:38import ospath = 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系列》Python详细入门教程
发布评论