数字类型

#======================================基本使用======================================
#1、用途

#2、定义方式

#3、常用操作+内置的方法

#======================================该类型总结====================================
#存一个值or存多个值
    
#有序or无序 
 就是指有没有索引，有索引的都是有序的

#可变or不可变
可变：在值变得情况下，id不变
不可变：在原值该百年的情况下，id也改变，则就不可变。

#一：基本使用：int
# 1 用途：记录年龄、等级、号码
#
# 2 定义方式
age=18 #age=int(18)
# print(type(age))
# int(‘abadf‘) #报错
# int(‘10.1‘) #报错
# int(‘101‘) #int只能将字符串中包含纯数字转成整型

# 进制转换（了解**）
# 其他进制转成十进制
# 二进制：0，1
# 10 #1*(2**1) + 0*(2**0)
# # 十进制：0-9
# 371 #3*(10**2) + 7*(10**1) + 1*(10**0)
# # 八进制：0-7
# 371 #3*(8**2) + 7*(8**1) + 1*(8**0)
# # 十六进制：0-9 A-F
# 371 #3*(16**2) + 7*(16**1) + 1*(8**0)

# 十进制转成其他进制
# print(bin(12))
# print(oct(12)) #14 =>1*(8**1) + 4*(8**0)
# print(hex(16))

# 3 常用操作+内置的方法

#二：该类型总结
# 1 存一个值
#
# 3 不可变
# x=10
# print(id(x))
# x=11
# print(id(x))


#一：基本使用：float
# 1 用途：记录身高、体重、薪资
#
# 2 定义方式
# salary=3.1 #salary=float(3.1)

# res=float(‘3.3‘)
# print(type(res))

# 3 常用操作+内置的方法

#二：该类型总结
# 1 存一个值
#
# 3 不可变
x=10.3
print(id(x))
x=10.4
print(id(x))

#一：基本使用
# 1 用途：记录描述性的状态，比如人的名字、地址、性别

# 2 定义方式：在"",‘‘,"""""",‘‘‘‘‘‘内包含一系列的字符
# 创建字符串
# msg=‘hello‘ #msg=str(‘hello‘)

# 讲其他类型转成字符串
# res1=str(1)
# res2=str([1,2,3])
# print(type(res1),type(res2))

# 注意引号的配对
# info="‘xxx‘"

# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
# msg=‘hello world‘
# print(msg[4]) 
# print(msg[-1]) 
# msg[3]=‘A‘
# name=‘egon‘


#2、切片(顾头不顾尾，步长)
# msg=‘hello world‘ # 切片就是从一个大的字符串中切分出一个全新的子字符串
# print(msg[0:5])   
# print(msg) # 没有改变原值，产生新的字符串

# print(msg[0:5:1]) 步经默认为1
# print(msg[0:5])
# print(msg[0:5:2]) #hlo

# 了解 ：
负向索引的步长要与迈的步子的方向一样
# print(msg[0:5:1])  正向步径为1
print(msg[0:5:1])

# msg=‘hello world‘
 # print(msg[5:0:-1]) 对的 # 
print(msg[5::-1]) 对的 
# print(msg[-1::-1]) 将字符串反转 


 
# print(msg[::-1]) 将字符串反转

#3、长度len
# msg=‘hello world‘
# print(len(msg))

#4、成员运算in和not in: 判断一个子字符串是否存在于一个大的字符串中
# print(‘alex‘ in ‘alex is dsb‘)
# print(‘dsb‘ in ‘alex is dsb‘)
# print(‘sb‘ in ‘alex is dsb‘)
# print(‘xxx‘ not in ‘alex is dsb‘) # 推荐
# print(not ‘xxx‘ in ‘alex is dsb‘)

#5、去掉字符串左右两边的指定字符strip，不管中间的

# user=‘      egon       ‘
# user=‘   x   egon       ‘
# user="*******egon********"
# user=" **+*  */***egon*  **-*****"
# print(user.strip("* +/-"))

# user=input(‘>>>: ‘).strip()    
# if user == "egon":
#     print(‘用户名正确‘)

