n202_python数据类型和数据结构

3.数据类型和数据结构

python的数据类型大致可以分为两种：python自带的内置数据类型和第三方扩展包中的数据类型。

其中，python自带的内置数据类型可以分为两种：

• 可变数据类型：list(列表)、dict(字典)、set(集合)
• 不可变数据类型：int、float、complex、bool、tuple(元组)、str、frozenset(不变集合)

根据元素有无先后顺序之分，python数据类型分为序列和非序列结构。常见的序列类数据类型有元组(tuple)、列表(list)、字符串(str)。

第三方扩展包中的数据类型中常见的有：pandas中的DataFrame、Series，numpy的ndarray。通常第三方工具包提供的数据类型对python自带的数据类型进行了一些优化，做到更高效、更方便使用。

改变或指定python中变量的数据类型的方法——使用赋值语句。

python数据类型的注意事项：

① python自带的数据类型中没有直接提供"数组"的概念，而用"列表"和"元组"代替。它们可以较好的解决一维数组的问题，但是当表示多维数组时，需要进行列表或元组的嵌套，操作繁琐。所以python的数据分析中，常使用第三方包(如Numpy)进行多维数组的表达。

② 从使用角度看，可以将"列表"、"元组"、"字符串"统称为"序列结构"，具有一些共同的操作，如"*"、切片。

③ python中特殊的标量，如None、NotImplemented和Ellipsis。这些的返回值都是对象

3.1 数据类型

列表(list)	[1,2,3]
元组(tuple)	(1,2,3)
集合(set)
字典(dict)

字典与集合的区别：字典是带有Key的集合。

1.判断数据类型

用内置函数isinstance()可以判断变量所属的数据类型

isinstance(True,int)#output:True

上述语句输出结果是True的原因：在python中bool类型是int类型的子类。

2.转换数据类型

用数据类型函数，int()、float()、list()可以实现python对象数据类型的转换。通常，强制类型转换的函数名与目标数据类型的名称一致。例如，需要强转成int类型，则强制转换函数名为int()。

3.特殊数据类型

x=complex(1,1)
print(x,x.real,x.imag)#OUTPUT:(1+1j) 1.0 1.0
a=None
print(a)#只有使用print才能将None显示出来，否则什么也看不见

4.表达进制

int('1000',base=2)#output:8
int('1000',base=8)#output:512

第一个参数必须要有单引号或者双引号括起来，如果没有的话python解释器会按照变量名来处理，但是在python中变量必须先定义再使用，不定义不能使用。

5.科学计数法

在python中e代表的不是自然常数e=2.71828，而是科学计数法中的10。

9.9e3 #output:9900.0

6.序列类型

在python中，序列(Sequence)并不是特指一个独立的数据类型，而是泛指一种有序的容器，即有"下标"这一概念。python中常见的序列类型有列表、元组、字符串；集合不属于序列，因为其中的元素是没有先后顺序的。序列具有共同的特征和操作。

• “切片”操作

  seq1=[1,2,3,4,5,6]
  seq2=(1,2,3,4,5,6)
  seq3="123456"
  seq1[1:3],seq2[1:3],seq3[1:3]
  #output:([2, 3], (2, 3), '23')
  

• “*” 乘法作为重复运算

  seq3*3 #output:'123456123456123456'
  

	关键字	标志性符号	是否可变(允许局部替换)	是否为序列(支持序列操作)	强制类型转换函数
1 整型	int	无			int()
2 实型	float	小数点			float()
3 复数类型	complex	+、j			complex()
4 布尔型	bool	True、False			bool()
5 字符(串)型	str	'' ""		是	str()
6 列表	list	[]	是	是	list()
7 元组	tuple	()		是	tuple()
8 集合	set	{}	是		set()
9 集合常量	frozenset	{}			frozenset()
10 字典	dict	{}、Key	是		dict()

3.2 列表、元组、字符串

3.2.1 列表

