Py基础及应用

相关注意、深入、使用及应用

# -*- coding: utf-8 -*-
'''
Py基础及应用.py


深入：
一、递归
二、装饰器

'''


# =============================================================================
# #此公司方  经营情况  提取方式 
# =============================================================================
'''
#按照 x分类的分类格式，将 z内容 分割成 y数量 的newlist，然后输出 str内容。
#使用：
#一、通过字符串方法 ''.join() 对 字符串列表list 迭代后进行连接转换操作，join只能连接字符串。 
也可以通过 .replace('','') 对字典的 key名称进行修改替换操作。strip()去除前后空格等。
'''

x=['行业','产品','地区']
y=[2,3,2]
z=['x1','x2','x3','x4','x5','x6','x7']

#创建 空list，然后 .append()追加进内容，形成相关 newlist
newy=[]
a=0
newz=[]
i=0    
for j in range(0,len(x)):   
    a=a+y[j]
    newy.append(a)
      
    zz=z[i:newy[j]]    
    i=newy[j]    
    newz.append(zz)  
print(newy)
print(newz)

#创建 空dict，然后 通过 key=value 形式for循环赋值，形成 数据dict
dt={}
for rx,rz in zip(x,newz):
    dt[rx]=','.join(rz)                      #通过字符串方法 ''.join() 对 list 迭代后进行连接转换操作。 也可以通过 .replace('','') 对字典的 key名称进行修改替换操作。
print(dt) 
print('产品:',dt['产品'])                     #通过 dict[key 输出相关 value值

一、数据结构

1.1字符串

# =============================================================================
# #字符串
# =============================================================================

#print语句参数
print('hello','word',sep='-')                #sep参数  自定义print多个语句时分隔符，默认为 空格
print('hello','world!',end='a')              #end参数  自定义结束字符串  默认为 换行符



#字符串格式化输出显示  format()
'''
#字符串格式化输出显示  format()
format替换字段  默认的三种方式
1、{}.format();
2、{0}.format();
3、{a}.format(a='K')

宽度、精度:    {a:10}.format(a='K')  其中的冒号：后面代表设置格式；整数部分代表宽度，小数点后面代表浮点数的小数位数。
符号、对其、填充 ：在指定宽度前可添加符号+代表正数，负数不影响以及其他符号。其中符号<、^、>分别代表左对齐、居中、右对齐，=号代表分离符号和数字之间，其他则代表填充内容。
'''

#width=int(input('输入要设置的宽度: '))
width=35

price_width=10
item_width=width-price_width

header_fmt='{{:{}}}{{:>{}}}' .format(item_width,price_width)
fmt       ='{{:{}}}{{:>+{}.2f}}' .format(item_width,price_width)

print(header_fmt)                            #运行输出 {:25}  {:>10} 用来指定宽度、格式
print(fmt)                                   #运行输出 {:25}  {:>10.2f}  用来指定宽度、格式、小数点

print('='*width)                             #输出=号  数量为Width宽度
print(header_fmt.format('Item','Price'))     #输出两个字符串，一个左对齐 且 宽度为item_width，一个右对齐 且 宽度为Price_width   
print('-'*width)                             #输出-号  数量为width宽度

print(fmt.format('Apple',-0.4))
print(fmt.format('Pears',0.5))
print(fmt.format('Cantaloupes',1.92))
print(fmt.format('Dried Apricots(16 oz.)',8))
print(fmt.format('Prunes(4 lbs.)',12))

print('='*width)

1.2字典和集合

# =============================================================================
# #字典 和 集合
# #dict字典 和 set集合： 都是无序。不同在于set集合有去重机制，且只有键没有值。
# =============================================================================

#字典的格式化设置应用 format_map() 及 个别字典方法
#字符串格式化设置  字典应用 format_map()
phonebook={'Beth':'9102','Alice':'2341','Ceil':'3258'}
print('Cell\'s number is {Ceil}'.format_map(phonebook))

