第一节 Python基础之数据类型(整型，布尔值，字符串)

print(18,type(18))
输出结果：
18 <class 'int'>

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的二进制位：

结果我们看出，确实是5位

注：关于计算机进制不懂的自行度娘了

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 lower(self):
"""
S.lower() -> str #返回一个字符串 Return a copy of the string S converted to lowercase.#返回一个小写的字符串,但是只对'A-Z'有效
"""
return ""

print("JASONHY".casefold())
输出结果是:
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 ""

#指定width大于字符串的长度，居中
print("jasonhy".center(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

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

#默认情况下
print("jasonhy".startswith("j"))
输出结果是：
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

#默认查找
print("jasonhyjasonhy".find("j"))
输出结果是：
0

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

#只要是由汉字，字母，数字中的一个或者他们的组合返回就是True
print("jasonhy1970".isalnum())
输出结果是：
True

从上面的功能中，我们发现isdecimal（） isdigit（） isnumeric（）都是用来判断数字的，那它们有什么区别呢？

从上面的结果，我们发现isnumeric（）情况下，阿拉伯数字和汉语下的数字都是返回True，而在汉语数字的情况下，isdigit（）和isdecimal()返回的是False，还有文档说明，罗马数字下isdigit（）返回的是True，isdecimal()返回的是False，由于本人在罗马数字的情况下测试不出想要的结果，所以在这里就不做演示了，我们需要知道的一点就是，只要数字，用isnumeric（）来做判断，返回的都是True

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

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

#首字母是大写，但是其他有大写的情况
print("JasoNhy".istitle())
输出结果是：
False

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 ""

#用×将字符串隔开
print("*".join("jasonhy"))
输出结果是：
j*a*s*o*n*h*y

#默认切割
print("jasonhyjasonhy".split("s"))
输出结果是：
['ja', 'onhyja', 'onhy']

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 ""

#移除两边的空格
print(" 18785100000 ".strip())
输出结果是：
18785100000

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

#对字符串遍历,使每个字符对应相应的索引
for item in range(len("jasonhy")):
print(item,s[item])
输出结果是:
0 j
1 a
2 s
3 o
4 n
5 h
6 y