python基础教程--代码集合（下）

38.字典dict

38.1 创建字典

字典：python内置的数据结构之一，与列表一样，是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列
字典的实现原理
字典的实现原理与查字典类似，python中的字典是根据key查找value所在的位置
常用的创建字典方式

# 字典：python内置的数据结构之一，与列表一样，是一个可变序列
# 以键值对的方式存储数据，字典是一个无序的序列
scores={'张三':100,'李四':200,'王五':300}
# 字典的实现原理
# 字典的实现原理与查字典类似，python中的字典是根据key查找value所在的位置
# 常用的创建字典方式
scores={'张三':100,'李四':200,'王五':300}
print(scores,type(scores) )

student=dict(name='jack',age=20)
print(student,type(student))

# 空字典
d={}
print(d,type(d))

结果

{'张三': 100, '李四': 200, '王五': 300} <class 'dict'>
{'name': 'jack', 'age': 20} <class 'dict'>
{} <class 'dict'>

进程已结束,退出代码0

38.2 字典获取元素

# 字典中获取元素
scores={'张三':100,'李四':200,'王五':300}
# 第一种方式，使用[]
print(scores['张三'])
print('scores[\'老刘\']', '[]方式 如果键不存在的话，会报错')

# 第二种方式，使用get()方法
print(scores.get('张三'))
print(scores.get('老刘'),'get()方式 键不存在的话会输出None')
print(scores.get('麻雀',99),'如果不存在输出默认值99')

结果

100
scores['老刘'] []方式 如果键不存在的话，会报错
100
None get()方式 键不存在的话会输出None
99 如果不存在输出默认值99

进程已结束,退出代码0

38.3 key字典

# key的判断
scores={'张三':100,'李四':200,'王五':300}
print('张三'in scores)
print('张三' not in scores)

del scores['张三']
scores.clear()
print(scores)
print('clear表示清空字典，del删除字典键值对')
scores['陈留']=98
print(scores,'新增键值对')
scores['陈留']=100
print(scores,'修改键值对')

结果

True
False
{}
clear表示清空字典，del删除字典键值对
{'陈留': 98} 新增键值对
{'陈留': 100} 修改键值对

进程已结束,退出代码0

38.4key-value-items键值对

# 获取字典视图
print('keys():获取字典中所有key')
print('value：()获取字典中所有value')
print('items():获取字典中所有key,value对')
scores={'张三':100,'李四':200,'王五':300}
# 获取所有的key
keys=scores.keys()
print(keys,'获取所有的keys',type(keys))
print(list(keys),type(list(keys)),'将所有的keys组成的视图装换为列表')

# 所有的value
values=scores.values()
print(values,type(values),'获取所有的values')
print(list(values),type(list(values)),'将所有的values组成的视图装换为列表')

# 获取所有的key-value对
items=scores.items()
print(items,'获取所有的key-value对')
print(list(items),type(list(items)),'转换之后的列表元素是由元组组成')

结果

keys():获取字典中所有key
value：()获取字典中所有value
items():获取字典中所有key,value对
dict_keys(['张三', '李四', '王五']) 获取所有的keys <class 'dict_keys'>
['张三', '李四', '王五'] <class 'list'> 将所有的keys组成的视图装换为列表
dict_values([100, 200, 300]) <class 'dict_values'> 获取所有的values
[100, 200, 300] <class 'list'> 将所有的values组成的视图装换为列表
dict_items([('张三', 100), ('李四', 200), ('王五', 300)]) 获取所有的key-value对
[('张三', 100), ('李四', 200), ('王五', 300)] <class 'list'> 转换之后的列表元素是由元组组成

进程已结束,退出代码0

38.5字典的遍历

# 字典元素的遍历
scores={'张三':100,'李四':200,'王五':300}

for i in scores:
    print(i,scores.get(i),scores[i],'scores.get(i),scores[i]都是输出字典的值')

结果

张三 100 100 scores.get(i),scores[i]都是输出字典的值
李四 200 200 scores.get(i),scores[i]都是输出字典的值
王五 300 300 scores.get(i),scores[i]都是输出字典的值

进程已结束,退出代码0

38.6 哈希函数haxi

d={'name':'张三','name':'李四'}
print(d,'key键是不可以重复的')

d={'name':'张三','nickname':'张三'}
print(d,'说明字典的value是可以重复的')

lst =[10,20,30]
lst.insert(1,100)
print(lst)
print('字典中的元素是无序的,不可以在任意位置插入元素','字典的key必须是不可变对象','字典也可以根据需要动态地伸缩','字典会浪费较大的内存，是一种使用空间换时间的数据结构')
print('哈希函数haxi')

结果

{'name': '李四'} key键是不可以重复的
{'name': '张三', 'nickname': '张三'} 说明字典的value是可以重复的
[10, 100, 20, 30]
字典中的元素是无序的,不可以在任意位置插入元素 字典的key必须是不可变对象 字典也可以根据需要动态地伸缩 字典会浪费较大的内存，是一种使用空间换时间的数据结构
哈希函数haxi

进程已结束,退出代码0

39.可变序列与不可变序列

39.1可变序列：列表，字典

39.2不可变序列，字符串，元组

'可变序列：列表，字典'
lst=[10,20,50]
print(id(lst))
lst.append(100)
print(id(lst),lst)

'不可变序列，字符串，元组'
s='hello'
print(id(s))
s=s+'world'
print(id(s))
print(s)
print('列表以方括号进行存储，元组以（）进行存储')

结果

2599109284232
2599109284232 [10, 20, 50, 100]
2599114381360
2599116461744
helloworld
列表以方括号进行存储，元组以（）进行存储

进程已结束,退出代码0

40.元组tuple

40.1创建元组

'元组的创建方式'
print('-'*20,'tuple元组：第一种使用（）','-'*20)
t=('python','world',98)
print(t,type(t))

t2='python','world',98
print(t2,type(t2))

t3='python',
print(t3,type(t3),'如果只包含一个元素需要进行加逗号进行分割')

print('-'*20,'tuple元组：第二种使用（）','-'*20)
t1=tuple(('python','world',98))
print(t1,type(t1))

print('-'*20,'空列表的创建方式','-'*20)
lst=[]
lst1=list()
print(lst,type(lst))
print(lst1,type(lst1))

print('-'*20,'空字典','-'*20)
d={}
d2=dict()
print(d,d2,type(d),type(d2))

print('-'*20,'空元组','-'*20)
t4=()
t5=tuple()
print(t4,t5,type(t4),type(t5))

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

结果