#字典方法
d1=dict.fromkeys(['key1','key2'],'value')        #fromkeys方法 创建一个字典  指定键名、统一value
d2={}.fromkeys(('key3','key4'))

print(d1.get('key9'))                            #get方法 查找数据  找不到返回None
print(d1.get('key9','找不到就返回指定值'))        #get方法 查找数据  找不到返回指定值

d1.setdefault('key11','找不到则添加并指定值')     #setdefault方法 查找键名，若无则添加更新键值对

1.3列表和元组

# =============================================================================
# #列表 和 元组
# #list列表 和 tuple元组：都是序列类型，可迭代、可索引、可添加；不同在于tuple元组不可修改。
# =============================================================================

#字符串列表  指定内容合并成为 字符串
'+'.join(['1','2','3'])                         #合并一个字符串列表，相反与 split()

#extend()方法 末尾拼接
a1=[1,2,3]
b1=4,5,6
a1.extend(b1)                                   #extend()方法  添加多个数据到列表末尾

#排序
x=[1,2,3]
x.reverse()                                     #reverse()  反向排序 就地排序修改
x.sort()                                        #sort()  正向排序 就地修改

二、条件、循环及其他语句

2.1条件、循环、并行迭代、推导式（字典推导式、列表推导式）

# =============================================================================
# #条件、循环及其他语句
# =============================================================================

#序列解包  可用*号来手机多余的值
a,b,*test=1,2,3,4,5,6                            #可用*星号来收集多余的值
c,*middle,d=7,8,9,10,11,12
print(test)
print(middle)


#bool布尔值 
e=True + False + 42
print(e)


#循环
#for循环、while循环
#break     跳出循环
#continue  结束本次循环

#name=''
#while  not name or name.isspace():              #如果为假 或者 空格，则继续循环
#    name=input('Please enter your name: ')
#print('hello,{}...'.format(name))


#内置函数 enumerate()生成可迭代的 索引-值 对。
strings=['adsfa','fdfdf','33rsfa','efwee']
for index,string in enumerate(strings):
    if '33' in string:
        strings[index]=['censored']
     

#并行迭代
names=['anne','beth','george','damon']
ages=[12,34,53,129]

for name,age in zip(names,ages):
    print(name,'is',age,'years old')

list(zip(names,ages))
dict(zip(names,ages))



#推导式 x for x in xs
#列表推导式  列表结构，可多个迭代，可后面添加条件判断。  
#注意：[]列表推导式形式，()却不是元祖推导式 而是一个生成器yield，关于生成器yield，可用内置函数 next()来进行迭代作用。

#将首字母相同的boy与girl配对
girls=['blice','aernice','clarice']
boys=['chris','arnold','bob']
bg=[b + ' + ' + g for b in boys for g in girls if b[0]==g[0]]
print(bg)

#将首字母相同的boy与girl配对，效率更高的方式
letterGirls={}
for girl in girls:
    letterGirls.setdefault(girl[0],[])                           #循环设置字典内容，返回的是一个空列表
    letterGirls.setdefault(girl[0],[]).append(girl)              #在空列表里追加 girl
print([b+ ' + ' +g for b in boys for g in letterGirls[b[0]]])    #注意这里是列表形式
    


#字典推导式
#注意：在字典推导式中 for前面有两个用冒号分割的表达式，分别对应键及值。而列表推导式中for前面只有一个表达式。
squares={i:'{} squared is {}'.format(i,i**2) for i in range(10)}
print(squares)
print(squares[8])

2.2语句（exec及eval）、断言assert

#语句
#exec()将字符串作为代码执行
#eval()类同于exec()，但只计算字符串表达式的值
from math import sqrt
scope={}
exec('sqrt=1',scope)                             #注意作用域 参数1位字符串，参数2为作用空间。
print(scope['sqrt'])

scope['x']=2
scope['y']=3
eval('x*y',scope)                                #同样注意作用域，否则一样会重写覆盖变量或代码



#断言
#age=-1
#assert 0<age<100,'age数值不在范围0-100以内'      #断言，可添加说明

