Python自学入门(三)：数据类型详解
Python自学入门(一)：环境安装
Python自学入门(二)：数据类型和运算符
2.4 数据类型详解
2.4.1 数值
| 类型 | 说明 | 示例 |
|---|---|---|
| int | 整数 | 100，-5 |
| float | 浮点数 | 3.14，2.0，2e+5(科学计数法，2*105 ) |
| bool | 布尔型 | True(等同于1，表示肯定)， False(等同于0，表示否定) |
| complex | 复数 | 2+3j，1j(虚部的系数为1的时候必须写1，否则j会被当作变量j) |
print(2e+5) #科学计数法，浮点数 200000.0
print(2.0-1.1) #0.8999999999999999 浮点数是近似数
print(1.0-0.1) #0.9
print(True+5) #6
a=2+3j #复数
b=1j
print(a*b) #-3+2j
2.4.2 字符串
一个或多个字符组成的文本就是字符串。字符串可以用单引号、双引号、三引号包裹起来。
name="张三" #双引号
gender='男' #单引号
hometown='''北京''' #三引号
print(name,gender,hometown)
#三引号可以用于大段文本换行
info='''PKU
COE
MEM'''
print(info)
从字符串中截取字符的时候，需要通过字符的索引位置获得字符，从左到右索引是从0开始计数的。如果是负数，代表从右到左计数，从-1开始。
| 字符串 | P | y | t | h | o | n | 从 | 入 | 门 | 到 | 放 | 弃 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 索引(左->右) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 索引(右->左) | -12 | -11 | -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
str="abcdefg"
print(str[0]) #a 索引为0表示第1个字符
print(str[-1]) #g 索引为-1是从右向左计数
print(str[1:3]) #bc 索引顾头不顾尾
print(str[3:]) #defg 从索引为3的字符开始，截取到最后
print(str[:3]) #abc 从索引为0的开始截取，不包含结束字符
print(str[2:-1]) #cdef 从所以为2的开始，不包含结束字符
字符串拼接
#字符串拼接
str1="hello"+"world"
print(str1) #helloworld
#用指定字符做分隔符拼接字符串
str2=",".join(["hello","world"])
print(str2) #hello,world
#重复输出
str3="abc"*2
print(str3) #abcabc
#拼接字符串和非字符串
str4="abc"+str(123)
字符串其它常用操作
str1="h,e,l,l,o"
print("h" in str1) #True 判断包含
print("h" not in str1) #False 判断不包含
print(str1.find('e')) #2 查找字符，返回索引，不包含该字符返回-1
print(len(str1)) #9 获得字符串长度
print(str1.replace('l','w')) #h,e,w,w,o 替换指定字符
print(str1.split(",")) #根据指定字符分割字符串，得到一个列表
print(len("")) #0 ''叫空字符串，是长度为0的字符串
2.4.3 列表(list)
列表中可以存放多个元素，Python的列表元素可以是不同类型的。列表长度可变，可以动态删除或添加元素。
通过索引访问列表中的元素：
- 从左到右计数时，索引从0开始
- 从右向左计数时，索引从-1开始
#列表中可以存放不同类型的数据，左边称为表头，右边是表尾
list1=["hello","list",123,True,3.14]
print(list1[0]) #hello，从左向右，左边第1个元素
print(list1[1]) #list，从左向右，左边第2个元素
print(list1[-1]) #3.14，从右向左，右边第1个元素(列表最后一个元素)
print(list1[-2]) #True，从右向左，右边第2个元素(列表倒数第二个元素)
列表截取的语法与字符串截取的语法类似：
list2=[0,1,2,3,4,5,6]
print(list2[2:5]) #[2, 3, 4]，从左到右，截取索引为2(包含)到索引为5(不包含)的元素
print(list2[1:-1]) #[1, 2, 3, 4, 5]，截取从左到右索引为1(包含)到右边倒数第1个(不包含)
print(list2[1:]) #[1, 2, 3, 4, 5, 6]，从左到右，索引为1的到末尾
print(list2[:3]) #[0, 1, 2]，从表头到索引为3(不包含)
通过索引更新(修改)列表中的元素
list3=['a','b','c']
list3[2]='d' #修改索引为2的元素
print(list3) #['a', 'b', 'd']
通过del命令删除元素，删除元素后，该位置之后的元素会向前移动，列表长度-1
list4=['a','b','c','d']
del list4[1] #删除索引为1的元素 后面元素会向前移动
print(list4) #['a', 'c', 'd']
print(list4[1]) #c。原列表中被删除的是b,后面的元素会向前移动，代替b的位置
list4.remove('c') #remove是根据元素值删除元素，元素不存在会报错
print(list4)
列表其它操作
list5=['a','b']
list6=list5*3 #将原列表重复2次，生成新列表
print(list6) #['a', 'b', 'a', 'b']
list7=['hello','list']
list8=list5+list7 #将两个列表拼接起来得到新的列表
print(list8)
print(len(list5)) #获取列表长度
print('a' in list5) #判断元素是否在列表中
newList=list("hello") #生成列表，结果是['h', 'e', 'l', 'l', 'o']
print(newList)
newList.append('a') #列表末尾追加一个元素，结果是['h', 'e', 'l', 'l', 'o', 'a']
print(newList)
newList.extend([1,2,3]) #列表末尾追加一个序列，结果是['h', 'e', 'l', 'l', 'o', 'a', 1, 2, 3]
print(newList)
print(newList.count('h')) #元素出现的次数
print(newList.index('l')) #元素第一次出现的位置
newList.insert(1,'a') #在指定位置插入元素
print(newList)
print(newList.pop()) #返回列表中最后一个元素，并将改元素从列表中删除(出列)
print(newList)
newList.reverse() #反转列表
print(newList)
newList=['h', 'e', 'l', 'l', 'o']
newList.sort() #排序，元素类型要相同,默认升序
print(newList)
newList.sort(reverse=True) #倒序排列
print(newList)
listA=['h', 'e', 'l', 'l', 'o']
listB=listA.copy() #复制原列表，得到新列表
print(listB)
listB.clear() #清空列表
print(listB)
2.4.4 元组(tuple)
元组用法与列表类似，元组与列表的区别是元组中的元素不能修改。元组声明用括号
()包裹元素。声明元组的时候需要注意，如果元组中只有一个元素，需要在元素后面加一个逗号，否则变量类型会被认为是元素对应的类型，而不是元组
tupleA=(3,4) #tuple
print(type(tupleA))
tupleA=(3) #int
print(type(tupleA))
tupleA=(3,) #tuple
print(type(tupleA))
通过索引访问元组元素，截取元组的语法与列表一样，另外len、max、min、+、*n、in等操作也与列表一样。
tupleB=('t','u','p','l','e')
print(tupleB[0]) #t
print(tupleB[1]) #e
print(tupleB[0:3]) #('t', 'u', 'p')
tuple("1234") #创建元组('1', '2', '3', '4')
tuple([1,2,3,4])#根据列表生成成元组 (1, 2, 3, 4)
元组中的元素不能修改
tupleC=(1,2,3)
tupleC[0]=10 #错误，'tuple' object does not support item assignment
tupleD=(1,2,3)
tupleE=(10,20)
tupleG=tupleD+tupleE #生成新的元组，不会影响原来的元组
print(tupleD)
print(tupleE)
print(tupleG)
元组元素不能修改，指的是相同内存地址存储的元素值不能修改，给元组变量重新赋值是创建了新的元组，并没有改变原来的元组对象，可以通过id(tuple)查看内存地址。
tupleF=(1,2) #创建一个元组，分配内存
tupleF=(3,4) #创建了新的元组，重新分配内存
2.4.5 集合(set)
集合是无序不重复的序列。集合使用大括号
{}。集合中的顺序指的是存入和元素排列的顺序，不是元素值的大小顺序。先存入的元素在后存入的元素之前，就是有序集合。元素排列的顺序与存入的先后无关，就是无序集合。
set1={"hello","集合","123","你好"}
set1.add("你好") #添加失败 集合中已经存在该元素
set1.add("abc") #添加成功
print(set1) #重复的元素只保留一个
set1.update([1,2,"a"]) #添加多个元素用update方法
print(set1)
set1.remove("hello") #删除元素，元素不存在会报错
set1.discard("123") #删除元素，元素不存在不会报错
print(set1)
print(set1.pop()) #弹出一个元素
setA={0,1,2,3,5,7,9}
setB={0,1,2,4,6,8}
setA.difference(setB) #差集 A里有B里没有
setA.union(setB) #并集
setA.intersection(setB) #交集
2.4.6 字典(dictionary)
字典是一种key-value形式存储的键值对集合。无序，key不可重复。key是不可变类型，可以用数字、字符串、元组当作key。value的类型没有限制。
dic1={'name':'张三','age':15} #声明字典
print(dic1['name']) #根据key获取value
dic1['name']='李四'
print(dic1['name'])
del dic1['name'] # 删除键 'name'
print(dic1)
dic1['phone']='13788889876' #如果key不存在，会直接加入到字典中
print(dic1)
dic1['phone']='18567896789' #key存在则会覆盖原来的value
print(dic1)
print(len(dic1)) #字典中元素个数
print('phone' in dic1) #key是否在字典中
print(dic1.pop('phone')) #弹出一个元素
print(dic1)
dic1.clear() # 清空字典
print(dic1)
2.4.7 可变类型和不可变类型
**不可变类型：**Number（数字）、String（字符串）、Tuple（元组）
**可变类型：**List（列表）、Set（集合）、Dictionary（字典）
可变和不可变指的是同一个内存地址存储的值是否可变
numA=123
numB=numA
print(numA is numB) #True
numB=456 #numA不变，改变的是numB指向的地址
print(id(numA),id(numB)) #地址不同
dicA={'name':'张三'}
dicB=dicA
print(dicB is dicA) #True
dicA['age']=10 #dicB改变
print(id(dicA),id(dicB)) #地址相同
print(dicB)
课后习题
一、填空题：
(1) 计算5的三次方。
(2) 16%3结果是________
(3) 3*2**3结果是______
(4) 11//2结果是_______
(5) x = True;y = False;z = False则：
x or y and z 结果是_______
(x or y) and z 结果是_______
(6) 4|3结果是______
4&2结果是______
二、选择题：
1.下面( )是合法的标识符。
(A) persons
(B) 2Users
(C) *point
(D) this
2.以下是合法标识符的是( )
(A) 123
(B) _name
(C) class
(D) 1first
3.下列标识符错误的是( )
(A) _sys1
(B) $_m
(C) I
(D) name40
三、问答题：
1.列表、元组、集合、字典的区别