-------------------- tuple元组：第一种使用（） --------------------
('python', 'world', 98) <class 'tuple'>
('python', 'world', 98) <class 'tuple'>
('python',) <class 'tuple'> 如果只包含一个元素需要进行加逗号进行分割
-------------------- tuple元组：第二种使用（） --------------------
('python', 'world', 98) <class 'tuple'>
-------------------- 空列表的创建方式 --------------------
[] <class 'list'>
[] <class 'list'>
-------------------- 空字典 --------------------
{} {} <class 'dict'> <class 'dict'>
-------------------- 空元组 --------------------
() () <class 'tuple'> <class 'tuple'>
空列表 [] []
空字典 {} {}
空元组 () ()

进程已结束,退出代码0

40.2 元组的不可变性

print('为什么要将元组设计成不可变序列')
print('在多任务环境下，同样操作对象时不需要加锁')
print('因此，在程序中尽量使用不可变序列')
print('注意事项')
print('元组中的存储是对象的引用')
print('1.如果元组中对象本身不可变对象，则不能再引入其他对象')
print('2.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但是数据可以改变')

t=(10,[20,30],9)
t1=tuple((10,[20,30],9))
t2=10,[20,30],9
t3=10,[20,30],9,
print(t,t1,t2,t3,type(t),type(t1),type(t2),type(t3),id(t))
print(t[0],t[1],t[2],type(t[0]),type(t[1]),type(t[2]),id(t[1]))
print('尝试将t[1]修改为100',id(t[1]))
# t[1]=100
print('t[1]=100会报错，因为元组不支持修改，不可变对象，不允许修改对象')
print('由于[20,30]列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变')
t[1].append(100)
print(t,id(t[1]))

结果

为什么要将元组设计成不可变序列
在多任务环境下，同样操作对象时不需要加锁
因此，在程序中尽量使用不可变序列
注意事项
元组中的存储是对象的引用
1.如果元组中对象本身不可变对象，则不能再引入其他对象
2.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但是数据可以改变
(10, [20, 30], 9) (10, [20, 30], 9) (10, [20, 30], 9) (10, [20, 30], 9) <class 'tuple'> <class 'tuple'> <class 'tuple'> <class 'tuple'> 2582380213016
10 [20, 30] 9 <class 'int'> <class 'list'> <class 'int'> 2582377812360
尝试将t[1]修改为100 2582377812360
t[1]=100会报错，因为元组不支持修改，不可变对象，不允许修改对象
由于[20,30]列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变
(10, [20, 30, 100], 9) 2582377812360
进程已结束,退出代码0

40.3元组遍历

print('元组的遍历')

t=('python','world',98)
print(t[0],t[1],t[2])
# print(t[3])     IndexError: tuple index out of range
print('遍历元祖')
for item in t:
    print(item)

结果

元组的遍历
python world 98
遍历元祖
python
world
98

进程已结束,退出代码0

41.集合set

41.1 创建集合set

print('集合','python语言中提供的内置数据结构','与列表、字典一样都属于可变数据类型的序列','集合斯没有value的字典')
print('-'*20,'第一种创建方式{}','-'*20)
s={664,2,3,4,0,5,6,78,9,7,2,3,5,7}
print(s,'集合不能重复')

print('-'*20,'第二种创建方式set（range()）','-'*20)
s1=set(range(6))
print(s1,type(s1))

print('-'*20,'第三种创建方式set（[ ]）','-'*20)
s2=set([1,2,4,5,5,6,6,7,8,9,1,5])
print(s2,type(s2))

print('-'*20,'第四种创建方式set(元组)','-'*20)
s3=set((1,2,3,44,4,4,44,5,674))
print(s3,type(s3),'集合中的元素是无序的')

s4=set('python')
print(s4,type(s4))

s5=set({12,4,65,48,67,45,1,4,2})
print(s5,type(s5))

print('定义一个空集合')
s6={}
print(type(s6),'这样不可以定义一个空集合，这样成了字典类型')

s7=set()
print(type(s7),'这样的类型才是集合set')

结果

集合 python语言中提供的内置数据结构 与列表、字典一样都属于可变数据类型的序列 集合斯没有value的字典
-------------------- 第一种创建方式{} --------------------
{0, 2, 3, 4, 5, 6, 7, 9, 78, 664} 集合不能重复
-------------------- 第二种创建方式set（range()） --------------------
{0, 1, 2, 3, 4, 5} <class 'set'>
-------------------- 第三种创建方式set（[ ]） --------------------
{1, 2, 4, 5, 6, 7, 8, 9} <class 'set'>
-------------------- 第四种创建方式set(元组) --------------------
{1, 2, 3, 4, 5, 674, 44} <class 'set'> 集合中的元素是无序的
{'t', 'h', 'n', 'p', 'y', 'o'} <class 'set'>
{65, 1, 67, 4, 2, 12, 45, 48} <class 'set'>
定义一个空集合
<class 'dict'> 这样不可以定义一个空集合，这样成了字典类型
<class 'set'> 这样的类型才是集合set

进程已结束,退出代码0

41.2 集合的相关操作

print('集合的相关操作')

s={10,20,30,40,5,106,0}
print(s)
print('-'*50,'集合元素的判断操作','-'*50)
print(10 in s,100 in s,10 not in s,100 not in s)

print('-'*50,'集合元素的新增操作','-'*50)
s.add(100)
print(s,'add()添加元素功能(单个元素)')
s.update({200,300,740})
print(s,'update()增加多个元素')
s.update([1000,6,0,46,2])
s.update((105,8,5,6))
print(s)

print('-'*50,'集合元素的删除操作','-'*50)
s.remove(1000)
print(s)
# s.remove(500)
print(s,'s.remove(500)如果指定元素存在则删除，不存在则会报错')
s.discard(500)
print(s,'s.discard(500)如果指定元素存在则删除，不存在不报错')
s.pop()
print(s,'s.pop()删除指定元素，不能添加参数')
# s.clear()
print(s,'# s.clear()清空所有元素')

结果

