---

python

一:第一章

1.print输出

print('hello,world')

#输出包含运算符--->4
print(3+1)

#讲数据输出到文件中,注意使用存在的盘符,并且用file=××的格式
fp=open('F:/text.text','a+')# 'a+' --> 如果文件不存在就创建,如果存在就在后面追加内容
print('hello',file=fp)
fp.close()

#不进行换行输出
print('hello','world','zaima')

2.转义字符

#转义字符
print('hello\nworld') # \n为换行,n-->newline的首字符表示换行

print('hello\tworld') #水平制表符(4个空格位),每四个占一个,这里hello有五个字符,所以空格为3个

print('hello\rworld') #输出结果:world ,这里\r表示回车,后面的world把前面的hello覆盖了

print('hello\bworld') #输出结果:hellworld   \b 为back回退一格

print('老师说:\'你好\'') #这里 \ 为转义字符

#原字符,不希望字符中的转义字符起作用,在字符前面加上r或者R
print(r'hello\nworld')

3.标识符和保留字

import keyword
print(keyword.kwlist)
#保留字:['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']  这都是一些关键字不能用来定义文件名字

标识符:
    变量,函数,类,模块和其他对象起的名字就叫标识符
    规则:
        字母,数字,下划线
        不能以数字开头
        不能是保留字(即关键字)
        严格区分大小写

4.变量

name='宋旭光'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

输出结果:
    宋旭光
    标识 2167929238224
    类型 <class 'str'>
    值 宋旭光

5.基本类型

1.整数int

#整数类型,可以是二进制,八进制,十进制,十六进制,默认是十进制
print('十进制',118)
print('二进制',0b101010) #二进制以0b开头
print('八进制',0o154) #八进制以0o开头
print('十六进制',0x1EF1) #十六机制以0x开头

输出结果:
    十进制 118
    二进制 42
    八进制 108
    十六进制 7921

2.字符串str

'' 和"" 里面的内容都是在一行输出
""" """ 和''' ''' 三引号可以在不同行输出

3.类型转换

name='张三'
age=20
#print('我的名字叫'+name+'今年'+age) 这里因为 + 是连接符,age和name类型不一样不能连接
print('我的名字叫'+name+'今年'+str(age)) #这里把age的int类型转换为str类型就可以了


转换函数:
    str()
    int() -->如果是讲float类型转换,会截取小数部分,保留整数部分; 如果将str类型转换为int时,字符串必须是整数,例如'123',不能是小数串:'12.35',如果是非整数串(文字类型),否则会报错
    float() --->非数字串不能转换,即文字不能转换,而数字串可以,bool也可以

6.python注释

#注释单行
print('hello')

'''注释多行,
你好啊,
这是一个多行注释'''

在文件的开头注释:
    #coding=utf-8
    会被电脑解析

二:运算符

1.input输入

present=input('请输入你想要的东西:')
print(present)

#输入两个数进行计算,这里输入都都是字符串类型,所以只能拼接不能计算
a=input('请输入第一个数:')
b=input('请输入第二个数:')
print(a+b)

#对输入的字符串类型进行类型转化
a=input('请输入第一个数:') 
a=int(a)  #简便方式,直接int()-->a=int(input('请输入第一个数:'))
b=input('请输入第二个数:')
b=int(b)   #简便方式,直接int()-->b=int(input('请输入第二个数:'))
print(a+b)

#对输入的字符串类型进行类型转化
a=int(input('请输入第一个数:'))
 #简便方式,直接int()-->a=int(input('请输入第一个数:'))
b=int(input('请输入第二个数:'))
  #简便方式,直接int()-->b=int(input('请输入第二个数:'))
print(a+b)

2.算术运算

