day07基本数据类型常用方法

day07

1.可变不可变类型

​ 当数据发生改变后，变量的内存地址发生了改变，即原值不可变 ，需要创建一个新的地址 比如int float str 元组

​ 如果值改变，但是内存地址没变，即原值可变 比如列表，字典 集合 类型， 一瓶水 瓶子不变 里面的水可以变

2.基本数据类型

#======================================int基本使用======================================
#1、用途
	人的年龄等
#2、定义方式
	a=18  本质是a=int(18)
	int数据类型转换
    a='18'
    x=int(a)
    print(x type(x))
    (18, <class 'int'>)
    可以将由纯整数构成的字符串转换成整形
#3、常用操作+内置的方法
	算数运算：加减乘除 比较运算：大于小于 等于 不等于 大于等于  小于等于
	
#======================================int该类型总结====================================
#存一个值or存多个值
    一个值
#有序or无序
	就一个值 扯不到有序无序问题
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
	不可变，

--------------------------------------------------------------------------------------------------

#======================================float基本使用======================================
#1、用途
	带小数点的，工资等
#2、定义方式
	a=18.00 本质是a=float(18.00)
    
	float数据类型转换
	s = '18.5'
	res=float(s)
	res,type(res)
	(18.5, <class 'float'>)
#3、常用操作+内置的方法
	算数运算：加减乘除 比较运算：大于小于 等于 不等于 大于等于  小于等于
#======================================float该类型总结====================================
#存一个值or存多个值
    一个值
#有序or无序
	就一个值 扯不到有序无序问题
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
	不可变 

--------------------------------------------------------------------------------------------------

#======================================str基本使用=====================================
#1、用途
	存一段话 或者一段说明文字
#2、定义方式
	name1 = 'jason'   本质:name = str('任意形式内容')
	str数据类型转换
    str()可以将任意数据类型转换成字符串类型 因为就相当于加了一个引号
#3、常用操作+内置的方法
	3.1 优先掌握的操作：
    	msg = 'hello world'
    (1)、按索引取值(正向取+反向取) ：只能取 因为是不可变型
 		print(msg[5])
 		print(msg[-1])  -1是倒数第一个字符
    (2)、切片(顾头不顾尾，步长)：从一个大字符串中拷贝出一个子字符串
    	res = msg[1:5:2]  # e l   第一个值指的是开始位置  第二个为结束位置 第三个步长
     #什么都不写 直接复制一份  步长为-1 则表示倒着走  初始位置-2:则表示从倒数第二个开始取值
    (3)、长度len
    	print(len(msg)) #表示输出这个字符串长度
    (4)、成员运算in和not in
    	print('el' not in msg) # 表示el这个字符是否在msg里面   not in表示取反
    (5)、移除空白strip
    	msg='      hello world      '
    	print(msg.strip())# strip移除字符串首尾指定的字符(默认移除空格)
        还有一个replace 
        print(msg.replace(' ',''))#第一个值写的是要被换掉的名称比如空格等，第二个表示换成什么
        #还可以有第三个参数 表示换几个 换几个空格 可以不是空格
    (6)、切分split：把一个字符串按照某种分割符切分一个列表
    	(6.1)、 把列表中的元素按照某种分隔符拼接成字符串
        	 msg = "egon:18:male:10"   
			res = msg.split(':')   #表示通过：把字符串分割成一块一块的成一个列表
			print(res)  
			print(res[0]) 
    (7)、循环
    	for msg = "hello world"
		for i in msg:
		print(i)
        #一个字符一个字符的输出 包括空格
#需要掌握的操作（****）
    1、strip,lstrip,rstrip  去除符号或者什么的 replace可以实现一样操作 不过replace更多用于替换
    	print("******egon*****".strip('*')) # 表示去除*号 不管左右都去除
		print("******egon*****".lstrip('*'))# 表示去除*号 去除左面的   l可以理解为left简写
		print("******egon*****".rstrip('*'))#表示去除*号 去除左面的   l可以理解为right简写
    2、lower,upper  转换大小写
    	print("AbC".lower())  #转小写
		print("AbC".upper())  #转大写
    3、startswith,endswith   还可以有参数表示startswith('e',1,4)  从下表一开始到4这个区间寻找
    	print('hello world'.startswith('he')) #从开始位置找he 找第一个，找到返回True
        print('hello world'.endswith('d'))  #从结束位置找he 找第一个，找到返回True
    4、format的三种玩法  he%s类似 
    	 #通过key来存值，也可以通过下标存值或者通过对应的下标format后面的是0开始的下标
		print("my name is {name} my age is {age}".format(age=18,name='egon'))
    	print("my name is {} my age is {}".format(18,'egon'))
		print("my name is {1} my age is {0}{0}{0}".format(18,'egon'))
    5、split,rsplit
    	msg = 'egon:18:male'
		print(msg.split(':',1)) #从左面开始划分  1表示化几个，1则划分一个剩下合到一起
		print(msg.rsplit(':',1))#从右面开始划分
    6、join  个人理解用于把一个字符串中间每一个字符中间都加东西或者列表一个字符都加东西
    	print('%'.join('hello')) #从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
		print('|'.join(['tony','18','read']) )  #同上 
    7、replace  用新的字符替换字符串中旧的字符
    	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 
    	判断是否是纯数字组成
        str8 = '5201314'
        str8.isdigit()   #True   因为全是数字