三、函数

3.1函数结构、文档、帮助

# =============================================================================
# #函数
# #函数 编写文档、查看文档、帮助
# #函数是 一段代码 的封装
# =============================================================================

help(函数名)
函数名.__doc__ 用来查看函数文档

3.2函数实例（斐波那契函数、二分递归函数等）

3.2.1斐波那契函数

#斐波那契函数
def fibs(num):
    '''
    这里是函数文档，斐波那契函数，参数是len。
    可使用 函数名.__doc__ 来查看文档
    或使用内置函数 help(函数名) 来查看函数帮助文档
    '''
    result=[0,1]
    for i in range(num-2):
        result.append(result[-2]+result[-1])
    return result
print(fibs.__doc__)           #注意编写函数文档的位置   可使用 函数名.__doc__ 来查看文档 
help(fibs)                    #或使用内置函数 help(函数名) 来查看函数帮助文档



#参数  位置参数、关键字参数、收集参数（*元组参数、**字典参数）
#收集参数 在 进行参数调用时候就成了 分配参数，实质就是 元组参数 和 字典参数
def print_params(x,y,z=3,*pospar,**keypar):
    '''
    x,y是位置参数；z是关键字参数；*是元组参数；**是字典参数
    '''
    print(x,y,z)
    print(pospar)
    print(keypar)
print_params(1,2,3,5,6,7,foo=1,bar=2)

3.2.2函数组合，编写一个程序，用来存储姓名，并让用户能够根据名字、中间名、姓来进行找人

#函数组合，编写一个程序，用来存储姓名，并让用户能够根据名字、中间名或姓来找人
def init(data):
    '''先初始化数据结构'''
    data['first']={}
    data['middle']={}
    data['last']={}

def lookup(data,label,name):
    '''获取人员姓名的函数'''
    return data[label].get(name)                     #get方法，有则返回数据，无则返回None

def store(data,*full_names):                         #此处运用*元组参数
    '''将人员存储到数据结构中的函数'''
    for full_name in full_names:                     #遍历实例的多个元组参数
        names=full_name.split()                      #将全名按照空格分隔
        if len(names)==2: names.insert(1,'')         #如果没有中间名，则插入''代替
        labels='first','middle','last'               #指定 姓、中间名、名
        for label,name in zip(labels,names):         #并行迭代
            people=lookup(data,label,name) 
            if people:                               #如果能获取到人员姓名，则在后面追加进去全名
                people.append(full_name)
            else:
                data[label][name]=[full_name]        #如果没有获取到人员姓名，则新添加 各个键值对。
d={}
init(d)
store(d,'张 小 盘','张 灯')
print(lookup(d,'first','张'))
print(lookup(d,'middle',''))
print(d)                                             #打印整个数据字典，可有轮廓概念

3.2.3范围参数函数 （重写range）

#范围参数的实现  range
def interval(start,stop=None,step=1):
    '''自建范围参数，实现range的for循环list效果'''
    if stop is None:
        start,stop=0,start
    result=[]
    
    i=start
    while i<stop:
        result.append(i)
        i+=step
    return result    
print(interval(20)) 

3.2.4二分查找递归函数

#二分查找 递归函数
def search(sequence,number,lower=0,upper=None):
    '''
    二分递归函数
    参数(有序的数字列表,数字,数字位置下限,数字位置上限)
    事实上，在可观察到的宇宙中，包含的粒子数大约为10**87个，要找出其中一个原子，只需要二分查找询问290次。
    '''
    if upper is None:upper=len(sequence)-1                    
    if lower==upper:
        assert number==sequence[upper]
        return upper
    else:
        middle=(lower+upper)//2
        if number > sequence[middle]:
            return search(sequence,number,middle + 1,upper)
        else:
            return search(sequence,number,lower,middle)
seq=[23,45,77,2,4,55,898]
seq.sort()
print(seq)
print(search(seq,77))

四、类

