1.异常

# try:
#     num = int(input("请输入数字："))
#     print('hello')# ValueError: invalid literal for int() with base 10: 'AAA'
# except:
#     print("请输入正确的整数")
#
#
# try:
#     num = int(input("请输入数字："))
#     print('hello')# ValueError: invalid literal for int() with base 10: 'AAA'
# except ValueError:
#     print("请输入正确的整数")

try:
    num = int(input("请输入数字："))
    print('hello') # ValueError: invalid literal for int() with base 10: 'AAA'
    a=10/0 #ZeroDivisionError: division by zero
    print(a)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除数不能为0")
except Exception as result:
    print("未知错误 %s" % result)
finally:
    # 无论是否有异常，都会执行的代码
    print("无论是否有异常，都会执行的代码")
#python 与java中异常部分不同的地方 python中多了一个else 及 当正常执行时 运行else
try:
    num = int(input("请输入整数："))
    result = 8 / num
    print(result)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除 0 错误")
except Exception as result:
    print("未知错误 %s" % result)
else:
    print("正常执行")
finally:
    print("执行完成，但是不保证正确")



def demo1():
    return int(input("请输入一个整数："))
def demo2():
    return demo1()

# print(demo2())
# try:
#     print(demo2())
# except ValueError:
#     print("请输入正确的整数")
# except Exception as result:
#     print("未知错误 %s" % result)

def input_password():

    # 1\. 提示用户输入密码
    pwd = input("请输入密码：")

    # 2\. 判断密码长度，如果长度 >= 8，返回用户输入的密码
    if len(pwd) >= 8:
        return pwd

    # 3\. 密码长度不够，需要抛出异常
    # 1> 创建异常对象 - 使用异常的错误信息字符串作为参数
    ex = Exception("密码长度不够")

    # 2> 抛出异常对象
    raise ex

try:
    user_pwd = input_password()
    # print(user_pwd)
except Exception as result:
    print("发现错误：%s" % result)

class MyException(Exception):                   #让MyException类继承Exception
    def __init__(self,name,age):
        self.name = name
        self.age = age
try:
    #知识点：主动抛出异常，就是实例化一个异常类
    raise MyException("zhansgan",19)            #实例化一个异常,实例化的时候需要传参数
except MyException as obj:                      #这里体现一个封装，
    print(obj.age,obj.name)                     #捕获的就是MyException类携带过来的信息

except Exception as obj:                        #万能捕获，之前的可能捕获不到，这里添加Exception作为保底
    print(obj)

2 io读写

bytes = '张三'.encode()
print(bytes)
print(type(bytes))
bytes = '张三'.encode('utf-8')
print(bytes)
print(type(bytes))
bytes = '张三'.encode('gbk')
print(bytes)
print(type(bytes))


bytes = b'\xe5\xbc\xa0\xe4\xb8\x89'
msg1 = bytes.decode()
print(msg1)
print(type(msg1))

msg1 = bytes.decode('utf-8')
print(msg1)
print(type(msg1))

msg1 = bytes.decode('gbk')
print(msg1)
print(type(msg1))


file=open("hello2.txt",encoding='utf-8')
print(file)
text=file.read()
print(text)
file.close()


# 打开文件
f = open("abc.txt", "w",encoding='utf-8')
print(f)
f.write("hello neuedu！\n")
f.write("今天天气真好")

# 关闭文件
f.close()


file=open("D:\\iotest\\nihao.txt")
print(file)
text=file.read()
print(text)
file.close()


# 打开文件
# r 表示对字符串里的转义符不进行转义，写的是什么就是什么
f = open(r"D:\iotest\nihao.txt", "a")
# f = open("D:\\iotest\\nihao.txt", "a")
print(f)
f.write("hello neuedu！\n")
f.write("今天天气真好")

# 关闭文件
f.close()



# read([size])方法 read([size])方法从文件当前位置起读取size个字节，若无参数size，
# 则表示读取至文件结束为止，它的返回值为字符串对象
f = open("a.txt",encoding='utf-8')
lines = f.read()
print(lines)
print(type(lines))
f.close()

# 2.readline()方法 从字面意思可以看出，该方法每次读出一行内容，
# 所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
f = open("a.txt",encoding='utf-8')
line = f.readline()
print(type(line))
while line:
    print(line)
    line = f.readline()
f.close()
# 3.readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，
# 每行作为一个元素，但读取大文件会比较占内存。
f = open("a.txt",encoding='utf-8')
lines = f.readlines()
print(type(lines))
# for line in lines:
print(lines)
f.close()


# 4.最简单、最快速的逐行处理文本的方法：直接for循环文件对象
f = open("a.txt",encoding='utf-8')
for line in f:
 print(line+"*")
