目录
第一、二章
1.文件读写
import time
p=open('D:\IDEALX\PyOne\sa.txt','r+')#r+,读写文件,该文件必须存在
m = sp.read()#从文件读取指定字节数,未指定参数则读取所有内容
m = int(m) + 1
print(m)
sp.seek(0)#设置文件当前位置
sp.truncate()#截取文件,截取的字节通过参数指定
sp.write(str(m))#将字符串写入文件,
sp.close()
fp = open('D:\IDEALX\PyOne\print.txt','a+')#a+,读写,若文件已存在,不清空文件,指针指向最后面,新加数据
print('第',m,'次运行输出时间是:',time.strftime("%Y-%m-%d-%H_%M_%S", time.localtime()),file=fp)
fp.close()
with open('D:\IDEALX\PyOne\sb.txt','a+') as sb:print('i know',file=sb)
2.转义字符
print('hello\nworld')#n->newline
print('hello\tworld')#\t,表示四个位置,比如my占了两个位置,还剩俩位置,所以输出俩空格
print('helloooo\tworld')#如果前面的字符刚好为4的整数倍,那么会输出四个空格
print('hello\rworld')#回车,world会覆盖hello
print('hello\bworld')#回退一格
print('http:\\www.baidu.com')#\会输出后面跟着的字符
print('http:\\\\www.baidu.com')
print('i say:\'good job\'')#\后面跟着单引号,就输出了单引号
3.变量和标识符
name='瑆玥琼'
print('标识',id(name))
print('类型',type(name))
print('值',name)
4.布尔数
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
print(f1+1,type(f1))#2,说明true=1
print(f2+1,type(f2))#1,说明false=0
5.整数
n=100
print(n,type(n))
print('十进制',100)
print('二进制',0b11111111)
print('十六进制',0x50)
print('八进制',0o70)
6.注释
#单行注释符
print("""多行输出,
比如这个""")
print('''这个也可以
完成多行输出''')
'''多行注释
使用这玩意'''
7.浮点数
n1=float(2.2)
n2=float(1.1)
print(n1+n2)
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
8.类型转换
a1=123
b1=456.789
c1='114'
d1='114.514'
e1=True
f1='what\'s up'
print(a1,type(a1))
print(str(a1),type(str(a1)))
print(int(b1),type(int(b1)))
print(int(c1),type(int(c1)))
#print(int(d1),type(int(d1)))#整数类型转换,只能将整数字符串转换,小数字符串不行
print(int(e1),type(int(e1)))
#print(int(f1),type(int(f1)))#文字字符串也不行
print(float(a1),type(float(a1)))
print(float(c1),type(float(c1)))
print(float(e1),type(float(e1)))
#print(float(f1),type(float(f1)))#浮点型转换,文字字符串无法转换
第三章
1.input的使用
pt =input ("哥们,这瓜多少钱一斤呐")
print(pt,type(pt))
p1=input("买几斤瓜")
p2=input("多少钱一斤的")
print(int(p1)*int(p2))
2.位运算
print(4&8)#0000 0100和0000 1000与
print(4|8)#0000 0100和0000 1000或
print(4<<1)#0000 0100左移一位,变成0000 1000
print(8//4)#//表示整除
print(8/4)
print(2*3)
print(2**3)#2的三次方
3.布尔运算符
s='helloword'
print('h' in s)
print('o' in s)
print('k' in s)
print('k' not in s)
f=True
f1=False
print(not f)
print(not f1)
4.比较运算符
a=10
b=10
print(id(a),'\n',id(b))
print(a is b)#is比较对象的标识是否一样,一样输出ture
print(a is not b)
list1=[10,20,30,40]
list2=[10,20,30,40]
print(id(list1),'\n',id(list2))
print(list1 is list2)#is比较对象的标识是否一样,一样输出ture
5.赋值运算符
a,b=10,20
print(a,b)
a,b=b,a
print(a,b)
#python中的这个解包赋值,可以省去别的语言中需要引入中间变量解决互换值的问题
6.求余运算
#求余运算,公式为:余数=被除数-除数*商,商=被除数/除数(结果精确到小数,取整)
print(9%4)#1, 1=9-4*2, 2=9/4=2.25(正数向下取整)
print(4%9)#4, 4=4-9*0 0=4/9=0.4444(正数向下取整)
print(-9%4)#3, 3=-9-(4)*(-3), -3=-9/4=-2.25(负数向下取整)
print(9%-4)#-3, -3=9-(-4)*(-3) -3=9/-4=-2.25(负数向下取整)
print(-9%-4)#-1, -1=-9-(-4)*2 2=-9/-4=2.25(正数向下取整)
print(-4%-9)#-4, -4=-4-(-9)*0 0=-4/-9=0.444(正数向下取整)
第四章
1.if的嵌套使用
print('请输入一个0~9之间的整数')
a=int(input('输入的整数为:'))
if a<=9:
if a>=0:
print('你输入的数为:',a,'正确!')
else:
print('请输入大于0的数')
else:
print('请输入小于9的数')
2.pass语句
print('您是否是VIP?y\n')
user=input()
if user:
pass#用于省略具体执行语句
else:
pass
3.单分支结构
print('请输入一个0~9之间的整数')
temp=int(input())
if temp>=0 and temp<=9:
print('输入正确,你输入的数字是:',temp)
else:
print('输入错误,请重新输入')
4.多分支结构
print('请输入你的成绩')
a=int(input('你的成绩为:'))
if a<=100 and a>=90:
print('优')
elif a<90 and a>=80:
print('良')
elif a<80 and a>=70:
print('好')
elif a<70 and a>=60:
print('及格')
else:
print('不及格')
5.对象的布尔值
#Python中所有对象都有布尔值
print(bool(False))
print(bool(''))
print(bool([]))
print(bool({}))
print(bool(list()))
6.条件表达式?
a=int(input('第一个数:'))
b=int(input('第二个数:'))
print('第一个数大' if a>b else '第二个数大')
第五章
1.break语句
for item in range(3):
p = input("请输入密码:")
if p == '114514':
print('密码正确')
break
else:
print('密码错误,请重新输入')
2.continue语句
"""输出所有50以内5的倍数"""
for item in range(1,51):
if item%5!=0:
continue
print(item)
3.for_in语句
for item in 'sword':
print(item)
for item in range(5):
print(item)
for _ in range(5):
print('下划线代表不使用到该变量!')
4.range函数
r=range(10)
print(r)
print(list(r))
s=int()
for i in r:
s+=i
print(s)
x = 'loveme'
for i in range(len(x)) :
print(x[i])
s=range(1,10)
print(list(s))
t=range(1,10,2)
print(list(t))
print(10 in t)
print(10 not in t)
5.while语句
a=1
while a<10:
print(a)
a+=1
#计算0到4之间的累加和
s=0
t=0
tp=0
while s<5:
while t<=s:
tp+=t
t+=1;
print(s,'的累加和为:',tp)
s+=1
6.嵌套循环
#输出一个矩阵
for i in range(1,5):
for t in range(1,5):#或者for t in range(1,i+1),这样就不用下面的if了
if t<=i:
print(t,'*',i,'=',i*t,end='\t')
print()
第六章
1.列表中指定元素的索引
list=['why',123,True,'why']
print(list.index('why'))#如果列表中有相同的元素,返回最前面的索引号
#print(list.index('NCK'))#查找 没有的元素时,抛出异常
print(list.index('why',1,4))#在指定的范围内查找元素的索引号
2.列表介绍
a=10#a指向一个id为xx的对象,里面有type和value
list1=['hello','world',123,True]#list1指向列表的id,列表中存放的是每个对象的id,每个对象里存放有该对象的type和value
print(id(list1))
print(type(list1))
print(list1)
print(list1[0],list1[-2])#从左往右(0,1,2,3……),从右往左(-1,-2,-3……)
3.列表元素的修改
list1 = [1,2,3,4,5,6,7]
list1[2]=40
print(list1)
list1[1:3]=[100,200,300]
print(list1)
4.列表元素的删除
list1 = [10,20,30,40,20,50,60,70,80,90,100]
list1.remove(20)#删除单个指定元素,重复元素删除前面的
print(list1)
list1.pop(1)#根据索引删除元素
print(list1)
list1.pop()#不指定索引则默认删除最后一个
print(list1)
print('-----切片操作,会产生一个新的列表-----')
new_list = list1[1:5]
print('原列表',list1)
print('新列表',new_list)
"""不产生新列表对象,删除原列表内容"""
list1[1:6]=[]
print(list1)
"""清楚列表中所有元素"""
list1.clear()
print(list1)
"""del语句删除列表对象"""
del list1
#print(list1)#会报错,因为列表list1已经被删除了
5.列表元素的判断和遍历
list1 = [1,2,3,4,5,6,7,8]
print(2 in list1)
print(10 in list1)
print(5 not in list1)
for item in list1:
print(item,end='\t')
6.列表元素的排序
#sort函数对列表本身进行操作,sorted函数会产生一个新列表,这是区别
list1 = [10,52,23,65,45,90,103]
list1.sort()#默认升序排序
print(list1)
list1.sort(reverse=True)#调用参数reverse进行降序排序
print(list1)
list1.sort(reverse=False)
print(list1)
print('-----使用内置函数sorted进行排序,将会产生一个新的列表对象-----')
list2 = [32,521,32,21,765,24]
new_list2 = sorted(list2)
print(list2)
print(new_list2)
new_list22 = sorted(list2,reverse=True)#指定参数进行降序排序
print(new_list22)
7.列表元素的添加
lst = [10,20,30]
print(lst)
lst.append(100)#在lst末尾添加一个元素
print(lst)
list1 = ['hello','world']
#lst.append(list1)#把list1当成一个元素添加到lst后面
lst.extend(list1)#把list1中每一个元素添加到lst后面
print(lst)
lst.insert(2,90)#在指定的第二个位置添加一个元素90
print(lst)
list3 = [True,False,'what']
lst[1:] = list3#切片,从1号元素开始切完后面的所有元素,将list3中的元素补给lst从1开始往后的元素
print(lst)
8.列表的切片
list1 = [1,2,3,4,5,6,7,8,9,10,11,12,13]
list2 = list1[2:7:1]
print(list2)
list3 = list1[-1:-7:-1]
print(list3)
list4 = list1[2::1]#切片默认到列表最后一个元素结束
print(list4)
list5 = list1[:7:1]#切片默认从列表第一个元素开始
print(list5)
list6 = list1[-9::-1]#切片最后一个元素默认为列表第一个元素
print(list6)
9.列表生成式
list1=[i for i in range(10)]
print(list1)
list2=[i*i for i in range(10)]#for前面的是每一个列表元素的表达式
print(list2)
list3=[i*2 for i in range(1,6)]
print(list3)
第七章
1.字典
sorce={'元素1':23,'元素2':24}#字典是一个可变序列,只有值可变,键不可变,根据key值查找value值
2.字典元素的增删改
scores={'张三':23,'李四':52,'王五':42}
print('张三' in scores)
print('张三' not in scores)
del scores['张三']#单个删除
print(scores)
scores.clear()#清空字典
print(scores)
scores['陈六']=90#增加一个字典元素
print(scores)
scores['陈六']=100
print(scores)
3.字典元素的获取
scores={'张三':23,'李四':52,'王五':42}
print(scores['张三'])
#print(scores['老六'])#KeyError: '老六'
print(scores.get('李四'))
print(scores.get('老六'))#None
print(scores.get('陈六',90))#90是在查找陈六所对应的value不存在时,提供的一个默认值
4.字典元素的遍历
scores={'张三':23,'李四':52,'王五':42}
for item in scores:
print(item)
for item in scores.values():
print(item)
for item in scores:
print(item,scores[item],scores.get(item))
5.字典生成式
items=['apple','banana','sword']
prices=[20,30,40,50,60,70]
d={item:price for item,price in zip(items,prices)}
print(d)
d2={item.upper():price for item,price in zip(items,prices)}#最前面的item是字典key值表达式,调用upper()函数使每个key大写
#后面的price是value值表达式
print(d2)
6.字典的创建
s={'方式1':24}
print(s)
s2=dict(name='方式2',age=40)
print(s2)
s3={}
print(s3)
7.获取字典视图
scores={'张三':23,'李四':52,'王五':42}
#获取所有的key
ps=scores.keys()
print(ps)
print(type(ps))
print(list(ps))#将所有的key组成的视图转成列表
#获取所有的value
psvalue=scores.values()
print(psvalue)
print(type(psvalue))
print(list(psvalue))
#获取所有的key-value键值对
psitem=scores.items()
print(psitem)
print(type(psitem))
print(list(psitem))#转换后的列表元素由元组组成
第八章
1.元组定义
#可变序列:比如列表、字典,里面的值发生改变后,id不变
list1=[20,30,40]
print(id(list1))
list1.append(400)
print(list1)
print(id(list1))
#不可序列:比如字符串、元组,值改变后,id跟着改变,即一个id对应一个值
s='hello'
print(id(s))
s=s+'world'
print(id(s))
2.元组不可变
t = ('OK',[20,30],90)
print(type(t[0]))
print(type(t[1]))
print(type(t[2]))
"""尝试将t[1]修改为100"""
#t[1] = 100 #元组不允许修改元素
"""由于[20,30]是列表,列表是可变序列,所以可以向列表中添加元素,而列表的内存地址不变"""
#元组当中的对象是可变对象时,可变对象的引用不允许修改,但允许修改其数据
t[1].append(100)
print(t[1])
3.元组的创建
#方式一
t1 = ('hello','world',98)
print(type(t1))
#方式二:
t2 = 'hello','world',99
print(type(t2))
t21 = 'hello'
print(type(t21))#字符串类型
t22 = ('hello',)
print(type(t22))#只有一个元素时,要带上括号和逗号才表示为元组
#方式三:
t3 = tuple (('hello',[20,30],78))
#t3 = tuple ('hello','world',78)#注意不要少一个分号
print(type(t3))
#空列表、字典、元组的创建
lis1 = []
lis1 = list()
lie1 = {}
lie1 = dict()
y1 = ()
y1 = tuple()
4.元组的遍历
t = ('OK',[20,30],90)
#第一种获取方式,索引
print(t[0])
print(t[1])
print(t[2])
#第二种方式,for——in
for item in t:
print(item,end='\t')
5.集合之间的关系
"""两集合是否相等"""
s1 = {1,2,3,4}
s2 = {4,3,2,1}
print(s1 == s2) #True
print(s1 != s2) #False
"""一个集合是否是另一个子集"""
t1 = {1,2,3,4}
t2 = {3,2,1}
print(t1.issubset(t2))
print(t2.issubset(t1))#t2是t1的子集吗? True
"""一个集合是否是另一个集合的超集"""
z1 = {1,2,3,4}
z2 = {3,2,1}
print(z1.issuperset(z2))
print(z2.issuperset(z1))#z2是z1的超集吗? False
"""两集合是否有交集"""
x1 = {1,2,3,4}
x2 = {3,2,1}
x3 = {7,8,9}
print(x1.isdisjoint(x2)) #有交集为False
print(x1.isdisjoint(x3)) #无交集为True
6.集合生成式
#列表生成式
s = [i*i for i in range(6)]
print(s)
#集合生成式
t = {i*i for i in range(10)}
print(t)
7.集合的创建
#第一种方式
s = {1,2,3,4,5,5,5,5,5}#集合中的元素不允许重复
print(s)
#第二种方式,使用内置函数set
s1 = set(range(6))
print(s1)
s2 = set([1,2,3,4,5,5,5])
print(s2)
s3 = set((1,2,4,4,5,65))#集合中的元素是无序的
print(s3)
s4 = set('wocao')
print(s4)
#定义一个空集合
#s5 = {}#这个默认是字典
s5 = set()
8.集合的操作
s = {1,2,3,4,5,6,7,8}
"""集合元素的判断操作"""
print(1 in s)
print(2 not in s)
"""添加操作"""
s.add(10)#一次添加一个元素
print(s)
s.update({11,12,13})#至少添加一个元素
print(s)
s.update([20,21,22])
s.update((30.31,32))
print(s)
"""删除操作"""
s.remove(20)#指定删除一个
print(s)
#s.remove(200)#没有时删除报错
s.discard(200)#没有时删除不报错
s.pop()#随机删除一个,不能指定参数
print(s)
s.clear()
print(s)
9.集合的数据操作
"""交集"""
s1 = {1,2,3,6,7}
s2 = {3,7,8,9}
print(s1.intersection(s2))
print(s1 & s2)
"""并集"""
print(s1.union(s2))
print(s1|s2)
"""差集"""
print(s1.difference(s2))
print(s2.difference(s1))
print(s1-s2)
print(s2-s1)
"""对称差集"""#截掉公共部分,两边集合放在一起
print(s1.symmetric_difference(s2))
第九章
1.字符串切片操作
#切片后产生新的字符串,id变了
s = 'hello,Python'
s1 = s[:5]#没有指定起始位置,从0开始
print(s1)
s2 = s[6:]#没有指定结束位置,到末尾结束
print(s2)
newstr = s1+'!'+s2
print(newstr)
print('---------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(newstr))
print('-----切片[star,end,step]------')
print(s[1:5:2])#从1到5,步长为2
print(s[::2])
print(s[::-1])#倒叙排序
print(s[-6::1])
2.字符串创建与驻留机制
import sys
a = 'abc'
b = "abc"
c = """abc"""
print(id(a),id(b),id(c))
a1 = 'abc'
b1 = 'ab'+'c'
c1 = ''.join(['ab','c'])#join,通过指定字符串连接参数中的元素
"""str = "-"
seq = ("a", "b", "c") # 字符串序列
print(str.join(seq))#a-b-c"""
print(a1 is b1)#在编译时就已经连接好的字符串,进行驻留
print(a1 is c1)#在运行时调用函数连接的字符串,不进行驻留
a2 = -111111
b2 = -111111
print(a2 == b2)#取消了原本的[-5,255]的整数数字才有驻留的限制
a3 = 'abc?'
b3 = 'abc'
print(id(a3),id(b3))
a3 = sys.intern(b3)#让a3强制等于b3
print(id(a3),id(b3))
print(a3 is b3)
3.字符串对齐操作
s = 'if you are coming'
print(s.center(30,'?'))#居中对齐,第一个参数指定宽度,第二个参数指定填充字符
print(s.ljust(15,'?'))#左对齐,指定宽度小于字符串长度时,原样输出字符串本身
print(s.ljust(20,'?'))
print(s.ljust(30))#不指定填充字符,默认为空格
print(s.rjust(20,'#'))
print(s.rjust(30))
print(s.rjust(12,'#'))
print(s.zfill(40))#只允许指定宽度,左边默认使用0进行填充
print('-8910'.zfill(8))
4.字符串替换与合并
s = 'what is up'
t = 'two dolor 1 kg'
print(s.replace('up','JAVA'))#替换操作
s1 = 'shit shit shit'
print(s1.replace('shit','good',2))
x1 = ['hello','world','python','and','java']#列表
print('|'.join(x1))
print(''.join(x1))
x2 = ('hello','world','python','and','java')#元组
print('|'.join(x2))
print(''.join(x2))
print('*'.join(s))
5.字符串查询
s = 'hello,hello'
print(s.index('o')) #4
print(s.rindex('o')) #10
print(s.find('o')) #4
print(s.rfind('o')) #10
#print(s.index('k'))#不存在会抛出异常
print(s.find('k'))#不存在会返回-1
print(s.rfind('k'))
6.字符串的分割
#从左侧劈割
s = 'hello the world'
lis = s.split()#默认劈分符是空格
print(lis)#分割后返回一个列表
s1 = 'hello|the|world'
print(s1.split())
print(s1.split(sep='|'))#sep指定劈分符
print(s1.split(sep='|',maxsplit=1))#maxsplit,指定最大劈分次数
#从右侧劈割
print(s1.rsplit())
print(s1.rsplit(sep='|'))
print(s1.rsplit(sep='|',maxsplit=1))#这里不同
7.字符串的判断
#判断字符串是否是合法标识符
s = 'hello the world'
print('1.',s.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三'.isidentifier())
print('4.','张三_123'.isidentifier())
#判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符\t)
print('5.','\t'.isspace())
#判断指定的字符串是否全部由字母组成
print('6.','abc'.isalpha())
print('7.','李四'.isalpha())
print('8.','李四_'.isalpha())
#判断是否全部由十进制数组成
print('9.','123'.isdecimal())
print('10.','123四'.isdecimal())
print('11.','ⅢⅡ'.isdecimal())#罗马数字
#判断是否全部由数字组成
print('12.','1234'.isnumeric())
print('13.','1234四'.isnumeric())
print('14.','ⅢⅡ'.isnumeric())
#判断是否全部由数字和字母组成
print('15','abcl'.isalnum())
print('16','阿米娅123'.isalnum())
print('17','刀客塔?'.isalnum())
8.字符串的常用操作,大小写转换
s = 'hello,python'
a = s.upper()#转大写
print(a)
b = s.lower()#转小写,会产生一个新的字符串对象,即使两个字符串内容一致
print(id(s),id(b))
print(b)
s1 = 'DA XIE xiao xie'
a1 = s1.swapcase()#大小写互换
print(a1)
b1 = s1.capitalize()#第一个字母大写,后面全部小写
print(b1)
c1 = s1.title()#把每个单词的第一个字母大写,后面全部小写
print(c1)
9.字符串的比较
print('apple'>'app') #True
print('abc'>'bac')# 比较的是两个字符的原始值(ordinal value)
print(ord('a'),ord('b'))#97<98
print(chr(97),chr(98))
''' == 和 is的区别:
== 比较的是value
is 比较的是id是否相等'''
a=b='Python'
c='Python'
print(a==b,b==c,a==c)
print(id(a),id(b),id(c))#字符串常量驻留
print(a is b,b is c,a is c)
10.字符串的编码转换
#字符串→编码→转换成二进制数据byte字节传输→解码→显示
#编码
s = '画船听雨眠'
print(s.encode(encoding='GBK'))#一个中文占两个字节
print(s.encode(encoding='UTF-8'))#一个中文占三个字节
#解码
byte = s.encode(encoding='GBK')
#print(byte.decode(encoding='UTF-8'))
print(byte.decode(encoding='GBK'))#解码方式要一一对应
byte = s.encode(encoding='utf-8')
print(byte.decode(encoding='utf-8'))
11.格式化字符串
#格式化字符串:将字符串以一定格式输出
name = '瑆玥琼'
age = 24
#1.%作为占位符
print('我叫%s,今年%d岁' % (name,age))
#2.{}作为占位符
print('我叫{0},今年{1}岁'.format(name,age))
#3.f-string
print(f'我叫{name},今年{age}岁')
#精度
print('%d' % 90)
print('%10d' % 90)#10表示宽度
print('%.3f' % 3.14159)#.3表示小数点后三位
print('%10.3f' % 3.14159)#同时表示宽度精度
print('{}'.format(3.14159))#{}是占位符,里面最好有个数字,0代表第一个占位符
print('{0}'.format(3.14159))
print('{0:.3f}'.format(3.14159))
print('{:10.3f}'.format(3.14159))
第十章
1.个数可变的位置形参和个数可变的关键字形参
def fun(*s):#个数可变的位置形参,生成元组
print(s)
fun(100)
fun(10,20,30)
fun([1,2,3],[4,5,6])
def fun1(**t):#个数可变的关键字形参,生成字典
print(t)
#fun1(100)
#fun1(10,20,30)
#fun1([1,2,3],[4,5,6])
fun1(a=10)
fun1(a=20,b=30,c=40)
fun1(s='hello',t='wrold')
'''函数定义中,位置形参和关键字形参都只能有一个,不能有(*s,*r)和(**s,**r)这种,
两者在一起时,位置形参在关键字形参前(*s,*r)'''
2.参数值的返回
def rt(num):
ou=[]
ji=[]
for i in num:
if i%2==0:
ou.append(i)
else:
ji.append(i)
return ji,ou #返回多个值时,结果为元组
print(rt([1,2,3,4,5,6,7,8,9]))
3.函数的参数传递
def rt(num):
ou=[]
ji=[]
for i in num:
if i%2==0:
ou.append(i)
else:
ji.append(i)
return ji,ou #返回多个值时,结果为元组
print(rt([1,2,3,4,5,6,7,8,9]))
4.函数的参数定义
def fun(a,b=10):#b称为默认值参数
print(a,b)
fun(100)
fun(20,30)
print('hello',end='\t')#print()函数中默认值参数end='\n',修改一下就不会换行了
print('hello')
5.函数的定义与调用
def fun(a,b=10):#b称为默认值参数
print(a,b)
fun(100)
fun(20,30)
print('hello',end='\t')#print()函数中默认值参数end='\n',修改一下就不会换行了
print('hello')
6.局部变量
def fun():
global a#局部变量a使用global进行生命,则变为全局变量
a = 10
print(a)
fun()#必须先执行一次该函数,不然下面输出时,a还未声明
print(a)
7.递归调用
def sum(n):
if n==1:
return n
else:
return n*sum(n-1)
print(sum(6))
第十二章
没有第十一章
1.动态绑定属性方法
class User():
def __init__(self,name,age):
self.fq=name
self.st=age
def XM(self):
print(self.fq)
def NL(self):
print(self.st)
us1 = User('张三',24)
us2 = User('李四',42)
us2.xingbie='女'
print(us2.XM(),us2.NL(),us2.xingbie)
def show():
print('show方法')
us1.sw=show()
print(us1.sw)
2.定义Python中的类
class Student:
pass
#Python中一切皆对象,Student是对象吗?内存有空间么?
print(id(Student))
print(type(Student))
print(Student)
class Feature:
#初始化方法
def __init__(self,name,age):
self.name=name #self.name 称为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age=age
a4='炸弹' #直接写在类里的变量,称为类属性
#实例方法
def funs(self):
print('定义在类里的函数叫方法')
#静态方法
@staticmethod
def stamethod():
print('静态方法参数中不允许写self符号')
#类方法
@classmethod
def cm(cls):
print('类方法,使用classmethod方法,参数为cls')
3.对象的创建
class Feature:
#初始化方法
def __init__(self,name,age):
self.name=name #self.name 称为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age=age
a4='炸弹' #直接写在类里的变量,称为类属性
#实例方法
def funs(self):
print('定义在类里的函数叫方法')
#静态方法
@staticmethod
def stamethod():
print('静态方法参数中不允许写self符号')
#类方法
@classmethod
def cm(cls):
print('类方法,使用classmethod方法,参数为cls')
#实例化对象
f1=Feature('李四',24)
f1.funs()
print(f1.name)
print(f1.age)
print('---------------------')
Feature.funs(f1) #与上功能相同,都是调用funs方法
第十三章
1.object类
class any():
pass
a1 = any()
print(dir(a1))#类any()继承自object类,dir方法可以显示any可以使用的object类中的方法
print(a1)
class any2():
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return '我的名字是{0},今年{1}'.format(self.name,self.age)
a2 = any2('瑆玥琼',24)
print(a2)#输出时会调用str方法,像上面的a1一样,但我重写了str方法,默认的str方法是返回当前对象的所属类的信息
2.多态
#多个类中含有同一个方法
class Animal():
def eat(self):
print('动物吃:')
class Cat(Animal):
def eat(self):
print('猫爱吃鱼')
class Dog(Animal):
def eat(self):
print('狗爱吃肉')
class Person(Animal):
def eat(self):
print('人爱吃饭')
def fun(animal):
animal.eat()
fun(Dog())
fun(Person())
3.封装
class User():#User,类对象
def __init__(self,name,age):
self.f1=name
self.__f2=age#加两个下划线,代表只能在类内部使用,不能被外部调用
us1 = User('张三',24)
print(us1.f1)
#print(us1.__f2)
print(dir(us1))
print(us1._User__f2)#但是仍可以通过:_类名__属性名 的方式来访问,全凭自觉性,__是用来提醒尽量不要访问该属性
4.特殊属性
class A():
pass
class B():
pass
class C(A,B):
def __init__(self,name,age):
self.name = name
self.age = age#实例对象的属性
#创建C类的实例化对象
x=C('Jony',24)
print(x.__dict__)#实例对象的属性字典
print(C.__dict__)
print('_________')
print(x.__class__)#输出对象所属的类
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(C.__mro__)#类的层次结构
print(A.__subclasses__())#输出A的子类
5.特殊方法
a=100
b=20
#c=a+b
c=a.__add__(b)
print(c)
x='帅啊'
y='卧槽'
z=x+y
z=x.__add__(y)
print(z)
class Person(object):
def __new__(cls, *args, **kwargs):#__new__()用于创建对象,你把这函数删了他也一样能创建,只是告诉你对象创建的过程中需要调用这个函数
xd=super().__new__(cls)
print('xd的id:{}'.format(id(xd)))
return xd
def __init__(self,name,age):
self.name=name
self.age=age
print('self的id:{}'.format(id(self)))
print('Person的id:{}'.format(id(Person)))
print('object的id:{}'.format(id(object)))
print('\r')
p1=Person('张三',24)
print('p1的id:{}'.format(id(p1)))
6.类的赋值与浅拷贝
class A():
pass
class B():
pass
class C():
def __init__(self,ct,ct2):
self.ct=ct
self.ct2=ct2
a1=A()
a2=a1
print(id(a1),id(a2))
#浅拷贝
b1=B()
import copy
c1=C(a1,b1)
c2=copy.copy(c1)
print(id(c1),id(c2))#拷贝后两个类的id不同,但里面的内容所指向的东西相同(只拷贝指向的子对象,不拷贝子对象的内容)
print(c1.ct,c1.ct2)
print(c2.ct,c2.ct2)#可以看出两个类输出的子对象id都一样
#深拷贝
c3=copy.deepcopy(c1)#拷贝后两个类的id和子对象id都变了了,把子对象一起拷贝了一遍
print(c1.ct,c1.ct2)
print(c3.ct,c3.ct2)#子对象的id已经变了
7.继承
class Animal(object):
def __init__(self,name,age):#类中自己的init方法第一个参数一定是self,代表类的实例,传递参数时不需要管self
self.name=name
self.age=age
class Dog(Animal):
def __init__(self,name,age,typ):
# super.__init__(name,age)#单个父类继承时,要是super()
super().__init__(name,age)
self.typ=typ
#class Smalldog(Animal,Dog):#参数中父类的顺序问题,一级一级按顺序写
class Smalldog(Dog,Animal):
def __init__(self,name,age,typ,eat):
# super().__init__(name,age,typ)#不能直接使用super()给父类传递参数,因为有两个父类
# Animal.__init__(name,age)#在进行父类传递参数的时候,
# Dog.__init__(name,age,typ)
Animal.__init__(self,name,age)
Dog.__init__(self,name,age,typ)
self.eat=eat
def pt(self):
print(self.eat)
sd = Smalldog('小旺',4,'柴犬','奶粉')
sd.pt()
第十四章
前置文件:cs.py
def add(a,b):
return a+b
1.Python中的包
#import只能导入包或者模块
import Python中的包
import Python中的包.py包 as ac
print(Python中的包.py包.a)
print(ac.a)
#from……import可以导入包、模块、函数、变量
from Python中的包 import py包 as pb
print(pb.a)
2.Python中常用的内容模块
import sys
import time
print(sys.getsizeof(24))
print(sys.getsizeof(True))
print(time.time())
print(time.localtime(time.time()))
import urllib.request#urllib包中有个request模块,用于发送请求
print(urllib.request.urlopen('https://www.4399.com/').read())#打开浏览器复制网址粘贴过来,别自己写成www.xxx.com
import math
print(math.pi)
3.以主程序方式运行
3.1 前置文件(名称为:以主2)
def add(a,b):
return a+b
if __name__=='__main__':#只有本模块(以主2)运行时,变量name的值才为main,才执行下面的语句
print(add(20,30))#在其他模块中运行则不会执行该语句,因为记录模块名称的变量__name__不为__main__
3.2 执行文件
import 以主2
print(以主2.add(40,70))
4.模块
#.py的一个文件就是一个模块
from cs import add#和第一个print对应
import cs#和第二个print对应
x=10
y=20
print(add(x,y))
print(cs.add(x,y))
第十五章
前置文件:a.txt
随便写点什么
都可以
1.os模块介绍
#os模块是与操作系统相关的一个模块(和windows或者Linux等)
import os
#os.system('notepad.exe')
#os.system('calc.exe')
#可直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')
2.os模块使用
import os
#返回当前目录
print(os.getcwd())
#返回指定路径下的文件和目录信息
print(os.listdir('../第十五章'))#..退出当前目录,在第十五章里面输出不了第十五章的信息
#创建目录
os.mkdir('MD1')
#创建多级目录
os.makedirs('A/B/C')
#删除目录
os.rmdir('MD1')
#删除多级目录
os.removedirs('A/B/C')
#将path设置为当前工作目录
os.chdir('D:\\IDEALX\\PyOne\\module2\\第十五章')
print(os.getcwd())
3.os.path模块
import os.path
#获取指定文件的目录
print(os.path.abspath('os2.py'))
#判断目录是否存在
print(os.path.exists('os模块.py'),os.path.exists('不存在的模块.py'))
#将目录或者目录名、文件名拼接起来
print(os.path.join('D:\\IDEALX','os模块.py'))
#分离文件名和扩展名
print(os.path.splitext('os2.py'))#将文件和后缀名拆分
print(os.path.split('D:\IDEALX\PyOne\module2\第十五章\os2.py'))#将目录拆分
#从一个目录中提取文件名
print(os.path.basename('D:\IDEALX\PyOne\module2\第十五章\os2.py'))
#从一个路径中提取文件路径,不包括文件名
print(os.path.dirname('D:\IDEALX\PyOne\module2\第十五章\os2.py'))
#判断是否是路径
print(os.path.isdir('D:\IDEALX\PyOne\module2\第十五章\os2.py'))
4.with语句
print(open('a.txt','rb'))
with open('a.txt','rb') as Y1:
with open('a2.txt','wb') as Y2:
Y2.write(Y1.read())
#with语句自动关闭文件,自动管理上下文资源,无论什么原因跳出with块,都能确保文件正常关闭
#with 上下文管理器 as 自定义文件名:
#上下文管理器:实现了_enter_()方法和_exit_()方法的函数就叫上下文管理器,open函数的父类中实现有这两个函数
#exit方法,用于关闭文件,enter方法用于返回赋值给自定义文件名
5.文件读写
file = open('a.txt','r')
print(file.readline())
print(file.readlines())
file.close()
6.遍历目录
import os.path
b1=os.getcwd()
list_b1=os.walk(b1)#walk返回一个三元组(根路径,文件名,路径)
for filedir,filename,filepath in list_b1:
print(filedir)
print(filename)
print(filepath)
for f1 in filedir:
print()