集合的相关操作
{0, 5, 40, 10, 106, 20, 30}
-------------------------------------------------- 集合元素的判断操作 --------------------------------------------------
True False False True
-------------------------------------------------- 集合元素的新增操作 --------------------------------------------------
{0, 100, 5, 40, 10, 106, 20, 30} add()添加元素功能(单个元素)
{0, 100, 5, 740, 40, 200, 10, 106, 300, 20, 30} update()增加多个元素
{0, 2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 1000, 46, 105, 8, 20, 30}
-------------------------------------------------- 集合元素的删除操作 --------------------------------------------------
{0, 2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 46, 105, 8, 20, 30}
{0, 2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 46, 105, 8, 20, 30} s.remove(500)如果指定元素存在则删除，不存在则会报错
{0, 2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 46, 105, 8, 20, 30} s.discard(500)如果指定元素存在则删除，不存在不报错
{2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 46, 105, 8, 20, 30} s.pop()删除指定元素，不能添加参数
{2, 100, 5, 740, 6, 40, 200, 10, 106, 300, 46, 105, 8, 20, 30} # s.clear()清空所有元素

进程已结束,退出代码0

41.3集合：交集、并集、差集、堆成差集

print('集合的数学操作')

print('交集')
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2,'intersection与&是等价的')

print('并集操作')
print(s1.union(s2))
print(s1 | s2,'union与 | 等价，并集操作')
print(s1,s2,'并集操作元集合不发生变化')

print('差集操作')
print(s1.difference(s2))
print(s1-s2,'difference与 - 是相同的')
print(s1,s2,'差集操作元集合不发生变化')

print('对称差集')
print(s1.symmetric_difference(s2))
print(s1^s2,'symmetric_difference与 ^是等价的')

结果

集合的数学操作
交集
{40, 20, 30}
{40, 20, 30} intersection与&是等价的
并集操作
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30} union与 | 等价，并集操作
{40, 10, 20, 30} {40, 50, 20, 60, 30} 并集操作元集合不发生变化
差集操作
{10}
{10} difference与 - 是相同的
{40, 10, 20, 30} {40, 50, 20, 60, 30} 差集操作元集合不发生变化
对称差集
{50, 10, 60}
{50, 10, 60} symmetric_difference与 ^是等价的

进程已结束,退出代码0

41.4 集合生成式

print('列表生成式')
lst=[i*i for i in range(100)]
print(lst)

print('集合生成式')
s= { i*i for i in range(100)}
print(s)

结果

列表生成式
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801]
集合生成式
{0, 1, 1024, 4096, 4, 9216, 9, 16, 529, 3600, 4624, 25, 36, 2601, 49, 7225, 3136, 64, 576, 1089, 1600, 2116, 5184, 6724, 7744, 9801, 81, 8281, 6241, 100, 625, 121, 4225, 1156, 8836, 3721, 144, 1681, 2704, 5776, 4761, 2209, 676, 169, 3249, 9409, 196, 1225, 5329, 729, 225, 1764, 7396, 6889, 7921, 2809, 256, 2304, 6400, 3844, 4356, 784, 1296, 8464, 289, 3364, 4900, 5929, 1849, 9025, 324, 841, 1369, 2401, 2916, 5476, 361, 3969, 900, 9604, 4489, 400, 1936, 7056, 7569, 3481, 6561, 1444, 8100, 5041, 441, 961, 2500, 6084, 8649, 3025, 484, 2025, 1521, 5625}

进程已结束,退出代码0

42 字符串

42.1 字符串的驻流机制

print('字符串的驻流机制')

a='python'
b="python"
c="""python"""
d='''python'''
print(a,b,c,d,id(a),id(b),id(c),id(d))
print('''仅保存一份相同且不可变字符串的方法，
不同的值被存放在字符串的驻留池中，
python的驻留机制对相同的字符串只保留一份拷贝，
后续创建相同的字符串时不会开辟新空间，
而是把该字符串的地址付给新创建的变量''')
print()

print('''驻留机制的几种情况（交互模式）：
字符串的长度为0或者1时；
符合标识符的字符串；
字符串只在编译时进行驻留，而非运行时；
[-5,256]之间的整数数字''')
s1 ='abc%'
s2='abc%'
print(s1 is s2,'False,在python中运行')
import sys
s1=sys.intern(s2)
print(s1 is s2)

print('''sys中的intern方法强制2个字符串指向同一个对象,pycharm对字符串进行了优化处理，所以不用pycharm''')

结果

字符串的驻流机制
python python python python 3064662398448 3064662398448 3064662398448 3064662398448
仅保存一份相同且不可变字符串的方法，
不同的值被存放在字符串的驻留池中，
python的驻留机制对相同的字符串只保留一份拷贝，
后续创建相同的字符串时不会开辟新空间，
而是把该字符串的地址付给新创建的变量

驻留机制的几种情况（交互模式）：
字符串的长度为0或者1时；
符合标识符的字符串；
字符串只在编译时进行驻留，而非运行时；
[-5,256]之间的整数数字
True False,在python中运行
True
sys中的intern方法强制2个字符串指向同一个对象,pycharm对字符串进行了优化处理，所以不用pycharm

进程已结束,退出代码0

42.2 字符串的查询操作

print('字符串的查询操作')

s='hello,hello'
print(s.index('lo'),'如果不存在会报错')
print(s.find('lo'),'如果不存在不会报错')
print(s.rindex('lo'),'如果不存在会报错')
print(s.rfind('lo'),'如果不存在不会报错')
print(s.find('k'))
print(s.find('e'))

结果

字符串的查询操作
3 如果不存在会报错
3 如果不存在不会报错
9 如果不存在会报错
9 如果不存在不会报错
-1
1

进程已结束,退出代码0

42.3 字符串的大小写转换方法

print('字符串的大小写转换方法')
print('''upper()把字符串中所有字符都转成大写字母；
lower()把字符串中所有字符都转成小写字母；
swapcase()把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母；
capitalize()把第一个字符转换成大写，把其余字符转换成小写；
title()把每个单词的第一个字符转换成大写，把每个单词的剩余字符转换成小写
''')

s='hello world python'
a=s.upper()
print(s,a,id(s),id(a),'upper把字符串中所有字符都转成大写字母：转换之后，会产生一个新的字符串对象')
b=s.lower()
print(s,b,id(s),id(b),'lower把字符串中所有字符都转成小写字母：转换之后的字符串对象不一样')
print(s==b,s is b,'说明他们的内容是相等的、地址是不相等，没有驻留')
c=s.swapcase()
print(s,c,id(s),id(c),'swapcase把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母：字符串对象不一样')

print(s.title(),'title()把每个单词的第一个字符转换成大写，把每个单词的剩余字符转换成小写')

结果

字符串的大小写转换方法
upper()把字符串中所有字符都转成大写字母；
lower()把字符串中所有字符都转成小写字母；
swapcase()把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母；
capitalize()吧第一个字符转换成大写，把其余字符转换成小写；
title()把每个单词的第一个字符转换成大写，把每个单词的剩余字符转换成小写

