Basic knowledge about python

1.Python的自述

2. python的简介

3.4

5.输出函数print

#可以输出数字
print(520)
print(98.5)
#可以输出字符串
print('helloworld')
print('helloworld')
#含有运算符的表达式
print(3+1)

#将数据输出文件中，注意点，1，所指定的盘符存在，2.使用file=fp
fp=open('D:/text.txt','a+')
print('helloworld',file=fp)
fp.close()

#不进行换行输出（输出内容在一行当中）
print('hello','world', 'python')

6.转义字符与原字符

print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')
print('hello\rworld')#world将hello进行了覆盖
print('hello\bworld')#\b是退一个格，将0退没了

print('http: \\\\www.baidu.com')
print('老师说：\’大家好\’’)

#原字符，不希望字符串中的转义字符起作用，就是用原字符，就是在字符串之前加上r/R
print(r'hello\nworld')

7.二进制与字符码

8 bit(位) = 1 byte（字节）

1024byte = 1kb

1024kb = 1MB

1024MB = 1GB

1024GB = 1TB

print(char(0b100111001011000))#ob表示二进制

print(ord('乘')) #ord返回值是十进制

8. python中的标识符和保留字

9.变量的定义和使用

name='马丽亚'

print(name)

print('标识'， id(name))

print('类型'， type(name))

print('值'， name)

10.变量的多次赋值

name='马丽亚'

name='楚留冰'

11.python中常见的数据类型

不管什么数据只要加上单/双引号就是字符串类型

12.数据类型——整数类型

n1=90

n2=76

n3=0

print(n1, type(n1))

print(n2, type(n2))

print(n3, type(n3))

#整数可以表示为二进制，十进制，八进制，十六进制

print('十进制'， 118)

print('二进制'， 0b10101111)#二进制以0b开头

print('八进制'， 0o176)#八进制以0o开头

print('十六进制'， 0x1EAF)

13.数据类型——浮点类型

a=3.14159

print(a, type(a))

n1 = 1.1

n2 = 2.2

print(n1+n2)

from decimal import Decimal

print(Decimal('1.1')+Decimal('2.2'))

不是所有的浮点型计算都有问题

14.数据类型——布尔类型

f1=True

f2=False

print(f1, type(f1))

print(f2, type(f2))

#布尔值可以转换成整数计算

print(f1+1) #2 1+1的结果为2 True表示1

print(f2+1) #1 0+1的结果为1 False表示0

15.数据类型——字符串类型

str1=‘人生苦短，我用Python'

str2="人生苦短，我用python"

str3="""人生苦短，#只有三引号可以在多行使用字符串

我用Python"""

str4=''' 人生苦短，

我用Python'''

ptinr(str1, type(str1))

ptint(str2, type(str2))

ptint(str2, type(str3))

ptint(str2, type(str4))

16.类型转换_str()函数与int()函数

name='张三'

age=20

print(type(name), type(age)) #说明name与age的数据类型不相同

print('我叫'+name+'今年'+age+’岁‘) #当str类型与int类型进行连接时，报错，解决方案，类型转换

print('我叫'+name+'今年'+str(age)+'岁') #将int类型通过str()函数转成了str()类型

print('=============str()将其他类型转成str类型---')

a=10

b=198.8

c=False

print(type(a), type(b), type(c))

print(str(a), str(b), str(c), type(a), type(str(b)), type(str(c)))

print('==========int()将其他的类型转int类型==========')

s1='128'

f1=98.7

s2='76.77'

ff=True

s2='hello'

print(type(s1), type(f1), type(s2), type(ff),type(s3))

print(int(s1), type(int(s1))) #将str转换成int类型，字符串为数字串

print(int(f1), type(int(f1)))#将float转成int类型，截取整数部分，舍掉小数部分

#print(int(f1), type(int(s2)))#将str转成int类型，报错，因为字符串为小数串

print(int(ff), type(int(ff)))

#print(int(s3), type(int(s3))) #将str转成int类型时，字符串必须为数字串（整数），非数字串是不允许转换的

17.类型转换_float（）函数

s1='128.98'

f1=‘76’

ff=True

s3='hello'

i=98

print(type(s1), type(s2), type(ff), type(s3), type(i))

print(float(s1), type(float(s1)))

print(float(s2), type(float(s2)))

print(float(ff), type(float(ff)))

#print(float(s3), type(float(s3)))#字符串中的数据如果是非数字串，则不允许转换

print(float(i), type(float(i)))

18. python中的注释

19.input函数的使用

present=input('大圣想要什么礼物呢？')

print(present)

20.input函数的高级使用

a=int(input('请输入一个加数：'))

#a=int(a) #将转换之后的结果存储到a中

b=input('请输入另一个加数：')

#b=int(b) #将转换之后的结果存储到b

print(type(a), type(b))

print(a+b)

21. 运算符_算数运算符

print(1+1) #加法运算

print(1+1)#减法运算

print(2*4)#乘法运算

print(1/2)#除法运算

print(11/2)#整除运算

print(11%2)#取余运算

print(2**2)#表示的是2的2次方

print(2**3)#表示的是2的三次方

22.运算符_赋值运算符

#赋值运算符，运算顺序从右到左

i = 3+4

print(i)

a=b=c #链式赋值

print(a, id(a))

print(b,id(b))

print(c,id(c))

print('-----------------支持参数赋值------------------')

a=20

a+=30 #相当于a=a+30

print(a)

a-=10 #相当于a=a-10

print(a)

a*=2#相当于a=a*2

print(a)

a/=3

print(a)

print('------------------解包赋值---------------------')

a,b,c=20,30,40

print(a,b,c)

#a,b=20，30，40 报错，因为左右变量的个数和值的个数不对应

print('--------------交换两个变量的值------------')

a,b=10,20

print('交换之前：'，a, b)

#交换

a, b=b,a

print('交换之后'， a,b)

23.运算符_比较运算符

#比较运算符，比较运算符的结果为bool类型

a, b = 10, 20

print('a>b吗？'，a>b) #False

print('a<b吗？'，a<b)#True

print('a<=b吗？'，a<=b)#True

print('a>=b吗？'，a>=b)#False

print('a==b吗？'，a==b)#False

print('a!=b吗？'，a！=b)#True

'''一个 = 成为赋值运算符， ==称为比较运算符

一个变量由三部分组成，标识（id）,类型，值

==比较的是值还是标识呢？比较的是值value

比较对象的表示使用 is

'''

a=10

b=10

print(a==b) #True 说明，a与b的value相等

print(a is b)#True说明，a与b的id标识，相等

lst1=[11,22,33,44]

lst2=[11,22,33,44]

print(lst1==lst2) # value -->True

print(lst1 is lst2)#id -->False

print(id(lst1))

print(id(lst2))

print(a is not b)#False a 的id与b的id是不相等的

print(lst1 is not lst2)

24.运算符_布尔运算符

#布尔运算符

a,b=1,2

print('------------------and 并且-------------')

print(a==1 and b==2)#True

print(a==1 and b<2)#False

print(a!=1 and b==2)#False

print(a!=1 and b!=2)#False

print（‘------------or 或者--------------）

print(a==1 or b==2) # True

print(a==1 of b<2) #True

print(a！=1 or b ==2)#True

print(a!=1 or b!=2)#False

print('--------------------not对bool类型操作数取反--------------------')

f=True

f2=False

print(not f)

print(not f2)
print('----------------------------in 于 not in-----------------------')

s = 'helloworld'

print('w' in s)

print('k' in s)

print('w' not in s)

print('k' not in s)

25.运算符_位运算

print(4&8) #按位与&,同为1时结果为1

print(4|8) #按位或|，同为0时结果为0

print(4<<1)#向左移动1位（移动一个位置）相当于乘以2

print(4<<2)#向左移动2位(移动两个位置)

print(4>>1)#向右移动1位，相当于除以2

print(4>>2)#向右移动2位，相当于除以4

26.运算符的优先级

特殊情况：右括号先算括号里面的

27.程序的组织结构_顺序结构

28.对象的布尔值

#测试对象的布尔值

print(bool(False)) #False

print(bool(0))#False

print(bool(0.0))#False

print(bool(None))#False

print(bool(''))

print(bool(""))

print(bool[])#空列表

print(bool(list()))#空列表

print(bool(()))#空元组

print(bool(tuple()))#空元组

print(bool({}))#空字典

print(bool(dic())) #空字典

print(bool(set())) #空集合

print('---------------以上对象的布尔值均为True----------------')

print(bool(18))

print(bool(True))

print(bool('Helloworld'))

29.单分支结构

money=1000 #余额

s=int(input('请输入取款金额')) #取款金额

#判断余额是否充足

if money>=s:

money=money-s

print('取款成功，余额为：'，money)

30.双分支结构

''‘从键盘录入一个整数，编写程序让计算机判断史奇数还是偶数’‘’

num=int(input('请输入一个整数'))

#条件判断

if num%2==0:

print(num, '是偶数')

else:

print(num, '是奇数')

31.多分支结构

score = int(input('请输入一个成绩：'))

#判断

if score>=90 and score<=100 ：

print('A级')

elif score >=80 and score<=89:

print('B级')

elif score>=70 and score <=79:

print('C级')

elif score>=60 and score<=69:

print('D级')

elif score>=0 and score<=59:

print('E级别')

else:

print('对不起，成绩有误，不在成绩的有效范围')

if 90 <=score<=100 ：

print('A级')

elif 80 <=score<=89:

print('B级')

elif 70<=score<=79:

print('C级')

elif 60 <=score<=69:

print('D级')

elif 0 <=score<=59:

print('E级别')

else:

print('对不起，成绩有误，不在成绩的有效范围')

32.分支结构_嵌套if的使用

answer=input('您是会员吗？y/n')

#外层判断是否是会员

if answer=='y': #会员

if money>=200:

print('打8折，付款金额为：'，money*0.8)

elif money>=100:

print('打9折，付款金额为：'，money*0.9)

else:

print('不打折，付款金额为：'，money)

else: #非会员

if money>=200:

print('打9.5折，付款金额为：'，money*0.95)

else:

print('不打折，付款金额为：'，money)

33.条件表达式

'''从键盘录入两个整数，比较两个整数的大小'''

num_a = int(input('请输入第一个整数'))

num_b = int(input('请输入第二个整数'))

#比较大小

''' if num_a>=num_b:

print(num_b, '大于等于'， num_b)

else：

print(num_a, ’小于‘，num_b)

'''print('使用条件表达式进行比较')

print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))

