day6 基本数据类型及内置方法

day6 基本数据类型及内置方法

一、10进制转其他进制

1. 十进制转二进制
	print（bin（11）） #0b1011
2. 十进制转八进制
	print(hex(11))   #0o13
3. 十进制转十六进制
	print(hex(11))   #0xb
4.二进制转其他进制
	print（int（'0b1011'，2））

二、可变和不可变类型

可变：如果值改变，但是内存地址不变，证明就是在改变原值，即原值可变
	list列表、字典dic
不可变：如果值改变，但是内存地址也变了，证明不是在改变原值，但是产生了新的值，即原值不可变
	int、float、str、元组

三、基本数据类型

1.int基本使用
1.1定义方式
	age = 18
1.2 int数据类型转换
	a = int（'18'）
    print（a，type（a））
1.3常用操作+内置的方法
	算数运算+比较运算
总结：int只能存一个值，并且int类型不可变
2.float基本使用
2.1定义方式
	salary = 3.33
2.2 float数据类型转换
	res=float('1.8')
     print（res，type（res））
2.3常用操作+内置的方法
	算数运算+比较运算
总结：float只能存一个值，并且int类型不可变

四、基本数据类型之字符串类型

4.str基本使用
4.1.定义方式
	name = 'meng' # name = str（'meng'）
4.2 str数据类型转换：可以把任意类型都转换成字符串类型
	res = str[1,2,3]
4.3 常用操作+内置方法
4.3.1 优先掌握的操作：
（1）、按索引取值（正向取+反向取）：只能取
    a = 'hello python'
    # print(a[4])
    # print(a[-1])
    print(a[:])
    print(a[::-1])
（2）、切片（顾头不顾尾，步长）：从一个大字符串中拷贝一个子字符串
	a = 'hello python'
    print(a[0:6:2])
    print(a[:])  #取全部
    print(a[::-1])  #反向取
（3）、长度len
    a = 'hello python'
    print(len(a))
（4）、成员运算in和not in
    a = 'hello python'
    print('he'in a)  #看he在a里吗
    print('meng' not in a) # 看meng不在a里
（5）、移除空白strip、replace
    # strip：移除值两边的空白
    # replace：移除值中间的空白，也可以移除所有的空白。如：.replace(' ','')
    x = input('请输入：').strip().replace(' ','')
    b = input('密码：').strip().replace(' ','')
    if x == 'meng' and b =='123':
         print('ok')
    else:
         print('no')
    或： name = '*****eg on****'
         print(name.strip('*').replace(" ",'')) #把*和空格去掉
（6）、切分split：把一个字符串按照某种分隔符切分一个列表
    a ='name:18:melae:10'
    b = a.split(':')
    print(b)
    print(b[0])
 （6.1）把列表中的元素按照某种分隔符拼接成字符串
    into = ['name','18','male','10']
    a =':'.join(into)
    print(a)
（7）、循环
    a = 'hello python'
    for b in a:
        print(b)

五、需要掌握的操作（****)

1、strip,lstrip,rstrip
    print('******meng******'.strip('*'))  # meng,去掉两边*
    print('******meng******'.lstrip('*'))  # meng,去掉左边*
    print('******meng******'.rstrip('*'))  # meng,去掉右边*
2、lower，upper
    print('AbC'.lower()) # abc，把大写转为小写
    print('AbC'.upper())  # ABC，把小写转为大写
3、startswith,endswith
    print('hello world'.startswith('he')) # True，查看是he开头
    print('hello world'.endswith('d'))  #True，查看是d结尾
    print('hello world'.startswith('e',1,4))  #True，查看这个索引有e没
4、format的三种玩法
    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')) #根据索引传送
    x = 'egon'
    y = 18
    print(f'my name is {x} ,my age is {y}') # 可以用赋值传送
5、split，rsplit
    msg = 'egon:18:male'
    print(msg.split(':')) #['egon', '18', 'male'] 根据：切割
    print(msg.rsplit(':',1)) #['egon:18', 'male'] 根据：步长为1切割
6、join
7、replace
8、isdigit
    print("18".isdigit()) #判断是否为整形
    age = input('>>>: ').replace(' ', '')
    if age.isdigit():
        age = int(age)
        if age > 18:
            print('too big')
        elif age < 18:
            print('too small')
        else:
            print('you got it')
    else:
        print("必须输入数字，小垃圾")