hello world python HELLO WORLD PYTHON 2569941913808 2569941580736 upper把字符串中所有字符都转成大写字母：转换之后，会产生一个新的字符串对象
hello world python hello world python 2569941913808 2569942016768 lower把字符串中所有字符都转成小写字母：转换之后的字符串对象不一样
True False 说明他们的内容是相等的、地址是不相等，没有驻留
hello world python HELLO WORLD PYTHON 2569941913808 2569943743184 swapcase把字符串中所有大写字母转换成小写字母，把所有小写字母转换成大写字母：字符串对象不一样
Hello World Python title()把每个单词的第一个字符转换成大写，把每个单词的剩余字符转换成小写

进程已结束,退出代码0

42.4 字符串对齐方法

print('字符串内容对其操作的方法')

print('''center()居中对齐
ljust（）左对齐
rjust()右对齐
zfill()右对齐''')

s='hello,Python'
s1=s.center(20,'*')
print(s1,'center()居中对齐,默认空格')
s2=s.ljust(20,'*')
print(s2,'ljust（）左对齐，默认空格，如果格数小于字符串数量就不用补空格')
s3=s.rjust(20,'*')
print(s3,'rjust()右对齐')
s4=s.zfill(20)
print(s4,'zfill()右对齐:用0进行填充')

print('-8910'.zfill(8))

结果

字符串内容对其操作的方法
center()居中对齐
ljust（）左对齐
rjust()右对齐
zfill()右对齐
****hello,Python**** center()居中对齐,默认空格
hello,Python******** ljust（）左对齐，默认空格，如果格数小于字符串数量就不用补空格
********hello,Python rjust()右对齐
00000000hello,Python zfill()右对齐:用0进行填充
-0008910

进程已结束,退出代码0

42.5 字符串的分割

print('字符串的分割')
s='hello world Python'
lst=s.split()
print(lst)
s1='hello|world|Python'
print(s1.split(),'按空格进行切分')
print(s1.split(sep='|'),'按|进行切分')
print(s1.split(sep='|'),'sep参数按|进行切分')
print(s1.split(sep='|',maxsplit=1),'按|进行切分,maxsplit表示最大分成几段')

print(s.rsplit())
print(s1.rsplit('1'))
print(s1.rsplit(sep='|',maxsplit=1),'rsplit()从右侧开始切分')

结果

字符串的分割
['hello', 'world', 'Python']
['hello|world|Python'] 按空格进行切分
['hello', 'world', 'Python'] 按|进行切分
['hello', 'world', 'Python'] sep参数按|进行切分
['hello', 'world|Python'] 按|进行切分,maxsplit表示最大分成几段
['hello', 'world', 'Python']
['hello|world|Python']
['hello|world', 'Python'] rsplit()从右侧开始切分

进程已结束,退出代码0

42.6 判断字符串操作的常用方法

print('判断字符串操作的常用方法')
print('-'*20,'isidentifier()判断指定的字符串是不是合法的标识符','-'*20)
s='hello ,python'
print('1',s.isidentifier())
print('2','hello'.isidentifier())
print('3','张三_'.isidentifier())
print('4','张三_123'.isidentifier())

print('5','\t'.isspace(),'isspace()判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）')

print('6','abc'.isalpha(),'isalpha()判断指定的字符串是否全部由字母组成')
print('7.','张三'.isalpha())
print('8.','张三1'.isalpha())

print('9','123'.isdecimal(),'isdecimal()判断指定字符串是否全部由十进制数字组成')
print('10','123四'.isdecimal())


print('12.','456'.isnumeric(),'isnumeric()判断指定的字符串是否全部由数字组成')
print('13.','123四'.isnumeric())

# isalnum()判断指定的字符串是否全部由字母和数字组成
print('15','abc1'.isalnum(),'isalnum()判断指定的字符串是否全部由字母和数字组成')
print('16','张三123'.isalnum())

结果

判断字符串操作的常用方法
-------------------- isidentifier()判断指定的字符串是不是合法的标识符 --------------------
1 False
2 True
3 True
4 True
5 True isspace()判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）
6 True isalpha()判断指定的字符串是否全部由字母组成
7. True
8. False
9 True isdecimal()判断指定字符串是否全部由十进制数字组成
10 False
12. True isnumeric()判断指定的字符串是否全部由数字组成
13. True
15 True isalnum()判断指定的字符串是否全部由字母和数字组成
16 True

进程已结束,退出代码0

42.7 字符串的比较操作

print('字符串的比较操作')

print('apple'>'app')
print('apple'>'balance')
print(ord('a'),ord('b'))
print(ord('杨'))

print('==与is的区别：==比较的是value，is比较的是id是否相等')
a=b='python'
c='python'
print(a==b,b==c,a is b,a is c,id(a),id(b),id(c))

结果

字符串的比较操作
True
False
97 98
26472
==与is的区别：==比较的是value，is比较的是id是否相等
True True True True 1158283438192 1158283438192 1158283438192

进程已结束,退出代码0

42.8 字符串的切片操作

print('字符串的切片操作')

print('字符串时不可变类型：不具备增、删、改等操作；切片操作将产生新的对象')
print('切片后产生新的操作对象')

s='hello,Python'
s1=s[:5]
s2=s[6:]
print(s1,s2)
print(s1+'!'+s2)
print(id(s),id(s1),id(s2))
print('-'*20,'[start；end:step]','-'*20)
print(s[1:5:1],'从1到5不包含5，步长为1')
print(s[::2],'默认从0到最后一个元素，步长为2')
print(s[1:5:],'从1到5结束，默认步长为1')
print(s[::-1],'默认从最后一个开始到第一个')
print(s[-6::1],'从-6开始到最后一个元素结束，默认步长为1')

结果

字符串的切片操作
字符串时不可变类型：不具备增、删、改等操作；切片操作将产生新的对象
切片后产生新的操作对象
hello Python
hello!Python
2454151239664 2454153330800 2454150911472
-------------------- [start；end:step] --------------------
ello 从1到5不包含5，步长为1
hloPto 默认从0到最后一个元素，步长为2
ello 从1到5结束，默认步长为1
nohtyP,olleh 默认从最后一个开始到第一个
Python 从-6开始到最后一个元素结束，默认步长为1

进程已结束,退出代码0

42.9 格式化字符串

print('格式化字符串')
print('''格式化字符串三种方法
1.  %   
2.  format
3.  f
''')
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
print('我叫{0},今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁')

结果

格式化字符串
格式化字符串三种方法
1.  %   
2.  format
3.  f