f.close()

# io 处理与java一样的地方是使用了 finally 来关闭close
#与java不同是 python多了with语法 更简洁
try:
    f = open('a.txt', 'r',encoding='utf-8')
    print(f.read())
finally:
    if f:
        f.close()

# with语法
# with和前面的try ... finally是一样的，但是代码更加简洁，并且不必调用f.close()方法
with open('a.txt', 'r',encoding='utf-8') as f:
    print(f.read())


with open(r'rrf.txt','rb')as f:
    f.readlines()
    f.seek(6,0)    #从开头移动6个字节
    print(f.tell())
    print(f.readline().decode())
    # f.tell()函数可以得到当前文件指针的位置
    print(f.tell() )

with open(r'rrf.txt', 'rb')as f:
    print(f.tell())
    print(f.readline().decode())
    f.seek(9,1)   #从当前指针位置移动9个字节
    print(f.readline() .decode() )

with open(r'rrf.txt', 'rb')as f:
    f.seek(-5,2)                    #指针在末尾，往前读5个字节
    print(f.read() .decode() )
    print(f.tell())



# with open(r'D:\pic\a1.jpg', 'rb')as f:
#     print(f.read())

with open('a.txt', 'r+') as f1:
    print(f1)
    print(type(f1))



f1 = open(r'D:\pic\a1.jpg', mode='rb')
content = f1.read()
f1.close()
# print(content)

f2 = open(r'D:\pic\b1.jpg', mode='wb')
f2.write(content)
f2.close()

# w,r,wt,rt都是python里面文件操作的模式。
# w是写模式，r是读模式。
# t是windows平台特有的所谓text mode(文本模式）,区别在于会自动识别windows平台的换行符。
# 类Unix平台的换行符是\n，而windows平台用的是\r\n两个ASCII字符来表示换行，python内部采用的是\n来表示换行符。
# rt模式下，python在读取文本时会自动把\r\n转换成\n.
#wt模式下，Python写文件时会用\r\n来表示换行。

3.引如模块 与 引入包

方式一：import 模块名
使用时：模块名.函数名()

import module1
module1.output()

方式二 :from 模块名 import 函数名
使用时：函数名()

from module1 import output
output()

1.2.3. 方式三: from 模块名 import *
使用时：函数名()

from module1 import *
output()

1.2.4. 方式四:from 模块名 import 函数名 as tt(自定义)
注意原来的函数名将失效

使用时：tt()

from module1 import output as tt
tt()

可以在模块当中定义一个变量all，指定导出的函数子集：

使用all的影响: 后面的[]里面写什么函数名，使用from 模块名 import 方式导入时导入什么 all如果没有这个变量将全部导入(all仅限 于from 模块名 import 这种导入方式)

加all示例：

__all__=['output']
def output():
    print('hello neuedu')

def output2():
        print('hello output2')

以下代码报错

from module1 import *
output2()

python中模块引入的 all 使用
python模块中的all，用于模块导入时限制，如：from module import *
此时被导入模块若定义了all属性，则只有all内指定的属性、方法、类可被导入；若没定义，则导入模块内的所有公有属性，方法和类。

1.实例1

#bb.py
class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class B():
    def __init__(self,name,id):
        self.name=name
        self.id=id
def fun():
    print("func() is run!")
def fun1():
    print("func1() is run!")

#test_bb 
from bb import *
a=A('zhansan','18')
print(a.name,a.age)
b=B("lisi",1001)
print(b.name,b.id)
fun()
fun1()

运行结果：
zhansan 18
lisi 1001
func() is run!
func1() is run!
注：
由于bb.py中没有定义all属性，所以导入了bb.py中所有的公有属性

实例2

#bb1.py
__all__=('A','func')
class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class B():
    def __init__(self,name,id):
        self.name=name
        self.id=id
def func():
    print("func() is run!")
def func1():
    print("func1() is run!")

#test_bb 
from bb1 import *
a=A('zhansan','18')
print(a.name,a.age)
func()
# b=B("lisi",1001)#NameError: name 'B' is not defined
# func1()#NameError: name 'func1' is not defined

结果
运行结果：
zhansan 18
func() is run!

注：
　　由于bb.py中使用了all=('A','func')，所以在别的模块导入该模块时，只能导入all中的变量、方法、类

实例3

#bb2.py
def func(): #模块中的public方法
    print('func() is run!')
def _func(): #模块中的protected方法
    print('_func() is run!')
def __func(): #模块中的private方法
    print('__func() is run!')

