通过游戏学python 3.6 第一季 第三章 实例项目 猜数字游戏--核心代码--猜测次数--随机函数和屏蔽错误代码 可复制直接使用 娱乐 可封装 函数

 

 猜数字游戏--核心代码--猜测次数--随机函数和屏蔽错误代码

 

 #猜数字--核心代码--猜测次数--随机函数和屏蔽错误代码 

 import random
 secrst = random.randint(1,99)

 number = secrst

 amount = random.randint(3,8)
 print('本次游戏次数为',amount,'次')

 count=0
 while count<=amount:
     try:
         conversion=input('请猜数字')
         guess=int(conversion)

         if guess == number:
             print('猜对了')
             break
         elif guess > number:
             print('大了')
         else:
             print('小了')

         count=count+1

         if count==amount:
             countine=input('任意键重新开始，“N”键退出游戏')
             if countine !='n':
                 count=0
             else:
                 exit()
     except:
         print('请输入数字，而不是其他')                

猜数字--随机函数和屏蔽错误代码

---

import random

 '''

 1.定义：

 模块:用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），
      本质就是.py结尾的python文件（文件名：test.py,对应的模块名test）

 包：用来从逻辑上组织模块的，本质就是一个目录（必须带有一个__init__.py 的文件）

 2.导入方法

 import module_name                              #快捷方式调用
 import module_name,module2_name                 #使用方法   module_name.m1()  

 from module_name  import *                      #完全复制，不建议使用,容易被覆盖
 from module_name  import m1,m2,m3               #使用方法    m1()

 from module_name import logger as logger_alex   #完全复制并且as改名

 3.import本质(路径搜索和搜索路径)

 导入模块的本质就是把python文件解释一遍
 (import test   test='test.py all code')
 (from test import name  name='code')
 #  import test1  #test1='test1.py 全部执行一遍'
 #  from.import test1  #当前目录路径下完全复制运行执行一遍

 导入包的本质就是执行该包下的__init__.py 的文件
 import module_name  ---> module_name.py ---->module_name.py的路径--->sys.path

 4.导入优化

 不重复搜索调用的方法
 from module_name  import m1                      #单个完全复制，使用方法  m1()
 from module_name import logger as logger_alex    #完全复制并且as改名

 5.模块的分类

 a:标准库
 b:开源模块（第三方模块）
 c:自定义模块

 '''

 print('-----------寻找当前环境目录路径--------')
 import sys,os
 a = os.path.abspath(__file__)
 b = os.path.dirname(os.path.abspath(__file__))
 c = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 d = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 print(a)
 print(b)
 print(c)
 print(d)

 print('--------创建新目录开始-----------')
 '''
 Python对文件的操作还算是方便的，只需要包含os模块进来，使用相关函数即可实现目录的创建。
 主要涉及到三个函数
 1、os.path.exists(path) 判断一个目录是否存在
 2、os.makedirs(path) 多层创建目录
 3、os.mkdir(path) 创建目录
 '''

 def mkdir(path):
     # 引入模块
     import os

     # 去除首位空格
     path=path.strip()
     # 去除尾部 \ 符号
     path=path.rstrip("\\")

     # 判断路径是否存在
     # 存在     True
     # 不存在   False
     isExists=os.path.exists(path)

     # 判断结果
     if not isExists:
         # 如果不存在则创建目录
         print(path+'创建成功')
         # 创建目录操作函数
         os.makedirs(path)
         return True
     else:
         # 如果目录存在则不创建，并提示目录已存在
         print (path+'目录已存在')
         return False

 # 定义要创建的目录
 m = '\\foo'
 mkpath = c+m
 # 调用函数
 mkdir(mkpath)
 print('--------创建新目录完成-----------')

 print('--------创建  module_alex.py 开始-----------')
 data1="name='alex'\n"
 data2="def say_hello():\n"
 data3="\tprint ('hello alex')"

 sys.path.append(d)
 f = open (mkpath + '\\module_alex.py','w+')
 f.write(data1)
 f.write(data2)
 f.write(data3)

 f.flush()
 f.close()
 print(f)
 print('--------创建 module_alex.py 完毕-----------')

 '''
 flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，
 同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
 一般情况下，文件关闭后会自动刷新缓冲区，但
 有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
 '''
 print('--------演示import 功能-----------')

 import sys,os
 print (sys.path)
 x=(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 sys.path.append(x)

 print('--------演示调用模块-----------')

 import module_alex
 print(module_alex.name)
 module_alex.say_hello()

 '''
 创建和读取文件

 info = {
     'name':'alex',
     'age':22
         }

 f = open ('test.txt','w')
 f.write(str(info))

 f.close()

 f = open ('test.txt','r')

 data = eval(f.read())

 f.close()

 print (data['age'])

 '''

import演示

 #自动生成代码

 print('-----------寻找当前环境目录路径--------')
 import sys,os
 a = os.path.abspath(__file__)
 b = os.path.dirname(os.path.abspath(__file__))
 c = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 d = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 print(a)
 print(b)
 print(c)
 print(d)

 print('--------创建新目录开始-----------')

 def mkdir(path):
     # 引入模块
     import os

     # 去除首位空格
     path=path.strip()
     # 去除尾部 \ 符号
     path=path.rstrip("\\")

     # 判断路径是否存在
     # 存在     True
     # 不存在   False
     isExists=os.path.exists(path)

     # 判断结果
     if not isExists:
         # 如果不存在则创建目录
         print(path+'创建成功')
         # 创建目录操作函数
         os.makedirs(path)
         return True
     else:
         # 如果目录存在则不创建，并提示目录已存在
         print (path+'目录已存在')
         return False

 # 定义要创建的目录
 m = '\\'+input('目录名称：')
 mkpath = c+m
 # 调用函数
 mkdir(mkpath)
 print('--------创建新目录完成-----------')

 print('--------创建  module_alex.py 开始-----------')
 data1='''

 #socketserver基本使用
 import os
 import json

 import socketserver

 class MyTCPHandler(socketserver.BaseRequestHandler):

     def put(self,*args):
         #接收客户端文件
         cmd_dic = args[0]
         filename = cmd_dic['filename']
         filesize = cmd_dic['size']
         if os.path.isfile(filename):
             f = open(filename + '.new','wb')
         else:
             f = open(filename ,'wb')

         self.request.send(b'200 ok')#返回json格式
         received_size = 0
         while received_size < filesize:
             data = self.request.recv(1024)
             f.write(data)
             received_size += len(data)
         else:
             print ('file[%s] has uploaded...' % filename)

     def handle(self):
         while True:
             try:
                 self.data =self.request.recv(1024).strip()
                 print ('{} wrote:'.format(self.client_address[0]))
                 print (self.data)

                 cmd_dic = json.loads(self.data.decode())
                 action = cmd_dic['action']

                 if hasattr(self,action):
                     func = getattr(self,action)
                     func(cmd_dic)

                 #self.request.send(self.data.upper())
             except ConnectionResetError as e:
                 print ('err,e')
                 break

 if __name__ == '__main__':

     HOST,PORT = 'localhost',9999
     #HOST,PORT = '0.0.0.0',9999

     server = socketserver.TCPServer((HOST,PORT),MyTCPHandler)
     server.serve_forever()

 '''

 sys.path.append(d)
 ls = input('文件名称：')
 f = open (mkpath + '\\'+ ls + '.py','w+',encoding='utf-8')
 f.write(data1)

 f.flush()
 f.close()
 print(f)
 print('--------创建 module_alex.py 完毕-----------')

#自动生成代码

 #random模块  String（字符串）
 #随机模块

 #!/usr/bin/env python
 #_*_encoding: utf-8_*_
 import random
 print('#random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0')
 print (random.random())  #0.6445010863311293  

 print('用于生成一个指定范围内的整数。')
 print (random.randint(1,7)) #
 #random.randint()的函数原型为：random.randint(a, b)，
 #用于生成一个指定范围内的整数。
 # 其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

 print('从指定范围内，按指定基数递增的集合中 获取一个随机数。')
 print (random.randrange(1,10)) #5  顾头不顾尾只不会1-9
 #random.randrange的函数原型为：random.randrange([start], stop[, step])，
 # 从指定范围内，按指定基数递增的集合中 获取一个随机数。如：random.randrange(10, 100, 2)，
 # 结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。
 # random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。

 print('从序列中获取一个随机元素。')
 print(random.choice('liukuni')) #i  #从字符串，列表，元组，字典里随机取值
 #random.choice从序列中获取一个随机元素。
 # 其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。
 # 这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。
 # list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。

 #random.sample的函数原型为：
 #random.sample(sequence, k)，
 #从指定序列中随机获取指定长度的片断。
 #sample函数不会修改原有序列。

 print('-------#实际应用：------------')
 #!/usr/bin/env python
 # encoding: utf-8
 import random
 import string

 print('-------#随机整数：------------')
 print( random.randint(0,99))  #

 print('-------#随机选取0到100间的偶数：------------')
 print(random.randrange(0, 101, 2)) #

 print('-------#随机浮点数：：------------')
 print( random.random()) #0.2746445568079129
 print(random.uniform(1, 10)) #9.887001463194844   #增加区间的功能

 print('-------#随机字符：------------')
 print(random.choice('abcdefg&#%^*f')) #f
 print(random.choice("学习Python"))#学
 print(random.choice(["JGood","is","a","handsome","boy"]))  #List
 print(random.choice(("Tuple","List","Dict")))   #List

 print('-------#多个字符中选取特定数量的字符：------------')
 print(random.sample('abcdefghij',3)) #['f', 'h', 'd']
 print(random.sample([1,2,3,4,5],3))    #[1, 2, 5] #从前面，随机取（参数：3）位

 print('-------#随机选取字符串：------------')
 print( random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )) #apple

 print('-------#洗牌#：------------')
 items = [1,2,3,4,5,6,7]
 print(items) #[1, 2, 3, 4, 5, 6, 7]
 random.shuffle(items)  #shuffle() 方法将序列的所有元素随机排序
 print(items) #[1, 4, 7, 2, 5, 3, 6]

 print('-------生成随机验证码：------------')
 import random
 checkcode = ''  #定义全局变量
 for i in range(6):
     current = random.randrange(0,6)
     if current != i:
         temp = chr(random.randint(65,90)) #chr()数字转换成ASCII，
     else:
         temp = random.randint(0,9)
     checkcode += str(temp)
 print (checkcode)

 #String（字符串）import string
 print('-------string类型介绍------------')
 import random
 import string
 a = string.__all__              #类型介绍
 b = string.ascii_letters        #大小写字母
 c = string.ascii_lowercase      #小写字母
 d = string.ascii_uppercase      #大写字母
 e = string.digits               #0-9
 f = string.hexdigits            #0-9,a-f,A-F
 g = string.octdigits            #0-7
 h = string.printable            #0-9,大小写字母,标点符号
 i = string.punctuation          #标点符号
 j = string.whitespace           #空格

 print(a)
 print('-------分割为了看的更清楚------------')
 print(b)
 print(c)
 print(d)
 print(e)
 print(f)
 print(g)
 print(h)
 print('-------分割为了看的更清楚------------')
 print(i)
 print('-------分割为了看的更清楚------------')
 print(j)

 print('-------随机函数测试string------------')
 x = random.choice(f)
 y = random.sample(f,5)
 print('-------用随机选取字符串测试string------------')
 print(x)
 print('-------用多个字符中选取特定数量的字符测试string------------')
 print(y)

