python 2.x默认的字符编码是ASCII，默认的文件编码也是ASCII

python 3.x默认的字符编码是unicode，默认的文件编码也是utf-8

无论以什么编码在内存里显示字符，存到硬盘上都是2进制，所以编码不对，程序就会出错了。

（ascii编码（美国），GBK编码（中国），shift_JIS编码（日本），，，，）

要注意的是，存到硬盘上时是以何种编码存的，再从硬盘上读出来时，就必须以何种编码读，要不然就乱了。。

常见的编码错误的原因有:

　　python解释器的默认编码

　　Terminal使用的编码

　　python源文件文件编码

　　操作系统的语言设置,掌握了编码之前的关系后,挨个排错就ok

如果想要中国的软件可以正常的在美国人的电脑上实现，有下面两种方法：

    1，让美国人的电脑都装上gbk编码

    2，让你的软件编码以utf-8编码

    第一种方法不可现实，第二种方法比较简单，但是也只能针对新开发的软件，

如果你之前开发的软件就是以gbk的编码写的，上百万行代码已经写出去了，

重新编码成utf-8格式也会费很大力气。

    所以，针对已经用gbk开发的软件项目如何让项目在美国人的电脑上正常显示

    还记得unicode的一个功能就是其包含了跟全球所有国家编码的映射关系，

所以无论你以什么编码存储的数据，只要我们的软件把数据从硬盘上读到内存，

转成unicode来显示即可，由于所有的系统，编程语言都默认支持unicode，

所有我们的gbk软件放在美国电脑上，加载到内存里面，变成了unicode，中文就可正常展示

#_*_coding:utf-8 _*_ 的作用是.py文件是什么编码，就需要告诉python用什么编码去读取这个.py文件

简单点说：

Python 2 将 strings 处理为原生的 bytes 类型，而不是 unicode，

Python 3 所有的 strings 均是 unicode 类型。

在python2.x中，写字符串，比如

>>>s = ”学习“

>>>print s

学习

>>>s

'\xd1\xa7\xcf\xb0'

    虽然说打印的是学习，但是直接调用的变量s，确实一个个16进制表示的二进制字节，

我们称这个为byte类型，即字节类型，它把8个二进制一组称为一个byte，用16进制表示

    所以说python2.x的字符串其实更应该称为字符串，通过存储的方式就能看出来，

但是在python2.x中还有一个bytes类型，两个是否相同呢，回答是肯定的，在python2.x中，bytes==str

python3.x中

    把字符串变成了unicode，文件默认编码编程了utf-8，这意味着，只要用python3.x，

无论我们的程序以那种语言开发，都可以在全球各国电脑上正常显示。

    python3.x除了把字符串的编码改成了unicode，还把str和bytes做了明确区分，

str就是unicode格式的字符串bytes就是单纯的二进制

（补充一个问题，为什么在python3.x中，把unicode编码后，字符串就变成了bytes格式

，为什么不直接打印成gbk的字符，我觉得就是想通过这样的方式明确的告诉你，想在python3.x中看字符，

必须是unicode，其他编码一律是bytes格式）

文件操作时候，以“r"或者”rb"模式打开，只能读取，无法写入；

硬盘上保存的文件都是某种编码的0101010，打开时需要注意：

    rb，直接读取文件保存时原生的0101010，在Python中用字节类型表示

    r和encoding，读取硬盘的0101010，并按照encoding指定的编码格式进行断句，

再将“断句”后的每一段0101010转换成unicode的 010101010101，在Python中用字符串类型表示

open(f_name,'r',encoding="utf-8")

f_name 是文件的路径，mode是打开的方式，encoding是编码格式

 encoding #文件编码 

 mode #打开模式 

 name #文件名 

 newlines #文件中用到的换行模式，是一个tuple 

 softspace #boolean型，一般为0，据说用于print

文件操作时候，以 “w”或“wb” 模式打开，则只能写，并且在打开的同时会先将内容清空。

写入到硬盘上时，必须是某种编码的0101010，打开时需要注意：

    wb，写入时需要直接传入以某种编码的0100101，即：字节类型

    w 和 encoding，写入时需要传入unicode字符串，内部会根据encoding制定的编码