我叫张三,今年20岁
我叫张三,今年20岁
我叫张三,今年20岁

进程已结束,退出代码0

print('%10d' % 99,'%d表示宽度')
print('%.2f' % 3.1415926,'%f表示保留几位有效小数，3表示小数点后三位')
print('%10.3f' % 3.1415926,'10表示总宽度为10，小数点位后三位')
print('helloworld')

结果

        99 %d表示宽度
3.14 %f表示保留几位有效小数，3表示小数点后三位
     3.142 10表示总宽度为10，小数点位后三位
helloworld

进程已结束,退出代码0

print('{0:.3}'.format(3.1415926),'表示一共是三位数')
print('{0:.3f}'.format(3.1415926),'表示一共是三位小数，0可以省略')
print('{0:10.3}'.format(3.1415926),'表示宽度为10，三位小数')

结果

3.14 表示一共是三位数
3.142 表示一共是三位小数，0可以省略
      3.14 表示宽度为10，三位小数

进程已结束,退出代码0

42.10 字符串的编码

print('字符串的编码转换：编码将字符串转换为二进制数据（bytes）,解码将bytes类型数据转换为字符串类型数据')
s='天涯共此时'
print('编码')
print(s.encode(encoding='GBK'),'在GBK这种编码格式中，一个中文占两个字节')
print(s.encode(encoding='UTF-8'),'在UTF-8这种编辑格式中，一个中文占三个字节')

print('解码')
print('byte代表就是一个二进制数据（字节类型的数据）')
byte=s.encode(encoding='GBK')
print(byte.decode(encoding="GBK"))

byte1=s.encode(encoding='UTF-8')
print(byte1.decode(encoding="UTF-8"),'用什么编码就得用什么解码') # 用什么编码就得用什么解码

结果

字符串的编码转换：编码将字符串转换为二进制数据（bytes）,解码将bytes类型数据转换为字符串类型数据
编码
b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1' 在GBK这种编码格式中，一个中文占两个字节
b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6' 在UTF-8这种编辑格式中，一个中文占三个字节
解码
byte代表就是一个二进制数据（字节类型的数据）
天涯共此时
天涯共此时 用什么编码就得用什么解码

进程已结束,退出代码0

43 函数

43.1 形参和实参

def calc(a,b): # a,b称为形式参数，简称形参，形参的位置在函数的定义处
    c=a+b
    return c
result=calc(1,2) #1,2称为实际参数的值，简称为实参，实参的位置是函数的调用处
print(result)

res=calc(b=10,a=20)     #=左边的变量的名称称为 关键字参数
print(res)

结果

3
30

进程已结束,退出代码0

43.2 函数参数传递

print('函数参数传递')
def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1',arg1)
    print('arg2',arg2)

n1=11
n2=[22,33,44]

fun(n1,n2)  #将位置传参，arg1与argue2是函数定义处的形参，n1,n2是函数调用处的实参。总结：实参名称与形参名称可以不一致

'''在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体的修改会影响到实参的值'''

结果

函数参数传递
arg1= 11
arg2= [22, 33, 44]
arg1 100
arg2 [22, 33, 44, 10]

进程已结束,退出代码0

def fun(num):
    odd= []
    even=[]
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even
lst=[10,24,32,54,85,78,82,77,44,553]
print(fun(lst))

print('''函数返回值
（1）如果函数没有返回值，函数自行完毕之后，不需要给调用处提供数据，return可以省略不写
（2）函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回的结果是元组''')
def fun1():
    print('hello')

fun1()


def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3():
    return 'hello','world'
print(fun3())

print('函数在定义时，是否需要返回值，视情况而定')

结果

([85, 77, 553], [10, 24, 32, 54, 78, 82, 44])
函数返回值
（1）如果函数没有返回值，函数自行完毕之后，不需要给调用处提供数据，return可以省略不写
（2）函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回的结果是元组
hello
hello
('hello', 'world')
函数在定义时，是否需要返回值，视情况而定

进程已结束,退出代码0

43.3 函数的调用

def fun(a,b=10):
    print(a,b)

# 函数的调用
fun(100)
fun(20,30)

结果

100 10
20 30

进程已结束,退出代码0

def fun(*args): # 函数定义时的可变位置参数
    print(args)

fun(10)
fun(10,30)
fun(30,40,50)

def fun1(**args):
    print(args)

fun1(a=10)
fun1(a=20,b=20,c=30)

'''def dun2(*args,*a):
    pass
    以上代码，程序会报错，个数可变的位置参数只能是1个
    def fun2(**args,**args):
    pass
    以上代码，程序会报错，个数可变的关键字参数，只能是一个
    '''
def fun2(*args1,**args2):
    pass
# def fun3(**args1,*args2):
#     pass
# 在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求啊个数可变的位置形参，放在个数可变的关键字形参之前

结果

(10,)
(10, 30)
(30, 40, 50)
{'a': 10}
{'a': 20, 'b': 20, 'c': 30}

进程已结束,退出代码0

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)

# 函数的调用
fun(10,20,30) #函数调用时的参数传递，称为位置传参
lst=[11,22,33]
fun(*lst) #在函数调用时，将列表中的每个元素都转换为位置传入实参
fun(a=100,b=300,c=200)#函数的调用，所以是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic) #在函数调用时，将字典中的键值对都进行转换为关键字实参传入

结果

a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
a= 100
b= 300
c= 200
a= 111
b= 222
c= 333

进程已结束,退出代码0

def fun(a,b=10):
    print('a=',a)
    print('b=',b)


def fun2(*args):
    print(args)

def fun3(**args2):
    print(args2)

fun2(10,20,30,40,50,60)
fun3(a=22,b=22,c=33)

def fun4(a,b,c,d):
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

fun4(10,30,20,50) #位置实参传递
fun4(a=10,b=20,c=30,d=40)#关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数采用位置实参传递，c和d采用关键字实参传递

结果

(10, 20, 30, 40, 50, 60)
{'a': 22, 'b': 22, 'c': 33}
a= 10
b= 30
c= 20
d= 50
a= 10
b= 20
c= 30
d= 40
a= 10
b= 20
c= 30
d= 40

进程已结束,退出代码0

def fun(a,b):
    c=a+b   # c就称为局部变量，因为c在函数体内进行定义的变量。a,b为函数的形参，作用范围也是函数的内部，相当于局部变量
    print(c)
fun(1,2)
# print(c) # 因为c是局部变量，超出了起作用的范围

name='111'
print(name)
def fun2():
    print(name)
# 调用函数
fun2()

