数据类型和内置方法

#一：基本使用
# 1 int用途:年龄 号码 等级...

# 2 定义方式
age=10 #age=int(10)
# x=int('1111') # int只能将纯数字的字符串转成十进制的整型
# print(type(x))

# 3 常用操作+内置的方法
#算数运算,比较运算



#二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
# age=10
# age

# 2 有序or无序
#    没有有序无序这么一说

# 3 可变or不可变
#可变不可变类型总结:
#     可变指的是改变原值,即在原值基础上进行修改
#     可变类型的底层原理:在id不变的情况下,值可以改变
#     不可变类型的底层原理:值改变,id也跟着变
#int是不可变数据类型
# age=10
# print(id(age))
# age=11
# print(id(age))


# 了解(**):
# 长整型Long,只有在python2中才有长整型号
# 复数complex
# x=1-2j
# print(x.real)
# print(x.imag)
# print(type(x))


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

# 3 常用操作
#算数运算 比较运算

# #二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
#
# 2 有序or无序
#    没有有序无序这么一说

# 3 可变or不可变
# float是不可变类型
# x=3.1
# print(id(x))
# x=3.2
# print(id(x))
# 3、常用操作和内置方法
#
#     数学运算、比较运算
#
# 4 按照以下几个点展开数据类型的学习


#一：基本使用
# 1 用途
#
# 2 定义方式
#
# 3 常用操作+内置的方法

#二：该类型总结
# 1 存一个值or存多个值
#     只能存一个值
#     可以存多个值，值都可以是什么类型
#
# 2 有序or无序
#
# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash            改的原值而没有申请新的内存地址
#     ！！！不可变：值变，id就变。不可变==可hash           原值没有改变，而是重新申请了一个内存地址放了进去，值变了，id也跟着变了

#浮点型float
# 　　作用：薪资，身高，体重，体质参数等浮点数相关

    # salary=3000.3 #本质salary=float(3000.3)
# 　　只能存一个值，根本没有有序无序这么一说，不可变类型，可以通过打印id验证

# 三 字符串


#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号双引号三引号内，由一串字符组成
# name='egon'         #只要是引号里面加的就是字符串，如一号里面放一个列表，任然是字符串

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in

#5、移除空白strip
#6、切分split
#7、循环
#1、按索引取值(正向取+反向取) ：只能取
# msg='hello world'
# print(msg[2])
# print(msg[-3])        #从大的字符串中取出小的字符串，即索引取出的是字符串类型

#2、切片(顾头不顾尾，步长)
# 　　从索引取值演变而来的
# msg='hello world'
# print(msg[1:2])       #一次可以取出多个字符
# print(msg[5::2])    #从5开始取到最后，步长为2
# print(msg[-3:-6:-1])
# print(msg[3:6:-1])          #不调不一致3:6是正向，-1是反向走，所以取不到值

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

#4、成员运算in和not in     #两者没有区别，not in语义化更加强，所以推荐使用 而not 。。。。in      是一个取反的操作

#5、移除空白strip
#strip
name='  *eg on**    '
print(name.strip())           #不加空格默认去的是左右两边的空格，不会去掉中间的空格
print(name.strip('*'))        #
print(name.lstrip('*'))
print(name.rstrip('*'))
#6、切分split
#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格,用于一个有规律的列表切分成一个列表
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

#7、循环           #用于取字符串中的字符，用for循环


# 需要掌握的操作


#1、strip,lstrip,rstrip
#2、lower,upper
#3、startswith,endswith
#4、format的三种玩法
#5、split,rsplit
#6、join
#7、replace
#8、isdigit



#strip
name='*eg*on**'           #切分的结果任然是字符串
print(name.strip('*'))   #只能去掉左右两边的指定的字符，并不能去掉中间的字符 列如name='eg*on'切分结果任然是eg*on
print(name.lstrip('*'))
print(name.rstrip('*'))