将unicode字符串转换为该编码的 010101010

文件操作时，以 “a”或“ab” 模式打开，则只能追加，即：在原来内容的尾部追加内容

写入到硬盘上时，必须是某种编码的0101010，打开时需要注意：

    ab，写入时需要直接传入以某种编码的0100101，即：字节类型

    a 和 encoding，写入时需要传入unicode字符串，内部会根据encoding制定的编码

将unicode字符串转换为该编码的 010101010

readline() #读取一行

readlines() #读取所有内容，并返回列表（一行为列表的一个元素值）

`python your_script.py old_str new_str filename`

#写函数，计算传入数字参数的和。（动态传参）

x = int(input("输入要计算的值x: "))  #定义动态输入的x值

y = int(input("输入要计算的值y: "))  #定义动态输入的y值

def calc(x,y):

    result = x+y

    return ("结果是：",result)

a = calc(x,y)

print(a)

# 输入要计算的值x: 123

# 输入要计算的值y: 456

# ('结果是：', 579)

# 2、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作

import os

file_name = "print_tofile.txt"

file_new_name = '%s.new' %file_name

old_str = '最近学习不太好'

new_str = '最近学习真不好'

f_old = open(file_name,'r',encoding='utf-8')

f_new = open(file_new_name,'w',encoding='utf-8')

for line in f_old:

    if old_str in line:

        line = line.replace(old_str,new_str)

        f_new.write(line)

        print(line)

f_old.close()

f_new.close()

os.replace(file_new_name,file_name)

import os

def update_func(a: object, old_str: object, new_str: object) -> object:  #定义三个接受值的形参，a是要修改的文件名，b是要修改的内容，c是修改后的内容

    #打开文件，文件名为接受的形参a

    file_old = 'a.txt'

    file_new = 'aa.txt'

    f_old = open(file_old,'r',encoding='utf-8')

    #打开修改后写入的文件

    f_new = open(file_new,'w',encoding='utf-8')

    # old_str = '你是我唯一的爱'

    # new_str = 'you are my everything'

    #循环每一行的文件的数据

    for line in f_old:

        new_content = line.replace(old_str,new_str)      #将要修改的内容字符串用replace替换

        f_new.write(new_content)             #将替换后的内容写入修改后写入的文件中

    f_new.close()

    f_old.close()

    os.replace(file_new,file_old)

update_func('a.txt','你是我唯一的爱','you are my everything')

你是我唯一的爱，you are my everything

you are my everything，you are my everything

def check_str(a):  #a为传过来的参数

    calc = False  #空格统计默认False没有

    for line in a:

        if line.isspace():

            calc = True

    return calc

a = '123 132 456 7489 456'

res = check_str(a)

print(res)

def func(strr,listt,tuplee):

    if strr.isspace():

        print("字符串有空内容")

    else:

        print("字符串里面没有空内容")

    if len(listt) ==0:

        print("列表有空内容")

    else:

        print("列表里面没有空内容")

    if len(tuplee) == 0:

        print("元祖有空内容")

    else:

        print("元组里面没有空内容")

res = func('123456',[],())

# 字符串里面没有空内容

# 列表有空内容

# 元祖有空内容

dic = {"k1": "v1v1", "k2": [11,22,33,44]}

PS:字典中的value只能是字符串或列表

# 4，写函数，检查传入字典的每一个value的长度,如果大于2，

        # 那么仅保留前两个长度的内容，并将新内容返回给调用者。

dic = {"k1": "v1v1", "k2": [11,22,33,44]}

def check_func(a):  #a为传过来的参数

    li = []

    for item in a.values():

        length = len(item)

        if length >2:

            li.append(item[0:2])

        else:

            continue

    return li

a = check_func(dic)

print(a)

# ['v1', [11, 22]]

    关于闭包，即函数定义和函数表达式位于另一个函数的函数体内（嵌套函数）。

而且这些内部函数可以访问他们所在的外部函数中声明的所有局部变量，参数。

