梳理python基础数据类型 (一)

基础数据类型

1.数字
整数(int,long)：整数在3版本没有大小长度分别，内存决定整数最大长度
浮点数(float)：具有小数点的数，无穷小数会做精度处理
布尔(bool)：非空非0为真，0或空为假
复数(complex)：复数的标志为虚部以大写 “J” 或小写 “j” 结尾

>>> a = 1 #int
>>> a = 1.5 #float
>>> a = True #bool
>>> a = 2+3j #complex

知识梳理：
进制转换、数据类型详解、类型转换、运算符
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中


推荐详细学习网站：
https://www.runoob.com/python/python-numbers.html

2.字符串(str)：
o 表示方式：使用单引号 ‘abc’ ; 双引号 “abc” ; 或者这样 ‘’’abc’’’ , “””abc”””，单个字符也称作字符串
o 索引：str[index] 使用index选择访问位置，索引从左向右，从0开始，从右向左，从-1开始
o index 也是我们经常称呼的下标，下标值不可大于等于字符串最大长度
o 切片：str[start:stop:[step…]] ，切片可以获取字符串上一定区间中的值
o 字符串其中的内容不可变，字符串为不可变数据对象

>>> mystr = '' #创建空字符串
>>> mystr = "a" #单个字符同样为字符串
>>> mystr = 'abcdefg'
>>> mystr[0] #索引值为正时，顺序从左向右取对应位置数据
'a'
>>> mystr[-1] #索引值为负时，顺序从右边向左取对应位置数据
'g'
>>> mystr[:] #未给出开始，结束索引；选择整个列表范围内的值
'abcdefg'
>>> mystr[:2] #切片选择0-2范围内的值，不包含索引为2的值
'ab'
>>> mystr[-3:] #切片选择从-3到最后位置的值
'efg'
>>> mystr[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
'ac'
>>> mystr[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
'gfedcba'
>>> mystr[0] = 1 #当对字符串数据对象进行值修改，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment							

join 操作

":".join(map(str,range(9)))  #map（str,abc)  #map将abc转为字符串格式
>>'0:1:2:3:4:5:6:7:8'  
"*".join('abcd')  
>>'a*b*c*d'
"*".join(['abcdef'])  #列表内元素看成一个整体
>>'abcdef'    
s1='afsdff'
"*".join(s1)  #在每一个字符后面增加一个*
>>>'a*f*s*d*f*f' 
>s1=['1','2','3']
s2="".join(s1)# 将一个可迭代对象内的字符串拼接成新字符串.
print(s2)
>>>123

判断系列

#字符串is系列操作,返回值都是bool类型,是返回True,否则返回False  
isalnum() #是否是字母和数字组成  

isalpha() #是否是字母  

isdecimal() #是否只包含十进制数字  

isdigit() #是否全部数字(0~9)

isidentifier() #是不是字母和下划线开头，其他都是字母.数字.下划线

islower() #是否都是小写

isupper() #是否全部大写

isspace() #是否只包含空白字符

知识梳理：
Python 字符串连接 转义字符 字符串运算符
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
Python 字符串内建函数

3.列表(list)：
o 列表(list)是使用最频繁的数据之一
o 表示方式：使用中括号，逗号分隔每个数据元素：[ ‘a’, ‘b’ , ‘c’ ]
o 列表同样可以支持索引和切片操作
o 列表为可变数据对象，列表中的数据可以被修改
o 可以创建一个空列表，或者只有一个元素的列表

>>> mylist = [] #创建空列表
>>> mylist = [1,2,3,4]
>>> mylist[0] #索引值为正时，顺序从左向右取对应位置数据
1
>>> mylist[-1] #索引值为负时，顺序从右边向左取对应位置数据
4
>>> mylist[:] #未给出开始，结束索引；选择整个列表范围内的值
[1,2,3,4]
>>> mylist[:2] #切片选择0-2范围内的值，不包含索引为2的值
[1,2]
>>> mylist[-3:] #切片选择从-3到最后位置的值
[2,3,4]
>>> mylist[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
[1,3]
>>> mylist[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
[4,3,2,1]
>>> mylist[0] = 'a' #修改列表第一个位置上的值为字母'a'
>>> mylist
['a',2,3,4]#列表为可变数据对象	
________________________________________

知识梳理：列表增加元素 修改查询和删除


举例函数应用

统计

>>> names
['jiao', 'Tenglan', hong', 'Tom', 'hong', 1, 2, 3]
>>> names.count("hong")
2

排序&翻转

>>> names
['yu', 'Tenglan', 'lekai', 'Tom', 'lekai', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['yu', 'Tenglan', 'lekai', 'Tom', 'lekai', 1, 2, 3]
>>> names.sort()
>>> names
['1', '2', '3', 'yu', 'lekai', 'lekai', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'lekai', 'lekai', 'yu', '3', '2', '1']

重点详解：

浅拷贝
o 实现浅拷贝的几种方式：
o 切片拷贝
o copy函数（来自copy模块）

---

>>> mylist = [1,2,3]
>>> mylist1 = mylist[:] #mylist1切片拷贝自mylist
>>> mylist[0] = 'a'
>>> mylist
['a', 2, 3]
>>> mylist1
[1, 2, 3]
#切片实现浅拷贝，修改其中一个，另一个不会随之更改
________________________________________

>>> import copy
>>> mylist = [1,2,3]
>>> mylist1 = copy.copy(mylist)
>>> mylist[0] = 'a'
>>> mylist1
[1, 2, 3]
>>> mylist
['a', 2, 3]
#这里在进行浅拷贝之后，两个列表中的值修改不会互相影响
________________________________________

但是浅拷贝也存在一个问题，虽然可以将列表数据进行复制拷贝，但是只能是浅层对象的拷贝：

>>> import copy
>>> mylist = [1,2,['a','b']]
>>> mylist1 = copy.copy(mylist)
>>> mylist[-1][0] = 1 #修改嵌套列表中的第一个数据元素
>>> mylist
[1, 2, [1, 'b']]
>>> mylist1
[1, 2, [1, 'b']]
#此时浅拷贝无法拷贝深层对象，修改结果互相影响
________________________________________

深拷贝
o 实现深拷贝的方式：
o copy模块下的deepcopy函数

>>> import copy
>>> mylist = [1,2,['a','b']]
>>> mylist1 = copy.deepcopy(mylist)
>>> mylist[-1][0] = 1
>>> mylist
[1, 2, [1, 'b']]
>>> mylist1
[1, 2, ['a', 'b']]
#经过deepcopy函数拷贝后，深层次对象也会被拷贝

4.元组(tuple)：
o 元组和列表类似，不同之处在于元组内数据不可以被修改
o 表示方式：使用小括号，逗号分隔每个数据元素：( ‘a’, ‘b’, ‘c’ )
o 元组同样索引和切片操作
o 元组中的数据不可以被修改，元组为不可变数据对象
o 单纯的创建一个只含有一个元素的元组是会被解释器认为是一个实际数据对象，并不解释成元组
o 创建只含有一个元素的元组：(1,)

>>> mytuple = (1,) #正确方式创建只含有一个数据的元组
>>> mytuple
(1,)#返回值为元组
>>> mytuple = (1) #错误方式创建只含有一个数据的元组
1#返回值为整型
>>> mytuple = (1, 2, 3, 4, 5)
>>> mytuple[0]
1
>>> mytuple[-1] #索引值为负时，顺序从右边向左取对应位置数据
4
>>> mytuple[:] #未给出开始，结束索引；选择整个列表范围内的值
(1, 2, 3, 4, 5)
>>> mytuple[:2] #切片选择0-2范围内的值，不包含索引为2的值
(1, 2)
>>> mytuple[-3:] #切片选择从-3到最后位置的值
(3, 4, 5)
>>> mytuple[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
(1, 3)
>>> mytuple[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
(5, 4, 3, 2, 1)
>>> mytuple[0] = 'a' #当对元组数据对象进行值修改，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment	

知识梳理：访问元组 修改 删除
元组运算符 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素

5.字典集合数据类型
字典
o 字典以键值对形式存在：{ key: value }
o 其中key值会进行hash运算，生成hash表，所以字典的访问效率要优于普通序列数据类型(列表，元组)
o key值由于需要通过hash，则一些可变数据类型不可以做key值，而value的类型没有限制，可以是任意数据类型
o 由于进行了