#lower,upper
name='egon'
print(name.lower())       #原值不会改变，重新申请了新的内存地址
print(name.upper())
print(name)
#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))        # 判断结果是布尔值
print(name.startswith('alex'))

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')      #
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)#打破位置的限制，但仍能指名道姓的传值

#split
name='root:x:0:0::/root:/bin/bash'        #把字符串切分成列表
print(name.split(':')) #默认分隔符为空格，默认从左往右切
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))          #可以控制切的次数

name='a|b|c'
print(name.rsplit('|',1)) #从右往左开始切分     字符串切分成列表的结果是['a|b', 'c']

#join
tag=' '                           #join把列表拼成一个大的字符串
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

num=['1','2','3']
print(':'.join(num))   #join只能将字符串的列表拼成一个大的字符串，不同类型的拼接会报错

num=[1,2,'c']
print(':'.join(num))      #会报错，类型不同底层拼接不能进行相加




#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))            #replace也不会改变原值，会产生一个新值,1代表的是替换的个数，SB是替换的值

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())        #判断字符串里面的是不是数字，是整型，浮点型也会为Flase


# 了解
#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错，返回-1
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有，可以指定查找范围

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))        #
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon	hello 	 world'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

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

#isdigt:bytes,unicode
print(num1.isdigit()) #True        #只能识别bytes和unicode两种雷凌
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

# 所有对字符串的该都是整体进行修改，重新赋一个值，id也会跟着变化，所以id是不可变类型



# 四 列表


#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])

l=list('abc')     #list只能跟能够被for循环编历的数据类型
#list的工作原理是向一个空列表中循环的放值
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取（存也就是改）
# 按照索引只能取值，不能加值
names=['egon','alex','wxx','lxx']

#2、切片(顾头不顾尾，步长)
# names=['alex','wxx','lxx','egon']
# print(names[0:3])

#3、长度
# names=['alex','wxx','lxx','egon']
# print(len(names))

#4、成员运算in和not in
# names=['alex','wxx','lxx','egon',4]
# print(4 in names)


#5、追加
# names=['alex','wxx','lxx','egon']
# names.append([1,2,3])
# names.append('cxx1')         #在列表的末尾加上我们添加的数据类型到列表中
# names.append('cxx2')
# names.append('cxx3')
# print(names)

#6、删除
# names=['alex','wxx','lxx','egon']
# del names[2]       #按照索引删除掉列表中指定的元素

# print(names)

#7、循环
# names=['alex','wxx','lxx','egon']
# for name in names:
#     print(name)

# 需要掌握的操作(****)
# names=['alex','wxx','lxx','egon',4,3.1]
# names.insert(1,'SB')              #按照索引在指定的元素前面添加上数据类型
# print(names)

# names=['alex','wxx','lxx','egon',4,3.1]
# res=names.remove('wxx')  # 单纯的删掉,是按照元素的值去删除，没有返回值
# print(res)
# print(names)


# names=['alex','wxx','lxx','egon',4,3.1]
# res=names.pop(1) #拿走一个值,是按照索引去删除,有返回值，原列表中数据被删除，但可以拿到删除的结果
# print(names)
# print(res)

# names=['alex','wxx','lxx','egon',4,3.1]
# print(names.pop())                   #默认删除的是末尾的一个元素
# print(names.pop())

names=['alex','wxx','lxx','lxx','egon',4,3.1]
# print(names.count('lxx'))             #统计列表中指定元素重复的个数

# print(names.index('lxx'))          #返回指定元素所在的索引值

# names.clear()                   #清空列表中的所有元素
# print(names)

# x=names.copy()                   #复制列表
# print(x)

# names.extend([1,2,3])             #将数据加入到列的末尾
# print(names)

# names.reverse()                #将列表中的所有元素取反
# print(names)

# names=[1,10,-3,11]
# names.sort(reverse=True)   #先对列表进行取反，然后在按照从大到小进行排序
# names.sort()              #按照从小到大进行排序

# print(names)


#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意数据类型
#
# 2 有序or无序
# 有序
# 3 可变or不可变
# 可变

# l=['a','b']
# print(id(l))
# l[0]='A'
# print(id(l))