基本数据类型的内置方法（一）

八大数据类型的内置方法

一、整型(int)和浮点型(float)的内置方法

	# 整型和浮点型的内置方法
	'''
	语法格式：						方法的表现方式：
		数据类型.方法名()				int(res) # 方法名()
	'''
	1.数据类型的转换
	int可以将由纯数字构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
	res = '123'
	print(res,type(res)) #打印出来的是(123 <class 'str'>)
	print(int(res),type(int(res))) #打印出来的是(123 <class 'int'>)
	'''内置方法'''
	print(int(res))
============================
	rev = '12.33'
	rev = int(rev)错误示范：字符串内包含了非整数符号
	print(rev)
	这个是报错提示：
		（Traceback (most recent call last):
	 	File "Neizhi.py", line 1, in <module>
	    rev = int(rev)
		ValueError: invalid literal for int() with base 10: '12.3'）

	1.2进制的转换
	'''十进制转换其他进制'''
	print(bin(10)) # 0b1010 0b代表的是二进制
	print(oct(2000)) #0o3720 0o代表的是八进制
	print(hex(2000)) #0x7d0 0x代表的就是十六进制
	'''这里做一个补充：十六进制10、11、12、13、14、15分别是用a/b/c/d/e/f来表示的'''

	'''其他进制转换十进制'''
	print(int('0b1010',2)) # 打印结果：10 里面的那个逗号后面的2、8、16就是对应的进制
	print(int('0o3720',8)) # 打印结果：2000
	print(int('0x7d0',16)) # 打印结果：2000

	
	1.3 float同样也可以做数据转换
	vrl = '12.3'
	vrl = float(vrl)
	print(vrl,type(vrl)) #打印出来的是(12.3 <class 'float'>)
	'''内置方法'''
	print(float(vrl))

数字类型主要就是用来做算术运算与比较运算，因此数字类型除了与运算符结合使用外，并无需要掌握的内置方法

二、字符串(str)的内置方法

1.数据类型转换

	str()可以将任意数据类型转换成字符串类型。如：
	name = ['chen','jack','tom','mc']
	name = str(name) #list ----> str
	print(name,type(name)) # ['chen', 'jack', 'tom', 'mc'] <class 'str'>
	'''内置方法'''
	print(str(name),type(str(name)))
======================================
	vall = {'name':'chen','age':18,'height':182}
	vall = str(vall)  #dict ----> str
	print(vall,type(vall)) # {'name': 'chen', 'age': 18, 'height': 182} <class 'str'>
	'''内置方法'''
	print(str(vall),type(str(vall)))
	
	'''列表、字典哪些带着括号的转换字符串的话取值的时候用下标（索引）取值的时候，会把里面的所有都算进去'''
	如：
	vl_list = ['chen','jack','tom']
	vl_list = str(vl_list)
	print(vl_list[0]) # 得到的是[

2.优先掌握的操作

	hak = 'hello Python!'
	1.按索引（下标）取值
	1.1.正向取值（从左往右）
	print(hak[2]) # （l）
	1.2.反向取值（负号表示从右往左）
	print(hak[-1])  # （！）
	'''对于字符串来说只能用索引取值，不允许改变值'''
	hak[0] = 'x' # 报错： TypeError: 'str' object does not support item assignment

	2.切片（顾头不顾尾，步长）
	print=（hak[0:9]） #（hello Pyt）
	'''顾头不顾尾，'''
	print = (hak[:5]) # 从索引0的位置一直切到4
	print = (hak[3:]) # 从3开始一直切到末尾
	2.1步长:下面演示里面的第三个参数'2'代表步长，会从0开始，每次加到2即可，所以会取出索引0、2、4、6、8的字符
	print=(hak[0:9:2]) #(hloPt)
	2.2反向切片
	print = (hak[::-1]) # (!nohtyP olleh) -1表示从右往左依次取值 

	3.长度len
	3.1获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符
	ankn = 'abcdefghijklmnop qrstuvwxyz'
	print(len(ankn)) #(27) 空格也算字符
	
	4.成员运算 in 和 not in
	ankn = 'abcdefghijklmnop qrstuvwxyz'
	4.1 in(在) 和 not in(不在)
	print('ghijkl' in ankn) # in是在的意思，当前这个在ankn里面 故返回True
	print('ghijkl' not in ankn) # not in 是不在的意思，当前这个在ankn里面 故返回False
	
	5.strip移除字符串首尾指定的字符（默认移除空格）
	5.1括号内不指定字符，默认移除首尾空白字符（空格、\n、\t）
	ankn = ' hello world '
	print(ankn.strip(),len(ankn)) # (hello world 13)
	print(ankn.strip(),len(ankn.strip())) # hello world 11
	-------------------------------------
	5.2括号内指定字符，移除首尾指定的字符
	ankn = '@@hello world@@'
	print(ankn.strip('@'),len(ankn)) # (hello world 15)
	print(ankn.strip('@'),len(ankn.strip('@'))) # hello world 11

	6.切分split
	6.1括号内不指定字符，默认以空格作为切分符号
	ankn = 'hi! good morning tom!'
	print(ankn.split()) # ['hi!', 'good', 'morning', 'tom']
	6.2括号内指定分隔字符，则按照括号内指定的字符分割字符串
	ankn = '127.0.0.1'
	print(ankn.split('.')) #['127', '0', '0', '1']
	'''注意：split切割得到的结果是列表数据类型'''

	7.循环
	ankn = '迄今为止人生都是大写的失败！'
	for i in ankn: #依次取出字符串中每一个字符
    	print(i,end=' ') # 迄 今 为 止 人 生 都 是 大 写 的 失 败 ! 

