Python知识

转载自:https://www.cnblogs.com/waltsmith/p/8029539.html

Python中的zip()与*zip()函数详解

前言

1. 实验环境: Python 3.6；
2. 示例代码地址：下载示例；
3. 本文中元素是指列表、元组、字典等集合类数据类型中的下一级项目（可能是单个元素或嵌套列表）。

zip(*iterables)函数详解

zip()函数的定义

• 从参数中的多个迭代器取元素组合成一个新的迭代器；
• 返回：
  返回一个zip对象，其内部元素为元组；可以转化为列表或元组；

• 传入参数：
  元组、列表、字典等迭代器。

  zip()函数的用法

• 当zip()函数中只有一个参数时
  zip(iterable)从iterable中依次取一个元组，组成一个元组。

• 示例：

## zip()函数单个参数
list1 = [1, 2, 3, 4]
tuple1 = zip(list1)
# 打印zip函数的返回类型
print("zip()函数的返回类型：\n", type(tuple1))
# 将zip对象转化为列表
print("zip对象转化为列表：\n", list(tuple1))

输出：

zip()函数的返回类型：
<class 'zip'>
zip对象转化为列表：
[(1,), (2,), (3,), (4,)]

• 当zip()函数有两个参数时
  • zip(a,b)zip()函数分别从a和b依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器--新的zip类型数据。
  • 注意：
    • 要求a与b的维数相同，当两者具有相同的行数与列数时，正常组合对应位置元素即可；
    • 当a与b的行数或列数不同时，取两者结构中最小的行数和列数，依照最小的行数和列数将对应位置的元素进行组合；这时相当于调用itertools.zip_longest(*iterables)函数。
• 举例：
  m = [[1,2,3], [4,5,6], [7,8,9]]
  n = [[2,2,2], [3,3,3], [4,4,4]]
  p = [[2,2,2], [3,3,3,]

zip(m, n)将返回([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3]), ([7, 8, 9], [4, 4, 4])

m[0], n[0]	m[1], n[1]	m[2], n[2]
[1,2,3] [2,2,2]	[4,5,6] [3,3,3]	[7,8,9] [4,4,4]

zip(m, p)将返回([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3])

m[0], n[0]	m[1], n[1]	m[2], n[2]
[1,2,3] [2,2,2]	[4,5,6] [3,3,3]	[7,8,9]

• 代码示例：

## zip()函数有2个参数
m = [[1, 2, 3],  [4, 5, 6],  [7, 8, 9]]
n = [[2, 2, 2],  [3, 3, 3],  [4, 4, 4]]
p = [[2, 2, 2],  [3, 3, 3]]
# 行与列相同
print("行与列相同:\n", list(zip(m, n)))
# 行与列不同
print("行与列不同:\n", list(zip(m, p)))

输出：

行与列相同:
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3]), ([7, 8, 9], [4, 4, 4])]
行与列不同:
[([1, 2, 3], [2, 2, 2]), ([4, 5, 6], [3, 3, 3])]

zip()函数的应用

• 矩阵相加减、点乘
  也可以使用for循环+列表推导式实现；
  m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  n = [[2, 2, 2], [3, 3, 3], [4, 4, 4]]

## zip()应用
# 矩阵相加减、点乘
m = [[1, 2, 3],  [4, 5, 6],  [7, 8, 9]]
n = [[2, 2, 2],  [3, 3, 3],  [4, 4, 4]]
# 矩阵点乘
print('=*'*10 + "矩阵点乘" + '=*'*10)
print([x*y for a, b in zip(m, n) for x, y in zip(a, b)])
# 矩阵相加,相减雷同
print('=*'*10 + "矩阵相加,相减" + '=*'*10)
print([x+y for a, b in zip(m, n) for x, y in zip(a, b)])

输出：

[2, 4, 6, 12, 15, 18, 28, 32, 36][3, 4, 5, 7, 8, 9, 11, 12, 13]