#random模块 String（字符串）

 #  import os
 #  help(os)
 # print(os)模块
 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
 os.curdir  返回当前目录: ('.')
 os.pardir  获取当前目录的父目录字符串名：('..')
 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
 os.remove()  删除一个文件
 os.rename("oldname","newname")  重命名文件/目录
 os.stat('path/filename')  获取文件/目录信息
 #重要
 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
 os.linesep    输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
 os.pathsep    输出用于分割文件路径的字符串
 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
 os.system("bash command")  运行shell命令，直接显示
 os.environ  获取系统环境变量   字典模式{k:v}
 #重要
 #  (path)路径  (r'c:\a\b\c\d\a.txt')
 os.path.abspath(path)  返回path规范化的绝对路径
 os.path.split(path)  将path分割成目录和文件名二元组返回(r'c:\a\b\c\d\a.txt')
 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
 os.path.isabs(path)  如果path是绝对路径，返回True(r'c:\a')
 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
 import os
 x = os.path.join(r'c:',r'\a',r'\a.txt')
 print (x)
 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

 #  sys模块
 sys.argv           命令行参数List，第一个元素是程序本身路径
 ['C:/Users/Administrator/AppData/Local/Programs/Python/Python36-32/212.py']
 sys.exit(n)        退出程序，正常退出时exit(0)
 sys.version        获取Python解释程序的版本信息
 sys.maxint         最大的Int值
 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
 sys.platform       返回操作系统平台名称
 sys.stdout.write('please:')
 val = sys.stdin.readline()[:-1]