#6、切分split:针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值

# msg="root:123456:0:0::/root:/bin/bash"
# res=msg.split(‘:‘)
# print(res[1])

# cmd=‘dowload|a.txt|3333333‘
# cmd_name,filename,filesize=cmd.split(‘|‘)

#7、循环
# msg=‘hello‘
# for item in msg:
#     print(item)

# 需要你掌握的
#1、strip,lstrip,rstrip
# print(‘*****egon*****‘.lstrip(‘*‘))
# print(‘*****egon*****‘.rstrip(‘*‘))
# print(‘*****egon*****‘.strip(‘*‘))

#2、lower,upper
# msg=‘aABBBBb‘
# res=msg.lower()
# print(res)
# print(msg)

#3、startswith,endswith
# msg=‘alex is dsb‘
# print(msg.startswith(‘alex‘))
# print(msg.endswith(‘sb‘))
# print(msg.endswith(‘b‘))

#4、format的三种玩法
# print(‘my name is %s my age is %s‘ %(‘egon‘,18))
# 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 {0} my age is {1}{1}‘.format(18,‘egon‘))

#5、split,rsplit
# msg=‘get|a.txt|333331231‘
# # print(msg.split(‘|‘,1))
# print(msg.split(‘|‘,1))
# print(msg.rsplit(‘|‘,1))

#6、join  把列表按照某个字符串为分隔符，重新拼接成字符串， 与split相反
# msg=‘get|a.txt|333331231‘
# l=msg.split(‘|‘)
# print(l)
#
# src_msg=‘|‘.join(l)
# print(src_msg)

#7、replace
# msg=‘alex say i have one tesla,alex is alex hahaha‘
# print(msg.replace(‘alex‘,‘sb‘,1))
# print(msg)

#8、isdigit # 判断字符串中包含的是否为纯数字
# print(‘10.1‘.isdigit())
# age=input(‘>>: ‘).strip()
# if age.isdigit():
#     age=int(age) #int(‘asfdsadfsd‘)
#     if age > 30:
#         print(‘too big‘)
#     elif age < 30:
#         print(‘too small‘)
#     else:
#         print(‘you got it‘)
# else:
#     print(‘必须输入数字‘)

# 需要了解的内置方法
#1、find,rfind,index,rindex,count
msg=‘hello alex is sb‘
# print(msg.find(‘alex‘))
# print(msg.find(‘alex‘,0,3))推荐使用，因为找不到不报错

# print(msg.index(‘alex‘))
# print(msg.index(‘alex‘,0,3))找不到，会报错


# msg=‘alex aaa alex‘
# print(msg.find(‘alex‘))  找到第一个就停止
# print(msg.rfind(‘alex‘)) 会都找出来

# msg=‘alex aaa alex‘
# print(msg.count(‘alex‘)) # 统计一个子字符串在大字符串中出现的次数


#2、center,ljust,rjust,zfill
# print(‘egon‘.center(50,‘*‘))  第一个是宽度，第二个是宽度不够用*填充
# print(‘egon‘.ljust(50,‘*‘))
# print(‘egon‘.rjust(50,‘*‘))
# print(‘egon‘.zfill(50)) zfill就是zerofill

#3、expandtabs
# print(‘a\tb‘.expandtabs(1))

#4、captalize,swapcase,title
# print(‘hello‘.capitalize())
# print(‘hElLo‘.swapcase())
# print(‘egon is nb‘.title())

#5、is数字系列
#在python3中
num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中无需加u就是unicode
num3=‘壹‘ #中文数字
num4=‘Ⅳ‘ #罗马数字

# ‘‘.isnumeric()可以识别: unicode,中文数字，罗马数字
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())

# ‘‘.isdecimal(): unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())

# ‘‘.isdigit() :bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())


#6、is其他
# print(‘abc你‘.isalpha()) # 字符串中包含的是字母或者中文字符

# 字符串中包含的是字母（中文字符）或数字
# print(‘ab‘.isalnum())
# print(‘123123‘.isalnum())
# print(‘ab123‘.isalnum())

