数字、字符串、列表类型及常用内置方法

可变不可变类型

1、可变类型：值改变，但是id不变，证明就是在改变原值，是可变类型
# 示例：
list=['a','b']
print(id(list))
l[0]='A'
print(list)
print(id(list))
RUN====》
5989000
['A', 'b']
5989000

2、不可变类型：值改变，但是id也跟着变，证明是产生了新的值，不改变原值，是不可变类型
# 示例：
x=9
print(id(x))
x=10
print(id(x))
RUN====》
8791317537872
8791317537904

基本数据类型及内置方法

数字类型

整型

# 基本使用：
1、用途：记录年龄、等级、数量

2、定义方式：
    age = 10 # age=int(10)

    # 数据类型的转换：只能将纯数字的字符串转成int
    x = int('123123')
    print(x,type(x))  #     123123 <class 'int'>

    x = int('12.3')
    print(x,type(x))  # 报错；无法将浮点型内容的字符串转成int

3、常用操作+内置方法
    即全部的数学运算和比较运算

浮点型

# 基本使用：
1、用途：记录身高、薪资、体重等

2、定义方式：
    salary = 1.5 # salary = float(10.1)

    数据类型的转换：只能将包含小数的字符串转成float
    示例：
    x=float('3.1')
    print(x,type(x))  # 3.1 <class 'float'>

3、常用操作+内置方法
    即全部的数学运算和比较运算

数字类型总结

1、数字类型只能存一个值

2、数字类型中的值不可变
    x = 1
    print(id(x))  # 8791357186896
    x = 2
    print(id(x))  # 8791357186928
    x=3.1
    print(id(x))  # 5222520
    x=4.3
    print(id(x))  # 5222784

    # 可见值变化了，id也随之变化，证明无法改原值，故数字类型不可变

字符串类型

# 基本使用：
1. 用途：记录 描述性质 的状态

2. 定义方式：
    msg = 'hello world' # msg = str('hello world')

    数据类型转换：所有类型都可以被str转成字符串类型
    示例：
    res=str([1,2,3])
    print(res,type(res))  # [1, 2, 3] <class 'str'>  # list类型被转成str类型

字符串类型的常用操作+内置方法

# 优先掌握的操作：（*****）
3.1 按索引取值（正向取 + 反向取）：只能取值，不能改值
    # 字符串中的字符其实也存在索引值
    msg = 'hello'
    print(msg[0],type(msg)) # h <class 'str'>  # 打印字符串msg中的第一位字符 即为h
    print(msg[-1]) # o  # 打印字符串msg中的倒数第1位数 即为o
    print(msg[-2]) # l  # 打印字符串msg中的倒数第2位数 即为l

    msg[0]='H' # 欲把'H'赋值给mag[0]（即msg中的第一位数）
    报错; # 证明字符串中的值无法被更改

3.2 切片（顾头不顾尾，步长）
    # 将字符串按照规定步长进行分割，分割出来的部分为一个单独的值
    msg='hello world'
    res=msg[0:3:1]
    '''
    []中的0为分割起始索引值，即msg中的第一个值 h，如不填，则默认为第一个字符的索引
    3为分割终点索引值,即msg中的第4个值 l，如不填，则默认为最后一个字符的索引
    1为分割取值的步长,即不跨越字符，挨个取值 如不填，则默认为步长为1
    '''
    print(res)  # hel
    print(msg)  # hello world

    msg='hello world'
    res=msg[:]
    print(res)  # hello world
    res=msg[::2]
    # 意思就是 步长为2，取字符串中第一个索引到最后一个索引对应的字符
    print(res)  # hlowrd

    # 反向切片取值：步长必须是负数
    msg='hello world'
    res=msg[-1:-12:-1]
    '''
    步长为负数，索引值也要配合步长进行反向圈定切片取值范围
    此行则代表切片范围为 倒数第1位索引值到第1位索引值
    （反方向时的索引不是以0开始计数的
    因为切片命令顾头不顾尾
    所以此时反向的第一位索引值需要扩大一位索引值以可以取到第一位字符）
    '''
    print(res)  # dlrow olleh
    res=msg[-1::-1] # dlrow olleh  # 此为反向切片，最终切片位置不填则默认为可以取到第1位字符
    print(res)
    res=msg[::-1] # dlrow olleh  # 此为反向切片，起点切片位置不填则默认为可以从倒数第1位开始切片
    print(res)