# =============================================================================
# #类
# #类是 相同属性 和 函数 的封装
# =============================================================================

#supper()调用超类的构造函数 __init__()

五、魔法方法、特性、属性、装饰器

5.1魔法方法

# =============================================================================
# #魔法方法、特性、属性、装饰器
# =============================================================================

#注意协议的概念  协议即行为或借口，遵循协议即实现了对象的行为。

#基本的 序列/映射 的协议，即元素item的集合
#四个魔法方法：__len__(self)、__getitem__(self,key)、__setitem__(self,key,value)、__delitme__(self,key)

'''
创建一个无穷序列
注意：  没有定义__delitem__方法
'''
def check_index(key):
    '''
    指定的键是否是可接受的索引？
    
    键必须为非负整数。如果不是整数则引发TypeError异常，如果是负数则引发IndexError异常（因为序列长度是无穷的）
    '''
    if not isinstance(key,int):
        raise TypeError('你错误的输入了非整数')
    if key<0:
        raise IndexError('你错误的输入了负数索引，要明白这个序列是无穷的...')

class ArithmeticSequence:
    def __init__(self,start=0,step=1):
        '''
        初始化这个 算数序列。
        参数start  序列中的第一个值
        参数step   序列中的步长，即两个相邻值的差值
        
        属性changed    一个字典，包含用户修改后的值。
        '''
        self.start=start
        self.step=step
        self.changed={}
    
    def __getitem__(self,key):
        '''
        从这个 算数序列 中获取一个指定键的值，索引的值。
        '''
        check_index(key)                            #首先函数检查这个键是否是非负整数索引
        try:
            return self.changed[key]
        except KeyError:
            return self.start + key*self.step
        
    def __setitem__(self,key,value):
        '''
        修改这个 算数序列 中的指定键的值，索引的值。
        '''
        check_index(key)                            #首先函数检查这个键是否是非负整数索引
        self.changed[key]=value                     #存储修改后的值

s=ArithmeticSequence()           #实例化这个 算数序列。默认参数即s=1,2,3,4,5...
print(s[2])                      

s1=ArithmeticSequence(0,5)       #实例化这个 算数序列。即s1=0,5,10,15,20....
print(s1[1])    
s1[1]=20                         #设置指定索引的值
print(s1[1])
print(s1[2])

5.1.1自建魔法类（一个带有访问计算器的列表 的类）

#自建魔法类 一个带有访问计算器的列表 的类
class CounterList(list):                  #继承系统list类
    def __init__(self,*args):
        super().__init__(*args)           #super()调用超类未关联的构造函数
        self.counter=0              
    def __getitem__(self,index):
        self.counter+=1
        return super(CounterList,self).__getitem__(index)
c1=CounterList(range(10))
print(c1)
c1.reverse()
print(c1)
del c1[3:6]
print(c1)

print(c1.counter)
c1[4] + c1[4]                             #计算器只有在 访问列表元素、获取列表元素时才会触发。
print(c1.counter)

5.2特性property

#特性property
#通过取存方法定义的属性 成为特性。可调用函数 property(fget,fset,fdel,doc)来赋值给属性，使之成为特性

class Rectangle:                  
    '''
    定义一个矩形类，并使其size为宽、高的元组形式的特性
    '''
    def __init__(self):
        self.width=0
        self.height=0
    def set_size(self,size):
        self.width,self.height=size
    def get_size(self):
        return self.width,self.height  
    size=property(get_size,set_size)       #通过调用函数proprety()并将取存方法作为参数来创建一个特性size
r=Rectangle()
r.width=10
r.height=20
r.get_size()
print(r.size)

5.3装饰器@

#装饰器@
#装饰器可用于包装方法，性质等同与 包装静态方法 和 包装类方法。
#装饰器可用于包装任何可调用的对象，可用于方法 和 函数。
#装饰器可指定一个或者多个，在方法或函数前面使用 @符号列出装饰器（指定多个装饰器时，应用的顺序与列出的顺序相反）