*zip(*iterables)函数详解

zip(iterables)函数

*zip()函数是zip()函数的逆过程，将zip对象变成原先组合前的数据。

• 代码示例：

## *zip()函数
print('=*'*10 + "*zip()函数" + '=*'*10)
m = [[1, 2, 3],  [4, 5, 6],  [7, 8, 9]]
n = [[2, 2, 2],  [3, 3, 3],  [4, 4, 4]]
print("*zip(m, n)返回:\n", *zip(m, n))
m2, n2 = zip(*zip(m, n))
# 若相等，返回True；说明*zip为zip的逆过程
print(m == list(m2) and n == list(n2))

输出：

*zip(m, n)返回:
([1, 2, 3], [2, 2, 2]) ([4, 5, 6], [3, 3, 3]) ([7, 8, 9], [4, 4, 4])
True

Python中的zip()与*zip()函数详解

---

Python classmethod 修饰符

• 描述
  classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

• 语法
  classmethod 语法：

classmethod

• 参数
  无。

• 返回值
  返回函数的类方法。

实例
以下实例展示了 classmethod 的使用方法：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    
    # 类方法不需要实例化类就可以被类本身调用
    @classmethod
    def func2(cls): # cls : 表示没用被实例化的类本身
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

---

numpy中array和asarray的区别

array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。

import numpy as np

#example 1:
data1=[[1,1,1],[1,1,1],[1,1,1]]
arr2=np.array(data1)
arr3=np.asarray(data1)
data1[1][1]=2
print 'data1:\n',data1
print 'arr2:\n',arr2
print 'arr3:\n',arr3

输出:
data1:
[[1, 1, 1], [1, 2, 1], [1, 1, 1]]
arr2:
[[1 1 1]
[1 1 1]
[1 1 1]]
arr3:
[[1 1 1]
[1 1 1]
[1 1 1]]

---

Python中的X[:,0]和X[:,1]

X[:,0]是numpy中数组的一种写法，表示对一个二维数组，取该二维数组第一维中的所有数据，第二维中取第0个数据，直观来说，X[:,0]就是取所有行的第0个数据, X[:,1] 就是取所有行的第1个数据。

举例说明：

 import numpy as np  
 X = np.array([[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[16,17],[18,19]])  
 print X[:,0]  

X[:,0]输出结果是：
[0,2,4,6,8,10,12,14,16,18]

---

np.random.shuffle(x)

该函数无返回值,直接将x打乱,打乱是"元素"级别的,比如x是二维数组,则打乱的是行:

a = np.random.randint(0,10,size=(5,5))
print(a)
shuffle_a = np.random.shuffle(a)
print(a)
##返回[[1 8 0 2 0]
 [9 0 7 7 5]
 [4 8 7 9 2]
 [6 4 3 8 4]
 [5 4 0 1 9]]
 和
[[9 0 7 7 5]
 [5 4 0 1 9]
 [1 8 0 2 0]
 [4 8 7 9 2]
 [6 4 3 8 4]]

---

np.random.choice(a, size=None, replace=True, p=None)

