基础考试题(0)

基础考试题 :

100到300之间所有能被3和7整除的数之和

total = 0
for i in range(100,301):
    if i %3  == 0 and i % 7 == 0 :
      total +=i
print(total)


##############################

for i in range (1,101):
    print (i)
    if i%3==0 and i%5==0:
        print ('A*B')
    elif i%3==0:
        print ('A')
    elif i%5==0:
        print ('B')

 使用MD5加密注册登录:

import hashlib

def md5(args):
    ooo = hashlib.md5(bytes('dsfdsfsds',encoding='utf-8'))
    ooo.update(bytes(args,encoding='utf-8'))
    return ooo.hexdigest()

def login(user,pwd):
    with open('db','r',encoding='utf-8') as f:
        for line in f:
            u,p = line.strip().split('|')
            if u == user and p == md5(pwd):
                return True

def register(user,pwd):
    with open('db','a',encoding='utf-8') as f:
        temp = user + '|' + md5(pwd)
        f.write(temp)

i = input('1,登录: 2,注册:')
if i == '2':
    user = input('用户名:')
    pwd = input('密码:')
    register(user,pwd)
elif i == '1':
    user = input('用户名:')
    pwd = input('密码')
    r = login(user,pwd)
    if r:
        print('登录成功')
    else:
        print('登录失败 ')

 用户登录程序

def login(username,password):
    '''
    登录用户名密码验证
    :param username: 用户名
    :param password: 密码
    :return: 如果是True验证成功,False验证失败
    '''
    f = open('login', 'r', encoding='utf-8')
    for line in f:
        line = line.strip()  # 默认strip无参数去掉空格,换行.有参数去掉两侧的值,如有Q就去掉两侧Q.
        line_list = line.split('$')
        if username == line_list[0] and password == line_list[1]:
           return True
    return False
def register(username,password):
    '''
    注册用户
    1.打开文件以a的模式往后追加
    2.用户名$密码
    :param username:用户名
    :param password:密码
    :return:True注册成功
    '''
    with open('login','a',encoding='utf-8') as f :
        temp = '
' + username + '$'+ password
        f.write(temp)
    return True
def user_exist(username):
    '''
    检查用户名是否存在
    :param username:要检查的用户名
    :return:True已存在,False不存在
    '''
    #一行行查找,若用户名存在,return Trun,否则 False
    with open('login','r',encoding = 'utf-8') as f:
        for line in f:
            line = line.strip()
            line_list = line.split('$')
            if line_list[0] ==username:
                return True
    return False
def main():
    print('欢迎登陆xx系统')
    inp = input ('1>>登陆: 2>>注册:')
    if inp == '1':
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
        is_login = login(user, pwd)
        if is_login:
            print('成功')
        else:
            print('失败')
    elif inp == '2':
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
        is_exist = user_exist(user)
        if is_exist:
            print('用户名已存在无法注册')
        else:
           result = register(user,pwd)
           if result:
               print('注册成功')
           else:
               print('注册失败')
main()

定义函数统计一个字符串中大小写字母,数字的个数,并返回结果　　

intCount = 0  #记录列表中的int元素个数
strCount = 0 #记录str元素个数
isalnumCount = 0#记录数字和字母的组合
otherCount = 0#记录其它元素个数
a = input("请输入你需要判断的字符串:")
for i in a:# 使用for循环遍历字符串，每次循环判断当前获取的元素的类型，并给对应计数器计数
    if i.isdigit(): #判断i是不是int
        intCount += 1
    elif i.isalpha(): #判断i是不是str
        strCount += 1
    elif i.isalnum():
        isalnumCount += 1
    else:
        otherCount += 1#判断i是不是  其它类型
print ("数字=%d，字母=%d，数字字母组合=%d, 其他=%d" % (intCount,strCount,otherCount,isalnumCount))
#打印:
#请输入你需要判断的字符串:1q"/2/w"
#数字=2，字母=2，数字字母组合=2, 其他=0
#######################################################################################################


函数统计大小写数字个数:
def func(s):
    isupper_count = 0
    islower_count = 0
    isdigit_count = 0
    for item in s:
        if item.isupper():
            isupper_count += 1
        elif item.islower():
            islower_count += 1
        else:
            isdigit_count += 1
    print(isupper_count,islower_count,isdigit_count)