3.3 长度 len
    示例：
    msg = 'hello world'
    print(len(msg))  # 11 # 代表字符串中有11位字符   

3.4 成员运算 in 和 not in ：判断一个子字符串是否存在于大字符串中
    示例：
    msg = 'wjw is beautiful'
    print('wjw' in msg)  # True
    print('w' in msg)  # True
    print('wjw' not in msg) # False  # wjw 不在 msg 中,结果为False
    print(not 'wjw' in msg) # False  # wjw 在 msg 中为True，取反后为False

3.5 移除空白 strip:
    用来清除字符串两边的字符，不指定取出什么字符则默认去除 空格
    示例：
    msg='      he llo     '
    res=msg.strip() # 没有指定去除什么字符，则默认去除空格
    print(res,id(res))  # he llo 6583272 # 只能去除两边的字符，中间的并没有被去除
    print(msg,id(msg))  # he llo      40059288 # 原值不变

    print('******eg**on*****'.strip('*'))  # eg**on

    print('***+-\/***egon#@$*****'.strip('*+-\/#@$'))  # egon

    应用示例：
    # 去除用户输入的内容的两边的空格
    name=input('username>>>: ').strip() # name='    egon      '
    pwd=input('password>>>: ').strip() # pwd = '    123       '
    username>>>:    egon
    password>>>:    123
    print(username,password)  # egon 123  # 没有空格

3.6 切分 split：针对有规律的字符串，按照某种分隔符切成列表
    info='egon:18:male'
    res=info.split(':') # 以':'为切刀口，切开str，形成新的str丢到list中
    print(res,type(res))  # ['egon', '18', 'male'] <class 'list'> # 输出的值为列表
    print(res[0],res[1])  # egon 18

    cmd='get|a.txt|33333'
    print(cmd.split('|',1))  # ['get', 'a.txt|33333']
    # 1为切割一次的一次，不指定切割次数或指定切割次数为-1，则切割所有指定字符

    延伸示例：
    # 用:号作连接符号将纯字符串的列表拼接成一个字符串
    list=['egon', '18', 'male']
    res=':'.join(list)
    # 以:为分隔，将list中的字符串 串到一起，然后复制给res
    print(res,type(res))  # egon:18:male <class 'str'>

3.7 循环
    for item in 'hello':
        print(item)
        
    h
    e
    l
    l
    o

# 需要掌握的操作 （****）
1. strip,lstrip,rstrip
    print('******egon***********'.strip('*')) # 去除两边的指定字符
    print('******egon***********'.lstrip('*')) # 去除左边(left)的指定字符
    print('******egon***********'.rstrip('*')) # 去除右边(right)的指定字符

    egon
    egon***********
    ******egon
    
    msg='                  hello  '
    msg.strip()  # 不给参数时默认去除空格
    print(msg)  # hello  # 两边没有空格

2. lower,upper
    print('Abc123'.lower()) # abc123  # 使字符串中的所有字母变为小写
    print('Abc123'.upper()) # ABC123  # 使字符串中的所有字母变为大写

3. startswith,endswith
    msg='alex is dsb'
    print(msg.startswith('alex')) # True  # 判断字符串是不是以指定字符开头来输出布尔值
    print(msg.endswith('dsb')) # True  # 判断字符串是不是以指定字符结尾来输出布尔值

4. format的三种玩法
    原理：
    res='my name is %s my age is %s' %('egon',18)
    print(res)  # my name is egon my age is 18

    res='my name is {name} my age is {age}'.format(age=18,name='egon')
    print(res)  # my name is egon my age is 18

    # 了解
    res='my name is {0}{1} my age is {2}{1}{2}'.format('egon',18,' tall ')
    print(res)  # my name is egon18 my age is  tall 18 tall

    res='my name is {} my age is {}'.format('egon',18)
    # 不指定索引时则默认第一个{}索引值为0，第二个{}索引值为1，一次排列
    print(res)  # my name is egon my age is 18

5. split,rsplit
    msg='a:b:c:d'
    print(msg.split(':',1))  # ['a', 'b:c:d']
    '''
    从前向后以指定字符将字符串分割成列表，不指定字符时则默认指定空格
    此条代码为 以:为号，分割从前向后分割一次
    '''
    print(msg.rsplit(':',1))  # ['a:b:c', 'd']
    '''
    从后向前以指定字符将字符串分割成列表，不指定字符时则默认指定空格
    此条代码为 以:为号，分割从后向前分割一次
    '''

