数字型
1.int():整数
class int(x,base=10) #x是数字或者字符串，base是进制数，默认是十进制，返回整型数据
int() #无参数时返回0
int(3.6) #3
int('12',16) #如果是带参数base的话，参数要用字符串形式，因为输入纯数字的时候int()的作用是取整
int("3.5",8) # 报错，str必须为整数
int("1010",2) # 1010是正确的二进制格式
总结：int()对纯数字的作用是取整，进行进制转换必须用字符串类型，而且字符串中的数字为整数，base为2时进行的是将前面的二进制转换为十进制，其余base则是将前面的字符串转换成对应的进制数。
字符串
2.format()：格式化输出
-
位置：
print("{} {}".format("123","456")) # 默认顺序输出 print("{1} {0}".format("123","456")) # 颠倒位置 print("{1} {0} {0}".format("123","456")) # 重复输出 ''' 输出结果： 123 456 456 123 456 123 123 ''' -
设置参数：
print("名字:{name},年龄:{age}".format(name="sss",age="18")) # 通过字典 site={"name":"sss","age":"19"} print("名字：{name},年龄：{age}".format(**site)) #通过列表索引 list1=["sss","14"] print("名字：{0[0]},年龄：{0[1]}".format(list1)) #{0[0]},第一个0代表format中的第一个列表，第二个0代表列表中的第一个参数 ''' 输出结果： 名字:sss,年龄:18 名字：sss,年龄：19 名字：sss,年龄：14 ''' -
类方法：
class A(object): #类 def __init__(self,value): # 构造方法，value初始化 self.value=value A_value=A(45) # 初始化value print("value的值为{0.value}".format(A_value)) # 输出结果：value的值为45 -
数字格式化：
print("{:.2f}".format(3.1415926)) # 3.14 print("{:.3f}".format(3.456897)) # 3.457数字 格式 输出 描述 3.1415926 {:.2f} 3.14 保留小数点后两位 3.1415926 {:+.2f} +3.14 带符号保留小数点后两位 -1 {:+.2f} -1.00 带符号保留小数点后两位 2.71828 {:.0f} 3 不带小数 5 {:0>2d} 05 数字补零 (填充左边, 宽度为2) 5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4) 10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4) 1000000 {:,} 1,000,000 以逗号分隔的数字格式 0.25 {:.2%} 25.00% 百分比格式 1000000000 {:.2e} 1.00e+09 指数记法 13 {:>10d} 13 右对齐 (默认, 宽度为10) 13 {:<10d} 13 左对齐 (宽度为10) 13 {:^10d} 13 中间对齐 (宽度为10) 11 '{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)1011 11 13 b 0xb 0XB进制 ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外还可以用{}来充当转义符：
print("{0}对应的第一个位置是{{0}}".format("123456")) #第一个大括号中的0可以省略 print("{1}对应的第一个位置是{{1}}".format("123456","absdf")) # 输出结果：123456对应的第一个位置是{0} # 输出结果：absdf对应的第一个位置是{1}
2.encode():指定的编码格式编码字符串
# 语法：
str.encode(encoding='utf-8',errors='strict')
# 参数：encodin--要使用的编码，errors--设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
# 返回值：该方法返回编码后的字符串，它是一个 bytes 对象。
s='起来学习'
s_utf=s.encode('utf-8')
s_gbk=s.encode('gbk')
print("utf-8长度：",len(s_utf))
print("gbk长度：",len(s_gbk))
print("utf-8编码：",s_utf)
print("gbk编码：",s_gbk)
print("utf-8解码：",s_utf.decode('utf-8','strict'))
print("gbk解码：",s_gbk.decode('gbk','strict'))
'''
utf-8长度： 12
gbk长度： 8
utf-8编码： b'\xe8\xb5\xb7\xe6\x9d\xa5\xe5\xad\xa6\xe4\xb9\xa0'
gbk编码： b'\xc6\xf0\xc0\xb4\xd1\xa7\xcf\xb0'
utf-8解码： 起来学习
gbk解码： 起来学习
'''
3.join():连接成新字符串
# 语法：
str.join(sequence)
# sequence--要连接的元素序列
# 返回值：通过指定字符连接序列中的元素后生成新的字符串
ls=['1','1','3']
print(';'.join(ls))
# 1;1;3
ls="123456"
print(';'.join(ls))
# 1;2;3;4;5;6
ls=('1','2')
print(';'.join(ls))
# 1;2
ls= {"name":"joy","school":"comper"}
print(';'.join(ls))
# name;school
4.split():指定分隔符对字符串切片
# 语法：
str.split(str='',num=string.count(str))
# 参数：str--分隔符，默认为所有的空字符，包括空格，换行，制表符等，num--分割次数。默认为-1，即分隔所有。
# 返回值：返回分隔后的字符串列表
s="what\nis\nyou\nname"
s1="what\tis\tyou\nname"
s2="what\n is\nyou\nname"
print(s.split())
print(s2.split(' ',2))
print(s1.split())
'''
['what', 'is', 'you', 'name']
['what\n', 'is\nyou\nname']
['what', 'is', 'you', 'name']
'''
5.replace():字符串以新代旧
# 语法：
str.replace(old,new[,max])
# 参数：old--将被替换的子字符串，new--新字符串，用于替换旧字符串，max--可选字符串，替换次数不超过max次
# 返回值：返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
s="Here is a pen,here is a pencil."
print(s.replace("is","was"))
print(s)
ls=['1','a','1','b']
a=' '.join(ls)
print(a.replace("1","",1))
'''
Here was a pen,here was a pencil.
Here is a pen,here is a pencil.
a 1 b
'''
6.find():找指定的子字符串
# 语法：
str.find(str,beg=0,end=len(string))
# 参数：str--指定检索的字符串，beg--开始检索，默认为0，end--结束检索，默认为字符串长度
# 返回值：如果包含子字符串返回开始的索引值，否则返回-1。
s="123sdfaa79**"
print(s.find('t'))
print(s.find('s',4,7))
print(s.find('s',2,7))
'''
-1
-1
3
'''
7.index():找指定的子字符串
# 语法：
str.index(str, beg=0, end=len(string))
# 参数：str -- 指定检索的字符串，beg -- 开始索引，默认为0，end -- 结束索引，默认为字符串的长度。
# 返回值：如果包含子字符串返回开始的索引值，否则抛出异常。
s="123sdfaa79**"
print(s.index('2',0,3))
print(s.index('t'))
'''
1
ValueError: substring not found
'''
8.ord():查字符ASCII码（转十进制）
'''
描述：
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
注意：python3不支持unicode函数
'''
# 语法：
ord(c)
# 参数：c--字符
# 返回值：对应的十进制整数
ord('a')
# 97
9.char():查整数对应的ASCII字符（ASCII码）
'''
描述：
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
'''
# 语法：
chr(i)
# 参数：i -- 可以是10进制也可以是16进制的形式的数字。
# 返回值：当前整数对应的 ASCII 字符。
print(chr(48))
# 0
10.ljust():左对齐
# 语法：str.ljust(width[,fillchar])
# 参数：width--指定字符串长度，fillchar--填充字符，默认为空格
# 返回值：返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
s='this is a example'
print(s.ljust(30,'#'))
# this is a example#############
11.rjust():右对齐
# 语法：str.rjust(width[,fillchar])
# 参数：width--指定字符串长度，fillchar--填充字符，默认为空格
# 返回值：返回一个原字符串右对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
s='this is a example'
print(s.rjust(30,'#'))
# #############this is a example
12.zfill():右对齐填0
# 语法：str.zfill(width)
# 参数：width--指定字符串长度，原字符串右对齐，前面填充0
# 返回值：返回指定长度的字符串
s='this is a example'
print(s.zfill(0))
print(s.zfill(30))
# this is a example
# 0000000000000this is a example
13.strip():去头尾
# 语法：str.strip([chars])
# 参数：chars--移除字符串头尾指定的字符序列
# 返回值：返回移除字符串头尾指定的字符序列生成的新字符串。
s='aaathisisaexampleaaa'
print(s.strip('a'))
# thisisaexample
# 可以看出中间没有被删掉
14.isdigit():都是数字
# 语法：str.isdigit()
# 参数：无
# 返回值：如果字符串只包含数字则返回 True 否则返回 False。
s='123456'
s1='123aa'
print(s.isdigit())
print(s1.isdigit())
# True
# False
15.isalpha():都是字母或者数字
# 语法：str.isalpha()
# 参数：无
# 返回值：如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。
s='123456'
s1='123aa'
s2=''
print(s.isalpha())
print(s1.isalpha())
print(s2.isalpha())
# True
# False
print("aABC".isalpha())
# True
16.range():一个可迭代的范围
# 语法：range(stop) range(start,stop[,step])
# 参数：start--开始计数，stop--结束计数，但是不包括stop，step--步长，默认为1
# range()函数返回的是一个可迭代对象，类型是对象，而不是列表类型
r1=range(5)
print(type(r1))
l1=list(r1)
print(l1)
r2=range(9,1,-1)
for i in r2:
print(i,end=" ")
# <class 'range'>
# [0, 1, 2, 3, 4]
# 9 8 7 6 5 4 3 2
列表
1.sort() 列表排序，看大小写
在实际开发中，关于对列表的排序我们会经常遇到。python为我们提供了两种关于对列表的排序方法。一起来看看。
使用列表对象的sort()方法实现
sort方法语法格式：
listname.sort(key = none,reverse = False)
参数说明：
listname: 表示要排序的列表
key: 表示在指定列表选择一个用于比较的键，如果设置 'key = str.lower' ,则表示在排序的时候不区分大小写。
reverse:可选参数，如果将其指定为True，表示降序排列，如果为False,则表示为升序排列
例如:
grade = [85,56,95,45,73,81,83,64,92,77]
print('原列表',grade)grade.sort()
print('升序',grade)grade.sort(reverse=True)
print('降序',grade)
执行上述代码结果如下：
原列表 [85, 56, 95, 45, 73, 81, 83, 64, 92, 77]
升序 [45, 56, 64, 73, 77, 81, 83, 85, 92, 95]
降序 [95, 92, 85, 83, 81, 77, 73, 64, 56, 45]
使用sort()方法排序比较简单,但是使用sort()方法对字符串列表排序的时候，采用的是大写优先原则，就是说先按照大写字母顺序排列，再按照小写字母顺序排列。是否按照大小写顺序排列主要取决于参数key,下面请细看示例。
NBA = ['Bryant','James','curry','durant']
print('原列表',NBA)NBA.sort()
print('区分大小写',NBA)NBA.sort(key = str.lower)
print('不区分大小写',NBA)
执行上述代码结果如下：
原列表 ['Bryant', 'James', 'curry', 'durant']
区分大小写 ['Bryant', 'James', 'curry', 'durant']
不区分大小写 ['Bryant', 'curry', 'durant', 'James']
说明:
采用sort()方法排序时，对中文支持不友好，排序的结果和我们平时的笔画或者拼音都是不一样的，如果想要实现对中文列表的排序，就需要自己手动写方法来实现。
使用内置函数sorted()函数实现
在python中还带有一个内置的sortd()函数，首先来看看它的语法格式:
sorted(intrable, key = None, revrese = False）
参数说明:
intrable: 表示要排序的列表名称
key: 表示在指定列表选择一个用于比较的键，如果设置 'key = str.lower' ,则表示在排序的时候不区分大小写。
revrese：可选参数，如果将其指定为True，表示降序排列，如果为False,则表示为升序排列
例如:
grade = [85,56,95,45,73,81,83,64,92,77]
print('原列表',grade)grade.sort()
print('升序',grade)grade.sort(reverse=True)
print('降序',grade)
执行上述代码结果如下：
原列表 [85, 56, 95, 45, 73, 81, 83, 64, 92, 77]
升序 [45, 56, 64, 73, 77, 81, 83, 85, 92, 95]
降序 [95, 92, 85, 83, 81, 77, 73, 64, 56, 45]
说明：
列表对象的sort()方法和内置函数sorted()方法基本相同，不同之处就在于
sort方法会在原list上直接进行排序，不会创建新的list。而sorted方法不会对原来的数据做任何改动，排序后的结果是新生成的。
如果我们不需要原来的数据而且数据是list类型，可以用sort方法，能够节省空间。否则要用sorted方法。
总的来说就是sorted方法不会对原来的数据做任何改动，排序后的结果是新生成的。所以sorted会返回一个排序过的列表！
引自：博主：
weixin_39639622
# 语法：list.sort(key=None,reverse=False)
# 参数： key--主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自可迭代对象当中，指定一个可迭代对象中的一个元素来排序
# reverse：排序规则，reverse=True降序；reverse=False，升序（默认）
# 返回值：该方法没有返回值，但是会对列表的对象进行排序
al = ['nihao', 'python', 'pycharm']
al.sort(reverse=True)
print(al)
# ['python', 'pycharm', 'nihao']
al = ['nihao', 'python', 'Pycharm']
al.sort(reverse=True)
print(al)
# ['python', 'nihao', 'Pycharm']
# 可以指定列表中的元素进行排序
r = [(1, 9), (3, 4), (7, 8)]
def takeSecond(r):
return r[1]
r.sort(key=takeSecond)
print(r)
# [(3, 4), (7, 8), (1, 9)]
在key关键字中是一个小循环，就是指定的全部的迭代对象
2.remove() 移除指定的第一个元素
# 语法：list.remove(obj)
# 参数：obj：列表中要移除的元素
# 返回值：该方法没有返回值但是会移除列表中的某个值的第一个匹配值
ls=['aa','bb','de','rsd','aa']
ls.remove('aa')
print(ls)
remove()函数的运行中有个需要注意的地方，主要是删除一个列表中的元素之后，列表中的索引号也会跟随改变，删一个改一次，不是最后才改的。
3.pop():移除元素
# 语法：list.pop([index=-1])
# obj--可选参数，要移除列表元素的索引值，不能超过列表总长度，默认index=-1，删除最后一个列表值
# 返回对象：该方法返回从列表中移除的元素对象
l=[1,2,3,4,4,5,7]
a=l.pop(3)
print(a,l)
# 4 [1, 2, 3, 4, 5, 7]