当其中一个这样的内部函数在包含他们的外部函数之外被调用时候，就形成了闭包。

也就是说，内部函数会在外部函数返回后被执行。而当这个内部函数执行的时候，

它仍然必需访问其外部函数的局部变量，参数以及其他内部函数，这些局部变量，

参数声明（最初时）的值是外部函数返回时候的值，但也会受到内部函数的影响。

    闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，

这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

# 6，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数

def func(strr):

    digit_number = 0

    space_number = 0

    alpha_number = 0

    else_number = 0

    for i in strr:

        if i.isdigit():

            digit_number +=1

        elif i.isspace():

            space_number +=1

        elif i.isalpha():

            alpha_number +=1

        else:

            else_number +=1

    return ("数字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))

res = func('sda!@#$%^&1234567dfghj da da ')

print(res)

# ('数字，空格，字母，其他内容分别有：', (7, 3, 12, 7))

def cards():

    num = []

    for i in range(2,11):

        num.append(i)

    num.extend(['J','Q','K','A'])

    type = ['红心','草花','方块','黑桃']

    result = []

    for i in num:

        for j in type:

            result.append((j,i))

    return result

print(cards())

# [('红心', 2), ('草花', 2), ('方块', 2), ('黑桃', 2),

#  ('红心', 3), ('草花', 3), ('方块', 3), ('黑桃', 3),

#  ('红心', 4), ('草花', 4), ('方块', 4), ('黑桃', 4),

#  ('红心', 5), ('草花', 5), ('方块', 5), ('黑桃', 5),

#  ('红心', 6), ('草花', 6), ('方块', 6), ('黑桃', 6),

#  ('红心', 7), ('草花', 7), ('方块', 7), ('黑桃', 7),

#  ('红心', 8), ('草花', 8), ('方块', 8), ('黑桃', 8),

#  ('红心', 9), ('草花', 9), ('方块', 9), ('黑桃', 9),

#  ('红心', 10), ('草花', 10), ('方块', 10), ('黑桃', 10),

#  ('红心', 'J'), ('草花', 'J'), ('方块', 'J'), ('黑桃', 'J'),

#  ('红心', 'Q'), ('草花', 'Q'), ('方块', 'Q'), ('黑桃', 'Q'),

#  ('红心', 'K'), ('草花', 'K'), ('方块', 'K'), ('黑桃', 'K'),

#  ('红心', 'A'), ('草花', 'A'), ('方块', 'A'), ('黑桃', 'A')]

例如:min_max(2,5,7,8,4)

返回:{‘max’:8,’min’:2}

# 2，写函数，传入n个数，返回字典{‘max’:最大值,’min’:最小值}

# 例如:min_max(2,5,7,8,4)

# 返回:{‘max’:8,’min’:2}

def max_min(*args):

    the_max = args[0]

    the_min = args[0]

    for i in args:

        if i>the_max:

            the_max = i

        else:

            the_min = i

    return {'max':the_max,'min':the_min}

res = max_min(2,4,6,48,-16,486)

print(res)

# {'max': 486, 'min': -16}

def area():

    def 计算长方形面积():

        pass

    def 计算正方形面积():

        pass

    def 计算圆形面积():

        pass

import math

print('''

请按照如下格式输出：

    调用函数area(‘圆形’,圆半径) 返回圆的面积

    调用函数area(‘正方形’,边长) 返回正方形的面积

    调用函数area(‘长方形’,长，宽) 返回长方形的面积''')

def area(name,*args):

    def areas_rectangle(x,y):

        return ("长方形的面积为：",x*y)

    def area_square(x):

        return ("正方形的面积为：",x**2)

    def area_round(r):

        return ("圆形的面积为：",math.pi*r*r)

    if name =='圆形':

        return area_round(*args)

    elif name =='正方形':

        return area_square(*args)

    elif name =='长方形':

        return areas_rectangle(*args)

print(area('长方形', 3, 4))

print(area('圆形', 3))

print(area('正方形', 3))

# 请按照如下格式输出：

#     调用函数area(‘圆形’,圆半径) 返回圆的面积

#     调用函数area(‘正方形’,边长) 返回正方形的面积

#     调用函数area(‘长方形’,长，宽) 返回长方形的面积

# ('长方形的面积为：', 12)

# ('圆形的面积为：', 28.274333882308138)

# ('正方形的面积为：', 9)

例如:cal(7)

计算7*6*5*4*3*2*1

# 4、写函数，传入一个参数n，返回n的阶乘。

# 例如: cal(7） 计算7 * 6 * 5 * 4 * 3 * 2 * 1

def cal(n):

    res= 1

    for i in range(n,0,-1):

        # print(i)

        res = res*i

        print(res)

    return res

print(cal(7))

# 5，编写装饰器，为多个函数加上认证的功能（用户的账号密码来源于文件），

# 要求登录成功一次，后续的函数都无需再输入用户名和密码

def login(func):

    def wrapper(*args,**kwargs):

        username = input("account:").strip()

        password = input("password:").strip()

        with open('userinfo.txt','r',encoding='utf-8') as f:

            userinfo = f.read().strip(',')

            userinfo = eval(userinfo)

            print(userinfo)

            if username in userinfo['name'] and password in userinfo['password']:

                print("success")

            else:

                print("pass")

    return wrapper

@login

def name():

    print("hello")

name()

对于list、string、tuple、dict等这些容器对象,使用for循环遍历是很方便的。

在后台for语句对容器对象调用iter()函数。iter()是python内置函数。

iter()函数会返回一个定义了 next()方法的迭代器对象，它在容器中逐个访问容器内的

元素。next()也是python内置函数。在没有后续元素时，next()会抛出

一个StopIteration异常，通知for语句循环结束。

迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的

时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数

的时候，调用的就是迭代器对象的_next_方法（Python3中是对象的_next_方法，

Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，

就要实现它的_next_方法。但这还不够，python要求迭代器本身也是可迭代的，

所以我们还要为迭代器实现_iter_方法，而_iter_方法要返回一个迭代器，

迭代器自身正是一个迭代器，所以迭代器的_iter_方法返回自身self即可。

两种方式获取：

    for 循环

    next 获取

2017-10-19 22:07:38 [1] test log db backup 3

2017-10-19 22:07:40 [2]    user alex login success

#注意：其中[1],[2]是指自日志方法第几次调用，每调用一次输出一条日志

def logger(filename,channel='file'):

    """

    日志方法

    :param filename: log filename

    :param channel: 输出的目的地，屏幕(terminal)，文件(file)，屏幕+文件(both)

    :return:

    """

    ...your code...

 #调用

 log_obj = logger(filename="web.log",channel='both')

 log_obj.__next__()

 log_obj.send('user alex login success')

name=['alex','wupeiqi','yuanhao','nezha']

map()函数

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把

函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

#  1，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb

# name=['alex','wupeiqi','yuanhao','nezha']

name=['alex','wupeiqi','yuanhao','nezha']

def sb(x):

    return x+'_sb'

res = map(sb,name)

print(list(res))

# 结果：

['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'nezha_sb']

num = [1,3,5,6,7,8]

# 2，用filter函数处理数字列表，将列表中所有的偶数筛选出来

# num = [1,3,5,6,7,8]

num = [1,3,5,6,7,8]

def func(x):

    if x%2 == 0:

        return True

ret = filter(func,num)

print(list(ret))

# 结果：

[6, 8]

portfolio = [

    {'name': 'IBM', 'shares': 100, 'price': 91.1},

    {'name': 'AAPL', 'shares': 50, 'price': 543.22},

    {'name': 'FB', 'shares': 200, 'price': 21.09},

    {'name': 'HPQ', 'shares': 35, 'price': 31.75},

    {'name': 'YHOO', 'shares': 45, 'price': 16.35},

    {'name': 'ACME', 'shares': 75, 'price': 115.65}

]

# 3，如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格

portfolio = [

    {'name': 'IBM', 'shares': 100, 'price': 91.1},

    {'name': 'AAPL', 'shares': 50, 'price': 543.22},

    {'name': 'FB', 'shares': 200, 'price': 21.09},

    {'name': 'HPQ', 'shares': 35, 'price': 31.75},

    {'name': 'YHOO', 'shares': 45, 'price': 16.35},

    {'name': 'ACME', 'shares': 75, 'price': 115.65}

]

# 　　

# 　　计算购买每支股票的总价

# 　　用filter过滤出，单价大于100的股票有哪些

portfolio = [

    {'name': 'IBM', 'shares': 100, 'price': 91.1},

    {'name': 'AAPL', 'shares': 50, 'price': 543.22},

    {'name': 'FB', 'shares': 200, 'price': 21.09},

    {'name': 'HPQ', 'shares': 35, 'price': 31.75},

    {'name': 'YHOO', 'shares': 45, 'price': 16.35},

    {'name': 'ACME', 'shares': 75, 'price': 115.65}

]

m = map(lambda y:y['shares']*y['price'],portfolio)

print(list(m))

# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]

a = []

for index,i in enumerate(portfolio):

    res= i['shares'] * i['price']

    a.append(res)

print(a)

# [9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]

# 　3、用filter过滤出，单价大于100的股票有哪些

f = filter(lambda d:d['price']>=100,portfolio)

print(list(f))

# [{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]

# 1，有列表 li = ['alex', 'egon', 'smith', 'pizza', 'alen'],

# 请将以字母“a”开头的元素的首字母改为大写字母；

li = ['alex', 'egon', 'smith', 'pizza', 'alen']

li_new = []

for i in li:

    if i.startswith('a'):

        li_new.append(i.capitalize())

    else:

        li_new.append(i)

print(li_new)

for i in range(len(li)):

    if li[i][0] == 'a':

        li[i] = li[i].capitalize()

    else:

        continue

print(li)

num = 20

   def show_num(x=num):

       print(x)

   show_num()

   num = 30

   show_num()

   昔人已乘黄鹤去，此地空余黄鹤楼。

   黄鹤一去不复返，白云千载空悠悠。

   晴川历历汉阳树，芳草萋萋鹦鹉洲。

   日暮乡关何处是？烟波江上使人愁。

# 4，有名为poetry.txt的文件，其内容如下，请删除第三行；

# 方法一：

# import os

# p = 'poetry.txt'

# file = open(p,'r',encoding='utf-8')

# print(file)

# pnew = '%s.new'%p

# filenew = open(pnew,'w',encoding='utf-8')

# str1 = '晴川历历汉阳树，芳草萋萋鹦鹉洲。'

# for i in file:

#     if str1 in i:

#         i = ''

#         filenew.write(i)

#     else:

#         filenew.write(i)

# file.close()

# filenew.close()

# os.replace(pnew,p)

# 方法二：逐行读取文件

import os

f1=open('poetry.txt', 'r',encoding='utf-8')

str='晴川历历汉阳树，芳草萋萋鹦鹉洲。'

with open('poetry1.txt', 'w', encoding='utf-8') as f2:

    ff1='poetry.txt'

    ff2='poetry1.txt'

    for line in f1:

        if str in line:

            line=''

            f2.write(line)

        else:

            f2.write(line)

f1.close()

f2.close()

os.replace(ff2,ff1)

   pizza

   alex

   egon

# 5，有名为username.txt的文件，其内容格式如下，写一个程序，

# 判断该文件中是否存在"alex", 如果没有，

# 则将字符串"alex"添加到该文件末尾，否则提示用户该用户已存在；

with open('username.txt','r+',encoding='utf-8') as f:

    str1 = 'alexx'

    i = f.read()

    print(i)

    if str1 in i:

        print("the user already exist in")

    else:

        f.write('\nalexx')

   pizza,100001

   alex, 100002

   egon, 100003

# 6，有名为user_info.txt的文件，其内容格式如下，

# 写一个程序，删除id为100003的行；

import os

a = 'user_info.txt'

b = 'user_info1.txt'

with open(a,'r',encoding='utf-8') as f:

    with open(b, 'w', encoding='utf-8') as f2:

        for i in f:

            if '100003' in i:

                pass

            else:

                f2.write(i)

os.replace(b,a)

   pizza,100001

   alex, 100002

   egon, 100003

# 7，有名为user_info.txt的文件，其内容格式如下，写一个程序，

# 将id为100002的用户名修改为alex li；

file = 'user_info.txt'

old_str = '100002'

new_str = 'alex, 100002'

file_data=''

with open(file,'r',encoding='utf-8') as f1:

    for line in f1:

        if old_str in line:

            line =new_str

        file_data +=line

        with open(file,'w',encoding='utf-8') as f1:

            f1.write(file_data)

    装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，

同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

    这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，

提供了额外的功能。

8，写一个计算每个程序执行时间的装饰器；

import time

def timer(func):

    def wrapper(*args,**kwargs):

        start_time = time.time()

        func(*args)

        stop_time = time.time()

        d_time = stop_time-start_time

        print(d_time)

    return wrapper

@timer

def sayhi():

    print("hello word")

sayhi()

lambda函数就是可以接受任意多个参数(包括可选参数)并且返回单个表达式值得函数

    好处：

        1.lambda函数比较轻便，即用即扔，适合完成只在一处使用的简单功能

        2.匿名函数，一般用来给filter，map这样的函数式编程服务

        3.作为回调函数，传递给某些应用，比如消息处理

普通参数：以正确的顺序传入函数，调用时数量必须和声明的一样

指定参数：参数和函数调用关系密切，函数调用使用关键字参数来确定传入的参数值，参数

                允许函数调用时参数的顺序和声明时不一致

默认参数：函数进行调用时，如果没有新的参数传入则默认的情况下，就调用默认参数

动态参数：个别函数能处理比当初声明时更多的参数，这些参数就动态参数

def func(s):

    al_num =0

    space_num = 0

    digit_num = 0

    others_num = 0

    for i in s:

        if i.isdigit():

            digit_num +=1

        elif i.isspace():

            space_num +=1

        elif i.isalpha():

            al_num +=1

        else:

            others_num +=1

        return (al_num,space_num,digit_num,others_num)

result = func("asdsadjlk1212jdjakdk2  d d d d323233223下")

print(result)

result = func("  d d d d323233223下")

print(result)

def func(s,lis,tup):

    zifuchuan = len(s)

    liebiao = len(lis)

    yuanzu = len(tup)

    if zifuchuan>5:

        print("大于5")

    else:

        print("小于5")

    if liebiao >5:

        print("大于5")

    else:

        print("小于5")

    if yuanzu >5:

        print("大于5")

    else:

        print("小于5")

    return (zifuchuan,liebiao,yuanzu)

func('dadadad','[1,2,3]',{1,2,3})

def func(n):

    for i in a:

        i = str(i)

        if '' in i:

            return ('空格： ',i)

        else:

            return ('没空格')

a = ('dasdsd dasd','ds')

res = func(a)

print(res)

def func(li):

    len_li = len(li)

    if len_li>2:

        print("列表长度大于2")

        new_li = li[0:2]

    return (new_li)

res = func([12,12,45,78,32,12])

print(res)

def func(li,tup):

    li = []

    tup = []

    for i in range(len(li)):

        if i %2 ==1:

            li.append(li[i])

    print(li)

    for j in range(len(tup)):

        if j %2 ==1:

            tup.append(tup[j])

    print(tup)

    return  (li,tup)

res = func([1,2,3,4,5,6,7,8,9],(1,2,3,11,21,4,5,6,7))

print(res)

# 18，写函数，计算传入字符串中的【数字】、【字母】、【空格】和【其他】的个数

def func(strr):

    digit_number = 0

    space_number = 0

    alpha_number = 0

    else_number = 0

    for i in strr:

        if i.isdigit():

            digit_number +=1

        elif i.isspace():

            space_number +=1

        elif i.isalpha():

            alpha_number +=1

        else:

            else_number +=1

    return ("数字，空格，字母，其他内容分别有：",(digit_number,space_number,alpha_number,else_number))

res = func('sda!@#$%^&1234567dfghj da da ')

print(res)

# ('数字，空格，字母，其他内容分别有：', (7, 3, 12, 7))