基本数据类型及内置方法

数据类型是用来记录事物的状态，而事物的状态又是随时变化的（），这意味着程序员在开发的过程中需要对数据进行着一系列复杂而频繁的操作，为了提高效率问题，python内部针对这一系列的操作，为每一种数据类型都内置了一系列方法

一 数字类型int，float

　　1.1.定义：

　　　　整型(int):a = 10 >> a = int(10)

　　　　浮点型（float）：a = 10.2 >> a = float(10.2)

　　　　注：名字+（）相当于调用某个功能

　　　　　　print（）#调用打印功能

　　　　　　int（）#调用创建整型数据的功能

　　　　　　float（）#调用创建浮点型数据的功能

　　1.2.类型转换：

　　　　1.2.1int可以将含有纯整数的字符串转化成整形，含有非整型的数字不能转化成整型

　　　　　　正确演示

　　　　　　>>s='10'

　　　　　　>>a=int(s)

　　　　　　错误演示

　　　　　　>>s='10.2'

　　　　　　>>a=int(s)#运行时会报错

　　　　1.2.2进制转换

　　　　　十进制转换成其他进制

　　　　　　>>a=11

　　　　　　>>bin(a)#转二进制

　　　　　　>>oct(a)#转八进制

　　　　　　>>hex(a)#转十六进制

　　　　　其他进制转十进制

　　　　　　>>int('0b11',2)#二进制转

　　　　　　　　>>3

　　　　　　>>int('0o11',8)#八进制转

　　　　　　　　>>9

　　　　　　>>int('0x11',16)#十六进制转

　　　　　　　　>>17　　　　　　

　　　　1.2.3float类型也可用于数据类型的转换

　　　　　　>>a='12.3'

　　　　　　>>b=float(a)

　　　　　　>>print(b,type(b))　

　　　　　　  >>b=12.3  float

　1.3.使用:

　　　　　　数字类型一般用来进行数学运算和比较运算，数字类型要掌握与运算符的结合使用，并不需要掌握其他的内置方法

二 字符串

　　2.1定义：

　　　　　　在单引号/双引号/多引号包含一串字符

　　　　　　name1='asdf'

　　　　　　name2="asdf"

　　　　　　name3="'asdf'"

　　2.2转换方法

　　　　数字类型的转换中，可以将任意的数据类型转换成字符串类型

　　　　>>str([1,2,3,4.])#list>str

　　　　>>str({'name':'xuqi','age':18})#dic>str

　　　　>>str({1,2,3,4})#set>str

　　　　>>str((1,2,3,4))#tuple>str

　　2.3使用

　　　　2.3.1优先掌握的操作

　　　　　　对于str类型来说只能用来取，不能能用来改，改的话会报错

　　　　　　1.按索引取值

　　　　　　　　>>str1='hello world'

　　　　　　　　正向取：

　　　　　　　　　　>>str1[3]

　　　　　　　　反向取：

　　　　　　　　　　>>str1[-4]

　　　　　　2.切片（顾头不顾尾）：

　　　　　　　　　>>str1='hello world'

　　　　　　　　　正向取：

　　　　　　　　　　　>>str1[0:9]#取出缩影0到8索引所对应的值

　　　　　　　　　步长：

　　　　　　　　　　　>>str1[0:9:2]#打三个参数代表步长，每次会累加2，分别取出0，2，4，6，8索引对应的值

　　　　　　　　　反向切片：

　　　　　　　　　　　>.str1[::-1]　#-1表示从右往左开始依次取

　　　　　　3.长度

　　　　　　　　>>str1='hello world'

　　　　　　　   >> len(str1)#获取字符串的长度

　　　　　　4.成员运算

　　　　　　　>>str1='hello world'

　　　　　　　　4.1 in：#判断某个字符串是否在一个大字符串中

　　　　　　　　　　>>'hello' in str1

　　　　　　　　4.2not ：in#判断某个字符串是否在另外一个大字符串中

