目录
一.数据类型1.1 数字型(Numbers)
1.2 布尔型(Boolean)
1.3 字符型(Strings)
二.内置容器
2.1 列表(List)
2.2 元组(tuple)
2.3 字典(Dict)
2.4 集合(Set)
一.数据类型
python和其他编程一样,包括几种数据类型:整形、浮点型、布尔型、字符型。这类数据类型的使用方法与其他编程语言很相似
1.1 数字型(Numbers)
(1)numbers是python中的数字类型,其包括:整数(长整数)、浮点数、复数。
(2)对数字类型的操作符有:加减乘除、幂运算(**)、与或非运算。
内置数学函数:pow、abs、round、int、hex、bin。
公用模块:random、math等。
#python中数据类型不用预先声明,直接传递数据即可
x = 3 #创建整形3
print type(x) # Prints "<type 'int'>"
print x # Prints "3"
print x + 1 # 加法运算; prints "4"
print x - 1 # 减法运算; prints "2"
print x * 2 # 乘法运算; prints "6"
print x ** 2 # 幂运算; prints "9"
x += 1 # 增一操作
print x # Prints "4"
x *= 2 # 倍增操作
print x # Prints "8"
y = 2.5 # 创建浮点型2.5
print type(y) # Prints "<type 'float'>"
print y, y + 1, y * 2, y ** 2 # Prints "2.5 3.5 5.0 6.25"
1.2 布尔型(Boolean)
(1)Python的布尔类型与别人的编程语言一致,不过在逻辑符号的表示上有了一些改变。
逻辑符号:and、or、not、!=
布尔值:True、False
t = True
f = False
print type(t) # Prints "<type 'bool'>"
print t and f # Logical AND; prints "False"
print t or f # Logical OR; prints "True"
print not t # Logical NOT; prints "False"
print t != f # Logical XOR; prints "True"
(2)Python会把0、空字符串”和None看成 False,其他数值和非空字符串都看成 True。因此我们可以使用逻辑符号来连接表达式,另外需要注意的是,python进行逻辑计算时,可能会遇到短路问题,如下面的程序:
a = True
print a and ‘a=T’ or ‘a=F’ #输出为a=F
输出结果为什么是a=F,而不是True。
原因是这里存在短路计算的原则:
* 在计算 a and b 时,如果 a 是 False,则根据与运算法则,整个结果必定为 False,因此返回 a;如果 a 是 True,则整个计算结果必定取决与 b,因此返回 b。
* 在计算 a or b 时,如果 a 是 True,则根据或运算法则,整个计算结果必定为 True,因此返回 a;如果 a 是 False,则整个计算结果必定取决于 b,因此返回 b。
首先计算a and 'a=T',计算结果是 ‘a=T’ 。 之后计算‘a=T’ or ‘a=F’ 计算结果还是 ‘a=T’
1.3 字符型(String)
(1)python中字符串可以看做是一个有序的字符的集合,用于存储和表现基于文本的信息。
(2)因为字符串可以看做一个集合,因此针对序列数据的操作对字符串同样适用,比如索引、分片、乘法、判断成员资格、求长度、取最大最小值、合并、分片等操作。
hello = 'hello' # 使用单引号创建
world = "world" # 也可用双引号创建
print hello # Prints "hello"
print len(hello) # String length; prints "5"
hw = hello + ' ' + world # 直接用加号,可以进行字符合并
print hw # prints "hello world"
hw12 = '%s %s %d' % (hello, world, 12) # 可以预先拼写字符格式 %s(字符型) %d(整数型)
print hw12 # prints "hello world 12"
(3)要注意python中字符串是不可变的,因此对字符串的项或者分片进行赋值操作是不合法的。
website='www.baidu.com'
website[-2:]='con' #报错 'str' object does not support item assignment
(4)针对字符串的方法有:find()、join()、lower()、replace()、split()、strip()、translate()等方法。
s='hellO'
print s.find('e') # 输出搜索词所在的索引位置;print 1
print s.capitalize() # 首字母大些; prints "Hello"
print s.lower() # print "hello"
print s.strip() # 除去两侧空格
print s.upper() # 全转为大些; prints "HELLO"
print s.rjust(7) # Right-justify a string, padding with spaces; prints " hellO"
print s.center(7) # 让字符居中来扩充空间; prints " hellO "
print s.replace('l', '(ell)') # Replace all instances of one substring with another;prints "he(ell)(ell)O"
print 'world '.strip() # 将所有字符小写; prints "world"
二.内置容器
python中的容器是通过某种方式将不同类型的数据组织在一起,是一种数据结构,常见的内置有:List、Dictionary、Set、Tuple。
2.1 列表(List)
(1)列表是python中最常用、最具灵活性的有序集合对象,使用[]进行表示,其内部可以包含任何种类的对象包括:数字、字符、列表等。
xs = [3, 1, 2] # Create a list
print xs, xs[2] # Prints "[3, 1, 2] 2"
(2)列表不同于字符串、元组的是,列表是一个可变类型,其内部数据可以进行修改,其可以对容器原处进行修改、还能实地的增加、缩短长度。
list1=[1,2,3,4]
list1[2]=5 #对第二个索引位置进行修改
print(list1) #print [1, 2, 5, 4]
(3)对列表的基本操作包括:索引、分片、序列相加(拼接)、乘法(倍增)、成员资格判断、求长度、最大最小值等操作。
xs = [3, 1, 2,5,8,9] # 创建一个列表
print(xs, xs[2]) # Prints "[3, 1, 2,5,8,9] 2"
print(xs[-1]) # 反向寻找列表中倒数第一个数; prints "9"
xs[2] = 'foo' # Lists can contain elements of different types
print(xs) # Prints "[3, 1, 'foo',5,8,9]"
xs.append('bar') # Add a new element to the end of the list
print(xs) # Prints "[3, 1, 'foo',5,8,9 'bar']"
x = xs.pop() # Remove and return the last element of the list
print(x, xs) # Prints "bar [3, 1, 'foo',5,8,9 ']"
xss=xs[2:4] # 对[3, 1, 'foo',5,8,9 ']做分片操作
print(xss) # print['foo', 5]
xss=xs+['n1','n2']#对[3, 1, 'foo',5,8,9 ']做序列相加
print(xss) #print [3, 1, 'foo', 5, 8, 9, 'n1', 'n2']
xss=xs*3 #对序列做乘法操作
print(xss) #print [3, 1, 'foo', 5, 8, 9, 3, 1, 'foo', 5, 8, 9, 3, 1, 'foo', 5, 8, 9]
'foo'in xss #进行成员判断,输出逻辑值 print True
print(len(xss)) #获取长度
注意:
*做分片操作时,如xs[2:4]是取第2个到第3个索引的数,尾部索引值不取。
*当内部有字符串类型时,不能进行sorted(排序)、min(获取最小值)、max等数值操作。
2.2 元组(Tuple)
(1)元组和列表一样是一种序列,使用()定义,内部可以包含各种数据类型,两者唯一的不同是元组不可修改,属于不可变序列类型,但是元组元素的元素是可以修改的。
t = (17, 'Jesse', ('LinuxKernel', 'Python'), [17, 'Jesse'])
t[0] = 18 #报错不可修改 不可改变内部元素 TypeError: 'tuple' object does not support item assignment
t = (11,22,["alex",{"k1":"v1"}])
t[2][1]['k1']='k2' #对元组内部元素的元素进行修改
print(t) #输出 (11, 22, ['alex', {'k1': 'k2'}])
(2)我们可以使用两者方式来定义元组,一种是使用[]直接定义元组,另一种是使用tuple来定义存放可迭代的数据类型。
ages = (11, 22, 33, 44, 55) #第一种定义方式
ages = tuple((11, 22, 33, 44, 55)) #第二种定义方式
(3)对元组的操作没有序列那么多,主要有:索引、合并、重复、迭代等操作。
tup = (55,77,85,55,96,99,22,55,)
tup.count(55) #返回结果:3 元素‘55’在元组tup中出现了3次
tup = (55,77,85,55,96,99,22,55,)
tup.index(55) #返回结果:0
tup.index(85) #返回结果:2
tup.index(55,2,7)
name_tuple = (1,2,3) #进行切片操作
print(name_tuple[0:2]) #输出(1,2)
name_tuple = (1,2,3) #获取元组长度
print(name_tuple[len(name_tuple)-1]) #输出 3
(4)既然有了列表,而有时必须要使用元组的原因是
*有些地方必须要用元组,比如字典中键的声明,键从本意上是不允许修改的,这样就比较适合对元组的使用。
2.3 字典(Dictionary)
(1)字典是python中比较灵活的内置数据结构类型,字典就像JAVA里面的map,以及JavaScript中的Object,是一种无序的集合,不同于之前的列表(有序集合),Dictionary通过定义键值对,使得内部的元素通过键进行存取,而不是使用序号偏移。
d = {'cat': 'cute', 'dog': 'furry'} # 使用键值对创建字典
print(d['cat']) # 通过字典的键,获取对应的值; prints "cute"
(2)字典有很大的灵活性,我们可以使用数字、字符串、元组等不可变数据类型来定义键,而且保存在字典中的项没有特定顺序,因此不能使用分片、合并等序列操作,并且内部的键值是不可重复的。
d = {'cat': 'cute', 'dog': 'furry'} # 使用键值对创建字典
#print(d[0]) # 按位置获取会报错 Error:KeyError: 0
print(d.keys()) #获取所有键 输出dict_keys(['dog', 'cat'])
print(d.values()) #获取所有对应值 输出dict_values(['furry', 'cute'])
print(d['dog']) #获取键dog对应值 输出furry
(3)对字典的基本操作包括修改字典(修改已有key的value)、增加新键值对、修改已有键值对、成员判断、迭代等操作。
person={'name':'zyb','addr':'hainan'} #定义字典
person=dict({'name':'zyb','addr':'hainan'})
print(person['name']) #查询内部元素 输出 zyb
person.get('name')
person['sex']='男' #修改键对应值
print(person) #打印输出 {'sex': '男', 'name': 'zyb', 'addr': 'hainan'}
person.pop('sex') #删除字典中一个键值对
#del person['sex']
print(person) #删除后输出:{'name': 'zyb', 'addr': 'hainan'}
for key in person: #遍历输出所有的键值:name addr
print(key)
person.clear() #清空所有字典,
print(person) #输出空字典{}
person1={'name':'zyb','addr':'hainan'}
personcp=person1.copy()
print(personcp) #进行内容拷贝,输出为{'name': 'zyb', 'addr': 'hainan'}
personmk={}.fromkeys(['name','age'])
print(personmk) #使用fromkey方式常见字典,输出{'age': None, 'name': None}
2.4 集合(Set)
(1)集合是python中一种无序且不重复的元素集合,其内元素是不可变对象,使用{}进行定义。*进行集合定义时有两种方式,一种是使用set(),另一种是使用{}直接创建。
a=set('boy')
print(a,type(a)) #最简单的创建方式,输出{'y', 'o', 'b'} <class 'set'>
b=set(['y', 'b', 'o','o'])
print(b,type(b)) #列表不能作为集合的内部元素,所以列表不能保留下来,内部元素将作为集合元素,输出{'y', 'o', 'b'} <class 'set'>
c=set({"k1":'v1','k2':'v2'})
print(c,type(c)) #使用字典来创建,会直接提取其中的键,输出{'k1', 'k2'} <class 'set'>
d={'k1','k2','k2'}
print(d,type(d)) #集合内元素是不重复的,所以只保留了两个元素,输出{'k1', 'k2'} <class 'set'>
e={('k1', 'k2','k2')}
print(e,type(e)) #元组可以作为集合的内部元素,输出出来,输出{('k1', 'k2', 'k2')} <class 'set'>
(2)对集合的操作包括集合比较、删除、交集、成员判断、合并、更新等操作。
#比较操作
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be) #找到se中存在,be中不存在的集合,返回不同的值
print(temp1) #{33, 11}
#删除操作
se = {11, 22, 33}
se.discard(11) # 移除元素11
se.discard(44) # 移除不存的元素44,未报错
print(se) # 打印输出{33, 22}
#取交集操作
se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be) # 取se和be之间的交集(共同存在的元素),赋给新值
print(temp1) # 输出22
#集合的更新
se = {11, 22, 33}
be = {22,44,55}
se.update(be) # 使用be对se进行更新,会将be的值对se进行覆盖
print(se) # 输出结果:{33, 22, 55, 11, 44}
#集合的转换
se = set(range(4)) #生成四个数0,1,2,3 组成一个集合
li = list(se) #将集合转换成列表
tu = tuple(se) #将集合转成元组
st = str(se) #将集合转成字符串
print(li,type(li)) #输出[0, 1, 2, 3] <class 'list'>
print(tu,type(tu)) #输出(0, 1, 2, 3) <class 'tuple'>
print(st,type(st)) #输出{0, 1, 2, 3} <class 'str'>