3.需要掌握的操作

	1.strip,lstrip,rstrip
	str1 = '**tony***'
	 
	str1.strip('*')  # 移除左右两边的指定字符
	'tony'
	str1.lstrip('*')  # 只移除左边的指定字符
	tony***
	str1.rstrip('*')  # 只移除右边的指定字符
	**tony
	===================
	
	2.lower(),upper()
	str2 = 'My nAme is tonY！'
 
	str2.lower()  # 将英文字符串全部变小写
	my name is tony！
	str2.upper()  # 将英文字符串全部变大写
	MY NAME IS TONY！
	===================
	
	3.startwith,endswith
	str3 = 'tony jam'
 
	# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
	str3.startswith('t') 
	True
	str3.startswith('j')
	False
	# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
	str3.endswith('jam')
	True
	str3.endswith('tony')  
	False
	===================
	
	4.格式化输出直format
	之前我们使用%s来做自付出啊难度格式化输出操作，在传值是，必须严格按照位置与%s一一对应，
	而字符串的内置方法format则提供了一种不依赖位置的传值方式
	案例：
	# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
	str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
	str4  
	'my name is tony, my age is 18!'
	 
	str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
	str4  
	'my name is tonytonytony, my age is tony!'

	format的其他使用方式（了解）
	# 类似于%s的用法，传入的值会按照位置与{}一一对应
	str4 = 'my name is {}, my age is {}!'.format('tony', 18)
	str4 
	my name is tony, my age is 18!
	
	# 把format传入的多个值当作一个列表，然后用{索引}取值
	str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
	str4
	my name is tony, my age is 18!
	 
	str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
	str4  
	my name is 18, my age is tony!
	 
	str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
	str4  
	my name is 18, my age is 18!
	===================
	
	5.split,rsplit
	# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
	str5='C:/a/b/c/d.txt'
	str5.split('/',1)
	['C:', 'a/b/c/d.txt']  
	 
	# rsplit刚好与split相反，从右往左切割，可以指定切割次数
	str5='a|b|c'
	str5.rsplit('|',1)
	['a|b', 'c']
	
	===================
	
	6.join
	# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
	'%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
	'h%e%l%l%o'
	'|'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
	'tony|18|read'
	===================
	
	7.replace
	# 用新的字符替换字符串中旧的字符
	str7 = 'my name is tony, my age is 18!'  # 将tony的年龄由18岁改成73岁
	str7 = str7.replace('18', '73')  # 语法:replace('旧内容', '新内容')
	str7
	my name is tony, my age is 73!
	 
	# 可以指定修改的个数
	str7 = 'my name is tony, my age is 18!'
	str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
	str7
	'MY name is tony, my age is 18!'
	
	===================

	8.isdigit
	# 判断字符串是否是纯数字组成，返回结果为True或False
	str8 = '5201314'
	str8.isdigit()
	True
	 
	str8 = '123g123'
	str8.isdigit()
	False

4.了解操作

	# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
>>> msg='tony say hello'
>>> msg.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
1  
# 1.2 index:同find,但在找不到时会报错
>>> msg.index('e',2,4) # 报错ValueError
# 1.3 rfind与rindex：略
# 1.4 count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e')  # 统计字符串e出现的次数
4
>>> msg.count('e',1,6)  # 字符串e在索引1~5范围内出现的次数
1
 
# 2.center,ljust,rjust,zfill
>>> name='tony'
>>> name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
>>> name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
 
# 3.expandtabs
>>> name = 'tony\thello'  # \t表示制表符(tab键)
>>> name
tony    hello
>>> name.expandtabs(1)  # 修改\t制表符代表的空格数
tony hello
 
# 4.captalize,swapcase,title
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  
# 4.2 swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()  
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
#4.3 title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much 
 
# 5.is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
 
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit() 
False
 
#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal() 
True
>>> num3.isdecimal() 
False
>>> num4.isdecimal() 
False
 
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric() 
True
>>> num3.isnumeric() 
True
>>> num4.isnumeric() 
True
 
# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
 
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
 
