数据类型（1）

所有的字符串或者数字，字典所具备的方法都存在相对应的类里面，所有对象所具备的功能都保存在相应的类中


布尔值（bool）


真（True）或者假（False），0或1


整型（int）


在python2里，一个int型包含32位，一个long型会占用更多的空间。在python3里long型已经不存在了，而int型可以存储到任意大小的整型，甚至超过64位。


python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常是32位，超过这个范围的整数就自动当成整数处理，而长整型的范围几乎完全没限制


定义一个整型的变量


#所定义的变量值不能用单引号或者双引号括起来


age = 18


输出其变量的数据类型


type(age)
整型所具备方法


bit_length


返回值表示该数字的是占用的最少位数


conjugate 返回该复数的共轭复数，复数，比如0+2j，其中num.real和num.image分别返回实部和虚部，num.conjugate()返回值共轭复数 


1
2
3
4
5
6
7
8
9
10
>>> num =-20
>>> num.conjugate()
-20
>>> num=0+2j
>>> num.real
0.0
>>> num.imag
2.0
>>> num.conjugate()
-2j


字符类型是python的序列类型，他的本质就是字符类型，而且python的字符串类型是不可以改变的，你无法将原字符串警醒修改


使用引号创建字符串


创建字符串类型可以使用单引号或者双引号


单引号 


1
2
3
4
>>> string = 'ansheng'
# type是查看一个变量的数据类型
>>> type(string)
<class 'str'>


1
2
3
4
>>> string = "ansheng"
# type是查看一个变量的数据类型
>>> type(string) 
<class 'str'>


capitalize(self)


把值得首字母变大写 


1
2
3
>>> name="ansheng"
>>> name.capitalize()
'Ansheng'

center（self,width,fillchar=none）

内容居中，width：字符串的总宽度；fillchar：填充字符，默认填充字符为空格。 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 定义一个字符串变量，名为"string"，内容为"hello word"
>>> string="hello word"
# 输出这个字符串的长度，用len(value_name)
>>> len(string)
10
# 字符串的总宽度为10，填充的字符为"*"
>>> string.center(10,"*")
'hello word'
# 如果设置字符串的总产都为11，那么减去字符串长度10还剩下一个位置，这个位置就会被*所占用
>>> string.center(11,"*")
'*hello word'
# 是从左到右开始填充
>>> string.center(12,"*")
'*hello word*'

count(self,sub,start=none,end=none

)

sub ->搜索的子字符串


start ->字符串开始搜索的位置，默认为第一个字符，第一个字符索引值是0


end ->字符串中结束搜索的位置，字符中第一个字符的索引是0，默认为字符串的最后一个位置


用于同一字符串里某个字符出现的次数，可选参数为在字符串搜索的开始和结束位置


1
2
3
4
5
6
7
>>> string="hello word"
# 默认搜索出来的"l"是出现过两次的
>>> string.count("l")
2
# 如果指定从第三个位置开始搜索，搜索到第六个位置，"l"则出现过一次
>>> string.count("l",3,6)
1


解码 


1
2
3
4
# 定义一个变量内容为中文
temp = "中文"
# 把变量的字符集转化为UTF-8
temp_unicode = temp.decode("utf-8")


编码，针对unicode 


1
2
3
4
# 定义一个变量内容为中文,字符集为UTF-8
temp = u"中文"
# 编码，需要指定要转换成什么编码
temp_gbk = temp_unicode.encode("gbk")


1
2
3
4
# 定义一个变量内容为中文,字符集为UTF-8
temp = u"中文"
# 编码，需要指定要转换成什么编码
temp_gbk = temp_unicode.encode("gbk")

endswith(self,suffix,start=none,end=none)

suffix -> 后缀，可能是一个字符串，或者也可能是寻找后缀的tuple


start -> 开始，切片从这里开始


end ->结束，片到此为止


于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False 


