zoukankan      html  css  js  c++  java
  • python基本数据类型及操作

    数字类型

    数字类型分为整型,浮点型,布尔型

    1.整型
    num = -1000000000000000000000000000000000000000000000000
    print(num, type(num))
    -100000000000000000000000000 <class 'int'>

    py2中小整数用int存放,大整数用long,而在py3中取消了长整型全部用int,数值过大的会被当作字符串保存。

    2.小数
    num = 3.14
    print(num, type(num))
    <class 'float'>

    3.布尔
    res = True
    print(res, type(res), isinstance(res, int))
    print(3.14 + True)

    True <class 'bool'> True
    4.140000000000001

    重点:数字类型直接的相互转化 *****
    a = 10
    b = 3.74
    c = True
    print(int(a), int(b), int(c))
    print(float(a), float(b), float(c))
    print(bool(a), bool(b), bool(c))

    int只能将纯数字转化为整型

    float只能将含有小数的数字转化为浮点型

    布尔型本质为0和1,0代表false1代表true.

    字符串类型

    1.定义: 可以有多种引号嵌套

    需求:你是"好学生"
    s1 = "你是"好学生""
    print(s1)

    你是"好学生"

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

    s2 = '你是"好学生"'
    print(s2)

    你是"好学生"

    单引号和双引号可以互相嵌套,但开头和结尾为单引号或双引号时可以使用三引号

    字符串的常规操作

    1.字符串的索引取值: 字符串[index]

    正向取值从0编号,反向取值从-1编号

    s1 = '123abc呵呵'
    print(id(s1)) # 2217572683576
    print(s1[0], id(s1[0])) # 2217543167200
    t_s = '1'
    print(id(t_s)) # 2217543167200

    2.字符串拼接

     s2 = '你好'

    s22 = '帅'
    ss2 = s2 + s22
    print(ss2, id(s2), id(s22), id(ss2))

    字符串可以直接拼接但是拼接后的字符串会开辟出新的内存来存储

    如果要拼接其他类型(str--字符串)

    a = 10
    b = "20"
    c = True
    res = "%s%s%s" % (a, b, c)    # 方法1
    print(res)
    res = str(a) + b + str(c)            # 方法2
    print(res)

    不同数据类型可以直接拼接但是必须要先转换为字符串类型

     3.字符串长度

    s3 = '12345'

    ln1 = s3.__len__()
    print(ln1)
    ln2 = len(s3)
    print(ln2)

    5

    5

     .__len__()作为魔法变量用来计算字符串长度

    4.字符串切片: 取子字符串 - [::] - [start_index:end_index:step]
    s4 = '123abc呵呵'
    sub_s = s4[0:6:]
    print(sub_s) 

    123abc
    sub_s = s4[0:6:2]
    print(sub_s) 

    13b
    sub_s = s4[::-1]
    print(sub_s) 

    呵呵cba321
    sub_s = s4[-1:-6:-1]
    print(sub_s) 

    呵呵cba

    [开始索引:结束索引:步长]

    步长为负的话会倒叙输出

    5.成员运算:判断某字符串是否在该字符串中

    s5 = '123abc呵呵'
    ss5 = '12a'
    print(ss5 in s5)             # False
    print(ss5 not in s5)       # True

    6.字符串循环(遍历)

    s6 = '123abc呵呵'
    for v in s5:
    print(v)

    1
    2
    3
    a
    b
    c

    每次循环输出字符串中的单个数值

    重要方法

    1.索引index(目标字符串的索引位置)
    s1 = '123abc呵呵'
    print(s1.index('b'))

    4

    index可以找出目标字符在字符串中的位置

    2.去留白(默认去两端留白,也可以去指定字符)

    s2 = '***好 * 的 ***'
    print(s2.strip('*'))

    3.计算子字符串个数
    s3 = '12312312'
    print(s3.count('123'))

    4.判断字符串是否是数字:只能判断正整数
    s4 = '123'
    print(s4.isdigit())

    5.大小写转换
    s5 = "AbC def"
    print(s5.upper()) # 全大写

    ABC DEF
    print(s5.lower()) # 全小写

    abc def
    # 了了解
    print(s5.capitalize()) # 首字母大写

    Abc def
    print(s5.title()) # 每个单词首字大写

    Abc Def

     6.以某某开头或结尾

    s6 = 'https://www.baidu.com'
    r1 = s6.startswith('https:')#以https开头
    r2 = s6.startswith('http:') 
    r3 = s6.endswith('com')  #以com结尾
    r4 = s6.endswith('cn')
    if (r1 or r2) and (r3 or r4):
    print('合法的链接')
    else:
    print('非合法的链接')

    7.替换
    s7 = 'egon say: he is da shuai b,egon!egon!egon!'
    new_s7 = s7.replace('egon', 'Liu某') # 默认替换所有
    print(new_s7)
    new_s7 = s7.replace('egon', 'Liu某', 1) # 替换一次
    print(new_s7)

    8.格式化
    s8 = 'name:{},age:{}'
    print(s8.format('Owen', 18)) # 默认按位置
    print('name:{1},age:{1}, height:{1}'.format('Owen', 18)) # 标注位置,一个值可以多次利用
    print('name:{n},age:{a}, height:{a}'.format(a=18, n="Zero")) # 指名道姓

    1. find | rfind:查找子字符串索引,无结果返回-1
    2. lstrip:去左留白
    3. rstrip:去右留白
    4. center | ljust | rjust | zfill:按位填充
    语法:center(所占位数, '填充符号')
    5. expandtabs:规定 所占空格数
    6. captialize | title | swapcase:首字母大写 | 单词首字母大写 | 大小写反转
    7. isdigit | isdecimal | isnumeric:数字判断
    8. isalnum | isalpha:是否由字母数字组成 | 由字母组成
    9. isidentifier:是否是合法标识符
    10. islower | isupper:是否全小 | 大写
    11. isspace:是否是空白字符
    12. istitle:是否为单词首字母大写格式

    列表类型

    list中可以存放多个值,可以存放所有类型的数据

    list中有序的,可以通过索引取值

    1.索引取值: 列表名[index]
    s1 = [1, 3, 2]
    print(s1[0])
    0
    print(s1[-1])
    2
    在列表名后以[]的格式获取相应位置的数值,查找的为负数时会从后往前查找
    2.列表运算: 得到的是新list
    s2 = [1, 2, 3]
    print(s2 + s2)
    [1, 2, 3, 1, 2, 3]
    print(s2 * 2)
    [1, 2, 3, 1, 2, 3]
    print(s2)
    [1, 2, 3]
    列表可以相加,相加后列表内的数值会合并。列表做乘法运算之后数值会翻倍累加
    .list的长度
    s3 = [3, 4, 1, 2, 5]
    print(len(s3))
    5
    len(list)可以计算出列表内数值的个数
    4.切片:[start_index:end_index:step]
    s4 = [3, 4, 1, 2, 5]
    new_s4 = s4[::-1]
    print(new_s4)
    new_s4 = s4[1:4:]
    print(new_s4)
    new_s4 = s4[-2:-5:-1]
    print(new_s4)
    list切片的格式为 list[开始索引:结束索引:步长]

      步长为负的话会倒叙输出

    5.成员运算:in
    s5 = [3, 4, '1', 2, 5]
    print('1' in s5)
    print(1 in s5)
    print(5 not in s5)
    判断目标数值是否在列表中,输出结果为布尔值
    6.循环
    s5 = [3, 4, '1', 2, 5]
    for v in s5:
    print(v, type(v))

    3 <class 'int'>
    4 <class 'int'>
    1 <class 'str'>
    2 <class 'int'>
    5 <class 'int'>



    for v in s5:
    if isinstance(v, int):
    print(v, end=' ')
    3 4 2 5 


    列表操作

    1.列表的增删改查
    ls = [1, 2, 3]


    print(ls)
    print(ls[1])
    2

    ls.append(0) # append可以在列表末尾增加‘0’
    print(ls)
    [1, 2, 3, 0]
    ls.insert(1, 666) # insert可以在任意index前增
    print(ls)

    [1, 666, 2, 3, 0]

    ls.insert(len(ls), 888) # insert实行末尾增
    print(ls)
    [1, 666, 2, 3, 0, 888]

    ls[1] = 66666 #直接吧目标数字更改
    print(ls)
    [1, 66666, 2, 3, 0, 888]

    ls.remove(888) #直接删除目标数值
    print(ls)
    res = ls.pop() # 默认从末尾删,并返还删除的值
    print(res)
    res = ls.pop(1) # 从指定索引删除,并返还删除的值
    print(res, ls)
    了了解
    del ls[2] #del也可以指定索引删除但还是不会返还值
    print(res, ls)
    # 清空
    ls.clear()
    print(ls)
    排序: 针对于同类型
    ls = ['3', '1', '2']
    ls.sort() # 默认正向排序
    print(ls)
    ['1', '2', '3']
    ls.sort(reverse=True) # 正向排序结果上翻转,形成倒序
    print(ls)
    ['3', '2', '1']
    2)翻转
    ls = ['3', '1', '2']
    ls.reverse() # 按存储的顺序进行翻转
    print(ls)
    ['2', '1', '3']
    计算值的个数 => 列表中可以存放重复数据
    ls = [1, 2, 1, 2, 3, 1]
    print(ls.count(1)) # 对象1存在的次数
    整体增加,添加到末尾
    ls = [1, 2, 3]
    ls.extend('123')
    print(ls)
    ls.extend([0, 1, 2])
    print(ls)
    目标的索引位置,可以规定查找区间
    ls = [1, 2, 1, 2, 3, 1]
    # 找对象1,在索引3开始往后找到索引6之前
    ind = ls.index(1, 3, 6)
    print(ind)

    可便于不可变类型

    ls = [10, 20, 30]
    print(id(ls), ls)
    ls[0] = 100
    print(id(ls), ls)

    print(id(10))
    print(id(20))
    print(id(100))
    print(id('100'))

    
    
    
  • 相关阅读:
    streamsets 集成 cratedb 测试
    streamsets k8s 部署试用
    streamsets rest api 转换 graphql
    StreamSets sdc rpc 测试
    StreamSets 相关文章
    StreamSets 多线程 Pipelines
    StreamSets SDC RPC Pipelines说明
    StreamSets 管理 SDC Edge上的pipeline
    StreamSets 部署 Pipelines 到 SDC Edge
    StreamSets 设计Edge pipeline
  • 原文地址:https://www.cnblogs.com/duGD/p/10726603.html
Copyright © 2011-2022 走看看