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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/246414