#testbb.py
from bb2 import *  #此方式只能导入公有的属性、方法、类【无法导入以单下划线开头（protected）或以双下划线开头(private)的属性、方法、类】
func()
# _func()
# __func()

运行结果：
func() is run!

注：
　　from bb import * --此方式只能导入公有的属性、方法、类【无法导入以单下划线开头（protected）或以双下划线开头(private)的属性、方法、类】
　　_func() #NameError: name '_func' is not defined
　　__func() #NameError: name '__func' is not defined

4.实例4

#bb3.py
__all__=('func','__func','_A')#放入__all__中所有属性均可导入，即使是以下划线开头
class _A():
    def __init__(self,name):
        self.name=name
def func():
    print("func() is run!")
def func1():
    print("func1() is run!")
def _func():
    print("_func() is run!")
def __func():
    print("__func() is run!")

from bb3 import *
func()
# func1()#func1不在__all__中，无法导入 NameError: name 'func1' is not defined
# _func()#_func不在__all__中，无法导入 nameError: name '_func' is not defined
__func()#__func在__all__中，可以导入
a=_A('zhangsan')#_A在__all中，可以导入
print(a.name)

结果：
func() is run!
__func() is run!
zhangsan
注：
　　放入__all中所有属性可导入，即使是以下划线开头
　　func1() #func1不在all中，无法导入NameError: name 'func1' is not defined
　　_func() #_func不在all中，无法导入NameError: name '_func' is not defined
　　__func() #__func在all中，可以导入
　　a=_A('python') #_A在all中，可以导入
实例五

#bb4.py
def func():
    print('func() is run!')
def _func():
    print('_func() is run!')
def __func():
    print('__func() is run!')

#test_bb.py
from bb4 import func,_func,__func#可以通过这种方式导入public，protected,private
func()
_func()
__func()

运行结果：
func() is run!
_func() is run!
__func() is run!

注：
　　虽然_func()、__func()属于"protected,private"权限的，但是如果使用该方式，是可以直接导入访问的

#test_bb.py
import bb4 #可以通过这种方式导入public，protected,private
bb4.func()
bb4._func()
bb4.__func()

运行结果：
func() is run!
_func() is run!
__func() is run!

注：
　　可以通过import模块的方式导入模块，然后使用模块.XX的方式访问"public,protected,private"权限的内容

导入包

package路径

#person.py
class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say(self):
        print(f"我的名字是{self.name} 年龄为 {self.age}")
    

导入包中函数，以及模块的方式
方式一：from 包名 import 模块名
使用时：模块名.函数名()

from neuedu import module3
module3.output()

方式二：from 包名.模块名 import 函数名
使用时：函数名()

from neuedu.module3 import output
output()

1.4.3. 方式三 ：import 包名.模块名
使用的时候 包名.模块名.函数名()

import neuedu.module3
neuedu.module3.output()

1.4.4. 方式四：from 包名 import *
前提是：将 init.py 文件中写入all变量(写入方式同模块导入的写入方式) 。 变量当中写入哪个模块则导入哪个模块，不写则什么都不导入 使用时：模块名.函数名() init.py

__all__ = ['module3']
from neuedu import *
module3.output()

1.4.5. 方式五：import 包名
前提是：在包里面的init.py 文件里写入 from . import 模块名 init.py里面导入哪个模块 通过本方式就能使用哪个模块
使用时：包名.模块名.函数名() init.py

from . import module3
import neuedu
neuedu.module3.output()

#__init__.py
#方法一
# from pack1 import *
# from pack1 import person
#方法二
__all__ = ["person"]

# __all__ = ["mod2", "mod3", "sub"]

包外：

testaa.py
from pack1 import person
p1=person.Person("tom",19)
p1.say()

#时间函数
import time
print(time.time())
print(time.localtime())
print(time.strftime("%Y-%m-%d %H:%M:%S"))
print(time.localtime())
print(time.localtime().tm_year)
"""
DST 是daylight saving time, 意思是：夏令时
在python的time, datetime模块下，按照struct_time格式输出时间，最后的一个tm_isdst的值就是告知是否为夏令时。
tm_isdst = 1 的时候表示时间是夏令时，
　　　　值为0的时候表示非夏令时
　　　　值为-1的时候表示时间不确定是否是夏令时 
"""
# time-->str
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

#str-->time
timestruct=time.strptime("2019-07-16 20:03:52","%Y-%m-%d %H:%M:%S")
print(timestruct.tm_year)

print(type(time.strptime("2019-07-16 20:03:52","%Y-%m-%d %H:%M:%S")))
print(time.strptime("2019-07-16 20:03:52","%Y-%m-%d %H:%M:%S"))

#datatime 日期+时间类型