　　　　　　　　　　>>'hello' not in str1

　　　　　　5.strip移除字符串左右两边的指定字符(默认移除的时空格)

　　　　　　　　5.1当strip（）括号中不指定所去除的字符时，默认移除的是空格

　　　　　　　　  >.str1='   hello world    '

　　　　　　　　  >>str1.strip()#>>hello world

　　　　　　　　5.2当strip（）括号中指定了去除的字符时，去除的就是指定的字符

　　　　　　　　  >>str1='**hello world**'

　　　　　　　　  >>str1.strip('*')#hello world

　　　　　　6.切分(split)

　　　　　　　　5.1当split（）括号中不指定指定的分隔符时，默认以空格作为切分符号

　　　　　　　　>>str1='hello world'

　　　　　　　　>>str1.split()#[hello,world]

　　　　　　　　5.2当split（）括号中指定指定的分隔符时，以指定的分隔符作为切分符号

　　　　　　　　  >>str1='1*2*3*4*5*6'

　　　　　　　　  >>str1.split('*')#[1,2,3,4,5,6]

　　　　　　7.循环

　　　　　　　　>>str1='今天的你还好吗'

　　　　　　　　>>for line in str1

　　　　　　　　>>print（line）#依次取出字符串中的内容，并打印

　　　　2.3.2需要掌握的操作

　　　　　　1.  strip，lstrip，rstrip

　　　　　　>>a='***asdfg***'

　　　　　　>>a.strip('*')#移除字符串左右两边的“*”字符

　　　　　　>>a.lstrip('*')#移除字符串左边的“*”字符

　　　　　　>>a.rstrip('*')#移除字符串右边的“*”字符

　　　　　　2.  lower,upper

　　　　　　>>a='My Name Is Xuqi'

　　　　　　>>a.lower()#将字符串全部变为小写

　　　　　　　　>>#my name is xuqi

　　　　　　>>a.upper()#将字符串群工部变为大写

　　　　　　　　>>#MY NAME IS XUQI

　　　　　　3.  startswith,endswith

　　　　　　>>a='My Name Is Xuqi'

　　　　　　startswith()判断是否以括号内指定字符开头，返回结果为bool值（True，False）