(os)模块sys模块

---

　　try:

　　except:

 #异常处理
 try:
     #name[3]
     #data['name']
     #open('r')
     a = 1
     print (a)
 except KeyError as e :
     print ('没有这个KEY',e)

 except IndexError as e :
     print ('列表操作错误',e)

 except (KeyError,IndexError) as e :
     print ('多个错误统一处理',e)

 except Exception as e :
     print ('所有的错误都处理，未知错误使用',e)

 else:
     print ('一切正常打印这个')

 finally:
     print ('不管有没有错误,都执行')

#异常处理except

 #1、异常基础
 #在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，
 #   而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！

 try:
     pass
 except Exception as ex:
     pass

 print('需求：将用户输入的两个数字相加,输入字母或者其他报错')
 while True:
     num1 = input('num1:')
     num2 = input('num2:')
     try:
         num1 = int(num1)
         num2 = int(num2)
         result = num1 + num2
     except Exception as e:
         print('出现异常，信息如下：')
         print(e)

异常基础

 '''
 2、异常种类

 常用异常

 AttributeError      试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
 IOError             输入/输出异常；基本上是无法打开文件
 ImportError         无法引入模块或包；基本上是路径问题或名称错误
 IndentationError    语法错误（的子类） ；代码没有正确对齐
 IndexError          下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
 KeyError            试图访问字典里不存在的键
 KeyboardInterrupt   Ctrl+C被按下
 NameError           使用一个还未被赋予对象的变量
 SyntaxError Python  代码非法，代码不能编译(个人认为这是语法错误，写错了）
 TypeError           传入对象类型与要求的不符合
 UnboundLocalError   试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
                     导致你以为正在访问它
 ValueError          传入一个调用者不期望的值，即使值的类型是正确的

 常用异常
 '''

 print('----以下实例，异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。----')
 dic = ["wupeiqi", 'alex']
 try:
     dic[10]
 except IndexError as e:
     print (e)

 dic = {'k1':'v1'}
 try:
     dic['k20']
 except KeyError as e:
     print (e)

 s1 = 'hello111111111111111'
 try:
     int(s1)
 except ValueError as e:
     print (e)

 print('-----未捕获到异常，程序直接报错---不演示了，自己测试吧-----')

 '''
 s1 = 'hello222222222222'
 try:
     int(s1)
 except IndexError as e:
     print (e)
 '''

 print('-----所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：')

 s1 = 'hello33333333333333'
 try:
     int(s1)
 except IndexError as e:
     print (e)
 except KeyError as e:
     print (e)
 except ValueError as e:
     print (e)

 print('-----万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：')

 s1 = 'hello4444444444444444'
 try:
     int(s1)
 except Exception as e:
     print (e)

 print('----接下来你可能要问了，既然有这个万能异常，其他异常是不是就可以忽略了！----')
 print('----答：当然不是，对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。----')

 s1 = 'hello5555555555555555'
 try:
     int(s1)
 except KeyError as e:
     print( '键错误')
 except IndexError as e:
     print ('索引错误')
 except Exception as e:
     print ('错误')

 print('--------异常其他结构--------')
 try:
     #name[3]
     #data['name']
     #open('r')
     a = 1
     print (a)
 except KeyError as e :
     print ('没有这个KEY',e)

 except IndexError as e :
     print ('列表操作错误',e)

 except (KeyError,IndexError) as e :
     print ('多个错误统一处理',e)

 except Exception as e :
     print ('所有的错误都处理，未知错误使用',e)

 else:
     print ('一切正常打印这个')

 finally:
     print ('不管有没有错误,都执行')

 print('------------------主动触发异常---------------')
 try:
     raise Exception('错误了。。。')
 except Exception as e:
     print (e)

 print('------------------主动触发异常222222222222222222---------------')
 s1 = 'hello'
 try:
     int(s1)
 except ValueError as e:
     print(e)

 print('---------自定义异常--------')
 class AlexException(Exception):
     def __init__(self,msg):
         self.message = msg
     #def __str__(self):
     #    return '替换了，自定义的异常'

 try:
     raise AlexException('自定义的异常，数据库连不上，我自己定义的异常')
 except AlexException as e:
     print(e)

 print('---------------断言------# assert 条件--------')

 assert 1 == 1   # 条件成立，则继续执行下面的代码

 print('''
 1、assert语句用来声明某个条件是真的。
 2、如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么assert语句是应用在这种情形下的理想语句。
 3、当assert语句失败的时候，会引发一AssertionError。
       ''')
 assert 1 == 2  #  条件不成立，则报错