func("dds323saDDD")
#打印:
3 5 3
#######################################################################################
将字符串的数字移除不区分大小写
import re
def fun(e):
    return re.sub(r'([d]+)',"", e).lower()#r为原生字符串,不用担心漏写反斜杠转义符
print(fun("232232D ddsdsss"))
#打印:
d ddsdsss
########################################################################################
以字典形式输出:

def alpha_counter(a):
    ret=(filter(lambda x:x if x.isalpha() else False,a))
    ret = [x.lower() for x in list(ret)]#统计字符串
    c =[list(ret).count(x) for x in ret]#统计个数
    return dict(zip(ret,c))#zip就是把2个数组糅在一起
print(alpha_counter('aAsmr3idd4bgs7Dlsf9eAF'))

获取两个列表中相同元素集合:

list_1 = [11,22,33]
list_1 = set(list_1)
list_2 = set([22,33,44])
print(list_1.intersection(list_2))

#打印
{33, 22}

将字符串装换成UTF-8编码字节类型:

ret = "张超"
print(type(ret))
ret = (bytes("张超",encoding="utf-8"))
print(type(ret))
# 打印:
# <class 'str'>
# <class 'bytes'>

计算数字绝对值:

print ("abs(-45) : ", abs(-45))#abs() 返回x的绝对值
print ("abs(100.12) : ", abs(100.12))
print("abs(0) :",abs(0))
# 数轴上一个数的点到原点的距离，是数的绝对值。
# 正数或零的绝对值是它自己，负数的绝对值是它的相反数。
# 如｜-400｜=400，｜3.5｜=3.5，｜0｜=0。

深浅拷贝原理:

浅拷贝之拷贝最外层

深拷贝全部都拷贝(除了最底层)

布尔值为False的值:

None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，返回0或False，则其实例也被当作False，其他对象均为True

内置函数all和any的区别:

print (all([-1,5,3]))#0，None,空值(),{},[]都为假,其它为真，循环参数每个都为真的时候结果才为真
print (any([-1,5,3]))#只要有一个为真就返回为真，全空为假，【，任何的】
# 打印:
# True
# True

使用内置函数将10进制装换为2,8,16进制表示的字符串:

print(bin(2))#整数10进制转换二进制字符串
print(oct(8))#10进制转8进制
print(hex(15))#10进制转16进制
int()#十进制
print(id(15))#返回内存地址

# 打印:
# 0b10
# 0o10
# 0xf
# 2000904864

内置函数dir,   help,    id  , type:

a=ascii([1,2,'开关'])
print(type(a),[a])#把一个内存数据格式打印成字符串格式

# 打印:<class 'str'> ["[1, 2, '\u5f00\u5173']"]

li=[]
print(dir(li))#列出详细方法信息
help(list)#列出详细信息

内助函数 globals(), locals():

print(globals())#整个程序（文件）所有的全局变量

def test():
    local_var=333
    print(locals())#打印当前局部变量
test()

三元运算书写格式  &  lambda表达式:

name='zc' if 1==1 else 'zc0'
print(name)
#打印:
zc


######################################################################################


res=filter(lambda  n:n>5,range(10))#【过滤器，】
#打印:
6,7,8,9,

res=map(lambda n:n*n,range(10))#把range10交给lambda处理
for i in res:
    print(i)

#打印:
0,1,4,9,16,25,36,49,64,81

利用内置函数zip实现结合:

list_1 = ["zc",11,22,33]
list_2 = ["is",22,33,44]
list_3 = ["good",33,44,55]
ret = zip(list_1,list_2,list_3)
for i in ret:
    print(i)
    
# 打印:
# ('zc', 'is', 'good')
# (11, 22, 33)
# (22, 33, 44)
# (33, 44, 55)

打开模式 "r" 和 "rb" 的区别:

rb  或 r+b  读取到的内容是字节类型，
r  只读模式,字符串

文件操作with的作用:

#with可以自动关闭文件,
with open('yesterday.py','r',encoding='utf-8') as f:#as f 相当于将这段话赋值给f ,等同于f= open('yesterday.py','r',encoding='utf-8')
    print(f.readline())

with open('yesterday.py','r',encoding='utf-8') as f,
     open('yesterday2.py', 'r', encoding='utf-8') as f2:#同时打开多个文件方法
    for line in f :
        print(line)