六、需要掌握的操作（***)

1、find,rfind,index,rindex,count
    msg = 'hello egon ahahah egon xxx egon'
    print(msg.find('egon1'))  #查不到，报错
    print(msg.index('egon1')) #查不到，报错
    print(msg.count('egon')) #3，描述出现的次数
    print(l.index('egon')) #用于从列表中找出某个值第一个匹配项的索引位置。

    print(msg.rfind('egon')) #27，返回最后一个索引
2、center,ljust,rjust,zfill
    print('egon'.center(50,'*'))  #从两边添加*
    print('egon'.ljust(50,'*'))   #从值的右边添加*
    print('egon'.rjust(50,'*'))   #从值的左边添加*

    print('egon'.rjust(50,'0'))   #用''填充,里面写啥都行
    print('egon'.zfill(50))       #用0填充，只能用0
3、captalize,swapcase,title
    print('abcd'.capitalize()) #首字母转大写
    print('AbCd'.swapcase()) #小写变大写，大写变小写
    print('my name is egon'.title()) #全为大写
4、is数字系列
    print('18'.isdigit()) #检测字符串是否只由数字组成
    print('Ⅳ'.isnumeric()) #检测字符串是否只由数字组成，可以是多类型的数字，如：一
5、is其他
    name='egon'
    print(name.isalnum()) #字符串由字母或数字组成
    print(name.isalpha()) #字符串只由字母组成

七、基本数据类型之list

7.1 定义方式：在[]用逗号分隔开多个任意类型的元素
7.2 list数据类型转换
    res = list("hello")
    print(res,type(res)) #['h', 'e', 'l', 'l', 'o'] <class 'list'>
7.3 常用操作+内置的方法
7.3.1 优先掌握的操作：
（1）、按索引存取值(正向存取+反向存取)：即可存也可以取
	l = [111,222,333,444,555,666,777]
    print(l[0])  #111
    print(l[-1]) #777
（2）、切片(顾头不顾尾，步长)
    l = [111,222,333,444,555,666,777]
    print(l[1:4:1])  # 拷贝
    print(l[:])
    print(l[::-1])
（3）、长度
    l = [111,222,333,444,555,666,777]
    print(len(l))
（4）、成员运算in和not in
    l = [111,222,333,444,555,666,777]
    print(333 in l)
（5）、追加、插入
    l = [111,222,333,444,555,666,777] #在值最后面添加
    l.append(888)

    l.insert(3,999999999999) #可以根据索引把值添加到该位置
    print(l)
（6）、删除
	l = [111, 222, 333, 444, 555, 666, 777]
    # （1）万能删除
    # del l[1]
    # print(l)

    # (2) l.remove()
    # v = l.remove(333)
    # print(l)
    # print(v)

    # (3) l.pop()
    # v = l.pop(2)
    # print(l)
    # print(v)
（7）、循环
    l = [111,222,333,444,555,666,777]
    for i in l:
    	print(i)
7.4 需要掌握
（1）、reverse() 方法反转元素的排序顺序。
    l = [111,'a',333,'dddd']
    l.reverse() #reverse() 方法反转元素的排序顺序。
    print(l)   #['dddd', 333, 'a', 111]
（2）、.extend:.extend
    l = [111, -3, 99, 27]
    nums = [333,444,555]
    l.extend(nums) #.extend
    print(l)
总结：list可以存多个值，是有序的，可变的。

八、元组

8.1 用途：元组就是一种不可变的列表
8.2 定义方式：在()内用逗号分割开多个任意类型的元素
    t = (11,11.333,"aaa",[666,777])  # t = tuple()
    print(type(t))
8.3 数据类型转换
    print(tuple("hello"))
8.4 优先掌握的操作
（1）、按索引存取值(正向存取+反向存取)：即可存也可以取
	l = （111,222,333,444,555,666,777）
    print(l[0])  #111
    print(l[-1]) #777
（2）、切片(顾头不顾尾，步长)
    l = (111,222,333,444,555,666,777)
    print(l[1:4:1])  # 拷贝
    print(l[:])
    print(l[::-1])
（3）、长度
    l = (111,222,333,444,555,666,777)
    print(len(l))
（4）、成员运算in和not in
    l = (111,222,333,444,555,666,777)
    print(333 in l)
总结：元组可以存多个值，是有序的，不可变类型