# 有两种日期和时间的对象：天真型和觉悟型。觉悟型对象有着用足以支持一些应用层面算法和国家层面时间调整的信息，
#觉悟型
# 例如时区和夏令时，来让自己和其他的觉悟型对象区别开来。觉悟型对象是用来表达不对解释器开放的特定时间信息 1。
#天真型
# 天真型对象没包含足够多的信息来明确定位与之相关的 "date"对象和"time"对象。天真型对象代表的是 世界标准时间(UTC),
# 当地时间或者是其它时区的时间完全取决于程序就像一个数字是代表的是米、英里或者质量完全取决于程序。
# 天真型对象以忽略了一些现实情况的为代价使得它容易理解和使用。

#4常用模块
import datetime
# 日期
print(datetime.date(year=2019,month=12,day=31))
# 时间
print(datetime.time(hour=15,minute=18,second=11))
# 日期+时间
print(datetime.datetime(year=2019,month=12,day=31,hour=15,minute=18,second=11))
adatetime=datetime.datetime(year=2019,month=12,day=31,hour=15,minute=18,second=11)
# 时间间隔 使用加减
print(datetime.timedelta(days=10))
print(adatetime+datetime.timedelta(days=10))
# 时区
print(datetime.timezone.utc)
print(datetime.datetime.now(datetime.timezone.utc))
# 获得当前时间
print(datetime.datetime.today())
print(datetime.datetime.now())
print(datetime.datetime(2018, 7, 2, 15, 5, 17, 127663))
# 时间戳---》时间
print(datetime.datetime.fromtimestamp(1530515475.18224))
print(type(datetime.datetime.fromtimestamp(1530515475.18224)))
#时间---》时间戳(float)
print(datetime.datetime.now().timestamp())
print(type(datetime.datetime.now().timestamp()))
#datetime.replace(year=self.year, month=self.month, day=self.day,
# hour=self.hour, minute=self.minute, second=self.second,
# microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)
#替换datetime对象的指定数据。
print(datetime.datetime.now().replace(year=2018))
# 0为星期一
print(datetime.datetime.now().weekday())
#目录操作

#获得当前操作目录
import sys
print(sys.path[0])
print(sys.path)

import os
print(os.getcwd())
print(os.path.join('/Users/pangao', 'test.txt'))
print(os.path.split('/Users/pangao/test.txt'))
print(os.path.splitext('/Users/pangao/test.txt'))
# os.rename('test.txt', 'testa.py')  #重命名
# os.remove('testa.py')   #删除
# 复制文件
import shutil
shutil.copyfile('test.txt', 'testa.py')

print(os.listdir('./'))
for filename in os.listdir('./'):
    print(filename)
print( os.walk('./'))
# fpathe父路径  dirs当前文件下的所有文件夹名  fs当前文件夹下的所有文件名
for fpathe, dirs, fs in os.walk('./'):
    print("fpathe*"+str(fpathe))
    print("dirs*"+str(dirs))
    print("fs*"+str(fs))

    # for f in fs:
        #打印路径及文件夹名
        # print(os.path.join(fpathe, f))

  #os.path.isfile('test.txt') # 如果不存在就返回False
print(os.path.isfile('test.txt') ) # 如果不存在就返回False
print(os.path.exists('test.txt')) #如果目录不存在就返回False



# 随机数模块
import random
random.randint(0, 10)
# random.random()：返回０到１之间随机数（不包括1）;
random.random()

# random.choice(seq)：在不为空的序列中随机选择一个元素；
s = 'helloWorld'
random.choice(s)
# random.sample(population, k)：在一个序列或者集合中选择k个随机元素()，返回由K个元素组成新的列表；（k的值小于population的长度）
print(random.sample('12345', 2))
['1', '2']
# random.uniform(a, b)
# 返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a 。
print(random.uniform(1,10))
# random.randrange(start, stop=None, step=1, _int=) ：在rang(start, stop,step)中选择一个随机数;
print(random.randrange(1, 10, 1))   #[1,10)之间随机整数
# l = ['C', 'C++', 'Java', 'C#', 'Python']
#random.shuffle(x, random=None)：将列表顺序打乱；

# Collections
# 该模块实现了专门的容器数据类型，为Python的通用内置容器提供了替代方案。 以下几种类型用的很多：
# defaultdict (dict子类调用工厂函数来提供缺失值)
# counter (用于计算可哈希对象的dict子类)
# deque (类似于列表的容器，可以从两端操作)
# namedtuple (用于创建具有命名字段的tuple子类的工厂函数)
# OrderedDict (记录输入顺序的dict)