print(1+1)
print(2-1)
print(3*2)
print(11/2) #除法运算, 结果为5.5
print(11//2) #整除运算 ,结果为5
print(11%2) #取余运算,结果为1
print(3**3) #幂运算,结果为27,为3*3*3

print(-9//4) #-3
print(9//-4)  #-3 一正一负向下取整

print(-9%4) # 3 余数=被除数-除数*商 -9-4*(-3) = -9+12= 3
print(9%-4) # -3

3.赋值

a=b=c=20 #链式赋值
#参数赋值:
a=20
a+=30 #-->a=a+30=50
print(a)
a-=10 #--?a=a-10=50-10=40
print(a)

#解包赋值 左右两边的个数相同
a,b,c=10,20,30

#交换
a,b=10,20
print(a,b)
#交换后
a,b=b,a
print(a,b)

4.比较运算

# > < = >= <= != 这些比较结果都是bool类型
'''
一个 = 成为赋值运算,== 称为比较运算
一个变量由三部分组成, 标识,类型,值
== 比较的是值
比较对象的标识使用 is
'''

a=10
b=10
print(a==b) #true 说明a和b的value值相等
print(a is b) #true 说明a和b的id标识相等

list1=[11,22,33]
list2=[11,22,33]
print(list1==list2) #true
print(list1 is list2) #false
print(list1 is not list2) #true -->list1的id与list2的id不相等吗

5.位运算

# &运算
print(4&8) #-->按照二进制运算,即00000100 和00001000 逐位与运算得0

# |运算
print(4|8)##-->按照二进制运算,即00000100 和00001000 逐位或运算得12

print(4<<1)#向左移动一位,相当于乘2 -->4*2=8
print(4<<2)#向左移动两位,相当于乘4 -->4*2*2=16

print(4>>1)#向右移动一位,相当于除乘2 -->4/2=2
print(4>>2)#向右移动两位,相当于除乘4 -->4/2/2=1

6.运算符优先级

** -->*,/,//,%--> +,- 
        			 --> <<,>> -->& -->| 
    									--> >,<,>=,<=,==,!= 
        													-->and -->or
            																--> =
|    <--算术运算-->  |  <--位运算符-->   | <--比较运算-->    | <--bool运算-->|<--赋值运算-->

三:分支结构

1.对象的布尔值

#以下对象的bool值为False
print(bool(False)) #False
print(bool(0)) #False
print(bool(0.0)) #False
print(bool(None)) #False
print(bool('')) #False
print(bool("")) #False
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合

#其他对象的bool值都是True

#这里可以直接把对象放入条件表达式中
例如:
age=int(input('请输入年龄:'))
if age: #--->这里如果为ture,直接往下执行
    print(age)
else:
    print('年龄为:',age)

2.单分支结构(if)

'''
	语法:
	if 条件表达式:
		条件执行体
'''
money=1000
a=int(input('请输入要取款的金额:'))
if money>=a:
    money=money-a
    print('剩余金额:',money)

3.双分支结构(if..else)

'''
	语法:
	if 条件表达式:
		条件执行体1
	else:
		条件执行体2
'''

#输入一个数判断是奇数还是偶数
num = int(input('请输入一个整数'))
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

4.多分支结构

'''
	语法:
	if 条件表达式1:
		条件执行体1
	elif 条件表达式2:
		条件执行体2
	elif 条件表达式N:
		条件执行体N
	[else:] -->可以省略
		条件执行体N+1
'''

#输入一个数判断等级
score=int(input('请输入一个数:'))
if score>=90 and score<=100:
    print('A')
elif score>=80 and score<90:
    print('B')
elif score>=70 and score<80:
    print('C')
elif score>=60 and score<70:
    print('D')
elif score>=0 and score<60:
    print('E')
else:
    print('您输入的成绩不符合')
    
简介写法:
    #输入一个数判断等级
score=int(input('请输入一个数:'))
if 90<=score<=100:
    print('A')
elif 80<=score<90:
    print('B')
elif 70<=score<80:
    print('C')
elif 60<=score<70:
    print('D')
elif 0<=score<60:
    print('E')
else:
    print('您输入的成绩不符合')

5.嵌套if

'''
	语法:
	if 条件表达式1:
		if 内层条件表达式:
			内层条件执行体1
		else:
			内层条件执行体2
	else:
		条件执行体
'''

#判断是否是会员根据消费金额打折
answer=input('是否是会员,请输入y/n:')
count = float(input('请输入您得消费金额:'))
if answer=='y':
    if count>=200:
        print('打八折,您消费:',count*0.8)
    elif count>=100:
        print('打九折,您消费:',count*0.9)
else:
    if count>=200:
        print('打九五折,您消费;',count*0.95)

6.条件表达式

#输入两个数,比较大小
num_a=int(input('请输入第一个数:'))
num_b=int(input('请输入第二个数:'))
if num_a>=num_b:
    print(num_a,'大于',num_b)
else:
    print(num_a,'小于',num_b)
    
    
 
#简写
print(   str(num_a)+'大于'+str(num_b)    if num_a>num_b else    str(num_a)+'小于'+str(num_b))

7.pass

#pass什么都不做,只是一个占位符,在搭建代码流程时,没有写代码的地方用pass,可以不报错

answer=input('是否是会员>y/n')
#判断
if answer=='y':
	pass
else:
    pass

四:循环

1.range函数

• 用来生成一个整数序列
• 创建range对象的三种方式
  • range(stop)
  • range(start,stop)
  • range(start,stop,step)

#第一种创建方式,只有一个参数
r=range(10)
print(r) #range(0, 10)
print(list(r)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],默认从0开始,相差为1.即步长为1

#第二种创建方式,两个参数
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],步长为2

#判断一个数是否在这个序列中
print(10 in r) #False
print(20 not in r) #True

2.while循环

• 选择结构的if和循环结构的while的区别
  • if是判断一次,条件为true执行一次
  • while是判断N+1次,条件为True执行N次

'''
	语法:
		while 条件表达式:
			条件执行体(循环体)
'''

#求4以内的整数合
sum=0
a=0
while a<5:
    sum+=a
    a+=1
print(sum)

3.小练习

#1-100之间的偶数和
sum=0
r=1
while r<=100:
    if r%2==0: 
        sum+=r
    r+=1
print('求和:',sum)


#1-100之间的偶数和
sum=0
r=1
while r<=100:
    if not bool(r%2):
        sum+=r
    r+=1
print('求和:',sum)


#1-100之间奇数和
sum=0
r=1
while r<=100:
    if r%2: #这里偶数满足条件都为False
        sum+=r
    r+=1
print('求和:',sum)

#1-100之间的偶数和
sum=0
for i in range(1,101):
    if i%2==0:
        sum+=i
print(sum)

4.for-in循环

'''
	语法:
		for 自定义的变量 in 可迭代对象:
		循环体
'''

#字符串循环遍历
for item in 'Python':
print(item)
#输出结果:
'''
P
y
t
h
o
n
'''

#range()产生的一个整数序列也是一个可迭代对象
for i in range(10):
	print(i)
    
#如果在循环体中不需要用到自定义的变量,可将自定义变量写为"_"
for _ in range(5):
    print('人生苦短')
'''
输出结果:
人生苦短
人生苦短
人生苦短
人生苦短
人生苦短
'''

#1-100之间的偶数和
sum=0
for i in range(1,101):
    if i%2==0:
        sum+=i
print(sum)

5.水仙花

#求三位数的水仙花数: 153=3*3*3+5*5*5+1*1*1

for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    #print(bai,shi,ge)
    #判断:
    if ge**3+shi**3+bai**3==item:
        print(item)

6.break

• 用于结束循环结构,通常与分支结构if一起使用

#输入三次密码,如果密码正确则通过,三次不正确就结束
for item in range(3):
    '''下面的都是条件循环体'''
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

• 和while循环搭配使用

#输入三次密码,如果密码正确则通过,三次不正确就结束
a=0
while a<3:
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1

7.continue

• 用于结束当前循环,进入下一次循环,通常与分支结构if一起使用

#使用continue,求1-50之间的5的倍数
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

8.嵌套循环

#输出一个三行四列的矩阵
for i in range(3):
    for j in range(4):
        print('*',end='\t')
    print()

#输出一个九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+'*'+str(j)+'='+str(i*j),end='\t')
    print()

#continue
for i in range(5):
    for j in range(1,11):
        if j%2==0:
            continue
        print(j,end='\t')
    print()
    
    '''
    输出结果:
    1	3	5	7	9	
    1	3	5	7	9	
    1	3	5	7	9	
    1	3	5	7	9	
    1	3	5	7	9	
    '''

五:列表

1.列表的创建

#创建列表的第一种方式
lst=['hello','world',95]

#创建列表的第二种方式,使用内置函数
lst2=list(['hello','world',95])

2.获取列表的索引

list=['hello','world',95,'hello']
print(list.index('hello')) #结果为:0  如果列表中有相同元素,会返回第一个元素的索引
#print(list.index('Python')) #如果不存在,会抛出异常:'Python' is not in list
print(list.index('hello',1,4)) #结果为:3

3.获取列表中指定元素

获取单个元素:
    正向索引从0到N-1  例如:list[0]
    逆向索引从-N到-1  例如:list[-1]

4.列表切片

list=[10,20,30,40,50,60,70,80]
list1=list[1:6:1] #[起始位置:结束位置:步长],即[start:stop:step]
#结果为:[20, 30, 40, 50, 60]
list2=list[:6:2] #默认是从0位置开始
list3=list[1::2] #默认是到结尾结束

print(list1[::-1]) #结果:逆序输出:[80, 70, 60, 50, 40, 30, 20, 10]

#即从最后一个开始,逆序排序,start为7
print(list1[7::-1])

5.遍历

list=[10,20,30,40,50,60,70,80]
for item in list:
    print(item)

6.列表增加元素

• append()
• extend()
• insert()
• 切片

list=[10,20,30]
list.append(100)
print(list) #结果:[10, 20, 30, 100]
list1=['nihao','daa']
#list.append(list1) #[10, 20, 30, 100, ['nihao', 'daa']],把list1作为一个元素添加
#list.extend(list1) #[10, 20, 30, 100, 'nihao', 'daa'] ,在list尾部扩展,在末尾一次性添加多个元素
#list.insert(1,50) #[10, 50, 20, 30, 100],在固定位置添加一个元素
list2=['在吗','false']
list[1:]=list2 #[10, '在吗', 'false'],把指定位置后全部切除,添加新的
print(list)

7.列表删除元素

• remove()
• pop()
• 切片
• clear()
• del

list=[10,20,30,40,50]
#list.remove(30) #[10, 20, 40, 50],移除一个元素,如果有重复的,移除相同的第一个元素
#list.pop(1) #[10, 30, 40, 50],根据下标移除元素
#list.pop() #[10, 20, 30, 40],如果不指定会删除最后一个元素

#切片
#new_list=list[1:3] #[20, 30],产生了一个新的对象
#list[1:3]=[] #[10, 40, 50],将切除的部分用空替代
#list.clear() #[],清楚列表
del list #删除列表
print(list)

8.列表修改

list=[10,20,30,40,50]
#list[1]=1000 #[10, 1000, 30, 40, 50],修改一个值

#修改列表当中多个值
list[1:3]=[100,200,300] #[10, 100, 200, 300, 40, 50]
print(list)

9.列表排序

list=[10,43,31,50,11]
#list.sort() #[10, 11, 31, 43, 50],默认升序排列,不产生新的列表对象

#通过指定关键字参数,是排序为降序
#list.sort(reverse=True) #[50, 43, 31, 11, 10],不产生新的列表对象

#使用内置函数sorted()排序,产生一个新的列表对象
#new_list=sorted(list) #[10, 11, 31, 43, 50]

#指定关键字降序
new_list=sorted(list,reverse=True) #[50, 43, 31, 11, 10]
print(new_list)

10.列表生成式

#list=[i for i in range(1,10)] #[1, 2, 3, 4, 5, 6, 7, 8, 9]
#list=[i*i for i in range(1,10)] #[1, 4, 9, 16, 25, 36, 49, 64, 81]

#产生2,4,6,8,10
list=[i*2 for i in range(1,6)] #[2, 4, 6, 8, 10]
print(list)

六:字典

1.字典的创建

1.使用花括号
 scores={'张三':100,'李四':60}
    
2.使用内置函数dict()
 dict(name='Jack',age=20)
    
3.空字典
d={}

2.字典元素的获取

scores={'张三':100,'李四':60}
print(scores['张三']) #如果没有则会报错
print(scores.get('张三')) #如果没有则会返回None
print(scores.get('李贺',60))#如果查找得value不存在,就会返回 后面的这个默认值

3.字典元素的增删改

scores={'张三':100,'李四':60}
#del scores['张三'] #删除指定的key-value
#scores.clear() #清除
scores['王五']=200 #新增元素
scores['王五']=300 #修改元素
print(scores)

4.获取字典视图

scores={'张三':100,'李四':60}
keys=scores.keys()
print(list(keys)) #['张三', '李四'],将所有的key组成的视图转换成列表

values=scores.values()
print(list(values)) #[100, 60]

items=scores.items()
print(list(items))#[('张三', 100), ('李四', 60)],转换后叫元组,由()构成

5.字典元素遍历

scores={'张三':100,'李四':60}
for item in scores:
    print(item,scores[item],scores.get(item))
    
'''
张三 100 100
李四 60 60
'''

scores=[{'name':"lisi",'age':50},{'name':"zhangsan",'age':60}]
for item in scores:
    print(item.get("name"),item.get("age"))
    
 '''   
lisi 50
zhangsan 60
'''

6.字典生成式

items=['Fruits','Books','Others']
price=[20,30,45]
d={ item:price for item,price in zip(items,price)  }
print(d) #{'Fruits': 20, 'Books': 30, 'Others': 45}

七:元组

• 可变序列:可以进行增删改操作,例如: 列表,字典
• 不可变序列,不可以进行增删改操作,例如: 元组,字符串

1.元组的创建方式

• 不可变,可重复,有序

1.直接小括号
t=('Python','hello',96)

2.使用内置函数tuple()
t=tuple(('Python','hello',32))

3.只包含一个元组的元素需要用逗号和小括号
t=(10,)

4.创建空元组
t=()
t=tuple()

2.元组的遍历

t=('Python','hello',96)
for item in t:
    print(item)

八:集合

• 集合是无序的
• 集合不允许有重复元素

1.集合创建

#第一种创建方式
s={1,2,1,3,3,3,4} #{1, 2, 3, 4},集合不允许有重复的数字
print(s)

#第二种创建方式set()
s1=set(range(6))
print(s1) #{0, 1, 2, 3, 4, 5},将列表转为集合

s2=set([1,2,3,4,4,5,5])
print(s2) #{1, 2, 3, 4, 5}

s3=set((1,2,3,3,4,65))
print(s3) #{{65, 1, 2, 3, 4} ,将元组转为集合,并且集合是无序的

s4=set('Python')
print(s4) #{'t', 'P', 'h', 'y', 'o', 'n'} ,将字符串转为集合

s5=set() #定义空集合

2.集合的相关操作

s={12,20,30,40}
#元素新增操作
s.add(50) #一次添加一个
s.update({20,30,60,70}) #添加至少一个,可以添加多个
s.update([60,66,22])
s.update((26,84,96))

#集合元素的删除
s.remove(20) #如果没有会抛出异常
s.discard(500) #如果删除的元素没有不会抛出异常
s.pop() #任意删除一个元素,随机的
s.clear() #清空

3.集合之间的关系

s1={10,20,30}
s2={30,20,10}
print(s1==s2) #True
print(s1!=s2) #False

#判断一个集合是否是另一个集合的子集
s1={10,20,30,40}
s2={10,20}
print(s2.issubset(s1)) #True

#判断一个集合是否是另一个集合的超子集
print(s1.issuperset(s2)) #True

#两个集合是否没有交集
print(s2.isdisjoint(s1)) #False

4.集合的操作

s1={10,20,30,40,50}
s2={10,20,60}
print(s1.intersection(s2)) #求交集{10, 20}
print(s1 & s2) # intersection()和 & 相同

#并集
print(s1.union(s2)) #{50, 20, 40, 10, 60, 30}
print(s1 | s2)#{50, 20, 40, 10, 60, 30} ,union()和 | 相同

#差集
print(s1.difference(s2)) #{40, 50, 30}
print(s1-s2) #{40, 50, 30},difference()和 - 相等

#对称差集
print(s1.symmetric_difference(s2)) #{40, 50, 60, 30}
print(s1 ^ s2) #{40, 50, 60, 30}

5.集合生成式

{i*i for i in range(1,10)}

九:字符串

1.字符串的创建和驻留机制

a='Python'
b="Python"
c='''Python''' #这三个a,b,c的id相同,指向同一个地址

2.字符串的查询操作

• index(),查找substr第一次出现的位置,如果查找的子串不存在,会抛出ValueError
• rindex(),查找substr最后一次出现的位置,如果查找的子串不存在,会抛出ValueError
• find(),查找substr第一次出现的位置,如果查找的子串不存在,则返回-1
• rfind(),查找substr最后一次出现的位置,如果查找的子串不存在,则返回-1

s='hello,hello'
print(s.index('lo')) #3
print(s.find('lo'))#3
print(s.rindex('lo')) #9
print(s.rfind('lo'))#9

3.字符串的大小写转换

s='hello,python'
a=s.upper() #转换成大写之后,会产生一个新的字符串对象
b=s.lower() #转换成小写之后,会产生一个新的字符串对象

s='hello,Python'
print(s.swapcase()) #HELLO,pYTHON,大写转小写,小写转大写

print(s.title()) #Hello,Python,把每个单词的首字母变成大写,其余小写
print(s.capitalize()) #Hello,python,把第一个字符换成大写,其余小写

4.字符串对齐操作

s='hello,Python'
'''居中对齐'''
print(s.center(20,'*')) #****hello,Python****,第一个参数指定宽度,后面表示填充

'''左对齐'''
print(s.ljust(20,'*')) #hello,Python********,左对齐
print(s.ljust(10)) #hello,Python,如果范围小,就返回原字符
print(s.ljust(20)) #hello,Python,填充符不写,用空格补充

'''右对齐'''
print(s.rjust(20,'*')) #********hello,Python
print(s.rjust(10)) #hello,Python
print(s.rjust(20)) #        hello,Python

'''右对齐'''
print(s.zfill(20)) #00000000hello,Python,只有一个参数,用0填充
print('-2531'.zfill(10)) #-000002531

5.字符串的劈分

s='hello world python'
print(s.split()) #['hello', 'world', 'python']

s1='hello|world|python'
print(s1.split(sep='|'))  #['hello', 'world', 'python'],指定'|'为分隔符
print(s1.split(sep='|',maxsplit=1)) #['hello', 'world|python'],指出最大的分段为1段

#rsplit()是从右边劈分

6.字符串的判断方法

1.isidentifier() #判断指定的字符是否是合法的标识符,字母,数字,下划线才是合法的
2.isspace() #判断指定的字符串是否由空白字符组成(回车,换行,水平制表符)
3.isalpha() #判断指定的字符是否由字母组成,汉字也算
4.isdecimal() #判断指定的字符串是否由十进制的数字组成
5.isnumeric() #判断指定的字符串是否全部由数字组成(一二三的汉字也算,罗马数字也算)
6.isalunm() #判断指定的字符串是否全部由字母和数字组成

7.替换与合并

s='hello,Python'
print(s.replace('Python','Java')) #hello,Java

s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2)) #hello,Java,Java,Python,指定替换的次数