1.列表下标表达方法：

	第1个元素	第2个元素	...	第n-1个元素	第n个元素
正数表示法	0	1		n-2	n-1
复数表示法	-n	-(n-1)		-2	-1

正数下标从0开始，编号自左向右👉

负数下标从-1开始，编号自右向左👈

2.对列表进行切片操作？

通过设置列表的可选参数start(切片开始位置包含)、stop(切片结束位置不包含)、step

myList[start:stop:step]

python序列的下标中出现[]、":"时，多数情况为对其进行"切片操作"。

在切片操作中，可选参数start、stop、step均可省略。

a=list("1234567890")
a,a[:5],a[:],a[2:]
"""
output:
(['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'],原始列表
 ['1', '2', '3', '4', '5'],省略start和step
 ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'],全部省略
 ['3', '4', '5', '6', '7', '8', '9', '0']),省略stop、step
"""

3.列表的常用操作：

合并运算	.extend()
删除运算	根据下标删除 .pop() 根据内容删除 .remove()
插入运算	.insert()
排序运算	.sort()
逆序运算	reversed()
跟踪下标运算	enumerate() # 显示有序容器中的每个元素及其下标
两个列表的同步计算	zip()

上述功能的实现，有的利用的是列表对象的"方法"，有的使用的是"python内置函数"。此外，"python内置函数"可以实现类似"方法"的功能，但二者在细节上有不同。如列表的.sort()方法对应的内置函数sorted()，虽然都可用于列表的排序，但是sorted()并不改变列表本身，而是生成了一个新的列表；但是前者则相反。

数据分析中应当特别注意数据分析过程中是否修改数据本身。

反向遍历: [::-1] (即step=-1)

a=list("1234567")#切片本身不会改变列表本身，因此当显示列表的当前值时，会显示其原来值
a,a[::-1]#output:(['1', '2', '3', '4', '5', '6', '7'], ['7', '6', '5', '4', '3', '2', '1'])

实现列表的反向遍历，还可以用内置函数reversed()或列表方法reverse()。

• reverse()函数返回的是一个迭代器 list_reverseiterator，使用list()强制转换方式显示其取值内容。

  a=[1,2,3]
  reversed(a) # <list_reverseiterator at 0x1c161126ca0>
  list(reversed(a)) # [3, 2, 1]
  a # [1, 2, 3] ——>说明内置函数reversed()并不改变a的本身
  

  内置函数reversed()不改变列表本身，列表方法.reverse()将改变列表本身。

  a=[1,2,3]
  a.reverse()#看不到任何东西，因为是特殊的数据类型None
  print(a.reverse())#使用print()函数才能见到None
  type(a.reverse())#NoneType
  a # [3, 2, 1] ——> 说明使用列表方法(列表名).reverse()已经改变了列表原始的值
  

• 类型转化

  用list()进行强制类型转化，可以将字符串类型——>列表类型。

  注意这里转化后的仍然是字符串类型，而不是数字(比如原来字符串是"123"——>"1","2","3")

• extend()和append()的区别

  extend() 平等地并列式合并；列表的"+"运算就是相当于是列表的extend()方法

  append() 以成员身份嵌入式追加

  a='123'
  a1=list(a)
  a1 #['1', '2', '3']
  a2=list(reversed(a)) # reversed()函数不会改变原始函数,推荐要求列表不变的情况下使用 
  a2 #['3', '2', '1']
  #列表的加运算等同于extend()是平等的并列式合并
  a1+a2 #['1', '2', '3', '3', '2', '1']
  a1.extend(a2) 
  a1 #['1', '2', '3', '3', '2', '1']
  a1.append(a2) # append()是以成员身份嵌入式追加,列表中嵌入列表
  a1 #['1', '2', '3', '3', '2', '1', ['3', '2', '1']]
  

4.列表推导式

列表推导式的结构：
需要重复计算的表达式	for	循环变量	in	迭代器

两个列表的并列相加计算，其中zip()函数的功能为并行迭代，此处使用了列表推导，列表推导式必须放在[]中。