with open('nihao.log','r',encoding='utf-8') as obj1,open('新文件','w',encoding='utf-8') as obj2:
    for line in obj1:#可以将obj1读一行写入obj2一行,最优的拷贝方式
        obj2.write(line)

函数的默认返回值:

函数中未指定return默认返回为None
函数返回值的作用是为了后面其它程序的逻辑需要根据这个返回值的结果进行操作

函数的普通参数,指定参数,默认参数,动态参数:

1.普通参数就是，传入函数，没有默认值
def f(a):
    a +=1
    return a
b=f(3)
print(b)
#打印
#4
###########################################################################################################################################
2.默认参数
def test(x,y=2):#默认参数：调用函数的时候默认参数可有可无，非必传，用途：1.默认安装值，2.数据库端口值，3.默认参数y=2必须放在后面，可以有多个默认参数
    print(x)
    print(y)
test(1) #实际会打印1,2

##########################################################################################################################################
3.动态参数(各参数组合)
def test5(name,age=18,*args,**kwargs):#位置参数，默认参数，*args，**kwargs参数组，组合使用（*args在前，**kwargs在后），可称为万能参数
    print(name)
    print(age)
    print(kwargs)
    print(args)
test5('alex',age=8,sex='男',hobby='美女')#打印alex，8，{'sex': '男', 'hobby': '美女'}，()
###########################################################################################################################################
4.指定参数,位置参数
def test(x,y):#x,y就是形参(形象的存在，是虚拟变量)
    print(x)
    print(y)
#形参和实参是从左到右一一对应的
test(1,2)#位置参数调用，1,2就是实参,(实际存在的，占用空间的)把1定义给了x,把2定义给了y，数据传送单向，实参传给形参，不能形参传给实参，调用函数时传给函数的参数
test(y=2,x=1)#关键字调用(指定参数)，与形参顺序无关
test(3,y=2)#既有位置调用也有关键字调用，关键参数不能写在位置参数前面

通过字符串格式化保留2位小数: 

s = 'i am %.2f zc' % 7.88123
print(s)

# 打印:
# i am 7.88 zc

字符串格式化:

temp = "i am {0},age{1}".format(*["seven",18])
print(temp)#打印i am seven,age18

Py导入方法:

import module_zc #可以同时导入多个，module_zc=all_code,把所有代码赋值给了一个变量，调用时module_zc.（，组件）
from module_zc import name,logger #直接调用不用加前缀，print(name)，logger()
from module_zc import * #导入所有，慎用
from module_zc import logger as logger_zc # 导入更改别名
from . import  test1 #当前目录下导入test1

192个商品每页显示10个进行分页:

r=divmod(192,10)
print(r)#取商，余数，可用于分页,(19, 2)

函数传参:

pyhon函数传参的时候穿的是引用，而不是实际值，这样可以节省内存

py3和py2  range区别:

py3:生成器循环的的时候才创建
py2:内存里面全部创建　

 py导入模块如何搜索路径:

import sys
print(sys.path)#返回模块的搜索路径，初始化时使用PYTHONPATH环境变

sys.srgv:

import sys#解释器相关的模块
print(sys.argv)#命令行参数List，第一个元素是程序本身路径
#sys.argv[0]表示代码本身文件路径，所以参数从1开始

获取一个路径的上级目录路径:

import os
print(os.path.dirname("D:Python高级全栈开发工程师-1"))#返回path的目录。其实就是os.path.split(path)的第一个元素

三个路径按照a,b,c顺序拼接起来:

import os
a = "zc"
b = "lib"
c = "bin"
print(os.path.join(a,b,c))
# 打印:zclibin

获取随机验证码:

随机生成验证码
import random
checkcode=''#先定一个空的全局变量
for i in range(4):
    current=random.randrange(0,4)#现在的，
    if current==i:
        tmp=chr(random.randint(65,90))
    else:
        tmp=random.randint(0,9)
    checkcode+=str(tmp)
print(checkcode)

re模块的 match search   findall:

re.match()#，从头开始匹配(两种方式:简单,分组)
re.search()#，浏览全部字符,匹配第一个符合规则的字符串
re.findall()#把所有匹配到的字符放到以列表中的元素返回
re.split()#以匹配到的字符当做列表分隔符
re.sub()#匹配字符并替换

正则表达式的分组:

输出结果:

import re
origin = "hello/bin/uuu/haa/d"
result = re.findall(r"(w+)/",origin)
print(result)
#['hello', 'bin', 'uuu', 'haa']