def fun3():
    global age      #函数内部定义的变量是局部变量，局部变量使用global声明，这个变量实际上变成了全局变量
    age =20
    print(age)
fun3()
print(age)

结果

3
111
111
20
20

进程已结束,退出代码0

43.4 递归函数

# 递归函数：如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
# 递归函数的组成
def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
# a=int(input())
a=int(input('请输入阶乘数：'))
# a=5
print(fac(a))
# 阶乘的计算：递归函数

结果

请输入阶乘数：10
3628800

进程已结束,退出代码0

43. 5 斐波那契数列

def fib(n): #
    if  n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

a=int(input('请输入斐波那契数列第几位上的数字:'))
print(fib(a))

for i in range(1,7):
    print(fib(i))

结果

请输入斐波那契数列第几位上的数字:6
8
1
1
2
3
5
8

进程已结束,退出代码0

44 try-except 异常

可以将错误进行打印输出

try:
    a=int(input('请输入第一个整数：'))
    b=int(input('请输入第二个整数：'))
    result=a/b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('谢谢您的使用')

结果

请输入第一个整数：12
请输入第二个整数：5.5
出错了 invalid literal for int() with base 10: '5.5'
谢谢您的使用

进程已结束,退出代码0

import traceback
try:
    print('-'*20)
    print(1/0)
except:
    traceback.print_exc()

结果

--------------------
Traceback (most recent call last):
  File "C:/Users/PC/Desktop/pycode/代码/马士兵-人工智能python基础/chap11/demo3.py", line 10, in <module>
    print(1/0)
ZeroDivisionError: division by zero

进程已结束,退出代码0

45异常类型

45.1 ZeroDivisionError

45.2 indexError

45.3 KeyError

45.4 Nameerror

45.5 SyntaxError

45.6 ValueError

# 异常类型
# ZeroDivisionError（）除（或取模）零（所有数据类型）
# print(10/0) #数学运算异常

# indexError序列中没有此索引（index）
lst=[11,22,33,44]
# print(lst[4])

# KeyError映射中没有这个键
dic={'name':'张三','age':20}
# print(dic['gander'])

# Nameerror未声明/初始化对象（没有属性）
# print(num)

# SyntaxError  python语法错误
# int a=20

# ValueError  传入无效的参数
# a=int('hello')

46 class

46.1 对象的创建

class Student:  #Student为类的名称（类别），由一个或者多个单词组成，每个单词的首字母大写，其余小写
    pass

print(id(Student))
print(type(Student))
print(Student)

结果

2505172989768
<class 'type'>
<class '__main__.Student'>

进程已结束,退出代码0

46.2 类属性、类方法、静态方法的使用

普通方法传入的第一个参数必须是self（当然也可以不用self，官方要求尽量用self），self是指实例对象本身；
静态方法无需传参；
类方法传入的第一个参数必须是class，是指类本身。

class Student:
    native_pace='吉安'   #直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name=name   #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋值给了实体变量
        self.age=age
    def eat(self):
        print('学生')

        # 静态方法
    @staticmethod
    def method():
        print('我使用staticmethod进行修饰，所以我是静态方法')
    # 类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
print('在类之外定义称为函数，在类之内定义的称为方法')
def drink():
    print('喝水')

# 创建Student类的对象
stu1=Student('张三',20)
print(id(Student),type(Student),Student)    #Student是类的名称
print(id(stu1),type(stu1),stu1)

结果

在类之外定义称为函数，在类之内定义的称为方法
1801531955688 <class 'type'> <class '__main__.Student'>
1801541807432 <class '__main__.Student'> <__main__.Student object at 0x000001A374426D48>

进程已结束,退出代码0

class Student:
    native_pace='吉安'   #直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name=name   #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋值给了实体变量
        self.age=age
    def eat(self):
        print('学生')

        # 静态方法
    @staticmethod
    def method():
        print('我使用staticmethod进行修饰，所以我是静态方法')
    # 类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
print('在类之外定义称为函数，在类之内定义的称为方法')
def drink():
    print('喝水')

# 创建Student类的对象
stu1=Student('张三',20)
stu1.eat()  #对象名.方法名
print(stu1.age,stu1.name)   # 调用类的方法
Student.eat(stu1)   # 都是调用Student中的eat方法 

结果

在类之外定义称为函数，在类之内定义的称为方法
学生
20 张三
学生

进程已结束,退出代码0

46.3 动态绑定属性和方法

class Student:
    native_pace='吉安'   #直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name=name   #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋值给了实体变量
        self.age=age
    def eat(self):
        print('学生')

        # 静态方法
    @staticmethod
    def method():
        print('我使用staticmethod进行修饰，所以我是静态方法')
    # 类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

# 类属性的使用方法
print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace='天津'
print(stu1.native_pace)
print(stu2.native_pace)

print('类方法的使用方式')
Student.cm()

print('静态方法的使用方式')
Student.method()

吉安
吉安
吉安
天津
天津
类方法的使用方式
我是类方法，因为我使用了classmethod进行修饰
静态方法的使用方式
我使用staticmethod进行修饰，所以我是静态方法

进程已结束,退出代码0

47 封装

47.1 封装的实现方法

class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车')

car=Car('宝马X5')
car.start()
print(car.brand)

结果

汽车
宝马X5

进程已结束,退出代码0

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age      #年龄不希望在类的外部被使用，所以加了两个_
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
# 在类的外部使用name和age
print(stu.name)
# print(stu.__age)
# print(dir(stu))
print(stu._Student__age)

结果

张三 20
张三
20

进程已结束,退出代码0

47.2 继承

print('继承')
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):
        super().info()
        print(self.stu_no)

class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):
        # print(self.name,self.age)
        super().info()
        print('教龄',self.teachofyear)

stu=Student('张三',20,'1001')

teacher=Teacher('李四',34,10)

stu.info()
teacher.info()

结果

继承
张三 20
1001
李四 34
教龄 10

进程已结束,退出代码0

47.3 继承的实现

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu))
print(stu)      #默认调用__str__()这样的方法
print(type(stu))

结果

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是张三，今年20岁
<class '__main__.Student'>

进程已结束,退出代码0

47.3多态的实现

print('''
多态：
简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，
仍然可以通过这个变量调用方法，
在运行过程中根据变量所引用的对象类型，
动态决定调用哪个对象中的方法
''')

class Animal(object):
    def eat(self):
        print('动物要吃肉')
class Dog(Animal):
    def eat(self):
        print('狗吃肉')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

def fun(animal):
    animal.eat()

fun(Dog())
fun(Cat())
fun(Person())