#join连接
s2=['hello','Python','Java']
print('|'.join(s2)) #hello|Python|Java

s3=('hello','Python','Java')
print(''.join(s3)) #helloPythonJava

print('*'.join('Python')) #P*y*t*h*o*n

8.字符串的比较

print('apple'>'app')#True
print('apple'>'bananer')#False
print(ord('a'),ord('b')) #97 98,比较原理
print(chr(97),chr(98)) #a b

'''
==和is的区别
==比较的是value
is比较的是id
'''

9.字符串格式化(format)

name='张三'
age=20
# %占位
print('我叫%s,今年%d岁' % (name,age)) #我叫张三,今年20岁

#使用{}
print('我叫{0},今年{1}岁'.format(name,age)) #我叫张三,今年20岁

#f-string
print(f'我叫{name},今年{age}岁') #我叫张三,今年20岁

print('%10d' % 99) #        99,10表示宽度
print('%.3f' % 3.1415926) #3.142,保留三位小数
#同时表示宽度和精度
print('%10.3f' % 3.1415926) #     3.142

#使用{}
print('{0:.3}'.format(3.1415926)) #3.14,这里3表示共有3位数
print('{0:.3f}'.format(3.1415926)) #3.142,保留3位小数
print('{0:10.3f}'.format(3.1415926)) #     3.142,同时设置宽度和精度

