python数据类型篇

数据类型（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

字符串（str）

字符类型是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

decode(self,encoding=none,errors=none):

解码

1
2
3
4

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

encode(self,encoding=none)

编码，针对unicode

1
2
3
4

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

编码，针对unicode

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

expandtabs(self,tabsize=none)

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'

find(self,sub,start=none,end=none)

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

isalnum(self)

检测字符串是否由字母和数字构成，如果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

isalpha(self)

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

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

isspace(self)

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

1
2
3
4
5
6
7

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

ljust(self,width,fillchar=none)

width -> 指定字符串长度

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

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

1
2
3
4
5
6

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

lower(self)

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

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'

partition(self,sep)

str ->指定的分隔符

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

1
2
3
4

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

replace(self,old,new,count=none)

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'

rfind(self,sub,start=none,end=none)

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

rjust(self,width,fillchar=none)

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'

rtrip(self,chars=none)

chars ->指定删除的字符

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

1
2
3
4

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

swapcase(self)

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

1
2
3

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

title(self)

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

1
2
3

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

upper(self)

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

1
2
3

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

列表(list)

列表的两种方法

第一种：

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

extend(self,iterable)

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']

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

value -> 列表中统计的对象

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

1
2
3
4

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

insert(self,index,p_object)

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']

pop(self,index=none)

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']

元组(tuple)

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

创建元组的两种方法

第一种：

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
{}

copy(self):

返回一个字典的浅复制

1
2
3

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

fromkeys(S,v=none)

S->字典键值列表

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

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

1
2
3
4

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

get(self,k,d=none)

key ->字典中要查找的键

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

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

1
2
3

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

items(self)

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

1
2
3
4

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

key(self)

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

1
2
3

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

pop(self,k,d=none)

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

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'}

popitem(self)

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

1
2
3
4
5
6

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

setdefault(self,k,d=none)

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}

update(self,E=none,**F)

把字典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'}

values(self)

显示字典中所有的值

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}

clear

清除集合内容

1
2
3
4

>>> se = { 11, 22, 33 }
>>> se.clear()
>>> se
set()

copy 浅复制

详细见下面的深浅复制

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}

未完待续。。。。