第一个参数表示从N中选择，第二个参数表示选几个,default是1个返回数字，replace具体用途还不知道，p表示概率

    >>> np.random.choice(5, 3)  
    array([0, 3, 4])  
      
    >>> np.random.choice(5, 3, p=[0.1, 0, 0.3, 0.6, 0])  
    array([3, 3, 0])  
      
    >>> np.random.choice(5, 3, replace=False)  
    array([3,1,0])  
      
    >>> np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])  
    array([2, 3, 0])  
      
    >>> aa_milne_arr = ['pooh', 'rabbit', 'piglet', 'Christopher']  
      
    >>> np.random.choice(aa_milne_arr, 5, p=[0.5, 0.1, 0.1, 0.3])  
    array(['pooh', 'pooh', 'pooh', 'Christopher', 'piglet'],  

---

linux命令行参数(-和–)

选项是调整命令执行行为的开关，即，选项不同决定了命令的显示结果不同。

选项分为长选项和短选项。

短选项：比如-h，-l，-s等。(后面接单个字母)

l短选项都是使用‘-’引导，当有多个短选项时，各选项之间使用空格隔开。

l有些命令的短选项可以组合，比如-l –h 可以组合为–lh

l有些命令的短选项可以不带-，这通常叫作BSD风格的选项，比如ps aux

l有些短选项需要带选项本身的参数，比如-L 512M

长选项：比如–help，–list等。(-- 后面接单词)

l长选面都是完整的单词

l长选项通常不能组合

l如果需要参数，长选项的参数通常需要‘=’，比如–size=1G

总结:

选项是限定结果的显示结果

短选项(- 一个横杠):只能修饰一个字符的选项，比如: ls -a,当然多个短选项可以合并，比如tar -cvf

长选项(-- 两个横杠):可以修饰单个字符，也可以修饰一个单词，比如:(1) chkconfig --list (2)chkconfig --add xxx (3)service --status-all

参数是传递到脚本中的真实的参数

ls -l和ls --l显示的有所出入

---

命令行运行Python脚本时传入参数的三种方式

如果在运行python脚本时需要传入一些参数，例如gpus与batch_size，可以使用如下三种方式。

python script.py 0,1,2 10 #不能输入参数名
python script.py --gpus=0,1,2 --batch-size=10
python script.py --gpus=0,1,2 --batch_size=10

这三种格式对应不同的参数解析方式，分别为sys.argv, argparse, tf.app.run, 前两者是python自带的功能，后者是tensorflow提供的便捷方式。

sys.argv

sys模块是很常用的模块， 它封装了与python解释器相关的数据，例如sys.modules里面有已经加载了的所有模块信息，sys.path里面是PYTHONPATH的内容，而sys.argv则封装了传入的参数数据。
使用sys.argv接收上面第一个命令中包含的参数方式如下：

import sys
gpus = sys.argv[1]
#gpus = [int(gpus.split(','))]
batch_size = sys.argv[2]
print gpus
print batch_size

argparse

import argparse
parser = argparse.ArgumentParser(description='manual to this script')
parser.add_argument('--gpus', type=str, default = None)
parser.add_argument('--batch-size', type=int, default=32)
args = parser.parse_args()
print args.gpus
print args.batch_size

用–gpus而不是-gpus,不然会出错
,另外需要注意的是，脚本运行命令python script.py --gpus=0,1,2 --batch-size=10中的–batch-size会被自动解析成batch_size.
parser.add_argument 方法的type参数理论上可以是任何合法的类型， 但有些参数传入格式比较麻烦，例如list，所以一般使用bool, int, str, float这些基本类型就行了，更复杂的需求可以通过str传入，然后手动解析。bool类型的解析比较特殊，传入任何值都会被解析成True，传入空值时才为False.

python script.py --bool-val=0 # args.bool_val=True 
python script.py --bool-val=False # args.bool_val=True
python script.py --bool-val=     # args.bool_val=什么都不写False

通过这个方法还能指定命令的帮助信息。具体请看API文档：https://docs.python.org/2/library/argparse.html

tf.app.run

tensorflow也提供了一种方便的解析方式。
脚本的执行命令为：

python script.py -gpus=0,1,2 --batch_size=10

对应的python代码为：

import tensorflow as tf
tf.app.flags.DEFINE_string('gpus', None, 'gpus to use')
tf.app.flags.DEFINE_integer('batch_size', 5, 'batch size')

FLAGS = tf.app.flags.FLAGS

def main(_):
    print FLAGS.gpus
    print FLAGS.batch_size

if __name__=="__main__":
    tf.app.run()

有几点需要注意：

1.tensorflow只提供以下几种方法：

tf.app.flags.DEFINE_string，

tf.app.flags.DEFINE_integer,

tf.app.flags.DEFINE_boolean,

tf.app.flags.DEFINE_float 四种方法，分别对应str, int,bool,float类型的参数。这里对bool的解析比较严格，传入1会被解析成True，其余任何值都会被解析成False。

2.脚本中需要定义一个接收一个参数的main方法：def main(_):，这个传入的参数是脚本名，一般用不到， 所以用下划线接收。

3.以batch_size参数为例，传入这个参数时使用的名称为–batch_size，也就是说，中划线不会像在argparse 中一样被解析成下划线。

4.tf.app.run()会寻找并执行入口脚本的main方法。也只有在执行了tf.app.run()之后才能从FLAGS中取出参数。从它的签名来看，它也是可以自己指定需要执行的方法的，不一定非得叫main：

run(
    main=None,
    argv=None
)

5 . tf.app.flags只是对argpars的简单封装。代码见https://github.com/tensorflow/tensorflow/blob/r1.2/tensorflow/python/platform/flags.py

---

python排序

• 非自定义排序

>>> class Student:
...     def __init__(self, name, grade, age):
...         self.name = name
...         self.grade = grade
...         self.age = age
...     def __repr__(self):
...         return repr((self.name, self.grade, self.age))
>>>
>>> student_objects = [
...     Student('john', 'A', 15),
...     Student('jane', 'B', 12),
...     Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

• 自定义排序
  在 python3 中，cmp 这个参数已经被移除了，那么在 python3 中应该怎么实现 python2 的 cmp 功能呢

import functools
def cmp(a, b):
    if a > b:
        return 1
    elif a < b:
        return -1
    else: return 0
a = [1, 2, 5, 4]
print(sorted(a, key=functools.cmp_to_key(cmp)))

---

xrange与range区别(python3中已无xrange)

xrange用法与range完全相同,所不同的是生成的不是一个list对象,而是一个生成器。要生成很大的数字序列的时候,用xrange会比range性能优很多,因为不用一上来就开辟一大块空间。

---

axis轴

自己做实验

arr = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(np.sum(arr,axis =0)) #还可以取axis=1,axis-2

---

dict判断元素是否存在

• dict可以当hashmap使用,num in dic.keys()用于判定键值是否存在
• num in dic与num in dic.keys()效果一致

---

循环dic里的元素

dic = {}
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3
for key, value in dic.items();
	....
**注意for i in dic仅仅是得到key的迭代器**

---

python字符串逆转(利用切片机制)

s_reversed=s[::-1]

---

python字典按照value进行排序

d = {'a':1,'b':4,'c':2}
d = sorted(d.items(),key = lambda x:x[1],reverse = True)

• 返回的是list类型,不再是dic
• 注意sorted函数本身并不改变传入的iterator的排序,所以要用一个值去接收返回值

---

numpy中的tile函数

>>> import numpy
>>> numpy.tile([0,0],5)#在列方向上重复[0,0]5次，默认行1次
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> numpy.tile([0,0],(1,1))#在列方向上重复[0,0]1次，行1次
array([[0, 0]])
>>> numpy.tile([0,0],(2,1))#在列方向上重复[0,0]1次，行2次
array([[0, 0],
       [0, 0]])
>>> numpy.tile([0,0],(3,1))
array([[0, 0],
       [0, 0],
       [0, 0]])
>>> numpy.tile([0,0],(1,3))#在列方向上重复[0,0]3次，行1次
array([[0, 0, 0, 0, 0, 0]])
>>> numpy.tile([0,0],(2,3))<span style="font-family: Arial, Helvetica, sans-serif;">#在列方向上重复[0,0]3次，行2次</span>
array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

---

numpy中的argsort函数(返回排序后的下标)

>>> x = np.array([3, 1, 2])
>>> np.argsort(x) #按升序排列
array([1, 2, 0])
>>> np.argsort(-x) #按降序排列
array([0, 2, 1])

>>> x[np.argsort(x)] #通过索引值排序后的数组
array([1, 2, 3])
>>> x[np.argsort(-x)]
array([3, 2, 1])

另一种方式实现按降序排序：

>>> a = x[np.argsort(x)]
>>> a
array([1, 2, 3])
>>> a[::-1]
array([3, 2, 1])   

---

python中sort和sorted函数

• 介绍
• sort函数是list列表中的函数，而sorted可以对list或者iterator进行排序
• sort和sorted的比较
• 用sort函数对列表排序时会影响列表本身，而sorted不会

>>> a = [1,2,1,4,3,5]
>>> a.sort
>>> a
[1, 1, 2, 3, 4, 5]

>>> a = [1,2,1,4,3,5]
>>> sorted(a)
[1, 1, 2, 3, 4, 5]
>>> a
[1, 2, 1, 4, 3, 5]

• sorted(iterable，cmp，key，reverse）
• iterable可以是list或者iterator；
• cmp是带两个参数的比较函数；
• key 是带一个参数的函数；
• reverse为False或者True；

用cmp函数排序

>>> list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]
   >>> sorted(list1,cmp = lambda x,y: cmp(x[0],y[0]))
   [('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]
   >>> sorted(list1,cmp = lambda x,y: cmp(x[1],y[1]))
   [('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

用key函数排序

>>> list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]
   >>> sorted(list1,key = lambda list1: list1[0])
   [('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]
   >>> sorted(list1,key = lambda list1: list1[1])
   [('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

用reverse排序

>>> sorted(list1,reverse = True)
   [('sara', 80), ('mary', 90), ('lily', 95), ('david', 90)]

---

python中类的全局变量

• 直接在类中声明，要用self调用该变量

class task_queue:
    queue=[]
    
    def append(self,obj):
        self.queue.append(obj)

---

python中的ascii码相减

• python中没有字符之间的直接相减运算，但可以通过ord()函数实现;ord()函数主要用来返回对应字符的ascii码

>>> ord('9')-ord('0')
9

---

tuple只支持读，不支持写

---

python交换对象

a, b = b, a

---

pandas

• 数据统计
  • describe统计下数据量、标准值、平均值、最大值等

print(data.describe())

* 运行效果

verified_type     review_id  like_counts
count    8880.000000  8.880000e+03  8880.000000
mean        9.778716  4.100745e+15     0.831194
std        47.350776  4.675363e+09    70.209162
min        -1.000000  4.100740e+15     0.000000
25%        -1.000000  4.100741e+15     0.000000
50%        -1.000000  4.100744e+15     0.000000
75%        -1.000000  4.100749e+15     0.000000
max       220.000000  4.100754e+15  6616.000000

• 读取csv前几行

#读取文件前5行
headdata = data.head(5)
print(headdata)

• 某行-所有列

#第一行所有数据,注意是数据的第一行,而不是表格第一行(列属性)
print(data.ix[0, ：])

• 某几行-所有列

#获取第2/4/6行的数据
print(data.ix[[1,3,5],：])

• 所有行-所有列

print(data.ix[:, :])

• 某列-所有行

# 读取username列所有的数据
print(data.ix[:, 'username'])

• 某几列-某几行

# 读取第1、3、5行，列名为username、verified_type、comment的数据
print(data.ix[[1,3,5], ['username','verified_type','comment']])

---

list中append 和 extend的区别

list.append(list1)，是将list1作为一个数据项、一个元素，追加在list中

>>> list=['a','b','c']
>>> list.append(['d','e','f'])
>>> list
['a', 'b', 'c', ['d', 'e', 'f']]
>>> len(list)
4
>>> list[-1]
['d', 'e', 'f']

list.extend(list1)，是将list1与list相连接

>>> list=['a','b','c']
>>> list
['a', 'b', 'c']
>>> list.extend(['d','e','f'])
>>> list
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(list)
6
>>> list[-1]
’f‘

• 如果append和extend的参数都是一个元素的话，是没有区别的，
• 若参数是一个列表或者元组的话，则存在如下区别：
• append是将它的参数视为element，作为一个整体添加上去的。
• extend将它的参数视为list，extend的行为是把这两个list接到一起，List里可以有任意的数据类型，所以，要分清这俩函数的区别。

---

python字典默认值

import collections
my_dict = collections.defaultdict(int) #此处选择自己的数据了类型

---

正则表达式切分字符串

用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：

>>> 'a b   c'.split(' ')
['a', 'b', '', '', 'c']

嗯，无法识别连续的空格，用正则表达式试试：

>>> re.split(r'\s+', 'a b   c')
['a', 'b', 'c']

无论多少个空格都可以正常分割。加入,试试：

>>> re.split(r'[\s\,]+', 'a,b, c  d')
['a', 'b', 'c', 'd']

再加入;试试：

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

如果用户输入了一组标签，下次记得用正则表达式来把不规范的输入转化成正确的数组。

---

python re模块中match、search、findall、finditer的区别

match

• 匹配string开头，成功返回Match object, 失败返回None，只匹配一个。

search

• 在string中进行搜索,成功返回Match object,失败返回None,只匹配一个

findall

• 在string中查找所有匹配成功的组, 即用括号括起来的部分。返回list对象，每个list item是由每个匹配的所有组组成的list。

finditer

• 在string中查找所有匹配成功的字符串, 返回iterator，每个item是一个Match object。

不多说概念，直接看栗子！

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from __future__ import print_function
import re

content = '333STR1666STR299'
regex = r'([A-Z]+(\d))'

if __name__ == '__main__':
    print(re.match(regex, content)) ##content的开头不符合正则，所以结果为None。

    ##只会找一个匹配，match[0]是regex所代表的整个字符串，match[1]是第一个()中的内容，match[2]是第二对()中的内容。
    match = re.search(regex, content)
    print('\nre.search() return value: ' + str(type(match)))
    print(match.group(0), match.group(1), match.group(2))  

    result1 = re.findall(regex, content)
    print('\nre.findall() return value: ' + str(type(result1)))
    for m in result1:
        print(m[0], m[1])

    result2 = re.finditer(regex, content)
    print('\nre.finditer() return value: ' + str(type(result2)))
    for m in result2:
        print(m.group(0), m.group(1), m.group(2))  ##字符串

输出

None 

re.search() return value: <TYPE ?_sre.SRE_Match?>
STR1 STR1 1 

re.findall() return value: <TYPE ?list?>
STR1 1 STR2 2 

re.finditer() return value: <TYPE ?callable-iterator?>
STR1 STR1 1 
STR2 STR2 2

试着把regex最外边的括号去掉，即regex = r’[A-Z]+(\d)’，组的个数就会减少一个：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from __future__ import print_function
import re

content = '333STR1666STR299'
regex = r'[A-Z]+(\d)'

if __name__ == '__main__':
    print(re.match(regex, content)) ##content的开关不符合正则，所以结果为None。

    ##只会找一个匹配，match[0]是regex所代表的整个字符串，match[1]是第一个()中的内容，match[2]是第二对()中的内容。
    match = re.search(regex, content)
    print('\nre.search() return value: ' + str(type(match)))
    print(match.group(0), match.group(1))  

    result1 = re.findall(regex, content)
    print('\nre.findall() return value: ' + str(type(result1)))
    for m in result1:
        print(m[0])

输出

None 

re.search() return value: <TYPE ?_sre.SRE_Match?>
STR1 1 

re.findall() return value: <TYPE ?list?>
1 2 

re.finditer() return value: <TYPE ?callable-iterator?>
STR1 1 
STR2 2

---

如何查看python的数据类型

type(data)

---