a=[1,2,3]
b=[5,4,3]
[i**j for i,j in zip(a,b)] #[1, 16, 27]

python中列表推导式，可以简化复杂的for语句。由于python中有列表推导式、ufunc函数、向量化计算等机制，因此基于python的数据科学项目中一般不会出现复杂的for语句。

[2 for i in range(3)] #[2, 2, 2] 先做range(),再做i,最后做2
[i for i in range(3)] #[0, 1, 2]
range(20) #range(0, 20)
[type(i) for i in [True,1,1.9," ",[],(),{}]] #[bool, int, float, str, list, tuple, dict]
print([type(i) for i in [True,1,1.9]]) #[<class 'bool'>, <class 'int'>, <class 'float'>]

列表推导式可以嵌套在其他函数中使用，ord(i)函数用于返回单个字符i的ASCII值。

["n%d"%i+"  "+"time%d"%i for i in range(6)]
# ['n0  time0', 'n1  time1', 'n2  time2', 'n3  time3', 'n4  time4', 'n5  time5']
# %d是占位符 在对应位置上显示的是%i的值

5.插入与删除

列表中的insert()函数可以向列表中新增或插入分量

pop()函数可以删除向量中某个下标的元素

list=[1,2,3]
list.insert(0,8) #在列表中下标为0的位置上新增数字"8"，其余往后
list #[8, 1, 2, 3]
list.pop(3) #3
list #[8, 1, 2]

6.常用操作函数

• 计算列表长度的方法使用len()，并不是length()

• 排序函数sorted()不改变列表本身，列表方法.sort()会改变列表本身的内容

  在数据分析中注意使用的函数或方法是否影响被操作对象本身的值。

• 两个列表的同步计算zip()，这个函数和reversed()函数一样，返回值均为一个迭代器，要使用list()强转，观察其中取值

  a1=[1,2,3]
  a2=[4,5,6]
  c=zip(a1,a2)
  print(list(c)) #[(1, 4), (2, 5), (3, 6)]
  

  callable()是python的内置函数，用来检查对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用，类似于iterable（）
  在如上代码中，由于变量list和函数list重名了，所以函数在使用list函数时，发现list是一个定义好的列表，而列表是不能被调用的，因此抛出一个类型错误。(变量命名时一定要避免与python中的关键字以及函数名、方法名重名)

3.2.2 元组

1.什么是元组

元组是一种不可变的、有序容器，python中的标志性符号是()

2.如何定义元组？(4种方式)

①用圆括号()	myTuple1=(1,2,3)
②用赋值语句，将已定义的元组变量赋值给新的元组变量	myTuple2=myTuple1
③用强制类型转化的方法，将其他类型转化为元组	myTuple3=tuple("data")
④用逗号运算符，即将第①种方法种的()省去，out输出时会自动加上()	myTuple4=1,2,3

3.元组的特点

①在python种，凡是用","分隔开的，都是元组

②元组是一种序列结构，因此支持序列结构的基本操作，比如切片、len()、sorted()、in操作等

③元组是不可变对象

④元组支持"拆包式赋值"，即以对号入座方式赋值。

• 改变元组中的元素，python报错，因为元组是不可变对象；但使用list()强转，将元组转化为列表，因为列表是可变对象。

  myTuple1=1,2,3
  myList1=list(myTuple1)
  myList1 # [1, 2, 3]
  

• 元组的排序：元组经过内置函数sorted()后，生成结果的数据类型不是元组，而是列表

  myTuple1=1,3,2
  result=sorted(myTuple1)
  type(result),result # (list, [1, 2, 3])
  

  注意，python中的元组没有.sort()方法，因为元组是不可变对象，而.sort()方法会改变原来的元组对象本身。

• 元组的in操作，判断某个元素是否在元组中，返回值是True或False

  myTuple1=1,3,2
  1 in myTuple1,6 in myTuple1 # (True, False)
  