6. replace
    msg='kevin is kevin is hahahah'
    res=msg.replace('kevin','sb',1)
    # 将'kevin'替换为'sb'，替换次数为 1
    print(res)  # sb is kevin is hahahah
    res=msg.replace('kevin','sb',2)
    # 将'kevin'替换为'sb'，替换次数为 2
    print(res)  # sb is sb is hahahah

7. isdigit
    print('123123'.isdigit())  # True  # 如果字符串是由纯数字组成的，则返回True
    print('123123   '.isdigit())  # False
    print('123123asdf'.isdigit())  # False
    print('12312.3'.isdigit())  # False

    应用示例：
    # 查成绩程序中，禁止用户输入纯数字以外的input
    score=input('请输入您的成绩： ').strip() #score='abc'
    if score.isdigit():
        score=int(score)
        if score >= 90:
            print('优秀')
        else:
            print('小垃圾')
    else:
        print('必须输入纯数字')

    请输入您的成绩： abc  # 必须输入纯数字

# 了解的操作
1. find,rfind,index,rindex,count
    print('123 ke123ke'.find('ke'))  # 4
    print('123 ke123ke'.rfind('ke'))  # 9
    print('123 ke123ke'.index('ke'))  # 4
    print('123 ke123ke'.rindex('ke'))  # 9

    print('123 ke123ke'.find('xxxx'))  # -1
    print('123 ke123ke'.index('xxxx'))  # 报错；
    print('123 ke123ke'.count('ke',0,6))  # 1



2. center,ljust,rjust,zfill
    print('egon'.center(50,'*'))
    print('egon'.ljust(50,'*'))
    print('egon'.rjust(50,'*'))

    ***********************egon***********************
    egon**********************************************
    **********************************************egon

    print('egon'.rjust(50,'0'))
    print('egon'.zfill(50))

    0000000000000000000000000000000000000000000000egon
    0000000000000000000000000000000000000000000000egon

3. captalize,swapcase,title
    print('abcdef dddddd'.capitalize()) # 将字符串的首字母变为大写，其余全为小写
    print('abcAef dddddd'.swapcase()) # 将字符串中所有字母大小写反转
    print('abcAef dddddd'.title()) # 将字符串中每个单词的首字母大写，其余全为小写

    Abcdef dddddd
    ABCaEF DDDDDD
    Abcaef Dddddd

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

    # bytes与阿拉伯数字组成的字符串
    # print(num1.isdigit())
    # print(num2.isdigit())
    # print(num3.isdigit())
    # print(num4.isdigit())
    
    True
    True
    False
    False

    # 阿拉伯数字组成的字符串
    # print(num2.isdecimal())
    # print(num3.isdecimal())
    # print(num4.isdecimal())

    True
    False
    False

    # 阿拉伯数字\中文\罗马组成的字符串
    # print(num2.isnumeric())
    # print(num3.isnumeric())
    # print(num4.isnumeric())

    True
    True
    True

字符串类型总结

1、字符串类型只能存一个值
2、字符串类型是有序的
3、字符串类型的值不可变

列表类型

# 基本使用：
1、用途：按照位置记录多个值，索引对应值

2、定义方式：在[]内用逗号分隔开多个任意类型的值
    l=['a',11,11.3] # l=list(['a',11,11.3])

    数据类型转换:但凡能够被for循环遍历的数据类型都可以传给list，被其转换成列表
    res=list('hello')
    print(res)  # ['h', 'e', 'l', 'l', 'o']

    res=list(123) # for循环无法循环int,所以无法定义int or float为list
    print(res)  # 报错；

    res=list({'a':1,'b':2,'c':3})
    # 将字典dict定义为list时，只会提取其中的key
    print(res)  # ['a', 'b', 'c']

列表类型的常用操作+内置方法

# 优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取
    l=['a','b','c','d','e']
    print(l[0]) # 取第1个值
    print(l[-1]) # 取倒数第1个值
    print(id(l))
    l[0]='A' # 将A赋值给list l 中的第一个值
    print(l)
    print(id(l))

    a
    e
    36725384
    ['A', 'b', 'c', 'd', 'e']
    36725384

    l=['a','b','c','d','e']
    # 强调强调强调！！！:对于不存在的索引会报错
    l[5]='AAAA'  # 报错；

    dic={"k1":111}
    dic['k2']=2222 # 将2222赋值给doc中的key_k2
    print(dic)  # {'k1': 111, 'k2': 2222}
    # 赋值字典中没有的key会新建这个key