json和pickle的区别:

json是所有语言都通用的，支持不同语言之间数据交互（如list、tuple、dict和string），只能处理简单的因为是跨语言的


Pickle（只可以在python中使用）它可以序列化任何对象并保存到磁盘中，并在需要的时候读取出来， 功能比json强大

序列化:
info={
    'name':'zc',
    'age':29,
}
f=open('test.txt','w')
f.write(json.dumps(info))#【废物】,将python基本数据类型装换为字符串
f.close()
**********************************************************    
反序列化:
f=open('test.txt','r')
data=json.loads(f.read())#【负载】,用于将字典,列表,元祖形式的字符串转换成相应的字典列表元祖
print(data['age'])

判断对错:

import json
l1 = ["hello",123,"zc"]
l2 = ["hello",123,'zc']
l3 = """["hello",123,"zc"]"""
l4 = """["hello",123,'zc']"""


a = json.loads(l1)
print(a)#错误
b = json.loads(l2)
print(b)#错误
c = json.loads(l3)
print(l3)#["hello",123,"zc"]
d = json.loads(l4)
print(d)#错误
e = json.dumps(l1)
print(e)#["hello", 123, "zc"]
f = json.dumps(l2)
print(f)#["hello", 123, "zc"]
g = json.dumps(l3)
print(g)#"["hello",123,"zc"]"
h = json.dumps(l4)
print(h)#"["hello",123,'zc']"

HTTP请求返回的本质是字符串

邮箱的正则表达式:

