python基础（二）-------数据类型

python开发基础篇（二）数据类型

python数据类型有：

1.数字

　　1.只能存放一个值

　　2.一经定义，不可更改

　　3.直接访问

　　主要的分类为：整型，长整型，（python2有长整型的概念Python统一为整型）布尔，浮点，复数

　　　　字符的函数

　　　　

2.字符串

　　定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串

　　无论是单引号多引号，只要是引号引起来的就都是字符串。

　　特性：

   　　1.只能存放一个值

   　　2.不可变

   　　 3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

补充：

  　　 1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l\thf'

   　　2.unicode字符串与r连用必需在r前面，如name＝ur'l\thf'

字符串“hello word ” 这本身就是一个字符串！

字符串的操作：

　　msg='hello'

　　移除空白 msg.strip()

　　分割msg.split('|')

　　长度len(msg)

　　索引msg[3] msg[-1]

　　切片msg[0:5:2]  #0  2  4

　　int()# 将字符转换为数字

　　msg.isspace() msg不能有空

　　msg.isdigit()  msg为整数

　　tpye(msg) 判断msg的类型

　　msg[0] msg的0索引是什么。

　　len((msg)) 计算msg的索引长度。

　　msg.replace(老，新) 将旧的内容替换成新的。

 

　3.列表

　　l=[1,2,3,4]

　　以中括号为特征，列表内可以是数字 也可以是字符串，可以是任意的数据类型。

　　定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

　　特性：

　　1.可存放多个值

　　2.可修改指定索引位置对应的值，可变

　　3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

　　list_test=[’lhf‘,12,'ok']

　　或

　　list_test=list('abc')

　　或

　　list_test=list([’lhf‘,12,'ok'])

　　取值方式：

　　print（list_test[0]） #中括号内的内容为该列表的索引位置

　　循环：循环的的方式有两种，一种是根据索引的方式，另一种是不根据索引！

　　根据索引的方式：

　　l=[1,2,3,[4,5]]

　　count =0

　　while count < len(l):

　　　　print(l[count])

　　　　count+=1

　　for count in range(len(l))

　　　　print(l[count])

　　不根据索引：

　　l=[1,2,3,[4,5]]

　　for count in range(len(l))　:

　　　　if type (l[count]) is list :

　　　　　　for i in range(len(l[count])):

　　　　　　　　　print(l[count][i])

　　　　　　else:

　　　　　　　　print(l[count])　

　可变类型与不可变类型：

id不动，type也不动，value被修改了，则称为可变类型

可变指的是：在id和type不动的前提下，值可变

切片操作：

　　l=['ab',1,2,'hello']

　　print(l[1:3])  #切片是对列表进行读的操作，并不会修改原来的数据！

　　追加：

　　l=['ab',1,2,'hello']

　　l.append('alex') #往列表内追加内容为alex的字符串！

　　print(l)

　　插入：

　　l.insert(2,'abc')  #根据索引来插入内容！