person = {'name':'xiaobai','age':18}
print ("The value of key  'name' is : ",person['name'])
# print ("The value of key  'city' is : ",person['city'])



# 其实最根本的原因在于当创建defaultdict时，首先传递的参数是所有key的默认value值，
# 之后添加name，age进去的时候才会有所改变，当最终查询时，如果key存在，那就输出对应的value值，
# 如果不存在，就会输出事先规定好的值‘Key Not Found’
from collections import defaultdict
person = defaultdict(lambda : 'Key Not found') # 初始默认所有key对应的value均为‘Key Not Found’
person['name'] = 'xiaobai'
person['age'] = 18
print ("The value of key  'name' is : ",person['name'])
print ("The value of key  'adress' is : ",person['city'])
# 一个道理，默认所有key对应的是一个list，自然就可以在赋值时使用list的append方法了
from collections import defaultdict
d = defaultdict(list)
d['person'].append("xiaobai")
d['city'].append("paris")
d['person'].append("student")

for i in d.items():
    print(i)

# Counter是dict的子类。因此，它是一个无序集合，其中元素及其各自的计数存储为字典。
# 就是一个计数器，一个字典，key就是出现的元素，value就是该元素出现的次数

from collections import Counter

count_list = Counter(['B','B','A','B','C','A','B','B','A','C'])  #计数list
print (count_list)


count_tuple = Counter((2,2,2,3,1,3,1,1,1))  #计数tuple
print(count_tuple)

# 在需要在容器两端的更快的添加和移除元素的情况下，可以使用deque.
# deque就是一个可以两头操作的容器，类似list但比列表速度更快
from collections import deque
d = deque()
d.append(1)
d.append(2)
d.append(3)

print(len(d))
print(d[0])
print(d[-1])
# deque最大的特点在于可以从两端操作：
d = deque([i for i in range(5)])
print(len(d))
# Output: 5

d.popleft()   # 删除并返回最左端的元素
# Output: 0

d.pop()       # 删除并返回最右端的元素
# Output: 4

print(d)
# Output: deque([1, 2, 3])

d.append(100)  # 从最右端添加元素

d.appendleft(-100) # 从最左端添加元素

print(d)
# Output: deque([-100, 1, 2, 3, 100])

# 首先定义一个deque时可以规定它的最大长度，deque和list一样也支持extend方法，方便列表拼接，但是deque提供双向操作：
# 现在d已经有9个元素了，而规定的maxlen=9，这个时候如果从左边添加元素，会自动移除最右边的元素，反之也是一样：
from collections import deque
d = deque([1,2,3,4,5], maxlen=9)  #设置总长度不变
d.extendleft([0])  # 从左端添加一个list
d.extend([6,7,8])   # 从右端拓展一个list
print(d)
d.append(100)
print(d)
d.appendleft(-100)
print(d)
# namedtuple
# 命名元组。大家一看名字就会和tuple元组有关，没错，它是元组的强化版。namedtuple可以将元组转换为方便的容器。
# 使用namedtuple，不必使用整数索引来访问元组的成员。觉得可以把namedtuple 视为 不可变的 字典
person = ('xiaobai', 18)
print(person)

from collections import namedtuple

Person = namedtuple('Person', 'name age city')        # 类似于定义class
xiaobai = Person(name="xiaobai", age=18, city="paris") # 类似于新建对象
print(xiaobai)
print(xiaobai.name)
print(xiaobai.age)
print(xiaobai.city)

# 这种无限接近class调用属性的方式还是非常不错的，在一些实际场景很有用。 最后还有一点千万不要忘了，不能修改namedtuple里的值：


# OrderedDict
# “OrderedDict” 本身就是一个dict，但是它的特别之处在于会记录插入dict的key和value的顺序
from collections import OrderedDict
d = {}
d['a'] = 1
d['b'] = 2
d['c'] = 3
d['d'] = 4
print(d)

d = OrderedDict()
d['a'] = 1
d['b'] = 2
d['c'] = 3
d['d'] = 4
print(d)

"""
python中的序列化与反序列化
"""
import pickle
#dumps
li = [11,22,33]
r = pickle.dumps(li)
print(r)


#loads
result = pickle.loads(r)
print(result)


#dump：
import pickle

li = [11,22,33]
print(open('db','wb'))
pickle.dump(li,open('db','wb'))

#load
ret = pickle.load(open('db','rb'))
print(ret)

# 创建对象将对象放到外存中，在反序列化回来
class AA:

    def say(self):
        print("aaaa")
a1=AA()
a1.say()

import pickle
pickle.dump(a1,open("a.txt","wb"))

aa=pickle.load(open("a.txt","rb"))
aa.say()