Python
Posted Mr.zhou_Zxy
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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.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().__i以上是关于Python的主要内容，如果未能解决你的问题，请参考以下文章