• 元组的频次统计，使用count()方法

  myTuple1=1,3,2,1,1,1,1
  myTuple1.count(1),myTuple1.count(6) # (5, 0)
  

• 元组的拆包式赋值规则：对号入座

  myTuple1=1,3,2,1,1
  x1,x2,x3,x4,x5=myTuple1
  x5,x2 # (1, 3)
  

4.元组的应用场景

①赋值语句，以"对号入座"方式赋值，如：x,y,z=1,2,3

②函数的实际参数，对应带有一个"*"的形式参数，如：def func(args1, *args2)

③函数的返回值，出现在return后，如：return 1,2,3

④两个变量的对调，如：x,y=y,x

x,y,z=1,2,3
%whos
"""
output：
Variable   Type    Data/Info
----------------------------
x          int     1
y          int     2
z          int     3
"""

• 在python中，元组对应的是带有一个"*"的形式参数，即"元组的形参接收不定长的实参"。

  def func(args1,*args2):
      print(args1)
      print(args2)
  func(6,1,2,3,4) 
  """
  6
  (1, 2, 3, 4) ——返回的是元组
  """
  

• 一个"*"对应的是元组，两个 "**" 对应的是字典：

  此时对应实参中必须显式给出每个key及其键值

  def func(args1,**args2):
      print(args1)
      print(args2)
  func(6,a=1,b=2,c=3,d=4)
  """
  6
  {'a': 1, 'b': 2, 'c': 3, 'd': 4} ——返回的是字典
  """
  

3.2.3 字符串

1.如何使用字符串？

可以使用单引号、双引号、三个单引号(当字符串本身占用多行式)

与C、Java不用的是python统一了“字符”与“字符串”的概念，认为字符是字符串的一种特例。当字符串本身含有单引号时，外部应当用双引号括起来；当字符串本身含有双引号时，外部应当用单引号括起来。也可以使用三个单引号，表示带有换行的字符串。

str1='''hello
lin
'''
str1 # 'hello\nlin\n'

2.转义字符

使用反斜杠 \ 表示，如果字符串本身就带有反斜杠\，处理方式有两种：

• 用 \ \ 来代替 \
• 字符串前加一个字母 r，代表原始字符串

3.python中字符串的特殊之处

①python中的字符串是不可变对象

②具有"序列"类型的共同特点，可以利用下标对字符串进行切片操作

不可变对象的含义是：该对象中的内容(取值)不会发生局部更改，与"动态类型语言"是不同概念。

4.python中字符串处理函数

① join()方法 或者 运算符+	字符串的合并
② strip()	去掉字符串左右的空白符号
③len()	计算字符串的长度
④upper() 或者 lower()	字符串的大小写转换
⑤sort()	字符串的排序
⑥成员运算符 in	判断某个字符是否在字符串中

• 字符串的合并

  join()方法的参数是"序列"，“.”之前的变量是分隔符号

  '_'.join(['test','01','OK']) # 'test_01_OK'
  'test'+'_'+'01' # 'test_01'
  

• 去除左右空白符号：空格、换行符等

  '   tes1  '.strip()  # 'tes1'
  

• 判断元素是否在字符串中

  'ts' in 'tes1','1' in 'tes1' # (False, True)
  

• 查看python字符集的方法

  python采用的是UTF-8(8-bit Unicode Transformation Format)

  内置函数ord()可以查看字符对应的Unicode编码，chr()则相反，根据Unicode编码还原出原始的字符。

  import sys
  sys.getdefaultencoding() # 'utf-8'
  chr(25105) # '我'
  ord('我')  # 25105
  

• 当字符串中含有转义字符时，输出方法s和print(s)的区别在于，前者不做转义

  s='1\t2'
  s # '1\t2'
  print(s) # 1	2
  'linG'.upper() # 'LING'
  'LING'.lower() # 'ling'
  

