Python中内置的数据结构有六种:Number (数值)、String (字符串)、list (列表)、Tuple(元组),Dictionary (字典)、Set (集合)，除此以队外，数组、矩阵等结构需要导入工具包后才可以实现

数值和字符串

本单元主要讲解了Python中的数据结构 – 数值和字符串类型的基础操作。

详细内容要点：

1、数值类型的使用；

2、字符串的使用：

1）字符串的声明；

2）转义字符串；

3）原始字符串；

4）字符串的操作与运算。

操作时避免出错的点：

1、中英文符号：Python中只支持英文符号；

2、转义字符的使用；

3、字符串不能被修改；

4、字符串的加法运算只能用于字符串和字符串。

数组
Python3里支持int、float、bool、complex(复数）几种类型的数值。

a=5
b=2
print(a+b)   #7
print(a-b)   #2
print(a*b)   #10
print(a/b)   #2.5
print(a//b)  #2
print(a%b)  #1
print(a**b)  #25

Python中字符串是一个由多个字符组成的序列，字符的个数即为字符串的长度。Python中没有字符，单个字符被认作长度为1的字符串。

#创建字符串
s1="python"  #单引号和双引号创建字符串完全一样
s2='python'
s3='''
	python
   '''
#三引号字符串可以是多行字符串

a='o'
type(a)  #str

转义字符

#使用单引号和双引号创建多行字符串时可以使用转义字符\n实现
s="py\nthon"
'''
py
thon
'''

#还可以屏蔽掉符号的含义
s="python\""
print(s)   #python'

#在字符串中打印\
s="python\\"
print(s)   #python\

原始字符串
在字符串前加入字母r

s = r"p\y\tho\n"
print(s)    #p\y\tho\n

字符串的操作
字符串的元素访问，字符串是一个有序(元素有对应的下标)且不可变（定以后不能修改）的结构

s='python'
print(s[0])       #'p'    #通过对于下标访问元素，对应下标为0~n-1 

#不可变，修改其值会报错
s[0]="1"     #TypeError: 'str' object does not support item assignment

字符串的运算
加法运算，拼接字符串

a='hello'
b='world'
print(a+b)    # helloworld

乘法运算，只能和常数相乘，字符串重复

a='hello'
b=2
print(a*b)    #hellohello

字符串的常用操作
字符串常用的操作都提供了对应的方法，如切割、大小写替换、拼接等。这些操作并没有修改原有的字符串，而是生成了新的字符串。

#切割
#str.spilt(str1):以str1为分隔符对字符串切割
s='python'
s.spilt('h')    #['pyt','on']

#替换
#str.replace(str1,str2)  :将字符串中的str1替换成str2生成新的字符串
s='python'
s.replace('py','PY')     #'PYthon'

#大小写转换
#str.lower():将字符串中的大写字符转换成小写字符
#str.upper():将字符串中的小写字符转换成大写字符
s='PYthon'
print(s.lower())   #python
print(s.upper())   #PYTHON

#拼接
#str.join(iter) :将所给参数中每个元素以指定的字符连接生成一个新的字符串
'-'.join("python")    #'p-y-t-h-o-n'

格式化输出
格式化输出，是指将指定的数据按照给定的格式进行输出。

#格式化操作符（百分号%）、字符串转换类型和格式化操作符辅助指令实现格式化输出
"My name is %s , age is %d' %('AI'，63)    #'My name is AI , age is 63'

列表和元组

本章节主要讲解了Python中的数据结构 – 列表和元组的基础操作。

详细内容要点：

1、列表的使用：

1）列表的创建；

2）列表的操作；

3）切片与索引。

2、元组的使用：

1）元组的创建；

2）元组的不可变性。

操作时避免出错的点：

1、列表与元组访问数据时下标从0开始；

2、元组不可被修改；

3、单元素元组需要使用 “，” 声明

• 列表

列表是一个序列，其中的元素可以是任意的数据类型，并且可以随时的添加或者删除元素。List = [obj1, obj2…]

#创建列表
s=[1,2,3]
print(s[0])   #2    #访问列表元素

#修改元素
s[1]=5
print(s)   #[5,2,3]

列表运算符

a=[1,2,3]
b=[4,5]

列表中的运算符和字符串相同

#乘法
print(a*2)   #[1,2,3,1,2,3]
#加法
print(a+b)   #[1,2,3,4,5]

列表中提供了很多方法，用于列表数据的操作

animals=['cat','dog','monkey']
#list.append(obj):在列表末尾增加新的对象
animals.append('fish')
print(animals)   #['cat','dog','monkey','fish']

#list.remove(obj):移除列表中某个值的第一个匹配项
animals.remove('fish')  #删除元素fish
print(animals)   #['cat','dog','monkey']

#list.insert(index,obj):用于将指定对象插入列表的指定位置，index：插入位置
animals.insert(1,'fish') #在小标为1的地方插入元素fish
print(animals)  #['cat','fish','dog','monkey']

#list.pop([index=-1]):要移除列表中对下标对应的元素（默认是最后一个），index：下标
animals.pop(1)  #移除下标为1的元素
print(animals)  #['cat','dog','monkey']

pop和remove的区别在于pop会返回删除的数据

#遍历并获取元素和对应索引
#enumerate(sequence):将一个可遍历的数据对象组合成一个索引序列，同时列出数据和数据下标，一般用在for循环当中
for i in enumerate(animals):
	print(i)

'''
(0,'cat')
(1,'dog')
(2,'monkey')
'''

#列表推导式
squares=[x*2 for x in animals]  #批量生成符合规则的元素组成的列表
print(squares)  #['catcat','dogdog','monkeymonkey']

list1=[12,45,32,55]
#list.sort(cmp=None,key=None,reverse=False):cmp为可选参数，如果指定了该参数，会使用该参数的方法进行排序，key是用来进行比较的元素，reverse为排序规则，False为升序
list.sort()   #对列表进行排序
print(list1)   #[12,32,45,55]

#list.reverse():反向列表中的元素
list1.reverse()   #列表逆置
print(list1)   #[55,45,32,12]

切片与索引

#索引
l=[1,2,3,[4,5]]   #嵌套列表
l[3][0]  #4    #索引的访问从0到n-1，所有有序索引都能使用

#切片
#list[start:end:step],start为0时可以省略，end为-1时可以省略，step为1时可以省略，负数指反序
l=[0,1,2,3,4,5]
l[::]   #[0,1,2,3,4,5]
l[1:4:2]   #[1,3]

• 元组
  元组是一个不可变的有序序列，类似于字符串，但是不同的是，元组中的元素可以是任意对象。元组的形式为小括号包裹元素:(obj1,obj2…）

#创建元组
t=(1,[1,2],'python')
print(t)   #(1,[1,2],'python')
print(type(t))   #<class,'tuple'>

#创建单个元素的元组
t1=(5)
t2=(5,)   #创建单个元素的元组序使用','来标明是元组
print(type(t1))   #<class,'int'>
print(type(t2))   #<class,'tuple'>

需要用’,'标明是一个元组，而不是数学符号
通过下标访问元素

t=(1,2,3)
print(t[1])  #2

#元组不可改变，修改数据会报错
t[1]=9   #TypeError : 'tuple' object does not support item assignment

#变相修改元组数据
t=(1,2,[3,5])  #不推荐
t[2][1]=7
print(t)   #(1,2,[3,7])

此方法修改的是列表而不是元组
一般情况下，元组存的数据都是不希望被改变的数据

字典和集合

本章节主要讲解了Python中的数据结构 – 字典和集合的基础操作。

详细内容要点：

1、字典的使用：

1）字典的创建；

2）字典数据的获取；

3）字典数据的插入和修改；

2、集合的使用：

1）集合的创建和操作；

b）数据去重。

操作时避免出错的点：

1、字典使用中括号取值时，键必须存在；

2、字典的键需要是不可变类型的数据。

• 字典

字典的每个元素由两部分组成 – 键和值，所以字典的元素也披称为键值对。其中键是不可变且唯一的，如果字典有相同的键，则后面的键对应的值会将前面的值覆盖。数据量大时，字典数据的访尚速度比列装块。字典由一对花括号包裹，元素由逗号隔开:{key:value}。
键必须是不可变且唯一的，否则后面的键会覆盖前面的键对应的值，造成数据丢失

#字典的三种赋值操作
x={'food':'spam','quantity':4,'color':'pink'}
x2=dict(food='spam',quantity=4,color='pink')
x3=dict([('food','spam'),('quantity',4),('color','pink')])

print(x)    #{'food':'spam','quantity':4,'color':'pink'}
print(x2)   #{'food':'spam','quantity':4,'color':'pink'}
print(x3)   #{'food':'spam','quantity':4,'color':'pink'}

获取字典数据

#使用键取值
print(x['food'])     #spam
print(x['x'])    #KeyError:'x'
#如果访问不存在的值会报错

#使用get(key,['str'])方法获取数据
print(x.get('food'))  #spqm
print(x.get('x'))    #None #使用get方法获取数据时，如果键不存在会返回指定的值str
print(x.get('x','x不存在'))  #x不存在

#查看所有的键
print(x.keys())   #dict_keys([ 'food', 'quantity ' , 'color'])
#查看所有的值
print(x.values())   #dict_values([ 'Spam', 4,'pink'])
#查看所有的键值对
print(x.items())   #dict_items([('food', 'Spam ')， ( 'quantity' , 4)，('color', 'pink')])

#向字典中输入数据
x['x']='x'
print(x)   #{'food':'spam','quanity':4,'color':'pink','x':'x'}

#修改字典中的数据
x['x']=0
print(x)   #{'food':'spam','quanity':4,'color':'pink','x':0}

• 集合

集合中的元素是唯一的，重复的元素会被删除。集合是由一个花括号包裹，内部元素以逗号隔开:{obj1,obj 2… .},元素可以是任何类型

sample_set={'prince','techs'}
print('Data' in sample_set)   #False  #in的作用是检查集合中是否存在某一元素 

#set.add(obj):给集合添加元素，如果添加的元素已经存在，则不执行任何操作
sample_set.add('Data')
print(sample_set)  #{'techs','prince','Data'}
print(len(sample_set))  #3

#set.remove(obj):移除集合中的指定元素
sample_set.remove('Data')   #删除元素Data
print(sample_set)  #{'techs','prince'}

list2=[1,3,1,5,3]  #创建列表
print(list(set(list2)))   #利用集合元素的唯一性进行列表去重
sample_set=frozenset(sample_set)    #[1,3,5]  #frozenset不可变集合

运算符和数据拷贝

本章节主要讲解了Python中数据结构间的运算符和数据拷贝。

详细内容要点：

1、深拷贝和深拷贝；

2、运算符：

1）赋值运算符；

2）比较运算符；

3）逻辑运算符；

3）成员运算符；

4）身份运算符。

操作时避免出错的点：

1、注意深拷贝和浅拷贝的区别；

2、注意 is 和 == 的区别。

• 数据拷贝

在Python中对于数据的拷贝可以根据拷贝形式的不同分为深拷贝和浅拷贝

• 浅拷贝(copy())，即对数据的表面结构进行拷贝，如果数据为嵌套的结构，则嵌套结构里面的元素是对之前数据的引用。修改之前的数据会影响拷贝得到的数据。
• 深拷贝，解决了嵌套结构中深层结构只是引用的问题，它会对所有的数据进行一次复制，修改之前的数据则不会改变拷贝得到的数据。

#数据赋值
a=[1,2,3,[4,5]]
b=a   #赋值
c=a.copy()  #浅拷贝
import copy
d=copy.deepcopy(a)  #深拷贝

a[0]=6  #修改a的值
print(a)   #[6,2,3,[4,5]]
print(b)   #[6,2,3,[4,5]]
print(c)   #[1,2,3,[4,5]]
print(d)   #[1,2,3,[4,5]]

Python赋值不是把值赋给变量名，而是把地址赋给变量名

#修改嵌套列表的值
a[3][0]=7
print(a)   #[6,2,3,[7,5]]
print(b)   #[6,2,3,[7,5]]
print(c)   #[1,2,3,[7,5]]
print(d)   #[1,2,3,[4,5]]

• 运算符

#赋值运算符
a=5
a+=1
print('a+=1= ',a)  #a+=1:6
a-=1
print('a-=1= ',a)  #a-=1:5
a*=2
print('a*=2= ',a)   #a*=2:10
a/=2
print('a/=1= ',a)  #a/=2:5.0

#比较运算符
print(1>=2)   #False
print(1<=2)   #True
print(1!=2)   #True
print(1==2)   #False

#逻辑运算
True and False  #False
True or False   #True
not True   #False

#成员运算符
a=[1,2,3]
1 in a  #True

#身份运算符
#身份运算符比对两个对象是否是一个对象，即这两个对象对应的数据所在的内存地址是否是一块内存地址
a=[1,2]
b=a   #a和b指向同一个数据所在地址
c=a.copy()

print(a is b)  #True
print(a is c)  #False
print(a==b==c)   #True