1
2
3
4
5
6
7
8
9
10
>>> string="hello word"
# 判断字符串中是否已"d"结尾，如果是则返回"True"
>>> string.endswith("d")
True
# 判断字符串中是否已"t"结尾，不是则返回"False"
>>> string.endswith("t")
False
# 制定搜索的位置，实则就是从字符串位置1到7来进行判断，如果第七个位置是"d"，则返回True，否则返回False
>>> string.endswith("d",1,7)
False


tabsize -> 指定转换字符串中的tab符号("\t")转为空格的字符数。


把字符串的tab符号("\t")转换为空格，tab符号("\t")默认空格数是8 


1
2
3
4
5
6
7
8
9
10
>>> string="hello       word"
# 输出变量"string"内容的时候会发现中间有一个"\t"，这个其实就是一个`tab`键
>>> string
'hello\tword'
# 把`tab`键换成一个空格
>>> string.expandtabs(1)
'hello word'
# 把`tab`键换成十个空格
>>> string.expandtabs(10)
'hello     word'


str -> 指定检索的字符串


beg -> 开始索引，默认是0


end ->结束索引，默认为字符串的长度


检索字符串中是否包含字符串str，如果指定beg(开始)和end(结束)范围，则检索是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1 


1
2
3
4
5
6
7
>>> string="hello word"
# 返回`o`在当前字符串中的位置，如果找到第一个`o`之后就不会再继续往下面寻找了
>>> string.find("o")
4
# 从第五个位置开始搜索，返回`o`所在的位置
>>> string.find("o",5)
7


检测字符串是否由字母和数字构成，如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False 


1
2
3
4
5
6
7
8
>>> string="hes2323"
# 如果存在数字或字母就返回`True`，否则返回`False`
>>> string.isalnum()
True
# 中间有空格返回的就是False了
>>> string="hello word"
>>> string.isalnum()
False


检测字符串是否只有字母组成 


1
2
3
4
5
6
7
8
# 如果全部都是字母就返回`True`
>>> string="helloword"
>>> string.isalpha()
True
# 否则就返回False
>>> string="hes2323"
>>> string.isalpha()
False

islower(self)

检测字符串是否由小写字母组成 


1
2
3
4
5
6
7
# 如果变量内容全部都是小写字母就返回`True`，否则就返回`False`
>>> string="hesasdasd"
>>> string.islower()
True
>>> string="HelloWord"
>>> string.islower()
False


检测字符串是否只由空格组成 


1
2
3
4
5
6
7
# 如果变量内容由空格来组成，那么就返回`True`否则就返回`False`
>>> string=" "
>>> string.isspace()
True
>>> string="a"
>>> string.isspace()
False


width -> 指定字符串长度


fillchar ->填充字符，默认我空格


返回一个元字符串左对齐，并使用空格填充至指定长度的新字符串，如果指定的长度小于原字符串长度则返回原字符串 


1
2
3
4
5
6
>>> string="helo word"
>>> len(string)
9
# 定义的长度减去字符串的长度,剩下的就开始填充
>>> string.ljust(15,'*')
'helo word******'


转换字符串中所有大写字符为小写。 


1
2
3
4
# 把变量里的大写全部转换成小写
>>> string="Hello WORD"
>>> string.lower()
'hello word'

lstrip(self,chars=none)

chars ->指定截取的字符


用于截取字符串左边的空格或指定字符 


1
2
3
4
# 从左侧开始删除匹配的字符串
>>> string="hello word"
>>> string.lstrip("hello ")
'word'


str ->指定的分隔符


用来根据指定的分隔符将字符串进行分割，如果字符串包含指定的分隔符，则返回一个3元的tuple，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。 


1
2
3
4
# 返回的是一个元组类型
>>> string="www.ansheng.me"
>>> string.partition("ansheng")
('www.', 'ansheng', '.me')


old ->将被替代的字符串


new ->新字符串，用于替换old字符串


count ->可选字符串，替换不超过count次


把字符串中的old(旧字符串)替换成new(新字符串)，如果指定第三个参数max，则替换不超过max次 

1
2
3
4
5
6
7
>>> string="www.ansheng.me"
# 把就字符串`www.`换成新字符串`https://`
>>> string.replace("www.","https://")
'https://ansheng.me'
# 就字符串`w`换成新字符串`a`只替换`2`次
>>> string.replace("w","a",2)
'aaw.ansheng.me'