• 特殊字符及路径问题

  注意输入路径和输出路径的区别 一条杠变为两条杠

  r代表的是原始字符串，其含义是不对字符串进行转义处理

  s= 'H:\lin_work\编程\python\朝乐门'
  s # 'H:\\lin_work\\编程\\python\\朝乐门'
  print(s) # H:\lin_work\编程\python\朝乐门
  g= r'\t\n\b'
  g # '\\t\\n\\b'
  print(g) # \t\n\b
  

5.正则表达式

python的正则表达式(Regular Expression)的功能可以用模块re实现。

compile()函数和findall()方法的功能分别为“自定义一个正则表达式”和“用自定义正则表达式匹配目标字符串中的所有子字符串”。

3.3 序列、集合、字典

3.3.1 序列

序列(sequence)不是一个独立的数据类型，而是列表、元组、字符串等元素之间具有顺序关系的数据类型的统称。特点如下：

①支持切片	[start:stop:step]
②支持索引	通过下标myString[1]
③支持迭代	序列是可迭代的数据类型，for i in myString
④支持拆包式赋值	即对号入座，特点是左侧有多个变量，进行并行赋值
⑤支持重复运算符	myString*3
⑥设有通用函数	在python中，凡是“序列”类型的对象，均支持共性函数。

序列常用的函数：①计算长度len() ②排序sorted()

③逆序reversed() ④跟踪下标enumerate() ⑤同步计算zip() 三者均返回迭代器，使用list()可强转为列表

myString='无花可比芳容'
for i in myString:
    print(i,end=' ') # 无 花 可 比 芳 容 

3.3.2 集合

集合(set)，是一种可变的、无序容器。定义方法有3种:① {} ② 赋值语句 ③ set()强转

python中不可变的集合类型是frozenset

具有以下特点：确定性、互异性、无序性本身就是数学中集合的特点

1-确定性，判断方法用运算符in。 元素 in 集合

2-无序性，不能通过下标访问集合中的某个元素。

3-互异性，因此集合{1,2,3}和{1,2,3,3}视为相等

4-支持集合运算，比如并、交、差等等。

5-属于可变对象，添加元素使用.add()，删除元素使用.remove()

主要应用场景：去重——进行重复元素的过滤

list1=[1,2,1,2]
set1=set(list1)
set1 # {1, 2}

集合的基本操作：

1-元素与集合之间的属于关系	in 或者 not in
2-集合与集合之间的相等关系	== 或者 ！=
3-集合与集合之间的包含关系	<就是⊂，<=就是⊆
4-集合之间的并、交、差操作	| & -
5-将集合改变为不可变集合	frozenset(变回去再set()即可)

a={1,2,3}
b={1,2,4}
c=a|b
d=a&b
e=a-b
print("并集为{0},交集为{1},差集为{2}".format(c,d,e)) # 并集为{1, 2, 3, 4},交集为{1, 2},差集为{3}
d=frozenset(d)
d  # frozenset({1, 2})

3.3.3 字典

• 字典是一种可变的、无序容器，其中每个值(value)都有自己的键(key)。在python中，字典的标志性符号是{}，表示的是一个映射结构，及key与value之间建立了一种映射关系，本质上字典是一个以key为元素的集合。

  可以通过key去访问value，因此也可以借此去修改相应的键值。

a={"name":"lin","age":7,"gender":"man"} #除了数值外，其余key、value均需要加引号，不然是未定义的变量不可以使用
a['name'] # 'lin' 通过key去访问value
a['name'] = 'zhang'
a['name'] # 'zhang' 通过key去修改value

• 字典是无序对象，无法通过下标去访问其中的元素，只有通过键去访问键值，键是区分的唯一依据。当key为字符串时，要使用引号，否则会犯变量未定义的错误。NameError: name 'work' is not defined

  python中的可变数据对象(如列表、集合、字典等)不可哈希，因此字典的key不能是“不可哈希”（unhashable type）对象。

• 字典的主要应用场景：存放“临时数据”，作为函数的实参传递给形参，对应带有 ** 的形参，如def func(args1, **args2)。