经典例题

翻页

以前写法
data_list = []

for i in range(1, 901):
    data_list.append('alex-%s' % i)

while True:
    # 1. 要查看的页面
    page = int(input('请输入要查看的页码:'))

    # 2. 每页显示 10 条
    per_page_num = 10

    start = (page-1) * per_page_num
    end = page * per_page_num

    page_data_list = data_list[start:end]
    for item in page_data_list:
        print(item)

用面向对象写

class Pagenation(object):
    """
    处理分页相关的代码
    """

    def __init__(self,data_list,page,per_page_num=10):
        """
        初始化
        :param data_list: 所有的数据
        :param page: 当前要查看的页面
        :param per_page_num: 每页默认要显示的数据行数
        """
        self.data_list = data_list
        self.page = page
        self.per_page_num = per_page_num

    @property
    def start(self):
        """
        计算索引的起始位置
        :return:
        """
        return (self.page-1) * self.per_page_num

    @property
    def end(self):
        """
        计算索引的结束位置
        :return:
        """
        return self.page * self.per_page_num

    def show(self):
        result = self.data_list[self.start:self.end]
        for row in result:
            print(row)


data_list = []

for i in range(1, 901):
    data_list.append('alex-%s' % i)

while True:
    # 1. 要查看的页面
    page = int(input('请输入要查看的页码:'))
    obj = Pagenation(data_list,page)
    obj.show()

 

老男孩简单选课

选课系统
class School:
    def __init__(self, address):
        self.address = address


bj = School('北京校区')
sh = School('上海校区')
sz = School('深圳校区')


class Course(object):
    def __init__(self, name, period, price, school=None):
        self.name = name
        self.period = period
        self.price = price
        self.school = school


py1 = Course('Python全栈', 110, 19999, bj)
py2 = Course('Python全栈', 110, 19999, sh)
py3 = Course('Python全栈', 110, 19999, sz)

l1 = Course('Linux运维', 110, 19999, bj)
l2 = Course('Linux运维', 110, 19999, sh)

g1 = Course('Go开发', 119, 19999, bj)


class Grade(object):
    def __init__(self, name, people, introduce, course=None):
        self.name = name
        self.people = people
        self.introduce = introduce
        self.course = course

gr1 = Grade('全栈1期',20,'....',py1)
gr2 = Grade('全栈1期',20,'....',py2)

gr3 = Grade('Linux8期',20,'....',l2)




gr1.people
gr1.course.price
gr1.course.school.address

 验证码

#------------------验证码-----------------------------------
# 目标一:随机产生任意个数字的验证码
def yanzhenma(x):                  #定义随机产生的验证码数字个数x的值可以随便的更改
    import random                  #引入随机数模块
    s = ""                         #定义一个空字符串来接验证码
    for i in range(x):
        num = random.randint(0,9)  #从0-9的数里面随机产生一个数
        s += str(num)              #将产生的随即数累加
    return s                       #返会最后的结果
print(yanzhenma(4))                #打印随机产生的四个验证码,当然也可以是6个依照需求来定
#
#
#  目标二:如何产生字母和数字组合在一起的验证码
def yanzhenma(x):                           #定义验证码的函数
    import random                           #引入随机数模块
    s = ""                                  #定义一个字符串类型的数来承接你随机产生的验证码
    for i in range(x):                      #定义需要随机数产生的次数
        digle = random.randint(0,9)         #随机产生数字
#介绍一个知识点chr(数字)调出来的是ASDII码中数字所对应的字母
        alph_upper = chr(random.randint(65,90))  #随机产生小写字母利用小写子母在ASDII码中的位置
        alph_lower = chr(random.randint(97,122))  # 同上,因为在ASDII中大小写不是连在一起的所以要分开写
        num = random.choice([str(digle),alph_lower,alph_upper])  #在前面的产生的随机数列表中随机产生一个字符
        s += num                              #将产生的随机数进行累加
    return s                                   #返回随机产生的数
print(yanzhenma(4))                            #打印随机验证码4位的
#
#
# 目标三:那么如果我想让他产生的是纯数字有时候产生的是字母加数字改怎么办??
#         很有挑战但是用最简单的方法去做
def yanzhenma(x,alpha=True):                #定义一个验证码的函数位数由自己设定字母默认是有的
    import random                           #引入随机数模块
    s = ''                                  #用s字符串来承接验证码
    for i in range(x):                      #随机循环的次数
        num = str(random.randint(0, 9))     #随机产生数字
        if alpha:                           #判断是不是需要字母
            alpha_upper = chr(random.randint(65, 90))  #随机产生小写字母
            alpha_lower = chr(random.randint(97, 122)) #随机产生大写字母
            num = random.choice([num, alpha_upper, alpha_lower])    #将产生的数字字母放在一起在随机产生一个需要位数的数
        s += num                                                #将随机产生的数放在一起
    return (s)                                                  #返回随机产生的数
print(yanzhenma(6,alpha=True ))                                 #调用函数并且给初始值

 

抢红包

