#coding : utf-8
'''
python的特点:  有高级数据结构
            数据和逻辑相分离的结构化和过程化
            提供基本模块
        数字显示: 0o 8进制
                0x  16进制
                0b   2进制
        可变类型: 列表,字典
        不可变类型: 数值 字符串 元祖

        (列表或迭代器)
        for iter_var in iterable:
            suite_to_repeat

        range(start,end,step=1)

        with open('foo.py') as f:
            data = f.datalines()

        模块导入的特性
        模块具有一个_name_特殊属性
        当模块文件直接执行时,_name_的值为 '_main_'
        当模块被另一个文件导入时,_name_的值为改模块的名字


        shutil.copyfileobj(fsrc,fdes[,length])
        将类似文件的对象fsrc的内容复制到类是文件对象fdst

        list(iter)  将可迭代对象转化为列表
        str(obj) 将obj对象转化为字符串
        tuple(iter)  把一个可迭代的对象转化为元祖

        alist = ['hello','world','heh','hh']
        #enumerate  枚举
        for i,j in enumerate(alist):
            print('index %d: %-s'%(i,j))

        format函数:
        print("my name is {},age{}".format('selen',18))
        使用关键字参数:

        通过{} 操作符创建字典
        通过dict()工厂方法创建字典
        通过fromkeys()创建具有相同的默认值的字典

        adict = {}.fromkeys(('bob', 'alice'), 23)

        for each_key in adict:
             print('key = %s,value = %s' % (each_key, adict[each_key]))


        from random import randint
        with open("./wangke.py",mode="r") as f:
            data = f.read()
            data1 = f.readlines()
        print(data1)

        str1=[]
        for i in range(10):
        num =randint(1,10);
        str1.append(num)

#print("my name is {name},age is {age}".format({"name":'selen',"age":30}))
import time
winpath = '/home/linux'
print(winpath)
newpath = r'/home/linux'
print(newpath)
adict = {}.fromkeys(('bob', 'alice'), 23)
print('%(bob)s'%adict)


adict['eamil'] = '[email protected]'
adict.pop('bob')
print(adict)
#返回列表 items
tu=adict.items()
print(type(tu))

import time
import datetime

print(time.localtime())
print(time.gmtime().tm_yday)
print(time.time())
dt=datetime.datetime.now()
days = datetime.timedelta(days = 100,hours = 3)
dd = dt+days
print(dd)
当python 检测到一个错误是,解释器就会指出当前流已经无法继续执行下去,这时候就会抛出异常
NameError  为声明/初始化
IndexErro 序列中没有此索引
SyntaxError 语法错误
IOError 输入输出错误




try:
    data = int(input('inut a number:'))
except KeyboardInterrupt:
    print('user cancelled')
except ValueError as e:
    print('you must input a number!',e)

pikle模块方法:
分别调用dump()和load()可以存储,写入


import pickle as p

shoplistfile = 'shoplist.data'
shoplist = ['apple','mango','carrot']
#file 返回一个文件对象
f = open(shoplistfile,'wb')
#把列表写入文件
p.dump(shoplist,f)

f.close()

f=open(shoplistfile,'rb')
#p 是一个模块,一个类  有一个方法load 返回一个list

storedlist = p.load(f)
print(storedlist)

内部函数:

def foo():
    def bar():
        print("bar() is called")
    print('foo() is called')
    #只能在内部调用
    bar()

#关键字参数允许参数缺失
def get_info(name,age):
    print("%s's age is %s"%(name,age))
get_info('bob',23)

#python 允许程序员执行一个没有显示定义参数的函数
#通过一个把元祖(非关键字参数)或字典(关键字参数)作为参数传递给函数
#func(*tuple_grp_nonkw_args,**dict_grp_kw_args)


#允许用lambda关键字创造匿名函数
#lambda [arg1[,arg2,...argN]:expression]

a = lambda x,y : x+y
print(type(a),a(3,4))

#filter(func,seq)；调用一个布尔函数func 来迭代遍历每个序列中的元素;返回一个使func返回为真的序列
data= filter(lambda x: x%2,[num for num in range(10)])
print(data)

#全局变量 作用域整个模块 局部变量作用域 函数内部
#名字空间 任何时候都有一个到三个的作用域(内建,全局,局部)
#偏函数是将函数编程式的概念和默认参数以可变参数结合在一起
#一个带有多参数的函数,如果其中某些参数基本上是固定的那么就可以通过偏函数为这些参数赋默认值

from operator import add
from functools import partial

add = partial(add,10)
print(add(25))

#递归函数  包含了对自身的调用  查看目录内的所有文件
def func(num):
    if num ==1:
        return 1
    else:
        return num*func(num-1)
#生成器  是一个带yield语句的函数  能返回一个中间结果
#yeild 语句返回一个只给调用者并暂停执行
#next 方法被调用时,他会准确的离开地方继续

def simp_gen():
    yield '1'
    yield '2->punch'
mygen = simp_gen()
#  发生器
print(type(mygen))

#闭包 将内部函数自己代码和作用域以及外部的函数作用结合起来
#闭包的词法变量不属于全局名字空间域或则局部的,而属于其他名字空间
#闭包对于安装计算,隐藏状态,以及在函数对象和作用域中随一切环视很有用
#闭包也是函数,但是他们能携带一些额外的作用域
def conuter(start =0):
    count = start
    def incr():
        nonlocal count
        count +=1
        return count
    return incr
#返回一个函数
a = conuter()
b = conuter(10)

print(type(a))
print(b())
#装饰器 是在函数调用之上的修饰
#这些函数是当声明一个函数或者方法的时候才会调用,
#装饰器的情形有:  引入日志  增加计时逻辑 来检测 给函数加入事务能力

#模块和文件
#名字空间就是一个从名陈到对象的关系映射集合

#搜索路径;sys.path中定义

import sys
print(sys.path)

#包是一个有层次的文件目录结构,是有联系的模块组合在一起 必须有一个__init__.py文件
#import 总是绝对导入  from--import相对导入
#内置模块
import hashlib
m = hashlib.n
print(m)

#print(m.hexdigest())

#可以在一个大的类中创建其他类的实例,实现一些其他属性和方法来增强对原来的类的对象
#类是蓝图,实例是根据蓝图创建出来的具体对象
#一个类是另一个类的组件
'''
class Manufacture:
    def __init__(self,phone,email):
        self.phone = phone
        self.email = email
    def printf(self):
        print(self.phone,self.email)
class Beartoy:
    def __init__(self,size,color,phone,email):
        self.size = size
        self.color = color
        self.vendor = Manufacture(phone,email)
    def printf(self):
        print(self.size,self.color,end = ' ')
        self.vendor.printf()
if __name__=='__main__':
    b=Beartoy(33,'red',120,444)
    b.printf()


#通过类继承覆盖方法