数据类型是每一种语言的基础，就比如说一支笔，它的墨有可能是红色，有可能是黑色，也有可能是黄色等等，这不同的颜色就会被人用在不同的场景。Python中的数据类型也是一样，比如说我们要描述一个人的年龄：小张今年18岁，这18就是一个整数，那么在Python语言里，我们将它定义为一个整型。我们也通过这一个例子引入Python的数据类型。
在讲数据类型之前，我们先引入两个方法，type和print，type是用来查看数据类型的，print是用来在控制台输出的，在接下的案例都会经常用到。
那么Python的数据类型有哪些呢？
Pyhton中的数据类型主要分为：整型（int）布尔值（bool）字符串（str）元组（tuple）列表（list）字典（dict）。
一、整型（int）：
现在有一个需求就是，就是我想输出一个18，并查看我们18是不是就像上面我说的一样，就是一个整型呢？那么我们可以这样做：
print(18,type(18))
输出结果：
18 <class 'int'>
从输出结果我们就知道，这样一个整数类型的在Pyhton里面就是一个整型。
那么整型数据类型都有哪些功能（方法）给我们使用呢？也就是说，我们用这些功能来完成什么事？
功能一：统计二进制位
def bit_length(self):
"""
int.bit_length() -> int #表示调用此方法返回的也是int类型的数
Number of bits necessary to represent self in binary. #返回的这个数是自身的二进制位
"""
return 0
案例：
print((18).bit_length())
输出结果：
5
18的二进制位：
print(bin(18))
输出结果：
0b10010
结果我们看出，确实是5位
注：关于计算机进制不懂的自行度娘了
这个方法一般也不怎么用！！！
二、布尔值（bool）
就是True和False，这个没什么要说的，需要注意的就是，bool（...)里面的参数如果是：None，""，()，[]，{}，0中的一个的时候，返回值是Fasle
三、字符串（str）
用' '或者" "包起来的就是一个字符串，比如：
print(type(''),type(""))
输出结果都是：
<class 'str'>
功能一：将首字母变成大写
def capitalize(self):
"""
S.capitalize() -> str #返回的是一个字符串 Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case. #如果首字母是小写，就将首字母变成大写，然后再将这个字符串返回
"""
return ""
案例：
print("jasonhy".capitalize())
输出结果是：
Jasonhy
用法：比如通过网页来生成个性名片，我们可以判断用户的用户名如果是英文并且首字母是小写，我们就可以将首字母变成大写之后，再将数据返回，展示给用户
功能二:大小写转换
def casefold(self): #3.3引入的
"""
S.casefold() -> str #返回一个字符串 Return a version of S suitable for caseless comparisons.#返回一个小写的字符串,可以对任何字符都有效
"""
return ""
def swapcase(self):
"""
S.swapcase() -> str Return a copy of S with uppercase characters converted to lowercase
and vice versa. #如果是大写,就转换成小写,小写的话就转换成大写
"""
return ""
def lower(self):
"""
S.lower() -> str #返回一个字符串 Return a copy of the string S converted to lowercase.#返回一个小写的字符串,但是只对'A-Z'有效
"""
return ""
案例:
print("JASONHY".casefold())
输出结果是:
jasonhy
print("JASONHY".lower())
输出结果是:
jasonhy
官网文档解释，这两个方法，如果其他语言中存在写的话，lower()是没有办法进行转换，比如德语中'ß'的小写是'ss'，而casefold是可以的，那么我们的解决办法可以如果中文和英文可以继续用lower（），其他语言的话再用casefold（），毕竟casefold（）是3.3才出现的。
def upper(self):
"""
S.upper() -> str Return a copy of S converted to uppercase. #返回一个经转换成大写的字符串
"""
return ""
案例：
print("jasonhy".upper())
输出结果是：
JASONHY
用法：我们在随机生成验证码的时候，有的时候生成的大写，有的时候是小写，有的时候是大小写混搭，我们为了方便处理，往往是将它转换成大写或者小写，然后统一处理
功能三：字符串的显示位置
def center(self, width, fillchar=None):
"""
S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space) #指定要显示的总长度width，width的长度减去字符串的的长度，剩余的默认用空格填充，字符串居中显示，如果差值小于0，那就只显示字符串
"""
return ""
def zfill(self, width):
"""
S.zfill(width) -> str Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.#以0的形式在左边填充
"""
return ""
def ljust(self, width, fillchar=None):
"""
S.ljust(width[, fillchar]) -> str Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).#字符串显示在左边
"""
return ""
def rjust(self, width, fillchar=None):
"""
S.rjust(width[, fillchar]) -> str Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space). #字符串显示在右边
"""
return ""
案例：
#指定width大于字符串的长度，居中
print("jasonhy".center(9,"*"))
输出结果是：
*jasonhy*
#以0的形式左边填充
print("jasonhy".zfill(9))
输出结果是：
00jasonhy
#指定长度小于字符串的长度，居中
print("jasonhy".center(6,"*"))
输出结果是：
jasonhy
#左边显示
print("jasonhy".ljust(9,"*"))
输出结果是：
jasonhy**
#右边显示
print("jasonhy".rjust(9,"*"))
输出结果是：
**jasonhy
功能四：统计字符出现的次数
def count(self, sub, start=None, end=None):
"""
S.count(sub[, start[, end]]) -> int #返回一个数字 Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation. #统计一个字符串中某个字符出现的次数，start表示统计的起始位置，end表示统计的结束位置，如果start和end不传的话，默认统计整个字符串
"""
return 0
案例：
#默认情况
print("jasonhyjasonhyjasonhy".count("j"))
输出结果是：
3
#设置起始位置
print("jasonhyjasonhyjasonhy".count("j",2,10))
输出结果是：
1
功能五：判断某个字符串的起始位置或结尾位置是某个字符串或某个字符
def startswith(self, prefix, start=None, end=None):
"""
S.startswith(prefix[, start[, end]]) -> bool #结果返回的是一个布尔值 Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try. #是否某个字符串开头，start表示从哪个位置开始算，end表示到哪个位置结束，默认是从0的位置开始
"""
return False
def endswith(self, suffix, start=None, end=None):
"""
S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try. #是否以某个字符串结尾
"""
return False
案例：
#默认情况下
print("jasonhy".startswith("j"))
输出结果是：
True
#规定起始位置
print("jasonhy".startswith("j",1,5))
输出结果是：
False
#默认情况
print("jasonhy".endswith("y"))
输出结果是：
True
#规定了起始位置
print("jasonhy".endswith("y",1,5))
输出结果是：
False
用法：比如我们公司要对不同姓氏的员工进行归类，这时我们就可以拿到每个员工的姓名，然后判断他是由哪个姓开头，只要结果返回True的，我们就可以将他归为一类了
功能六：查找某个字符在字符串中出现的位置
def find(self, sub, start=None, end=None):
"""
S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation. #返回这个字符出现的位置，默认返回第一次出现的位置，start表示从哪开始查找，end表示到哪结束 Return -1 on failure. #如贵这个字符查不到，结果返回-1
"""
return 0
def index(self, sub, start=None, end=None):
"""
S.index(sub[, start[, end]]) -> int Like S.find() but raise ValueError when the substring is not found. #和find一样，但是如果查不到就会报错
"""
return 0
案例：
#默认查找
print("jasonhyjasonhy".find("j"))
输出结果是：
0
#规定查找的位置
print("jasonhyjasonhy".find("j",1,8))
输出结果是：
7
用法：既然find（）和index（）都是查找字符出现的位置，但是index（）如果查不到程序就会挂掉，对于我们来说，我希望的是找不到，这个程序能继续运行，而不是直接挂掉，所以一般我们用的是find（）。
功能七：判断字符串里面是否含有数字，字母，汉字
def isalnum(self):
"""
S.isalnum() -> bool Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise. #是否是由数字、字母、汉字组成，或者是这些的组合
"""
return False
def isalpha(self):
"""
S.isalpha() -> bool Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise. #是否是由汉字、字母或这两者组成
"""
return False
def isdecimal(self): #
"""
S.isdecimal() -> bool Return True if there are only decimal characters in S, #是否只是由数字组成
False otherwise.
"""
return False
def isdigit(self):
"""
S.isdigit() -> bool Return True if all characters in S are digits
and there is at least one character in S, False otherwise. #是否由数字组成
"""
return False
def isnumeric(self):
"""
S.isnumeric() -> bool Return True if there are only numeric characters in S, # 是否由数字组成
False otherwise.
"""
return False
案例：
#只要是由汉字，字母，数字中的一个或者他们的组合返回就是True
print("jasonhy1970".isalnum())
输出结果是：
True
#是否只是又汉字和字母组成，是的话就返回True
print("jasonhy1970".isalpha())
输出结果是：
False
从上面的功能中，我们发现isdecimal（） isdigit（） isnumeric（）都是用来判断数字的，那它们有什么区别呢？
print("".isdigit())
print("".isdecimal())
print("".isnumeric())
阿拉伯数字的情况下，这三者的输出结果都是：
True
print("一".isdigit())
print("一".isdecimal())
这两个输出都是：
False
print("一".isnumeric())
输出结果是：
True
从上面的结果，我们发现isnumeric（）情况下，阿拉伯数字和汉语下的数字都是返回True，而在汉语数字的情况下，isdigit（）和isdecimal()返回的是False，还有文档说明，罗马数字下isdigit（）返回的是True，isdecimal()返回的是False，由于本人在罗马数字的情况下测试不出想要的结果，所以在这里就不做演示了，我们需要知道的一点就是，只要数字，用isnumeric（）来做判断，返回的都是True
用法：用户在设置密码的时候，我们希望用户的密码设置不要过于简单，比如全是数字或全是字母，我们可用isalpha（）是否都是字母和isnumeric（）是否都是数字，如果符合这两种情况下的一种，我们就给用户一个提示，说“设置的密码过于简单，密码应该包含字母，数字”等等
功能八：制表
def expandtabs(self, tabsize=8):
"""
S.expandtabs(tabsize=8) -> str Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed. #通过tabsize来计数，如果在计数的过程中，遇到'\t'的话，就以空补齐
"""
return ""
案例：
#制作一个姓名和年龄对应的表格
print("name\tage\njasonhy\t18".expandtabs(10))
输出结果是：
name age
jasonhy 18
功能九：判断一个字符串是否是标识符
def isidentifier(self):
"""
S.isidentifier() -> bool Return True if S is a valid identifier according
to the language definition. #如果一个字符串按照标志符的格式的话，返回True Use keyword.iskeyword() to test for reserved identifiers
such as "def" and "class".
"""
return False
补充：什么是标识符？
①第一个字母必须是字母或者下划线
②剩下的字符可以是数字,字母或者下划线
③区分大小写
案例：
#定义一个run的标识符
print("run".isidentifier())
输出结果是：
True
用法：可以通过自带的ide来测试自己将要定义的是否是标识符，是的话，就可以用在自己的程序中，但是一般没有必要这样做
功能十：判断是一个字符串中是否含有不可显示的字符
def isprintable(self):
"""
S.isprintable() -> bool Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise. #如果一个字符串中含有不可显示的字符时，比如'\t'，'\n'返回False
"""
return False
案例：
#含有'\t'
print("jasonhy\t18".isprintable())
输出结果是：
False
用法：用户在输入电话号码的时候，不小心按到的换行符，那么这时我们就可以提示用户输入了电话号码含有其他字符，或者我们也可以判断这种不可显示的字符是属于那种字符，然后用""来替换掉
功能十一：是否都是空格
def isspace(self):
"""
S.isspace() -> bool Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise. #如果字符串都是空格，就返回True
"""
return False
案例：
#不全都是空格
print(" jasonhy".isspace())
输出结果是：
False
用法：我们有的时候需要一个需求，就是当我们分享一些文件的时候，我们希望用户在评论之后才能看到全部的内容，评论内容也规定了一定的字数，为了避免用户输入的一大串的全部空格来凑齐字数，如果用户是在这种情况下，我就要提示用户输入的内容不能为空
功能十二：判断是否是标题以及标题转换
def istitle(self):
"""
S.istitle() -> bool Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones. #如果字符串的首字母是大写并且其他的都是小写，返回True
Return False otherwise.
"""
return False
def title(self):
"""
S.title() -> str Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case. #将字符串的首字母变成大写，其他全都变成小写
"""
return ""
案例：
#首字母是大写，但是其他有大写的情况
print("JasoNhy".istitle())
输出结果是：
False
#通过title（）来进行转换
print("JasoNhy".title().istitle())
输出结果是：
True
功能十三：字符串连接和分割
def join(self, iterable):
"""
S.join(iterable) -> str Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S. #将一个字符串添加到一个可迭代的字符串里面，这个字符串将会在每个可迭代的字符串的字符之间
"""
return ""
def split(self, sep=None, maxsplit=-1):
"""
S.split(sep=None, maxsplit=-1) -> list of strings #返回的是一个字符串的列表 Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result. #通过字符串中的某一个字符或字符串对这个字符串进行切割，被用来切割的字符串或字符不会出现在字符串列表中，如果指定maxsplit，也就是切割数，来进行切割，如果这个切割数超过这个字符串中被选中切割的字符出现的次数，则按照被选中字符出现的次数进行切割，这时候这个切割数就不起作用了
"""
return []
def partition(self, sep):
"""
S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.#也是用来切割的，被选中的字符切割之后还存在在元组中，得到的元组主要分为三段，头-被选中切割的字符-尾，从左边开始查找切割字符
"""
pass
def rpartition(self, sep):
"""
S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S. #从右边查找切割字符
"""
pass
案例：
#用×将字符串隔开
print("*".join("jasonhy"))
输出结果是：
j*a*s*o*n*h*y
#拼接元组里面的字符串（元组后面会讲到）
print(" ".join(("my","name","is","jasonhy")))
输出结果是：
my name is jasonhy
#拼接列表里面的字符串（列表后面会讲到）
print(" ".join(["my","name","is","jasonhy"]))
输出结果是：
my name is jasonhy
#默认切割
print("jasonhyjasonhy".split("s"))
输出结果是：
['ja', 'onhyja', 'onhy']
#指定切割数
print("jasonhyjasonhy".split("s",1))
输出结果是：
['ja', 'onhyjasonhy']
#三段式切割，从左边开始查找
print("jasonhyjasonhy".partition("s"))
输出结果是：
('ja', 's', 'onhyjasonhy')
#三段式切割，从右边开始查找
print("jasonhyjasonhy".rpartition("s"))
输出结果是：
('jasonhyja', 's', 'onhy')
用法：我们在填写兴趣爱好的时候，一般情况都会填写很多兴趣，我们在提交这些兴趣爱好的时候，一般都是以字符串的加逗号形式进行提交的，那么在后台进行数据处理的时候，就需要对这些字符串进行处理，这时就用split来进行切割了，","切割之后得到一个列表，我们再将这个列表返回前台；在我填写地址信息的时候，如果我们和后台约定提交的方式是：["广东省","广州市","天河区"]，这时候，join就有用武之地了。
功能十四：空格处理
def strip(self, chars=None):
"""
S.strip([chars]) -> str Return a copy of the string S with leading and trailing
whitespace removed. #移除两边的空格
If chars is given and not None, remove characters in chars instead. #如果两端只有其中一端有空格，或者都没有空格，在指定chars的时候，就可以移除没有空格的那一端
"""
return ""
def lstrip(self, chars=None):
"""
S.lstrip([chars]) -> str Return a copy of the string S with leading whitespace removed. #移除左边的空格
If chars is given and not None, remove characters in chars instead. #如果左边不是空格，当chars不是空的时候，就移除chars
"""
return ""
def rstrip(self, chars=None):
"""
S.rstrip([chars]) -> str Return a copy of the string S with trailing whitespace removed. #移除右边的空格
If chars is given and not None, remove characters in chars instead. #如果右边没有空格，并且chars不为空的时候，就将chars移除
"""
return ""
案例：
#移除两边的空格
print(" 18785100000 ".strip())
输出结果是：
18785100000
用法：我们在登录输入密码的时候，有的时候不小心就多加一个空格，在后台进行数据处理的时候，就要用strip（）来去除空格了，要不然用户就认为自己的密码错了，怎么输还是错误，这样就不好了。
功能十五：替换
def replace(self, old, new, count=None):
"""
S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced. #将指定的字符串替换成新的字符串,如果count指定,就按照count数来进行替换
"""
return ""
案例:
#只替换一个j
print("jasonhyjasonhy".replace("j","J",1))
输出结果是:
Jasonhyjasonhy
用法:一般用来进行正则表达式(后面讲到)替换的
功能十六:生成连续数字(range函数)
#对字符串遍历,使每个字符对应相应的索引
for item in range(len("jasonhy")):
print(item,s[item])
输出结果是:
0 j
1 a
2 s
3 o
4 n
5 h
6 y