常用异常和实例

 ArithmeticError
 AssertionError
 AttributeError
 BaseException
 BufferError
 BytesWarning
 DeprecationWarning
 EnvironmentError
 EOFError
 Exception
 FloatingPointError
 FutureWarning
 GeneratorExit
 ImportError
 ImportWarning
 IndentationError
 IndexError
 IOError
 KeyboardInterrupt
 KeyError
 LookupError
 MemoryError
 NameError
 NotImplementedError
 OSError
 OverflowError
 PendingDeprecationWarning
 ReferenceError
 RuntimeError
 RuntimeWarning
 StandardError
 StopIteration
 SyntaxError
 SyntaxWarning
 SystemError
 SystemExit
 TabError
 TypeError
 UnboundLocalError
 UnicodeDecodeError
 UnicodeEncodeError
 UnicodeError
 UnicodeTranslateError
 UnicodeWarning
 UserWarning
 ValueError
 Warning
 ZeroDivisionError

 更多异常

更多异常--来个会翻译联系我

---

exit()

 Python里   os._exit() sys.exit() exit()    的区别

 Python退出程序的方式有两种：os._exit()， sys.exit()
 1）os._exit()   直接退出 Python程序，其后的代码也不会继续执行。

 2）sys.exit()   引发一个 SystemExit异常，若没有捕获这个异常，Python解释器会直接退出；
                 捕获这个异常可以做一些额外的清理工作。
                 0为正常退出，其他数值（1-127）为不正常，可抛异常事件供捕获。

 3) exit()       跟 C 语言等其他语言的 exit() 应该是一样的。
    os._exit()   调用 C 语言的 _exit() 函数。

    os._exit()   用于在线程中退出
    sys.exit()   用于在主线程中退出。

exit()