　　print((l)

　　删除：

　　　l.pop(l)  #用pop是从后往前删除！

　　统计长度用len(l)

　　队列与堆栈

　　#队列：先进先出
　　l=[]
　　#append与pop(0)
　　#入队列
　　# l.append('people1')
　　# l.append('people2')
　　# l.append('people3')
　　# print(l)
　　#出队列
　　# print(l.pop(0))
　　# print(l.pop(0))
　　# print(l.pop(0))

　　#insert(0,item)
　　入队
　　.insert(0,'people1')
　　l.insert(0,'people2')
　　l.insert(0,'people3')
　　# print(l)

　　#出队
　　# print(l.pop())
　　# print(l)
　　# print(l.pop())
　　# print(l)
　　# print(l.pop())

　　#堆栈：先进后出,或者说后进的先出
　　#append与
　　# l=[]
　　# l.append('people1')
　　# l.append('people2')
　　# l.append('people3')
　　# print(l)

　　# print(l.pop())
　　# print(l.pop())
　　# print(l.pop())

　　常用的操作：

　　list.append():追加成员

　　list.count(x):计算列表中参数x出现的次数

　　ist.extend(L):向列表中追加另一个列表L

　　list.index(x):获得参数x在列表中的位置

　　list.insert():向列表中插入数据

　　ist.pop():删除列表中的成员（通过下标删除）

　　list.remove():删除列表中的成员（直接删除）

　　list.reverse():将列表中成员的顺序颠倒

　　list.sort():将列表中成员排序

　4.元组

　　定义：与列表类似，只不过［］改成（）

　　特性：

　　1.可存放多个值

　　2.不可变

　　3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

　　

取值
# print(t[4][0])

#循环
t=('a',1,'b',1,(3,4))
# index=0
# while index < len(t):
# print(t[index])
# index+=1

# for i in range(len(t)):
# print(t[i])

#tuple类型的方法
# print(t.count(1))
# print(t.index('b'))

#tuple常用操作
# 索引
# 切片
# t=('a',1,'b',1,(3,4))
# print(t[1:3])
# print(t)
# 循环
# 长度
# print(len(t))
# 包含
#
# print('a' in t)

#元组的特性是：不可变,元组的元素可以是任意数据类型
# t=(1,2,['a','b'])
# print(id(t),type(t),t)

# t[2][0]='aaaaaaa'
# print(t)
# print(id(t),type(t),t)

# t[2]=3
# t[2][0]=123123123123

　5.字典

　　定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash

　　特性：

　　1.可存放多个值

　　2.可修改指定key对应的值，可变

　　3.无序

　　

　　Python字典包含了以下内置方法：

　　radiansdict={}

　　1、radiansdict.clear()：删除字典内所有元素

　　2、radiansdict.copy()：返回一个字典的浅复制

　　3、radiansdict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

　　4、radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值

　　5、radiansdict.has_key(key)：如果键在字典dict里返回true，否则返回false

　　6、radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组

　　7、radiansdict.keys()：以列表返回一个字典所有的键

　　8、radiansdict.setdefault(key, default=None)：和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

　　9、radiansdict.update(dict2)：把字典dict2的键/值对更新到dict里

　　10、radiansdict.values()：以列表返回字典中的所有值

　　6.集合：　　

集合的作用一：关系运算
集合的作用二：去重

定义集合：
 集合内的元素必须是唯一的；
 集合内的元素必须是可hash的，也是就不可变类型；
 集合是无序的

常用操作：

#关系运算
python_s={'egon','alex','钢蛋','老王'}　　　　　　　　
linux_s={'alex','钢蛋','欧德博爱','艾里科四'}

#取共同部分：交集
# print(python_s & linux_s)
#
#
# #取老男孩所有报名学习的学生：并集
# print(python_s | linux_s)
#
# #取只报名了python课程的学生：差集
# print(python_s - linux_s)

#取只报名了linux课程的学生：差集
# print(linux_s - python_s)

#取没有同时报名python和linux课程的学：对称差集

# print(linux_s ^ python_s)

python_s={'egon','alex','钢蛋','老王'}
# linux_s={'alex','钢蛋','欧德博爱','艾里科四'}

与符号的意义一样的操作！

# print(python_s.intersection(linux_s))# 交集：python_s & linux_s

# print(python_s.union(linux_s))#并集:|

# print(python_s.difference(linux_s)) #python_s-linux_s

# print(python_s.symmetric_difference(linux_s))# 对称差集，python_s ^ linux_s

# python_s={'egon','alex','钢蛋','老王'}
# linux_s={'alex','钢蛋','欧德博爱','艾里科四'}
# python_s.difference_update(linux_s)
# print(python_s)

bool值 True 和False

**所有的数据类型自带布尔值,只有0，None，空的布尔值为False

数据类型的转换总结：