#创建静态方法  将其包装在 staticmethod类的对象中
#创建类方法    将其包装在 classmethod类的对象中

5.4属性的魔法方法

#属性的魔法方法
#__getattribute__(self,name)   在属性被访问前自动调用
#__getattr__(self,name)        在属性被访问而对象没有这样的属性时被自动调用
#__setattr__(self,name,value)  试图给属性赋值时自动调用
#__delattr__(self,name)        试图删除属性时自动调用

class Rectangle1:
    '''
    继续定义一个矩形类，用访问属性的魔法方法来实现 size 特性来代替proprety函数
    '''
    def __init__(self):
        self.width=0
        self.height=0
    def __setattr__(self,name,value):
        if name=='size':
            self.width,self.height=value
        else:
            self.__dict__[name]=value
    def __getattr__(self,name):
        if name=='size':
            return self.width,self.height
        else:
            raise AttributeError('属性错误：没有这个属性')
r1=Rectangle1()
r1.size
r1.width=2
r1.height=3
r1.size

六、迭代器 和 生成器

6.1迭代器

# =============================================================================
# #迭代器 和 生成器
# =============================================================================

#迭代器的魔法方法
#__next__(self)  实现了__next__方法的对象是迭代器
#__iter__(self)  是迭代器协议的基础。实现了__iter__方法的对象是可迭代的。

class Fibs:
    '''
    斐波那契数列 无限迭代器
    '''
    def __init__(self):
        self.a=0
        self.b=1
    def __next__(self):
        self.a,self.b=self.b,self.a+self.b
        return self.a
    def __iter__(self):
        return self                              #实现__iter__方法，并返回self，就成了可迭代了，可用作循环。
fibs=Fibs()
for f in fibs:
    if f>1000:
        print(f)
        break

#另外需要了解下 内置函数的 iter迭代器 和 next迭代函数
it=iter([1,2,3,4,5])                             #内置函数iter()可获得迭代器
next(it)                                         #内置函数next()可产生迭代作用

#用 list从迭代器创建序列  
#将迭代器的魔法方法添加条件
class TestIterator:
    value=0
    def __next__(self):
        self.value+=1
        if self.value>10: raise StopIteration    #如果调用次数超过10，则停止迭代
        return self.value
    def __iter__(self):
        return self
ti=TestIterator()
list(ti)

6.2生成器yield

#生成器 yield
#包含yield的语句被称为 生成器。
#包含 基线条件 和 递归条件。  即最后一个条件处理 和 循环的条件处理。

#简单生成器  使用推导式加元组括号，如(x for x in range(10)),然后通过内置函数next迭代该生成器
g=(x for x in range(10))
print(g)
next(g)


#递归式生成器
def flatten(nested):
    '''
    递归式生成器，递归参数列表内的每一个元素，参数可为多层嵌套列表
    如果参数内元素为字符串类型则输出字符串，不可迭代字符串单个字母
    '''
    try:
        #不迭代类似字符串的对象
        #通过 参数 和 字符串 相加是否产生类型异常来判断 参数是否是字符串类型
        try: nested+''                          #如果参数里有字符串类型，就捕捉类型异常，然后忽略
        except TypeError: pass
        else: raise TypeError                   #如果没有引发异常，就手动引发 类型异常，用来执行外部的捕获异常单输出字符串
        
        for sublist in nested:
            for element in flatten(sublist):
                yield element
    except TypeError:
        yield nested

list(flatten(['foo',['bar',1,2,3],'three',[4,5],'六']))

f=flatten(['foo',['bar',1,2,3],'three',[4,5],'六'])
next(f)

6.2.1八皇后问题（用生成器yield来解决）

#八皇后问题
#八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：
#在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