2、切片(顾头不顾尾，步长)
    l=['a','b','c','d','e']
    print(l[1:4]) # 切片取第2位到第5位
    print(l[::-1]) # 反向切片取倒数第1位 到 第1位

    ['b', 'c', 'd']
    ['e', 'd', 'c', 'b', 'a']

3、长度 len
    l=['a','b','c','d','e']
    print(len(l))  # 5

4、成员运算in和not in
    list=['a','b','c','d','e']
    print('a' in list) # True  # 判断'a'在不在list中，返回bool值

5、追加.append与insert
    l=['a','b','c','d','e']
    l.append('xxx') # 在 l 末尾插入'xxx'
    l.append('yyy') # 在 l 末尾插入'yyy'
    print(l)  # ['a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']

    l=['a','b','c','d','e']
    l.insert(1,'xxxx') # 在指定索引值的位置插入'xxxx'
    print(l)  # ['a', 'xxxx', 'b', 'c', 'd', 'e']

6、删除 del、remove、pop
    l=['a','bbb','c','d','e']
    # del是一种通用的删除操作，没有返回值
    del l[0] # 删除 l 中的第1个值
    print(l)  # ['bbb', 'c', 'd', 'e']

    dic={'k1':1}
    del dic['k1'] # 删除 dic 中的key_k1
    print(dic)  # {}

    l=['a','bbb','c','d','e']
    l.remove(xxx) # (指定要删除的那个元素),没有返回值
    res=l.remove('bbb') # 给被删除的元素赋值给res
    print(l)  # ['a', 'c', 'd', 'e']
    print(res) # None  # 查找通过res开看删除的元素是否有返回值

    l.pop(xxx) # (指定要删除的那个元素的索引),返回刚刚删掉的那个元素
    l=['a','bbb','c','d','e']
    l.pop(-1) # 删除 l 中倒数第 1 个值
    res=l.pop(1) # 删除 l 中第 2 个值，并将这个值赋值给res
    print(l)  # ['a', 'c', 'd']
    print(res) # bbb  # 验证res是否被成功赋值，即删掉的元素有没有成功返回

7、循环
    l=['a','b','c','d','e']
    for item in l:
        print(item)

    a
    b
    c
    d
    e

    应用示例：
    # 练习：
    # 队列：先进先出
    l=[]
    # 入队
    l.append('first')
    l.append('second')
    l.append('third')
    print(l)  # ['first', 'second', 'third']

    l=[]
    # 入队
    l.append('first')
    l.append('second')
    l.append('third')
    # 出队
    print(l.pop(0))  # first
    print(l.pop(0))  # second
    print(l.pop(0))  # third

    #堆栈：后进先出

# 需要掌握的操作
    l=['aaa','bb',345]
    l.clear() # 删除列表中所有内容
    
    # 此时表l中为空
    l.append([1,2,3]) # 在列表末尾插入表格 [1,2,3]
    print(l)  # [[1, 2, 3]] # 在此时的空列表l中插入了一个列表

    l=['aaa','bb',345]
    for i in [1,2,3]:
        l.append(i)
        print(l)  # ['aaa', 'bb', 345, 1, 2, 3]
            
    '''
    上面代码中的for循环追加值的效果
    可以用下面
    .extend 来直接插入一个代码
    .extend 的原理就是将列表中的元素拆出列表然后追加到 l 中
    '''
    l=['aaa','bb',345]
    l.extend([1,2,3])
    print(l)  # ['aaa', 'bb', 345, 1, 2, 3]



# 排序 .reverse 、 sort
    l=['aaa','bb',345]
    l.reverse()
    # 将列表中的元素重新颠倒排序
    print(l)  # [345, 'bb', 'aaa']

    只有在列表中所有元素都是同种类型的情况下才能用sort排序
    l=[1,3,2] # 列表中的元素皆为int
    l.sort(reverse=True)
    # 当reverse为True时从大到小排列，当reverse为False时从小到大排列
    print(l)  # [3, 2, 1]

    

    l=['z','d','a'] # # 列表中的元素皆为str
    l.sort()
    print(l)  # ['a', 'd', 'z']

列表类型总结

1、列表类型能存多个值
2、列表类型是有序的
3、列表类型的值不可变

转载于:https://www.cnblogs.com/shuchengyi/articles/10867068.html