str -> 查找的字符串


beg -> 开始查找的位置，默认为0


end ->结束查找位置，默认我字符串的长度


返回字符串最后一次出现的位置，如果没有匹配则返回-1 


1
2
3
4
5
6
7
>>> string="hello word"
# rfind其实就是反向查找
>>> string.rfind("o")
7
# 指定查找的范围
>>> string.rfind("o",0,6)
4


width -> 指定填充字符后中字符串的总长度 


fillchar ->填充的字符，默认为空格


返回一个原字符串右对齐，并使用空格填充至长度width的新字符串，如果指定的长度小于字符串的我长度则返回原字符串 


1
2
3
4
5
6
7
>>> string="hello word"
>>> len(string)
10
>>> string.rjust(10,"*")
'hello word'
>>> string.rjust(12,"*")
'**hello word'


chars ->指定删除的字符


删除string字符串末尾指定的字符（默认为空格） 


1
2
3
4
# 从尾部开始匹配删除
>>> string="hello word"
>>> string.rstrip("d")
'hello wor'


用于字符串的大小写字母进行转换，大写变小写，小写变大写 


1
2
3
>>> string="hello WORD"
>>> string.swapcase()
'HELLO word'


返回“标题化”的字符串，就是说所有单词都是以大写开始，其余字母为小写 


1
2
3
>>> string="hello word"
>>> string.title()
'Hello Word'


将字符串中的小写字母转为大写字母 


1
2
3
>>> string="hello word"
>>> string.upper()
'HELLO WORD'


列表的两种方法


第一种：


name_list = ['python','php','java']


第二种：


name_list = list (['python','php','java'])


列表所具备的方法：


append(self,p_object)


在列表的末尾添加新的对象 


1
2
3
4
>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list.append("C#")
>>> name_list
['Python', 'PHP', 'JAVA', 'C#']

count(self,value)

obj ->列表中统计的对象


统计某个元素在列表中出现的次数 


1
2
3
>>> name_list = ['Python', 'PHP', 'PHP']
>>> name_list.count("PHP")
2


seq -> 元素列表


用于在列表尾一次性追加另一个序列中多个值 


1
2
3
4
5
6
7
8
9
10
11
>>> name_list = ['Python', 'PHP', 'Python']
>>> name_OS = ['Windows', 'Linux', 'Unix']
>>> name_list
['Python', 'PHP', 'Python']
>>> name_OS
['Windows', 'Linux', 'Unix']
# 把列表`name_OS`中的内容添加到`name_list`的尾部
>>> name_list.extend(name_OS)
# 输出的结果
>>> name_list
['Python', 'PHP', 'Python', 'Windows', 'Linux', 'Unix']


value -> 列表中统计的对象


从列表中找出某个值第一个匹配项的索引位置 


1
2
3
4
# 查找对象所在的位置
>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list.index("PHP")
1


index -> 对象obj需要插入的索引位置


obj -> 要插入到列表中的对象


将指定对象插入列表 


1
2
3
4
5
>>> name_list = ['Python', 'PHP', 'JAVA']
# 把位置`1`的内容换成`C`，后面的自动退格一个位置
>>> name_list.insert(1,"C")
>>> name_list
['Python', 'C', 'PHP', 'JAVA']


index ->可选参数，要移除列表元素的位置


移除列表中的一个元素，并且返回该元素的值 


1
2
3
4
5
6
>>> name_list = ['Python', 'PHP', 'JAVA']
# 删除位置1上面的内容，并且返回删除的字符串
>>> name_list.pop(1)
'PHP'
>>> name_list
['Python', 'JAVA']

remove(self,value)

value -> 列表中要移除的对象


  


1
2
3
4
5
6
7
8
>>> name_list = ['Python', 'PHP', 'JAVA', 'Python']
# 每次删除的时候只会把第一次匹配到的值删除，第二个值不会被删除
>>> name_list.remove("Python")
>>> name_list
['PHP', 'JAVA', 'Python']
>>> name_list.remove("Python")
>>> name_list
['PHP', 'JAVA']