#自建函数检测冲突
def conflict(state,nextX):
    '''
    自建函数检测 既有的皇后位置 和 需要检测的下一个皇后位置 是否冲突。 
    即检测任意两个皇后的x坐标是否为相减为0 或 任两个皇后之间是否组成对角线的正方形图形。
    参数state  为一个序列结构，显示的是既有皇后的位置
    参数nextX  为需要检测的下一个皇后的位置
    
    需要明白参数state不受len数量影响，该自建函数只管检测参数nextX与既有参数是否冲突，不管既定的皇后位置有多少个。
    '''
    nextY=len(state)
    for i in range(nextY):
        #这里进行了两个条件判断：（0 , nextY-i）
        #一个是0，即不能在同一列上面
        #一个是nextY-i，即任意两个皇后不能组成对角线形成正方形形态
        if abs(state[i]-nextX) in (0,nextY-i):   #注意这里不是range,而是判断是否 水平X为0 或 垂直距离相等
            return True                          #如果皇后有冲突，则返回 True。要明白return后不执行后面代码
    return False                                 #如果前面检测都没有冲突，就返回 False
conflict([1,3,0],2)
conflict((1,),2)

#自建函数生成器 处理基线条件 即最后一个皇后的位置输出生成器
def queensLast(num,state):
    '''
    自建函数  解决八皇后基线条件，即最后一个皇后的位置生成器。
    参数num    为皇后的数量
    参数state  为之前的既定的皇后位置
    '''
    if len(state)==num-1:                        #首先条件判断是否是最后一个皇后
        for pos in range(num):                   #遍历最后一个皇后的每一列位置，检测是否冲突
            if not conflict(state,pos):          #如果没有冲突，就生成这个 位置 输出。
                yield pos
list(queensLast(4,[1,3,0]))
next(queensLast(4,[1,3,0]))


#自建函数生成器 处理递归条件 即输出指定数量的皇后位置序列 
def queens(num=8,state=()):
    '''
    解决基线条件以后即可生成最后一个皇后的位置输出，
    然后将 之前的既定皇后位置序列 追加在 最后皇后位置的序列之前 即可完成 指定数量的皇后位置序列。
    默认参数num    为指定的皇后数量
    默认参数state  为既定的皇后位置序列，默认为空则可从头开始输出。
    '''
    for pos in range(num):
        #如果 当前皇后位置序列state 与 下一个皇后位置pos 不冲突，则才能执行后面代码
        if not conflict(state,pos):                        #自建函数检测参数 皇后位置状态 和 下一个皇后位置是否冲突
            #基线条件，和单独设置的基线条件效果等同
            if len(state) == num-1:
                yield(pos,)                                #if解决的是 基线条件 即最后一个皇后的位置输出
            #递归条件
            else:                                          #else解决的是 队规条件 即如果不是最后一个皇后就从头开始算起。
                for result in queens(num,state+(pos,)):    #递归调用，从 位置(0,)开始
                    yield (pos,)+result                    #从既有皇后位置序列（0,）开始往后循环生成输出。
#                    yield result
#                    yield pos
list(queens(4))

list(queens(8))                       #通过这几个输出对比函数内内容来更好理解
list(queens(8,(0,)))                  #通过这几个输出对比函数内内容来更好理解    
for solution in queens(8):            #通过这几个输出对比函数内内容来更好理解
    print(solution)

list(queens(4,[1,3,0]))



#八皇后扫尾工作  清晰输出
def prettyprint(solution):
    '''格式化输出 八皇后 的位置状态'''
    def line(pos,length=len(solution)):
        return '.'*(pos) + 'X' +'.'*(length-pos-1)
    
    for pos in solution:
        print(line(pos))

prettyprint(list(queens(8))[2])        #格式化输出 八皇后 的第3个状态。

七、异常（捕获异常并处理、引发异常）

# =============================================================================
# #异常
# #捕获异常并处理、引发异常
# =============================================================================
#捕获异常并处理
while True:
    try:
        x=int(input('输入X： '))
        y=int(input('输入y： '))
        value=x/y
        print('x/y is ',value)
    except Exception as e:
        print('异常：',e)
        print('再次输入')
    else:                                                  #条件判断，如果未出现异常，则执行else
        break
    finally:
        print('这是必须执行的...')