import re
text = input("Please input your Email address：
")
if re.match(r'^[0-9a-zA-Z_-]{0,19}@[0-9a-zA-Z]{1,13}.[com,cn,net]{1,3}$',text):
#if re.match(r'[0-9a-zA-Z_]{0,19}@163.com',text):
    print('Email address is Right!')
else:
    print('Please reset your right Email address!')

Python 对象和类的关系:

对象是类的具体实例化,
类:人类
对象:其中的人

输出一下代码:

a = "zc %"
print(a)
#zc %
####################################
b = "zc %d %%" % (10)
print(b)
#########################################
def func(a1):
    return a1 + 100 #func值被系统垃圾回收机制回收。
func = lambda a1:a1 + 200
ret = func(10)
print(ret)
#210
############################################
def f1(args):
    print(args + 100)

def f2(args):
    ret = f1(args + 1)
    print(args)
    print(ret)
ret = f2(7)
print(ret)
# 打印
# 108
# 7
# None
# None
##########################################
def f1(args):
    print(id(args))
n = 1111
print(id(n))
f1(n)
# 打印
# 1818722165808
# 1818722165808
########################################
def func(args):
    args.append(55)
    # return args 没有加返回值
li = [11,22,33,44]
li = func(li)
print(li)
# 打印:
# None
#########################################
namelist = ["zc","hello"]
def func():
    namelist = 123
func()
print(namelist)
# 打印:
# ['zc', 'hello']
##########################################
namelist = ["zc","hello"]
def func():
    global namelist
    namelist = 123
func()
print(namelist)
# 打印:
# 123
########################################
namelist = ["zc","hello"]
def func():
 namelist.append("seven")
func()
print(namelist)
# 打印:
# ['zc', 'hello', 'seven']
#############################################
r1 = eval("1 + 10 * 10")#eval#字符串表达式，返回值
r2 = exec("1 + 10 * 10")#exec执行代码，没有返回值，，实行的意思
print(r1,r2)
# 打印:
# 101 None

ret=eval('1+2+3')#，评价的意思
print(ret)#可以执行字符串形式的计算表达式
ret=eval('a+10',{'a':9})
print(ret)#结果19

输出一下代码:

import re
r = re.match("d+","123abc").group()
print(r)
# 打印
# 123
###########################################

使用requests和xml实现天气查询:

import requests
from xml.etree import ElementTree as ET
r = requests.get('http://www.webxml.com.cn/WebServices/WeatherWebService.asmx/getWeatherbyCityName?theCityName=宝鸡')
s = r.text
a = ET.XML(s)
for i in a:
    print(i.text)

 字符串排序:

s = 'abcde'
print(s[::-1])#切片方法设置步长为-1，反过来排序。

l = list(s)
l.reverse()
result = "".join(l)
print(result)

l = list(s)
result = "".join(l[::-1])
print(result)
# 打印:
# edcba
# edcba
# edcba
#################################################

代码:

li = [11,22,33,44]
def func(x):
    if x >33:
        return True
    else:
        return False
n = filter(func,li)#过滤器
print(list(n))#获取大于33的元素
#打印:
[44]
#####################################################################################
 li = [11,22,33,44]
def func(x):
    return x< 33
n = filter(func,li)
print(list(n)) #获取小余33的元素
# 打印:
# [11, 22]
####################################################################################
l1 = [1,2,3,5]
def func(x):
    if x % 2 == 1:
        return x +100
    else:
        return x
l2 = map(func,l1)
for i in l2:  #将所有的奇数加100
    print(i)
# 打印:
# 101
# 2
# 103
# 105
################################################################################
l1 = [11,22,33,44]
l2 = map(lambda x: x + 100  if x % 2 == 0 else x ,l1)
for i in l2:
    print(i)# 将所有的偶数的元素加100
# 打印:
# 11
# 122
# 33
# 144
######################################
li = "zc"
print(li * 2)#py独有
#zczc
########################################
for i in range (1,6):
    print(i ** 2)
# 1
# 4
# 9
# 16
# 25
############################################
x = 0
while x <5:
    print(x **2)
    x += 1
# 0
# 1
# 4
# 9
# 16
##########################################
a = 5
round(a,2)
print("%.2f" %a)
# 5.00
##########################################
print(round(1.445,2))#1.45
########################################
for i in range(1, 10):
    for j in range(1, i+1):
#for j in range(1, 10):方形输出　　
#for j in range(i, 10):左上角格式输出:i=1  j=1至9...
        print("%d*%d=%d"% (j,i,i*j), end=" ")
    print("")

1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 
########################################

代码:

def di(x):
    if x == 1 or x == 0:
        return 1
    else:
        return x * di(x - 1)
print(di(7))#阶乘算法 1*2*3..7
# 5040
###########################################
def func(x,day):
    day -= 1
    if day == 0:
        return x
    x = (1 + x) * 2
    ret = func(x,day)
    return ret
ret = func(1,10)
print(ret)
#1534
########################################

猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第 10 天刚好剩一个。问猴子第一天摘了多少个桃子？

解题思路：

这题得倒着推。第10天还没吃，就剩1个，说明第9天吃完一半再吃1个还剩1个，假设第9天还没吃之前有桃子p个，可得：p * 1/2 - 1 = 1，可得 p = 4。以此类推，即可手算出。

代码思路为：第10天还没吃之前的桃子数量初始化 p = 1，之后从9至1循环9次，根据上述公式反推为 p = (p+1) * 2 可得第1天还没吃之前的桃子数量。for循环中的print()语句是为了验证推算过程而增加的。

p = 1
print('第10天吃之前就剩1个桃子')
for i in range(9, 0, -1):
    p = (p+1) * 2
    print('第%s天吃之前还有%s个桃子' % (i, p))
print('第1天共摘了%s个桃子' % p)

第10天吃之前就剩1个桃子
第9天吃之前还有4个桃子
第8天吃之前还有10个桃子
第7天吃之前还有22个桃子
第6天吃之前还有46个桃子
第5天吃之前还有94个桃子
第4天吃之前还有190个桃子
第3天吃之前还有382个桃子
第2天吃之前还有766个桃子
第1天吃之前还有1534个桃子
第1天共摘了1534个桃子

如有以下两个列表
l1=[...]
l2=[]
第一个列表中的数字无序不重复排列，第二个列表为空列表
需求：
取出第一个列表的最小值放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
取出第一个列表的最小值（仅大于上一次的最小值）放到第二个列表的首个位置，
...
依此类推，从而获取一个有序的列表 l2，并将其返回给函数调用者。

deffunc(l1,l2):
pass

l1 = [11,33,44,2,66]
l2 = []
def func(l1,l2):
    for item in range(len(l1)):
        v = min(l1)
        l2.insert(0,v)
        l1.remove(v)
    return l2
print(func(l1,l2))
#[66, 44, 33, 11, 2]

利用filter、lambda 表达式获取 l1 中元素小于 33 的所有元素l1=[11,22,33,44,55]

l1 = [11,22,33,44,55]
print(list(filter(lambda x:x<33,l1)))
# [11, 22]