#------------------抢红包--------------------
import random
def func(s, n):
    lst = []
    sum = 0
    for i in range(n):
        if i == n-1:
            lst.append(s-sum)
            break
        m = random.uniform(s//(n+1), s//(n-1))
        sum += m
        lst.append(m)
    return random.sample(lst, n)
print(func(10, 5))

 

时间差

def dif(x,y):

    import time                                         #引入时间模块
    true_time = time.mktime(time.strptime(x,"%Y-%m-%d %H:%M:%S"))       #将开始的字符串时间先编程结构化时间然后在转换成时间戳时间便于计算时间差
    time_now = time.mktime(time.strptime(y,"%Y-%m-%d %H:%M:%S"))        #将现在的字符串时间先编译成结构化时间然后在转换成时间戳时间
    dif_time = time_now - true_time                                     #将现在的时间与开始的时间作差
    struct_time = time.gmtime(dif_time)                                 #将时间差变换成结构化时间
    print("过去了%d年%d月%d天%d小时%d分钟%d秒"%(struct_time.tm_year-1970,struct_time.tm_mon-1,  #结构化时间与1970-1-1 0:0:0
                                               struct_time.tm_mday-1,struct_time.tm_hour,       #作差值显示时间差的结构化输出
                                               struct_time.tm_min,struct_time.tm_sec))
dif("2018-8-9 8:0:0","2018-8-9 9:0:0")

 

用sys模块做用户登陆
#-----------用sys模块做用户登陆---------------
#首先要明确一件事那就是以前的input用的好好的为什么要用sys模块原因就是因为sys模式能帮助我们争取cpu的占用权
#这一点是非常重要的因为input就是一个用户请求要是用户不输入内容那么就一直等待,cpu是不会等待的你只能输入完之后在排队
import sys
import os
sys.argv
usr = sys.argv[1]
psw = sys.argv[2]
if usr == "majiankai" and psw == "123":
    os.mkdir("%s"%(usr))
    print("登陆成功! 已创建您的文件夹",)
else:
    os.rmdir("%s"%(usr))
    exit()

 

计算文件大小

# 计算文件夹内容的大小

# 循环 —
# — 堆栈思想
# 列表,满足一个顺序,先进来后出去
lst = ['F:\os模块测试']
size_sum = 0
while lst:
    path = lst.pop()
    path_list = os.listdir(path)
    for name in path_list:
        abs_path = os.path.join(path, name)
        if os.path.isdir(abs_path):
            lst.append(abs_path)
        else:
            size_sum += os.path.getsize(abs_path)
print(size_sum)

# 递归
def func(path):
    size_sum = 0
    name_lst = os.listdir(path)
    for name in name_lst:
        path_abs = os.path.join(path, name)
        if os.path.isdir(path_abs):
            size = func(path_abs)
            size_sum += size
        else:
            size_sum += os.path.getsize(path_abs)
    return size_sum
lst = func('F:\os模块测试')
print(lst)

 

网络编程的示例

--------------------------------服务端----------------------------------------
import socket   "不仅python 中有在C,C#,C++中也有
serve = socket.socket()
server.bind("1921.168.13.125",8001)  #这一步是进行绑定IP地址是自己的
server.listen(5)    #设置后面可以等待5个人
ret1 = server.accept()  #在这里会有阻塞,只要有人连接就建立通讯开始交换数据
print(ret1)     #这里面是有两个数据的1:conn是从客户端和服务端连接的对象
     
                     2:addr:是客户端的地址信息
conn.recv (1024)#"1024"表示服务端通过对象获取数据时 ,一次性最多传输1024个字节
conn.send (b'start') #服务端通过连接对象给客户端回复了一个消息

 

-----------------------------------------客户端----------------------------------
import socket

client = socket.socket()

# 客户端向服务端发起连接请求
# 阻塞,去连接,直到连接成功后才会继续向下走。
client.connect(('192.168.13.125',8000))


# # 链接上服务端后,向服务端发送消息
client.send(b'hello')


# 客户端等待服务端给他发送消息
data = client.recv(1024)
print(data)

# 关闭自己
client.close()

 

 这样只是进行了一次通讯传输完数据之后就关闭了,那么怎样实现连续的传输呢?

 

-------------------------------服务端---------------------------------------------
import socket

server = socket.socket()

server.bind(('192.168.13.155',8001))

server.listen(5)

while True:
    conn,addr = server.accept()
    # 字节类型
    while True:
        data = conn.recv(1024) # 阻塞
        if data == b'exit':
            break
        response = data + b' SB'
        conn.send(response)

    conn.close()

 

 

 

 

 

-----------------------------------客户端---------------------------------------
import socket

sk = socket.socket()

sk.connect(('192.168.13.155',8001))

while True:
    name = input("请输入姓名:")
    sk.send(name.encode('utf-8')) # 字节
    if name == 'exit':
        break

    response = sk.recv(1024) # 字节
    print(response.decode('utf-8'))

sk.close()

 

 这样就实现了基本通讯的功能

 

posted @ 2018-09-02 13:51  RootEvils  阅读(95)  评论(0)    收藏  举报