#引发异常
raise Exception('这里手动引发了一个 通用异常Exception！')    #引发异常 并 指定错误提示消息。     

八、模块module

8.1模块的路径

模块的概念即为.py文件，包的概念即是包含模块.py文件的目录。
（从数据结构——>函数——>类——>模块——>包，是逐层的升级过程）

8.2模块的引入（标准库、第三库、自定义库）

8.2.1、标准库自带的模块调用

例如:sys,调用自带的模块只需要import sys 引入既可以使用

8.2.2、第三方模块的调用

调用第三方模块，需要先安装模块,在CMD里执行pip install module语句,再执行命令python -m pydoc -b来打开本地模块文档查看
然后使用时再import module引入

8.2.3、自定义模块的调用（同级模块文件、下级目录模块文件、上级目录模块文件）

假定目录结构如下：
test
-----t1.py
-----t2.py
-----test1
-----------testm.py
-----test2
-----------testmm.py

8.2.3.1调用“同级目录模块文件” ，直接使用import 模块名

例如：t1.py要调用t2.py模块中的func(),

引入使用方法有2种：
_1引入 import t2，使用 t2.func()
_2引入 from t2 import func，使用 func()

8.2.3.2调用“下级目录中的模块文件”,需要在“下级目录”中创建“init.py文件”，该文件可以什么都不写

例如：t1.py调用test1目录中的testm.py模块，需要在test1目录下创建__init__.py文件。

引入使用方法有3种：
_1引入 import test1.testm, 使用 test1.testm.func()
2引入 from test1.testm import *, 使用 func()
3首先编辑test1目录中的__init.py文件添加内容 from .testm import func，注意testm前面有符号 点.
然后再引入 from test1 import func ，使用 func()

8.2.3.3调用“上级目录中的模块文件”，被调用模块文件所在的目录下需要创建__init__.py文件,还要sys来添加上级目录为环境变量

例如：test2目录下的testmm.py文件调用test1目录下的testm模块，在test1目录下创建__init__.py，还要通过sys模块添加test目录为临时环境变量。
引入使用方法如下：
import sys
print(sys.path) #列表结构输出 系统环境变量列表，
sys.path.append("…") #…两个点号表示上级目录，意将上级目录添加到环境变量。
‘’’
1.对于模块和自己写的脚本不在同一个目录下，在脚本开头加sys.path.append(‘xxx’)：
此时sys.path 返回的是一个列表！该路径已经添加到系统的环境变量了，当我们要添加自己的搜索目录时，可以通过列表的append()方法
2.把路径添加到系统的环境变量，或把该路径的文件夹放进已经添加到系统环境变量的路径内。环境变量的内容会自动添加到模块搜索路径中。
可以通过dir(sys)来查看他里面的方法和成员属性。
‘’’
from test1.testm import *
或
import test1.testm

在python中，如何把一个python文件夹（及其包含的python文件）加入到python环境变量中以方便其他python文件调用呢。有两种方法，下面对其进行简单的介绍。

1. import sys

导入系统自带的sys模块，然后将需要加入的文件夹的路径进行追加或者插入，如下：

import sys
sys.path.append(r’E:\src\ttlayer’)
sys.path.insert(0,r’E:\src\ttlayer’)
说明：导入sys模块，然后打印sys.paht即可查看文件夹是否被添加到python的环境变量中去。sys.path返回模块的搜索路径，append和insert方法，将一个python文件夹加入到python的环境变量中，这样我们就可以在其他python文件中调用这些加入到环境变量中python文件了。

2. pycharm

利用pycharm中现有的功能项，将python文件夹加入到python的环境变量中，操作步骤如下： 选择需要加入到python环境变量中的文件夹，右键单击——选择Mark Directory as——Sources Root 选项，即可这样就可以把该文件夹的路径添加到python的环境变量中去了。我们可以在任意一个文件中导入该文件夹下的python文件。同时，文件夹做了该项设置后，其颜色会变成蓝色。