sort(self,cmp=none,key=none,reverse=false):

对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数 


1
2
3
4
5
6
>>> name_list = ['Python', 'PHP', 'JAVA']
>>> name_list
['Python', 'PHP', 'JAVA']
>>> name_list.sort()
>>> name_list
['JAVA', 'PHP', 'Python']


元组和列表的唯一区别就是列表可以更改，元组不可以更改


创建元组的两种方法


第一种：


ages = (11,22,33,44,55)


第二种


ages = tuple((11,22,33,44))


元组所具备的方法


count(self,value)


value -> 元素的值


查看列表中元素出现的次数 


1
2
3
4
5
>>> ages = tuple((11, 22, 33, 44, 55))
>>> ages
(11, 22, 33, 44, 55)
>>> ages.count(11)
1

index(self,value,start=none,stop=none)

value -> 元素的值


start ->开始的位置


stop ->结束的位置


查找元素在元组中的位置 


1
2
3
4
5
>>> ages = tuple((11, 22, 33, 44, 55))
>>> ages
(11, 22, 33, 44, 55)
>>> ages.count(11)
1

字典(dict)


字典是无序的，创建字典的两种方式


第一种：


person = {"name": "mr.wu","age": 18}


第二种：


person = dict({"name": "mr.wu","age": 18})


字典所具备的方法


clear(self)清除内容


删除字典中的所有元素 


1
2
3
4
5
6
7
>>> person = dict({"name": "mr.right", 'age': 18})
>>> person
{'age': 18, 'name': 'mr.right'}
>>> person.clear()
# 清空字典的内容之后字典会变成一个空字典
>>> person
{}


返回一个字典的浅复制 


1
2
3
>>> person = dict({"name": "ansheng", 'age': 18})
>>> person.copy()
{'age': 18, 'name': 'ansheng'}


S->字典键值列表


v->可选参数，设置键序列(seq)的值


创建一个新字典，以序列seq中元素做字典的键，value为字典所有对应的初始值 


1
2
3
4
>>> seq = ('name', 'age', 'sex')
>>> dict = dict.fromkeys(seq)
>>> dict
{'age': None, 'name': None, 'sex': None}


key ->字典中要查找的键


default ->如果指定键的值不存在，返回该默认值


返回指定键的值，如果值不在字典中返回默认值，默认值为none 


1
2
3
>>> person = {"name": "ansheng", 'age': 18}
>>> person.get("name")
'ansheng’


以列表返回可遍历的(键，值)元组数组 


1
2
3
4
>>> person = {"name": "mr.wu", 'age': 18}
# 以元组的方式输出出来
>>> person.items()
[('age', 18), ('name', 'mr.wu')]


以列表的形式返回一个字典所有的键 


1
2
3
>>> person = {"name": "ansheng", 'age': 18}
>>> person.keys()
['age', 'name']


删除指定给定键所对应的值 


1
2
3
4
5
6
7
8
>>> person = {"name": "ansheng", 'age': 18}
>>> person
{'age': 18, 'name': 'ansheng'}
# 返回删除键对应的值
>>> person.pop("age")
18
>>> person
{'name': 'ansheng'}


随机返回并删除字典中的一对键和值，因为字典是无顺序的，没有所谓的“最后一项”或是其他顺序 


1
2
3
4
5
6
>>> person = {"name": "ansheng", 'age': 18}
# 随即删除并显示所删除的键和值
>>> person.popitem()
('age', 18)
>>> person
{'name': 'ansheng'}


key -> 查找的键值


default -> 键不存在时，设置的默认键值


如果key不存在，则创建，如果存在，则返回已存在的值并不修改 


1
2
3
4
5
6
7
8
>>> person = {"name": "ansheng", 'age': 18}
# 如果字典中有这个键，那么就输出这个键的值
>>> person.setdefault("name")
'ansheng'
# 如果没有则不输出，但是会创建一个键，值为默认的'None'，值是可以指定的
>>> person.setdefault("sex")
>>> person
{'age': 18, 'name': 'ansheng', 'sex': None}