34. pass语句

#pass语句，什么都不做，只是一个占位符，用到需要些语句的地方

answer = input('您是会员吗？y/n')

#判断是否是会员

if answer=='y'

pass

else:

pass

35. range函数的使用

#range()的三种创建方式

r = range(10)

prin(r) #range(0, 10)

print(list(r)) #用于查看range对象中的整数序列 list是列表的意思

'''第二种创建方式，给了两个参数（小括号中给了两个数）'''

r=range(1,10) #指定了起始值，从1开始，到10结束（不好含10），默认步长为1

print(list(r)) #[1,2,3,4,5,6,7,8,9]

'''第三种创建方式，给了三个参数（小括号中给了三个数）’‘’

r=range(1,10,2)

print(list(r)) #[1,3,5,7,9]

'''判断指定的整数在序列中是否存在 in, not in'''

print(10 in r) #False, 10不在当前的r这整个序列中

print(9 in r)#True, 9在当前的r这个序列中

print(10 not in r)#True

print(9 not in r)#False

36. while循环

#计算0到4之间的累加和

‘’‘

4步循环法

1. 初始化变量

2.条件判断

3.条件执行体（循环体）

4.改变变量

总结：初始化的变量与条件判断的变量于改变的变量为同一个

'''

sum=0 #用来存储累加和