10.字符串的编码与解码

s='海上生明月'
#编码
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))

#解码
byte=s.encode(encoding='UTF-8')
#byte代表一个二进制数据(字节类型的数据)
print(byte.decode(encoding='UTF-8'))

十一:函数

1.函数参数传递

def fun(arg1,arg2):
    print('arg1',arg1)
    print('arg2',arg2)
    arg1=100
    arg2.append(200)
    print('arg1',arg1)
    print('arg2',arg2)

n1=11
n2=[10,20,30]
fun(n1,n2)
print('n1',n1)
print('n2',n2)

'''
arg1 11
arg2 [10, 20, 30]
arg1 100
arg2 [10, 20, 30, 200]
n1 11
n2 [10, 20, 30, 200]

在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会影响实参的值,即arg1的值修改为100不会影响 arg1=11
如果是可变对象,在函数体的修改会影响实参的值,arg2的修改,append(200),会影响n2的值
'''

2.函数的返回值

函数的返回值:
    1.如果函数没有返回值[函数执行完毕后,不需要给调用处提供数据,],return可以省略不写
	2.函数没有返回值,如果是1个,直接返回类型
    3.函数的返回值,如果是多个,返回的结果为元组

3.函数的默认值

def fun(a,b=10)
	print(a,b)
#函数的调用
fun(100) #-->只传一个参数,b采用默认值
fun(20,30) #-->30将默认值10替代