把字典dict2的键/值对更新到dict1里 


1
2
3
4
5
6
7
8
9
>>> dic1 = {"name":"ansheng"}
>>> dic2 = {"age":"18"}
>>> dic1
{'name': 'ansheng'}
>>> dic2
{'age': '18'}
>>> dic1.update(dic2)
>>> dic1
{'age': '18', 'name': 'ansheng'}


显示字典中所有的值 


1
2
3
>>> person = {"name": "ansheng", 'age': 18}
>>> person.values()
[18, 'ansheng']


索引就是指某个值在列表或别的数据类型中的一个位置


定义一个列表，查看列表中linux值对应在列表中的位置 


1
2
3
4
5
>>> list_os = ["Windows","Linux","Mac","Unix"]
>>> list_os.index("Linux")
1
>>> list_os[1]
'Linux'

切片

切片操作符是序列名字后跟一个方括号，方括号中有一个可选的数字，并用冒号分隔，注意这与你使用的索引操作符十分相似，记住数是可选的，而冒号是必须的，切片操作符中的第一个数表示切片开始的位置，第二个数表示切片到哪里结束，第三个数表示切片间隔数，如果不指定第一个数，python就从序列首开始，如果没有指定第二个数，则python会停止在序列尾。注意：返回的序列从开始位置开始，刚好在结束位置之前结束，即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。


更多实例如下：


切片符                             说明


[:]                       提取从开头到结尾的整个字符串


[start:]                从start到结尾的字符串


[:end]                 从开头提取到end-1


[start:end]          从start提取到end-1


[start:end:setp]   从start提取到end-1，每setp个字符提取一个


数据类型转换


定义一个整型的变量，然后转换成字符串类型 


1
2
3
4
5
6
7
8
9
10
>>> type(age)
<class 'int'>
>>> age
18
>>> string=str(age)
>>> string
'18'
>>> type(string)
<class 'str'>


python允许你对某些字符进行转义，以此实现一些难以单纯用字符描述的效果 


1
2
3
4
5
# 常用的内容也转义也就是`\n`和`\t`了，`\n`是用来换行的，`\t`是用来代替一个`tab`键
>>> string="My \n Name  \t is"
>>> print(string)
My
 Name    is


你可以使用 + 号将多个字符串或者字符变量拼接起来 


1
2
3
4
5
6
>>> a="my "
>>> b="name "
>>> c="is "
>>> d="ansheng"
>>> a+b+c+d
'my name is ansheng'


数据类型（2）

基本数据类型set集合


集合的元素是不重复且无须的集合，集合就像是字典舍弃了值一样


创建set集合 


1
2
3
4
5
>>> s = set([11,22,33])
>>> s
{33, 11, 22}
>>> type(s)
<class 'set'>

第二种不常用创建set集合的方式 

1
2
3
4
5
6
# 这种的创建方式，集合中的元素相当于字典中的key
>>> s = {11,22,33}
>>> type(s)
<class 'set'>
>>> s
{33, 11, 22}

把其他的可迭代的数据类型转化为set集合 


1
2
3
4
5
6
>>> li = ["a","b","c"]
>>> seting = set(li)
>>> seting
{'b', 'a', 'c'}
>>> type(seting)
<class 'set'>

集合和字典的区别就是字典有冒号，几个没有冒号


 列表(list)转换成集合(set)就是[]转换成{}



集合所提供的方法                      



 add



往集合内添加元素（添加的元素也是无顺的）



1
2
3
4
5
>>> se = { 11, 22, 33 }
# 元素写在小括号内
>>> se.add(44)
>>> se
{33, 11, 44, 22}


清除集合内容 


1
2
3
4
>>> se = { 11, 22, 33 }
>>> se.clear()
>>> se
set()


详细见下面的深浅复制


difference


寻找集合的元素var1中存在，var2中不存在 


1
2
3
4
5
6
>>> var1 = { 11, 22, 33 }
>>> var2 = { 22 ,55 }
>>> var1.difference(var2)
{33, 11}
>>> var2.difference(var1)
{55}