#需要的了解的操作（***）
    1、find,rfind,index,rindex,count
    	msg='tony say hello'    print(msg.find('o',1,3))
    	print(msg.find('o')) # 出现o的第一个位置的索引 可以写范围 可以不写  1
        print(msg.find('o')) # 出现o的最后一个位置的索引 可以写范围 可以不写  13
        index、rindex 和find一样  只不过找不到的话会报错  find找不到会返回-1
        count
        print(msg.count('o'))  #表示方法用于统计字符串里某个字符或子字符串出现的次数
    2、center,ljust,rjust,zfill
    	print('egon'.center(50,'*')) #从值的两边加*号，总共50个字符
		print('egon'.ljust(50,'*'))#从值的左边加*号，总共50个字符  l==left
		print('egon'.rjust(50,'*'))#从值的有边加*号，总共50个字符  r==right
		print('egon'.rjust(50,'0'))  #从值的有边加0，总共50个字符
		print('egon'.zfill(50)) #从值的有边加0，总共50个字符，只能加0，默认就是0
    3、expandtabs
    	name='egon\thello'
		print(name)
		print(name.expandtabs(1))
    	expandtabs() 方法把字符串中的 tab 符号 \t 转为空格
    4、captalize,swapcase,title
    	print('abcd'.capitalize())  #第一个字母大写
	    print('AbCd'.swapcase())   #大写变小写，小写变大写
        print('my name is egon'.title())  # 首字母大写
    5、is数字系列
    	 print('18'.isdigit())  #判断是否纯数字  阿拉伯数字
		 print('Ⅳ'.isnumeric())  #判断是否数字  中文、等等
    6、is其他
    	
#======================================str该类型总结====================================
#存一个值or存多个值
一个值
#有序or无序
有序
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
不可变

--------------------------------------------------------------------------------------------------

#======================================list基本使用======================================
#1、用途
	多个装备，多个爱好，多门课程，多个女朋友等
#2、定义方式
	list数据类型转换
    但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
    print(list('wdad'))  # 结果：['w', 'd', 'a', 'd'] 
	print({"name":"jason","age":18})#结果：['name', 'age']
#3、常用操作+内置的方法
	
#3.1 优先掌握的操作：
    1、按索引存取值(正向存取+反向存取)：即可存也可以取
    	my_friends=['tony','jason','tom',4,5]
		print(my_friends[0])   #输出tony   反向取-1
    2、切片(顾头不顾尾，步长) 根据索引取值
    	my_friends=['tony', 'jason', 'tom', 4]
    	 my_friends[0:4:2]     #输出结果为['tony', 'tom']
        res = msg[1:5:2]  # e l   第一个值指的是开始位置  第二个为结束位置 第三个步长
    3、长度
    	print(len(msg)) #表示输出这个字符串长度
    4、成员运算in和not in
    	print('el' not in msg) # 表示el这个字符是否在msg里面   not in表示取反
    5、追加、插入
    	l1 = ['a','b','c']
        l1.append('d')
        print(l1)  # ['a', 'b', 'c', 'd']
     5.2 extend()一次性在列表尾部添加多个元素
		l1.extend(['a','b','c'])
		print(l1)
		['a', 'b', 'c', 'd', 'a', 'b', 'c']
     5.3 insert()在指定位置插入元素
     	#如果在同一个位置一直插入元素，一开始的就会排在后面
     	l=[]
		l.insert(0,'p1')
		l.insert(0,'p2')
		l.insert(0,'p3')
		print(l)
		# 输出结果为['p3', 'p2', 'p1']
		-----------------------------------
		l = []
		l.append('p1')# 加到列表最后
		l.append('p2')
		l.append('p3')
		print(l)
		# ['p1', 'p2', 'p3']
		l.pop(0)# 弹出索引0
		print(l)
---------------------------------------------
		l1.insert(0,"first")  # 0表示按索引位置插值
		print(l1)
		['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
    6、删除
    	（1）万能删除
        	l = [11,22,33,44]
            del l[2]  # 删除索引为2的元素
            print(l)
            [11,22,44]
         (2) l.remove()
        	 l = [11,22,33,44]
			l.remove(33)   #删除value等于33的值
			print(l)
         (3)l.pop()
        	 #pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素    
        	 #和rel的区别在于pop有返回值，，rel无返回值
			l = [11,22,33,22,44]
			res=l.pop()   #不加东西删除44  加索引指定删除
			print(res)
44
	7、循环 颠倒列表内元素顺序
    		 for i in l:
			 print(i)
	8.给列表内所有元素排序
    	l = [11,22,3,42,7,55]
        l.sort(reverse=True)  # reverse用来指定是否倒着排序，默认为False
        print(l)
#3.2 需要掌握

    
#======================================list该类型总结====================================
#存一个值or存多个值
    多个值
#有序or无序
有序
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
可变

--------------------------------------------------------------------------------------------------

#======================================元组基本使用======================================
#1、用途
元组就是一种不可变的列表
#2、定义方式 在()内用逗号分割开多个任意类型的元素
		t = (11,11.333,"aaa",[666,777])  # t = tuple()
		print(type(t))
	元祖数据类型转换   #('h', 'e', 'l', 'l', 'o')
    print(tuple("hello"))   #一个字符一个字符的变成元祖tuple
#3、常用操作+内置的方法
# 优先掌握的操作：
	1、按索引取值(正向取+反向取)：只能取
    	tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
        tuple1[0]    #    1

	2、切片(顾头不顾尾，步长)
    	tuple1[0:6:2] 
		#(1, 15000.0, 22)
	3、长度
    	len(tuple1)    #6

	4、成员运算in和not in
    	'hhaha' in tuple1  # True
		'hhaha' not in tuple1   #False
#需要了解的
	t = (111,222,222,222,333)
	print(t.count(222))
	print(t.index(222))
#======================================元祖该类型总结====================================
#存一个值or存多个值
    多个值
#有序or无序
	有序
#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
	不可变
    t = (11, 22, [33, 44])
	t[2][0] = 66