4.函数参数定义

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

#个数可变的关键字形参,结果是一个字典
def fun1(**args): 
	print(args)
fun1(a=10)
fun1(a=10,b=20)
'''
{'a': 10}
{'a': 10, 'b': 20}
'''

#个数可变的位置参数和关键字参数可以结合,ps:必须个数可变的位置形参,放在个数可变的关键字形参之前
def fun3(*arg1,**arg2)
	pass

def fun3(**arg1,*arg2) #这样会报错
	pass


def fun4(a,b,*,c,d) #从*之后的参数,在函数调用时,只能采用关键字参数传递

5.变量作用域

def fun()
	global age #函数内部生命的变量,局部变量使用global声明,这个变量实际上就变成了全局变量
    age=20
    print(age)

6.递归函数

#计算阶乘
def fun1(n):
    if n==1:
        return 1
    else:
        return n*fun1(n-1)
print(fun1(6))

7.斐波那契数列

def fun(n):
    if n==1:
        return 1
    if n==2:
        return 1
    else:
        return fun(n-1)+fun(n-2)
print(fun(6)) #8

#输出前6位的数,用列表
for i in range(1,7):
    print(fun(i))

十二.异常处理机制

1.捕获异常

1.try-except

try:
    函数执行体
except 异常类型:
    函数执行体
    