#二：该类型总结
# 1 存一个值
#
# 2 有序

# 3 不可变
# x=‘abc‘
# print(id(x))
# x=‘def‘



03列表类型

#一：基本使用
# 1 用途：存放多个值，可以根据索引存取值

# 2 定义方式：在[]内用逗号分割开多个任意类型的值
l=[‘egon‘,‘lxx‘,‘yxx‘] # l=list([‘egon‘,‘lxx‘,‘yxx‘])
# l1=list(‘hello‘) #list本质就相当于调用了一个for循环依次取出‘hello‘的值放入列表
# print(l1)
# l2=list({‘x‘:1,‘y‘:2,‘z‘:3})
# print(l2)
# list(10000) # 报错:因为不能调运for

# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=[‘egon‘,‘lxx‘,‘yxx‘]
# print(l[0])
# l[0]=‘EGON‘
# print(l)
# print(l[-1])
# print(l[3])
# l[0]=‘EGON‘ # 只能根据已经存在的索引去改值
# l[3]=‘xxxxxxxx‘ #如果索引不存在直接报错

#2、切片(顾头不顾尾，步长)
l=[‘egon‘,‘lxx‘,‘yxx‘,444,555,66666]
# print(l[0:5])
# print(l[0:5:2])
# print(l[::-1])

#3、长度
# l=[‘egon‘,‘lxx‘,‘yxx‘,444,555,66666,[1,2,3]]
# print(len(l))

#4、成员运算in和not in
# l=[‘egon‘,‘lxx‘,‘yxx‘,444,555,66666,[1,2,3]]
# print(‘lxx‘ in l)
# print(444 in l)

#5、追加
l=[‘egon‘,‘lxx‘,‘yxx‘]
# l.append(44444)
# l.append(55555)
# print(l)

#6、往指定索引前插入值
# l=[‘egon‘,‘lxx‘,‘yxx‘]
# l.insert(0,11111)
# print(l)
# l.insert(2,2222222)
# print(l)

#7、删除
# l=[‘egon‘,‘lxx‘,‘yxx‘]

#单纯的删除值：
# 方式1：
# del l[1] # 通用的   各种类型通用
# print(l)

# 方式2：
# res=l.remove(‘lxx‘) #    列表独有的 指定要删除的值，返回是None
# print(l,res)

# 从列表中拿走一个值
# res=l.pop(-1) # 按照索引删除值(默认是从末尾删除)，返回删除的那个值
# print(l,res)

#8、循环
# l=[‘egon‘,‘lxx‘,‘yxx‘]
# for item in l:
#     print(item)

# 需要掌握的操作
l=[‘egon‘,‘egon‘,‘lxx‘,‘yxx‘,444,555,66666]
# print(l.count(‘egon‘))
# print(l.index(‘egon‘))
# print(l.index(‘yxx‘,0,1))
# l.clear()

# items=[‘a‘,‘b‘,‘c‘]
# items=‘hello‘
# for item in items:
#     l.append(item)
# l.extend(items)
# print(l)

# l=[‘egon‘,‘egon‘,‘lxx‘,‘yxx‘,444,555,66666]
# l.reverse()
# print(l)

# nums=[3,-1,9,8,11]
# nums.sort(reverse=True)
# print(nums)

# items=[1,‘a‘,‘b‘,2]
# items.sort()


#二：该类型总结
# 1 存多个值

#
# 2 有序
#
# 3 可变
# l=[‘a‘,‘b‘,‘c‘]
# print(id(l))
# l.append(‘d‘)
# print(id(l))


# 队列：先进先出
# l=[]
# # 入队
# l.append(‘first‘)
# l.append(‘second‘)
# l.append(‘third‘)
# print(l)
# # 出队
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))

# 堆栈：先进后出
l=[]
# 入栈
l.append(‘first‘)
l.append(‘second‘)
l.append(‘third‘)
# print(l)
# 出栈
print(l.pop())
print(l.pop())
print(l.pop())