　　　　　　  >>a.startswith('M'）

　　　　　　>>endswith()判断是否以括号内指定字符开头，返回结果为bool值（True，False）

　　　　　　  >>a.endswith('i')

　　　　　　4.  格式化输出之format

　　　　　　　　之前使用的%s是针对一些固定的格式的，在传入值的时候必须严格按照%s位置一 一对应，而字符串的内置方法format提供了一种不依赖于位置传值的方法

　　　　　　　　　　>>my name is {name},my age is {age}.format(age=18,name='xuqi')

　　　　　　　　　　>>my name is xuqi,my age is 18

　　　　　　　　把format传入的多个值当成一个列表，按照索引取值

　　　　　　　　　　>>my name is {0},my age is {1}.format('tony',18)

　　　　　　　　　　>>my name is tony,my age is 18

　　　　　　5.  split,rsplit

　　　　　　　　>>a='a:/a/s/d/f/f/g'

　　　　　　　　split按照从左往右的顺序对字符串切分，可以指定切割次数

　　　　　　　　　　>>a.split('/',2)

　　　　　　　　　　>>['a:','a','s/d/f/f/g']

　　　　　　　　rsplit按照从右往左的顺序对字符串切分，也可以指定切割次数

　　　　　　　　　　>>a.rsplit('/',1)

　　　　　　　　　　>>['a:/a/s/d/f/f','g']

　　　　　　6.  join

　　　　　　　　从可迭代对象中取出多个字符串，按照指定字符进行分隔，并将其拼接成一个新的字符串

　　　　　　　　>>'*'.join(hello)

　　　　　　　　>>'h*e*l*l*o'

　　　　　　　　>>'|'.join('xuqi',18,'23k')

　　　　　　　　>>xuqi|18|23k

　　　　　　7.  replace　:用新的字符替换旧的字符

　　　　　　　　>>a='my name is xuqi my age is 18'

　　　　　　　　>>b=a.replace('my','MY',1)

　　　　　　　　>>print(b)#MY name is xuqi my age is 18　　　

　　　　　　8.  isdigit:判断字符串是由纯数字组成，返回值为bool

　　　　　　　　>>str1='123456'

　　　　　　　　>>str2='123a456'

　　　　　　　　>>print(str1)#True

　　　　　　　　>>print(str2)#False

　　　　2.3.3了解的操作

　　　　　　1.  find,rfind;index,rindex;count

　　　　　　2.  center;ljust,rjust;zfill

　　　　　　3.  expandtabs

　　　　　　4.  capitalize,swaplcase;title

　　　　　　5.  is数字系列　　

　　　　　　6.  其他

三 列表

　　3.1定义：

　　　　在[]内用逗号分隔开的任意数据类型的值

　　3.2类型转换

　　　　但凡能被for循环遍历的数据类型，都能被list（）转换成列表类型，list（）也会像for循环一样遍历出数据类型中所包含的每一个元素放到列表中

　　　　元组，字符串，字典，集合，列表都可被list转换成列表，但是字典同其他类型不太一样，字典转换的是'key'值

　　3.3使用

　　　　3.3.1优先掌握的操作

　　　　　　

　　　　　  # 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
　　　　　  # 1.1 正向取(从左往右)
　　　　　　>>> my_friends=['tony','jason','tom',4,5]
　　　　　　>>> my_friends[0]  
　　　　　　tony
　　　　　　# 1.2 反向取(负号表示从右往左)
　　　　　　>>> my_friends[-1]  
　　　　　　5
　　　　　　# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
　　　　　　>>> my_friends = ['tony','jack','jason',4,5]
　　　　　　>>> my_friends[1] = 'martthow'
　　　　　　>>> my_friends
　　　　　　['tony', 'martthow', 'jason', 4, 5]


　　　　　　# 2.切片(顾头不顾尾，步长)
　　　　　　# 2.1 顾头不顾尾：取出索引为0到3的元素
　　　　　　>>> my_friends[0:4] 
　　　　　　['tony', 'jason', 'tom', 4]
　　　　　　# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
　　　　　　>>> my_friends[0:4:2]  
　　　　　　['tony', 'tom']

　　　　　　# 3.长度
　　　　　　>>> len(my_friends)
　　　　　　5
　　　　　　
　　　　　　# 4.成员运算in和not in
　　　　　　>>> 'tony' in my_friends
　　　　　　True
　　　　　　>>> 'xxx' not in my_friends
　　　　　　True

　　　　　　# 5.添加
　　　　　　# 5.1 append()列表尾部追加元素
　　　　　　>>> l1 = ['a','b','c']
　　　　　　>>> l1.append('d')
　　　　　　>>> l1
　　　　　　['a', 'b', 'c', 'd']

　　　　　　# 5.2 extend()一次性在列表尾部添加多个元素
　　　　　　>>> l1.extend(['a','b','c'])
　　　　　　>>> l1
　　　　　　['a', 'b', 'c', 'd', 'a', 'b', 'c']

　　　　　　# 5.3 insert()在指定位置插入元素
　　　　　　>>> l1.insert(0,"first")  # 0表示按索引位置插值
　　　　　　>>> l1
　　　　　　['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

　　　　　　# 6.删除
　　　　　　# 6.1 del
　　　　　　>>> l = [11,22,33,44]
　　　　　　>>> del l[2]  # 删除索引为2的元素
　　　　　　>>> l
　　　　　　　[11,22,44]

　　　　　　# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
　　　　　　>>> l = [11,22,33,22,44]
　　　　　　>>> res=l.pop()
　　　　　　>>> res
　　　　　　44
　　　　　　>>> res=l.pop(1)
　　　　　　>>> res
　　　　　　22

　　　　　　# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
　　　　　　　　>>> l = [11,22,33,22,44]
　　　　　　>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
　　　　　　>>> print(res)
　　　　　　None

　　　　　　# 7.reverse()颠倒列表内元素顺序
　　　　　　>>> l = [11,22,33,44]
　　　　　　>>> l.reverse() 
　　　　　　>>> l
　　　　　　[44,33,22,11]

　　　　　　# 8.sort()给列表内所有元素排序
　　　　　　# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
　　　　　　>>> l = [11,22,3,42,7,55]
　　　　　　>>> l.sort()
　　　　　　>>> l 
　　　　　　[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
　　　　　　>>> l = [11,22,3,42,7,55]
　　　　　　>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
　　　　　　>>> l 
　　　　　　[55, 42, 22, 11, 7, 3]
　　　　　　# 8.2 了解知识：
　　　　　　# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
　　　　　　>>> l1=[1,2,3]
　　　　　　>>> l2=[2,]
　　　　　　>>> l2 > l1
　　　　　　True
　　　　　　# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
　　　　　　>>> s1='abc'
　　　　　　>>> s2='az'
　　　　　　>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
　　　　　　True
　　　　　　# 所以我们也可以对下面这个列表排序
　　　　　　>>> l = ['A','z','adjk','hello','hea']
　　　　　　>>> l.sort()
　　　　　　>>> l
　　　　　　['A', 'adjk', 'hea', 'hello','z']

　　　　　　# 9.循环
　　　　　　# 循环遍历my_friends列表里面的值
　　　　for line in my_friends:
  　　　　  print(line) 
　　　　　　'tony'
　　　　　　'jack'
　　　　　　'jason'

四 元组

　　4.1作用:

　　　　　　元组和列表类似，可以存多个任意类型的元素，同列表不同的是元组内的元素不能修改，元组相当于不可变的列表，用于记录多个固定而不可修改的值，仅仅用来取

　　4.2定义：

　　　　　　（）内用逗号分隔开多个任意类型的值

　　4.3转换方法

　　　　　　但凡能被for循环遍历的数据类型都能传给tuple()转换成元组

　　4.4使用

　　　　>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 

     # 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  

     >>> tuple1[0]1>>> tuple1[-2]

      22

      >> tuple1[0] = 'hehe' # 报错：TypeError:

　　　　# 2、切片(顾头不顾尾，步长)
　　　　>>> tuple1[0:6:2] 
　　　　(1, 15000.0, 22)

　　　　# 3、长度
　　　　>>> len(tuple1)  
　　　　6

　　　　# 4、成员运算 in 和 not in
　　　　>>> 'hhaha' in tuple1 
　　　　True
　　　　>>> 'hhaha' not in tuple1  
　　　　False 

　　　　# 5、循环
　　　　>>> for line in tuple1:
　　　　...     print(line)
　　　　1
　　　　hhaha
　　　　15000.0
　　　　11
　　　　22
　　　　33

五 字典

　　5.1定义：

　　　　　　在{}内用逗号分隔开任意类型的数据，且每个数据都是以'key':value的形式，一般来说value可以是任意的数据类型，但key必须是不可变类型，一般来说，key所对应的应是str类型，因为石头人类型对value值具有描述性的功能

　　　　　　info={'name':'xuqi','age':18,'sex':'male'}

　　　　　　info=dict{name='xuqi',age=18,sex='male'}

　　5.2类型转换

　　　　　　转换一：info=dict([['name','xuqi'],('age',18)])#info={'name':18,'name':'xuqi'}

　　　　　　转换二：fromkeys会从元组中取出每个值当作key，然后与None组成key：value放到字典中

　　　　　　　　　　{}.fromkeys((name','age','sex'),None)#info={'name':None,'age':None,'sex':None}

　　5.3使用

　　　　5.3.1优先掌握的操作

　　　　　　info={'name':'xuqi','age':18,'hobbies':['play','basketball']}

　　　　　　1. 按key取值，可存可取

　　　　　　　　1.1取

　　　　　　　　>>info['name']

　　　　　　　　>>#xuqi

　　　　　　      1.2对于赋值操作来说，如果key原先不存在于字典，则会新增key：value

　　　　　　　　>>info['gender']='male'

　　　　　　　　>>#info={'name':'xuqi','age':18,'hobbies':['play','basketball'],'gender':'male'}

　　　　　　　　1.3对于赋值操来说，如果key原先存在于字典中，则会修改与拿来key所对应的值

　　　　　　　　>>info['name']='egon'

　　　　　　　　>>#info={'name':'egon','age':18,'hobbies':['play','basketball']}

　　　　　　2.  长度

　　　　　　　　>>len(dic)

　　　　　　　　>>#3

　　　　　　3.  成员运算

　　　　　　　　>>'name' in dic#判断某个值是否是字典key

　　　　　　4.  删除

　　　　　　　　>>info.pop('name')#通过指定的key来删除字典key的键对值

　　　　　　　　>>#info={'age':18,'hobbies':['play','basketball']}

　　　　　　5.  键keys（），values（），键值对items（）

　　　　　　　　>>a=info.keys()

　　　　　　　　>>#dict_keys(['name','age'])

　　　　　　　　>>b=info.values()

　　　　　　　　>>#dict_values(['xuqi',18],['play','basketball'])

　　　　　　　　>>c=info.items()

　　　　　　　　>>#dict_items([('name','xuqi'),('age',18),('hobbies',['play','basketball'])])

　　　　　　6.  循环:默认遍历的是字典的key值

　　　　　　　　6.1默认遍历key

　　　　　　　　　　>>for line in info：

　　　　　　　　　　　　>>print（key）

　　　　　　　　　　　　>>#name age hobbies

　　　　　　　　6.2只遍历key

　　　　　　　　　　>>for line in info.keys():

　　　　　　　　　　　　>>print(line)

　　　　　　　　　　　　>>#name age hobbies

　　　　　　　　6.3只遍历value

　　　　　　　　　　>>for line in info.values()

　　　　　　　　　　　　>>print(line)

　　　　　　　　　　　　>>#xuqi 18 ['play','basketball']

　　　　　　　　6.4遍历key与value

　　　　　　　　　　>>for line in info.items()

　　　　　　　　　　　　>>print(line)

　　　　　　　　　　　　>>#('name','xuqi')  ('age',18)  ('hobbies',['play','basketball'])

　　　　5.4.2需要掌握的操作

　　　　　　>>a={'name':'xuqi','age',18}

　　　　　　1.  get()

　　　　　　　　>>b=a.get('name')#key存在，则返回key所对应的值>>'xuqi'

　　　　　　　　>>print（b）

　　　　　　　　>>c=a.get('hobbies')#若key不存在，则默认返回None

　　　　　　　　>>print（c）

　　　　　　注：字典取值一般采用get方法

　　　　　　2.  pop()

　　　　　　　　>>v=a.vpop('name')#删除指定的key的对应键对值，并将值返回

　　　　　　　　>>print（v）

　　　　　　　　>>#a={'age':18}

　　　　　　　　>>#'v=xuqi'

　　　　　　3.  popitem

　　　　　　　　>>b=a.popitem()#随机删除一队键对值，并将删除的值以元组的形式返回

　　　　　　　　>>print(b)

　　　　　　　　>>#b={'name','xuqi'}

　　　　　　　　>>#a={'age':18}

　　　　　　4.update():用新字典更换旧字典，有则修改，无则添加

　　　　　　　　>>a.update({'name':egon,'gender':'male'})

　　　　　　　　>>a={'name':'egon','age':18,'gender':'male'}

　　　　　　5.fromkeys()

　　　　　　　　>>dic=dic.fromkeys(['k1','k2','k3'],[])

　　　　　　　　>>#dic={'k1':[],'k2':[],'k3':[]}

　　　　　　6.setdefault()#key值不存在时则新增键对值，并将新增的value返回,若key存在，返回已存在的key对应的value

　　　　　　　　>>dic=('k1':111,'k2':222)

　　　　　　　　>>res=dic.setdefault(’k1':666,k3':333)

　　　　　　　　>>print(res)

　　　　　　　　>>#res=111,333

　　　　　　　　>>dic={'k1':111,'k2':222,'k3':333}

六 集合

　　6.1作用

　　　　　　集合，list,tuple,dict一样可以存放多个值，集合主要用于：去重，关系运算

　　6.2定义

　　　　　　在{}内用逗号分隔开多个元素，集合具备以下三个特点：

　　　　　　1：每个元素必须是不可变类型

　　　　　　2：集合内没有重复的元素

　　　　　　3：集合内元素是无序的

　　　　　　注1：集合类型没有索引对应值，也没有key对应值，所以说无法取得单个值，集合主要用于去重和关系运算

　　　　　　注2：{}可用于定义字典，也可用于定义集合，空字典，空集合的定义

　　　　　　d={}#定义空字典

　　　　　　s=set（）#定义空集合

　　6.3转换方法

　　　　　　凡是能被for循环遍历的数据类型（强调：遍历出来的数据类型必须是不可变类型）都可以传给set()转换成集合类型

　　6.4使用

　　　　6.4.1关系运算

　　　　　　>>friends1={"xuqi","jason","egon"}

 　　　　　   >>friends2={"jy","jason","egon"}

　　　　　　1.合集/并集：求两个用户的所有好友（有重复的就只保留一个）

　　　　　　　　>>friends1 | friends2

　　　　　　　　>>#{"xuqi","jy","jason","egon"}

　　　　　　2.交集：

　　　　　　　　>>friends1 & friends2

　　　　　　　　>>#{"egon","jason"}

　　　　　　3.差集：

　　　　　　　　>>friends1 - friends2#friends1独有的好友

　　　　　　　　>>#{"xuqi"}

　　　　　　　　>>friends2 - friends1#friends2独有的好友

　　　　　　　　>>#{"jy"}

　　　　　　4.对称差集：

　　　　　　　　>>friends1 ^ friends2#求两个用户的独有的好友们

　　　　　　　　>>#{"xuqi","jy"}

　　　　　　5.值是否相等(==)

　　　　　　　　>>friends1 == friends2

　　　　　　　　>>False

　　　　　　6.父集:一个集合是否包含另外一个集合，不包含则返回False

　　　　　　　　>>{1,2,3,4} >= {1,2,3}#返回True

　　　　　　　　>>{1,2,3} >= {1,3,5}#返回False

　　　　6.4.2去重：

　　　　　　注：只能针对不可变类型

　　　　　　　　集合本身是无序的，去重之后无法保留原来的顺序

　　　　　　　　>>l={'a','b','c','b','d','b'}

　　　　　　　　>>s=set(l)

　　　　　　　　>>#l={'c','d','b','a'}

　　　　　　　　我们需要保证顺序不变即去重才是最终目标‘

　　　　　　　　>>l=[{'name':'xuqi','age':18},{'name':'egon','age':30},{'name':'xuqi','age':18}]

　　　　　　　　>>new_l=[]

　　　　　　　　>>for dic in l:

　　　　　　　　>>　　if dic not in new_l:

　　　　　　　　>>　　　　new_l.append(dic)

　　　　　　　　>>prinr(new_l)

　　　　　　　　即去重了也保证了顺序

　　　　　　　　>>l=[{'name':'xuqi','age':18},{'name':'egon','age':30}]　　　　

　　　　6.4.3其他操作

　　　　a={'a','s','d'}

　　　　长度：len(a) # 3

　　　　成员运算：'s' in a # True

　　　　循环：for line in a:

　　　　　　　　print(line) # s a d