• 捕获异常的顺序按照先子类后父类的顺序,为例避免遗漏可能出现的异常,可以在最后增加BaseException

#多个异常处理
try:
    代码
except Exception1:
    代码
except Exception2:
    代码
except BaseException:
    代码

2.try-except-else

• 如果try中没有抛出异常,则执行else,如果try抛出异常,则执行except

try:
    代码
except:
    代码
else:
    代码

3.try-except-else-finally

• finally无论是否发生异常都会被执行,能常用来释放try块中申请的资源

try:
    代码
except:
    代码
else:
    代码
finally:
    代码

2.常见的异常类

• ZeroDivisionError —>除零
• indexError —>序列中没有此索引
• KeyEoor —>映射中没有这个键
• NameError —>未声明/初始化对象(没有属性)
• SyntaxError —>Python语法错误
• ValueError —>传入无效的参数

3.traceback

• 打印错误日志

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

十三:类

1.类的创建

• 在类外定义为函数,在类内定义为方法

class Student:
    native_place='河南' #直接写在类里面的变量,称为类属性
    def __init__(self,name,age):
        self.name='张三'  #self.name称为实例属性,进行了一个赋值操作,将局部变量的name的值赋给实体属性
        self.age=20

    #实例方法:
    def info(self): #这里self指的是需要传入一个自身类型的对象
        print('我的名字是:',self.name,'年龄是:',self.age)

    #静态方法:
    @staticmethod
    def tm():
        print('------')

    #类方法
    @classmethod
    def cm(cls):
        print('------')

    

2.对象的创建

stu1=Student('张三',20)
stu1.info() #对象名.方法名
print(stu1.name)
print(stu1.age)
Student.info(stu1) #类名.方法名(类的对象),实际上是方法定义的self

3.类属性,类方法调用

• 类属性: 类中方法外的变量称为类属性,被该类的所有对象所共享
• 类方法: 使用类名直接访问方法
• 静态方法: 使用类名直接访问方法

print(Student.native_place) #访问类属性
Student.cm() #调用类方法
Student.tm() #调用静态方法

4.动态绑定属性和方法

class Student:
    def __init__(self,name,age):
        self.name='张三'  
        self.age=20
    def eat(self):
        print(self.name+'在吃饭')
stu1=Student('张三',20)
stu2=Student('李四',30)
stu2.gender='女' #只针对当前的对象
print(stu2.gender)

def show():
    print('定义在类外的函数')
stu1.show=show() #只针对当前的对象
stu1.show

5.封装

class Student:
    def __init__(self,name,age):
        self.name='张三'  
        self.__age=20 #年龄不希望在类的外部被使用,所以加了两个_
    def eat(self):
        print(self.name+'在吃饭')
        
stu1=Student('张三',20)
#print(dir(stu1)) dir()可以查看对象所有的属性
print(stu1._Student__age) #在类的外面可以通过_Student__age进行访问

6.继承

• 如果一个类没有继承任何类,默认继承object
• Python支持多继承
• 定义子类时,必须在其构造函数中调用父类的构造函数

语法格式:
    class 子类类名(父类1,父类2):
        pass

class Person(object): #默认继承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

class Teacher(Person):
    def __init__(self,name,age,year):
        super().__init__(name,age)
        self.year=year

stu=Student('张三',20,'1234')
teacher=Teacher('王老师',30,10)

stu.info()
teacher.info()

7.重写

class Person(object): #默认继承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,year):
        super().__init__(name,age)
        self.year=year
    def info(self):
        super().info() #保留,调用父方法
        print('教学时间:',self.year)#改写增加新的方法输出

stu=Student('张三',20,'1234')
teacher=Teacher('王老师',30,10)

stu.info()
teacher.info()

8.object类

class Student:
    def __init__(self,name,age):
        self.name='张三'
        self.age=20
    def __str__(self):
        return '我的名字是{0},我的年龄是{1}'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu)) # dir()可以查看对象所有的属性
print(stu) #默认调用__str__方法

9.特殊方法

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('李四')
print(stu1+stu2) #将两个对象相加,因为重新编写了__add__()方法
print(len(stu1)) #4 ,len()是求长度的

10.拷贝

变量的赋值操作:
    只是形成两个变量,实际上还是指向同一个对象
cpu1=CPU()
cpu2=cpu1  -->这两个id相同

浅拷贝:
    一般为浅拷贝,对象包含的子对象内容不拷贝,拷贝后的子对象id相同
深拷贝:
    deepcopy函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同,拷贝后的子对象id不同

#浅拷贝
import copy
computer=Computer(cpu1,disk)
computer2=copy.copy(computer)

十四:模块

1.模块导入

语法:
    import 模块名称 [as 别名] 
    例子:
        import math
    
    from 模块名称 import 函数/变量/类
    例子:
        from math import pi
        print(pi) #只导入了math里面的pi

2.主程序运行

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

#输入 main
if __name__ == '__main__':  #加入后,别的类调用时就不会显示打印输出,只有在本文件点击执行才运行输出
    print('add执行了')

3.包

注意事项:

• import导入时
  • import 包名
  • import 模块名
• from 包名 import
  • from 包名 ipmort 模块名
  • from 包名.模块名 imoprt 变量/函数等

语法:
    import 包名.模块名 [as 别名]

4.常用的内容模块

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

5.第三方模块安装和使用

安装:
    pip install 模块名
 
使用:
    import 模块名

十五:文件

1.文件读写

语法:
    file=open(filename [,mode,encoding])
    
    file-->被创建的文件对象
    open-->创建文件对象的函数
    filename-->要创建或打开的文件名称
    mode-->打开模式默认认为只读
    encoding-->默认文本文件中字符的编写格式为gbk

