数据类型（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()返回值共轭复数
12345678910 >>> num =-20>>> num.conjugate()-20>>> num=0+2j>>> num.real0.0>>> num.imag2.0>>> num.conjugate()-2j 字符串（str）
字符类型是python的序列类型，他的本质就是字符类型，而且python的字符串类型是不可以改变的，你无法将原字符串警醒修改
使用引号创建字符串
创建字符串类型可以使用单引号或者双引号
单引号
1234 >>> string = 'ansheng'# type是查看一个变量的数据类型>>> type(string)<class 'str'> 双引号
1234 >>> string = "ansheng"# type是查看一个变量的数据类型>>> type(string) <class 'str'> 字符串所具备的方法
capitalize(self)
把值得首字母变大写
123 >>> name="ansheng">>> name.capitalize()'Ansheng'
center（self,width,fillchar=none）
内容居中，width：字符串的总宽度；fillchar：填充字符，默认填充字符为空格。
1234567891011121314 # 定义一个字符串变量，名为"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，默认为字符串的最后一个位置
用于同一字符串里某个字符出现的次数，可选参数为在字符串搜索的开始和结束位置
1234567 >>> string="hello word"# 默认搜索出来的"l"是出现过两次的>>> string.count("l")2# 如果指定从第三个位置开始搜索，搜索到第六个位置，"l"则出现过一次>>> string.count("l",3,6)1 decode(self,encoding=none,errors=none):
解码
1234 # 定义一个变量内容为中文temp = "中文"# 把变量的字符集转化为UTF-8temp_unicode = temp.decode("utf-8") encode(self,encoding=none)
编码，针对unicode
1234 # 定义一个变量内容为中文,字符集为UTF-8temp = u"中文"# 编码，需要指定要转换成什么编码temp_gbk = temp_unicode.encode("gbk") 编码，针对unicode
1234 # 定义一个变量内容为中文,字符集为UTF-8temp = u"中文"# 编码，需要指定要转换成什么编码temp_gbk = temp_unicode.encode("gbk")
endswith(self,suffix,start=none,end=none)
suffix -> 后缀，可能是一个字符串，或者也可能是寻找后缀的tuple
start -> 开始，切片从这里开始
end ->结束，片到此为止
于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False
1 2345678910 >>> 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
12345678910 >>> 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
1234567 >>> string="hello word"# 返回`o`在当前字符串中的位置，如果找到第一个`o`之后就不会再继续往下面寻找了>>> string.find("o")4# 从第五个位置开始搜索，返回`o`所在的位置>>> string.find("o",5)7 isalnum(self)
检测字符串是否由字母和数字构成，如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False
12345678 >>> string="hes2323"# 如果存在数字或字母就返回`True`，否则返回`False`>>> string.isalnum()True# 中间有空格返回的就是False了>>> string="hello word">>> string.isalnum()False isalpha(self)
检测字符串是否只有字母组成
12345678 # 如果全部都是字母就返回`True`>>> string="helloword">>> string.isalpha()True# 否则就返回False>>> string="hes2323">>> string.isalpha()False
islower(self)
检测字符串是否由小写字母组成
1234567 # 如果变量内容全部都是小写字母就返回`True`，否则就返回`False`>>> string="hesasdasd">>> string.islower()True>>> string="HelloWord">>> string.islower()False isspace(self)
检测字符串是否只由空格组成
1234567 # 如果变量内容由空格来组成，那么就返回`True`否则就返回`False`>>> string=" ">>> string.isspace()True>>> string="a">>> string.isspace()False ljust(self,width,fillchar=none)
width -> 指定字符串长度
fillchar ->填充字符，默认我空格
返回一个元字符串左对齐，并使用空格填充至指定长度的新字符串，如果指定的长度小于原字符串长度则返回原字符串
123456 >>> string="helo word">>> len(string)9# 定义的长度减去字符串的长度,剩下的就开始填充>>> string.ljust(15,'*')'helo word******' lower(self)
转换字符串中所有大写字符为小写。
1234 # 把变量里的大写全部转换成小写>>> string="Hello WORD">>> string.lower()'hello word'
lstrip(self,chars=none)
chars ->指定截取的字符
用于截取字符串左边的空格或指定字符
1234 # 从左侧开始删除匹配的字符串>>> string="hello word">>> string.lstrip("hello ")'word' partition(self,sep)
str ->指定的分隔符
用来根据指定的分隔符将字符串进行分割，如果字符串包含指定的分隔符，则返回一个3元的tuple，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
1234 # 返回的是一个元组类型>>> 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次
1234567 >>> 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
1234567 >>> string="hello word"# rfind其实就是反向查找>>> string.rfind("o")7# 指定查找的范围>>> string.rfind("o",0,6)4 rjust(self,width,fillchar=none)
width -> 指定填充字符后中字符串的总长度
fillchar ->填充的字符，默认为空格
返回一个原字符串右对齐，并使用空格填充至长度width的新字符串，如果指定的长度小于字符串的我长度则返回原字符串
1234567 >>> string="hello word">>> len(string)10>>> string.rjust(10,"*")'hello word'>>> string.rjust(12,"*")'**hello word' rtrip(self,chars=none)
chars ->指定删除的字符
删除string字符串末尾指定的字符（默认为空格）
1234 # 从尾部开始匹配删除>>> string="hello word">>> string.rstrip("d")'hello wor' swapcase(self)
用于字符串的大小写字母进行转换，大写变小写，小写变大写
123 >>> string="hello WORD">>> string.swapcase()'HELLO word' title(self)
返回“标题化”的字符串，就是说所有单词都是以大写开始，其余字母为小写
123 >>> string="hello word">>> string.title()'Hello Word' upper(self)
将字符串中的小写字母转为大写字母
123 >>> string="hello word">>> string.upper()'HELLO WORD' 列表(list)
列表的两种方法
第一种：
name_list = ['python','php','java']
第二种：
name_list = list (['python','php','java'])
列表所具备的方法：
append(self,p_object)
在列表的末尾添加新的对象
1234 >>> name_list = ['Python', 'PHP', 'JAVA']>>> name_list.append("C#")>>> name_list['Python', 'PHP', 'JAVA', 'C#']
count(self,value)
obj ->列表中统计的对象
统计某个元素在列表中出现的次数
123 >>> name_list = ['Python', 'PHP', 'PHP']>>> name_list.count("PHP")2 extend(self,iterable)
seq -> 元素列表
用于在列表尾一次性追加另一个序列中多个值
1234567891011 >>> 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 -> 列表中统计的对象
从列表中找出某个值第一个匹配项的索引位置
1234 # 查找对象所在的位置>>> name_list = ['Python', 'PHP', 'JAVA']>>> name_list.index("PHP")1 insert(self,index,p_object)
index -> 对象obj需要插入的索引位置
obj -> 要插入到列表中的对象
将指定对象插入列表
12345 >>> name_list = ['Python', 'PHP', 'JAVA']# 把位置`1`的内容换成`C`，后面的自动退格一个位置>>> name_list.insert(1,"C")>>> name_list['Python', 'C', 'PHP', 'JAVA'] pop(self,index=none)
index ->可选参数，要移除列表元素的位置
移除列表中的一个元素，并且返回该元素的值
123456 >>> name_list = ['Python', 'PHP', 'JAVA']# 删除位置1上面的内容，并且返回删除的字符串>>> name_list.pop(1)'PHP'>>> name_list['Python', 'JAVA']
remove(self,value)
value -> 列表中要移除的对象
移除列表中某个值的第一个匹配项
12345678 >>> 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):
对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数
123456 >>> 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 -> 元素的值
查看列表中元素出现的次数
12345 >>> 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 ->结束的位置
查找元素在元组中的位置
12345 >>> 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)清除内容
删除字典中的所有元素
1234567 >>> person = dict({"name": "mr.right", 'age': 18})>>> person{'age': 18, 'name': 'mr.right'}>>> person.clear()# 清空字典的内容之后字典会变成一个空字典>>> person{} copy(self):
返回一个字典的浅复制
123 >>> person = dict({"name": "ansheng", 'age': 18})>>> person.copy(){'age': 18, 'name': 'ansheng'} fromkeys(S,v=none)
S->字典键值列表
v->可选参数，设置键序列(seq)的值
创建一个新字典，以序列seq中元素做字典的键，value为字典所有对应的初始值
1234 >>> seq = ('name', 'age', 'sex')>>> dict = dict.fromkeys(seq)>>> dict{'age': None, 'name': None, 'sex': None} get(self,k,d=none)
key ->字典中要查找的键
default ->如果指定键的值不存在，返回该默认值
返回指定键的值，如果值不在字典中返回默认值，默认值为none
123 >>> person = {"name": "ansheng", 'age': 18}>>> person.get("name")'ansheng’ items(self)
以列表返回可遍历的(键，值)元组数组
1234 >>> person = {"name": "mr.wu", 'age': 18}# 以元组的方式输出出来>>> person.items()[('age', 18), ('name', 'mr.wu')] key(self)
以列表的形式返回一个字典所有的键
123 >>> person = {"name": "ansheng", 'age': 18}>>> person.keys()['age', 'name'] pop(self,k,d=none)
删除指定给定键所对应的值
12345678 >>> person = {"name": "ansheng", 'age': 18}>>> person{'age': 18, 'name': 'ansheng'}# 返回删除键对应的值>>> person.pop("age")18>>> person{'name': 'ansheng'} popitem(self)
随机返回并删除字典中的一对键和值，因为字典是无顺序的，没有所谓的“最后一项”或是其他顺序
123456 >>> person = {"name": "ansheng", 'age': 18}# 随即删除并显示所删除的键和值>>> person.popitem()('age', 18)>>> person{'name': 'ansheng'} setdefault(self,k,d=none)
key -> 查找的键值
default -> 键不存在时，设置的默认键值
如果key不存在，则创建，如果存在，则返回已存在的值并不修改
12345678 >>> 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里
123456789 >>> dic1 = {"name":"ansheng"}>>> dic2 = {"age":"18"}>>> dic1{'name': 'ansheng'}>>> dic2{'age': '18'}>>> dic1.update(dic2)>>> dic1{'age': '18', 'name': 'ansheng'} values(self)
显示字典中所有的值
123 >>> person = {"name": "ansheng", 'age': 18}>>> person.values()[18, 'ansheng'] 索引
索引就是指某个值在列表或别的数据类型中的一个位置
定义一个列表，查看列表中linux值对应在列表中的位置
12345 >>> 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个字符提取一个
数据类型转换
定义一个整型的变量，然后转换成字符串类型
12345678910 >>> type(age)<class 'int'>>>> age18>>> string=str(age)>>> string'18'>>> type(string)<class 'str'> 使用“\”转义
python允许你对某些字符进行转义，以此实现一些难以单纯用字符描述的效果
12345 # 常用的内容也转义也就是`\n`和`\t`了，`\n`是用来换行的，`\t`是用来代替一个`tab`键>>> string="My \n Name \t is">>> print(string)My Name is 使用 + 拼接
你可以使用 + 号将多个字符串或者字符变量拼接起来
123456 >>> a="my ">>> b="name ">>> c="is ">>> d="ansheng">>> a+b+c+d'my name is ansheng'
数据类型（2）
基本数据类型set集合
集合的元素是不重复且无须的集合，集合就像是字典舍弃了值一样
创建set集合
12345 >>> s = set([11,22,33])>>> s{33, 11, 22}>>> type(s)<class 'set'>
第二种不常用创建set集合的方式
123456 # 这种的创建方式，集合中的元素相当于字典中的key>>> s = {11,22,33}>>> type(s)<class 'set'>>>> s{33, 11, 22} 把其他的可迭代的数据类型转化为set集合
123456 >>> li = ["a","b","c"]>>> seting = set(li)>>> seting{'b', 'a', 'c'}>>> type(seting)<class 'set'> 集合和字典的区别就是字典有冒号，几个没有冒号
列表(list)转换成集合(set)就是[]转换成{}
集合所提供的方法
add
往集合内添加元素（添加的元素也是无顺的）
12345 >>> se = { 11, 22, 33 }# 元素写在小括号内>>> se.add(44)>>> se{33, 11, 44, 22} clear
清除集合内容
1234 >>> se = { 11, 22, 33 }>>> se.clear()>>> seset() copy 浅复制
详细见下面的深浅复制
difference
寻找集合的元素var1中存在，var2中不存在
123456 >>> var1 = { 11, 22, 33 }>>> var2 = { 22 ,55 }>>> var1.difference(var2){33, 11}>>> var2.difference(var1){55} 未完待续。。。。