结果

多态：
简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，
仍然可以通过这个变量调用方法，
在运行过程中根据变量所引用的对象类型，
动态决定调用哪个对象中的方法

狗吃肉
猫吃鱼
人吃五谷杂粮

进程已结束,退出代码0

class Animal(object):
    def eat(self):
        print('动物会吃')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person:
    def eat(self):
        print('人吃五谷杂粮')

# 定义一个函数
def fun(obj):
    obj.eat()

# 开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())

fun(Person())

结果

猫吃鱼
狗吃骨头
动物会吃
人吃五谷杂粮

进程已结束,退出代码0

47.4 特殊属性

print('''
特殊方法和特殊属性：
特殊属性：
__dict__:获得类对象或者实例对象所绑定的所有类似和方法的字典
特殊方法：
__len__():通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__():通过重写__add__()方法，可使用自动以对象具有“+”功能
__new__():用于创建对象
__init__():对创建对象进行初始化
''')
# print(dir(object))

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
# 创建C类对象
x=C('Jack',20) # x是C类型的一个实例对象
print(x.__dict__)  #实例对象的数学字典
print(C.__dict__)
print(x.__class__,'输出了对象所属的类别')
print(C.__bases__,'C类的父类类型的元素')
print(C.__base__,'输出最近的父类')
print(C.__mro__,'查看类的层次结构')
print(A.__subclasses__(),'子类的列表')

结果

特殊方法和特殊属性：
特殊属性：
__dict__:获得类对象或者实例对象所绑定的所有类似和方法的字典
特殊方法：
__len__():通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__():通过重写__add__()方法，可使用自动以对象具有“+”功能
__new__():用于创建对象
__init__():对创建对象进行初始化

{'name': 'Jack', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x000002D3D0E82AF8>, '__doc__': None}
<class '__main__.C'> 输出了对象所属的类别
(<class '__main__.A'>, <class '__main__.B'>) C类的父类类型的元素
<class '__main__.A'> 输出最近的父类
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>) 查看类的层次结构
[<class '__main__.C'>] 子类的列表

进程已结束,退出代码0

47.5 特殊方法

a=20
b=100
c=a+b # 两个整数类型的对象相加操作
d=a.__add__(b)
print(d)
print(c)

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('张三')

stu2=Student('李四')

s=stu1+stu2
print(s,'实现了两个对象的加法运算（因为在student类中，编写__add__（）特殊的方法）')
s=stu1.__add__(stu2)
print(s)
lst=[11,22,33,44]
print(len(lst))
print(lst.__len__())

结果

120
120
张三李四 实现了两个对象的加法运算（因为在student类中，编写__add__（）特殊的方法）
张三李四
4
4

进程已结束,退出代码0

47.6 __new__与__init__创建对象

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __new__(cls,*args,**kwargs):
        print('__new__被调用执行了cls的id值为{0}'.format(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)))

print('创建Person类的实例对象')
p1=Person('张三',20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

结果

object这个类对象的id为：140734983666880
Person这个类对象的id为：1959066217800
创建Person类的实例对象
__new__被调用执行了cls的id值为1959066217800
创建对象的id为：1959075803080
__init__被调用，self的id 值为：1959075803080
p1这个Person类的实例对象的id:1959075803080

进程已结束,退出代码0

47.8类的赋值

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,dick):
        self.cpu=cpu
        self.dick=dick

# 变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1),type(cpu1))
print(cpu2,id(cpu2),type(cpu2))

结果

<__main__.CPU object at 0x00000202CBAC6F88> 2211030265736 <class '__main__.CPU'>
<__main__.CPU object at 0x00000202CBAC6F88> 2211030265736 <class '__main__.CPU'>

进程已结束,退出代码0

47.9 深拷贝与浅拷贝

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

# 变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1),type(cpu1))
print(cpu2,id(cpu2),type(cpu2))

disk=Disk() #创建一个硬盘类的对象
computer=Computer(cpu1,disk)    #创建一个计算机类的对象

print('-'*20,'浅拷贝','-'*20)
# 浅拷贝
import copy
print(disk)
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

print('-'*20,'深拷贝','-'*20)
# 深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

结果

类的浅拷贝和深拷贝
变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象
浅拷贝：Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，
因此，原对象与拷贝对象会引用同一个子对象
深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象、源对象和拷贝对象所有的子对象也不相同

<__main__.CPU object at 0x000001DAAD876DC8> 2038725832136 <class '__main__.CPU'>
<__main__.CPU object at 0x000001DAAD876DC8> 2038725832136 <class '__main__.CPU'>
-------------------- 浅拷贝 --------------------
<__main__.Disk object at 0x000001DAAD876B08>
<__main__.Computer object at 0x000001DAAD876D48> <__main__.CPU object at 0x000001DAAD876DC8> <__main__.Disk object at 0x000001DAAD876B08>
<__main__.Computer object at 0x000001DAAD878C08> <__main__.CPU object at 0x000001DAAD876DC8> <__main__.Disk object at 0x000001DAAD876B08>
-------------------- 深拷贝 --------------------
<__main__.Computer object at 0x000001DAAD876D48> <__main__.CPU object at 0x000001DAAD876DC8> <__main__.Disk object at 0x000001DAAD876B08>
<__main__.Computer object at 0x000001DAAD878C08> <__main__.CPU object at 0x000001DAAD876DC8> <__main__.Disk object at 0x000001DAAD876B08>

进程已结束,退出代码0

48 模块

48.1什么是模块

print('''
模块：
模块的英文名为Modules
函数与模块的关系：一个模块中可以包含N多个函数
在Python中一个扩展名为.py的文件就是一个模块
使用模块的好处：
1.方便其他程序和脚本的导入并使用
2.毕淼函数和变量冲突
3.提高代码的可维护性
4.提高代码的可重用性
''')

def  fun():
    pass
def fun2():
    pass
class Student:
    native_place='吉林'
    def eat(self,name,age):
        self.name=name
        self.age=age
    @classmethod
    def cm(cls):
        pass
    @staticmethod
    def sm():
        pass

a=10
b=20
print(a+b)

结果

模块：
模块的英文名为Modules
函数与模块的关系：一个模块中可以包含N多个函数
在Python中一个扩展名为.py的文件就是一个模块
使用模块的好处：
1.方便其他程序和脚本的导入并使用
2.毕淼函数和变量冲突
3.提高代码的可维护性
4.提高代码的可重用性

30

进程已结束,退出代码0

48.2模块的导入

print('导入模块')
import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2,3),type(math.pow(2,3)))
print(math.floor(9.999))