file=open('a.txt','r')
print(file.readlines()) #读出每行
file.close() #关闭流

2.文件打开模式

r	以只读模式打开文件,文件的指针会放在文件的开头
w	以只写模式打开文件,如果文件不存在则创建,如果存在,则会覆盖原有的内容,文件的指针会放在文件的开头
a	以追加模式打开文件,如果文件不存在则创建,文件指针在文件开头,如果文件存在,则会在末尾追加内容,文件指针在源文件末尾
b	以魏晋至方式打开文件,不能单独使用,需要与其他模式一起使用,rb,或者wb
+	以读写方式打开文件,不能单独使用,需要与其他模式一起使用,a+

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

3.with

with open('filename','rb') as 别名:  
    #with语句可以自动管理上下文资源,不论什么原因跳出with块,都能确保文件正确地关闭,以此来达到释放资源的目的

文件的复制:

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

4.os模块

• 这个模块与操作系统有关
• import os

os.getcwd()	放回当前的工作目录
os.listdir(path)	返回指定路径下的文件和目录信息
os.mkdir(path[,mode])	创建目录
os.makdirs(path1/path2….)	创建多级目录
os.rmdir(path)	删除目录
os.removedirs(path1/path2…)	删除多级目录
os.chdir(path)	将path设置为当前工作目录

5.os.path

• import os.path

os.path.abspath(path)	用于获取文件或目录的绝对路径
os.path.exists(path)	用于判断文件或目录是否存在,如果存在返回true,否则返回False
os.path.join(path,name)	将目录与目录或者文件名拼接起来
os.path.splittext()	分离文件名和扩展名
os.path.basename(path)	从一个目录中提取文件名
os.path.dirname(path)	从一个路径中提取文件路径,不包括文件名
os.path.isdir(path)	用于判断是否为路径

6.案例

1.列出指定目录下的所有.py文件

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

2.walk()

• 遍历得出根目录下所有的文件,包括子文件

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

十六:学生管理

filename='student.txt'
import os
def menum():
    print('------------------学生管理系统----------------------')
    print('\t\t\t\t\t\t1.录入学生信息')
    print('\t\t\t\t\t\t2.查找学生信息')
    print('\t\t\t\t\t\t3.删除学生信息')
    print('\t\t\t\t\t\t4.修改学生信息')
    print('\t\t\t\t\t\t5.排序学生信息')
    print('\t\t\t\t\t\t6.统计学生总人数')
    print('\t\t\t\t\t\t7.查看所有学生信息')
    print('\t\t\t\t\t\t0.退出')
def main():
    while True:
        menum()
        num=int(input('请输入相关的操作数字:'))
        if num in [0,1,2,3,4,5,6,7]:
            if num==0:
                answer=input('确定要推出吗 y/n')
                if answer=='y' or answer=='Y':
                    print('谢谢使用')
                    break
                else:
                    continue
            elif num==1:
                insert()
            elif num==2:
                find()
            elif num==3:
                delete()
            elif num==4:
                modify()
            elif num==5:
                sort()
            elif num==6:
                total()
            elif num==7:
                showStudent()

def insert():
    studentList=[]
    while True:
        id=input('请输入学生id:')
        if not id:
            break
        name=input('请输入名字:')
        if not name:
            break
        try:
            englishScore=int(input('请输入英语成绩:'))
            pythonScore=int(input('请输入python成绩:'))
            javaScore=int(input('请输入java成绩:'))
        except:
            print('输入的成绩不是整数类型,请从新输入')
            continue
        #将录入的成绩加入文件
        student={'id':id,'name':name,'englishScore':englishScore,'pythonScore':pythonScore,'javaScore':javaScore}
        studentList.append(student)
        answer=input('是否继续写入y/n')
        if answer=='y':
            continue
        else:
            break
    save(studentList)
    print('学生信息录入完毕')
def find():
    studentQuery=[]
    while True:
        id1=''
        name1=''
        if os.path.exists(filename):
            num=input('按照id查找输入1,按照name查找输入2')
            if num=='1':
                id1=input('请输入要查找的id:')
            elif num=='2':
                name1=input('请输入要查找的名字:')
        else:
            print('查询有误')
            find()
        with open(filename,'r',encoding='UTF-8') as file:
            studentList=file.readlines()
            for item in studentList:
                d=dict(eval(item))
                if id1!='':
                    if id1==d['id']:
                        studentQuery.append(d)
                elif name1!='':
                    if name1==d['name']:
                        studentQuery.append(d)
        #显示结果
        show_student(studentQuery)
        #清空
        studentQuery.clear()
        answer=input('是否继续查询 y/n:')
        if answer=='y':
            continue
        else:
            break

def show_student(list):
    if len(list)==0:
        print('没有查到数据')
        return
    #定义显示的格式
    format_title='{:^6}\t{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^8}'
    print(format_title.format('ID','姓名','英语成绩','python成绩','java成绩','总成绩'))
    #定义现实的内容
    format_data='{:^6}\t{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^8}'
    for item in list:
        print(format_data.format(item.get('id'),
                                 item.get('name'),
                                 item.get('englishScore'),
                                 item.get('pythonScore'),
                                 item.get('javaScore'),
                                 int(item.get('englishScore'))+int(item.get('pythonScore'))+int(item.get('javaScore'))
                                 ))
