Python语法随笔
Python语法随笔
- 第一次测试代码 - 语法差异
- 牛客习题基础语法掌握
- 语法进阶
第一次测试代码 - 语法差异
Python 是一种高级的、通用的解释型编程语言。它被广泛用于各种领域，使用时最主要的就是注意缩进。
print("不换行",end="")
print("666")
d=a=c=101
c=",k"+",."
print(type(d))
if d==101:
print("456")
elif d==1:
print(a)
else:
print(c)
k=0
i=0;
while True:
if i==9:
break;
print(i)
i+=1 #这里值得注意的是,i++是不存在的
多行注释
"""
这是个
多行注释
"""
multiline = """
这是个多行
字符串
"""
multiline = '''
多行
字符串
'''
print(multiline)
test=input("权")
print(test)
name='aabbcc'
age=20
str='我叫{}，我今年{}岁'
print(str.format(name,age))
for a in [1,10]:
print(a)
for i in range(1, 10): #这里值得注意的是,要使用range()函数
print(i)
三目运算符
c=a if a>b else b
a=1
b=2
c=a if a>b else b
print(c)
随机数
import random
x=random.randint(1,20)
print(x)
除法
/表示带小数除法
//：表示整除
次幂：2的8次幂表示：2**8
赋值运算，可以多个赋值，a=b=c=1; a,b,c,d=1,2,3,“aadd” ; 数据直接交换：x,y=y,x 可实现
逻辑运算：and 、or、not，表示与、或、非
in、not in表示在这个序列内就返回true，如果不是就返回false
s=input()
a=float(s)
print("%.2f"%a)
a=input()
s=int(a,16)
print(s)
s=list(input()).append('Allen')
print(s)
列表删除
s=input().split()
del s[0]
print(s)
牛客习题基础语法掌握
输出
创建一个依次包含字符串’P’、‘y’、‘t’、‘h’、'o’和’n’的列表my_list，先使用sorted函数对列表my_list进行临时排序，第一行输出排序后的完整列表，第二行输出原始的列表。再使用sort函数对列表my_list进行降序排序，第三行输出排序后完整的列表。
s=['P','y','t','h','o','n']
a=sorted(s)
print(a)
print(s)
a.reverse()
print(a)
解密码
每位数字都要加上3再除以9的余数代替该位数字，然后将第1位和第3位数字交换，第2位和第4位数字交换。请输出牛妹破解后的密码。
s=list(input())
for i in range(0,4):
s[i]=(int(s[i])+3)%9
s[0],s[1],s[2],s[3]=s[2],s[3],s[0],s[1]
print(s)
栈
stack = [1, 2, 3, 4, 5]，请将其视作栈，使用pop函数弹出末尾两个元素，再使用append函数将输入元素加入到栈中，每次操作完成后都要输出整个列表。
stack = [1, 2, 3, 4, 5]
stack.pop()
print(stack)
stack.pop()
print(stack)
stack.append(int(input()))
print(stack)
队列
queue = [1, 2, 3, 4, 5] 被视作队列，请使用pop函数连续两次取出队首元素，再使用append函数将输入元素添加到队尾，每次操作后都要输出完整的列表。
queue = [1, 2, 3, 4, 5]
del queue[0]
print(queue)
del queue[0]
print(queue)
queue.append(int(input()))
print(queue)
使用print()语句和切片
来打印列表group_list的前两个元素表示去做第一个任务的人的名字，再使用print()语句和切片来打印列表group_list的中间三个元素表示去做第二个任务的人的名字，再使用print()语句和切片来打印列表group_list的后两个元素表示去做第三个任务的人的名字。
l=['Tom', 'Allen', 'Jane', 'William', 'Tony' ]
print(l[0:2])
print(l[1:4])
print(l[3:5])
第一行输出x除以y的商和余数；第二行输出x除以y的非整除结果，保留两位小数。
a=int(input())
b=int(input())
print("%d %d"%(a//b,a%b))
print("%0.2f"%(a/b))
与，或，非
输出x与y，x或y，非x，非y的值，前两个为数值，后两个为布尔值
方法1
a=input().split()
print(int(a[0]) and int(a[1]))
print(int(a[0]) or int(a[1]))
print(not int(a[0]))
print(not int(a[1]))
方法 2
x,y=map(int,input().split())
print(x and y)
print(x or y)
print(not x)
print(not y)
Python的位运算
是直接将数字看成二进制，直接对二进制数字的每一位进行运算。现输入两个十进制整数x、y，请计算它们的位与、位或，输出按照十进制的形式。
第一行输出x位与y；
第二行输出x位或y
x,y=map(int,input().split())
print(x & y)
print(x | y)
列表
创建一个依次包含字符串
‘Niuniu’、‘Niumei’、‘GURR’和’LOLO’的列表current_users，再创建一个依次包含字符串’GurR’、‘Niu Ke Le’、'LoLo’和’Tuo Rui Chi’的列表new_users，使用for循环遍历new_users，如果遍历到的新用户名在current_users中，则使用print()语句一行输出类似字符串’The user name GurR has already been registered! Please change it and try again!'的语句，否则使用print()语句一行输出类似字符串’Congratulations, the user name Niu Ke Le is available!'的语句。（注：用户名的比较不区分大小写）
current_users=['Niuniu','Niumei','GURR','LOLO']
new_users=['GurR','Niu Ke Le','LoLo','Tuo Rui Chi']
for i in range(0,len(current_users)):
current_users[i]=current_users[i].upper()
for i in range(0,len(new_users)):
if new_users[i].upper() in current_users:
print('The user name %s has already been registered! Please change it and try again!'%new_users[i])
else:
print('Congratulations, the user name %s is available!'%new_users[i])
计算平均绩点
牛牛在门头沟大学学习，一学年过去了，需要根据他的成绩计算他的平均绩点，假如绩点与等级的对应关系如下表所示。请根据输入的等级和学分数，计算牛牛的均绩（每门课学分乘上单门课绩点，求和后对学分求均值）。
A 4.0
B 3.0
C 2.0
D 1.0
F 0
方法1
socre = 0
xy=0
while True:
g = input()
if g == "A":
x=float(input())
A = 4.0
elif g == "B":
x=float(input())
A = 3.0
elif g == "C":
x=float(input())
A = 2.0
elif g == "D":
x=float(input())
A = 1.0
elif g=='F':
x=float(input())
A = 0.0
elif g == "False":
break
socre=socre+A*x
xy=xy+x
print('%0.2f'%((socre)/xy))
方法2 字典
ji_dict={'A':4.0,'B':3.0,'C':2.0,'D':1.0,'F':0}#绩点存放的字典
s_dict={'A':0,'B':0,'C':0,'D':0,'F':0}#绩点对应的人数，初始值0
ji_sum,sum=0,0#前者为绩点和，后者为人数和
while True:
a=input()
if a=='False':
break
s=int(input())
s_dict[a] +=s
#两字典的相同的键的值乘积求和
for s_keys in s_dict.keys():
sum += s_dict[s_keys]
ji_sum += s_dict[s_keys]*ji_dict[s_keys]
print("{:.2f}".format(ji_sum/sum))
遍历列表
牛牛有一个列表，记录了他和同事们的年龄，你能用for循环遍历链表的每一个元素，将其累加求得他们年龄的总和与平均数吗？
方法1
list=input().split()
s=0
for i in range(0,len(list)):
s=int(s)+int(list[i])
print(f'{s} {s/len(list)}')
方法2
list=input().split()
s=0
for i in range(0,len(list)):
s=int(s)+int(list[i])
print('%s %.1f'%(s,s/len(list)))
循环时初始化列表跳跃
通过给函数 range()指定第三个参数来创建一个列表my_list，
其中包含 [0, 19] 中的所有偶数；
再使用一个 for 循环将这些数字都打印出来（每个数字独占一行）。
"""
for i in range(m, n, s)
参数m,n为左右边界，s为步长
"""
list=[]
for i in range(0,19,2):
list.append(i)
for i in range(0,len(list)):
print(list[i])
被5整除的数字
创建一个列表my_list，其中包括 [1, 50] 内全部能被5整除的数字；
再使用一个 for 循环将这个列表中的数字都打印出来（每个数字独占一行）。
方法1
list=[]
for i in range(0,51,5):
list.append(i)
for i in range(1,len(list)):
print(list[i])
方法2
my_list = [i for i in range(1, 51) if i % 5 == 0]
for i in my_list:
print(i)
二维列表
现有一个矩阵
[1 2 3]
[4 5 6]
[7 8 9]
，请使用list记录该矩阵，对于牛牛输入的数字n，输出n个该矩阵相加的结果
输入：2
输出：[[2, 4, 6], [8, 10, 12], [14, 16, 18]]
方法1
list=[[1,2,3],[4,5,6],[7,8,9]]
s=int(input())
for i in list:
for j in range(0,3):
i[j]=i[j]*s
print(list)
方法2
list=[[1,2,3],[4,5,6],[7,8,9]]
s=int(input())
for i in range(len(list)):
for j in range(len(list[i])):
list[i][j]=list[i][j]*s
print(list)
元组
使用元组（tuple）进行记录。
先输入两个人的名字，
请输出他们报名成功以后的元组。
"""
可以将列表转换成tuple，也可以直接()创建tuple，或者将多个变量赋值给一个值会自动转换成tuple
"""
print(tuple([input(),input()]))
print((input(),input()))
tuple = input(),input()
print(tuple)
#可以将列表转换成tuple，也可以直接()创建tuple，或者将多个变量赋值给一个值会自动转换成tuple
元组操作
创建一个依次包含字符串’Niuniu’和’Niumei’的元组entry_form，并直接输出整个元组。
然后尝试使用try- except代码块执行语句：entry-form[1] = ‘Niukele’，
若是引发TypeError错误，请输出’The entry form cannot be modified!'。
tuple=tuple(['Niuniu','Niumei'])
print(tuple)
try:
tuple[1]= 'Niukele'
except TypeError as e:
print('The entry form cannot be modified!')
编辑元组
[‘Tom’, ‘Tony’, ‘Allen’, ‘Cydin’, ‘Lucy’, ‘Anna’]，
请将它们创建为不可被修改的Python元组后，输出整个元组。
对于牛牛输入的名字name，请使用成员运算检验它是否出现在这份秘密名单中，
若是在名单中则输出’Congratulations!‘，否则输出’What a pity!’
方法1
tuple=tuple(['Tom', 'Tony', 'Allen', 'Cydin', 'Lucy', 'Anna'])
print(tuple)
if(tuple.count(input())):
print('Congratulations!')
else:
print('What a pity!')
方法2
tuple=tuple(['Tom', 'Tony', 'Allen', 'Cydin', 'Lucy', 'Anna'])
print(tuple)
if(input() in tuple):
print('Congratulations!')
else:
print('What a pity!')
牛牛的元组
牛牛有一个元组，其中记录数字1-5，请创建该元组，并使用len函数获取该元组的长度。
牛牛觉得这个元组太短了，想要在该元组后再连接一个6-10的元祖，请输出连接后的元组及长度。
第一行输出整体的原始元组。（带括号输出）
第二行输出原始元组的长度。
第三行输出连接后的整体元组。（带括号输出）
第四行输出连接后的元组长度。
tuple1=1,2,3,4,5
print(tuple1)
print(len(tuple1))
tuple2 = tuple(range(6,11))
tuple3 =tuple1 + tuple2
print(tuple3)
print(len(tuple3))
字典操作
创建一个依次包含键-值对’<‘: ‘less than’和’==’: ‘equal’的字典operators_dict，
先使用print()语句一行打印字符串’Here is the original dict:’，
再使用for循环遍历 已使用sorted()函数按升序进行临时排序的包含字典operators_dict的所有键的列表，使用print()语句一行输出类似字符串’Operator < means less than.‘的语句；
对字典operators_dict增加键-值对’>': ‘greater than’后，
输出一个换行，再使用print()语句一行打印字符串’The dict was changed to:’，
再次使用for循环遍历 已使用sorted()函数按升序进行临时排序的包含字典operators_dict的所有键的列表，
使用print()语句一行输出类似字符串’Operator < means less than.'的语句，确认字典operators_dict确实新增了一对键-值对。
dict={'<': 'less than','==': 'equal'}
print('Here is the original dict:')
for i in sorted(dict):
print(f'Operator {i} means {dict[i]}.')
print(' ')
dict['>']= 'greater than'
print('The dict was changed to:')
for i in sorted(dict):
print(f'Operator {i} means {dict[i]}.')
创建遍历字典
创建一个依次包含键-值对{‘name’: ‘Niuniu’和’Student ID’: 1}的字典my_dict_1，
创建一个依次包含键-值对{‘name’: ‘Niumei’和’Student ID’: 2}的字典my_dict_2，
创建一个依次包含键-值对{‘name’: ‘Niu Ke Le’和’Student ID’: 3}的字典my_dict_3，
创建一个空列表dict_list，使用append()方法依次将字典my_dict_1、my_dict_2和my_dict_3添加到dict_list里，
使用for循环遍历dict_list，对于遍历到的字典，使用print()语句一行输出类似字符串"Niuniu’s student id is 1."的语句以打印对应字典中的内容。
dict1={'name': 'Niuniu','Student ID': 1}
dict2={'name': 'Niumei','Student ID': 2}
dict3={'name': 'Niu Ke Le','Student ID': 3}
list=[]
list.append(dict1)
list.append(dict2)
list.append(dict3)
for i in list:
print(f"{i['name']}'s student id is {i['Student ID']}.")
字典遍历
创建一个依次包含键-值对’Beijing’: {Capital: ‘China’}、‘Moscow’: {Capital: ‘Russia’}和’Paris’: {Capital: ‘France’}的字典cities_dict，
请使用for循环遍历"已使用sorted()函数按升序进行临时排序的包含字典cities_dict的所有键的列表"，
对于每一个遍历到的城市名，使用print()语句一行输出类似字符串’Beijing is the capital of China!'的语句。
dict={'Beijing': {'Capital': 'China'},'Moscow': {'Capital': 'Russia'},'Paris': {'Capital': 'France'}}
for i in sorted(dict.keys()):
print(f"{i} is the capital of {dict[i]['Capital']}!")
对应的字典内容
Allen’: [‘red’, ‘blue’, ‘yellow’]、‘Tom’: [‘green’, ‘white’, ‘blue’]和’Andy’: [‘black’, ‘pink’]的字典result_dict，作为已记录的调查结果。
现在驼瑞驰想查看字典result_dict的内容，你能帮帮他吗？
使用for循环遍历"使用sorted()函数按升序进行临时排序的包含字典result_dict的所有键的列表"，
对于每一个遍历到的名字，先使用print()语句一行输出类似字符串"Allen’s favorite colors are:"的语句，然后再使用for循环遍历该名字在字典result_dict中对应的列表，依次输出该列表中的颜色
dict = {
"Allen": ["red", "blue", "yellow"],
"Tom": ["green", "white", "blue"],
"Andy": ["black", "pink"],
}
for i in sorted(dict.keys()):
print(f"{i}'s favorite colors are:")
for j in dict.get(i):
print(j)
方法2
dict = {
"Allen": ["red", "blue", "yellow"],
"Tom": ["green", "white", "blue"],
"Andy": ["black", "pink"],
}
for i in sorted(dict.keys()):
print(f"{i}'s favorite colors are:")
print(dict[i][0])
print(dict[i][1])
try:print(dict[i][2])
except:continue
封装字典
牛牛有两份列表，一份记录了牛客网用户的名字，另一份记录他们使用的语言。
假设两份列表一一对应，请使用zip函数将两份列表封装为字典，
以名字为key，语言为value，然后直接输出字典。
输入：Niuniu NIumei Niukele
C C++ Python
输出：{‘Niuniu’: ‘C’, ‘NIumei’: ‘C++’, ‘Niukele’: ‘Python’}
"""zip () 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表.得到列表，将列表转化为字典"""
key=input().split()
value=input().split()
dict=dict(zip(key,value))
print(dict)
字典添加
正在学习英语的牛妹创建了一个字典：
{‘a’: [‘apple’, ‘abandon’, ‘ant’], ‘b’: [‘banana’, ‘bee’, ‘become’],
‘c’: [‘cat’, ‘come’], ‘d’: ‘down’}。现牛妹新学了一个字母letter，以及一个新单词word，请把它们增加到字典中，再输出更新后的字典
dict={'a': ['apple', 'abandon', 'ant'], 'b': ['banana', 'bee', 'become'], 'c': ['cat', 'come'], 'd':'down'}
key=input()
dict[key]=input()
print(dict)
字典记录
Python的字典可以用来计数，让要被计数的元素作为key值，
它出现的频次作为value值，只要在遇到key值后更新它对应的value即可。
现输入一个单词，使用字典统计该单词中各个字母出现的频次。
dict={}
s=input()
for i in s:
if i in dict:
dict[i]+=1
else:
dict[i]=1
print(dict)
数学函数
使用max和min函数快速的找到这些数字的最值
输入：3 5 6 9 10 6 2
输出：10 2
s=[int(i)for i in input().split()]
print(max(s))
print(min(s))
输入初始化列表
输入一串年龄序列，请将其转换成列表，并使用sum函数直接获取列表的和。
list=[int(i)for i in input().split()]
print(sum(list))
绝对值
牛牛想要这样一个程序，只要是输入一个整数，不管正负，它一定转换为正数，即获取该数字的绝对值，你能用abs函数实现吗？
print(abs(int(input())))
ASCII码表转换
牛牛刚学习了ASCII码，他知道计算机中的字母很多用的都是这个编码方式，
现在输入一个字母，你能使用ord函数将其转换为ASCII码对应的数字吗？
print(ord(input()))
进制转换
牛妹刚学习进制转换，对这方面掌控还不太熟练，
她想请你帮她写一个十进制到十六进制的进制转换器，
你能使用hex函数帮助她完成这个任务吗？
result = bin(int(input())) #十进制转二进制
result = oct(int(input())) #十进制转八进制
result = hex(int(input())) #十进制转十六进制
print(result)
幂运算
在Python中，除了使用两个乘号相连外，还能使用pow函数表示幂运算。
现牛牛输入正整数x与y，请你使用两种方法分别计算xy与yx。
x,y=map(int,input().split())
print(pow(x,y))
print(pow(y,x))
count计数
在牛客网内部使用1标记正确回答的题，使用0表示回答错误的题。牛牛拿到自己的作答记录是一串01序列，
他想知道自己一共答错了多少次，你能将这串序列转换为列表，使用count函数帮助牛牛统计一下吗
list=input().split()
print(list.count('0'))
集合index查询
牛客网有一个打卡系统，记录了每个人这一个星期上班打卡的记录（以名字的形式）。
牛牛想知道自己在这一个星期是第几个打卡的人，你用将这份名字记录转换为列表，然后使用index函数找到’NiuNiu’的位置吗？
list=input().split()
print(list.index('NiuNiu'))
判断字符
Python有内置函数isalpha、isdigit、isspace可以分别判断字符串是否只包含字母、
数字、空格，现在输入一个字符串，请分别输出这三个函数的判断结果。
str=input()
print(str.isalpha())
print(str.isdigit())
print(str.isspace())
find函数
牛客网公布中奖信息了，中奖信息是一个很长的字符串，牛牛想知道自己的名字（‘NiuNiu’）
有没有出现在其中，你能帮助他使用字符串的find函数查找一下吗
字符串序列.find(字串，开始位置下标，结束位置的下标)
# 这里可以省略开始和结束的位置的下标，
str=input()
print(str.find('NiuNiu'))
# 查找字符串里面的字符
# find 查找字符在字符串的索引下标，未查到时，返回 -1
# index 查找字符在字符串的索引下标，未查到时，报错——ValueError
count字符计数
牛客网喜欢’Niu’这个词，各个地方的称号、标语都会出现。
现在给你一定长字符串patten，你能使用count函数找到’Niu’在其中出现的次数吗？
str=input()
print(str.count('Niu'))
列表切割
英文句子都是由单词之间通过空格间隔而组成，牛牛想知道一句英语句子里面包含有哪些单词，
你能使用split函数将它们全部按照空格分割，记录进列表中吗，请输出列表。
print(input().split())
join函数
牛牛在和牛妹做一个游戏，牛牛给定了牛妹一些单词字符串，
他想让牛妹把这些单词拼接成以空格间隔开的句子，很可惜牛妹Python没有学好，你能使用join函数帮帮她吗```
q=''
while True:
s=input()
if s=='0':
break
elif q==' ':
q=s
else:
q+=''.join(s)+' '
print(q)
方法2
b=[]
while True:
a=input("")
if a =='0':
break
else:
b.append(a)
c=' '.join(b)
print(c)
join()函数
语法： ‘sep’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
# Python program to demonstrate the
# use of join function to join list
# elements with a character.
list1 = ['1','2','3','4']
s = "-"
# joins elements of list1 by '-'
# and stores in sting s
s = s.join(list1)
# join use to join a list of
# strings to a separator s
print(s)
#输出1-2-3-4
list1 = ['g','e','e','k', 's']
print("".join(list1))
#输出geeks
replace函数
字符串序列.replace(旧字符，新字符，替换次数)
替换次数可以不写，不写表示全部替换；如果替换次数>字串出现次数，表示全部替换，但是不会报错
题目1
牛客网在录入用户名字信息发生了错误，所有的字符子串’ab’都被录成’a*'，运营同学急坏了。
你能使用Python字符串的replace函数，将名字信息中的’a*'全部修改回’ab’吗？
str=input()
print(str.replace('*','b'))
范围函数
round(number,digits)
| number | digits |
|---|---|
| digits>0 | 四舍五入到指定的小数位 |
| digits=0 | 四舍五入到最接近的整数 |
| digits<0 | 在小数点左侧进行四舍五入 |
| 如果round()函数 | 只有number这个参数，等同于digits=0 |
题目
牛客网的财务同学很苦恼，各个部门提交的资料中关于金额的小数保留简直是乱七八糟，你能使用round函数，
帮助财务同学将输入数字的小数位修正为四舍五入保留至最多两位小数吗？（请不要使用字符串格式化输出保留小数位）
f=float(input())
print(round(f,2))
计算公式函数
牛牛听说Python中有一个很神奇的函数eval()，只要输入的字符串是一个公式，它能够直接计算这个公式的值。
现牛牛以字符串地形式输入一个公式，请你使用eval()计算结果。
str=input()#eval(<字符串>) 能够以Python表达式的方式解析并执行字符串，并将返回结果输出
print(eval(str))#eval函数的作用是将输入的字符串转为Python语句，并执行该语句
集合和列表转换
python中，set转list的非常的简单，直接将set的值放入list()的括号中即可，相反，list转set也同样如此。
题目
某公司内部报名年会活动，因为是匿名报名，有的同事可能偷偷“帮助”别人报名了，导致一个名字出现多次。
后台营运同学希望你能用set函数将这些名字记录为一个集合，以到达去重的目的，请输出这些名字创建的集合，
输出的时候使用sorted函数对集合排序。
l=set(input().split())
print(sorted(list(l)))#sorted(l)也ok
cal函数
请定义一个函数cal()，该函数返回两个参数相减的差。
输入第一个数字记录在变量x中，输入第二个数字记录在变量y中，
将其转换成数字后调用函数计算cal(x, y)，再交换位置计算cal(y, x)。
def call(a,b):
return a-b
a=int(input())
b=int(input())
print(call(a,b))
print(call(b,a))
递归
兔子的数量以这样的方式增长：每个月的兔子数量等于它前一个月的兔子数量加它前两个月的兔子数量，即f(n)=f(n-1)+f(n-2)。
假设第1个月的兔子有2只，第2个月的兔子有3只，你能使用递归的方法求得第n个月的兔子有多少只吗？
def solve(s):
if s>=3:
return solve(s-1)+solve(s-2)
elif s==1:
return 2
else :
return 3
s=int(input())
print(solve(s))
函数
球的表面积公式为V=4\pi r^2V=4π(r**2),请写一个函数，输入球的半径，返回球的表面积。
球的半径如下：[1, 2, 4, 9, 10, 13]，请输出这些半径下的表面积，π取math库的math.pi。
import math
def V(r):
return 4*(math.pi)*r*r
r=[1, 2, 4, 9, 10, 13]
for i in r:
print('%0.2f'%V(i))
面向对象-牛客
题目
Python老师为了更好地管理班级，利用一个类Student来管理学生，这个类包含了学生姓名（str）、
学号（str）、分数（int）、每次作业等级（list[str]）等信息。请你帮助牛牛的老师实现这样一个类，
并定义构造方法实现初始化，定义打印函数实现打印学生的姓名、学号、分数、提交作业的次数、每次作业的等级。
# class Circle(object): #创建Circle类，Circle为类名
# pass #此处可添加属性和方法
# 在定义 Circle 类时，可以为 Circle 类添加一个特殊的 __init__() 方法，当创建实例时，__init__() 方法被自动调用为创建的实例增加实例属性。
# class Circle(object): #创建Circle类
# def __init__(self, r): #初始化一个属性r（不要忘记self参数，他是类下面所有方法必须的参数）
# self.r = r #表示给我们将要创建的实例赋予属性r赋值
# 注意：__init__() 方法的第一个参数必须是 self（self代表类的实例，可以用别的名字，但建议使用约定成俗的self），后续参数则可以自由指定，
# 和定义函数没有任何区别。
# circle1 = Circle(1) #创建实例时直接给定实例属性，self不算在内
# circle2 = Circle(2)
# print(circle1.r) #实例名.属性名 访问属性
# print(circle2.r) #我们调用实例属性的名称就统一了
# 注意：实例名.属性名 circle1.r 访问属性，是我们上面Circle类__init__() 方法中 self.r 的 r 这个实例属性名，
# 而不是__init__(self, r)方法中的 r 参数名，如下更加容易理解：
# class Circle(object): #创建Circle类
# def __init__(self, R): #约定成俗这里应该使用r，它与self.r中的r同名
# self.r = R
# circle1 = Circle(1)
# print(circle1.r) #我们访问的是小写r
# 面试喜欢问的问题：创建类时，类方法中的self是什么？
# self 代表类的实例，是通过类创建的实例 (注意，在定义类时这个实例我们还没有创建，它表示的我们使用类时创建的那个实例)
# 实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。实例属性访问优先级比类属性高，所以我们访问时优先访问实例属性，
# 它将屏蔽掉对类属性的访问。
class Student(object):
def __init__(self,name,number,score,grade):
self.name=name
self.number=number
self.score=score
self.grade=grade
def info(self):
return f"{self.name}'s student number is {self.number}, and his grade is {self.score}. He submitted {len(self.grade.split())} assignments, each with a grade of {self.grade}"
name=input()
number=input()
score=input()
grade=input()
student=Student(name,number,score,grade)
print(student.info())
题目2
请为牛客网的员工创建一个Employee类，包括属性有姓名（name）、（salary），并设置初始化。同时该类包括一个方法printclass，
用于输出类似’NiuNiu‘s salary is 4000, and his age is 22’的语句。
请根据输入的name与salary为该类创建实例e，并调用printclass方法输出信息，如果没有年龄信息则输出错误信息"Error! No age"。
根据输入的年龄为实例e直接添加属性age等于输入值，再次调用printclass方法输出信息。（printclass方法中建议使用try…except…结构）
class Employee(object): #创建类！定义类名为Employee
def __init__(self, name, salary): #创建__init__方法，定义属性
self.name = name #实例的属性1
self.salary = salary ##实例的属性2
def printclass(self): #定义方法
try:
print(f"{self.name}'salary is {self.salary}, and his age is {self.age}")
except:
print("Error! No age")
#使用(try a:except b)语句：
#若a语句错误则执行b语句，即a中无年龄信息则输出错误信息"Error! No age"
#若a语句正确则不执行b语句，即直接输出类似‘**'salary is **, and his age is **’信息。
name = input() #输入name字符
salary = input() #输入salary整数
e = Employee(name, salary)#创建类的实例e
e.printclass() #调用printclass方法,输出信息
e.age = input() #直接给实例emp加属性(整数age)
e.printclass() #调用printclass方法,输出信息
题目3
请为牛客网的员工创建一个Employee类，包括属性有姓名（name）、（salary），并设置初始化。
同时该类包括一个方法printclass，用于输出类似’NiuNiu‘s salary is 4000, and his age is 22’的语句。
请根据输入的信息为Employee类创建一个实例e，调用hasattr方法检验实例有没有属性age，
如果存在属性age直接调用printclass输出，否则使用setattr函数为其添加属性age，
并设置值为输入后，再调用printclass输出。
class Employee(object):
def __init__(self,name,salary):
self.salary=salary
self.name=name
def printclass(self):
print(f"{self.name}'salary is {self.salary}, and his age is {self.age}")
name=input()
salary=input()
age=input()
e=Employee(name,salary)
if hasattr(e,'age') is False:
print(hasattr(e,'age'))
setattr(e,"age",age)
e.printclass()
else:
e.printclass()
题目4 坐标
请创建一个Coordinate类表示坐标系，属性有x和y表示横纵坐标，并为其创建初始化方法__init__。
请重载方法__str__为输出坐标’(x, y)'。
请重载方法__add__，更改Coordinate类的相加运算为横坐标与横坐标相加，纵坐标与纵坐标相加，返回结果也是Coordinate类。
现在输入两组横纵坐标x和y，请将其初始化为两个Coordinate类的实例c1和c2，并将坐标相加后输出结果。
class Coordinate(object):
def __init__(self,x,y):
self.x=x
self.y=y
def __str__(self):
return(f'({self.x}, {self.y})')
def __add__(self,other):
return Coordinate(self.x+other.x,self.y+other.y)
x1,y1=map(int,input().split())
x2,y2=map(int,input().split())
c1=Coordinate(x1,y1)
c2=Coordinate(x2,y2)
print(c1+c2)
正则表达式匹配
题目1
牛牛最近正在研究网址，他发现好像很多网址的开头都是’https://www’，他想知道任意一个网址都是这样开头吗。
于是牛牛向你输入一个网址（字符串形式），你能使用正则函数re.match在起始位置帮他匹配一下有多少位是相同的吗？（区分大小写）
import re
a=re.match('https://www',input())
print(a.span())#返回匹配结果的位置，左闭右开区间
模式匹配
re.match()必须从字符串开头匹配！match方法尝试从字符串的起始位置匹配一个模式，
如果不是起始位置匹配成功的话，match()就返回none。主要参数如下
# re.match(pattern, string)
# pattern 匹配的正则表达式
# string 要匹配的字符串
import re
a = re.match('test','testasdtest')
print(a) #返回一个匹配对象
print(a.group()) #返回test，获取不到则报错
print(a.span()) #返回匹配结果的位置，左闭右开区间
print(re.match('test','atestasdtest')) #返回None
| 匹配任意1个字符(除了\n) | |
|---|---|
| [] | 匹配[]中列举的字符 |
| \d | 匹配数字，即0-9 |
| \D | 匹配非数字，即不是数字 |
| \s | 匹配空白，即空格，tab键 |
| \S | 匹配非空白 |
| \w | 匹配单词字符，即a-z、A-Z、0-9. |
| \W | 匹配非单词字符 |
正则裁剪
牛牛翻看以前记录朋友信息的电话薄，电话号码几位数字之间使用-间隔，后面还接了一下不太清楚什么意思的英文字母，
你能使用正则匹配re.sub将除了数字以外的其他字符去掉，提取一个全数字电话号码吗？
import re
s=input()
print(re.sub(r'\D',"",s))#sub(要替换的数据，替换成什么，要替换的数据所在的数据) r为转意移除
正则识别
牛牛记录电话号码时，习惯间隔几位就加一个-间隔，
方便记忆，同时他还会在电话后面接多条#引导的注释信息。
拨打电话时，-可以被手机正常识别，#引导的注释信息就必须要去掉了，
你能使用正则匹配re.match将前面的数字及-信息提取出来吗，去掉后面的注释信息
输入：123-3456-789 #NiuMei #1 cool girl
输出：123-3456-789
| * 出现0次或无数次 | + 至少出现一次 |
|---|---|
| ? 1次或则0次 | {m}指定出现m次 |
| {m,} 至少出现m次 | {m,n} 指定从m-n次的范围 |
| $ 匹配结尾字符 | ^ 匹配开头字符 |
| \b 匹配一个单词的边界 | \B 匹配非单词边界 |
import re
s=input()
res=re.match('(\d*[-]?)*',s)
print(res.group())
测试切片转换
创建以 1 开头的 n+1 长的列表
n = input()
f = [1] + [0] * int(n)
print(f)
s='123456'
print(int (s[0:3]))#切片字符串
语法进阶
闭包
闭包 在外函数中定义一个内函数，用到了非全局变量，
那么将这个内部函数以及用到的变量称为闭包
闭包条件:
1.在函数中嵌套一个函数
2.内层函数必须使用一个外部作用域的非全局变量
3.外层函数的return值必须只能是 内层函数的函数名
nonloacl用来在函数或者其他作用域中使用外层（非全局）变量
global关键字用来在函数或其他局部作用域中使用全局变量。
但是如果不修改全局变量也可以不使用global关键字。
def outer():
x=0
def countint():
nonlocal x
x += 1
print(x)
return countint
ot = outer()#两个括号代表掉用两个函数 outer()等于count_int,所以outer()()就等于count_int()==>>就等于内函数调用语句
ot()
ot()
ot()
面向对象-继承
1.定义一个父亲类 Father：拥有方法唱歌sing()表示会唱歌
2.定义一个母亲类 Mother：拥有方法dance()表示会跳舞
3.女儿Daughter继承了父母基因，不过唱歌比母亲好
4.另外还参加了跆拳道社
会唱歌
会跳舞
比妈妈强
还会跆拳道
class Father:
def sing(self):
print("会唱歌")
class Mother:
def dance(self):
print("会跳舞")
class Daughter(Mother,Father):
def dance(self):
Mother.dance(self)#因为方法重写被覆盖掉了，再使用要用扩展的方式
#super().父类方法:该方法指定调用最左边同名的父类方法
print("比妈妈强")
def TQD(self):
print("还会跆拳道")
D1 = Daughter()
D1.sing()
D1.dance()
D1.TQD()
#设置属性
#__init__
class Father:
def sing(self,name):
print(f'{name}会唱歌')
class Mother:
def dance(self,name):
print(f'{name}会跳舞')
class Daughter(Mother,Father):
def __init__(self,name):
self.name=name
def dance(self):
Mother.dance(self,'妈妈')#因为方法重写被覆盖掉了，再使用要用扩展的方式
#super().父类方法:该方法指定调用最左边同名的父类方法
Father.sing(self,self.name)
Mother.dance(self,self.name)
print(f'{self.name}比妈妈强')
def TQD(self):
print(f'{self.name}还会跆拳道')
D1 = Daughter('爸爸')
D1.sing('女儿')
D1.dance()
D1.TQD()
初始化结构
str()方法:用于返回对象的描述信息有更好可读性,只能传递字符串数据
class OP1:
pass
o1 = OP1()
print(o1) #内存地址<__main__.OP1 object at 0x0000019427AD57B8>
class OP1:
def __str__(self):
return '该对象是op1对象'
print(OP1())#该对象是op1对象
#OP1()在控制台使用
# <__main__.OP1 object at 0x00000292F33FA208>
repr(self)方法:也是返回对象的描述信息，但是默认是地址，之前的地址就是来自于这里的默认
与__str__方法不同的是该方法是专门给python解释器和开发人员看的
因为print是给用户看的
直接输出不是
class OP1:
def __repr__(self):
return '该对象是op1对象'
print(OP1())#该对象是op1对象
OP1()#该对象是op1对象 python控制台
查看类中所有属性和方法
dir():
class Op2:
a=1
def eat(self):
pass
print(dir(Op2))#以列表返回
| 系统默认创建的结构 | ！ |
|---|---|
| ‘class’ ， ‘delattr’ ， ‘dict’, ‘dir’, | |
| ‘doc’, ‘eq’, ‘format’, | |
| ‘ge’, ‘getattribute’, ‘gt’, ‘hash’, | |
| ‘init’, ‘init_subclass’, ‘le’, ‘lt’, | |
| ‘module’, ‘ne’, ‘new’, ‘reduce’, | |
| ‘reduce_ex’, ‘repr’, ‘setattr’, | |
| ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’``` |
类的内置函数:hasattr(),getattr(),setattr(),delattr()
hasattr(对象名,属性名/方法)用来判断某个类的实例化对象是否包含指定的属性或方法
class Op3:
def eat(self):
pass
h1 = Op3()
print(hasattr(h1,'a'))#判段是否有a属性或方法 false
print(hasattr(h1,'eat'))
class Op4:
def drink(self):
self.eat = 3
h2 = Op4()
print(hasattr(h2,'eat')) #False 没有对实例属性进行创建 没有调用drink对eat创建
h2.drink()#创建属性
print(hasattr(h2,'eat')) #True
#getattr(对象名,'属性名')--》用来获取类的对象中指定属性的值
class Op5:
def __init__(self):
self.eat = 3
h2 = Op5()
print(getattr(h2,'eat'))#3 不存在 会报错 AttributeError: 'Op5' object has no attribute 'ea'
#setattr(对象名,'属性名')--》用来修改 或 添加 类的对象中指定属性的值
class Op5:
def __init__(self):
self.eat = 3
h2 = Op5()
print(setattr(h2,'eat',6))#None 存在 会修改
print(h2.eat)
print(Op5().eat)#不改变
setattr(h2,'name',"沈阳") #不存在会添加
print(h2.name)
delattr(对象名,‘属性名’)–>用来删除 类的对象中指定属性的值
class Op5:
def __init__(self):
self.eat = 3
h2 = Op5()
print(h2.eat)#3
delattr(h2,'eat')
print(h2.eat)#不存在 会报错 AttributeError: 'Op5' object has no attribute 'eat'
delattr(h2,'a')#不存在 会报错
对象关系方法
| 对象关系方法 | value |
|---|---|
| issubclass | 判断第一个类是不是后面类的子类 |
| isinstance | 判断实例是否是后面的实例 |
| type | 也可以判断,但是只能判断单个类 |
issubclass (类名,类名或元组) 判断第一个类是不是后面的任意一个类的子类
class op1:
pass
class op2:
pass
class op3(op1):
pass
print(issubclass(op3,op2))#False
print(issubclass(op3,op1))#True
print(issubclass(op3,(op2,op1)))#True
isinstance 判断 对象 是否是后面任意一个 类的对象
class op1:
pass
class op2:
pass
class op3(op1):
pass
h1 = op2()
print(isinstance(h1,op2))#True
print(isinstance(h1,op3))#False
print(isinstance(h1,(op1,op2,op3)))#True
当调用属性不存在时,一般会报错,为了防止报错,并且有提示语可以设置__getattr__函数提示用户
class Op1:
b=2
def __getattr__(self, item):
return "这个属性不存在"
h1 = Op1()
print(h1.c)#不存在输出 "这个属性不存在"
迭代器 iter() 从可迭代对象中返回一个迭代器
可迭代对象 list tuple str 遍历也称作迭代
#next(): 从迭代器中获取下一个数据,如果无法获取,会触发Stoptrerator异常 for也属于迭代器自带next()函数
a = [1,2,3,4]#自制迭代器 迭代器能节省大量内存空间 不是一次全部生成输出
a_iter=iter(a) #通过iter()函数将可迭代对象a转为一个迭代器
print(a_iter)#<list_iterator object at 0x000002263D243198>
print(next(a_iter))
print(next(a_iter))
print(next(a_iter))
print(next(a_iter))
生成器 也是一种特殊的迭代器
1.推导式:python中是一种特殊的数据处理方式,是可以从一个数据序列构建另一个新的数据序列的结构体
一般分为:列表推导式 字典推导式 和集合推导式
列表推导式
格式1. [列表元素 for 迭代变量 in 可迭代对象]
格式2. [列表元素 for 迭代变量 in 可迭代对象 if 条件]```
#生成100个随机数
import random
List_int = [random.randint(20,100) for i in range(100)]
print(List_int)
2.元组推导试：将普通推导式的括号改为()就会变成一个生成器了！！！
import random
List_int = (random.randint(20,100) for i in range(100))
print(List_int)#<generator object <genexpr> at 0x000002ED1814EBF8>generator生成器形式
for i in range(100):
print(next(List_int))
3.函数
只要在def生成的函数内部有yield关键字就称为生成器函数yield的作用:能够让函数中断，并保持这个中断的状态，中断后，代码可以继续往下执行，过一段时间还可以重新调用这个函数，并且运行会是按照上一次调用的中断位置接着运行yield的使用，和return一样，都可以打印和返回数据，yield 数据
结果
123
456
def output():
print(123)
print(456)
output()
def output():
return 123
return 456
print(output())#123
print(output())#123
def output():#生成器函数
yield 123
yield 456
print(output())#<generator object output at 0x0000027F5524E410>
bt = output()
如果想要每调用一次函数，才会获取一个值的效果，
并且可以只使用一个内存空间，可以使用生成器来实现
print(next(bt))#123
print(next(bt))#456
装饰器
装饰器:给函数去添加一些额外的功能,通常不需要在原本的函数内部做任何代码的改动
本质:就是一个闭包函数,把业务函数名作为参数传入装饰器里面进行连接
闭包 在外函数中定义一个内函数，用到了非全局变量，
那么将这个内部函数以及用到的变量称为闭包
闭包条件:
1.在函数中嵌套一个函数
2.内层函数必须使用一个外部作用域的非全局变量
3.外层函数的return值必须只能是 内层函数的函数名
#写一个登录\注册函数
def log_on(): #log_on是一个装饰器函数
def inner():
print('请先注册再,登录')
print('注册完成,请登录')
return inner
# def register():
print(input('请输入账号:'))
print(eval(input("请输入密码:")))
#运行顺序
#1.print('请先注册再,登录')
#2.print(input('请输入账号:'))print(eval(input("请输入密码:")))
#3.print('注册完成,请登录')
```装饰器的使用方式
方法一:直接通过传递函数名给那个要装饰的函数进行修饰
为了防止数据丢失,不容易被外界获取一般写成 闭包,更加严谨的保存数据```
def log_on(a): #log_on是一个装饰器函数,a=register a()=reggister
def inner():
print('请先注册再,登录')
a() #register
print('注册完成,请登录')
return inner
def register():#被装饰的函数(业务函数):注册函数
print(input('请输入账号:'))
print(eval(input("请输入密码:")))
log_on(register)()
方法二:通过语法糖 @符号进行修饰 使用装饰器:@装饰器函数名
def log_on(a): #log_on是一个装饰器函数,a=register a()=reggister
def inner():
print('请先注册再,登录')
a() #register
print('注册完成,请登录')
return inner
@log_on
def register():#被装饰的函数(业务函数):注册函数
print(input('请输入账号:'))
print(eval(input("请输入密码:")))
register()#可以直接使用被修饰的函数