'''初始化变量为0’‘’

a=0

'''条件判断‘’‘

while a<5:

'''条件执行体（循环体）'''

sum+=a

a+=1

print('和为'，sum)

37.while 练习题1到100之间的偶数和

'''计算1到100之间的偶数和‘’‘

’‘’初始化变量‘’‘

sum=0

a=1

while a<=100:

if a%2==0 # if not bool(a%2)

sum+=a

a+=1

print('1-100之间的偶数和'， sum)

38. for_in循环

for item in 'python': #第一次取出来的是p,将p赋值item, 将item的值输出

print(item)

#range() 产生一个整数序列，-->>也是一个可迭代对象

for i in range(10):

print(i)#输出0-9

#如果在循环体中不需要使用到自定义变量，可将自定义变量写为''_’‘

for _ in range(5)

print('人生苦短，我用Python')

print('使用for循环，计算1到100之间的偶数和')

sum = 0

for i in range(1, 101)

if not bool(i%2)

sum+=i

print('1到100之间的偶数和为'，sum)

39. for_in练习题 100-999之间的水仙花数

# 输出100到999之间的水仙花数
# 举例：153 = 3*3*3 + 5*5*5 + 1*1*1
for item in range(100, 1000):a = item % 10b = item // 10 % 10c = item // 100if a**3 + b**3 + c**3 == item:print(item)

40.流程控制语句break

# 从键盘录入密码，最多录入3次，如果正确就结束循环for item in range(3):pwd = input('请输入密码：')if pwd == '8888':print('密码正确')breakelse:print('密码不正确')

a = 0
while a<3:# 条件执行体（循环体）pwd = input('请输入密码：')if pwd == '8888':print('密码正确')breakelse:print('密码不正确')# 改变变量a += 1

41.流程控制语句continue

#要求输出1到50之间所有5的倍数， 5， 10， 15 ....

#5的倍数的共同点：和5的余数为0的数都是5的倍数

什么样的数不是5的倍数，1， 2， 3 ....与5的余数不为0的数都不是5的倍数

要求时使用continue实现

for item in range(1,51):if item % 5 == 0:print(item)for item in range(1, 51):if item % 5 != 0:continueprint(item)

42. else语句

for item in range(3):pwd = input('请输入密码：')if pwd == '8888':print('密码正确')breakelse:print('密码不正确')
else:print('对不起，三次密码输入错误')

a = 0
while a < 3:pwd = input('请输入密码')if pwd == '8888':print('密码正确')breakelse:print('密码不正确')a += 1
else:print('对不起，三次密码输入均不正确')

43.嵌套循环

for i in range(1, 4):for j in range(1, 5):print('*', end='\t')print()for i in range(1, 10):for j in range(1, i +1):print(i, '*', j, '=', i*j, end= '\t')print()

44.二重循环中的break与continue

# 流程控制语句 break 与 continue 在for i in range(5):for j in range(1, 11):if j % 2 == 0:break# continueprint(j)

45.为什么需要列表

a = 10
lst = ['hello', 'world', 98]
print(id(lst))
print(type(lst))
print(lst)

46. 列表对象的创建

47.列表的特点

# 创建列表的第一种方式使用[]
lst = ['hello', 'world', 98, 'hello']
print(lst[0], lst[-4])
# 创建列表的第二种方式，使用内置函数list()lst2 = list(['hello', 'world', 98])

48. 获取指定元素的索引

lst = ['hello', 'world', 98, 'hello']print(lst. index('hello'))
# print(lst. index('Python'))
print(lst. index('hello', 1, 4))

49.获取列表中的元素

lst = ['hello', 'world', 98, 'hello']
# 获取索引为2的元素
print(lst[2])
# 获取索引为-3的元素
print(lst[3])print(lst[10])

50.获取列表中的多个元素_切片操作

lst = [10, 20, 30, 40, 50, 60, 70, 80]
print('原列表', id(lst))
lst2=lst[1:6:1]
print('切的片段：', id(lst2))
print(lst[1:6]) # 默认步长为1
print(lst[1:6:])
print(lst[1:6:2])
# stop=6, step=2, start采用默认
print(lst[:6:2])
# start=1, step=2, stop采用默认
print(lst[1::2])
print('----------step步长为复数的情况--------')
print[::-1]
print(lst[7::-1])
print(lst[6:0:-2])

51. 列表的判断及遍历

print('p' in 'python')
print('k' not in 'python')lst = [10, 20, 'python', 'hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
print('---------------------')
for item in lst:print(item)

52.列表元素的添加操作

# 向列表的末尾添加一个元素
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))
lst.append(100)
print('添加元素之后', lst, id(lst))
lst2 = ['hello', 'world']
# lst.append(lst2) 将lst2作为一个元素添加到列表的末尾
# 向列表的末尾一次性添加多个元素
lst. extend(lst2)
print(lst)# 在任意位置上添加一个元素
lst. insert(1, 90)
print(lst)lst3 = [True, False, 'hellp']
lst[1:] = lst3
print(lst)

53.列表元素的删除操作

lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30) # 从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)
# pop() 根据索引移除元素lst.pop(1)
print(lst)lst.pop() # 如果不指定参数（索引）， 将删除列表中的最后一个元素
print(lst)
print('----------切片操作-删除至少一个元素，将产生一个新的列表对象-----------')
new_list = lst[1:3]
print('原列表', lst)
print('切片后的列表', new_list)
# 不产生新的列表对象，而是删除原列表中的内容
lst[1:3] = []
print(lst)
# 清楚列表中的所有元素lst. clear()
print(lst)del lst
print(lst)

54. 列表元素的修改操作

lst = [10, 20, 30, 40]# 一次修改一个值
lst[2] = 100
print(lst)
lst[1:3] = [300, 400, 500, 600]
print(lst)

55.列表的排序操作

lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))
# 开始排序，调用列表对象的sort方法，升序排序
lst.sort()
print('排序后的列表', lst, id(lst))# 通过指定关键字参数，将列表中的元素进行降序排序
lst. sort(reverse=True)
print(lst)lst.sort(reverse=False)
print(lst)
print('-----------------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-----------')
lst = [20, 40, 10, 98, 54]
print('原列表', lst)
# 开始排序
new_list = sorted(lst)
print(lst)
print(new_list)
# 指定关键字残数，实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)

56.列表生成式

57. 什么是字典

58.字典的实现原理

59.字典的创建

# 使用{}创建字典
scores = {'张三': 100, '李四': 98, '王五': 45}
print(scores)
print(type(scores))# 第二种创建dict()
student = dict(name='jack', age=20)
print(student)# 空字典
d = {}
print(d)

60.字典元素的获取

# 获取字典的元素
scores = {'张三': 100, '李四': 98, '王五': 45}
# 第一种方式，使用[]
print(scores['张三'])
# print(scores['陈六']) KeyError: '陈六'
# 第二种方式，使用get()方法
print(scores.get('张三'))
print(scores.get('陈六'))  # None
print(scores.get('麻七', 99))  # 99是在查找'麻七' 所对的value不存在时，提供的一个默认值

61.字典元素的增_删_改操作

# 获取字典的元素
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)
print('张三' not in scores)del scores['张三']   # 删除指定的key-value对
# scores.clear() #清空字典的元素
print(scores)
scores['陈六'] = 98  # 新增元素
print(scores)scores['陈六'] = 100 # 修改元素
print(scores)

62.获取字典视图

63. 字典元素的遍历

scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:print(item, scores[item], scores.get(item))

64. 字典的特点

d = {'name': '张三', 'name': '李四'}
print(d)d = {'name': '张三', 'nikename': '张三'}
print(d)lst = [10, 20, 30]
lst. insert(1, 100)
print(lst)
d = {lst: 100}
print(d)

65.字典生成式

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85, 100, 120]d = {item.upper(): price for item, price in zip(items, prices)}
print(d)

66. 什么是元组

# 可变序列 列表，字典
lst = [10, 20, 45]
print(id(lst))
lst.append(300)
print(id(lst))
# 不可变序列，字符串，元组
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))
print(s)

67. 元组的创建方式

# 元组的创建方式
# 第一种创建方式，使用（）
t = ('python', 'world', 98)
print(t)
print(type(t))t2 = 'python', 'world', 98  # 省略了小括号
print(t2)
print(type(t2))t3 = ('python',)  # 如果元组中只有一个元素，逗号不能省略
print(t3)
print(type(t3))# 第二种创建方式，使用内置函数tuple()
t1 = tuple(('Python', 'world', 98))
print(t1)# 空元组的创建方式
# 空列表的创建方式lst = []
lst1 = list()d = {}
d2 = dict()# 空元组
t4 = ()
t5 = tuple()
print('空列表', lst, lst1)
print('空字典', d, d2)
print('空元组', t4, t5)

68. 为什么要将元组设计成不可变序列

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

69. 元组的遍历

# 元组的遍历
t = ('Python', 'world', 98)
# 第一种获取元组的方式，使用索引
print(t[0])
print(t[1])
print(t[2])# 遍历元组
for item  in t:print(item)

70. 集合的概述与创建

# 集合的创建方式
# 第一种创建方式使用{}
s = {2, 3, 4, 5, 5, 6, 6, 7} # 集合中的元素不允许重复
print(s)# 第二种创建方式使用set()
s1 = set(range(6))
print(s1, type(s1))s2 = set([1, 2, 4, 5, 5, 6, 6])
print(s2, type(s2))s3 = set((1, 2, 4, 4, 5, 65))  # 集合中的元素是无序的
print(s3, type(s3))s4 = set('python')
print(s4, type(s4))s5 = set({12, 4, 34, 55, 66, 44, 4})
print(s5, type(s5))
# 定义一个空集合s6 = {}  # dict字典类型
print(type(s6))s7 = set()
print(type(s7))

71. 集合的相关操作

# 集合的相关操作
s = {10, 20, 30, 405, 60}
# 集合元素的判断操作
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)
# 集合元素的新增操作
s.add(88)
print(s)
s.update({200, 400, 300})
print(s)
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s)
# 集合元素的删除操作
s. remove(100)
print(s)
# s.remove(500) #KeyError: 500
s.discard(500)
s.discard(300)
print(s)
s.pop()
s.pop()
print(s)
s.clear()
print(s)

72. 集合间的关系

# 两个集合是否相等（元素相同， 就相等）
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False# 一个集合是否是另一个集合的子集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1))
print(s3.issubset(s1))# 一个集合是否是另一个集合的超集
print(s1.issuperset(s2))  # True
print(s1.issuperset(s3))
# 两个集合是否含有交集
print(s2.isdisjoint(s3))  # False 有交集为False
s4 = {100, 200, 300}
print(s2.isdisjoint(s4))  # True   没有交集为True

73. 集合的数据操作

# 集合的数学操作
# （1）交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))
print(s1 & s2)  # intersection()与 &等价，交集操作# （2）并集操作
print(s1.union(s2))
print(s1 | s2) # union 与 | 等价，并集操作
print(s1)
print(s2)
# (3) 差集操作
print(s1.difference(s2))
print(s1-s2)print(s1)
print(s2)
# （4）对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

74. 集合生成式

# 列表生成式
lst = [i*i for i in range(10)]
print(lst)# 集合生成式
s = {i*i for i in range(10)}
print(s)

75. 字符串的创建与驻留机制

(base) C:\Users\11396>python
Python 3.9.12 (main, Apr 4 2022, 05:22:27) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> s1=''
>>> s2=''
>>> s1 is s2
True
>>> s1='%'
>>> s2='%'
>>> s1 is s2
True
>>> s1='abc%'
>>> s2='abc%'
>>> s1 == s2
True
>>> s1 is s2
False
>>> id(s1)
2052061752112
>>> id(s2)
2052061771440
>>> s1='abcx'
>>> s2='abcx'
>>> s1 is s2
True
>>> a='abc'
>>> b='ab'+'c'
>>> c=''.join(['ab','c'])
>>> a is b
True
>>> a is c
False
>>> c
'abc'
>>> type(c)
<class 'str'>
>>> type(a)
<class 'str'>
>>> a=-5
>>> b=-5
>>> a is b
True
>>> a=-6
>>> b=-6
>>> a is b
False
>>> import sys
>>> a='abc%'
>>> b='abc%'
>>> a is b
False
>>> a = sys.intern(b)
>>> a is b
True
>>>

76.字符串的常用操作_字符串的查询操作

# 字符串的查询操作
s = 'hello, hello'
print(s. index('lo'))  # 3
print(s. find('lo'))  # 3
print(s. rindex('lo'))  # 9
print(s. rfind('lo'))  # 9# print(s. index('k')) ValueError: substring not found
print(s. find('k'))  # -1print(s. rfind('k'))  # -1

77.字符串的常用操作_字符串的大小写转换

# 字符串中的大小写转换的方法
s = 'hello, python'
a = s.upper()  # 转成大写之后，会产生一个新的字符串对象
print(a, id(a))
print(s, id(s))
b = s.lower()
print(b, id(b))  # 转换之后，会产生一个新的字符串对象
print(s, id(s))
print(b == s)
print(b is s)  # Falses2 = 'hello, Python'
print(s2.swapcase())print(s2. title())

78. 字符串的常用操作_字符串内容对齐操作

s = 'hello,Python'
# 居中对齐
print(s.center(20, '*'))
# 左对齐
print(s.ljust(20, '*'))
print(s.ljust(8))
print(s.ljust(20))
#  右对齐
print(s.rjust(20, '*'))
print(s.rjust(20))
print(s.rjust(10))
# 右对齐， 使用0进行填充
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))

79. 字符串的常用操作_字符串的劈分

s = 'hello world Python'
lst = s.split()
print(lst)
s1 = 'hello | world | Python'
print(s1.split(sep='|'))
print(s1.split(sep='|', maxsplit=1))
print('----------------------')
# rsplit()从右侧开始劈分
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|', maxsplit=1))

80. 字符串的常用操作_字符串判断的相关操作

s = 'hello, python'
print('1.', s.isidentifier())
print('2.', 'hello'.isidentifier())
print('3.', '张三_'.isidentifier())
print('4.', '张三_123'.isidentifier())print('5.', '\t'.isspace())print('6.', 'abc'.isalpha())
print('7.', '张三'.isalpha())
print('8.', '张三1'.isalpha())print('9.', '123'.isdecimal())
print('10.', '123四'.isdecimal())
print('11.', 'Ⅰ'.isdecimal())print('12.', '123'.isnumeric())
print('13.', '123四'.isnumeric())
print('14.', 'Ⅰ'.isnumeric())print('15.', 'abc1'.isalnum())
print('16.', '张三123'.isalnum())
print('17.', 'abc!'.isalnum())

81. 字符串的常用操作_替换与操作

s = 'hello, Python'
print(s.replace('Python', 'Java'))
s1 = 'hello, Python, Python, Python'
print(s1.replace('Python', 'Java', 2))
lst = ['hello', 'Java', 'Python']
print('|'.join(lst))
print(' '.join(lst))t = ('hello', 'Java', 'Python')
print(''.join(t))
print('*'.join('Python'))

82. 字符串的比较操作

print('apple' > 'app')
print('apple' > 'banana')
print(ord('a'), ord('b'))
print(ord('李'))
print(chr(97), chr(98))
print(chr(26446))# ==与is的区别
# ==比较的是 value
# is比较的是id是否相等a = b = 'Python'
c = 'Python'
print(a == b)
print(b == c)print(a is b)
print(a is c)
print(id(a))
print(id(b))
print(id(c))

83. 字符串的切片操作

s = 'hello,Python'
s1 = s[:5]   # 由于没有指定起始位置，所以从0开始
s2 = s[6:]  # 由于没有指定结束位置， 所以切到字符串的最后一个元素
s3 = '!'
newstr = s1 + s3 + s2print(s1)
print(s2)
print(newstr)print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))
print('------切片[start:end:step]--------')print(s[1:5:1])  # 从1开始截到5（不包含5），步长为1
print(s[::2])  # 默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1])  # 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1])  # 从索引为-6开始，到字符串的最后一个元素结束，步长为1

84.格式化字符串

# 格式化字符串
# （1） % 占位符
name = '张三'
age = 20
# （2） {}
print('我叫{0}， 今年{1}岁'.format(name, age))
# (3) f-string
print(f'我叫{name}, 今年{age}岁')print('%10d' % 99)  # 10表示的是宽度
print('%.3f' % 3.1415926)  # .3表示的是
# 同时表示宽度和精度
print('%10.3f' % 3.1415926)  # 一共总宽度为10， 小数点后3位
print('hellohello')print('{0:.3}'.format(3.1415926))  # .3表示的是一共3位数
print('{:.3f}'.format(3.1415926))  # .3f表示的是3位小数
print('{:10.3f}'.format(3.1415926))  # 同时设置宽度和精度，一共是10位，3是小数部分

85. 字符串的编码与解码

s = '天涯共此时'
print(s.encode(encoding='GBK'))  # 在GBK这种编码格中 一个中文占两个字节
print(s.encode(encoding='UTF-8'))  # 在UTF-8这种编辑格式中，一个中文占三个字节# 解码
# yte代表就是一个二进制数据（字节类型的数据）
byte = s.encode(encoding='GBK')  # 编码
print(byte.decode(encoding='GBK'))  # 解码byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding = 'UTF-8'))

86. 函数的定义与调用

def calc(a, b):c = a + breturn cresult = calc(10, 20)
print(result)

87. 函数调用的参数传递_位置实参_关键字实参

def calc(a, b):  # a,b成为形式参数，简称形参，形参的位置是在函数的定义处c = a + breturn cresult = calc(10, 20)  # 10，20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)res = calc(b=10, a=20)  # 左侧的变量的名称称为关键词参数
print(res)

88. 函数参数传递的内存分析

def fun(arg1, arg2):print('arg1', arg1)print('arg2', arg2)arg1 = 100arg2.append(10)print('arg1', arg1)print('arg2', arg2)# returnn1 = 11
n2 = [22, 33, 44]
print('n1', n1)
print('n2', n2)
fun(n1, n2)  # 将位置传参，arg1,arg2是函数定义处的形参，n1,n2是函数调用处的实参，总结，实参名称与形参名称可以不一致
print('n1', n1)
print('n2', n2)
# 在函数调用过程中，进行参数的传递
# 如果是不可变对象， 在函数体的修改不会影响实参的值 arg1修改位100，不会影响n1的值
# 如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改，append(10), 会影响到n2的值

89. 函数的返回值

def fun(num):odd = []  # 存奇数even = []  # 存偶数for i in num:if i % 2:odd.append(i)else:even.append(i)return odd, even# 函数的调用lst = [10, 29, 34, 23, 44, 53, 55]
print(fun(lst))
# 函数的返回值
# （1）如果函数没有返回值【函数执行完毕之后，不需要给调用出提供数据】 return可以省略不写
# （2）函数的返回值，如果是1个，直接返回类型
# （3）函数的返回值，如果是多个，返回的结果为元组def fun1():print('hellp')fun1()def fun2():return 'hello'res = fun2()
print(res)
print(fun2())def fun3():return 'hello', 'world'print(fun3())# 函数在定义是，是否需要返回值，视情况而定

90. 函数参数定义_默认值参数

def fun(a, b=10):print(a, b)# 函数的调用fun(100)
fun(20, 30)
print('hello', end='\t')

91. 函数参数定义_个数可变的位置形参

def fun(*args):  # 函数定义是的可变的位置参数print(args)fun(10)
fun(10, 30)
fun(30, 405, 50)def fun1(**args):print(args)fun1(a=10)
fun1(a=20, b=30, c=40)# def fun2(*args, *a):
#     pass
# 以上代码，程序会报错，可变的位置参数，只能是1个
# def fun(**args, **args):
# pass
# 以上代码，程序会报错，个数可变的关键字参数，只能是1个def fun2(*arg1, **args2):pass# def fun3(**args1, *arg2):
#   pass
# 在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前

92. 函数的参数总结

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

def fun(a, b=10):  # b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参print('a=', a)print('b=', b)def fun2(*args):  # 个数可变的位置形参print(args)def fun3(**args2):  # 个数可变的关键字形参print(args2)fun2(10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)def fun4(a, b, *, c, d):print('a=', a)print('b=', b)print('c=', c)print('d=', d)
# 调用fun4函数# fun4(10, 20, 30, 40)  # 位置实参传递
fun4(a=10, b=20, c=30, d=40)  # 关键字实参传递
fun4(10, 20, c=30, d=40)  # 前两个参数，采用的是位置实参传递，而c,d采用的是关键字实参传递
# 需求， c,d只能采用关键字实参传递# 函数定义时的形参的顺序问题def fun5(a, b, *, c, d, **args):passdef fun6(*arg, **args2):passdef fun7(a, b=10, *args, **args2):pass

93. 变量的作用域

def fun(a, b):c = a+b  # c就称为局部变量，因为c在函数体内进行定义的变量，a,b,为函数的形参，作用范围也是函数内部，相当于局部变量print(c)# print(c)
# print(a)name = '杨老师'
print(name)def fun2():print(name)
# 调用函数
fun2()def fun3():global age  # 函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量age = 20print(age)fun3()
print(age)

94. 递归函数

def fac(n):if n == 1:return 1else:res = n*fac(n-1)return resprint(fac(6))

98. 斐波那契数列

def fib(n):if n == 1:return 1if n == 2:return 1else:return fib(n-1)+fib(n-2)# 斐波那契数列第六位上的数字
print(fib(6))# 输出这个数列的前6位上的数字
for i in range(1,7):print(fib(i))

96. BUG的由来

97. BUG的常见类型——粗心导致的错误

98. BUG的常见类型_错误点不熟悉导致

lst = [11, 22, 33, 44]  # 列表的索引是从0开始
# print(lst[4])
print(lst[3])lst=[]
# lst = append('A', 'B', 'C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)

99. BUG的常见类型_思路不清晰导致

100. BUG的常见类型_被动掉坑

a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))8
result = a/b
print('结果为：', result)

try:a = int(input('请输入第一个整数'))b = int(input('请输入第二个整数'))8result = a/bprint('结果为：', result)
except ZeroDivisionError:print('对不起，除数不允许为0')
except ValueError:print('只能输入数字串')
print('程序结束')

101. try-except-else结构与try-except-else-finally结构

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

102.Python中常见的异常类型

# print(10/0)  # ZeroDivisionError
lst=[11, 22, 33, 44]
# print(lst[4])  # IndexError 索引从0开始
dic = {'name' : '张三', 'age':20}
# print(dic['gender'])  # KeyError# print(num)  # NameError# int a = 20  # SyntaxError# a = int('hello')  # ValueError

103. traceback模块的使用

# print(10/0)
import traceback
try:print('---------------------------')print(1/0)
except:traceback.print_exc()

104. Pycharm的程序调试

i = 1
while i <= 10:print(i)i += 1

105. 编程的两大思想_面向过程_面向对象

106. 类与对象

107. 定义python中的类

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写passprint(id(Student))  # 2678247276896
print(type(Student))  # <class 'type'>
print(Student)  # <class '__main__.Student'>

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写native_pace = '吉林'   # 直接写在类里的变量，称为类属性def __init__(self, name, age):self.name = nameself.age = age# 实例方法def eat(self):print('学生在吃饭...')# 静态方法@staticmethoddef method():print('我使用了staticmethod进行修饰，所以我是静态方法')# 类方法@classmethoddef cm(cls):print('我是类方法，因为我使用了classmethod进行修饰')# 在类之外定义的称为函数，在类之内定义的称为方法
def drink():print('喝水')

108. 对象的创建

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写native_pace = '吉林'  # 直接写在类里的变量，称为类属性def __init__(self, name, age):self.name = nameself.age = age# 实例方法def eat(self):print('学生在吃饭...')# 静态方法@staticmethoddef method():print('我使用了staticmethod进行修饰，所以我是静态方法')# 类方法@classmethoddef cm(cls):print('我是类方法，因为我使用了classmethod进行修饰')# 在类之外定义的称为函数，在类之内定义的称为方法
def drink():print('喝水')# 创建student类的对象
stu1 = Student('张三', 20)stu1.eat()
print(stu1.name)
print(stu1.age)print('---------------------------')
Student.eat(stu1)  # 33行与28行代码功能相同，都是调用Student中eat的方法# 类名.方法名（类的对象）->实际上就是方法定义处的self

109. 类属性_类方法_静态方法的使用方式

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写native_pace = '吉林'  # 直接写在类里的变量，称为类属性def __init__(self, name, age):self.name = nameself.age = age# 实例方法def eat(self):print('学生在吃饭...')# 静态方法@staticmethoddef method():print('我使用了staticmethod进行修饰，所以我是静态方法')# 类方法@classmethoddef cm(cls):print('我是类方法，因为我使用了classmethod进行修饰')# 类属性的使用方式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()

110.动态绑定属性和方法

class Student:def __init__(self, name, age):self.name = nameself.name = agedef eat(self):print(self.name+'在吃饭')stu1 = Student('张三', age = 20)
stu2 = Student('李四', age = 30)
print(id(stu1))
print(id(stu2))
print('---------为stu2动态绑定性别属性---------')
stu1.gender = '女'
print(stu1.name, stu1.age, stu1.gender)
print(stu2.name, stu2.age)print('---------------------')
stu1.eat()
stu2.eat()def show():print('定义在类之外的，称为函数')
stu1.show = show()
stu1.show()

110. 面向对象的三大特征_封装的实现方式

class Car:def __init__(self, brand):self.brand = branddef start(self):print('汽车已启动...')car = Car('宝马X5')
car.start()
print(car.brand)

class Student:def __init__(self, name, age):self.name = nameself.__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)

111. 继承及其实现方式

class Person(object):def __init__(self, name, age):  # Person继承object类self.name = nameself.age = agedef 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
class Teacher(Person):def __init__(self, name, age, teachofyear):super().__init__(name, age)self.teachofyear = teachofyearstu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)stu.info()
teacher.info()

class A(object):pass
class B(object):passclass C(A, B)：pass

112. 方法重写

class Person(object):def __init__(self, name, age):  # Person继承object类self.name = nameself.age = agedef 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_nodef info(self):super().info()print(self.stu_no)
class Teacher(Person):def __init__(self, name, age, teachofyear):super().__init__(name, age)self.teachofyear = teachofyeardef info(self):super().info()print('教龄', self.teachofyear )stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)stu.info()
print('---------------')
teacher.info()

113. object类

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

114. 多态的实现

Class Animal(object):

def eat(self):

print('动物会吃')

Class Dog(Animal):

def eat(self):

print('狗吃骨头...')

Class Car(Animal):

def eat(self):

print('猫吃鱼...')

# 定义一个函数

def fun(obj):

obj.eat()

#开始调用函数

fun(Cat())

fun(Dog())

fun(Animal())

print('----------------------')

fun(Person())

Java是静态语言必须有继承关系才可以使用eat()

117. 特殊属性

#print(dir(object))

class A:

pass

class B:

pass

class C(A, B):

def __init__(self. name, age):

self.name = name

self.name = 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__()) # 子类的列表

116. 特殊方法

a = 20

b = 100

c = a + b # 两个整数类型的对象的相加操作

d = a.__add__(b)

print(c)

print(d)

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('Jack')

stu2 = Student('李四')

s = stu1 + stu2 # 实现了两个对象的加法运算（因为在Student类中编写__add__()特殊的方法）

print(s)

s=stu1.__add__(stu2)

print(s)

print('------------------------------')

lst=[11, 22, 33, 44]

print(len(lst)) # len是内容函数len

print(lst. __len__())

print(len(stu1))

117. __New__与__init__演示创建对象的过程

class Person(object):

def __new__(cls, *args, **kwargs):

print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))

obj = super().__new__(cls)

print('创建的对象的id为：{0}'.format(id(obj)))

def __init__(self, name, age):

print('__init__被调用了，self的值为：{0}'.format(id(self)))

self.name = name

self.age = age

print('object这个类对象的id为：{0}'. format(id(object)))

print('Person这个类对象的id为：{0}'. format(id(Person)))

# 创建Person类的实例对象

p1 = Person('张三'， 20)

print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

118. 类的赋值与浅拷贝

class CPU:

pass

class Disk:

pass

class Computer：

def __init__(self, cpu, disk):

self.cpu = cpu

self.disk = disk

# (1)变量的赋值

cpu1 = CPU

cpu2 = cpu1

print(cpu1, id(cpu1))

print(cpu2, id(cpu2))

# （2）类的浅拷贝

print('----------------------------------------')

disk = Disk() # 创建一个硬盘类的对象

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

# 浅拷贝

import copy
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)

119. 深拷贝

# 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer3, computer3.cpu, computer3. disk)

<__main__.Computer object at 0x000002DD85D25EB0> <class '__main__.CPU'> <__main__.Disk object at 0x000002DD85D25A60>
<__main__.Computer object at 0x000002DD85D25C70> <class '__main__.CPU'> <__main__.Disk object at 0x000002DD85C71160>

120. 什么叫模块_模块化编程的好处

def fun():pass
def fun2():passclass Student:native_place = '吉林'  # 类属性def eat(self, name, age):self.name = nameself.age = age@classmethoddef cm(cls):pass@staticmethoddef sm():passa = 10
b = 20
print(a+b)

121.模块的导入

import mathprint(id(math))
print(type(math))
print(math)
print(math.pi)
print('-----------------------')
print(dir(math))
print(math.pow(2,3), type(math.pow(2, 3)))
print(math.ceil(9.001))
print(math.floor(9.9999))

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

import calcprint(calc.add(10, 20))
print(calc.div(10, 4))

# 导入cals自定义模块使用
from calc import addprint(add(10, 20))

122.以主程序方式运行

import calc2print(calc2.add(100, 200))

def add(a, b):return a+bif __name__ == '__main__':print(add(10, 20))  # 只有当点击运行calc2时, 才会执行运算

123. Python中的包

# 导入带有包的模块时注意事项import package1
import calc#  使用import方式进行导入时，只能跟包名或模块名from package1 import moudle_A
from package1.moudle_A import a# 使用from...import 可以导入包，模块，函数变量

124. Python中常用的内容模块

import sys
import time
import math
import urllib.request
print(sys.getsizeof(24))
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)

125.第三方模块的安装与使用

import schedule
import timedef job():print('哈哈 ------')schedule.every(3).seconds.do(job)
while True:schedule.run_pending()time.sleep(1)

126. 编码格式的介绍

127. 文件读写原理_读取磁盘文件中的内容

file = open('a.txt', 'r')
print(file.readlines())file.close()

128. 常用的文件打开模式

file = open('a.txt', 'w')
file.write('Python')file.close()

scr_file = open('logo.png', 'rb')target_file = open('copylogo.png','wb')target_file.write(scr_file.read())target_file.close()
src_file.close()

129.文件对象的常用方法

file = open('a.txt','r')
# print(file.read(2))
# print(file.readline())
print(file.readlines())

file = open('c.txt','a')
lst = ['java', 'go', 'python']
file.writelines(lst)
file.close()

file = open('a.txt','r')
file.seek(2)
print(file.read())
file.close()

file = open('a.txt','r')
file.seek(2)
print(file.read())
print(file.tell())
file.close()

file = open('d.txt','a')
file.write('hello')
file.flush()
file.write('world')
file.close()

130. with语句

# My ContentMgr实现了特殊方法__enter__(), __exit__()称为该类对象遵守了上下文管理器协议
# 该类对象的实例对象，称为上下文管理器
# MyContentMgr()class MyContentMgr(object):def __enter__(self):print('enter方法被调用执行了')return selfdef __exit__(self, exc_type, exc_val, exc_tb ):print('exit方法被调用执行了')def show(self):print('show方法被调用执行了')with MyContentMgr() as file:  # 相当于file=MyContentMgr()file.show()

================================

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

131. os模块的常用函数

# os模块与操作系统相关的一个模块
import os
# os.system('notepad.exe')
# os.system('calc.exe')
# os.system('E:\\QQ\\Bin\\QQ.exe')
print(os.getcwd())
lst=os.listdir('../pythonProject7')
print(lst)# os.mkdir('newdir2')
# os.makedirs('A/B/C')
# os.rmdir('newdir2')
os.removedirs('A/B/C')
os.chdir('E:\\vippython\\chap14')
print(os.getcwd())

132. os.path模块的常用方法

import os.path
print(os.path.abspath('demo9.py'))
print(os.path.exists('demo9.py'), os.path.exists('demo18.py'))
print(os.path.join('E:\\python', 'demo13.py'))
print(os.path.split('E:\\vippython\\chap15\\demo13.py'))
print(os.path.splitext('demo13.py'))
print(os.path.basename('E:\\vippython\\chap15\\demo13.py'))
print(os.path.dirname('E:\\vippython\\chap15\\demo13.py'))
print(os.path.isdir('E:\\vippython\\chap15\\demo13.py'))

# 列出指定目录下的所有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)
print(lst_files)
for dirpath, dirname, filename in lst_files:print(dirpath)print(dirname)print(filename)for dir in dirname:print(os.path.join(dirpath, dir))for file in filename:print(os.path.join(dirpath, file))