def save(list):
    try:
        student_txt=open(filename,'a',encoding='UTF-8') #有就追加
    except:
        student_txt=open(filename,'w',encoding='UTF-8') #没有就创建
    for item in list:
        student_txt.write(str(item)+'\n')
    student_txt.close()

def delete():
    while True:
        student_id=input('请输入你要删除的学生id:')
        if student_id!='':
            if os.path.exists(filename):
                with open(filename,'r',encoding='UTF-8') as rfile:
                    student_list=rfile.readlines()
            else:
                student_list=[]
            flag=False
            if student_list:
                with open(filename,'w',encoding='UTF-8') as wfile:
                    d={}
                    for item in student_list:
                        d=dict(eval(item)) #将字符串转为字典
                        if d['id']!=student_id:
                            wfile.write(str(d)+'\n')
                        else:
                            flag=True
                    if flag:
                        print(f'id为{student_id}的学生已经被删除')
                    else:
                        print(f'没有这个找到学号为{student_id}的学生')
            else:
                print('没有学生信息')
                break
            showStudent() #删除学生后重新显示
            answer=input('是否继续删除:y/n:')
            if answer=='y':
                continue
            else:
                break



def modify():
    showStudent()
    if os.path.exists(filename):
        with open(filename,'r',encoding='UTF-8') as file:
            studtent_list=file.readlines()
    else:
        return
    sid=input('请输入修改学生的id:')
    with open(filename,'w',encoding='UTF-8') as wfile:
        for item in studtent_list:
            d=dict(eval(item)) #将字符串转为字典
            if d['id']==sid:
                print('可以修改学生的信息')
                while True:
                    try:
                        d['name']=input('请输入修改后的名字')
                        d['englishScore']=int(input('请输入英语成绩'))
                        d['pythonScore']=int(input('请输入python成绩'))
                        d['javaScore']=int(input('请输入java成绩'))
                    except:
                        print('输入的成绩有误')
                    else:
                        break
                wfile.write(str(d)+'\n')
                print('修改成功')
            else:
                wfile.write(str(d)+'\n')
        answer=input('是否继续修改y/n:')
        if answer=='y':
            modify()

def sort():
    showStudent()
    if os.path.exists(filename):
        with open(filename,'r',encoding='utf-8') as file:
            studentList=file.readlines()
        student_new=[]
        for item in studentList:
            d=dict(eval(item))
            student_new.append(d)
    else:
        return
    order_asc=input('升序请输入0,降序请输入1')
    if order_asc=='0':
        order_asc_bool=False
    elif order_asc=='1':
        order_asc_bool=True
    else:
        print('输入有误,请重新输入')
        sort()
    mode=input('请输入要进行的排序方式(1.按照英语成绩 2.按照python成绩 3.按照java成绩 0.按照总成绩)')
    if mode=='1':
        student_new.sort(key=lambda x: int(x['englishScore']),reverse=order_asc_bool)
    elif mode=='2':
        student_new.sort(key=lambda x: int(x['pythonScore']),reverse=order_asc_bool)
    elif mode=='3':
        student_new.sort(key=lambda x: int(x['javaScore']),reverse=order_asc_bool)
    elif mode=='0':
        student_new.sort(key=lambda x: int(x['englishScore'])+int(x['pythonScore'])+int(x['javaScore']),reverse=order_asc_bool)
    else:
        print('您输入的有误,请重新输入')
        sort()
    show_student(student_new)
def total():
    if os.path.exists(filename):
        with open(filename,'r',encoding='UTF-8') as file:
            studentList= file.readlines()
            if studentList:
                print(f'共录入的学生人数是{studentList.__len__()}')
            else:
                print('没有数据')
    else:
        print('没有保存数据')

def showStudent():
    student_list=[]
    if os.path.exists(filename):
        with open(filename,'r',encoding='utf-8') as file:
            student=file.readlines()
            for item in student:

                student_list.append(eval(item))
            if student_list:
                show_student(student_list)
if __name__ == '__main__':
    main()

十七:正则表达式

操作符	说明
.	表示任何单个字符
[ ]	字符集,对单个字符给出取值范围	[abc]表示a,b,c, [a-z]表示a到z单个字符
[^]	非字符集,对单个字符给出排除范围	[^abc]表示非a或b或c的单个字符
*	前一个字符0次或无限次扩展	abc* 表示ab,abc,abcc,abccc等
+	前一个字符1次或无限次扩展	abc+ 表示abc,abcc,abccc等
?	前一个字符0次或1以扩展	abc? 表示ab,abc
|	左右表达式任意一个	abc|def 表示abc ,def
{m]	扩展前一个字符m次	ab{2]c 表示 abbc
{m,n}	扩展前一个字符m至n次,(含n)	ab{1,2}c 表示 abc, abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串的结尾
( )	分组标记,内部只能使用 | 操作符	(abc) 表示abc,(abc|def)表示abc,def
\d	数字,等价于[0-9]
\w	单词字符,等价于[A-Za-z0-9_]

十八:补充re

#建议在正则表达式中,被比较的字符串前面加上r,不用担心转义字符的问题
a=r"\aads-\"
print(a)

#sub替换
print(re.sub("a","A","abcdsaasd")) #找到a用A替换,在第三个字符串中查找"A"

m=re.search("asd","Aasd") #前面的字符串是规则,后面的字符串是被校验的对象

print(re.findall("[A-Z]","ASDsDSFA")) #['A', 'S', 'D', 'D', 'S', 'F', 'A'],查询单个
print(re.findall("[A-Z]+","ASDsDSFA")) #['ASD', 'DSFA'],匹配多个

赏

谢谢你请我吃糖果

支付宝

微信