from math import pi
import math
print(pi)
print(pow(2,3))
print(math.pow(2,3))

结果

导入模块
1584978229992
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
8.0 <class 'float'>
9
3.141592653589793
8
8.0

进程已结束,退出代码0

48.3 模块定义

def add(a,b):
    return a+b
def div(a,b):
    return a/b
#如何导入自定义模块

48.4导入自己定义的模块

找到自己定义的模块的位置，然后import导入

import demo3
print(demo3.add(10,20))
print(demo3.div(10,20))

from demo3 import add
print(add(10,20))

import demo5
print(demo5.add(100,200))
print('不执行在main下面的主程序')

48.5 以主程序方式运行

print('''
以主程序形式运行：
在每个模块的定义中都包含一个记录模块的变量__name__,
程序可以检查该变量，以确定他们在哪个模块中执行。
如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中执行。
顶级模块的__name__变量的值为__main__
if __name__ == '__main__' :
     pass
''')

def add(a,b):
    return a+b

if __name__=='__main__':
    print(add(10,20))   #只有当点击运行demo5时，才会执行运算

print(add(100,300))  #可以进行调用

结果

以主程序形式运行：
在每个模块的定义中都包含一个记录模块的变量__name__,
程序可以检查该变量，以确定他们在哪个模块中执行。
如果一个模块不是被导入到其他程序中执行，那么它可能在解释器的顶级模块中执行。
顶级模块的__name__变量的值为__main__
if __name__ == '__main__' :
     pass

30
400

进程已结束,退出代码0

48.6 python的包

print('''
python中的包：
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
作用：
代码规范
避免模块名称冲突
包与目录的区别
包含__init__.py文件的目录称为包
目录里通常不包含__init__.py文件
包的导入
import 包名.模块名
''')

48.7 导入自定义包

import pageage1.module_A as ma
# print(pageage1.module_A.a)
print(ma.a)

print('导入带有包的模块时注意事项')
import pageage1
import demo5
print('使用import方式进行导入时，智能跟包名或者模块名')

from pageage1 import module_A
from pageage1.module_A import a

print('使用from...import可以导入包，模块，函数，变量')

48.8 python中常用的内容模块

import sys  # 与Python解释器及其环境操作相关的标准库
import time # 提供与时间相关的各种函数的标准库
import os   #提供了访问操作系统服务功能的标准库
import calendar #提供与日期相关的各种函数的标准库
import urllib.request   # 用于读取来自网上（服务器）的数据标准库
import json #用于使用JSON序列化和反序列化对象
import re   #用于在字符串中执行正则化表达式匹配和替换
import math #提供标准算数运算函数的标准库
import decimal  #用于进行精确控制运算精度、有效位数和四舍五入操作的十进制运算
import logging  #提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

print(sys.getsizeof(21))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

48.9 安装python包

可以在命令行输入

conda install **(包名)
#例如
conda install schedule

或者直接在pycharm中直接打开python解释器，找到对应的包，进行安装即可

49 编码

49.1 编码格式

编码格式
常见的字符编码格式
python的解释器使用的是Unicode（内存）
.py文件在磁盘上使用UTF—8存储（外存）

encoding=UTF-8 默认形式
修改编码方式，默认编码方式为UTF-8，上面修改为GBK，ANSI
不同编码方式，磁盘的大小不一样，即字节数不一样

49.2 文件读取

打开文件记得要.close（）关闭文件

print('以只读模式打开文件，文件的指针会放在文件的开头')
file= open('a.txt','r')
print(file.readlines())
file.close()

49.2 文件只写模式

print('以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有的内容，文件指针在文件的开头')
file= open('b.txt','w')
file.write('helloworld')
file.close()

49.3 文件追加模式

print('以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加文件内容，文件指针在源文件末尾')
file=open('b.txt','a')
file.write('python')
file.close()

49.4 二进制打开文件

print('以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb或者wb')
src_file=open('logo.png','rb')

target_file=open('logo.png', 'wb')

target_file.write(src_file.read())

target_file.close()
src_file.close()

file=open('a.txt','r')
file1=open('a.txt','a')
lst=['123456789','1']
file1.writelines(lst )
file1.close()

print(file.read(2))
print(file.readline())
print(file.readlines() )
file.close()

file=open('a.txt','r')
file1=open('a.txt','a')
lst=['123456789','1']
file1.writelines(lst )
file1.close()
print(file.read(2))
print(file.readline())
print(file.readlines() )
file.close()

with open('a.txt','r') as file:
    print(file.read())

49.5 上下文管理器

'''MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类帝乡遵循了上下文管理协议
该类对象的实例对象，称为上下文管理器

MyContentMgr（）
'''
class MyContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit方法被调用了')

    def show(self):
        print('show方法被调用执行了')

with MyContentMgr() as file:
    file.show()

结果

enter方法被调用执行了
show方法被调用执行了
exit方法被调用了

进程已结束,退出代码0

49.6 复制图片

with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())

49.7 os模块常用方法

import os
# os.system('notepad.exe')#打开记事本
# os.system('calc.exe')#打开计算器
os.startfile('C:\\Program Files (x86)\\Tencent\\WeChat.exe')#打开指定文件

import os
print(os.getcwd())
print(os.listdir())
lst=os.listdir('../chap15')
print(lst)

# os.mkdir('newdir2')#创建目录
# os.makedirs('A/B/C')#创建多级目录
# os.rmdir('newdir2')#删除目录
os.removedirs('A/B/C')#移除多级目录
os.chdir('')#将path设置为当前工作目录

import os.path
print(os.path.abspath('demo13.py'))#获取文件或目录的绝对路径
print(os.path.exists('demo13.py'),os.path.exists('demo14.py'))# 用于判断文件是否存在
print(os.path.join('E','demo13.py'))#将目录或者文件拼接起来
print(os.path.split('demo13.py'))#文件名和扩展名进行分离
print(os.path.splitext('demo13.py'))#分离文件名和扩展名
print(os.path.basename('demo15.py'))#提取文件名
print(os.path.dirname('demo13.py'))#从一个路径中提取文件路径，不包括文件名
print(os.path.isdir('demo13.py'))#判断是否为路径

import os
path=os.getcwd()
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)


import os
path=os.getcwd()
lst_files=os.walk(path)
for dirpath,dirname,filename in lst_files:
    print(dirpath)
    print(dirname)
    print(filename)
    for fir in dirname:
        print(os.path.join(dirpath,dir))
    for file in filename:
        print(os.path.join(dirpath,file))