# 6.is其他
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower()  # 字符串是否是纯小写
True
>>> name.isupper()  # 字符串是否是纯大写
False
>>> name.isspace()  # 字符串是否全是空格
False
>>> name.istitle()  # 字符串中的单词首字母是否都是大写
False

三、列表(list)的内置方法

1.数据类型转换

所有可以支持for循环的类型都可以转为列表

2.需要掌握的操作

	1.按索引存取值(正向存取+反向存取)：即可存也可以取
	1.1 正向取值（从左往右）
	name = ['chen','jack','tom','henny']
	print(name[0]) # chen
	1.2 反向取值（负号表示从右往左）
	print(name[-1]) # henny
	
	1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但是如果索引不存在则报错
	name[2] = 'jason'
	print(name) # ['chen', 'jack', 'jason', 'henny']

	2.切片
	2.1顾头不顾尾，步长
	print(name[1:3]) # ['jack', 'tom']
	print(name[0:3:2]) # ['chen', 'tom']
	print(name[:3]) # ['chen', 'jack', 'tom']
	print(name[2:]) # ['tom', 'henny']
	print(name[::-1]) # ['henny', 'tom', 'jack', 'chen']

	3.长度
	name = ['chen','jack','tom','henny']
	print(len(name)) # 4
	
	4.成员运算in和not in
	name = ['chen','jack','tom','henny']
	print('chen' in name) # True
	print('chen' not in name) # False

	5.添加
	5.1 append()列表尾部追加元素
	name = ['chen','jack','tom','henny']
	name.append('hank')
	print(name) # ['chen', 'jack', 'tom', 'henny', 'hank']
	---------------
	name.append(666)
	print(name) # ['chen', 'jack', 'tom', 'henny', 'hank', 666]
	---------------------
	name.append([1,2,33,4])
	print(name) # ['chen', 'jack', 'tom', 'henny', 'hank', 666, [1, 2, 33, 4]]

	5.2 extend()一次性在列表尾部添加多个元素
	name.extend(['hank','loser',666])
	print(name) # ['chen', 'jack', 'tom', 'henny', 'hank', 'loser', 666]
	'''extend的底层原理就是append+for'''
	
	5.3 insert()在指定的位置插入元素
	name.insert(2,'ankn') # 这里2表示按索引位置插值 也可以插入一个列表，这里就不多演示
	print(name) # ['chen', 'jack', 'ankn', 'tom', 'henny']

	6.删除
	6.1 del
	name = ['chen','jack','tom','henny']
	del name[2] # 删除索引为2的值
	print(name) # ['chen', 'jack', 'henny']

	6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
	name = ['chen','jack','tom','henny']
	name.pop(2)
	print(name) # ['chen', 'jack', 'henny']

	rel = name.pop(2)
	print(rel) # tom （相当于给name列表里面的值弹出然后赋予给了rel）

	6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
	name = ['chen','jack','tom','henny']
	name.remove('jack')  # 从左往右查找括号内需要删除的元素
	print(name) # ['chen', 'tom', 'henny']
	
	rel = name.remove('jack')
	print(rel) # None 返回的是None 空、无的意思
	
	7.reverse()颠倒列表内元素顺序
	ha_list = [1,2,33,4,5,656]
	ha_list.reverse()
	print(ha_list) # [656, 5, 4, 33, 2, 1]

	8.sort()给列表内所有元素排序
	8.1 排序时列表元素之间必须是相同的数据类型，不可混搭，否则报错
	ha_list = [1,2,33,4,5,656]
	ha_list.sort() # 默认是从小到大的排序
	print(ha_list) # [1, 2, 4, 5, 33, 656] 
	
	ha_list.sort(reverse=True) # reverse用来装订是否颠倒顺序，默认为False
	print(ha_list) # [656, 33, 5, 4, 2, 1]

3.了解的操作

	1.我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应
	位置的元素的大小，如果分出大小，则无需比较下一个元素，比如：
	l1 = [1,2,3]
	l2 = [1,2]
	print(l1 > l2) # True
	
	字符之间的大小取决于它们的ASCII表中的先后顺序，越往后越大
	s1 = 'abc'
	s2 = 'acd'
	print(s2 > s1) # s1与s2的第一个字符没有分出胜负，但是第二个字符'c' > 'b'，所以s2>s1成立 True

	'''所以我们也可以对下面这个列表排序'''
	vl = ['a','fd','v','b','jkls','her']
	vl.sort()
	print(vl) # ['a', 'b', 'fd', 'her', 'jkls', 'v']

	2.循环
	'''循环遍历ha_friends列表里面的值'''
	ha_friends = ['chen','jack','tom','ankn',5]
	for line in ha_friends:
	    print(line , end=' ') # chen jack tom ankn 5 

	3.
	l = [1,2,3,4,5,6]
	print(l[0:3:1])  #正向步长 [1, 2, 3]
	print(l[2::-1]) #反向步长 [3, 2, 1]

	#通过索引取值实现列表翻转
	print(l[::-1]) # [6, 5, 4, 3, 2, 1]